MEGA8 ADC Interrupt beeinflusst TWI Interrupt

[Harry_13 (Gast)]

Hallo, ich habe aktuell als kleines Projekt ein per i2c steuerbares 
Display inklusive Tastenfeld. Das Tastenfeld wird mittels 
Widerstandsmatrix und ADC eingelesen. Mein Problem ist allerdings dass 
der ADC zu schnell zu sein scheint, wenn ich nämlich nicht 50ms delay in 
meine Hauptschleife integriere, habe ich keinen Zugriff mehr per I2C.
Und wenn ich den ADC ohne Interrupt einlese also das Bit (1<<ADIE) nicht 
setze, dann stürzt er mir ab sobald ich eine Spannung am ADC anlegen 
habe. Wisst ihr weiter?
Vielen Dank für eure Zeit

#include <stdlib.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <avr/eeprom.h>
#include "twislave.h"
#include "twislave.c"
#include "lcd-routines.h"
#include "lcd-routines.c"
#include <util/delay.h>
#ifndef F_CPU
#define F_CPU 8000000UL
#endif

//###################### Slave-Adresse
#define SLAVE_ADRESSE 0x50                 // Slave-Adresse

//###################### Macros
#define uniq(LOW,HEIGHT)  ((HEIGHT << 8)|LOW)      // 2x 8Bit   --> 16Bit
#define LOW_BYTE(x)          (x & 0xff)          // 16Bit   --> 8Bit
#define HIGH_BYTE(x)         ((x >> 8) & 0xff)      // 16Bit   --> 8Bit


#define sbi(ADDRESS,BIT)   ((ADDRESS) |= (1<<(BIT)))  // set Bit
#define cbi(ADDRESS,BIT)   ((ADDRESS) &= ~(1<<(BIT)))  // clear Bit
#define  toggle(ADDRESS,BIT)  ((ADDRESS) ^= (1<<BIT))    // Bit umschalten

#define  bis(ADDRESS,BIT)  (ADDRESS & (1<<BIT))    // bit is set?
#define  bic(ADDRESS,BIT)  (!(ADDRESS & (1<<BIT)))    // bit is clear?
#define PORT_ON(port,pin) port |= (1<<pin)
#define PORT_OFF(port,pin) port &= ~(1<<pin)

//###################### Variablen
  uint16_t   Variable=2345;        //Z‰hler
  uint16_t  buffer;
  uint16_t  low, hight;
/* Byte */
uint16_t brightness EEMEM;
/* Byte */
uint16_t contrast EEMEM;
//### PORTS

