hexadezimale Werte im Array !

[casa74]

Ok habe hier mal versucht, mit den Erkenntnissen aus den letzten Beiträgen,ein Programm zu basteln!

Bin mir absolut nicht sicher ob das von der Struktur bzw. Stil so hinhaut !!
Vielleicht hat ja jemand lust da mal schnell drüber zu fuchsen.
Bin für jeden Hinweis dankbar !


MFG
Casa

/*************************************************
Empfangen der GPS-daten,
zusammenfügen von GPS-Daten in einen Bitrahmen  und
Senden des Bitrahmens
**************************************************/



#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/signal.h>
#include <usart_bibliothek.h>
#define      gps_data_size     96 /* Wert 96 wird der Variablen Datenfeld zugewiesen  */
#define      header_data_size  30 /* Wert 30 wird der Variablen header_data_size zugewiesen*/



static int ifr;           /* Definition eines Zählers für for in frame_data*/
static int ih;            /* Definition eines Zählers für for in header_data*/
static int ig;            /* Definition eines Zählers für for in gps_data*/

static unsigned char gps_data[gps_data_size]; /* USART Array für Dateneingänge */
static unsigned char pointer;                 /* USART pointer  */

static unsigned char frame[header_size + gps_data_size + crc_size]; /* Datenrahmen komplett*/

static unsigned char header[header_size]={0x82,0xA4,0xA6,0x8E,0x60,0x60,0x9c,0x68,0xA8,0xB0,0x92,
                                   0x40,0x76,0xA4,0x8A,0x98,0x82,0xB2,0x40,0x60,0xAE,0x92,
                                   0x88,0x8A,0x64,0x40,0x65,0x03,0xF0};/*headerdaten*/





/*----------- Initialisieren des USART -----------------------------------------------*/

                  
                                                               
	UBRRH = 0;
	UBRRL = 191;  /*Baudrate des USART wird bei 4MHZ auf 4800 Baud gesetzt*/
	
        UCSRC = (1<<URSEL)|(3<<UCSZ0); /*Datenformat auf 1Byte gesetzt, kein Paritätbit, kein Stopbit*/
                        
	UCSRB = (1<<RXCIE)|(1<<TXCIE)|(1<<RXEN)|(1<<TXEN);  /*Aktivieren der Empfangs 
                        und Sendebereitschaft und der Interrupts*/
	
   





       /*------Programmeinstieg------------------*/


