Hallo,

Ik heb een systeem ontworpen met een Atmega162 waaraan een aantal devices hangen waarmee via I2C wordt gecommuniceerd. De I2C communicatie wordt uitgevoerd in het hoofdprogramma en werkt prima.

Dit systeem wil ik nu koppelen aan een PC. De communicatie daarmee gaat via RS232. Hiervoor gebruik ik de uart library van Peter Fleury. Die library werkt met interrupts (UART0_RECEIVE_INTERRUPT en UART0_TRANSMIT_INTERRUPT). De uart library werkt ook prima, maar niet in combinatie met de I2C bus. Als er data binnenkomt hangt de I2C bus zich op.

Dat valt op zich wel te verklaren: als die seriele data op het moment komt dat er via I2C wordt gecommuniceerd, dan zal de aanroep van de interrupt routine de timing van I2C in de war sturen, want die wordt dan even onderbroken.

Maar hoe los je zoiets nu op? Als je interrupts zou uitschakelen tijdens de I2C communicatie heb je natuurlijk kans dat je seriele data mist.

Iemand suggesties?

Vast bedankt !!

In principe zou onderbreking van het i2c signaal niet uit mogen maken omdat je master de klok bepaalt. Maar dat is misschien een ideale situatie ... gebruik je ook interrupts voor de i2c communicatie?

De beste oplossing in dit soort situaties is volgens mij in je interrupt functies enkel een globale vlag te zetten die je in je main afhandeld wanneer het jou uit komt. Dan kan je zelf ook je prioriteit bepalen.

[edit]
Dat neemt niet weg dat je dan nog serieele ccommunicatie kunt kwijtraken (door een overflow). Als je het helemaal netjes wilt doen zal je ook handshaking moeten gebruiken.

[Bericht gewijzigd door _Danny_ op (18%)]

--Dat valt op zich wel te verklaren: als die seriele data op het moment komt dat er via I2C wordt gecommuniceerd, dan zal de aanroep van de interrupt routine de timing van I2C in de war sturen, want die wordt dan even onderbroken.--

Ik denk dat je hier gelijk in heb. Ik heb zelf geen ervaring met deze hardware en software maar ik neem aan (omdat je via een uart werkt) dat de uart dit netjes op kan lossen.
1 laat de uart geen interrupt genereren op het moment van ontvangen van data. De uart kan normaal automatisch een x aantal bytes in zijn buffer (zie datasheet) zonder problemen ontvangen op de vooraf ingestelde (zo laag mogelijke) waardes.
2 lees dan de uart uit (evt buffers leeghalen) nadat het hele I2C verhaal afgerond is.
nogmaals er zullen vast commandos voor zijn maar je moet dus zelf er naar zoeken. in elk geval commandos zonder interrupt routine.

Falcon

Op 18 november 2009 22:13:47 schreef _Danny_:
In principe zou onderbreking van het i2c signaal niet uit mogen maken omdat je master de klok bepaalt. Maar dat is misschien een ideale situatie ... gebruik je ook interrupts voor de i2c communicatie?

De master bepaalt inderdaad de klok, maar blijkbaar kan de communicatie wel op een zodanig tijdstip worden onderbroken dat het fout gaat. Zolang ik geen data via de seriele interface stuur gaat de I2C communicatie niet fout (dagen achtereen elke 100mS communicatie zonder probleem).

Voor de I2C gebruik ik geen interrupts..

Op 18 november 2009 22:22:46 schreef Falcon79:
1 laat de uart geen interrupt genereren op het moment van ontvangen van data. De uart kan normaal automatisch een x aantal bytes in zijn buffer (zie datasheet) zonder problemen ontvangen op de vooraf ingestelde (zo laag mogelijke) waardes.

Ik zal dit eens gaan proberen. Ik dacht dat een ontvangen byte meteen moest worden gelezen (via interrupt). Ik zal de spec er eens op nalezen. Weet iemand toevallig een uart library die zonder interrupts werkt?

Ik gebruik zelf probleemloos rs232 en i2c op een atmega32.
Daarbij zorg ik er wel voor dat de interrupt van de seriele poort de data in een ringbuffer zet. Zodra het systeem er aan toe is laat ik de data verwerken.
Tijdens de communicatie via i2c wordt er slechts af en toe een byte opgeslagen. I2c is vrij traag en hoort daar geen last van te hebben.