//################################################################################################### Initialisierung
void Initialisierung(void)
  {
          cli();
    char text [2];
    lcd_init();

    //### TWI
  init_twi_slave(SLAVE_ADRESSE);      //TWI als Slave mit Adresse slaveadr starten

    // Die Ausgabemarke in die 2te Zeile setzen
        lcd_setcursor( 0, 1 );
    lcd_string(">Booting...");
    lcd_setcursor( 0, 2 );
        itoa (SLAVE_ADRESSE,text,16);
    lcd_string("I2C Adress=0x");
        lcd_string(text);
        for (int Index=0; Index<85; ++Index) {
            rxbuffer[Index] = 0x20;
        }
        rxbuffer[81]=0xFF;
        rxbuffer[82]=0xFF;
        rxbuffer[83]=0xFF;
        rxbuffer[84]=0xFF;
          sei();
}
//update LCD
void lcd_update(void){
    cli();
    for (int o=1;o<=4; o++)
    for (int i=1; i<=20; i++){
        lcd_setcursor( i-1, o );
        lcd_data(rxbuffer[i+((o-1)*20)]);
    }
    sei();
}
//################################################################################################### Hauptprogramm
ISR(ADC_vect)
{
char text[5];
itoa (ADC,text,16);
lcd_setcursor( 0,4 );
lcd_string(text);
}
int main(void)
{
    int adc_count=0;
    
    DDRC &= ~(1 << PC0);
    PORTC &= ~(1 << PC0);
    Initialisierung();
    DDRB = (1 << DDB1) | (1 << DDB2);
    OCR1A = eeprom_read_word(&brightness); // PWM einstellen,
    OCR1B = eeprom_read_word(&contrast);
    ICR1 = 1000;  // TOP-wert
    
    TCCR1A = (1<<COM1A1) | (1<<COM1B1) | (1<<WGM11); // 2-Kanal "non-inverting"
    TCCR1B = (1<<WGM13)|(1<<WGM12) | (1<<CS11);
    
    //Initialize ADC
    ADMUX = (1<<REFS0);               // Set Reference to AVCC and input to ADC0
    ADCSRA =(1<<ADEN)|(1<<ADPS2)|(1<<ADPS1)|(1<<ADIE)| (1<<ADPS0);    // Fadc=Fcpu/prescaler=8000000/128=62.5kHz
    // Fadc should be between 50kHz and 200kHz
    // Enable ADC conversion complete interrupt
                          // Set the I-bit in SREG
    
    ADCSRA |= (1<<ADSC);              // Start the first conversion


    char text[2];
    while(1)
    {

        for (int Index=0; Index<85; ++Index) {
            txbuffer[Index] = rxbuffer[Index];
        }
  
        uint16_t brightness_i2c=0;
        uint16_t contrast_i2c=0;
  
        brightness_i2c=(rxbuffer[81]<<8)|(rxbuffer[82]);
        contrast_i2c=(rxbuffer[83]<<8)|(rxbuffer[84]);

       
        if (rxbuffer[0]==1){
                     lcd_update();
            rxbuffer[0]=4;
        }else if(brightness_i2c!=eeprom_read_word(&brightness) && brightness_i2c!=0xFFFF){
        eeprom_write_word(&brightness,brightness_i2c);
            OCR1A = eeprom_read_word(&brightness);
     
        }else if (contrast_i2c!=eeprom_read_word(&contrast) && contrast_i2c!=0xFFFF){
            eeprom_write_word(&contrast,contrast_i2c);
            OCR1B = eeprom_read_word(&contrast);
          
        }else{
            for (uint8_t i=0; i<10; i++) _delay_ms(10);
      
        }
        ADCSRA |= (1<<ADSC);

  } //end.while
} //end.main

[Arc N. (arc)]

Mega8 hat afair kein Hardware-I2C also dürfte das per Software 
(timingkritisch) gemacht werden und da der ADC-Interrupt 
höchstwahrscheinlich viel zu lange braucht (itoa + LCD-Routinen, 
letztere womöglich noch mit Delays) wird das die I2C-Übertragung aus dem 
Takt bringen.
Lösung: Im ADC-Interrupt nur ein (volatile) Flag (adcReady o.ä.) setzen 
und das ADC-Ergebnis kopieren und die Ausgabe und Umwandlung in der Main 
machen, wenn das Flag gesetzt ist.

[Harry_13 (Gast)]

Der hat doch TWI/I2C laut Datenblatt oder was verstehe ich da falsch?
http://www.atmel.com/Images/Atmel-2486-8-bit-AVR-microcontroller-ATmega8_L_summary.pdf 
(S165)

[Mitlesa (Gast)]

8 Mhz / 800 ergibt eine Interrupt-Rate von 10KHz oder 1/10usec.

Die Ausgabe eines LCD Zeichens dauert typischerweise (grob
geschätzt) 1..10usec.

Das bedeuted dass der Prozessor aus den Interrupts (wo er auf
das LCD schreibt) kaum mehr herauskommt um was anderes zu tun.

[Harry_13 (Gast)]

Okay ja das klingt logisch :), kann ich irgendwie den ADC ohne Interrupt 
auslesen? Das wäre mir das liebste, so oft benötige ich den ja nicht...

[Stefan F. (Gast)]

Sicher, er setzt ja ein Flag, wenn die Messung beendet ist. Das liest du 
in der Hauptschleife aus.

[Harry_13 (Gast)]

Ja das mache ich ja Normalerweise so:
initialisierung:

  ADCSRA =(1<<ADEN)|(1<<ADPS2)|(1<<ADPS1)| (1<<ADPS0);

  ADCSRA |= (1<<ADSC); // Start conversion
    while (ADCSRA & (1<<ADSC)); // wait for conversion to complete
    adc_value = ADCW; //Store ADC value

