-         

Ergebnis 1 bis 2 von 2

Thema: Datenaustauschproblem zw. PC und Atmega32

  1. #1
    Neuer Benutzer Öfters hier
    Registriert seit
    07.02.2006
    Ort
    Weimar
    Beiträge
    19

    Datenaustauschproblem zw. PC und Atmega32

    Anzeige

    Hallo,
    ich habe ein Datenaustauschproblem zwischen Atmega32 und PC. Ich sende vom PC aus Steuersignale an den Atmel, der daraufhin je nach Befehl bestimmte Aktionen ausführen soll. Das ganze funktioniert eigentlich auch recht gut, allerdings reagiert der Atmel nach einiger Zeit nicht mehr auf die Befehle und führt dementsprechend auch nicht mehr die gewünschten Aktionen aus. Hier hilft dann nur noch das Betätigen der Reset-Taste. Danach funktioniert es wieder für ein kurze Zeit.
    Ich habe auch schon versucht den Watchdog einzubauen. Dieser scheint auch immer wieder "resetet" zu werden, weswegen ich darauf schließe, dass sich der Atmel nicht komplett festfährt.
    Ich verwende ein einfaches String-basiertes Protokoll (siehe weiter unten) und sende Steuerbefehle der Form "pwm128" oder "stat00". Ich vermute das das Problem vielleicht auf das Protokoll zurückzuführen ist.

    Ich wäre für jede Hilfe sehr dankbar.
    Hender

    Meine Main.c sieht wie folgt aus:
    Code:
    #include <stdio.h>
    #include <stdlib.h> 
    #include <ctype.h>
    #include <string.h>
    #include <avr/io.h>
    #include <avr/delay.h>
    #include <avr/interrupt.h>
    #include <avr/signal.h>
    #include <avr/wdt.h> 
    #include "uart.h"
    #include "adc.h"
    #include "pwm.h"
    
    void init(void)
    {
      DDRB=255;
      PORTB=0;
      
      DDRC=255;
      //PORTC=255;
      PORTC=(1<<PC0);
      
      DDRD |= (1 << PD4);
      DDRD |= (1 << PD5);
      
      adc_init();
      uart_init();
      pwm_init();
      
      wdt_enable(WDTO_500MS); //enable Watchdog with 500ms timeout
      
      sei(); 
    }
    
    int main()
    {
      uint8_t i_value=0;
      i=0;
      
      init();
        while (1)
        {
        	wdt_reset(); //reset Watchdog
          if(receive_char==1)
        	{
        		i++;
        		if(i>5)
        		{
        			i=0;
     		    	//receive_char=0;
            	sendflag=0;
            	i_value=0;
        		}
        		receive_char=0;
        	}
    
        	if(receive_char==0&&sendflag==0)
        	{
            if (memcmp (pc_data, "dflt", 4 ) == 0)
            {
              PORTC=(1<<PC0);
              //OCR1AL=255;
              OCR1BL=255;
            }        
            if (memcmp (pc_data, "bump", 4 ) == 0)
            {
              PORTC=(1<<PC0);
              //OCR1AL=0;
              OCR1BL=0;
            }
            if (memcmp (pc_data, "dent", 4 ) == 0)
            {
              PORTC=(0<<PC0);
              //OCR1AL=0;
              OCR1BL=0;
            }        
            
            if (memcmp (pc_data, "onbt", 4 ) == 0)
            {
              PORTC=(1<<PC0);
              //OCR1AL=254;
              OCR1BL=10;
            }
            
            if (memcmp (pc_data, "stat", 4 ) == 0)
            {
              send_state();
            }          
            
            if (memcmp (pc_data, "pwm", 3 ) == 0)
            {
              i_value = atoi((char*)&pc_data[3]);
              PORTB=i_value;
              //itoa(i_value,string2send,10);
              OCR1AL=i_value;
              OCR1BL=i_value;
              send_state();
              //toascii_8(ADCValue);
            }
            i=0;
        		sendflag=1;
        	}
        }  
    }
    Meine uart.h:
    Code:
    unsigned char pc_data[10];
    unsigned char build_str[4];
    unsigned char str2send[25];
    volatile unsigned char receive_char;
    unsigned char sendflag;
    int i;
    
    /*
     *  functions, exported
     */
    
    void uart_init (void);
    int uart_putc(unsigned char c);
    void uart_puts (char *s);
    uint8_t uart_getc (void);
    Meine uart.c:
    Code:
    #include <avr/io.h>
    #include <avr/signal.h>
    #include "uart.h"
    
    // Initialisierung UART
    void uart_init (void)
    {
    /* USART-Init 38400 Baud bei 8MHz für Mega32 */
      UCSRB = ( (1<<RXCIE) | (1<<RXEN) | (1<<TXEN) );
    /* Einstellen des Datenformats: 8 Datenbits, 1 Stoppbit */
      UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0);
      UBRRH  = 0;                                   // Highbyte ist 0
      UBRRL  = 12;                                  // Lowbyte ist 51 ( dezimal )
    }
    
    // Zeichen senden
    int uart_putc(unsigned char c)
    {
        while (!(UCSRA & (1<<UDRE))); /* warten bis Senden moeglich */
        UDR = c;                      /* sende Zeichen */
        return 0;
    }
    
    // String senden 
    void uart_puts (char *s)
    {
        while (*s)
        {   /* so lange *s != '\0' also ungleich dem "String-Endezeichen" */
            uart_putc(*s);
            s++;
        }
    }
    
    SIGNAL (SIG_UART_RECV)
    {
      pc_data[i]=UDR;
      receive_char=1;
    }

  2. #2
    Erfahrener Benutzer Robotik Einstein Avatar von SprinterSB
    Registriert seit
    09.06.2005
    Ort
    An der Saar
    Beiträge
    2.801
    Irgendwie hab ich ein ungutes Gefühl bei der Kommunikation zwischen deiner APplikation und der UART-ISR...

    Während receive_char==1 ist kann eine IRQ auftauchen und du verlierst Zeichen. Vielleicht ist's das?
    Disclaimer: none. Sue me.

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •