Ik heb bij voti een aantal I2C-LCD's gekocht, alleen ik krijg niks op het scherm getekend.

http://www.voti.nl/winkel/p/LCD-9.html

Ik gebruik een 16F819 en heb het schema van project1 gebruikt.

Ik heb het test-programmaatje zo gemaakt dat de communicatie begint na het indrukken van een knop. Als eerst gaat er een ledje branden na het indrukken. Dit ledje moet nadat alles is verzonden weer uit gaan. Dan begint (doet een poging tot ;)) hij met communiceren. Dan als alles klaar is moet het ledje uit en gaat hij in een oneidige lus zitten.

MAAR het ledje gaat niet uit en ik krijg ook niks op mijn scherm. Maw hij kan niet met het lcd communiceren.

Dus heeft iemand tips (of voorbeeld-stukjes code) waar je op moet letten bij het sofware-matig communiceren met I2C? Ik doe alles met assembler om het wat makkelijker te maken ;). Van dat andere heb ik geen kaas gegeten.

krijg je een ACQ na het adresseren ? (trekt het display de SDA lijn naar omlaag ?)

het schema in dat voorbeeld is niet zo denderend. Je hebt pull-ups nodig van SDA naar 3v3 en van SCL naar 3v3. betrouw niet op de interne weak pull ups van de processor die je gebruikt.

Ik heb zelf dit schema gebruikt:
http://users.skynet.be/bk317494/015/015.htm
Wel met een andere controller DS89C420 en dan bitbanged I2C. Dit schema werkte het beste, een ander schema werkte ook alleen zag ik vage strepen door het scherm. (verholpen met de spannings deler op de I2C bus met 2 keer 10K weerstanden).
Ik zou eerst zelf controleren of je een I2C signaal krijgt, en of deze klopt.

Tis al gelukt :D. Op een of andere manier krijg ik dat ssp-module niet aan de gang. Ik heb een andere manier gevonden, om zonder open-drain te communiceren: http://users.swing.be/fg/pic/#I2C_M_3pins.
Het werkt wel. Het zal zeker niet de beste manier zijn maar het werkt.

Mooi he ;)
http://www.expandctss.com/upload/index.php?page=download&file=LCD-scherm.JPG

Alleen ik krijg ook vage strepen (zie je alleen als je heeel goed kijkt en contrast niet helemaal goed heb). En ik heb trouwens goed beeld met een spanning op Vlcd tussen de -4,45V en -4,65V ipv -8V.

Alleen heb ik nu een andere vraag.
Bij een acknowledge wordt sda laag getrokken door de slave. Als de slave meer tijd nodig heeft, houdt ie dan sda of clk omlaag? Bij twee site's (waarvan de een is geschreven door iemand met industriele I2C-apparaten op zijn naam) wordt er namelijk gezegd dat sda pas wordt losgelaten wanneer de slave klaar is met het verwerken van de data.

Ik hoop dat sda laag gehouden wordt anders moet ik nog een pin gebruiken om clk in de gaten te houden. Dat zou jammer zijn.

Dit is een vrij simpele I2C slave. Er is geen 'intelligentie' aan boord van het LCD waar processing tijd voor nodig is. Volgens mij kun je zelfs de acknowledge negeren. De slave zal geen delay 'vragen'.

Wat het contrast betreft is mijn ervaring met dit LCD dat de spanning op pin 4 veel meer van invloed is dan de negatieve spanning. Wat staat daar bij jou op?

Ik had dus ook last van vage strepen, dat was bij mij weg met die spannings deler van 2 weerstanden van 10k in de SDA en SCL lijn.
Heeft te maken met +5V van de I2C of pullups in het display wegvloeit.

Op 5 januari 2005 18:46:53 schreef Squant:
Ik had dus ook last van vage strepen, dat was bij mij weg met die spannings deler van 2 weerstanden van 10k in de SDA en SCL lijn.
Heeft te maken met +5V van de I2C of pullups in het display wegvloeit.

Bedoel je dat het ic een beetje gevoed wordt door de pull-up :D en dat de spanning iets zakt (door hoge weerstand pull-up) op het moment dat hij een pixeltje aanstuurt?

Op 5 januari 2005 16:56:28 schreef jojo:
Dit is een vrij simpele I2C slave. Er is geen 'intelligentie' aan boord van het LCD waar processing tijd voor nodig is. Volgens mij kun je zelfs de acknowledge negeren. De slave zal geen delay 'vragen'.