aber wieso wird genau dann, mit Interrupt disabled, immer mit Spannung 
am ADC mein Controller resetted?

[Mitlesa (Gast)]

Harry_13 schrieb:
> aber wieso wird genau dann, mit Interrupt disabled, immer mit Spannung
> am ADC mein Controller resetted?

Da musst du schon den ganzen Code zeigen der dieses Verhalten
provoziert. Am Lesen des ADCs wird es wohl nicht liegen ....
.... vielleicht auch noch die Schaltung (zeigen) ....

[Arc N. (arc)]

Harry_13 schrieb:
> Der hat doch TWI/I2C laut Datenblatt oder was verstehe ich da falsch?
> 
http://www.atmel.com/Images/Atmel-2486-8-bit-AVR-microcontroller-ATmega8_L_summary.pdf
> (S165)

Dann hatte ich das falsch im Kopf. Ändert aber nichts daran, dass die 
Zeit im Interrupt zu lang ist und währenddessen die anderen Interrupts 
zu lange blockiert sind.

[Amateur (Gast)]

Zugegeben ich bin etwas provokativ.

Weißt Du, was Du ausgibst?

Wenn ich Deine lcd_update()-Funktion richtig verstehe, so schreibst Du 
immer das ganze Display voll.

Ist das würglich nötig?

Mit der Geschwindigkeit?

Ist die Ausgabe schneller als die Zufuhr von neuen Werten, so ist 
definitiv irgendwas in die Hose gegangen.

Es gibt immer die Möglichkeit, Teile oder, wenn Du keine Ahnung hast, 
ganze Zeilen zu aktualisieren.

Hast Du Dich mal mit der maximalen "Hinguckfrequenz" beschäftigt? Damit 
meine ich die maximale Frequenz, mit der das Auge Änderungen erkennt und 
das in 4 Zeilen...

[Mitlesa (Gast)]

Harry_13 schrieb:
> aber wieso wird genau dann, mit Interrupt disabled, immer mit Spannung
> am ADC mein Controller resetted?

Mal so ins Blaue geraten:

Du konfigurierst den ADC so dass beim Lesen ein Interrupt ausgelöst
wird den du nicht als ISR auch bedienst. Der unbediente Interrupt
lässt den Prozessor in den Reset springen.

[Harry_13 (Gast)]

Bei genau diesem Code passiert folgendes, solange der Eingang vom ADC 
auf GND ist ist alles gut, sobald aber irgendeine Spannung anliegt, wird 
das Display geleert, ( zeigt nichts mehr an) und per I2C ist er auch 
nicht mehr Ansprechbar, nach einem RESET funktionierts dann wieder. 
Fehler in der Beschaltung könnte man doch ausschliessen, da es ja mit 
Interrupts einliest? AVCC und AREF liegen halt auf 5V GND wurde mit GND 
verbunden. Das LCD hängt mit 4 Bit an PortD, An OC1A hängt per Pwm und 
Transistor die Hintergundbeleuchtung an OC1B hängt die Kontrastspannung 
mit 100uF Kondensator an Masse. Die Betriebsspannung ist stabilisiert 
und Zusätzlich mit einem Glättungskondensator (330uF) versehen. der I2C 
Bus ist mit PullUps versehen und wird mit einem Level Shifter auf 3.3 V 
für einen Raspi geshiftet. Ich zeichne morgen aber gerne noch nen 
Schaltplan :)

#include <stdlib.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <avr/eeprom.h>
#include "twislave.h"
#include "twislave.c"
#include "lcd-routines.h"
#include "lcd-routines.c"
#include <util/delay.h>
#ifndef F_CPU
#define F_CPU 8000000UL
#endif

//###################### Slave-Adresse
#define SLAVE_ADRESSE 0x50                 // Slave-Adresse

//###################### Macros
#define uniq(LOW,HEIGHT)  ((HEIGHT << 8)|LOW)      // 2x 8Bit   --> 16Bit
#define LOW_BYTE(x)          (x & 0xff)          // 16Bit   --> 8Bit
#define HIGH_BYTE(x)         ((x >> 8) & 0xff)      // 16Bit   --> 8Bit


