-
        
+ Antworten
Seite 1 von 2 12 LetzteLetzte
Ergebnis 1 bis 10 von 15

Thema: Warum wird die main-routine dauernt neu gelstartet ?

  1. #1
    Neuer Benutzer Öfters hier
    Registriert seit
    10.10.2004
    Beiträge
    6

    Warum wird die main-routine dauernt neu gelstartet ?

    Hi,

    beim einfügen der "Selbst-Vorstellung" über die serielle Schnittstelle, mußte ich festsetllen, daß die Zeile
    ( USART_transmit_string ("Programm zur Spannungsueberwachung 10/2004 "); )
    immer wieder aufgerufen wird.

    Könnte das am Interrupt liegen ? Habt Ihr irgendwelche Ideen ?

    Code:
    #include <avr/io.h>
    #include <stdlib.h>
    #include <avr/signal.h>
    #include <avr/interrupt.h>
    #include <simple_delayroutinen.c>
    #include <io_modul.h>
    
    volatile unsigned int grenzwert;
    int hilfs;
    
    SIGNAL (SIG_UART_RECV) {
    	
    	hilfs=empfange();
    	
    }
    
    
    int main (void) {
    
    grenzwert=800;
    //Intialisierung
    	USART_Init ();
    	ad_init();
    	set_id();
    	v_ref(5);
    	
    	// Text ausgabe. Wiederholt sich unendlich. Warum ???
    	
    	USART_transmit_string ("Programm zur Spannungsueberwachung 10/2004 ");	
    	USART_transmit('\n');
    	USART_transmit('\r');
    	
    	
    	
    	DDRB = 0xff;
    	
    // Variablen	
    	int x=0;
    	char buffer [10];
    	unsigned erg=0;
    	
    	
    	
    	sei (); // Interrupt erlauben
    	
    
    	
    	delay_ms(8000); //Einschaltzeitverzögerung	
    	
    for(;;){
    	
    PORTB = 0xff; 	
    
    		for (int i=0;i<=3;i++) // Überwachen der Ports 0 bis i
    		{
    			erg=ad_port(i); 		// Port auslesen
    			if(erg < grenzwert)									
    			{	
    			
    			PORTB = 0xff-0x02;
    			delay_ms(1000);	 // Wenn Wert zu niedrig Pin2 von Port B einschalten
    			
    			}
    
    		}
    		}
    		
    return 0;
    }

  2. #2
    Erfahrener Benutzer Roboter-Spezialist
    Registriert seit
    23.05.2004
    Ort
    Untersöchering(Bayern,Alpenvorland)
    Alter
    29
    Beiträge
    215
    Ich seh jetzt eigentlich keinen Fehler im Quelltext. Aber wozu hast du diese Zeile bzw. den UART Recevier(Empfangen) Interrupt,
    SIGNAL (SIG_UART_RECV) {

    hilfs=empfange();

    }

    dein programm empfängt doch nie etwas. Du wertest die Variable hilfs auch nie aus, oder wird sie von einer Funktion aus <io_modul.h> gebraucht, da sie ja global ist. Deswegen kannst du UART_REC sicher weglassen.
    Gruß Muraad

  3. #3
    Neuer Benutzer Öfters hier
    Registriert seit
    10.10.2004
    Beiträge
    6
    Doch mein Program empfängt was.

    Ich kann mir per Terminal diverse Spannungswert usw. ausgeben lassen, Wertverändern, Resten(extern) usw. und sofort.

    Hab halt auf der Uni nur JAVA gelernt
    Deshalb schreib ich ins Hauptprg nur das Nötigste. Es gib aber noch ausreichend verkettete Unterprogramme...

  4. #4
    Neuer Benutzer Öfters hier
    Registriert seit
    10.10.2004
    Beiträge
    6
    Ach so.

    Die übergabe der Empfangendaten ans Hauptprg. hab ich zum Test rausgenommen.
    Wird trotzdem nicht schöner...

  5. #5
    Erfahrener Benutzer Roboter-Spezialist
    Registriert seit
    23.05.2004
    Ort
    Untersöchering(Bayern,Alpenvorland)
    Alter
    29
    Beiträge
    215
    Dann kann ich dir leider nicht weiter helfen. Der Quelltext des Hauptprogramms hat auf jeden Fall keine Fehler. Vielleicht hast du einen Fehler in USART_transmit_string().
    Was vielleicht noch der Fehler ist ist das du ein Leerzeichen zwischen USART_transmit_string und("Programm zur Spannungsueberwachung 10/2004 ") hast, es darf aber soweit ich weiß keins kommen.
    Is mir grad aufgefallen als ichs hier rein kopiert hab, und ich glaub irgendwie das ist der Fehler.
    Gruß Muraad

  6. #6
    Neuer Benutzer Öfters hier
    Registriert seit
    10.10.2004
    Beiträge
    6
    Hm,

    in meinen Debug-USART-Ausgaben hab ich auch Leerzeichen.
    Ist ja ein Zeichen wie jedes andere auch...

    Naja.
    Kann man nichts machen.
    Vielen Dank erstmal für Deine Mühe

  7. #7
    Erfahrener Benutzer Roboter-Spezialist
    Registriert seit
    23.05.2004
    Ort
    Untersöchering(Bayern,Alpenvorland)
    Alter
    29
    Beiträge
    215
    aber hast dus mal ohne Leerzeichnen zwischen Funktionsname und Parameterklammern versucht? würd mich nur interessieren.
    Gruß Muraad

  8. #8
    Gast
    Dann gehe ich mal davon aus, dass du RXCIE und TXCIE aktiviert hast in deiner USART-Init. Dass das nicht so geht wenn du für TX keine ISR schreibst, sollte dir klar sein.
    Gewöhn dir bitte an, immer den kompletten Code zu posten.

  9. #9
    Neuer Benutzer Öfters hier
    Registriert seit
    10.10.2004
    Beiträge
    6
    Also nochmal zu dem Programm.
    Diesmal mit vollständigen Quellcodes:


    usart_emp.h

    Code:
    #include <usart_bibliothek.h>
    int hilf=0;
    int id=1;
    
    /*void set_id(int x) // veraltet
    {
    id=x;
    }
    */
    void set_id (void) {
    	DDRC=0x00; //Port C = Input
    	id =PINC-240;  // Einlesen der PINs an Port C. Wert korrektur verbesserungswürdig
    	id=~id-65520;
    		
    	
    }
    
    int empfange (void) {
    	char buffer [10];
    	unsigned erg=0;
    	unsigned char data = 0;	
    	    data = USART_receive ();
    		if (data == '?'){
    			data = USART_receive ();
    			if (data == 'V'){
    				data = USART_receive ();
    				hilf=data;
    				hilf=hilf-48;
    				if (hilf==id ){
    					data = USART_receive ();
    					hilf=data;
    					hilf=hilf-48;
    					if (hilf<8)
    					{
    					erg=ad_port(hilf);
    					utoa(erg, buffer, 10);		// Wandelt in String	
    					USART_transmit('\t');
    					USART_transmit_string (buffer);
    					USART_transmit('\r');
    					USART_transmit('\n');
    					//return 0;
    					}	
    				}
    			}
    			else{
    				if(data == 'A'){
    				data = USART_receive ();
    				hilf=data;
    				hilf=hilf-48;
    				//char buffer [10];
    				unsigned erg=0;
    					if(hilf==id){
    						USART_transmit('\t');
    						for (int i=0;i<=7;i++)
    						{
    						int erg=ad_port(i);
    						utoa(erg, buffer, 10);		// Wandelt in String	
    						USART_transmit_string (buffer);
    						USART_transmit('\t');
    						}
    						USART_transmit('\r');
    						USART_transmit('\n');
    
    			}	}	}
    		
    		
    		}
    		else{
    			if(data == '!'){
    				//USART_transmit_string (" 1.schleife  ");
    				data = USART_receive ();
    				if(data == 'I'){
    				//USART_transmit_string (" 2.schleife  ");
    					data = USART_receive ();
    					hilf=data;
    					hilf=hilf-48;
    					if(hilf == id){
    					//USART_transmit_string (" 3.schleife  ");
    						//USART_transmit_string (" Reset ");
    						DDRB = 0xff;
    						PORTB = 0xff-0x01;
    						
    						delay_ms(3000);	
    					}
    				}	
    			
    				else{
    					if(data == 'T'){
    						int t=0;
    						int h=0;
    						int z=0;
    						int e=0;
    						int zwischen_erg=0;
    						data = USART_receive ();
    						hilf=data;
    						hilf=hilf-48;
    						if(hilf == id){
    							data = USART_receive ();	
    							hilf=data;
    							t=hilf-48;
    							zwischen_erg=zwischen_erg+t*1000;
    							
    							data = USART_receive ();	
    							hilf=data;
    							h=hilf-48;
    							zwischen_erg=zwischen_erg+h*100;
    							
    							data = USART_receive ();	
    							hilf=data;
    							z=hilf-48;
    							zwischen_erg=zwischen_erg+z*10;
    							
    							data = USART_receive ();	
    							hilf=data;
    							e=hilf-48;
    							zwischen_erg=zwischen_erg+e*1;
    							
    							// debug code
    							/*utoa(zwischen_erg, buffer, 10);		// Wandelt in String 	
    						USART_transmit_string (buffer);
    						USART_transmit('\t');
    							*/
    							return zwischen_erg;
    							
    					}	}	
    					else
    					{}
    					
    				}
    			
    			}
    			else
    			{}
    		
    		}
    		
    		
    		
    return 9;
    }
    usart_bibilothek.h

    Code:
    /***********************************************************
    	Funktionsbibliothek für den USART des Atmega8
    ***********************************************************/
    
    #include <avr/io.h>
    
    #define F_CPU 4000000
    #define USART_BAUD_RATE 9600
    #define USART_BAUD_SELECT (F_CPU/(USART_BAUD_RATE*16L)-1)
    
    void USART_Init(void) {
        UCSRB = _BV(RXCIE) | _BV(TXCIE) | _BV(RXEN) | _BV(TXEN); // wenn einer der zustände 1 dann schreiben
        UBRRL = (unsigned char) USART_BAUD_SELECT; 
    }
    
    void USART_transmit (unsigned char c) {
    	while (!(UCSRA & (1<<UDRE))) {}	//wenn speicherfrei und keine Fehler
    	UDR = c;
    }
    
    void USART_trans (unsigned int a)
    {
    while (!(UCSRA & (1<<UDRE))) {}
     UDR = a;
    }
    unsigned char USART_receive (void) {
        while(!(UCSRA & (1<<RXC))) {}
        return UDR;
    }
    
    void USART_transmit_string (unsigned char *string) {
        while (!(UCSRA & (1<<UDRE))) {}
    	while ( *string)
    		USART_transmit (*string++);
    }
    main_prg

    Code:
    #include <avr/io.h>
    #include <stdlib.h>
    #include <avr/signal.h>
    #include <avr/interrupt.h>
    #include <simple_delayroutinen.c>
    #include <io_modul.h>
    
    volatile unsigned int grenzwert;
    int hilfs;
    
    SIGNAL (SIG_UART_RECV) {
    int x=0;
    	char buffer [10];
    	unsigned erg=0;
    	
    hilfs=empfange();
    			
    	if(hilfs>10){
    		  grenzwert=hilfs;
    		
    			//debug code
    			
    			/*USART_transmit('\t');
    			USART_transmit_string (" Im interrupt ");
    			utoa(grenzwert, buffer, 10);
    			USART_transmit_string (buffer);
    			USART_transmit('\t');*/
    			
    	}
    }
    
    
    int main (void) {
    
    grenzwert=800;
    //Intialisierung
    	USART_Init ();
    	ad_init();
    	set_id();
    	v_ref(5);
    	USART_transmit_string ("!!! Spannungsüberwachung !!!");	
    	USART_transmit('\n');
    	USART_transmit('\r');
    	
    	DDRB = 0xff;
    	
    // Variablen	
    	int x=0;
    	char buffer [10];
    	unsigned erg=0;
    	
    	
    	
    	sei (); // Interrupt erlauben
    	
    
    	
    	delay_ms(8000); //Einschaltzeitverzögerung	
    	
    for(;;){
    	
    PORTB = 0xff; 	
    
    for (int i=0;i<=3;i++) // Überwachen der Ports 0 bis i
    {
    
    			erg=ad_port(i); 		// Port auslesen
    			if(erg < grenzwert)									
    			{	
    			
    			/*utoa(grenzwert, buffer, 10);    
    			USART_transmit('\t');
    			USART_transmit_string (" In Hauptprg ");
    			USART_transmit_string (buffer);
    			*/
    			
    			PORTB = 0xff-0x02;
    			delay_ms(1000);	 // Wenn Wert zu niedrig Pin2 von Port B einschalten
    			
    			//debug text	
    			/*utoa(i, buffer, 10);
    			USART_transmit_string (" Fehler bei  ");
    			USART_transmit_string (buffer);
    			utoa(grenzwert, buffer, 10);
    			USART_transmit('\t');
    			USART_transmit_string (buffer);
    			USART_transmit('\t');			
    			USART_transmit('\n');
    			USART_transmit('\r');
    			*/
    			}
    
    
    }
    }
    return 0;
    }
    io_modul.h
    Code:
    #include <avr/io.h>
    #include <stdlib.h>
    #include <avr/signal.h>
    #include <avr/interrupt.h>
    //#include <usart_bibliothek.h>
    #include <ad_read.h>
    #include <usart_emp.h>
    
    int daten (void) {
    	USART_Init ();
    // Variablen	
    	int x=0;
    	char buffer [10];
    	unsigned erg=0;
    	ad_init();
    	v_ref(5);
    	
    	
    	x=empfange();
    		if (x<8)
    		{
    		erg=ad_port(x);
    			utoa(erg, buffer, 10);		// Wandelt in String	
    			USART_transmit('\t');
    			USART_transmit_string (buffer);
    			
    	
    			
    			USART_transmit('\r');
    			USART_transmit('\n');
    			return 0;
    		}	
    		else
    		{
    		return x;
    		}
    
    
    
    }
    ad_read.h
    Code:
    #include <avr/io.h>
    #include <stdlib.h>
    #include <avr/signal.h>
    #include <avr/interrupt.h>
    //#include <usart_bibliothek.h>
    
    unsigned int vref=3;
    
    void v_ref(int x)
    	{
    	vref=x;
    	}
    
    void ad_init(void)
    	{
    	ADCSRA =  _BV(ADEN) | _BV(ADPS2); //Prescaler
    	}
    
    unsigned ad_port (int x)
    {
    unsigned int high_bit=0;
    unsigned int unten_bit=0;
    unsigned erg=0;
    	
    switch(x) // Portwahl
    	{
    	case 0: break;
    	case 1:	ADMUX |= _BV(MUX0);
    					break;
    	case 2:	ADMUX |= _BV(MUX1);
    					break;
    	case 3:	ADMUX = _BV(MUX0) | _BV(MUX1);
    					break;
    	case 4: ADMUX =  _BV(MUX2);
    					break;
    	case 5: ADMUX = _BV(MUX2) | _BV(MUX0);
    					break;
    	case 6: ADMUX = _BV(MUX2) | _BV(MUX1);
    					break;
    	case 7: ADMUX = _BV(MUX2) | (_BV(MUX1)|_BV(MUX0));
    					break;
    				
    	}
    	
    
    ADCSRA |= _BV(ADSC); // Konvertierung Starten
    while (ADCSRA & _BV(ADSC)) {}
    		//warte, bis ADSC gelöscht wird --> Ende der Konvertierung
    		
    unten_bit = ADCL;
    high_bit = ADCH;
    //erg=(high_bit);
    erg=((unten_bit+high_bit*256L)*vref)*1000L/1024L;		
    return erg;		
    }
    id_portc.h
    Code:
    #include <avr/io.h>
    #include <stdlib.h>
    #include <avr/signal.h>
    #include <avr/interrupt.h>
    //#include <usart_bibliothek.h>
    #include <ad_read.h>
    #include <usart_emp.h>
    
    int get_id (void) {
    
    // Variablen	
    	int id;
    	//char buffer [10];
    	//unsigned erg=0;
    	
    
    
    	DDRC=0x00; //Port C = Input
    	
    	
    	id =PINC-240;  // Einlesen der PINs an Port C. Wert korrektur verbesserungswürdig
    	id=~id-65520;
    		
    	
    }

  10. #10
    Gast
    UCSRB = _BV(RXCIE) | _BV(TXCIE) | _BV(RXEN) | _BV(TXEN);
    -->
    UCSRB = _BV(RXCIE) | _BV(RXEN) | _BV(TXEN);

    Ich habe die aktivierten Interrupts mittlerweile auch im Programm auf meiner Homepage auskommentiert, da scheinbar viele die Programmschnipsel einfach benutzen, ohne sich die Rubrik dazu richtig durchzulesen.

+ Antworten
Seite 1 von 2 12 LetzteLetzte

Berechtigungen

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