Wie heeft een idee hoe ik het beste meerdere AVR's aan elkaar kan knopen? Één AVR gaat fungeren als Master die de anderen bestuurd, maar de andere AVR's moeten wel wat terug kunnen geven. Eventueel moet een PC de bus kunnen lezen via de Master AVR.
Ik zit te denken aan TWI(I2C) of RS485 ofzo, maar ik heb helaas niet genoeg ervaring/kennis van deze bussen.
Is het bijvoorbeeld mogelijk om bij een I2C bus automatisch adressen te laten toevoegen (eerst kijken wat er al aan adressen op de bus zitten dan het eerstvolgende adres gebruiken), of moet dat altijd hardwarematig en vooraf ingesteld?
timmie
niet met me uitspraken(of opmerkingen) eens mail me.K8048 guide
ik heb de ballen verstand niet van AVR's of van de genoemde bussen maar kan je nix op maat maken voor jezelf?
mssn ook makkelijk te vertellen om welke avr's het gaat het aantal en wat nog meer voor vreemde dingen een rol spelen
Op 15 december 2006 22:10:22 schreef timmie:
ik heb de ballen verstand niet van AVR's of van de genoemde bussen maar kan je nix op maat maken voor jezelf?mssn ook makkelijk te vertellen om welke avr's het gaat het aantal en wat nog meer voor vreemde dingen een rol spelen
Het begint in ieder geval met 1 Master AVR en 3 Slaves. Welke AVR's het worden: voor de Master een Mega32/64/128 ofzo, voor de Slaves zal het wel een Tiny.. worden.
De communicatie hoeft niet snel te zijn en de afstanden zijn kort.
De Tiny's detecteren kortsluiting en moeten dan een karakter op de bus zetten zodat de master weet dat er een kortsluiting is opgetreden (ff in het kort verteld)
timmie
niet met me uitspraken(of opmerkingen) eens mail me.K8048 guide
moet toch te doen zijn met de uart of zie ik dat verkeerd
dan kan je makkelijk de data versturen van slave naar master
en van de master naar slave hoeft ookk geen probleem te zijn in principe
[Bericht gewijzigd door timmie op ]
Op 15 december 2006 22:15:31 schreef timmie:
moet toch te doen zijn met de uart of zie ik dat verkeerd
Ja waarsch wel maar ik heb daar geen verstand van! En toch wil ik het een keer leren! Alle tips zijn welkom.
Timmie bedankt voor je snelle reacties! 
timmie
niet met me uitspraken(of opmerkingen) eens mail me.K8048 guide
no problem
oke ff snel gedacht van mij hoor maar:
je gooit van de slave naar master het volgende:
startbit-adresbit(dus welke slave)-foutcode-stopbit
contacteer me anders ff op msn dat legt voor mij in ieder geval makkelijker uit,als je niet snapt wat ik bedoel
[Bericht gewijzigd door timmie op ]
Atmel heeft application notes over I2C master en slave implementaties, zoek hier even tussen:
http://www.atmel.com/dyn/products/app_notes.asp?family_id=607
als dit je eerste AVR kennismaking is is dit wel een beetje hoog gegrepen, probeer eerst eens een ledje te laten pinken...
Zoals reeds opgemerkt kan je de UART of I2C gebruiken
Hangt alles dan nog af welke programmeertaal je gaat gebruiken ook.
BASCOM heeft standaard instructies om die poorten te besturen.
WilToyo
Maak me niet gek, ik ben al gek.
Waarom wil je AVR's aan elkaar knopen?
I2C is wel het makkelijkste, Met de UART is ook wel mogelijk, maar dan zul je zelf een soort protocol moeten verzinnen. En I2C is erg gemakkelijk zeker als het er al hardwarematig op zit.
Op 15 december 2006 22:25:05 schreef madwizard:
Atmel heeft application notes over I2C master en slave implementaties, zoek hier even tussen:
http://www.atmel.com/dyn/products/app_notes.asp?family_id=607
Die heb ik gezien ja, maar ik kom er niet uit. En voordat ik dat helemaal ga uitzoeken wil ik eigenlijk eerst weten of de bus eigenschappen voldoen aan mijn eisen zeg maar.
Zoals timmie zegt moet ik dus een adres meegeven. Is het niet gewoon mogelijk om 'iets' op de bus te zetten zodat elk device er wat mee kan zonder het specifiek naar één AVR toe te sturen??
Op 15 december 2006 22:29:00 schreef shortcircuit:
als dit je eerste AVR kennismaking is is dit wel een beetje hoog gegrepen, probeer eerst eens een ledje te laten pinken...Zoals reeds opgemerkt kan je de UART of I2C gebruiken
Hangt alles dan nog af welke programmeertaal je gaat gebruiken ook.BASCOM heeft standaard instructies om die poorten te besturen.
Dit is zeker niet mijn eerste kennismaking met AVR, dat ledtoggle verhaal heb ik wel gehad. Maar dit is wel mijn eerste kennismaking met communicatie tussen AVR's. Eigenlijk moet je elk nieuw onderdeel weer leren. Dus je kunt me eigenlijk geen AVR beginner noemen 
De programmeertaal is C
Ik denk dat jij meer moet afvragen wat voor toepassing wil deze bus systemen gaan gebruiken. I2C zal het inderdaad het bedenken van een protocol versimpele aangezien je gebruik kan maken van de adressering van I2C. Daarin tegen zal UART vele malen sneller zijn en dus geschikter zijn bij snelle communicatie. Je kan het natuurlijk ook anders aanpakken, zoals ik voor een project heb gedaan en dat is gewoon weg UART en I2C(bit banging) combineren. Het enigste wat dan natuurlijk niet kan is dat je de slave devices tegelijk I2C en UART maakt.
WilToyo
Maak me niet gek, ik ben al gek.
Op 15 december 2006 22:33:43 schreef SMD lover:
Zoals timmie zegt moet ik dus een adres meegeven. Is het niet gewoon mogelijk om 'iets' op de bus te zetten zodat elk device er wat mee kan zonder het specifiek naar één AVR toe te sturen??
Als alle AVR's steeds hetzelfde moeten ontvangen kun je gewoon alle UART's aan elkaar knopen zonder dat je met adressen hoeft te werken. Als je het op deze manier doet is de UART het makkelijkste. Wel moet je voor zorgen dat op deze manier de master alleen maar hoeft te zenden en de slaves niet, als dat niet het geval is ga je geheid problemen krijgen.
Beste SMDlover,
Als je de mogelijkheid hebt je controllers ook in een hogere programmeertaal (BASIC oid) te programmeren, dan heb ik misschien mogelijk iets van een oplossing voor je (of althans een aanpak in die richting).
Ik heb namelijk een complete netwerkarchitectuur voor microcomntrollers ontwikkeld (hardware en software), gebaseerd op 1 master en een onbeperkt aantal nodes. Alle nodes kunnen met elkaar praten. Een succesvolle test heb ik uitgevoerd tussen twee nodes met 20 meter kabel ertussen. Deze architectuur is waarschijnlijk nog utgebreider dan je nu nodig hebt, ik voer namelijk zowel power als communicatie over slechts twee verwisselbare lijntjes. Met aparte powerlijnen kun je de hardware aanmerkelijk versimpelen, maar de software grotendeels gebruiken.
Ik heb eea. aangekondigd in een eerdere posting op CO onder de sectie Software en Interfacing:
http://www.circuitsonline.net/forum/view/40266
Het complete document en bijbehorende software staat op de volgende website:
http://www.kranenborg.org/ee/picaxe/twowirenetwork.htm
het pdf-document beschrijft de gehele architectuur (hardware, protocol, software ed.)
Merk op dat ik PICs met een ingebouwde BASIC interpreter gebruik, de zogenaamde PICAXE controllers. Aangezien het hele netwerk protocol in BASIC is geschreven, kan het gemakkelijk naar een andere taal overgezet worden. Het lijkt me sowieso verstandig dit soort complexere zaken in een hogere programmeertaal te implementeren.
Voor nader info over de door mij gebruikte PICAXEs zie de volgende link:
http://www.circuitsonline.net/forum/view/27155/
Met vriendelijke groet,
Jurjen Kranenborg
http://www.kranenborg.org/jurjen
Op 15 december 2006 22:07:32 schreef SMD lover:
Ik zit te denken aan TWI(I2C) of RS485 ofzo, maar ik heb helaas niet genoeg ervaring/kennis van deze bussen.Is het bijvoorbeeld mogelijk om bij een I2C bus automatisch adressen te laten toevoegen (eerst kijken wat er al aan adressen op de bus zitten dan het eerstvolgende adres gebruiken), of moet dat altijd hardwarematig en vooraf ingesteld?
Beide bussen zijn in principe bruikbaar, I2C meer voor de korte afstand en RS485 ook voor langere afstanden.
Voor beide geldt echter dat je niet 'automatisch' adressen kunt toevoegen, je zult daar dus zelf een algorithme voor moeten bedenken/implementeren.
Afhankelijk van de implementatie van de I2C controller of de UART kun je gewoon de adressen zien die langskomen en de data uitlezen ('meekijken' zogezegt).
Bij UART's is het waarschijnlijk wel wat makkelijker om een collision detect systeem in te bouwen omdat je direct kunt teruglezen wat er op de bus gebeurt. (De physical layer van CAN is daarvoor nog beter geschikt, en kun je zonder meer uitwisselen met de PL van RS485.) Dat kan nuttig zijn bij het dynamisch bepalen van de adressen van de nodes.
Doe het op basis van de UART (even er vanuit gaande dat de tiny's die je uitgezocht hebt die ook hebben). Dat is makkelijk programmeren, doorgaans snel zat en de te overbruggen afstand is afhankelijk van wat je er als driver achter hangt. Als je het moet gaan bit-bangen, wordt het al wat minder leuk, maar is het nog steeds goed te doen.
Zelfs 'plain ttl' zou moeten werken, als de Tx van alle slaves open collector (om in TTL style te blijven) doet.
Afhankelijk van de te overbruggen afstanden ('kort' is een rekbaar begrip...) en de storende invloeden in je omgeving, kun je daar wat leuks voor verzinnen.
Als protocol gebruik je polling (om het simpel te houden). Nadat je een slave gepolled hebt, heeft deze een vooraf bepaald window de tijd voor response. Zo voorkom je busconflicts. Lengte van je window afhankelijk maken van je slave, maar als zo'n ding op 16MHz loopt moet een paar mS genoeg zijn (ja, de AVR kan het ook in een paar uS; je zou eens uit moeten rekenen hoe je met je UART uit komt bij de gekozen bitrate).
Als je master 'idle' is, kan deze niet bestaande nummers pollen. Als daar response op komt, hangt er 'ineens' wat aan. Als je nummertoekenning automagisch wilt laten doen, geeft je devices een default nummer (dan hoeft de master alleen daar naar te kijken...) en maak je een commando dat dat gewijzigd kan worden. Daarna uiteraard wel in EEPROM zetten. Enige beperking is dat je maar 1 nieuw device tegelijk aan je bus mag hangen. Als ik je eisen zo zie, zal dat denk ik geen probleem zijn.
Een andere mogelijkheid is iet ah-la 1-Wire implementeren. Maxim heeft een leuke manier van 'network discovery' bedacht, werkt best geinig. Naar mijn idee is dat nodeloos ingewikkeld voor jouw doel. Idem voor I2C.
stecj366
Sonar is meer dan Ping...
Of je gaat inderdaad voor de UART, maar je zorgt ervoor dat niemand zo maar (slaves dus) wat gaat zened. Dus je maakt een echte M/S bus. De master stuurt bv eerst een preamble character, dan het adress vd slave, en de slave gaat dan zenden. De andere slaves moeten dan hun mond houden, tot ze zelf opgeroepen worden
Greetz
Op 16 december 2006 06:04:01 schreef Marco69:Als je master 'idle' is, kan deze niet bestaande nummers pollen. Als daar response op komt, hangt er 'ineens' wat aan. Als je nummertoekenning automagisch wilt laten doen, geeft je devices een default nummer (dan hoeft de master alleen daar naar te kijken...) en maak je een commando dat dat gewijzigd kan worden. Daarna uiteraard wel in EEPROM zetten. Enige beperking is dat je maar 1 nieuw device tegelijk aan je bus mag hangen. Als ik je eisen zo zie, zal dat denk ik geen probleem zijn.
Dit zou idd een leuke oplossing kunnen zijn! Maar ik ben wel echt een beginner met UART en I2C. Marco als ik me goed herinner heb jij wel eens vaker berichten gepost over AVR en C of zit ik nu fout? Misschien heb je een UART source voorbeeldje voor me of een handige link?
@Henk B: CAN lijkt me een beetje lastig omdat veel AVR's daar niet standaard mee zijn uitgerust.
@Jurjen: Bedankt voor je interessante post! Ziet er heel mooi uit, power en comm over 2 lijnen! Idd gebruik ik ook een hogere programmeertaal(C). De power hoeft in mijn project niet meegevoerd te worden dus dat heb ik niet nodig. Het gaat bij mij slechts om de communicatie.
@Rhino: Snelheid is niet echt van belang, ook de hoeveelheid data die verzonden gaat worden is uiterst beperkt. Het enige is dat de master sommige functies die een slave uitvoert moet kunnen aan- of uitzetten.
Een hapklaar stuk code... Niet voor het grijpen. Als het er al zou zijn, dan hier zeer zeker in assembly.
De datasheets zijn er meestal vrij duidelijk in, kijk ook eens bij de application notes van Atmel. Evt. wat code snippets van avrfreaks. Ik heb hier zeer zeker niets in C, daar ik op AVRs geen C doe (alleen op 8051 voor het 'lompe' werk).
Op 16 december 2006 22:01:38 schreef Marco69:
Een hapklaar stuk code... Niet voor het grijpen. Als het er al zou zijn, dan hier zeer zeker in assembly.
De datasheets zijn er meestal vrij duidelijk in, kijk ook eens bij de application notes van Atmel. Evt. wat code snippets van avrfreaks. Ik heb hier zeer zeker niets in C, daar ik op AVRs geen C doe (alleen op 8051 voor het 'lompe' werk).
Het gaat me ook niet om een hapklaar stuk code hoor, daar is de lol vanaf. Ik vroeg me alleen af of je misschien een tutorial of zo wist.
Dan heb ik me vergist ik dacht dat je wel wat met C i.c.m. AVR deed.
AVRfreaks is idd een goede misschien 
Dan heb ik me vergist ik dacht dat je wel wat met C i.c.m. AVR deed.
Nope. Heb wel een hoop met C op 'kleine dingen' gespeeld, waarbij 'klein' toch groter is dan AVR. Blijf erbij dat je dit soort uCs gewoon in assembly programmeert. Dan merk je al snel dat een C compiler een C compiler is, waarbij de 'voodoo' die ze uithalen toch vaak sterk op elkaar lijkt.
Voor wat betreft die UARTs: het concept is voor bijna allemaal hetzelfde: Je init die dingen (parameters instellen, globals mbt. queues initen ed., interrupts enable) en vervolgens ben je eigenlijk klaar... Als je wat wilt versturen douw je dat je Tx buffer in, die kijkt of er nog wat uitgaand loopt, zo nee, schuift het eerste character naar de UART. De rest volgt wel als er een interrupt komt dat de eerste weg is (beter gezegd: van het holding register naar het shift register verplaatst is).
Incomming net zoiets: zodra je en interrupt dat er wat binnen is te pakken hebt, douw je dat de Rx buffer in. Uiteraard zit daar nog wat handling bij om overflows te voorkomen en evt. hardware handshaking.
Dat is dan de modulaire opbouw. Vaak schrijf ik het pas voor de applicatie, zeker als het protocol al garandeert dat buffering niet echt nodig is omdat het geen burst achtige zaken kent of toch 'wacht op antwoord'.
Maar eh... Die AVR datasheets zijn toch redelijk uitgebreid? Of heb jij een AVR te pakken waar dat niet zo is? Voor zover mij bekend, lijken alle AVR UARTS heel sterk op elkaar, dus met een stukje over een andere AVR kom je een eind.
Tenslotte... Doe dit soort dingen gewoon in assembly. Je hebt veel directer in de hand wat er gebeurt en dat is voor het begrip erg fijn. Zeker als je van zowel je compiler als van je device weinig weet, kan een 'goedbedoelde' 'optimalisatie' van een compiler (zoals laatst die korte discussie over het gebruik van 'volatile' leuke bijeffecten hebben. Als 'de rest' dan toch in C zou moeten, kun je altijd je assembly daarin intergreren, danwel het nog een keer over doen in C. En zo spannend is AVR assembly nou ook weer niet...
Op het gevaar af een nieuwe discussie te starten:
Ik ben het geheel oneens met het voorgaande advies wat betreft het gebruik van assembly.
Gebruik wel degelijk een hogere programmeertaal en laat assembly links liggen, zeker bij projecten van deze grootte.
Het is een algemeen bekend feit dat de enige manier om productiviteit te vergoten het gebruik van abstractie (i.e. hogere programmeertaal concepten) is. Ikzelf werk bij ABB Research in Zweden, in een omgeving waarin met embedded systems in robotics gewerkt wordt ( en microcontrollers); er is daar werkelijk niemand die in assembly programmeert.
Assembly is alleen nuttig voor bepaalde programma delen die versnelling behoeven, of zeer specifieke configuraties moeten regelen. Dit laatste is echter op veel microcontrollers ook vanuit de hogere programmeertaal te regelen (Op de PICAXEs bijvoorbeeld door via POKE instructies de statusregisters van de PIC te bewerken).
De meeste hogere programmeertalen voor microcontrollers zijn uitgerust met commando's om seriele data te verzenden met het RS232 protocol. Met die basis kun je zelf snel een netwerk protocol implementeren, en naar hartelust experimenteren. Dit is precies wat ik in het genoemde two-wire netwerk artikel gedaan heb: de nodes wisselen pakketjes uit van 4 bytes (zenderID, ontvangerID, byte1, byte2). Je hebt namelijk meer zaken te regelen (polling/interrupts, timing, synchronisatie etc. etc.), en assembly wordt dan een nodeloos onoverzichtelijke zaak. Ik zie veel te veel projecten op CO die door op een te laag abstractieniveau te beginnen dreigen te verzanden in onzinnige details. Ook voor de toekomstige kennisopbouw schiet je er weinig mee op; heel weining mensen die werken met embedded systemen gaan deze (voor het grootste deel) in assembly programmeren.
Met vriendelijke groet,
Jurjen
Op 18 december 2006 00:24:15 schreef kranenborg:Ik ben het geheel oneens met het voorgaande advies wat betreft het gebruik van assembly.
Ik ben het niet geheel oneens met Marco, assembly is wel degelijk handig zeker bij een interrupt handler ofzo. Helaas is assembly voor mij een not done, assembly vraagt veel van de programmeur dus hou ik het ook liever bij C.
Maar interrupts e.d. doe ik toch graag tussen mn c source in assembly.
@Marco: Ik begrijp dat jij het niet zo moeilijk vindt, maar voor een beginner in de basis van communicatie (UART's, bussen e.d.) is het toch niet makkelijk te behappen hoor!
Bedankt voor ieders welgemeende adviezen! Ik heb inmiddels 2 AVR's met elkaar aan het babbelen gekregen, nog even op polling basis, maar straks op interrupts.
Nou vraag ik me alleen nog af hoe ik mn bus makkelijk kan uitbreiden d.w.z. als ik een device toevoeg dat deze automatisch een adres krijgt, en ik die dan ook voor de master bereikbaar maak.
Mn bussysteem moet dus dynamisch worden zodat ik niet alle adressen in de source hoef de definieren.
Heeft iemand een idee?
Het idee van Marco om tijdens idle time alle adressen te pollen lijkt me wel wat, alleen vraag ik me af of dat niet wat te traag gaat worden, ik denk namelijk dat ik tijdens een startup zal moeten doen.
Ik ben het maar voor een klein deel met je eens. Ik heb op 8051 beiden gedaan (doe het eigenlijk nog steeds; van basic heb ik 20 jaar geleden al afscheid genomen, doe dan maar C) en grijp toch vaak terug op assembly, juist omdat dat sneller te implementeren is (alhoewel dat in C prima zou kunnen). Wellicht als je met relatief eenvoudige (en niet te 'timing gerelateerde') zaken bezig bent...
Dat assembly onoverzichtelijk is, is een misvatting. Je code wordt langer (wat de listing aan gaat), maar het hoeft daarmee niet onoverzichtelijker te zijn. Dat is je eigen discipline. Verder gebruik je dat net als in een hogere programmeertaal gewoon met function calls, de syntax is wat anders. Daarnaast kan een beetje compiler overweg met calls naar '3rd party' assembly, dus voor een mix is het ook geen probleem.
De andere kant is natuurlijk dat je geen nieuwe wielen uit moet gaan vinden. Een goed werkende (als in 'doet wat ik wil met een behoorlijke performance') library opnieuw gaan maken is onzin. Echter, goed werkende libraries zijn zeldzaam. Doorgaans heb je teveel configuratie nodig, of kan het nou net niet wat ik wil / zit er veel te veel in; een soort bomen-bos verhaal. Als ze ze vindt: goed bewaren
. Het wordt weer een ander verhaal als je op iets wat een OS heeft aan de gang gaat; voor zover ik begreep is dat hier niet van toepassing (toch?).
Verder kom ik de grootste puinhopen tegen in OO achtige zaken, voornamelijk 'omdat het zo goed was voor de prodcutiviteit' om het in OO (als in 'hoger abstractie niveau') te doen. Dus of dat nou de oplossing is? Het zou mooi kunnen zijn, maar het maakt het je ook erg makkelijk om er een zooitje van te maken, en dat lukt heel vaak erg goed
.
Tenslotte zie je (zeker op 'embedded' niveau) heel sterk de verschillen in code geschreven door mensen die assembly geprogrammeerd hebben en zij die dat niet gedaan hebben. Functioneel doet het vaak wel ongeveer hetzelfde, maar inhoudelijk komen bij de laatste groep relatief vaak constructies voorbij in de categorie 'leuk, maar zo doe je dat dus niet'.
Uiteindelijk is het meeste wat we hier doen toch voor de hobby. Als het om 'productiviteit' ging, is denk ik 95% 'effectiever' door het gewoon ergens te kopen / weg te mieteren en nieuw te kopen (voor de reparatievragen).
[offtopic]Ben wel jaloers op je werkstek...
Het is hier op z'n zachts gezegd druk, om het niet 'vol' te noemen.
Ik was al bang voor een discussie daarover
Toch nog ff een herhaling van mn vraag:
Nou vraag ik me alleen nog af hoe ik mn bus makkelijk kan uitbreiden d.w.z. als ik een device toevoeg dat deze automatisch een adres krijgt, en ik die dan ook voor de master bereikbaar maak.
Mn bussysteem moet dus dynamisch worden zodat ik niet alle adressen in de source hoef de definieren.
Heeft iemand een idee?
Het idee van Marco om tijdens idle time alle adressen te pollen lijkt me wel wat, alleen vraag ik me af of dat niet wat te traag gaat worden, ik denk namelijk dat ik tijdens een startup zal moeten doen.
Noem je dit self-adressing ofzo?? 