#define sbi(ADDRESS,BIT)   ((ADDRESS) |= (1<<(BIT)))  // set Bit
#define cbi(ADDRESS,BIT)   ((ADDRESS) &= ~(1<<(BIT)))  // clear Bit
#define  toggle(ADDRESS,BIT)  ((ADDRESS) ^= (1<<BIT))    // Bit umschalten

#define  bis(ADDRESS,BIT)  (ADDRESS & (1<<BIT))    // bit is set?
#define  bic(ADDRESS,BIT)  (!(ADDRESS & (1<<BIT)))    // bit is clear?
#define PORT_ON(port,pin) port |= (1<<pin)
#define PORT_OFF(port,pin) port &= ~(1<<pin)

//###################### Variablen
  uint16_t   Variable=2345;        //Z‰hler
  uint16_t  buffer;
  uint16_t  low, hight;
/* Byte */
uint16_t brightness EEMEM;
/* Byte */
uint16_t contrast EEMEM;
//### PORTS

//################################################################################################### Initialisierung
void Initialisierung(void)
  {
          cli();
    char text [2];
    lcd_init();

    //### TWI
  init_twi_slave(SLAVE_ADRESSE);      //TWI als Slave mit Adresse slaveadr starten

    // Die Ausgabemarke in die 2te Zeile setzen
        lcd_setcursor( 0, 1 );
    lcd_string(">Booting...");
    lcd_setcursor( 0, 2 );
        itoa (SLAVE_ADRESSE,text,16);
    lcd_string("I2C Adress=0x");
        lcd_string(text);
        for (int Index=0; Index<85; ++Index) {
            rxbuffer[Index] = 0x20;
        }
        rxbuffer[81]=0xFF;
        rxbuffer[82]=0xFF;
        rxbuffer[83]=0xFF;
        rxbuffer[84]=0xFF;
          sei();
}
//update LCD
void lcd_update(void){
    for (int o=1;o<=4; o++)
    for (int i=1; i<=20; i++){
        lcd_setcursor( i-1, o );
        lcd_data(rxbuffer[i+((o-1)*20)]);
    }
}
int main(void)
{
DDRC &= ~(1 << PC0);
PORTC &= ~(1 << PC0);
Initialisierung();
DDRB = (1 << DDB1) | (1 << DDB2);
OCR1A = eeprom_read_word(&brightness); // PWM einstellen,
OCR1B = eeprom_read_word(&contrast);
ICR1 = 1000;  // TOP-wert

TCCR1A = (1<<COM1A1) | (1<<COM1B1) | (1<<WGM11); // 2-Kanal "non-inverting"
TCCR1B = (1<<WGM13)|(1<<WGM12) | (1<<CS11);

//Initialize ADC
ADCSRA = (1<<ADEN) | (1<<ADPS2) | (1<<ADPS0)| (1<<ADPS1);
 ADMUX = (1<<REFS0);  
unsigned int adc_value=0; // Variable to hold ADC result

char text[4];
while(1)
{
    ADCSRA |= (1<<ADSC); // Start conversion
    while (ADCSRA & (1<<ADSC)); // wait for conversion to complete
    adc_value = ADCW; //Store ADC value
    itoa (adc_value,text,16);
    lcd_setcursor( 0,4 );
    lcd_string(text);
    for (int Index=0; Index<85; ++Index) {
        txbuffer[Index] = rxbuffer[Index];
    }
    uint16_t brightness_i2c=0;
    uint16_t contrast_i2c=0;

    brightness_i2c=(rxbuffer[81]<<8)|(rxbuffer[82]);
    contrast_i2c=(rxbuffer[83]<<8)|(rxbuffer[84]);
    if (rxbuffer[0]==1){
                 lcd_update();
        rxbuffer[0]=4;
    }else if(brightness_i2c!=eeprom_read_word(&brightness) && brightness_i2c!=0xFFFF){
    eeprom_write_word(&brightness,brightness_i2c);
        OCR1A = eeprom_read_word(&brightness);

    }else if (contrast_i2c!=eeprom_read_word(&contrast) && contrast_i2c!=0xFFFF){
        eeprom_write_word(&contrast,contrast_i2c);
        OCR1B = eeprom_read_word(&contrast);

    }else{
    }

} 
}