Ik kan je de code voor een fifo buffer hier wel posten als je daar belangstelling voor hebt.

[Bericht gewijzigd door hennep op (12%)]

Op 18 november 2009 23:13:30 schreef hennep:
Ik gebruik zelf probleemloos rs232 en i2c op een atmega32.
Daarbij zorg ik er wel voor dat de interrupt van de seriele poort de data in een ringbuffer zet. Zodra het systeem er aan toe is laat ik de data verwerken.
Tijdens de communicatie via i2c wordt er slechts af en toe een byte opgeslagen. I2c is vrij traag en hoort daar geen last van te hebben.

Interessant. Bij mij wordt de data ook gebufferd via de interrupt. Als je zegt dat I2C vrij traag is, op welke snelheid laat je dit lopen dan? Ik gebruik fast mode (400Khz).

mijn geheugen liet me in de steek, ik moest even in de header file kijken:

/* I2C clock in Hz */
#define SCL_CLOCK  100000L

De uart code kun je trouwens hier oppikken:
http://hennep.xs4all.nl/elec/uart.c
http://hennep.xs4all.nl/elec/uart.h

Ik heb de rs232 code ergens van een ander forum gepikt en de fifo daar zelf aan toegevoegd. mogelijk is dit niet de laatste versie, die heb ik dan niet thuis en zal ik later klaarzetten.

Dit gebruik ik om i2c aan te sturen:
http://hennep.xs4all.nl/elec/i2c.c
http://hennep.xs4all.nl/elec/i2c.h

Heb ik ook ergens anders gepikt (wat ben ik toch slecht)

[Bericht gewijzigd door hennep op (16%)]

Op 18 november 2009 23:29:31 schreef hennep:
mijn geheugen liet me in de steek, ik moest even in de header file kijken:

/* I2C clock in Hz */
#define SCL_CLOCK  100000L

Bedankt voor die code! Ik zie dat zowel je I2C clock, en je baud rate (19200) beduidend lager zijn dan bij mij (400Khz en 115k2). Misschien kan ik ook wel met lagere snelheden uitkomen. Maar een echte garantie dat het dan altijd goed gaat heb je dan natuurlijk nog niet, of denk je van wel? Ik zoek eigenlijk naar een 100%-zeker-geen-conflict oplossing.

Ik weet niet of vertragen van de communicatie helpt, maar wat let je om het eens te proberen.
Wat betreft de 100% garantie, die heb je alleen als je dat zelf in het protocol opneemt. Ik verstuur mijn data met een header, een lengte byte, de data zelf en een xor byte aan het eind. als het xor byte niet overeenkomt met de voorafgaande data dan stuur ik die data opnieuw, net zo vaak als nodig is.

Ik zal bij mij de snelheden eens opvoeren. Als het bij mij ook gaat hangen dan weten we dat avr dat niet aan kan. Ik werk dinsdagavond weer aan mijn project, even geduld dus.

Ik zie net dat ik voor de baudrate 19200 heb gekozen vanwege de lage afwijking. Er staat in de datasheet een tabel met daarin baudrates bij verschillende clockfrequenties. Ik werk met de interne resonator, op 8MHz dus, en dan heb ik bij 19200 baud een afwijking van 0.2%
Als ik 115k zou gebruiken dan is de afwijking 8.5%

een I2C bus moet er gewoon tegen kunnen dat je processor even met iets anders bezig is, zeker als het de master is.

Wat je zou kunnen doen, is de I2C bus ook interrupt-based afhandelen, en in de ISR van de UART de global interrupt enable weer aanzetten, zodat de I2C interrupt ook nog door kan komen. Je moet dan wel eerst de UART interrupt uitzetten, en aan het eind van de routine weer terug aan. Let daarbij wel op de grootte van de stack; worst-case wordt deze een stuk groter dan wanneer je geen geneste interrupts krijgt.

Dus in de ISR eerst de UART interrupt uit, de global interrupt enable aan, dan je ding gaan doen, de global interrupt enable weer uit zetten, en de UART interrupt weer aan. Dit is vooral handig als de interrupt routine nogal veel tijd kost.

Overigens heeft de ATMEGA162, voor zover ik weet, geen hardware FIFOs voor de UART.