void main(void)
{

       
        
   while (!(UCSRA & (1<<RXC));              /* Warten bereit zum empfang*/
   
        {   
           if (++pointer == gps_data_size)    /* Zählvariable pointer wächst bis auf den*/
                                              /*Wert von Datenfeld (100) an */
           pointer = 0;                       /* Erreicht Pointer den Wert von */
                                              /*Datenfeld, wird pointer wieder auf 0*/
                                              /*zurückgesetzt */
           gps_data[pointer] = UDR;	        /* Bei jeder Inkrementierung von pointer
                                                   wird der aktuellere Inhalt vom UDR 
        }                                          in das entsprechende Datenfeld vom 
                                                   Array gesetzt. */
	
      }


        /*---------Es folgt zuerst die Zuweisung der header_daten in das Frame Array ---------*/

       



          for(i=0;i<HEADER_SIZE; i++) /* Anweisung die bis headersize
                                                           raufzählt*/

                  { 
                        frame[i] = header_data[i];   /* Mit jedem schritt wird 
                                                                  Inhalt aus header-data in 
                                                                  frame geschoben*/
                  }





       /*--- Daten aus gps_data werden im Anschluss an Header den
              Array-Frame übergeben---*/



           for(ig=HEADER_SIZE;ig<gps_data_size + header_size; ig++)

         { 
            frame[i] = gps_data[i] 
         }





       /* ----Datenausgabe aus dem ARRAY "Frame" an den
               TX des USART-----*/
                    
                    
                    
    
             while (!(UCSRA & (1<<RXC));              
      
              {    
                  UDR=0x07               /*senden des Anfangsflag*/
    
              }   


 

              while (!(UCSRA & (1<<UDRE) ) );          

        {
     
      for (ifr=0; ifr<header_size + gps_data_size + crc_size; ifr++) 
                                                             /* wird  hochgezählt, solange
                                                                 ifr kleiner als die Länge 
                                                                 von komplettarray */  
                     {
 
                                if (!frame[ifr]) /* wenn Inhalt des aprs == /0 */
         
                                 break;           /* wird Schleife beendet */

                                 UDR=frame[ifr];  /* Innerhalb der 
                                                           for- Bedingung wird einzeln 
                                                          jeder Inhalt des Array seriell 
                                                          über usart  ausgesendet */ 
                     } 
        }


            while (!(UCSRA & (1<<UDRE) ) );

    
                           {
                               UDR = 0x7E /*senden des Endflags*/
                           }
}

[/code]

[cavegn]

hi

funktioniert es denn?

was mir gerade aufgefallen ist - eigentlich ist es überflüssig, dass du frame und header seperat definerst.

static unsigned char frame[header_size + gps_data_size + crc_size]=
{0x82,0xA4,0xA6,0x8E,0x60,0x60,0x9c,0x68,0xA8,0xB0 ,0x92,
0x40,0x76,0xA4,0x8A,0x98,0x82,0xB2,0x40,0x60,0xAE, 0x92,
0x88,0x8A,0x64,0x40,0x65,0x03,0xF0};

würde reichen, glaube ich. dann kannst du auch die for-schlaufe, die das array mit den headerdaten füllt, sparen.

ansonsten:

die formatierung sieht bei mir nicht so schön aus, das liegt aber an meinem editor, glaube ich

ahja, ein paar funktionen zur strukturierung würden das programm ein wenig lesbarer machen

cu

chris

[casa74]

Wenn ich deine Version der Framebildung richitg verstanden habe,
wird also der Frame direkt in voller Größe definiert und die ersten Plätze
einfach schon mit den konstanten Daten aufgefüllt?!?
werde es mal versuchen !

Habe im moment leider keine Möglichkeit das in der Praxis zu testen.
Kommt aber bald.
Wollte halt schonmal vorher wissen, ob zumindest von der Syntax alles stimmt
und vor allem die Sende und Empfangsanweisungen richitg in C von mir programmiert wurde.

Mit der Strukturierung hast du natürlich recht, werde es noch in einzelne Funktionsblöcke aufteilen.
Ich glaube das hiess Prototype-style, oder so ! muss erstmal sehen wie das funzt !
Habe es halt jetzt nur alles in eine Funktion gepackt, weil es vom Verständnis für mich "noch" einfacher ist.

Gruß und schönen Abend!

Casa74

[Psiyou]

Hi,

also da sind ein paar Fehler drinne... Denke mal nicht das Du versucht hast das zu Kompilieren.... Solltest Du in Zukunft tun, Fehler anschauen, selber überlegen und erst dann fragen (sonst lernst auch nichts, nur wer schon mal Stundenlang davor gessesn hat und verzweifekt ist kapiert auch was ).
Erst mal hast Du unten in den for schleifen bei den Zuweisungen das ; vergessen. Dann die Initialisierung der UART kann nicht ausserhalb einer funktion erfolgen (dort können nur globale Variablen definiert werden, Funktionsprototypen, Preprozessoranweisungen etc). Mach am besten eine init() funktion (siehe Bsp).
Dann nimt man wenn möglich auch keine globalen Variablen sondern lokal. Vor allem wenn es nur eine funktion gibt
Und was Du da in der ersten Schleife machts mit den Pointer gibt nicht wirklich sinn... Lass so was erst mal aussen vor und arbeite Dich in die Grundfunktionsweisen von C ein.
Ich poste hier mal ein Bsp wie ich das ungefähr lösen wurde als kleine Hilfe, jetzt Dein Prog durchzusprechen währe etwas zu langwierig...

#define	gps_data_size		96 /* Wert 96 wird der Variablen Datenfeld zugewiesen  */
#define	header_data_size	30 /* Wert 30 wird der Variablen header_data_size zugewiesen*/
#define	crc_size	1

void init(void); //Prototyp

void main(void)
{

	int i=0; //schleifenzaehler       
	unsigned char data[header_data_size+gps_data_size+crc_size]={0x82,0xA4,0xA6,0x8E,0x60,
									0x60,0x9c,0x68,0xA8,0xB0,0x92,0x40,0x76,0xA4,0x8A,0x98,
									0x82,0xB2,0x40,0x60,0xAE,0x92,0x88,0x8A,0x64,0x40,0x65,
									0x03,0xF0};/*headerdaten*/
	
	init();	//UART initialisieren...
	
	while(1) //unendlich schleife...
	{
		//empfangen der Daten
		for(i=gps_data_size;i<gps_data_size + header_data_size; i++)
		{
			while (!(UCSRA & (1<<RXC)));/* Warten bereit zum empfang*/
			data[i] = UDR;
		}
		
		//hier fehlt noch Berechnung der Pruefsumme...

		UDR=0x07;               /*senden des Anfangsflag*/

		for (i=0; i<header_data_size + gps_data_size + crc_size; i++)	//senden der Daten
		{
			while (!(UCSRA & (1<<UDRE) ) );
			UDR = data[i];
        }

		while (!(UCSRA & (1<<UDRE)));

		UDR = 0x7E; /*senden des Endflags*/
	}//while(1)

}//main()



/*----------- Initialisieren des USART -----------------------------------------------*/

void init(void)
{
    UBRRH = 0;
    UBRRL = 191;  /*Baudrate des USART wird bei 4MHZ auf 4800 Baud gesetzt*/
   
	UCSRC = (1<<URSEL)|(3<<UCSZ0); /*Datenformat auf 1Byte gesetzt, kein Paritätbit, kein Stopbit*/
                       
	UCSRB = (1<<RXCIE)|(1<<TXCIE)|(1<<RXEN)|(1<<TXEN);  /*Aktivieren der Empfangs
                        und Sendebereitschaft und der Interrupts*/
}//init()

Hab die Initanweisungen jetzt nicht überprüft da ich die Header auch nicht habe.
Wenn irgwnd was unklar ist noch mal fragen.