CHAR[] im Interrupt mit ext funktionen nutzen! HELP!

Könntest Du vielleicht mal präzisieren, wo genau die Probleme auftreten? 
BTW: SIGNAL ist veraltet. Bitte ISR verwenden und, falls noch nicht 
geschehen, auf aktuelle WINAVR-Version updaten. Außerdem haben serielle 
Ausgaberoutinen in einem Interrupt-Handler normalerweise nichts zu 
suchen.

Übrigens: Du hast Deine Strings alle mit 6 Elementen deklariert, hast 
aber beim Aufruf von dtostrf 6 Stellen als "width" angegeben. Das passt 
nicht! Für den Nullterminator brauchst Du eine zusätzliche Stelle. Alle 
Arrays müssen in dem Fall als "unsigned char NAME[7]" deklariert werden, 
sonst schreibt dtostrf den Nullterminator ins Speichernirvana und die 
Ausgaberoutine findet ihn nicht.

vielen dank für die schnellen antworten.

C:/WinAVR/avr/include/avr/signal.h:36:2: warning: #warning "This header 
file is obsolete.  Use <avr/interrupt.h>."

woher bekomme ich die neueste? hab die erst vor 1 Woche runtergeladen...

ok danke.

Mein Problem lag hoffentlich an der Größe der char Variablen und er hat 
daher nie etwas in die Interruptfunktion übergeben können...

werde es morgen mal testen. aber globale Variablen sollten doch kein 
Problem in der Interrupt Funktion sein oder?

Bzw wie würde es besser gehen? es soll halt beim INTO auslösen die Daten 
gesendet werden...

@Karl Heinz:
Afaik ist die im Aufruf von dtostrf angegebene "width" aber inkl. 
Dezimalpunkt und eventuellem Vorzeichen. Das sagt mir zumindest der 
Kommentar in der stdlib.h. Ob es bei seinen zu erwartenden Zahlenwerten 
ausreicht, mit 6 Stellen (davon drei Nachkomma und ein Dezimalpunkt und 
u.U. zusätzlich noch ein Vorzeichen, bleibt evtl. nur eine Stelle vor 
dem Dezimalpunkt übrig) darzustellen, kann man anhand des geposteten 
Codes nicht nachvollziehen, da die ganzen Zwischenrechnungen fehlen.

@Jörn:
Code von der Größe demnächst bitte als Anhang schicken! Und bei 
kleineren Codestücken auf eine übersichtliche Formatierung achten (Code 
kannst Du auch im Fenster in Farb-Syntax-Darstellung posten, wenn Du ihn 
in

1

 und

 einschließt).

Na, das hat ja geklappt. Also C-Code in "eckige Klammer auf, großes C, 
eckige Klammer zu" und am Ende "eckige Klammer auf, Schrägstrich (/), 
großes C, eckige Klammer zu"...

@Karl Heinz:
Er benutzt aber gar kein printf, sondern nur dtostrf...

hy funktioniert alles aber suuuper langsam!!

Die  umwandlung von double in das char mit dtostrf()... dauert 10ms 
jeweils!!

das ist viel zu lange!!!

wie kann ich die double Werte per UART einfacher bzw. schneller 
übertragen??
max 2 Ziffern vor dem Komma und 2 dahinter reichen aus...

10 ms bei 8 MHz (entspricht 80000 CPU-Takten) kommt mir auch ein 
bisschen arg viel vor. Da müsste sogar sprintf schneller sein. Woher 
nimmst Du die Gewissheit, dass das so lange dauert? Bist Du sicher, dass 
der µC mit 8 MHz läuft?

hab vor und hinter dem befehl PINB=0x02 an aus gemacht und das ganze mit 
dem Oszi gemessen...

fused sind in
sut1 nix
sut0 haken
cksel3 haken
cksel2 nix
cksel1 haken
cksel0 haken

Bin ich blind, oder warum finde ich in dem Code nirgends eine Anweisung 
"PINB = 0x02"? Was für ein Controller ist das überhaupt?

[Code]
#define   F_CPU 8000000UL
#include  <avr/io.h>
#include  <stdio.h>
#include  <stdlib.h>
#include   <inttypes.h>
#include   <avr/interrupt.h>

#define BAUD     38400UL
#define UBRR_BAUD  ((F_CPU)/(16*(BAUD))-1)

char LFC[15];
char TC[15];
char LFKC[15];

int uart_putc(unsigned char c)
{
  while (!(UCSRA & (1<<UDRE)));

  UDR = c;
  return 0;
}

int uart_puts( char* str )
{
  while( *str )
    uart_putc( *str++ );
  return 0;
}