Wat het contrast betreft is mijn ervaring met dit LCD dat de spanning op pin 4 veel meer van invloed is dan de negatieve spanning. Wat staat daar bij jou op?

Ik wou in de toekomst natuurlijk ook eeproms gaan gebruiken hè ;). Het ging me gewoon om het protocol en hierover gaan ze niet echt diep op in, in het manual van philips.

Op pin 4 heb ik 2,78V omdat dit volgens die site gewoon het beste resultaat gaf.

Ps. Ik vond de prijs bij voti zo belachelijk goedkoop dat ik er 5 heb gekocht. Alleen de pootjes waarmee hij aan de print vast klikt zijn bijna allemaal kapot. Maar dan lijm ik hem wel :).
Hebben jullie vergelijkbaar beeld als wat ik heb? Of zou ik anders een fototje van jullie project mogen zien? Als dat niet teveel gevraagd is.

I2C faq ( google hem )

Normaal doet een slave alleen aan ACQ stretching en dat gebeurt aleen bij bepaalde (oude) eeproms zoals de PCF8582

wat wil zeggen dat ze direct een ACQ genereren na het frame ontvangen te hebben. Dus na de laatste clock pulse zal de slave de sda laag trekken. ( soms gebeurt dit pas op het moment dat jij de klok laag maakt.)

De master ( jij dus genereert nu een clock pulse op SCL ( Clock hoog en terug laag )

je moet dus eigenlijk altijd kijken naar SDA vlak voor je de CLK terug laag maakt, en verifieren direct na het laag maken van de clock dat SDA ook terug hoog staat. )

Als de SDA niet hoog komt dan heeft de slave hem nog gevangen. je moet dan wachten.

Nogmaals dit gebeurt alleen bij 1 of 2 oude Ic's die waarchijnlijk toch niet meer te krijgen zijn.

Clock stretching is een techniek die gebruikt word in multimaster om de bus te 'grabben'
Het collision detection mechanisme en arbitering mechanisme werkt als volgt op i2c.

een '0' heeft voorrang op een 1. Als er 2 masters op hetzelfde moment iets op de bus zetten dan is het diegene die die de '0' op de bus zet die zal winnen. Een master moet bij elke 'state change to 1' die hij doorvoert ( in een multimaster omgeving) op de bus verifieren of dit gelukt is. Dus als ik een lijn ( hetzij SDA of SCL )
hoog maak moet ik kijken of die effectief ook terug hoog komt. Indien SDA : kan ik wachten ze zal gelost worden ( extended ACQ phase). Indien SCL : backoff. iemand anders is ook aan het praten op de bus. en ik heb de arbitratie verloren. Ik moet nu wachten tot ik een Stop conditie zie om opnieuw te proberen. Dit mechanisme gaandeert ook dat de master die wel gewonnen heeft rustig verder kan praten. I k heb namelijk zijn data niet verstoord. )

Stel een noodsituatie en een master heeft onmiddelijk de bus nodig. Wat hij kan doen is de SCL lijn laag trekken en wachten tot iedereen de SDA los heeft gelaten. vanzodra de SDA vrij is pak ik die over en zet ze laag. Nu genereer ik een STOP op de bus. De bus is nu vrij en ik kan een transfer cyclus starten.

In een multimaster omgeving ziet een i2c flowchart er zo uit ( is bijna letterlijk te implementeren in software zals ik het hier schrijf )

initiele conditie is SCL en SDA1 ( is de rustconditie )

sub sendbyte(adress,data)
if scl=0 or sda=0 then goto backoff
' check bus state
: retry ' is ook start van procedure
SCL=0
SDA=0 ' start generatie
: sendadress
for x = 0 to 7
SDA=bit adress.x
if adress.x=1 and SDA=0 goto BACKOFF
' arbitratie verloren door andere master
SCL=1
if scl=0 then goto prio_backoff
' arbitratie verloren door prioriteit aanvraag
SCL=0
next
: acqphase
SCL=1
wait for SDA=0
SCL=0
wait for SDA=1 ' ACQ stretch detectie
: sendbyte
for x = 0 to 7
SDA=bit data.x
if data.x=1 and SDA=0 goto BACKOFF
' arbitratie verloren
SCL=1
if scl=0 then goto prio_backoff
' arbitratie verloren door prioriteit
SCL=0
next
: sendstop
SDA=0
SCL=1
SDA=1
exit sub
: backoff '
SDA=1
SCL=1
wait for stop
goto retry
: prio_backoff
' hier wachten we langer omdat een andere master
' prioriteit wilt op de bus
SDA=1
SCL=1
wait for stop
wait 1 second
goto retry
end sub