[Harry_13 (Gast)]

Amateur schrieb:
> Wenn ich Deine lcd_update()-Funktion richtig verstehe, so schreibst Du
> immer das ganze Display voll.
>
> Ist das würglich nötig?
>
> Mit der Geschwindigkeit?


Nein, die LCD_Update wird nur aufgerufen wenn mit I2C alle Daten 
angekommen sind und in Rx_buffer[0] eine 1 steht, die wird nach dem 
Update gelöscht. somit kann ich in aller ruhe Daten in den Speicher 
laden und diese dann auf einen Rutsch aufs LCD schreiben lassen.

[Karl H. (kbuchegg)]

Amateur schrieb:

> Wenn ich Deine lcd_update()-Funktion richtig verstehe, so schreibst Du
> immer das ganze Display voll.

Und dann das ganze auch noch unter Interrupt Sperre

void lcd_update(void){
    cli();
    for (int o=1;o<=4; o++)
    for (int i=1; i<=20; i++){
        lcd_setcursor( i-1, o );
        lcd_data(rxbuffer[i+((o-1)*20)]);
    }
    sei();
}

Den Cursor nach jedem Zeichen immer neu zu setzen braucht auch kein 
Mensch. Jede einigermassen vernünftige LCD Library wird nach der Ausgabe 
eines Zeichens den Cursor ganz für sich alleine um 1 Zeichen weiter 
setzen.

Zum Thema Interrupt Sperre:
Da die I2C Routinen offensichtlich über Interrupts funktionieren 
(funktionieren müssen), ist es ganz fies, wenn du für eine derart lange 
Zeit die Interrupts abstellst. In dieser Zeit wird dein TWI Interface 
nämlich lahm gelegt.

Ganz abgesehen davon, dass es vollkommmen ausreichen würde, wenn in der 
Hauptschleife immer nur ein einziges Zeichen aus deinem 
Bildschirmspeicher aufs LCD übertragen wird. Nur dann eben reihum immer 
das jeweils nächste, so dass sich dein LCD dann eben über einen Zeitraum 
von 20*4 = 80 Durchläufen durch die Hauptschleife aktualisiert. Das ist 
immer noch schnell genug, so dass kein Mensch bemerken wird, dass das 
nicht in einem Rutsch sondern nach und nach geschieht.

Alles in allem: das ist mal wieder alles mit der heissen Nadel 
zusammengestrickt und dann noch dazu mit wenig Sachkentniss.

[Karl H. (kbuchegg)]

