Programm bleibt stehen

[Chris T. (chris0086)]

Hallo Leute ich hab wieder ein Problem wo ich nicht weis warum es so 
ist.
Ich gebe werte über die serielle aus aber es wird nicht alles 
ausgegeben. Allerdings wird meine "Überprüfungsled" getoggelt, also das 
Programm läuft weiter.

#include <stdlib.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <util/crc16.h>
#include <avr/eeprom.h>
#include "uart.h"
#include "lib_crc.h"
#include <util/delay.h>

/* define CPU frequency in Mhz here if not defined in Makefile */
#ifndef F_CPU
#define F_CPU 8000000UL
#endif


/* 9600 baud */
#define UART_BAUD_RATE      9600

uint8_t count =0;
uint8_t timerdelay = 10;
uint8_t t_overflow = 0;
uint16_t ptherme EEMEM = 0000;
void entprellung( volatile uint8_t *port, uint8_t maske ) {
  uint8_t   port_puffer;
  uint8_t   entprellungs_puffer;

  for( entprellungs_puffer=0 ; entprellungs_puffer!=0xff ; ) {
    entprellungs_puffer<<=1;
    port_puffer = *port;
    _delay_us(150);
    if( (*port & maske) == (port_puffer & maske) )
      entprellungs_puffer |= 0x01;
  }
}

ISR (TIMER1_OVF_vect)
{  if(count==timerdelay)
  {
    //PORTD ^= (1<<PD3); //Toggeln
    count=0;
    t_overflow = 1;
    TIMSK &= ~(1<<TOIE1);
  }
  count++;
}

ISR (INT0_vect)
{
  entprellung( &PIND, (1<<PIND2) ); // ggf. Prellen abwarten
    if( PIND & (1<<PIND2) )           // dann stabilen Wert einlesen
    {
      PORTD ^= (1<<PD3); //Toggeln

      //key_pressed =1; // Taste wurde gedrückt

    }
    else
    {

      // mach was anderes
    }

}



uint16_t CRC_ausgeben(uint8_t *werte,uint8_t j)
{
uint8_t i;
uint16_t CRC_r = 0x0000;
unsigned short crc =0xFFFF;

  for(i=0;i<j; i++)
       {
         if(i==0)
         CRC_r=update_crc_16(crc,werte[i]);
         else
           CRC_r=update_crc_16(CRC_r,werte[i]);
       }
  return CRC_r;
}





int main(void)
 {

     uint8_t sendstring[6];
     uint8_t i;
     uint16_t crc =0xFFFF;
     uint16_t ergebnis;

     uint8_t c;
     uint8_t wr_typ = 0;
//Initialisierung
     //USART initialisieren
     uart_init( UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) );

     //interrupt an Pin INT0 konfigurieren
        DDRD &= ~(1<< DDD2); //Eingang
        PORTD |= (1<< PD2);
        GICR |= (1<<INT0);
     sei();
     //PIN 3 Port D auf Ausgang
         DDRD |= (1<<DDD3);
         PORTD |= (1<<PD3); //Einschalten
     // 16-bit Timer aktivieren Überlauf alle 8,388 Sekunden
     TCCR1B |= (1<<CS12)| (1<<CS10);
     TIMSK |= (1<<TOIE1);
//Programmstart
     timerdelay = 0; // 4 = ca. 30 Sekunden warten bis WR bereit

     sendstring[0]=0x02;
     sendstring[1]=0x04;
     sendstring[2]=0x00;
     sendstring[3]=0x00;
     sendstring[4]=0x00;
     sendstring[5]=0x02;
     /*
      * Transmit single character to UART
      */
     uart_putc('\r');  //<-- wird gesendet


     ergebnis = CRC_ausgeben( sendstring,6);

     i = ergebnis;  
     uart_putc(i);//<-- wird gesendet
     i = ergebnis >> 8;
     uart_putc(i);//<-- wird gesendet
     // eeprom_busy_wait();
     //eeprom_write_word(&ptherme, 0xffff);
     
uart_putc('\r'); // <-- wird nicht gesendet
//eeprom_busy_wait();
//          ergebnis = eeprom_read_word(&ptherme);

uart_putc('\r'); // <-- wird nicht gesendet
uart_putc(ergebnis); // <-- wird nicht gesendet
uart_putc(ergebnis>>8); // <-- wird nicht gesendet
 PORTD ^= (1<<PD3); //Toggeln // LED geht aber aus, wurde während der Initialisierung eingeschaltet

Ich sehe leider keine Fehler im Code

[Bjoern B. (per)]

Hallo,
womit lässt Du dir das gesendete Anzeigen, kann es sein das es keine 
Darstellbaren zeichen sind ?

gruß,
Björn

[Chris T. (chris0086)]

Hab jetzt uart_putc durch USART_Transmit ersetzt, jetzt sendet er alles:

void USART_Transmit( char data )
{
  /* Wait for empty transmit buffer */
  while ( !( UCSRA & (1<<UDRE)) )
    ;
  /* Put data into buffer, sends the data */
  UDR = data;
};

Die Funktion uart_putc hatte ich aus der Lib von Peter Fleury

[Chris T. (chris0086)]

Hab aufm PC HTerm laufen das zeigt ja alles an, und mit der Änderung 
läuft das auch, nur warum?

[Karl H. (kbuchegg)]

Chris tian schrieb:

> Die Funktion uart_putc hatte ich aus der Lib von Peter Fleury


Ich seh in deinem Code die Hauptschleife nicht.

Du MUSST den µC in einer Endlosschleife gefangen halten!

main() darf auf keinen Fall verlassen werden, denn:
Das 'Runtime' System schaltet in diesem Fall sofort die Interrupts ab. 
Die Fleury UART-Lib ist aber Interrupt getrieben. Ohne aktivierte 
Interrupts tut sich dann nichts mehr. Alle Zeichen, die es bis dahin nur 
in die FIFO geschafft haben, bleiben dann auch in der FIFO.

int main()
{

  ....


  while( 1 ) {
  }
}

wenn die Hauptschleife leer ist, dann ist sie eben eine leere 
Endlosschleife. Aber du willst auf keinen Fall haben, dass der 
Programmfluss jemals aus main wieder rauskommt.

Und das gilt für ALLE Programme auf einem AVR! Alle? Ja, alle!