I2C-Irq-Interupt für ARM-Microcontroller

[Alex T. (mikro_step)]

Hallo,
ich möchte vom ARM-LPC2xxx-Mikrocontroller an LCD-Display über ein 
I2C-Bus Daten schicken, also "Bilder auf LCD-Display übertragen" und 
habe ein Beispiel für Datenübertrageung über ein I2C-Bus, aber nicht für 
LCD, bei NXP gefunden:

#include"LPC210x.h"
void Initialize(void);
/* I2C ISR */
__irq void I2C _ISR(void);
/* Master Transmitter states */
void ISR_8(void);
void ISR_18(void);
void ISR_28(void);
/*************************** MAIN ************************/
int main(){
   /* Initialize system */
   Initialize ();
   /* Send start bit */
   I2C ONSET=0x60;
   /* Do forever */
   while(1)
   {      IOCLR=0x40;
      IOSET=0x40;   }
}
/*************** System Initialization ***************/
void Initialize()
{
   /* Remap interrupt vectors to SRAM */
   MEMMAP=0x2;
   /* Initialize GPIO ports to be used as indicators */
   IODIR=0xF0;
   IOSET=0xF0;
   /* Initialize Pin Connect Block */
   PINSEL0=0x50;
   /* Initialize I2C */
   I2CONCLR=0x6c;/* clearing all flags */
   I2CONSET=0x40; /* enabling I2C */
   I2SCLH=0xC; /* 100 KHz */
   I2SCLL=0xD;
   /* Initialize VIC for I2C use */
   VICINTSEL=0x0; /* selecting IRQ */
   VICINTEN= 0x200; /* enabling I2C */   
   VICCNTL0= 0x29; /* highest priority and enabled */
   VICVADDR0=(unsigned long) I2C_ISR;   
   /* ISR address written to the respective address register*/
}
/********************** I2C ISR **************************/
__irq void I2C_ISR()
{
   int temp=0;
   temp=I2STAT;
   switch(temp)
   {
      case 8:
         ISR_8();
         break;
      case 24:
         ISR_18();
         break;
      case 40:
         ISR_28();
         break;
      default :
         break;
    }
VICVADDR=0xFF;
}
/* I2C states*/
/* Start condition transmitted */
void ISR_8()
{
   /* Port Indicator */
   IOCLR=0x10;
   /* Slave address + write */
   I2DAT=0x74;
   /* Clear SI and Start flag */
   I2CONCLR=0x28;
   /* Port Indicator */
   IOSET=0x10;
}
/* Acknowledgement received from slave for slave address */
void ISR_18()
{
   /* Port Indicator */
   IOCLR=0x20;
   /* Data to be transmitted */
   I2DAT=0x55;
   /* clear SI */
   I2CONCLR=0x8;
   /* Port Indicator */
   IOSET=0x20;
}
/* Acknowledgement received from slave for byte transmitted from master. Stopcondition is transmitted in this state signaling the end of transmission */
void ISR_28()
{
   /* Port Indicator */
   IOCLR=0x80;
   /* Transmit stop condition */
   I2CONSET=0x10;
   /* clear SI */
   I2CONCLR=0x8;
   /* Port Indicator */
   IOSET=0x80;
}

Ich bin ein Anfänger und meine Frage wäre: findet die vollstendige 
Datenübertragung(Startbit, Slaveadresse+W,Daten,Stopbit) nur ein mal 
statt oder die wiederholt sich regelmasig? Ich habe ein 
Versändnisproblemm und weiß nicht wie Interupt bei Datenübertragung in 
Hardware funktionirt :(
Danke im voraus.

[Tilo (Gast)]

Handbuch lesen :)

Dort steht normalerweise drin, wodurch der IRQ ausgelöst wird. Pauschal 
lässt sich deine Frage nicht beantworten.
Vermutlich wird es so sein, dass der IRQ ausgelöst wird, wenn das 
TX-Register gerade am leer werden ist und neu befüllt werden darf.

Es ist irreleveant, ob an I2C ein LCD oder etwas anderes angeschlossen 
ist. Wichtig sit für dich, wie die Daten kodiert werden müssen. Das 
steht im Handbuch des LCD drin.

[Alex T. (mikro_step)]

Tilo, danke für die Antwort,

wie die Daten kodiert werden habe ich rausgefunden. So wie ich verstehe, 
brauche ich die Daten regelmäßig in einen bestimten Zeitabstand an 
LCD-Display zu schicken. Kann man so was mit Interupt machen? Geht das 
nur mit Hilfe des Timers? Kann man das auch ohne Timer machen? Z.B. in 
diesem Fall(das Programm oben)? Werden die Daten hier nur ein mal 
abgeschickt und dann läuft die while-Schleife oder die Übertragung wird 
wiederholt?

[Peter D. (peda)]

Ich würde das I2C erstmal in Software machen, also ganz einfach mit 
Portpin wackeln.
Und erst, wenn das LCD damit funktioniert, kann man über Interrupts 
nachdenken.

Wenn das LCD anderen Modies kann (8Bit, UART, SPI), würde ich die 
erstmal nehmen.

Denn I2C ist nicht gerade das einfachste Interface, wenn man noch nie 
damit gearbeitet hat.
Daher würde ich I2C erstmal mit einfachen ICs anfangen, z.B. PCF8574(A) 
PIO oder LM75 Sensor.


Peter

[Tilo (Gast)]

Peters Tip mit den einfachen ICs ist nicht schlecht.
Bei deinem LCD kommen noch Timings ins Spiel. Wenn der Bus nicht läuft, 
wird das eklig zum debuggen.
Auf Software-SPI würde ich verzichten, aber das ist geschmackssache. Bei 
Hardware muss man sich darüber im klaren sein, wie Start und Stop Bits 
erzeugt werden. Ich hab I2C bei einem ADUC7000 verwendet. Der generiert 
die Bits automatisch. So bald der TX-Fifo leer läuft, wird das Stop-Bit 
automatisch erzeugt. Werden die Daten nicht rechtzeitig nachgelifert, 
geht das böse aus.

Ansonsten: Wenn Daten mit festen Timing gesendet werden sollen brauchst 
du einen Timer oder eine andere Zeitquelle.

[Alex T. (mikro_step)]

Danke für die Tipps,
ich kann aber nicht auf IC verzichten, es geht einfach nicht:( So ist 
die Aufgabe. Mein LCD hat nur I2C-Bus. Ich habe jedoch schon ein paar 
Beispiele gefunden, für mein Mikrocontroller und für mein LCD.. jetzt 
möchte ich die für meine Aufgabestellung anpassen

Tilo schrieb:
> Ansonsten: Wenn Daten mit festen Timing gesendet werden sollen brauchst
>
> du einen Timer oder eine andere Zeitquelle.

Danke für den Tipp, also ich werde ein Zähler für Timer implementiren. 
So wie ich jetzt verstanden habe, die Übertragung aus dem obengenannten 
Beispiel wird nur einmal ausgeführt. Ich möcht aber die Bilder an 
LCD-Display regelmäßig schicken..