.. vim: noexpandtab fileencoding=utf-8 nomodified wrap textwidth=270 foldmethod=marker foldmarker={{{,}}} foldcolumn=4 ruler showcmd lcs=tab\:|- list tabstop=8 noexpandtab nosmarttab softtabstop=0 shiftwidth=0 :date: 2023.06.21 03:16:36 :modified: 2023.09.04 09:55:04 :tags: HW,6809,Expanduino :authors: Gilhad :summary: Expanduino_I, přidán SpeedTest :title: Expanduino_I :nice_title: |logo| %title% |logo| |Expanduino_I-nahled.png| |Expanduino_I_galerie_DSC_7885.s.jpg| %HEADER% Viz též `Inspiromat `__ `asm6809 <../asm6809.html>`__ `6809-6809E_Reference_Card <../6809-6809E_Reference_Card.pdf>`__ `Galerie <./Expanduino_I_galerie.html>`__ Externí ``__ Expanduino_I -------------------------------------------------------------------------------- Vymýšlím přídavnou desku pro 6809 počítač (`OMEN kilo od Martina Malého `__), kam by šlo připojit "cokoliv" - teda pro začátek nějakou klávesnici (asi PS/2 kvůli snadnému ovládání) a nějaké zobrazovadlo jako několikařádkový OLED, nebo tak něco. A třeba i kombinovanou retro tlačítkovo/LED/7-segmentovou klávesnici. A USB-Serial, ten je v podstatě "zdarma" na tom Arduinu. A taky by šlo nějakým trikem tam pak "natypovat" připravené .hex soubory a tak podobně. (A SD kartu, RTC, EEPROM ...) Což by narychlo šlo pomocí nějakého Arduina, protože pro ty je takových návodů bambilión. Jenomže 6809 běží na téměř 2MHz (krystal skoro 8MHz, kvůli dělitelnosti pro ACIA MC6850 která dělá sériový vstup/výstup na 115.200Bd. A zařízení mapuje do paměti, takže data tečou přez stejné dráty jako vykonávané instrukce. a to nemá Arduino absolutně šanci nějak softwarově ustíhat. Takže ta přídavná karta bude mít směrem k 6809 vystrčené 2R+2W registry podobně jako ta ACIA a směrem k Arduinu vystrčené SPI shiftregistry pro čtení a zápis a uvnitř si bude sama udržovat, zda má data ten či onen směr. (Zní to složitě, ale prakticky tam budou 2x74595 pro paralelní výstup, 1x74165 pro paralelní vstup, 1x 74373 pro stavový registr, 3xSR hradla a nějaká "bižuterie" pro výběr adresy a ovládání Enable.) (Nakonec to budou 4+4 registry.) No a to dekódování adresy (a čísla desky a Read a Write) bych právě udělal raději přez jeden PAL, než přez spoustu 7400, protože vlastně potřebuju jen pro 8 výstupních pinů definovat, kdy na kterém má být nula nebo jedna. Pro každý výstupní pin je daná kombinace (0,1,nezáleží) na 6 vstupních linkách, kdy má být aktivován ( = 0 a ve všech ostatních případech má být neaktivní = 1, protože příslušné vstupy jsou negované) - což je přesně to, co tyhle PAL umí dobře. (A ty "nezáleží" tam vlastně nebudou) (Už jsem to vyřešil) Zatím tápu s tím vypalováním - co jsem zatím hledal po netu, tak mám sílící pocit, že by to mělo nějak jít pomocí nějakého "programátoru", kterému by mělo stačit asi tak Arduino, nějaký DC-DC 5->12V, patice a pár součástek okolo a všechno ostatní by odřel nějaký program v PC přez USB komunikaci s tím Arduinem - až na to, že jsem nedohledal jaký program pro Arduino, jak to konkrétně zapojit a jaký program pro PC (já mám linux). A mám z nějaké Číny nějaké `ATF16V8BQL-PU15 <.root/HW/ATF16V8BQL.html>`__ (a teď tam píšu víc o tom vypalování, :strike:`třeba to nějak půjde` a jde to i doma) (A v `Inspiromat `__ si píšu nápady, errata a jiné další věci) FAQ -------------------------------------------------------------------------------- Co to vlastně má vůbec dělat? * Mám retropočítač s 6809, ale nemá žádné periférie. * Mám arduina a pro ty je periferií všude plno. * 6809 vidí všechno jako paměť na 2MHz 8-bit sběrnici. * Arduino umí dobře SPI sběrnici (8MHz 1-bit) * Takže Expanduino je z jedné strany vidět jako 4 adresy na 2MHz 8-bit sběrnici, z druhé jako 8 SPI (8MHz 1-bit) a uvnitř je to "nějak prodrátované". * Následně teda 6809 může využívat všechna zařízení připojitelné k Arduinu a všechny jeho komunikační schopnosti. (Například RTC, sériovou EEPROM, teploměr, SD kartu, ...) Jak to funguje a na co tam jsou všechny ty divné obvody? * "Nějak prodrátované" znamená, že když jeden "někam" zapíše, tak by to následně měl druhý přečíst, aby tam zase první mohl znova zapsat. (logika, ne? :)) Na které straně hřiště je zrovna míč hlídá HW desky pomocí 7 SR hradel napojených na "Status Register" (adresa 0 pro čtení, SPI zařízení 0 (pro čtení)), který je dostupný pořád oběma a tudíž nepotřebuje vlastní SR semafor. * "Někam" je buď 74HC165 (8-bit vstup, SPI výstup)(4x), nebo 74HC595 (SPI vstup, 8-bit výstup)(3x). * "Stavový registr" je připojený na 74HC165 (pro SPI přístup) a na 74HC373(pro paralelní přístup, 74HC245 by byla lepší volba) * SR hradla jsou 74HC279, ale ta jsou řízená úrovní, proto je před každý vstup zařazen "Edge trigger" z NOT+NAND+RC, který z náběžné hrany udělá pulz. (To jsou ta jednoduchá 74HC00+74HC04 - nenašel jsem lepší cestu, ale rád se nechám poučit - taky nevím všechno, natož aktivně a chyb dělám mraky (a pak je opravuju - viz 74HC373 -> 74HC245, nebo níže Micro ->Every)) * O adresování se stará PAL ATF16V8BQL (který má vlastní článek) - mám 3 bity adresy, 1 z IO1 a signály Read a Write, z toho ukuchtím signál pro jeden z 8 chipů, že má být na sběrnici právě on (a nebo nikdo) (A když tenhle signál skončí, tak se překlopí příslušný SR semafor) * Obdobnou funkci pro Arduino plní 74HC138 (Demux) řízený signály Sel0..2, SelEnable a Demux2 (74HC138 Demux2 plní obdobnou funkci pro přídavná zařízení, jak SD karta) * Protože 74HC165 mají na sériovém výstupu nějakou hodnotu pořád (nemají tam 3state), tak si je na vstup Arduina přepínám pomocí SerMux 74HC151, stejně jako externí SPI. * Arduino jsem původně vybral Micro, (protože má USB na sobě a mám jich doma dost a navíc má 2.5 kB RAM oproti obvyklým 2 kB, ale ukázalo se, že je to pořád málo, když použiju SdFat, tak mi přeteče zásobník do haldy a proměnných. Takže jsem koupil Arduino nano Every, které má 48 kB flash a 6 kB RAM a snad to bude stačit) * RTC jsem použil nějaký takovýhle ``__ a tak mám v ceně i EEPROM a teploměr. * SD nějaký takovýhle ``__, jenže SD karty (a tyhle levné moduly) nejsou SPI, jen "něco podobného" (musí mít Slave Select v nule (=aktivní) při vkládání karty, taky ho ignorují a i když nejsou vybrané, tak klidně dělají bordel na sběrnici i v sobě), takže je z jedné strany oddělený SerMux, (který ho ignoruje, když není vybraný) a z druhé strany dvěma NAND (a jedním NOT, které jsem zapoměl), které mu odříznou vstupy, když není vybraný. * LEDky ukazují stav SR semaforů, zelená bude ukazovat stav relaxovaný, žlutá stav, kdy čeká na vyprázdnění, pozice u kraje jsou pro 6809, pozice uvnitř pro Arduino * Bit 0 ("Stav stavového registru osobně" - což nedává smysl, je připraven vždy) je ovládán přímo Arduinem a asi ho budu používat k instantní signalizaci stavu Arduina - čili bude "busy" když Arduino bude "plnit úkoly", třeba komunikovat s SD kartou a bude "free - ready" když Arduino bude mít volno a jen sledovat stav registrů. Ale to zatím nemám moc dobře promyšlené, prostě je volný, tak proč ho nepoužít ... * Plošňák jsem navrhnul v KiCad ``__, protože mi přijde nejlepší z volně dostupných programů a sedí mi. Vyrobit jsem ho nechal v ``__, kde mi jich udělali rovnou 5, za asi 2$+2$ poštovného - čili za stovku až domů. * Další verzi (Expanduino_II) plánuju až tuhle rozchodím plně (a vychytám chyby) a budou v ní zahrnuté všechny potřebné úpravy Princip -------------------------------------------------------------------------------- * Na vhodné adrese v paměti (`9000h` = `IO1` na rozšiřovací sběrnici) budou speciální registry pro čtení a zápis (kompatibilní s `6809`) a za nima se bude skrývat `Arduino`, které nějak všechno udělá. * Na jedné adrese je vždy pár registrů, jeden pro čtení (`R`) a druhý pro zápis (`W`). HW desky se stará aby to nějak fungovalo. * Na adrese 000b je `Status register`_ pro čtení (udává, co lze číst a kam psát) a `Control register`_ pro zápis (kterým se dá ovládat ta deska/Arduino - zatím nevím, co bych chtěl posílat, ale to se uvidí) * Na adrese 001b je Seriová linka (podobně jako u ACIA) * Adresy 010b a 011b budou obsahovat další, podobně řízená, zařízení jako 001b * celkově tedy jde o :strike:`2/` 4 adresy a teda :strike:`4/` 8 registrů * čtení/zápis registru **musí** probíhat tak, že `6809` * čte Status register tak dlouho, dokud se na příslušném bitu neobjeví log. **1** (teda, to čtení není důležité, důležité je, aby ten příznak byl nastaven) * jednorázově přečte/zapíše zvolený registr (celkem kdykoli později, nebo se na to vykašle) * pro další čtení/zápis/registr zopakuje předchozí kroky * Arduino si :strike:`pravidelně` často (loop) čte `Status register`_ (který udržuje HW) a podle toho čte zapsané registry, nebo doplňuje další hodnoty do registrů pro čtení * když má registr příznak, že jde použít, tak s ním Arduino nic nedělá * když 6809 registr použije (přečte/zapíše), tak HW shodí jeho příznak * když Arduino zapíše/přečte registr, tak HW příznak poté zase nahodí * pokud `6809` dodrží postup, tak nemůže dojít k hazardu a Arduino může být pomalé/rychlé jak chce (a jak integráče zvládnou) * `HW desky` (integráče mezi 6809 a Arduinem) * pro registr pro čtení (`R`) má 3-state output, který je enablován :overlinecite:`IOx`, adresou a :overlinecite:`RD` signálem * pro registr pro zápis (`W`) má input, který je zapsán do vnitřního stavu :overlinecite:`IOx`, adresou a :overlinecite:`WR` signálem * pro `Status register`_ 3-state průchodka, za kterou jsou SR klopáky udržující přehled, kdo by měl teď s registrem pracovat (1 => 6809) * sám `Status register`_ je kdykoli k dispozici komukoli, takže jeho bit můžu použít pro něco jiného, asi pro status Arduina, jestli se zrovna fláká a je volné (1), nebo pracuje naplno (0) a třeba komunikuje s SD kartou nebo tak * asi by stálo i za to ten `Status register`_ zobrazit LEDkama, aby bylo vidět, co se zrovna děje, ale už se mi tam nikam rozumně nevešly, tak jsem použil aspoň SMD s centrálním odporem. Status register -------------------------------------------------------------------------------- * Status register má v zádech SR klopáky, které si pamatují, kdo k registru přistupoval naposled a tedy kdo (ten druhý) by měl být další na řadě * 1 znamená, že registr teď patří 6809, 0 znamená, že patří Arduinu * bit 0 je speciální, ovládaný Arduinem, 1 znamená, že Arduino je připraveno plnit příkazy, 0 že Arduino na něčem pilně pracuje * protože průchodka **není** bufferovaná, je to jediný (jednoduchý) způsob, jak Arduino může hlásit svůj stav 6809 * bit 1 je pro `Control register`_ (který je jednostranný kanál) * bity 2/3 jsou pro `R`/`W` registry na adrese 001b (Exp1 seriový kanál) * bity 4/5 jsou pro `R`/`W` registry na adrese 010b (Exp2 seriový kanál) * bity 6/7 jsou pro `R`/`W` registry na adrese 011b (Exp3 seriový kanál) * SR reagují na vzestupnou hranu :overlinecite:`Enable`, tedy na moment, kdy 6809/Arduino ten registr "pouští" * pokud ho pustí Arduino, nastaví se SR na 1 a na řadě je 6809 * pokud ho pustí 6809 nastaví se SR na 0 a na řadě je Arduino * jakmile jeden zapíše, tak druhý může číst, to ten druhý přečetl, může první opět vesele něco zapsat * reagovat musí na hranu, nikoli na stav, viz `S-R Edge trigered`_ Control register -------------------------------------------------------------------------------- * asi bude časem něco dělat (třeba přepínat připojená zařízení, nebo spouštět "makra", nebo přepínat přídavnou RAM/ROM/EEPROM, nebo tak něco) * technicky je to prostě `W` registr, ke kterému není spárovaný `R` registr * organizačně se teda asi bude používat pro čistě výstupní záležitosti, jako je nastavování Expanduina * v Arduinu má svůj `FIFO` objekt, který ho bufferuje (a asi i FIFO_text pro řetězce) Sériové kanály -------------------------------------------------------------------------------- * Exp1 .. Exp3 na adresách 001b .. 011b * do každého jde psát a z každého jde číst (pokud je co), s čím jsou "venku" propojeny je už záležitostí konfigurace (Arduina) * v Arduinu jim odpovídají `FIFO` objekty, do kterých `ManageRegisters()` automagicky načítá hodnoty registrů, nebo je z nich naopak plní * patrně budu používat `Exp1` jako `stdin` a `stdout` a `Exp2` pro komunikaci s Arduinem, jako třeba "\*read /GAME/DATA.DTA" -> vrátí se proud bytů odpovídajích obsahu souboru, "\*date" -> vrátí se datum, "\*typein /HEX/program1.hex" podsune do "klávesnice" Exp1 obsah toho souboru ... * `Exp3` zatím nevím (ale klidně může třeba v nějakých režimech sloužit jako `stderr` a/nebo jako debugovací konzole - uvidím) Konstrukce -------------------------------------------------------------------------------- Použiju 74HCxxx (i když mi tam KiCad občas nabízí jiné symboly, jako 74LS a tak) LED ================================================================================ * LED mám jen SMD, protože klasické se mi už nevešly * jedna pro `SelectEnable` který je aktivní v nule, takže LED proti +5V * jedna pro `DeMux2`_ aktivní v jedničce, takže LED proti GND * po jedné pro každý registr (LED pro `Status register`_ ovládá přímo Arduino, ostatní ovládají `S-R Edge trigered`_) LED poti +5V i proti GND, barva podle relaxovaného stavu zelená, žlutá když potřebuje řešit. * tady se mi už odpory nevešly vůbec, tak jen jeden proti +5V a jeden proti GND společné, ono to funguje i tak celkem dobře S-R Edge trigered ================================================================================ .. |Pulse| image:: Pulse.png :width: 150 :target: Pulse.png .. |SR-Edge_Dtype| image:: SR-Edge_Dtype.png :width: 150 :target: SR-Edge_Dtype.png .. |SR-Edge_NAND| image:: SR-Edge_NAND.png .. |SR-Edge_NAND_capacity| image:: SR-Edge_NAND_capacity.png .. |StatusLogic-err| image:: StatusLogic-err.png .. |StatusLogic-normal| image:: StatusLogic-normal.png .. |StatusLogic-schema| image:: StatusLogic-schema.png Pro každý `R`/`W` registr potřebuju `SR` semafor, který pamatuje, kdo ho naposled použil (a tedy kdo s ním má dál pracovat a zda jeho příznak ve `Status register`_ má být nastaven (`zdroj obrázku `__): |StatusLogic-schema| Když jde všechno krásně, tak signály běhají takto |StatusLogic-normal| * zapisující si z `S`/:overlinecite:`S` zjistil, zda smí psát, a když mu enable `E1` spadnul na nulu, tak tam data nasypal a když pak vylezl na log. `1`, tak už měl hotovo a `S` se sám nastavil * čtoucí si z `S`/:overlinecite:`S` zjistil, zda smí číst, a když mu enable `E2` spadnul na nulu, tak ta data načetl a když pak vylezl na log. `1`, tak už měl hotovo a `S` se sám shodil dolů * ve chvíli, kdy se signál `S` změní, tak už je hotovo a druhá strana může cokoli * `Arduino` si enable `Ex` nastavuje dle potřeby, pro `6809` je odvozen z adresy a `R/W/E` signálů Když to nejde tak krásně a někdo dělá kraviny, tak to taky může vypadat takhle: |StatusLogic-err| * čárkované čáry jsou kde se `S`/:overlinecite:`S` nastavuje na stejnou hodnotu, jakou už mělo (a jsou to případy, které neměly nastat) * při opakovaném zápisu se pokaždé zapíše nová hodnota * v tom lepším případě čtoucí začne číst až poslední hodnotu a předchozí příjdou vniveč * ale když se to špatně potká tak čtoucí možná přečte část jedné a část druhé hodnoty (třeba i několikrát) * a když je to hodně špatně, tak pak ještě přečte zmršený zbytek poslední hodnoty (třeba jen část a ještě posunutou, nebo co se tam HW stane) * při opakovaném čtení je platné jen první čtení, opakování můžou (dle HW) vrátit cokoli (tu samou hodnotu, nějakou haluz, samé nuly, nebo jedničky) * a pokud přitom ještě haluzí zapisující, tak tam můžou lézt naprosté bludy * nicméně pokud se oba umoudří, tak by po vyčerpání haluzí měl být systém zase funkční * možná tam dám něco pro `Control register`_, jako že zápis magické hodnoty (třeba 00h) přiměje Arduíno zresetovat vše co má do `soft-rebootu` - a `6809` si nějak uklidí svoje buffery sama. Technicky to jde udělat například `takto `__ a zabere to 1+1/2 chipu: |SR-Edge_Dtype| A nebo dát `Pulse generator` před vstupy klasického SR ze dvou NAND (NOR), jak jsem zamýšlel původně (a s použitím 74xx14 to zabere jen 1+1/3 chipu) |Pulse| Takže rozhodnuto, NAND+NOT, levné, snadné, malé |SR-Edge_NAND| A protože to nefunguje dost spolehlivě (moc krátké pulzy = nic nedělá) a v PAL je to totálně zabité, tak přidáme kondenzátor a odpor, přez který se nabíjí a tak to zpoždění utěšeně naroste (Otázka je jak velké hodnoty použít, někde se doporučuje něco jak 5 |kOhm| a 150 pF, já úspěšně zkusil 220 |Ohm| a 150 pF) |SR-Edge_NAND_capacity| Signály -------------------------------------------------------------------------------- clock ================================================================================ * clock se používá jeden společný, výběr chipu se dělá jinak (`74151 SerMux`_ přepne správnou linku pro čtení, zápis se provede vybráním a odvybráním správného `R` registru) * v podstatě to znamená, že se všechny chipy naráz čtou a plní, akorát se to zapíše jen v jednom chipu * Vlastně pro `W` registry ten clock disabluju, protože bych z nich jinak vytáhnul data ještě před čtením * A pro `SD` kartu to taky filtruju, protože ta nedodržuje `SPI` konvence, že by ji chipselect vybíral a pokud není vybraná, že nemá ani kecat, ani poslouchat, ale být HighZ S-R registry ================================================================================ * `Q` znamená, že je k dispozici `6809` (`W` je prázdný a připraven pro zápis, `R` je naplněn a připraven pro čtení) * :overlinecite:`Q` znamená, že je k dispozici Arduinu (`W` je naplněn a připraven pro čtení, `R` je prázdný a připraven pro zápis) * realizován jako 1/2 74HC00 nebo 1/4 74HC279 * `2023.07.29 08:00:00` rozchození S-R Edge Trigger na breadboardu - kondíky značené 150p (s hodnotama asi 3x vyššíma?) a 220 |Ohm| odpory (s 4k7 to nechodilo, ještě bych rád vysledoval, kde to začíná chodit (1 |kOhm| chodí "jak kde, jak kdy", takže 220 |Ohm| je akorát) a pak dal něco s řekněme 4x rezervou) Chipy -------------------------------------------------------------------------------- ATF16V8BQL ================================================================================ * dekóduje :overlinecite:`WR` `A[0..2]` :overlinecite:`RD` a :overlinecite:`CS` (:overlinecite:`IO1` na sběrnici desky) na :overlinecite:`Enable` pro jednotlivé registry * Jednotlivé výstupy se přímo připojují k `Output Enable` / `Data Read` pinům jednotlivých registrů a jejich vzestupná hrana shazuje příslušné `S-R registry`_ - Reset * viz `ATF16V8BQL <.root/HW/ATF16V8BQL.html>`_ a `SMdec01.pld <.root/HW/SMdec01.pld>`_ 74151 SerMux ================================================================================ * vybírá serial pro čtení * jdou číst pouze `W` registry a `Status register`_ * `Enable` je aktivováno pořád (protože výstup je připojen k Arduinu a stejně má vždy nějakou hodnotu) * pomocí `Select[0..2]` se vybere zdroj, který se přepisuje na `SerRxx` vstup * Piny * 1..4, 12..15 `serial Input`, zapojit na `W` registry a `Status register`_ * 5 `SerRxx` output, zapojit na Arduino * 9..11 `Select[0..2]`, zapojit na Arduino * 7 :overlinecite:`Enable` - `GND` * 6 NC (negace pinu 5) 74138 DeMux ================================================================================ * přepíná :overlinecite:`Enable` pro jednotlivé interní registry DeMux2 ================================================================================ * přepíná :overlinecite:`Enable` pro jednotlivé externí registry 74595 ReadReg ================================================================================ * Registry 2,4,6 (0 je `Status register`_ a tomu se hodnoty nastavujou přímo přez `S-R registry`_ ) * Zapsání hodnoty se dělá tak, že se registr vybere (latch LOW), nashiftujou se do něj data a pak se odvybere (čili latch jde z LOW do HIGH a ten edge to zapíše) (zároveň ten edge nahodí `S-R registry`_ - Set) * `SelectEnable` je nutný, aby se postupným zadáváním jednotlivých bitů adresy nepřepínaly náhodně jiné registry (a odpřepnutím nezapisovaly jako Enabled) .. code:: for (int i=0; i<2; ++i) digitalWrite(Select[i], _BV(address,i); // prepare `address` to select chip digitalWrite(SelectEnable, LOW); // send it to chip (select it) shiftOut(SerW, clock, LSBFIRST, value); // send `value` to all chips digitalWrite(SelectEnable, HIGH); // let selected chip to latch it * Piny * 15, 1..7 `Output` - zapojit na `D[0..7]` * 13 :overlinecite:`OE` - Output Enabled, aktivní v nule, připojuje k `D[0..7]` sběrnici - zapojit na výstup `ATF16V8BQL` * 12 `RCLK` - Registr Write Clock - vzestupná hrana zapíše nashiftovaná data do registru - :overlinecite:`ArdEnable` - zapojit na `74138 DeMux`_ * 14 `SER` sériový vstup, zapojit na `SerW` přímo (shiftování ptákovin nevadí, když se nezapíšou) * 11 `SRCKL` sériové hodiny, zapojit na `clock` přímo (shiftování ptákovin nevadí, když se nezapíšou) * 9 `SerOut Qh'` - NC * 10 :overlinecite:`SRCLR` - clear, zapojit na `+5V` (nuluje registr) 74165 WriteReg ================================================================================ * Registry 1,3,5,7 (a částečně i 0 `Status register`_ ) * Přečtení hodnoty se dělá tak, že se registr vybere (latch LOW) (a zároveň se tím i vybere jako vstup pro `SerMux`), data se vyshiftujou ven do Arduina a pak se odvybere (čili latch jde z LOW do HIGH a ten edge nahodí `S-R registry`_ - Set) * `SelectEnable` je nutný, aby se postupným zadáváním jednotlivých bitů adresy nepřepínaly náhodně jiné registry (a odpřepnutím nezapisovaly jako Enabled) * Piny * --- 74HC279 S-R register ================================================================================ * Pro `S-R registry`_, abych ušetřil pouzdra a místo na desce * zdvojené vstupy spojím, protože tu logiku nepotřebuju * `Cite:` Podvody na Aliexpresu * Ale ten poslední by docela roztomilý - potřeboval jsem integráče `74HC279` (s důrazem na to **HC**, které znamená při jakém napětí to spíná a jaké proudy to zvládá) - stránka jasně psala HC, měla fotku s HC, cenu podobnou jako ostatní s HC ... no ale přišly **LS** - takže jsem to nafotil, reklamoval, dostal peníze zpátky a šel shánět jinam. Ale po nějaké době jsem zkoušel zkoušečku na integráče, hodil to do ní a ono to fungovalo (čekal jsem chyby kvůli napětí). Takže buď blbě navržená zkoušeka (což by mě mrzelo), nebo je něco jinak. Tak jsem ten integráč zkusmo zapojil s nějakými odpory a spoustou měřáků a co byste řekli? Byl to fake. I když to mělo na sobě jasně vytištěné **74LS279**, tak to byl přeznačený **74HC279** Vstupy aktivní v nule, když jsem šel od +5V dolů, na 2.5V skokem přepnulo. Výstup do zátěže 4 mA způsobil úbytek asi 1.5V, v obou směrech (teda od nuly a od Vcc) - typické hodnoty pro 74HCxxx :) Arduino ================================================================================ * Zvolil jsem Arduino Pro Mikro s mikro USB, protože jich už doma několik navíc mám, má USB a pro základní připojení má nožiček dost (a je mrňavé) * `kicad schema tady `__ instalace uvnitř popsána * SPI * D14 - MISO * D15 - SCK * D16 - MOSI * D17 - SS - TX LED (musí být output a taky bude ;) * --- SPI ================================================================================ * Pro použití `SPI` i pro vnější zařízení udělám * `DeMux2`_ - vybírá druhý demuxer, který umožňuje adresovat druhou (alternativní) sadu SPI zařízení pro zápis do nich * SerR2 - `SD karta`_ `MISO` umožňuje čtení alternativního zařízení 2 * SerR4 - umožňuje čtení alternativního zařízení 4 * SerR6 - umožňuje čtení alternativního zařízení 6 SD karta ================================================================================ * Většinou asi chodí na 3V3, ale moduly by měly být 5V tolerantní * Je to **ZMRŠENINA** !!! * Pro `SPI` vyžaduje `CS` nastavený na 0 při vložení/powerup * **Nerespektuje** `CS` pro `Data Out` (a asi ani pro `Data In`) * Tudíž je **nezbytné** ji od SPI oddělit v **obou směrech** * `SOLVED. Nrf24 (Mirf lib) + Micro SD-card works OK together `_ * asi koupím `tohle `_ a říznu podle plánku výše * místo říznutí jsem to odříznul pomocí `SD_Enable` viz ``__ * takže * použiju zbylou půlku 74HC00 NAND a 1/3 74HC04 NOT na blokování `Clock` a `MOSI` pokud není vybrána * dovnitř ji pustím přez `SerR2` a přepnu si ji podle potřeby navolením `DeMux2`_ a `Sel 2` RTC ================================================================================ * I2C `RTC `_ (s teplotně kompenzovaným krystalem a s 4KB I2C EEPROM) + `CR2025 `_ * !!! **odpájet odpor v nabíjení** !!! * chodí bezproblémově EEPROM ================================================================================ * I2C `RTC `_ (s teplotně kompenzovaným krystalem a s 4KB I2C EEPROM) + `CR2025 `_ * !!! **odpájet odpor v nabíjení** !!! * chodí bezproblémově JLCpcb -------------------------------------------------------------------------------- * `Návod `_ * `grbv` program na prohlédnutí vygenerovaných souborů Obrázky -------------------------------------------------------------------------------- .. |Expanduino_I-bottom-empty.png| image:: Expanduino_I-bottom-empty.png :width: 250 :target: Expanduino_I-bottom-empty.png .. |Expanduino_I-bottom.png| image:: Expanduino_I-bottom.png :width: 250 :target: Expanduino_I-bottom.png .. |Expanduino_I-nahled.png| image:: Expanduino_I-nahled.png :width: 250 :target: Expanduino_I-nahled.png .. |Expanduino_I-top-LEDsOK.png| image:: Expanduino_I-top-LEDsOK.png :width: 250 :target: Expanduino_I-top-LEDsOK.png .. |Expanduino_I-top-empty.png| image:: Expanduino_I-top-empty.png :width: 250 :target: Expanduino_I-top-empty.png .. |Expanduino_I-top.png| image:: Expanduino_I-top.png :width: 250 :target: Expanduino_I-top.png * |Expanduino_I-nahled.png| Expanduino_I-nahled.png * |Expanduino_I-top-LEDsOK.png| Expanduino_I-top-LEDsOK.png * |Expanduino_I-top.png| Expanduino_I-top.png * |Expanduino_I-top-empty.png| Expanduino_I-top-empty.png * |Expanduino_I-bottom.png| Expanduino_I-bottom.png * |Expanduino_I-bottom-empty.png| Expanduino_I-bottom-empty.png Zdrojáky -------------------------------------------------------------------------------- * `KiCad projekt `__ * `Gerber files `__ * `Firmware + test komunikace `__ ano, posílají si data navzájem :) * `Firmware + test rychlosti `__ rychlost, kterou dokážou cpát data do HW, bez testů, zda smí a zda někdo poslouchá (Arduino R: 18.000 B/s W: 18.500 B/s; 6809: 96.900 B/s - ano, je to v bytech za sekundu) tedy s plným handshakem bude Expanduino_I asi 2x pomalejší, než ACIA - to není zlé, vzhledem k tomu, co všechno může zařizovat, ale komunikaci spíš tedy přez tu ACIA ... Errata -------------------------------------------------------------------------------- .. |Expanduino_I_fix_001_schema.png| image:: Expanduino_I_fix_001_schema.png :width: 250 :target: Expanduino_I_fix_001_schema.png .. |Expanduino_I_fix_001_spoje.png| image:: Expanduino_I_fix_001_spoje.png :width: 250 :target: Expanduino_I_fix_001_spoje.png .. |Expanduino_I_fix_002_schema.png| image:: Expanduino_I_fix_002_schema.png :width: 250 :target: Expanduino_I_fix_002_schema.png .. |Expanduino_I_fix_002_spoje.png| image:: Expanduino_I_fix_002_spoje.png :width: 250 :target: Expanduino_I_fix_002_spoje.png .. |Expanduino_I_galerie_DSC_7873.s.jpg| image:: Expanduino_I_galerie_DSC_7873.s.jpg :width: 250 :align: top :target: Expanduino_I_galerie_DSC_7873.s.jpg .. |Expanduino_I_galerie_DSC_7874.s.jpg| image:: Expanduino_I_galerie_DSC_7874.s.jpg :width: 250 :align: top :target: Expanduino_I_galerie_DSC_7874.s.jpg .. |Expanduino_I_galerie_DSC_7875.s.jpg| image:: Expanduino_I_galerie_DSC_7875.s.jpg :width: 250 :align: top :target: Expanduino_I_galerie_DSC_7875.s.jpg * Nějak jsem se zamotal do úrovní Enable pro SD, správně to má být takto (negovaný signál aktivní v nule): * schema |Expanduino_I_fix_001_schema.png| * fix |Expanduino_I_fix_001_spoje.png| * foto |Expanduino_I_galerie_DSC_7875.s.jpg| * 74HC595 mají blbě zapojený :overlinecite:`SRCLR` (clear) na `GND` místo na `+5V` * schema |Expanduino_I_fix_002_schema.png| * fix |Expanduino_I_fix_002_spoje.png| * foto |Expanduino_I_galerie_DSC_7873.s.jpg| |Expanduino_I_galerie_DSC_7874.s.jpg| * světýlka jsou obráceně (GND má být u okraje, aby ho 1 rozsvítila, pořadí u kraje GG YG YG YG je správně) Schéma -------------------------------------------------------------------------------- .. |Expanduino_I_schema_Arduino.png| image:: Expanduino_I_schema_Arduino.png :width: 250 :align: top :target: Expanduino_I_schema_Arduino.png .. |Expanduino_I_schema_Enable_Decoding.png| image:: Expanduino_I_schema_Enable_Decoding.png :width: 250 :align: top :target: Expanduino_I_schema_Enable_Decoding.png .. |Expanduino_I_schema_LEDs.png| image:: Expanduino_I_schema_LEDs.png :width: 250 :align: top :target: Expanduino_I_schema_LEDs.png .. |Expanduino_I_schema_PWR.png| image:: Expanduino_I_schema_PWR.png :width: 250 :align: top :target: Expanduino_I_schema_PWR.png .. |Expanduino_I_schema_Read_Registers.png| image:: Expanduino_I_schema_Read_Registers.png :width: 250 :align: top :target: Expanduino_I_schema_Read_Registers.png .. |Expanduino_I_schema_SD_card.png| image:: Expanduino_I_schema_SD_card.png :width: 250 :align: top :target: Expanduino_I_schema_SD_card.png .. |Expanduino_I_schema_SR1.png| image:: Expanduino_I_schema_SR1.png :width: 250 :align: top :target: Expanduino_I_schema_SR1.png .. |Expanduino_I_schema_SR2.png| image:: Expanduino_I_schema_SR2.png :width: 250 :align: top :target: Expanduino_I_schema_SR2.png .. |Expanduino_I_schema_Status_Register.png| image:: Expanduino_I_schema_Status_Register.png :width: 250 :align: top :target: Expanduino_I_schema_Status_Register.png .. |Expanduino_I_schema_Write_Registers.png| image:: Expanduino_I_schema_Write_Registers.png :width: 250 :align: top :target: Expanduino_I_schema_Write_Registers.png * Expanduino_I_schema_Arduino.png |Expanduino_I_schema_Arduino.png| * Expanduino_I_schema_Enable_Decoding.png |Expanduino_I_schema_Enable_Decoding.png| * Expanduino_I_schema_LEDs.png |Expanduino_I_schema_LEDs.png| * Expanduino_I_schema_PWR.png |Expanduino_I_schema_PWR.png| * Expanduino_I_schema_Read_Registers.png |Expanduino_I_schema_Read_Registers.png| * Expanduino_I_schema_SD_card.png |Expanduino_I_schema_SD_card.png| * Expanduino_I_schema_SR1.png |Expanduino_I_schema_SR1.png| * Expanduino_I_schema_SR2.png |Expanduino_I_schema_SR2.png| * Expanduino_I_schema_Status_Register.png |Expanduino_I_schema_Status_Register.png| * Expanduino_I_schema_Write_Registers.png |Expanduino_I_schema_Write_Registers.png| Galerie z finální fáze oživování -------------------------------------------------------------------------------- `Galerie <./Expanduino_I_galerie.html>`__ .. |Expanduino_I_fix_001_spoje-link| image:: Expanduino_I_fix_001_spoje.png :width: 250 :target: inspiromat.html .. |Expanduino_I_galerie_DSC_7870-link| image:: Expanduino_I_galerie_DSC_7870.s.jpg :width: 250 :target: Expanduino_I_galerie.html .. |Expanduino_I_galerie_DSC_7885.s.jpg| image:: Expanduino_I_galerie_DSC_7885.s.jpg :width: 250 :target: Expanduino_I_galerie_DSC_7885.s.jpg **Galerie z finální fáze oživování (klikací)** |Expanduino_I_galerie_DSC_7870-link| **Errata, Poznámky a Plány (klikací)** |Expanduino_I_fix_001_spoje-link|