Op 18 november 2009 23:47:26 schreef hennep:
Ik zie net dat ik voor de baudrate 19200 heb gekozen vanwege de lage afwijking. Er staat in de datasheet een tabel met daarin baudrates bij verschillende clockfrequenties. Ik werk met de interne resonator, op 8MHz dus, en dan heb ik bij 19200 baud een afwijking van 0.2%
Als ik 115k zou gebruiken dan is de afwijking 8.5%

Komt ook bekend voor. Ik gebruik een 16Mhz kristal, en dan is de afwijking bij 115k -3.5%. Grotere afwijking dan geadviseerd, maar nog geen problemen gezien.

Ben benieuwd of je dezelfde problemen gaat zien als ik als je naar hogere snelheden gaat. Ik denk overigens dat alleen de I2C snelheid van invloed kan zijn, want de bus loopt op het eerste ontvangen seriele byte al vast: op de 1e interrupt dus. Verlagen van de baudrate zal dan m.i. niet veel invloed hebben. De interrupt zal hooguit iets later komen omdat het onvangen van de bits iets langer duurt. Ik zal er toch eens mee testen en laat het nog weten.

[Bericht gewijzigd door maxva op (28%)]

Dat zou ook geen i2c problemen mogen geven. Hooguit een minder betrouwbare rs232 overdracht.

De code die ik heb toegevoegd aan uart.c maakt overigens geen gebruik van een hardware fifo zoals SparkyGSX veronderstelt. Ik heb zelf een buffer van 55 tekens gedeclareerd. Die grootte kun je aanpassen met de regel: #define BUFSIZE 55

Op 19 november 2009 13:09:10 schreef hennep:
Dat zou ook geen i2c problemen mogen geven. Hooguit een minder betrouwbare rs232 overdracht.

komt overeeen met wat ik net ge-edit heb aan mijn vorige post (elkaar gekruist). We zitten op dezelfde golflengte...

Wijkt jouw initialisatie van i2c af van de code die ik in i2c.c heb staan (zie mijn tweede bijdrage aan dit draadje)

[Bericht gewijzigd door hennep op (13%)]

Op 19 november 2009 00:13:11 schreef SparkyGSX:
een I2C bus moet er gewoon tegen kunnen dat je processor even met iets anders bezig is, zeker als het de master is.

Dat was inderdaad ook mijn gedachte. De praktijk is helaas anders. Ik wil dit binnenkort is in detail gaan bekijken met een logic analyzer: triggeren op de seriele interrupt, en I2C signalen vlak ervoor en erna bekijken en vergelijken met communicatie zoals het gaat zonder dat er seriele data binnenkomt.

Bedankt voor het idee over het gebruik van een 2e interrupt. Wat je dan echter toelaat is dat I2C interrupts worden afgehandeld tijdens het uitvoeren van de seriele interrupt of niet? Hou ik dan niet een vergelijkbaar probleem?

Op 19 november 2009 13:16:07 schreef hennep:
Wijkt jouw initialisatie van i2c af van de code die ik in i2c.c heb staan (zie mijn tweede bijdrage aan dit draadje)

Ik heb de code niet bij me. Zal het binenkort laten weten.

Ik heb even zitten rekenen naar aanleiding van de gedachtengang over dubbele interrupts.
Een byte versturen bij 400kHz kost aan tijd 20 us, wordt door de twi interface hardwarematig verzorgt.
Een byte versturen bij 115 kbaud kost 70 us, er treedt een interrupt op per byte.
Jouw controller draait op 16 MHz dus een instructie duurt 62.5 ns
Je kunt dus 320 instructies draaien per byte dat via i2c over de lijn gaat en per serieel byte draait de controller 1120 instructies.
Timing kan nooit het probleem zijn.

Je schrijft ook dat de i2c bus zich ophangt, niet dat er bytes wegvallen. Zelfmoordneigingen zijn lastig te behandelen, ook bij controllers.

Ik lees net dat de uart-code die jij gebruikt van Peter Fleury is. De i2c code die ik gebruik is ook van hem. Mogelijk kun je hem een vraag sturen per email of hij dezelfde problemen heeft gehad. Zijn emailadres staat in i2c.c

