Atmega8515 integer mit 32 bytes

[clubber (Gast)]

Hi leute,

ich programmiere mit einem Atmega8515 in der Programmiersprache C und 
dem avr-gcc compiler. Ich benötige einen Integer mit 32 Bit. Dazu habe 
ich ich die Headerdatei  #include <stdint.h> includiert und int32_t als 
Datentyp verwendet.
Ich will einen counter hochzählen lassen. dieser zählt jedoch nur bis 
32767 und wechselt dann ins negative also geht dann mit -32767 weiter. 
Das deutet darauf hin, dass ich einen 2 byte integer verwendet, wie kann 
ich dann sonst einen 4 byte integer bet Atmega8515 verwenden, wenn nicht 
mit int32_t?

[Klaus W. (mfgkw)]

Gibt es dazu auch Quelltext?

[H.Joachim S. (crazyhorse)]

das Problem wird in der Ausgaberoutine liegen.
Die Variable hat zwar 2Byte, ausgegeben werden aber nur die letzten 
beiden (int).

[clubber (Gast)]

Hi.

Hier ist der Quelltext mit den wichtigsten Zeilen:


#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>

/* Initialisierungen der Interrupts und Uart*/

int32_t count=0;  //counter der Impulse

while(1)
{
 count++;

 //In Sekunden takt wird über Uart count gesendet
 send(count);
}


Ich habe auch schon direkt long int versuch, auch zählt er nur bis 32767 
und geht dann ins negative.

[clubber (Gast)]

Also ich verwende itoa() um die integer in einen string zu wandeln.
Um diese anschließend über Uart wegzuschicken.
Kann das dadurch kommen?

[Klaus W. (mfgkw)]

Das ist nur die halbe Wahrheit.
Mehr Quelltext!

[Klaus W. (mfgkw)]

clubber schrieb:
> Also ich verwende itoa() um die integer in einen string zu wandeln.
> Um diese anschließend über Uart wegzuschicken.
> Kann das dadurch kommen?

ja, sicher
i in itoa() steht für int, und das hat bei dir 2 Byte.
Wenn du itoa mit einer int32_t aufrufst, wird dafür auf 2 Byte 
abgeschnitten.

[clubber (Gast)]

int uart_putChar(unsigned char c)  //Buchstabe schicken
{

  while(!(UCSRA & (1<<UDRE)))  //warten bis Senden möglich
  {
  }
  UDR=c;
  return 0;
}


void uart_putString(char*s)    //string schicken
{
  while(*s)  //solange '\0' nicht erreicht
  {
    uart_putChar(*s);
    s++;
  }
}



int main()
{
    char buf[5];


   while(1)
  {
     count++;
           //jede sekunde
           itoa(count,buf,10);
           uart_putString(buf);
        }
}


  return 0;
}


//Interruptroutinen
/*---------------------------------------------------------------------- 
-----------------------*/



ISR (INT0_vect)  //Externe Interrupts werden hier bearbeietet
{
  if ( (PIND & (1<<PIND2)) && !(PIND & (1<<PIND3))) //drehung vorwärts
  {
    count--;
    PORTA=0b01000000;
  }
  else if ( (PIND & (1<<PIND2)) && (PIND & (1<<PIND3))) //drehung 
rückwärts
  {
    count++;
    PORTA=0b00100000;
  }

}

ISR(TIMER0_COMP_vect)  //Timer0 register löst alle 100µs aus
{
  static uint16_t InterCount=0;


  InterCount++;
  if(InterCount==10000)
  {
    InterCount=0;
    UartTXflag=1;
  }

}




ISR(USART_RX_vect)  //Über UART zeichen empfangen
{
  unsigned char buffer;

    // Daten aus dem Puffer lesen
    buffer = UDR;


  if ( uart_str_complete==0 )
  {  // wenn uart_string gerade in Verwendung, neues Zeichen verwerfen
    // Daten werden erst in string geschrieben, wenn nicht 
String-Ende/max Zeichenlänge erreicht ist/string gerade verarbeitet wird
     if (buffer!='\n' && buffer!='\r' && uart_str_count<5-1)
     {
      uart_string[uart_str_count]=buffer;
      uart_str_count++;
     }
     else
     {
      uart_string[uart_str_count]='\0';
      uart_str_count=0;
      uart_str_complete=1;
     }
  }
}

[clubber (Gast)]

Gibt es dann eine andere möglichkeit 4 bytes integer in einem string zu 
wandeln?

[fido (Gast)]

gibt auch noch ein ltoa() für "long to..."
versuchs mal damit.

[clubber (Gast)]

vielen Dank Leute,


hat geklappt. Ihr seid die besten.