en hieronder staat een routine waarmee ik een priority event genereer. ik jaag iedereen van de bus af en zet een STOP op de bus. Ik weet dat alle andere masters nu in hun Priority wahtlus zitten en dat alle slaves gereset zijn door het feit dat ze een STOP gezien hebben

sub prio_request

SCL=0
while SDA=0 wend
' op een bepaald moment heeft iedereen gelost
SDA=0 ' ik zet SDA nu laag
' ik zet nu een normale sTOP conditie op de bus
SCL=1
SDA=1
' de bus is nu van mij en alle andere masters zitten
' nu in hun prio_backoff. ik kan nu mijn ding doen
end sub

Tis toch zo een schoon elegant en simpel protocol.

Volgens jou hoef ik dus eigenlijk helemaal niet te kijken of de ack gestretched wordt omdat dat alleen bij eeproms uit de oertijd gebeurt. Maar zou ik dit toch voor de zekerheid willen doen dan moet ik naar sda kijken.

Nogmaals vond ik over dat stretchen weinig in de manual van philips. Maar in de tekeningetjes zag je volgens mij dat de clock gestreched werd.
http://www.expandctss.com/upload/index.php?page=download&file=I2C.JPG

Dat multi-master zal ik toch wel niet gebruiken. Te moeilijk voor mij ;).

Ik heb trouwens wat geknutseld aan de spanningen op pin4 en pin3 ook heb ik de spanningsdeler gemaakt. De lijnen zijn nu weg :D. En ik heb schitterend glashelder beeld. Een spanning van -7,15V op pin4 en 2,38V op pin3 gaf mij het beste resultaat. De lagere spanning op pin3 maakte het resultaat ook minder gevoelig voor de spanning op pin4. Eerst had ik alleen goed beeld als ik een spanning op pin4 tussen de 4,45 en 4,65V had en nu tussen de 10 en 4,3V. Nogal een verbetering dus.

In dat voorbeeld gebeurt dit direct na de ACQ phase omdat de huidige processor inderdaad een hoge prioriteit moet afhandelen.Dit staat letterlijk aangegeven : Clock line held low while interrupts are serviced. ( de slave kan je gedurende de ACQ phase tijdelijk als een 'Master' beschouwen omdat hij de controle heeft. Hij vraagt dus een 'backoff' situatie aan van andere masters )

De ACQ fase is een speciaaltje. Het ander emechanisme wat ik beschreven heb is de gangbare zaak terwijl je gewoon nog bits aan het zenden bent.

Het stukje code wat ik daar gegeven heb doet dit dan ook.

Ik vermoed trouwens dat dit voorbeeldje komt uit de sectie waar twee masters tegen elkaar spreken ( de ene is dan tijdelijk een 'slave' maar heeft mastering capabilities ) Ik ken persoonlijk geen enkel I2C slave IC ( dat geen CPU bevat ) die dit doet.

Heb net ff een datasheet van een willekeurige eeprom van microchip erbij gepakt. Hierin stond dat de eeprom pas gaat schrijven na een STOP. Wil je hierna nog wat doen met de eeprom, dan zal hij helemaal geen acknowledge geven totdat hij klaar is met schrijven. Wil je meerdere bytes achter elkaar schrijven dan bewaart hij dit tot een STOP.

Snap ik dit allemaal goed :D? En zo ja gebeurd dit bij alle (meeste) eeprom's? Wat als je een byte wilt lezen, kan dit wel zo snel of heeft hij hier ook tijd voor nodig.
Als ik dit weet, weet ik genoeg voor voorlopig;). Dan kan ik weer knutselen en experimenteren. Geweldig die µC's, al die mogelijk heden :D.

Jep. er zijn er die zo werken ook ja.
daar kan je tot 4 byte inschuiven ( er is een beperking van 4 byte in een keer. bij de hele grote zoms 8 of 16 byte ) in een keer. Als je dan een STOP op de bus zet dan gaat ie aan de slag. Zolang ie bezig is met zijn interne cyclus zal ie niet reageren op een start

Die chips hebben meestal een extra pin ( ik dacht pin 6 of 7 ) die aangeeft wanneer ie klaar is met zijn ding. )

Kijk eens op de website van xicor ( nu waarchijnlijk intersil ) die hadden vroeger altijd mooeie appnotes staan vor un 24xx familie voor allerhand eprocessoren met sourcecode erbij en al.