Seriekoppla I/O moduler

[Plogen]

Jag försöker hitta bästa lösningen för att kunna seriekoppla moduler enligt exempel nedan:




(inte den egentliga konstruktionen utan exempel)

Kvarbilden är följande:

• Alla LED:ar skall kunna styras individuellt.
  Vid knappstyck skall indikation skickas till µC alt. avläsas enligt förutbestämt intervall.
  Man skall kunna seriekoppla minst 31st moduler, gärna 160+.
  Alla moduler skall kunna identifiera sin position "adress" i kedjan själv. Alltså inte hårdvarusatt adress.

Det jag har spånat kring är att använda mig av utav en I2C I/O Expanders, men har inte hittat någon som uppfyller kraven.
Jag har även funderat på att använda ATTINY µC och använda I2C-bussen för kommunikation. Men att adressera själv har jag inte löst (inte utan att behöva koppla in en modul i taget vilket inte är önskvärt).
Det jag är inne på nu är att på något sätt använda Shift-Out/Shift-In men jag vet inte hur jag skall kunna kombinera dom två. Och hur många Shift-register kan man ha i serie "daisy-chain"? Vilka avstånd accepteras? Finns det 2-bit Shift-register?

[sodjan]

Totalt avstånd ? (Sannolikt går I2C bort).
Ska modulerna inte ha fasta adresser ?
Likställer de adress med position ? D.v.s så att den 10'nde modulen
rent fysiskt på linan även har adress 10 ?
När ska denna adresssättnming ske ? Vid power-on ?
Eller ska modulerna vara "hot-plug" med adresser som dynamiskt ändras ?
Har du tittat på CAN ?

Det som jag ser som det trixigaste är just dynamiska adresser.
Det förutsätter i princip att varje modul filtrerar trafiken som ska
gå vidare. I alla fall i den initiala läget då adresserna ska sättas.

[monstrum]

Om de ska kunna förstå sin egen position i kedjan måste det vara en uppbruten kommunikationslinje. Om hög hastighet inte är något krav så kan man ju helt enkelt ha en UART som lyssnar från ett håll och skickar åt andra. Den sista modulen i kedjan byglar sin sändpinne till en tredje pinne som bara kopplar rakt bakåt genom alla andra moduler. Ett slags token-ring-nätverk.

Det första som görs vid uppstart är att man skickar ett adress-meddelande som varje modul uppfattar, inkrementerar och skickar vidare. När mastern får tillbaka ett meddelande via tillbakakopplingen så ser den att adresstilldelningen är klar och även hur många moduler som finns i kedjan.

Resten handlar bara om att utforma protokollet på ett bra och smidigt sätt. Behöver inte blir så komplicerat.

[sodjan]

Om inte alla moduler är exakt lika till funktionen, så behöver man även
fråga modulerna om sin funktion efter att adresstilldelningen är klar.
Men det kanske var just exakt likadana moduler !?

[victor_passe]

Man kan ju skicka kommandon via uart.
master(arduino) sänder [header][addr][data]
den första tar sänder vidare [header][addr-1][data]
till addr=0, så lyssnar enhet #addr på datan
Och allt som skickas på rx går vidare.

Då måste varje slav ha 2st uart enheter.

[blueint]

Eller så har man en gemensam serielina med UART och alla enheter har en address inprogrammerad i sitt EEPROM.

[sodjan]

> ...och alla enheter har en address inprogrammerad...

Men då kan vi ju ändra andra krav och föreslå vilken lösning som helst.

[monstrum]

Man kan ju sätta alla på samma bus och sedan ha en handskakningspinne åt varje håll för varje modul. Då kan man låta den som ser en hög nivå på denna pinne ta en address (genom att skicka något slags address-claim meddelande), sedan sätta sin pinne hög till nästa modul. Alla lyssnar ju på bussen och vet därmed hur högt i adresser som är tagna. När inga fler address-claim skickas (med någon bestämd timeout) så vet man att förfarandet är klart.

[Plogen]

Man kan ju sätta alla på samma bus och sedan ha en handskakningspinne åt varje håll för varje modul. Då kan man låta den som ser en hög nivå på denna pinne ta en address (genom att skicka något slags address-claim meddelande), sedan sätta sin pinne hög till nästa modul. Alla lyssnar ju på bussen och vet därmed hur högt i adresser som är tagna. När inga fler address-claim skickas (med någon bestämd timeout) så vet man att förfarandet är klart.

Det kan vara en möjlig lösning!
Jag hade tänkt att använda en ATTINY85/25 men då måste jag se till att ändra RESET FUSE så att jag kan använda RESET pin som en OUTPUT.
Detta eftersom det går åt 2st exta I/O pinnar vilket jag bara har en till övers...
Undrar om http://code.google.com/p/arduino-tiny/ har någon liknande funktionalitet som följande bootloader:
http://www.avrfreaks.net/index.php?modu ... em_id=1008
Annars kan jag ju inte programmera om kretsarna i framtiden eftersom jag inte äger en High Voltage programmerare, ingen som har en STK500 till övers?

[monstrum]

Är det inte bättre att köra med en processor som har tillräckligt med pinnar utan att tappa reset?

[monstrum]

Alternativet är ju som sagt att kedjekoppla serieinterfacen. Det behövs inte två UART:ar utan det räcker att den lyssnar från ett håll och sänder åt det andra. Det blir dock långsammare då alla paket måste skickas genom hela kedjan, något som förvisso ökar räckvidden. Har du 160 enheter på samma buss så får du ha feta drivare.

[Plogen]

Anledningen till valet av ATTINY är för att volymerna kommer vara höga 160+ per system och varje krona per µC gör mycket i slutändan...
Samt att utrymmet som modulerna skall placeras i är begränsat, men dock troligtvis inte omöjligt att få in en >8-pin µC
Kanske får gå upp till ATTINY2313 om jag inte löser RESET FUSE...

[blueint]

Isåfall kika på kretsar som används i LCD som kan styra iaf 80 utgångar. Eller någon mikrokontroller med flera I/O det lär löna sig om det är många utgångar som behövs.

[monstrum]

Fast som jag förstår det så är det distribuerat system så att dra omkring mängder med I/O är antagligen inte aktuellt.

Om det är för produktion så är det väl inget problem att man inte kan flasha om, eller är tanken att man via samma kommunikationskanal skall kunna ladda ny firmware? Jag skulle nog satsat på enklaste möjliga lösning med den billigaste mcu:n man kan hitta.
I första utvecklingssteget kan man ju köra en större processor så man slipper HV-programmering.