int main (void)
{

double         Faktor = 0.0048828125;
double        LF = 0;
double        T = 0;
double         LFkomp = 0;

  UCSRB   |= (1 << TXEN) | ( 1 << RXEN );  // UART TX, RX einschalten
   UCSRC   |= ( 1 << URSEL )|( 3<<UCSZ0 );  // Asynchron 8N1
   UBRRH  = (uint8_t) (UBRR_BAUD>>8);      // USART Baud
    UBRRL  = (uint8_t) UBRR_BAUD;

  ADCSRA = _BV(ADEN) | _BV(ADPS1) | _BV(ADPS2);  // AD anschalten & 
Prescaler 64 Takt = (CLK/Prescaler) 50-200kHz
  MCUCR = _BV(ISC00)|_BV(ISC01);
  GICR  = _BV(INT0);
  sei();
  uart_puts("System wurde gestartet\r");
  DDRB = 0x03;

  for (;;)
  {
                      // Rohleitfähigkeit einlesen
                    // 0-5V 0-24 mS =>
    ADMUX = 0;              // AD Kanal A.0
    ADCSRA |= _BV(ADSC);        // AD Messung starten
    while (ADCSRA & _BV(ADSC))      // bis ein Wert eingelesen ist 
warten
    {}
    LF = ADCW;              // Weise den Wert b zu
    LF = LF*(double)Faktor;
    LF = LF * 5.42857;          // Umrechnung Spannung pro mS

                      // Temperatur einlesen
                      // 0-5V ,0-60 C
    ADMUX = 0x01;                 // AD Kanal A.1
    ADCSRA |= _BV(ADSC);            // AD Messung starten
    while (ADCSRA & _BV(ADSC) )     // bis ein Wert eingelesen ist
    {}

    T = ADCW;              // Weise den Wert b zu
    T= (T*Faktor)*28.869-27.713;

    int loesung = 1;
                      // Acetat = 1
                      // Bicarbonat = 2
    if(loesung == 1)
      {
      double a = 0.021;
      LFkomp = LF+LF*a*(T-25);
      }

    else if(loesung == 2)
      {
      double a = 0.023;
      LFkomp = LF+a*(T-25);
      }
    PORTB=0x01;
    dtostrf(LF,6,4,LFC);
    PORTB=0x00;
    dtostrf(T,6,4,TC);
    dtostrf(LFkomp,6,4,LFKC);
    }
}

ISR (SIG_INTERRUPT0)
{

    uart_puts("\r");
  //  uart_puts( "Rohleitfähigkeit  : " );
    uart_puts(LFC);
  //  uart_puts("[mS/cm]\r");
      uart_puts("\r");
  //  uart_puts( "Temperatur        : " );
    uart_puts(TC);
  //  uart_puts("[°C]\r");
    uart_puts("\r");
    //  uart_puts( "Endleitfähigkeit  : " );
    uart_puts(LFKC);
  //  uart_puts("[mS/cm]\r");
    uart_puts("\r");

}




[\Code]

Atmel MEga8 und intern auf 8Mhz

Ich lese immer das +5V Signal.

Hallo, meiner Meinung nach solltest du dein Programm ein bischen 
abaendern.

1. Nur ein Flag in der ISR setzen und in der Main abfragen z.B.:

Pseudo AVR GCC Code

1

#define TRANSMIT 0

2

volatile u8 TRANSMIT=0;

3

4

ISR(xxx)

5

{ 

6

  status_flagreg |= (1<<TRANSMIT);

7

}

8

9

10

int main(void)

11

{

12

  for(;;){

13

  if(status_flagreg & (1<<TRANSIMT)){

14

   uart0_out("uzibuz");

15

  }

16

  }

17

}

2. In der Codesammlung liegt von Peter Danneger seine Output Routinen 
für den 8051er. Eine Portierung für AVR GCC hab ich in dem selben Thread 
hinterlegt. Die Funktion sind sehr schnell und Code sparend.

Gruß,
Dirk

mhh es muss sofort ohne verzögerung gesendet werden. von daher wär das 
leider im schlimmsten Fall mit fast 30ms zu spät.

die output routine werde ich mal testen...

hy

ja das Problem mit dem unterbrechen des ADC hatte ich auch schon im 
Kopf. leider machten mir nur die Chars Probleme und so folg das cli 
wieder raus :-)

1. Wenn ich am anfang von For schleife sei() und am ende CLI mache merk 
er sich dann den zwischendurch ausgelösten IRQ und löste ihn aus oder 
nur wenn er im "rücksprung"  hinter cli und in der For() schleife nach 
oben ist zu sei springt? also

...
for (;;)
  {
   sei();
    ADMUX = 0;              // AD Kanal A.0
....
  cli();
  }

2. benötigt werden nur zahlen von 0-50 8. die Nachkommastellen sollten 
auf 2 gerundet werden so das nur XX.XX übergeben werden müssen. das 
Protokol am PC kann ich ja selber definieren.

Kann ich nicht die 2 Vorkommaziffern und 2 Nachkommazifffern jeweils in 
einem 8bit Wert senden und am PC einfach zusammensetzen durch ein 
Protokoll...

also AA senden, BB senden....

-> AA.BB und CC.DD

könnte ja die Vorkommazahl durch runden bekommen (->int) und die nach 
kommastellen durch
Zahl *100- int*100....

oder geht das einfacher?