I²C ICs abfragen zwecks GETACK

[MedanoCC]

Olla!

Kurze Frage: Es gibt doch das Problem, dass wenn ein I²C-IC angesprochen werden soll, der aber nicht im Netz hängt, das System beim GETACK stehenbleibt, weil es in eine Endlosschlaufe geht.

Jetzt habe ich irgendwo gelesen, wie man das per ASM umgehen kann, bzw. wie der GETACK Befehl auszusehen hat um nach einer bestimmten Zeit aus der Schlaufe zu springen. Kanns mir denn jemand hier kurz skizzieren oder einen anderen Tipp geben, wie ich erkenne, ob der entsprechende IC im Netz ist bzw. Strom hat ??

Super, danke

MedanoCC

[jörg]

Das Problem tritt auf, wenn Du den System I2C Bus der CC1 benutzt, und dafür die System I2C-Routinen verwendest (I2C_START usw, liegen bei Adressen $08xx).

Wenn Du es vermeiden willst, musst Du eine eigene Routine "WRITE" zum Schreiben verwenden: die muss dasselbe macht wie das Original, aber bei fehlendem ACK nicht wiederholen. Dazu musst Du allerdings auch die I2C_START kopieren. Insgesamt dürften das dann mindestens 30 Bytes Code sein -- ganz schön viel.
Details dazu findest Du im Source-Listing der CC1 Routinen.

Wenn Du nur ein mal am Anfang prüfen musst, ob der I2C Baustein überhaupt da ist, könntest Du das ganze am Anfang des BASIC Programms einmalig als SYS Routine laufen lassen, und im laufenden Betrieb dann die System-Routinen verwenden, um Platz zu sparen.

Eine andere Methode kenne ich nicht.

[MedanoCC]

Hi!

Danke für Deine Antwort. Die Frage ist jedoch noch für mich, wie dann die Routine aussehen muss, da ich ja eine Schlaufe machen muss, die dann jedoch nicht unendlich sondern kontrolliert, d.h. nach einer bestimmten Zeit abbrechen muss. Wie sieht das denn dann aus ? Kann auch ein Basic-Script sein.

Könntest Du das vorgehen kurz skizieren ?


Danke - MedanoCC

[jörg]

OK, nur damit wir uns richtig verstehen:

1. Du willst den System I2C Bus der CC1 für Deine Peripherie mitbenutzen, z. B. einen PCF8574 hinhängen

2. Dafür hast Du ein Assembler-Programm, das die System-Routinen I2C_Start, I2C_Write, I2C_Read_Last usw. aufruft.
Dein Assembler-Programm sieht dann (immer) in etwa so aus:

; EEPROM vom I2C Bus abmelden
jsr I2C_ReadLast

; I2C Bus starten und mein device selektieren
ldx xxx (z. B. $A1)
jsr I2C_Start

; meine Daten zu diesem device senden
ldx xxx (z. B. $A3)
jsr I2C_Write

; vielleicht nochmal was senden

; mein Device abmelden
jsr I2C_Stop

; das EEPROM wieder anmelden
xxxx

3. Problem ist die System Routine I2C_Write, die auch noch mal in I2CStart enthalten ist.
Das sieht im Original so aus:

;------------------------------------------------
; void I2C_Start ( unsigned char devadr );

	global	_I2C_Start
	signat	_I2C_Start,4216
;------------------------------------------------

; Startbedingung nach Init, Write oder Stop moeglich
; Vorbedingung: SCL lo (nach Write) oder 
;               SCL hi und SDA hi (nach Init und Stop)
; SCL und SDA als Ausgang, SDA nach low ziehen
; = Startbedingung
; warten

_I2C_Start	BSET	SDA,DIR		; SDA hi ausgeben
		BSET	SDA,PORT	; Vorbereiten der Startbed.
		BSET	SCL,PORT	; SCL hi falls lo
		BCLR	SDA,PORT	; SDA lo -> STARTBEDINGUNG
		BCLR	SCL,PORT	;
		

		; nach jeder Startbedingung wird sofort
		; das Controlbyte geschrieben,
		; also weiter bei I2C_Write
		
;------------------------------------------------
; void I2C_Write ( unsigned char byte );

	global	_I2C_Write
	signat	_I2C_Write,4216
;------------------------------------------------

_I2C_Write	BSET	SDA,DIR		; SDA out
		TXA			; 
		STA	writebuf	; merken fuer retry

		LDX	#8		; init loop
putnextbit	ROLA
		BCC	lobit		; 
		BSET	SDA,PORT	; hi bit
		BRA	writeclock
lobit		BCLR	SDA,PORT	; lo bit

writeclock	BSET	SCL,PORT	; scl hi
		BCLR	SCL,PORT	; scl lo
		
		DEX
		BNE	putnextbit	; loop

		; ACK-Bit lesen
		; Achtung: ACK ist low-aktiv

            	BCLR	SDA,DIR		; sda als Eingang
		BSET	SCL,PORT	; scl hi
		BRSET	SDA,PORT,retrywrite; no ACK -> retry
		BCLR	SCL,PORT
		RTS
		
		; hierher nur bei control byte,
		; wenn EEPROM noch nicht bereit
		 
retrywrite	BCLR	SCL,PORT	; 
		LDX	writebuf
		BRA	_I2C_Start

4. Diese beiden Routinen musst Du jetzt in Deinen Assembler-Source kopieren und anstelle der beiden Systemroutinen aufrufen.

5. Dann muss Du Dir den Teil "ACK-Bit lesen..." anschauen: Genau der Befehl
BRSET SDA, PORT, retrywrite
stört Dich: Wenn kein ACK da ist, wird unentwegt dasselbe Byte nochmal geschrieben.

6. Jetzt musst Du Dir überlegen, was in diesem Fall BEI DEINER SCHALTUNG passieren soll.
6.1 Du Kannst Dir zum Beispiel sagen: "Mir ist's egal ob das Byte quittiert wird": dann lässt Du den BRSET einfach weg.
6.2 Oder Du könntest den Befehl über eine Schleife paar (hundert) mal wiederholen, und erst dann aufhören.
6.3 Oder Du könntest das Ergebnis (ACK oder NOACK) an die aufrufende CCBASIC Routine zurückgeben, und die überlegt sich das dann.