Op 19 november 2009 13:42:30 schreef hennep: Je schrijft ook dat de i2c bus zich ophangt, niet dat er bytes wegvallen. Zelfmoordneigingen zijn lastig te behandelen, ook bij controllers.

Klopt. Wat ik bedoel met ophangen is dat er geen communicatie meer mogelijk is. In het hoofdprogramma vraag ik elke 100mS de tijd op van een I2C RTC chip (1307), en een analoge waarde ingelezen door een zelfgebouwde I2C slave (met een Attiny461) en zet die op de aangesloten LCD. Het weergeven van datum, tijd en analoge waarde gaat goed zolang er maar niks binnenkomt op de seriele poort. Want dan stopt de I2C bus (geen data meer terug van de slaves). Seriele data komt nog wel gewoon binnen (wordt ook weergegeven op de LCD).

Ik zal Peter Fleury eens een email sturen. Kijken wat hij ervan denkt.

Op 19 november 2009 13:42:30 schreef hennep:
Ik heb even zitten rekenen naar aanleiding van de gedachtengang over dubbele interrupts.
Een byte versturen bij 400kHz kost aan tijd 20 us, wordt door de twi interface hardwarematig verzorgt.

Aha, hier hebben we een essentieel verschil: de Atmega32 heeft TWI, en de Atmega162 niet. Ik heb dan ook de assembly code uit Peter Fleury's library gebruikt die I2C in software implementeert. Dus dat vergt meer processor cycles dan op de Atmega32.

Dan gebeurt er in die code nogal wat. Ik heb zelf eens i2c code geschreven voor een 89c2051 van atmel in 8051 assembler. Dat is wel even iets anders dan een register laden voor een hardware twi.

Heb je al geprobeerd om clock en data op een andere poort aan te sturen?
Hoe wordt de timing geregeld, kan dat met een andere timer?
Dat is misschien niet de netste oplossing maar als het werkt...

Op 19 november 2009 20:39:08 schreef hennep:
Dan gebeurt er in die code nogal wat.

Tja, daar heb ik niet zo'n goed beeld van. Ik heb een logic analyzer, en ga dadelijk eens wat meten. Ik hoop vanavond wat resultaten te kunnen posten.

[Edit]
Net gemeten hoe lang het duurt om een lees commando naar de RTC chip te sturen, om vervolgens datum en tijd te lezen (7 bytes) en te converteren naar decimale waarden. Totaal 299uS. Het op de LCD zetten van de waardes duurt ongeveer twee keer zo lang. Totaal dus minder dan 1mS. Kun je dus zo'n honderd van dergelijke acties doen als je 10x per seconde een update wilt. Valt nogal mee dus.

[Edit 2]
Het versturen van een commando naar, en lezen van 1 byte van m'n zelf gecreerde slave (Attiny461) duurt in totaal 148uS.

[Edit 3]
De UART interrupt routine om het ontvangen byte in de buffer te plaatsen duurt 1,4uS. Toch ook niet echt een eeuwigheid...

Dat verklaard natuurlijk alles: als de TWI softwarematig wordt gedaan, zonder het gebruik van timers of timer interrupts, gaat het helemaal mis als je daar tussendoor een interrupt routine uitvoert die even duurt. Ik denk dat je het probleem zou kunnen verminderen of helemaal verhelpen door de UART niet interrupt-driven te doen, als is dat zeker geen elegante oplossing.

Het beste is waarschijnlijk om een controller te gebruiken met een hardware TWI interface.

Op 19 november 2009 21:36:07 schreef SparkyGSX:
Dat verklaard natuurlijk alles: als de TWI softwarematig wordt gedaan, zonder het gebruik van timers of timer interrupts, gaat het helemaal mis als je daar tussendoor een interrupt routine uitvoert die even duurt.

Kun je misschien verklaren waarom het dan helemaal mis gaat? Tijdens het uitvoeren van de interrupt routine blijven de CLK en DATA lijn toch in de toestand waarin ze waren op het moment dat de interrupt optrad? Het enige dat er m.i. dan kan gebeuren is dat de pulsen wat langer worden, nl de tijd die de interrupt duurt. Is dat per definitie een probleem?

Oops, wilde geen nieuwe post doen maar een edit. Ik weet niet of en hoe je een post kunt weghalen...

[Bericht gewijzigd door maxva op (90%)]