char text[4];
while(1)
{
    ADCSRA |= (1<<ADSC); // Start conversion
    while (ADCSRA & (1<<ADSC)); // wait for conversion to complete
    adc_value = ADCW; //Store ADC value
    itoa (adc_value,text,16);

Da der größte Wert, den du vom ADC kriegen kannst, 1024 ist, ist ein 
text[4] um 1 Stelle zu klein.
-> du nudelst dir irgendwas im Speicher nieder.

[Karl H. (kbuchegg)]

unsigned int adc_value=0; // Variable to hold ADC result

char text[4];
while(1)
{
    ADCSRA |= (1<<ADSC); // Start conversion
    while (ADCSRA & (1<<ADSC)); // wait for conversion to complete
    adc_value = ADCW; //Store ADC value
    itoa (adc_value,text,16);


itoa ist die falsche Funktion für einen unsigned int.
das i in itoa steht für int. Den hast du aber nicht. Du hast einen 
unsigned int. Die richtige Funktion dafür ist utoa.

Und mach dir um Himmels willen Hilfsfunktionen!
Einen int oder unsigned int auf einem LCD ausgeben braucht man alle Nase 
lang. Das ist wirklich keine Raketentechnik sich dafür eine lcd_puti 
bzw. lcd_putu Funktion zu schreiben.

void lcd_puti( int wert )
{
  char txt[7];

  itoa( wert, txt, 10 );
  lcd_string( txt );
}

void lcd_putu( unsigned int wert )
{
  char txt[7];

  utoa( wert, txt, 10 );
  lcd_string( txt );
}

fertig. Die Funktionen kommen zu deinen LCD Funktionen mit dazu und in 
Zukunft passiert dir so was nicht mehr, dass dein Ausgabearray zu klein 
ist.

[Mitlesa (Gast)]

Karl H. schrieb:
> Da der größte Wert, den du vom ADC kriegen kannst, 1024 ist

1023?  (-->0x3FF)

[Amateur (Gast)]

>Nein, die LCD_Update wird nur aufgerufen wenn mit I2C alle Daten...

Meine Frage bezog sich hauptsächlich darauf, ob es sinnvoll ist immer 
das GANZE Display zu aktualisieren. Da gibt’s nämlich - versteckt - jede 
Menge an delay.

Nicht vergessen: Egal ob Du nur alle paar Sekunden, oder im 
Mikrosekundenrhythmus, einen Funktionsblock aufrufst. Ist dieser, 
zeitlich, zu lang ist er zeitlich zu lang.

[Karl H. (kbuchegg)]

Mitlesa schrieb:
> Karl H. schrieb:
>> Da der größte Wert, den du vom ADC kriegen kannst, 1024 ist
>
> 1023?  (-->0x3FF)

Ja ok. Danke
Das Array ist trotzdem zu klein

[Harry_13 (Gast)]

Amateur schrieb:
> Meine Frage bezog sich hauptsächlich darauf, ob es sinnvoll ist immer
> das GANZE Display zu aktualisieren. Da gibt’s nämlich - versteckt - jede
> Menge an delay.

Da gebe ich dir recht, das muss ich noch ändern. Ein größerer Buffer 
hilft auf nichts, trotzdem hängt er wieder... Die Interrupt Sperre war 
aktuell nur testweise drinnen, da mir zuvor der ADC interrupt immer die 
Display Aktualisierung unterbrochen hat, und somit zum teil nur halb 
geschrieben wurde.

[asdf (Gast)]

Harry_13 schrieb:
> Okay ja das klingt logisch :), kann ich irgendwie den ADC ohne Interrupt
> auslesen? Das wäre mir das liebste, so oft benötige ich den ja nicht...

Und warum nicht umgekehrt? ADC im Interrupt auslesen, aber mit dem LCD 
in der Hauptschleife kommunizieren?

[Karl H. (kbuchegg)]

asdf schrieb:
> Harry_13 schrieb:
>> Okay ja das klingt logisch :), kann ich irgendwie den ADC ohne Interrupt
>> auslesen? Das wäre mir das liebste, so oft benötige ich den ja nicht...
>
> Und warum nicht umgekehrt? ADC im Interrupt auslesen, aber mit dem LCD
> in der Hauptschleife kommunizieren?

Im Prinzip muss es egal sein.
Ob mit oder ohne Interrupt, da darf nichts abschmieren.

[Amateur (Gast)]

Noch zwei Fragen:

Woher kommt rxbuffer. Immerhin 80 Zeichen.

Meckern Deine Include-Dateien nicht, wenn Du die Frequenz nachher 
festlegst?

Soweit mir bekannt benötigt zumindest delay.h diese Angabe...

[Karl H. (kbuchegg)]

Harry_13 schrieb:

> aktuell nur testweise drinnen, da mir zuvor der ADC interrupt immer die
> Display Aktualisierung unterbrochen hat, und somit zum teil nur halb
> geschrieben wurde.

Na ja gut.
Das war sowieso Quatsch.

Dein LCD ist nun mal eine Shared Resource und damit gibt es nur eine 
Stelle, die darauf zugreifen darf. Entweder die Hauptschleife oder 1 
ISR. Aber nicht beide gleichzeitig, denn sonst kommen sich die ins 
Gehege.

[Karl H. (kbuchegg)]

Hast du schon mal probiert, was pasiert wenn du nur den ADC am laufen 
hast

