Elektroda.pl
Elektroda.pl
X
SterControlSterControl
Proszę, dodaj wyjątek dla www.elektroda.pl do Adblock.
Dzięki temu, że oglądasz reklamy, wspierasz portal i użytkowników.

Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM

p.kaczmarek2 25 Maj 2020 21:28 2772 6
  • Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Witajcie moi drodzy
    Chciałbym zaprezentować tutaj drugą wersję mojego Arduino VGA Shield
    (nakładki na Arduino UNO generującej jednokolorowy obraz VGA i czarno-biały PAL/NTSC) - tym razem wykonaną za pomocą elementów SMD, i z dodatkowymi układami na pokładzie (expander portów MCP23016 oraz dwie kości EEPROM AT24CM02).
    Opis pierwszej wersji tego shielda znajdziecie tutaj:
    https://www.elektroda.pl/rtvforum/viewtopic.php?p=18496229#18496229

    Co to za Arduino Shield?
    W dużym skrócie mój shield jest nakładką na Arduino UNO która pozwala bardzo łatwo generować jednokolorowy obraz na monitor VGA oraz obsługiwać klawiaturę PS/2. Opcjonalnie też dostępne jest wyjście sygnału PAL/NTSC dla telewizorów. Shield korzysta z biblioteki 'ASCII Video Terminal' dla PIC32MX250F128B autorstwa geoffg. Arduino UNO komunikuje się z tym shieldem poprzez UART na wybranych przez nas za pomocą lutowanej zworki pinach.
    Dodatkowo na pokładzie (nowość w tej wersji!) znajduje się:
    - expander portów MCP23016, dzięki czemu zyskujemy aż 16 dodatkowych IO!
    - dwie kości EEPROM AT24CM02, dzięki którym zyskujemy aż 512KB pamięci nieulotnej do własnych projektów!
    Obie nowości znajdują się na magistrali I2C od Arduino.
    Poniżej szczegółowo opiszę cały projekt, umieszczę proste przykłady użycia nowości na płytce a na koniec dam bardziej zaawansowane demka korzystające z poszczególnych funkcjonalności shielda.

    Projekt Arduino VGA Shield SMD
    Niniejszy projekt jest zasadniczo aktualizacją jego poprzedniej wersji która była wykonana w THT (montaż przewlekany):
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    W obecnej wersji większość elementów jest w obudowach SMD, dodatkowo dzięki zaoszczędzonemu miejscu udało mi się na płytkę dodać:
    - złącze USB od PIC32 (do aktualizacji softu poprzez bootloader; może to dać też w przyszłości możliwość łatwego użycia tego shielda bez Arduino, ale na razie brakuje na PCB w tym celu regulatora 3.3V)
    - dwie kości pamięci EEPROM AT24CM02 na magistralę I2C od Arduino (standardowo piny 4 i 5)
    - 16-bitowy expander portów MCP23016 na magistralę I2C od Arduino (jak wyżej; piny 4 i 5)
    - rezystory pull-up na piny 4 i 5 (jak wyżej; magistrala I2C Arduino)
    W ten sposób obecna wersja wyszła tak:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Całość open hardware i do pobrania poniżej.
    Schemat płytki w PDF:
    shield_vga...otated.pdf Download (98.15 kB)Punkty: 1 dla użytkownika
    Schemat płytki w PNG:
    shield_vga...ated-1.png Download (183.02 kB)Punkty: 1 dla użytkownika
    Pełny projekt płytki w Eagle (.sch + .brd):
    shield_vga..._EAGLE.zip Download (100.56 kB)Punkty: 4 dla użytkownika
    Pliki Gerber które wyeksportowałem z Eagle (te same, których użyłem przy zleceniu wykonania gołego PCB płytkarni):
    shield_vga...RBERES.zip Download (291.24 kB)Punkty: 2 dla użytkownika
    Tym razem obyło się bez żadnych błędów na płytce. Płytki standardowo zamówiłem w Chinach (10 sztuk - ktoś chętny na kilka?) a jak przybyły to wziąłem się do lutowania.

    Lutowanie Arduino VGA Shield w wersji SMD
    Opiszę tutaj szczegółowo jak zlutowałem tę płytkę w warunkach domowych.
    Na początek przygotowałem wszystkie elementy:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    I tym razem nawet nie używałem złącza VGA (DSUB25) z starej płyty głównej od komputera, tylko miałem zakupione przez internet.
    Do lutowania użyłem mojej wiernej najtańszej lutownicy kolbowej i na tę okazję zmieniłem jej grot na grot ścięty (choć pewnie lepszy byłby grot ścięty typu minifala, ten z wyżłobionym 'zbiorniczkiem' na cynę):
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Zacząłem lutowanie od najmniejszych elementów:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Dałem też wtedy cynową zworkę na sygnał "B" (Blue) koło złącza VGA, czyli wybrałem niebieski kolor czcionki.
    Szybko przyszła pora na złącza:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Złącze DSUB25 czyli VGA oraz MDC6 (aka 'mini din') czyli PS/2:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Na zdjęciu można zobaczyć, że wciąż nie przylutowałem EEPROMów - to dlatego, że dopiero czekałem na paczkę z nimi.
    Jak przyszły to uzupełniłem ubytek:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Potem jeszcze uzupełniłem ubytek złącza RCA (od sygnału PAL/NTSC); nie miałem takiego na składzie więc wylutowałem z jakiegoś fragmentu urządzenia elektronicznego, to chyba był odtwarzacz kaset VHS:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Złącze RCA:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    I oto końcowy efekt (już po wyczyszczeniu z nadmiaru topnika):
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Warto jeszcze pamiętać, że przed użyciem należy zrobić ze spoiwa lutowniczego następujące zworki:
    - zworka pinu RX shielda z Arduino
    - zworka pinu TX shielda z Arduino
    - zworka pinu RESET z Shielda (łączy RESET od PIC32 z RESET od Arduino)
    - zworka wyboru koloru VGA z Shielda
    - dwie zworki na magistrali I2C dla EEPROMów
    Przed użyciem shielda trzeba oczywiście też wgrać mu firmware na PIC32MX250F128B za pomocą PICKIT3 (lub innego programatora) poprzez złącze ICSP dostępne na płytce.

    Test generowanego sygnału VGA z różnymi monitorami i telewizorem
    W temacie dotyczącym poprzedniej wersji mojego shielda (tutaj: https://www.elektroda.pl/rtvforum/viewtopic.php?p=18496229#18496229 ) pojawiła się uwaga, że nie działa on z częścią monitorów. Postanowiłem to zweryfikować.
    Użyłem do tego:
    - telewizora LG42LE4500
    - monitora DELL 1703FP
    - monitora ASUS VH196S
    - monitora HP L1706
    - monitora SyncMaster 740N
    Zapraszam do obejrzenia zdjęć z testów.
    Test 1 - monitor DELL 1703FP:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Tabliczka znamionowa użytego monitora:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Test 2 - telewizor LG42LE4500:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Tabliczka znamionowa użytego telewizora:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Test 3 - monitor ASUS VH196S:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Tabliczka znamionowa użytego monitora:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Test 4 - HP L1706.
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Tabliczka znamionowa użytego monitora:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Test 5 - SyncMaster 740N.
    Ten monitor naprawiałem tutaj: https://www.elektroda.pl/rtvforum/topic3688191.html , wymieniłem w nim kondensatory elektrolityczne. Dzięki temu może dalej działać i brać udział w testach mojego shielda:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Tabliczka znamionowa użytego monitora:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Podsumowując, shield VGA przetestowałem z czterema monitorami i jednym telewizorem i w każdym przypadku obraz był poprawnie wyświetlany.
    Sygnał widziany jest przez wszystkie urządzenia jako 640x480, mimo iż w dokumentacje użytej biblioteki jest podana nieco inna rozdzielczość. Po prostu shield w sprytny sposób sobie z tym radzi zostawiając puste marginesy wokół obrazu (co zresztą widać na większości zdjęć z jego działania).
    Nie znalazłem ani jednego urządzenia przez którego sygnał VGA z mojego shielda nie był wspierany, a jego timingi (31.5kHz i 60Hz) są zgodne z tym, co jest w kodzie:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM

    Test generowanego sygnału PAL
    Generowanie czarno-białego obrazu PAL (oraz NTSC - też jest wspierany) może się przydać gdy chcemy obsłużyć jakiś starszy telewizor, pewnie jeszcze CRT, który nie posiada złącza VGA. Może to być podyktowane chociażby sentymentem - niektórzy lubią korzystać ze starszego sprzętu nawet dla samej satysfakcji korzystania z niego.
    Z tego powodu przetestowałem też jak shield radzi sobie z generowaniem sygnału PAL.
    Sygnał PAL ze shielda podłącza się za pomocą przewodu RCA:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Wystarczy pojedynczy sygnał video, audio nie jest oferowane przez ten shield.
    Test PAL 1 - telewizor LG42LE4500:
    Podłączenie:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Obraz na ekranie:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Obraz generowany przez shield jest tutaj rzecz jasna czarno-biały; zworka od koloru (wybór R/G/B) jest tylko dla VGA.

    Test PAL 2 - stary telewizor CRT TX-21AT1P:
    Ten pierwszy test PAL z nowym, płaskim telewizorem LG42LE4500 poniekąd mija się z celem, bo użyty tam telewizor ma złącze VGA (i to nie jedno!) więc nic nie stoi na przeszkodzie, by go podłączyć normalnie.
    Z tego powodu też przetestowałem tryb PAL z telewizorem który jest o wiele bardziej z tym trybem związanym - ze starym, ciężkim telewizorem kineskopowym, dokładniej 'Panasonic Colour TV' model TX-21AT1P:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Tabliczka znamionowa tego telewizora:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Sygnał PAL podłączyłem z przodu telewizora do złącz RCA:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Warto tu wspomnieć, że nawet jeśli telewizor nie ma złącz RCA to sygnał PAL można też podać poprzez SCART - w przewodzie SCART jest jeden pin odpowiedzialny za wejście 'composite video'.
    Sygnał PAL oczywiście tutaj nie jest modulowany i odbieramy go w trybie AV:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    (Aczkolwiek jakby się postarać i użyć np. modulatora ze starego odtwarzacza VHS to można by prosto odbierać sygnał ze shielda poprzez złącze antenowe; choć wtedy jest ryzyko, że będziemy 'siać' sygnał po okolicy; do tej pory pamiętam jak kilkanaście lub więcej lat temu odbierałem przez przypadek na telewizorze obraz z konsoli do gier sąsiada).
    Na telewizorze uruchomiłem demko, które opisane jest nieco niżej w tekście. Rezultat:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM

    Uwaga - co jeśli monitor pokazuje 'nieobsługiwany format VGA'?
    Chciałbym tu tylko jeszcze przypomnieć, że shield w celu obsługi zarówno standardu PAL jak i VGA musi w sprytny sposób między nimi przełączać. Nie generuje dwóch sygnałów naraz. Shield przy starcie (po sygnale RESET lub podaniu zasilania) sam określa, czy monitor VGA jest podłączony i jeśli nie, to przechodzi w tryb PAL. Określa to poprzez badanie stanu na pinie RA4. Więc jeśli podłączymy monitor VGA w trakcie do shielda to powinniśmy wcisnąć przycisk RESET na Arduino lub wyłączyć i włączyć zasilanie - w przeciwnym razie shield będzie już 'nastawiony na PAL' i monitor VGA nic nie wyświetli.
    RESET z Arduino jest połączony z RESET (aka MCLR) z PIC32 z płytki shielda, ale należy pamiętać by na płytce shielda dać tam zworkę by oba układy resetowały się razem.
    (O tym, że mam wspomnieć o tym problemie przypomniał mi Bartek, który odkupił ode mnie jedno PCB poprzedniej wersji shielda - za przetestowanie układu i zwrócenie uwagi tu dziękuję)

    Test magistrali I2C - skan dostępnych urządzeń
    Na samym początku na mojej płytce uruchomiłem prosty program całkowicie niezwiązany z VGA - skaner I2C.
    Program ten pochodzi z oficjalnej strony Arduino:
    https://playground.arduino.cc/Main/I2cScanner/
    i po prostu wykrywa wszystkie urządzenia podłączone na magistralę I2C, czyli w przypadku użytego przeze mnie Arduino UNO na jego piny 4 i 5.
    Program drukuje adresy I2C znalezionych urządzeń na port szeregowy/terminal Arduino.
    Kod: c
    Zaloguj się, aby zobaczyć kod

    Program skompilowałem i wgrałem na Arduino z założonym moim shieldem.
    Rezultat sketchu:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Widzimy, że skan I2C znalazł aż 9 urządzeń! Ale czy na pewno?
    Na powyższym zrzucie ekranu:
    - adres 0x20 to port expander MCP23016
    - adresy 0x50, 0x51, 0x52, 0x53 to pierwszy AT24CM02 (przypominam: w adresie urządzenia AT24CM02 dwa bity odpowiadają za jego 'wewnętrzny adres' pamięci; dwa bity dają nam 4 możliwe adresy)
    - adresy 0x54, 0x55, 0x56, 0x57 to drugi AT24CM02
    Czyli wszystko jest okej - dwie pamięci EEPROM i jeden expander portów.
    Poniżej zaprezentuję już jak można ich użyć.

    Lutowanie przejściówki do expandera portów (dla płytki stykowej)
    Na płytce znajduje się 16-pinowe złącze 2.54mm (2 rzędy po 8 pinów) od MCP23016:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Oferuje ono dodatkowe 16 pinów IO którymi możemy sterować przez I2C.
    Polecam używać go w połączeniu z takim przewodem (najlepiej też zakupić odpowiednie gniazdo pod ten przewód by nie dało się go wsadzić odwrotnie, ale ja takiego pod ręką nie miałem):
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Do tego sugeruję zlutować sobie przejściówkę z tego przewodu do płytki stykowej/prototypowej. Płytka stykowa ma rozstaw pól 2.54mm pasujący do goldpinów, za wyjątkiem środkowego przedziałka płytki który ma akurat 5.08mm, czyli tyle ile wąski rozstaw pinów z obudowy DIP. Aż prosi się to wykorzystać. Opiszę tutaj jak - na początek trzeba przygotować goldpiny 1x8 (dwie sztuki) i 2x8 (jedna sztuka) oraz płytkę wierconą:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Następnie warto dodać topnik na płytkę, by się lepiej lutowało:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Dalej umieścić na naszej płytce pierwszy rząd goldpinów (on będzie wchodzić w płytkę stykową), ale odwrotnie niż zazwyczaj:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Teraz trzeba ją przylutować - najwygodniej bardzo cienką końcówką. Przy lutowaniu pilnować, by goldpiny były prostopadle do płytki:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Pierwszy lut gotowy:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Następnie trzeba dokończyć wszystkie luty i można od drugiej strony płytki dać złącze 2x8 2.54mm goldpin i zacząć łączyć odpowiednie piny:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Dalej polecam delikatnie przylutować drugi pojedynczy rząd goldpinów który wejdzie w płytkę stykową:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Następnie wystarczy zmostkować odpowiednie piny za pomocą lutownicy.
    Jeszcze tylko trzeba odciąć zbędny fragment PCB:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Przejściówka gotowa:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Idealnie pasuje do wybranego przeze mnie przewodu (choć ponownie tu Wam polecam użyć nie zwykłych goldpinów 2x8, lecz złącza pod ten konkretny kabelek; wtedy unikniecie ryzyka podłączenia go odwrotnie):
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Przejściówka expandera portów gotowa. Tak wygląda razem z Shieldem i Arduino:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Następne cztery akapity przedstawią testy MCP23016 w oparciu o te połączenie.

    Test expandera portu - MCP23016 - użyta biblioteka
    Na początku do obsługi expandera portów MCP23016 sterowanego poprzez I2C próbowałem użyć tej biblioteki od Adafruit (mimo iż jest ona dla MCP23017 - liczyłem na podobieństwo układów):
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Ale nie zadziałała, więc ostatecznie użyłem biblioteki CyMCP23016 autorstwa Chris Brunner aka cyrusbuilt, stąd:
    https://github.com/cyrusbuilt/CyMCP23016
    Kopia zapasowa repozytorium (na czas pisania tematu):
    CyMCP23016...200525.zip Download (38.37 kB)
    Bibliotekę dodałem do Arduino poprzez Sketch->Include Library->Add .ZIP Library.

    Test expandera portu - MCP23016 - układ testowy
    Do przygotowania układu testowego MCP23016 użyłem płytki stykowej i wcześniej opisanej przejściówki i kabelka, do tego kilka rezystorów:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Do tego oczywiście trzeba osobno podpiąć masę (i zasilanie, jeśli go potrzebujemy)
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM

    Test expandera portu - MCP23016 - blink LED
    Pierwszym przykładem użycia MCP23016 jaki przygotowałem jest proste miganie jedną diodą poprzez ten expander portów, poprzez I2C.
    Wybrałem pin GP0.0, w tej bibliotece oznaczany MCP23016_PIN_GPIO0_0.
    Kod prawie w całości pochodzi z przykładu biblioteki z Githuba:
    Kod: c
    Zaloguj się, aby zobaczyć kod

    Kod tylko przełącza stan na pierwszym pinie expandera i dodatkowo wysyła jego stan na UART.
    Rezultat w Serial Monitor:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Rezultat na filmie:

    W taki sam sposób możemy sterować wszystkimi 16 pinami od MCP23016.

    Test expandera portu - MCP23016 - prosty licznik binarny
    Drugim, bardziej zaawansowanym przykładem użycia MCP23016 jaki tu zaprezentuję jest prosty licznik binarny zrealizowany na 8 diodach LED (czyli 8-bitowy). Do tego użyłem całego portu GP0:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Odpowiednio zmodyfikowałem też kod przykładu. Do ustawienia odpowiednich diod LED użyłem pętli for oraz operatorów bitowych, całość sketchu jest do wglądu poniżej:
    Kod: c
    Zaloguj się, aby zobaczyć kod

    Powyższy kod powinien być zrozumiały nawet dla początkujących z Arduino, jedyną z pozoru trudną rzeczą w nim jest 'wyłuskanie' bitu za pomocą counter & (1<<(i)). Ta linijka po prostu sprawdza, czy i-ty bit zmiennej counter jest zapalony.
    Rezultat na filmie:

    Wszystko działa poprawnie. Można by jeszcze sprawdzić czy wszystko jest okej z drugim portem od MCP23016, ale uznałem, że to już jest zbędne.

    Test pamięci EEPROM - AT24CM02 - użyta biblioteka
    Do obsługi pamięci EEPROM a dokładniej dwóch kości AT24CM02 użyłem biblioteki autorstwa Rushikesh Patel aka luffykesh z Githuba, tej:
    https://github.com/luffykesh/AT24Cx
    Kopia zapasowa/snapshot repo na czas pisania artykułu:
    AT24Cx-mas...200525.zip Download (9.08 kB)
    Bibliotekę dodałem do Arduino poprzez Sketch->Include Library->Add .ZIP Library.

    Test pamięci EEPROM - AT24CM02 - test zapisu i odczytu
    Na początek sprawdziłem czy w ogóle komunikacja z AT24CM02 działa poprawnie. W tym celu użyłem przykładowego kodu z wybranej biblioteki, jedynie tylko zmodyfikowałem go by korzystał z konkretnie AT24CM02 (z pierwszego na PCB, o adresie 0x50):
    Kod: c
    Zaloguj się, aby zobaczyć kod

    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM

    Następnie zmodyfikowałem ten kod tak, by przetestować użycie dwóch EEPROM jednocześnie.
    W celu weryfikacji czy na pewno kod korzysta z dwóch różnych kości postanowiłem zapisać na ten sam adres różne wartości (dla pierwszej kości: 42, dla drugiej: 15) i potem je odczytać i sprawdzić czy są zachowywane.
    Kod: c
    Zaloguj się, aby zobaczyć kod

    Rezultat sketchu:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Jak widać obie pamięci EEPROM działają poprawnie. W ten sposób zyskujemy całe dodatkowe 512KB (dwie kości po 256KB) pamięci!

    Małe demko - drukowanie kodów klawiszy na ekranie
    Teraz przedstawię proste demko już bezpośrednio związane z głównymi atutami mojej nakładki, czyli generowaniem obrazu VGA i obsługą klawiatury PS/2.
    Poniższe demko odbiera klawisze wciśnięte na klawiaturze i wyświetla ich kody na ekranie - za wyjątkiem strzałek, które są kodowane jako kilka kolejnych wartości i trzeba je w specjalny sposób wykrywać.
    Każda wciśnięcie jednej ze strzałek daje na UART następujące kody:
    Kod: c
    Zaloguj się, aby zobaczyć kod

    Strzałki w poniższym demku są wykrywane poprawne i informacje o ich wciśnięciu są wyświetlane jako tekst.
    UWAGA: Poniższe demko poprawnie obsługuje Caps Lock i wpisywanie znaków z Shift, ale tego nie ma w kodzie na Arduino, gdyż dzieje się to w samym shieldzie i na klawiaturze.
    Pełny kod demka:
    Kod: c
    Zaloguj się, aby zobaczyć kod


    Rezultat działania:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Shift i Caps-Lock są poprawnie obsługiwane, a same klawisze są bezbłędnie odbierane (za wyjątkiem pewnej sytuacji - ale o tym w następnym akapicie).

    Dlaczego lepiej korzystać z baud 19200 a nie np. z 1200?
    Tutaj chciałbym zwrócić uwagę na to jak duże znaczenie ma świadomy wybór odpowiedniego baud komunikacji UART ze shieldem.
    Nie można wybrać zbyt dużego baud, bo ogranicza nas zdolność SoftwareSerial z Arduino. Przy około 38400 mogą się zacząć problemy. To raczej wiadomo, podobne informacje powtarzają się na forum Arduino:
    https://forum.arduino.cc/index.php?topic=528912.0
    Ale nie można też wybrać zbyt małego baud, bo wtedy będziemy gubić znaki lub co gorsza otrzymywać błędne dane.
    Łatwo to pokazać uruchamiając demo 'test klawiszy' i wciskając (trzymając cały czas) klawisz strzałki, który wysyłany jest przez UART jako trzy znaki.
    Zdjęcie demka 'odbiór klawiszy' przy baud 1200:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Zdjęcie demka 'odbiór klawiszy' przy baud 19200:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Widzicie różnicę?
    Wniosek: nieodpowiednio dobrany baud może naprawdę namieszać, również gdy wybierzemy jego zbyt małą wartość. Na zdjęciu widać, że raz nawet wysłała się wartość '109' która odpowiada klawiszowi 'm', co z pewnością mogłoby mieć niepożądany skutek jeśli byśmy w naszym programie korzystali zarówno ze strzałek jak i z tego klawisza.

    Zaawansowane edytor tekstu
    Teraz zaprezentuję nieco bardziej zaawansowane demko oparte o mojego shielda, a mianowicie prosty edytor tekstu.
    Edytor tekstu będzie oferować:
    - obsługa klawisza Shift
    - obsługa klawisza Caps Lock
    - obsługa klawisza Delete (usuwanie znaku po kursorze)
    - obsługa klawisza Backspace (usuwanie znaku przed kursorem)
    - obsługa klawisza Enter (dodawanie nowej linii)
    Część tej funkcjonalności jest po stronie Arduino, a część na shieldzie.
    Rzeczy takie jak poruszanie kursorem, obsługa bufora tekstu, dodawanie znaków, usuwanie ich itp. są po stronie Arduino.
    Zdjęcia z działania dema-edytora tekstu na monitorze VGA i klawiaturze PS2:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM

    Edytor tekstu można by znacznie ulepszyć, ograniczyć bardziej zbędne odświeżanie pełnego ekranu lub po prostu przenieść w większej części na PICa.
    Skecz Arduino do pobrania:
    ino_vga_te...xtEdit.zip Download (2.8 kB)

    Test edytora tekstu na starym telewizorze CRT TX-21AT1P
    W ramach uzupełnienia poprzedniego akapitu przedstawiam tu filmik z działania edytora tekstu w trybie PAL na telewizorze kineskopowym:

    Zbędne 'pełne odświeżenie' ekranu w trakcie dodawania nowej linii do tekstu można by usunąć w kodzie programu, ale nie to było celem tego demka.

    Zaawansowane demko - system plików na EEPROM
    Przedstawione tutaj demko opracowałem w celu dokładniejszego przetestowania obu pamięci EEPROM znajdujących się na płytce (te pamięci pozwalają nam zapisać dane które nie utracą się nawet po całkowitym odłączeniu zasilania od Arduino). Demko to stanowi podstawową wersję systemu plików, który wspiera podstawowe operacje na plikach i katalogach (tworzenie ich, usuwanie, dodawanie danych, przeglądanie, czyszczenie), pozwala też zagnieżdżać katalogi/pliki w innych katalogach tworząc strukturę drzewa. System oczywiście też jest na różne sposoby ograniczony - brakuje dynamicznej alokacji pamięci dla danych pliku, choć jest ona dostępna dla samych katalogów i plików (używane są ponownie zwolnione sloty).
    Demko obsługuje się poprzez Serial Monitor od Arduino który pełni dla niego funkcję linii komend i wspiera następujące polecenia:
    - dir/ls - wyświetla zawartość bieżącego katalogu
    - mkdir - tworzy katalog o danej nazwie
    - rmdir - usuwa katalog z zawartością
    - resetfs - resetuje EEPROMy do pustego systemu plików
    - resetfile - resetuje plik do stanu pustego (tj. ustawia jego długość na zero)
    - rmfile - usuwa plik
    - cd - przechodzi do danego folderu
    - mkfile - tworzy pusty plik o danej nazwie
    - append - dodaje do danego pliku dany ciąg znaków
    - show - pokazuje dany plik w konsoli
    Poniżej umieszczam zrzuty ekranu z testów powyższego systemu plików; myślę, że ich zawartość nie wymaga komentarza.
    Testy komend mkdir, ls, mkfile, append, ls:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Testy komend: cd, mkdir, mkfile:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Testy komend: rmdir, rmfile, resetfs:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Testy komend: show, mkfile, append:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Demko do pobrania:
    ino_eepro..fs.zip Download (3.36 kB)

    Kompilacja wsadu z kodu źródłowego
    Jeśli tylko chcecie złożyć i używać tego shielda z Arduino to nie musicie samodzielnie kompilować kodu na PICa, potrzebny dla niego .hex załączam tutaj:
    Firmwa..zip Download (87.27 kB)
    Ale jeśli ktoś chce zmodyfikować samo działanie shielda, to kod można łatwo skompilować w środowisku MPLAB X IDE v5.20:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Przy użyciu kompilatora XC32 (v2.20):
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Dodatkowo do kompilacji wymagana jest biblioteka PIC32 Peripheral Library (słynne plib.h wraz z innymi nagłówkami), którą ściąga się osobno ze strony Microchipa:
    https://www.microchip.com/SWLibraryWeb/product.aspx?product=PIC32%20Peripheral%20Library
    Gdy już ją zainstalujemy, to wszystko poprawnie się kompiluje:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Kompilować wsad można w dwóch trybach:
    - tryb dla bootloadera (do wgrania wsadu przez USB za pomocą PIC32UBL.exe) - wtedy w projekcie załączamy 32MX250F128B.ld
    - tryb bez bootloadera (do wgrania wsadu przez ICSP) - wtedy w projekcie wykluczamy plik 32MX250F128B.ld
    Więcej informacji na ten temat znajdziecie w oryginalnej paczce z kodem źródłowym:
    Terminal_S..rce.zip Download (336.98 kB)

    Dalszy rozwój projektu - dalsza minimalizacja?
    Obecna wersja pozostawia jeszcze pole do popisu i możliwość ulepszenia, m.in. dlatego że np. użyty PIC32 jest w wersji PIC32MX250F128B-50I/SO, czyli obudowa SOIC:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    A ten sam mikrokontroler jest jeszcze dostępny w obudowach SSOP (PIC32MX250F128B-50I/SS):
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    ... oraz w QFN (PIC32MX250F128B-50I/ML):
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Wszystkie obudowy naszego PICa (kolejno: QFN, SSOP, SOIC i SPDIP) umieściłem na obrazku poniżej:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM

    Dalszy rozwój projektu - co można by lepiej zrobić?
    Projekt (i też jego wykonanie - luty) nie jest idealny i dużo można by jeszcze ulepszyć.
    - można by dać slot na kartę microSD na płytce (podłączony do SPI od Arduino)
    - można by (jak wspomniałem wyżej) użyć mniejszych obudów elementów i zyskać w ten sposób miejsce na coś więcej na płytce
    - można by zastąpić MCP23016 (wymagający zewnętrznego rezystora i kondensatora na pinie CLK) poprzez nieco lepszy MCP23017 (który nie wymaga tych dwóch elementów)
    - można by też dać tam mocniejszego PICa i/lub iść w stronę kolorowego VGA
    - umieszczone tu przykłady możny by ulepszyć i zoptymalizować, lecz nie to było ich celem (to tylko demonstracja możliwości shielda, nie miała być wydajna)
    Możliwe zatem, że za jakiś czas zrobię trzecią wersję shielda.

    Tabela załączników
    Dla wygody czytelników umieszczam tutaj raz jeszcze odnośniki do załączników które pojawiły się w temacie:













    NazwaOpisZałącznik
    Źródła Eagle projektuPliki .sch i .brd które można edytować w Eagle. Użyjcie tego, jeśli chcecie zrobić własną, zmodyfikowaną wersję tego shielda.
    Pliki Gerber projektuTe pliki wysyłamy płytkarni jeśli chcemy by nam wyprodukowali PCB pod ten projekt. Nie polecam ich edytować.
    Arduino skecz - demo edytora tekstuPełny kod edytora tekstu zrealizowanego na tym shieldzie dla Arduino w formacie .ino. Wymaga podłączonej klawiatury i monitora/telewizora do działania.
    Arduino skecz - demo klawiszyPełny kod testera klawiszy PS/2 z obsługą strzałek zrealizowanego na tym shieldzie dla Arduino w formacie .ino. Wymaga podłączonej klawiatury i monitora/telewizora do działania. ino_vga_pr...eyCode.zip Download (1.03 kB)
    Arduino skecz - demo system plików na EEPROMPełny kod prostego systemu plików na dwóch kościach EEPROM na magistrali I2C Arduino wraz z linią komend na UART. Ten projekt nie korzysta wcale z VGA i nie korzysta z klawiatury PS/2. Kod w formacie .ino
    Skompilowane firmware dla PICa z ShieldaNiezbędny wsad do jednorazowego wgrania na PIC32MX250F128B znajdującego się na pokładzie shielda. Można go wgrać np. za pomocą PICKIT3.
    Kod źródłowy shieldaKod C firmware shielda na PIC32MX250F128B dla MPLAB. Projekt autorstwa geoffg.
    Datasheet AT24CM02Dla dociekliwych - nota katalogowa użytej kości pamięci atmel-8828...asheet.pdf Download (1.11 MB)
    Datasheet MCP23016Dla dociekliwych - nota katalogowa użytego expandera portów mcp230..pdf Download (543.31 kB)
    Biblioteka AT24CXBiblioteka AT24CX z Githuba - kopia zapasowa, wersja ta którą przetestowałem i wykorzystałem do tego projektu. Tę paczkę .ZIP można łatwo dodać do Arduino poprzez 'Add .ZIP Library...'.
    Biblioteka CyMCP23016Biblioteka CyMCP23016 z Githuba - kopia zapasowa, wersja ta którą przetestowałem i wykorzystałem do tego projektu. Tę paczkę .ZIP można łatwo dodać do Arduino poprzez 'Add .ZIP Library...'.


    Podsumowanie
    Jestem bardzo zadowolony z drugiej wersji mojego shielda. Przejście z montażu przewlekanego na powierzchniowy pozwoliło mi zmieścić na nim nieco więcej niż w pierwszej wersji. Dzięki oparciu o Arduino UNO całość jest wygodna i prosta w użyciu nawet dla początkujących. Umieszczone dodatkowo na płytce układy (MCP23016 i AT24CM02) też posiadają gotowe biblioteki dla Arduino dostępne w sieci, co sprawia, że obsługa mojego shielda sprowadza się do składania programów niemalże jak z klocków, a użycie klawiatury PS/2 oraz możliwość wyświetlania jednokolorowego obrazu VGA oraz czarno-białego obrazu PAL/NTSC nadaje całości nieco 'oldschoolowy' klimat.

    Fajne! Ranking DIY
    Potrafisz napisać podobny artykuł? Wyślij do mnie a otrzymasz kartę SD 64GB.
    O autorze
    p.kaczmarek2
    Poziom 24  
    Offline 
  • SterControlSterControl
  • #2
    tmf
    Moderator Mikrokontrolery Projektowanie
    Fajne wykonanie. Ale tak się zastanawiam dlaczego 32-bitowy procesor generuje tylko monochromatyczny obraz tekstowy? Przecież spokojnie mógłby wygenerować obraz kolorowy zarówno dla VGA, jak i PAL/NTSC. W trybie graficznym trochę mało jest pamięci RAM, ale w trybie tekstowym jest jej aż nadto. Zresztą generując obraz ten procesor praktycznie się nudzi, więc można spokojnie w niego załadować program, który jest realizowany na AVR z Arduino i całość nadal będzie się nudzić.
  • SterControlSterControl
  • #3
    grendel123
    Poziom 15  
    Jeszcze raz z ciekawości przetestowałem swoją wersję tego układu na monitorze podłączonym do niej już w momencie podania zasilania i faktycznie układ ruszył. Wcześniej zmyliło mnie to, że po podłączeniu monitora ten otrzymywał sygnały synchronizacji i się wybudzał, ale nie rozpoznawał obsługiwanego trybu. Nie wgryzałem się w kod źródłowy aż tak bardzo, żeby znaleźć moment przełączania z VGA na Video. Sprawdziłem jedynie w kodzie generowanie sygnału synchronizacji i wyszło mi faktycznie, że jest zgodny ze standardem VGA 640x480 (czyli powinno działać) i dalej odpuściłem temat.
    W zasadzie to się cieszę, że nie napisałeś pod moim postem jak to jest rozwiązane, bo dzięki temu poznałem i uruchomiłem projekt FabGL na ESP32. Jeśli interesujesz się tematem VGA w Arduino to polecam - potęga. Cenowo wychodzi podobnie jak ten układ, ale jest kolor, przygotowane biblioteki do GUI (okienka, przyciski, formularze, pola combo, checkbox, fonty i inne).
    Moja wersja:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
  • #4
    p.kaczmarek2
    Poziom 24  
    tmf napisał:
    Ale tak się zastanawiam dlaczego 32-bitowy procesor generuje tylko monochromatyczny obraz tekstowy?

    Dobre pytanie, ale tak jak pisałem na początku, shield do generacji obrazu korzysta z 'ASCII Video Terminal' autorstwa geoffg, który właśnie jest jednokolorowy i swoją drogą też jest w stanie generować proste kształty:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Nie przerabiałem samej generacji VGA, choć już od jakiegoś czasu rozważam modyfikacje i ulepszenie jej.
    Całkiem możliwe, że będzie zrobiona trzecia wersja, już kolorowa.
    Mam na oku jedną konkretną bibliotekę/przykład kolorowego VGA na licencji GPL (żaden problem - i tak publikuję źródła) którego zamierzam użyć:
    https://blogs.fsfe.org/pboddie/?p=1712
    http://hgweb.boddie.org.uk/VGAPIC32/file/bf3ddd5a9874/README.txt
    Zalikowany wyżej kod korzysta oczywiście z DMA do generowania obrazu. Przykład można łatwo skompilować w darmowym kompilatorze mips, ja już kompilowałem to pod Ubuntu:
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM
    Ale nie testowałem jeszcze w praktyce.
    Też możliwe, że jak zdecyduję się na robienie wersji kolorowej (pewnie w oparciu o przykład powyżej) to użyję już nieco mocniejszego PICa, np: pic32mx795f512l.

    grendel123 napisał:
    projekt FabGL na ESP32
    (...)
    Arduino VGA Shield - wersja druga, SMD - z expanderem portów i pamięcią EEPROM

    Nie słyszałem o tym, zapraszam byś dokładniej opisał czym to jest i opublikował na DIY.
  • #5
    khoam
    Poziom 38  
    Opis projektu FabGL z kodami źródłowymi jest dostępny tutaj: https://github.com/fdivitto/FabGL
  • #6
    tmf
    Moderator Mikrokontrolery Projektowanie
    p.kaczmarek2 napisał:
    Też możliwe, że jak zdecyduję się na robienie wersji kolorowej (pewnie w oparciu o przykład powyżej) to użyję już nieco mocniejszego PICa, np: pic32mx795f512l.

    Zachęcam gorąco do prób. Mocniejszy PIC nie będzie potrzebny - swego czasu pokazałem jak wygenerować VGA na XMEGa - procesorze o wiele słabszym. Przykład można pobrać - jest w jednym z przykładów do moich książek. Sam kod to raptem parę linii - dla mono generowanie jest proste - na timerach impulsy synchronizacji, co nie zajmuje żadnego czasu procesora, dane lecą przez DMA do SPI, co też jest procesem nie pochłaniających dużych zasobów. Dla XMEGa obciążenie generowaniem obrazu było na poziomie max kilku procent. Dla obrazu kolorowego - w wersji prostej można wykorzystać QSPI, jeśli procesor takowy posiada i 16 kolorów nas satysfakcjonuje, albo też użyć DMA i zewnętrznego zatrzasku synchronizowanego przez pixel clock - niezbędne bo DMA nie działa synchronicznie z pixelclock i powodowałoby to jitter na poziomie pikseli. Oczywiście jeśli mówimy o kolorowej grafice to potrzeba sporo pamięci.
    Ja bym jednak poszedł w FTDI - co prawda ten chip steruje matrycami LCD, ale prosty konwerter zrobi z tego sygnał NTSC/PAL/VGA. O ile pamiętam takie rozwiązanie zostało już pokazane tu w DIY. Ale chyba jeszcze lepiej pójść w HDMI - tez mi się kojarzy, że takie rozwiązanie tu było pokazane. Trochę bardziej to wymagające, bo tu chyba minimalny pixelclock to 200 MHz i trzeba odpowiednio zainicjować kontroler HDMI. Ale kody już można znaleźć w necie.
  • #7
    piotr_go
    Konstruktor DIY elektronika