int main(void)
{
  DDRB = (1 << DDB1) | (1 << DDB2);
  OCR1A = eeprom_read_word(&brightness); // PWM einstellen,
  OCR1B = eeprom_read_word(&contrast);
  ICR1 = 1000;  // TOP-wert

  TCCR1A = (1<<COM1A1) | (1<<COM1B1) | (1<<WGM11); // 2-Kanal "non-inverting"
  TCCR1B = (1<<WGM13)|(1<<WGM12) | (1<<CS11);

  lcd_init();

  //Initialize ADC
  ADCSRA = (1<<ADEN) | (1<<ADPS2) | (1<<ADPS0)| (1<<ADPS1);
  ADMUX = (1<<REFS0);  
  unsigned int adc_value=0; // Variable to hold ADC result
  char text[7];

  while(1)
  {
    ADCSRA |= (1<<ADSC); // Start conversion
    while (ADCSRA & (1<<ADSC)); // wait for conversion to complete
    adc_value = ADCW; //Store ADC value

    utoa (adc_value,text,16);
    lcd_setcursor( 0,4 );
    lcd_string(text);
  } 
}

Wenn an deiner Hypothese was dran ist, dann müsste es auch hier zu 
Problemen kommen.

[Harry_13 (Gast)]

Karl H. schrieb:
> Hast du schon mal probiert, was pasiert wenn du nur den ADC am laufen
> hast
Gerade getestet, nur der ADC läuft... Sobald ich jetzt aber I2C 
aktiviere ist dieses dann nicht ansprechbar

[Harry_13 (Gast)]

Amateur schrieb:
> Woher kommt rxbuffer. Immerhin 80 Zeichen.
>
> Meckern Deine Include-Dateien nicht, wenn Du die Frequenz nachher
> festlegst?
>
> Soweit mir bekannt benötigt zumindest delay.h diese Angabe...

RXBuffer kommt aus der I2C Lib. von Jtronics
http://www.jtronics.de/avr-projekte/library-i2c-twi-slave.html
Die Frequenz übergebe ich zusätzlich im Makefile.

[Karl H. (kbuchegg)]

Harry_13 schrieb:
> Karl H. schrieb:
>> Hast du schon mal probiert, was pasiert wenn du nur den ADC am laufen
>> hast
> Gerade getestet, nur der ADC läuft... Sobald ich jetzt aber I2C
> aktiviere ist dieses dann nicht ansprechbar

Dann würde ich mir an deiner Stelle die I2C Implementierung mal näher 
ansehen

[Karl H. (kbuchegg)]

Harry_13 schrieb:

> RXBuffer kommt aus der I2C Lib. von Jtronics
> http://www.jtronics.de/avr-projekte/library-i2c-twi-slave.html

Dann ist aber deine Verwendung von 85 im Code keine gute Idee.

Die Größe des zur Verfügung stehenden buffers wird durch 'buffer_size' 
festgelegt.

        for (int Index=0; Index < buffer_size; ++Index) {
            txbuffer[Index] = rxbuffer[Index];
        }

oder gleich mittels memcpy.
Solche doppelt gemoppelt Dinge solltest du dir abgewöhnen. Es gibt nur 
eine einzige Stelle, an der die Buffergröße als Zahlenwert bekannt ist. 
Und das ist hier in twislave.h

//#################################### von Benutzer konfigurierbare Einstellung 

#define buffer_size 20                 //Größe der Buffer in Byte (2..254)

wenn dort bei dir nicht 85 steht, dann liegt hier der Fehler. Aber 
selbst wenn bei dir da 85 eingetragen sein sollte, dann solltest du 
trotzdem überall dieses #define benutzen und nicht direkt in deinem Code 
85 stehen haben. Das sind alles nur Stolpersteine.


> Die Frequenz übergebe ich zusätzlich im Makefile.

Dann nimm sie aus dem Code raus.
Doppelte Angaben verwirren nur.

[Karl H. (kbuchegg)]

Ich denke, das hier ist falsch

    case TW_SR_DATA_ACK:             // 0x80 Slave Receiver,Daten empfangen
      data=TWDR;                 // Empfangene Daten auslesen
      if (buffer_adr == 0xFF)         // erster Zugriff, Bufferposition setzen
        {
          if(data<=buffer_size)      // Kontrolle ob gewünschte Adresse im erlaubten bereich

das kann hier nicht <= heissen. Das muss < sein!

(Wenn immer im Zusammenhang mit Array Indizierung irgendwo ein <= 
auftaucht, dann muss man hellhörig werden)