Hallo,
so habe die Probleme gelöst es funktioniert alles. Naja fast alles, muss jezt noch mein Kommunikation mit VB.Net hinbekommen (auch schon fast am verzweifeln).
Ich möchte mich mal bei allen beteiligten bedanken, für die groß Hilfe, viel Dank!
Das Hauptproblem lag wahrscheinlich darin das mein 12MHz Quarz einen defekt hatte bzw hat, habe das jetzt alles auf dem intern 8MHz laufen und funktioniert alles,
es waren aber auch noch genug kleine fehler dabei.
Ich habe mein Aufteilung mit der "strtok" und "strcpy" funktionen erledigt.
Mit der strtok habe ich auf meine String auf Trennzeichen untersucht
und mit der strcpy in die entsprechenden Variablen gespeichert.
Wenn ich jetzt über das RealTerm eine 1,2,3,4\n sende veränderen sich auch die Blink Zeiten entsprechend.
Hier mal mein Programm
Code:
#include <avr/io.h>
#include <util/delay.h>
#include <stdlib.h>
#include <string.h>
#define F_CPU 8000000 /* evtl. bereits via Compilerparameter definiert */
#define BAUD 300 // Baudrate
// Berechnungen
#define UBRR_VAL ((F_CPU+BAUD*8)/(BAUD*16)-1) // clever runden
#define BAUD_REAL (F_CPU/(16*(UBRR_VAL+1))) // Reale Baudrate
#define BAUD_ERROR ((BAUD_REAL*1000)/BAUD) // Fehler in Promille, 1000 = kein Fehler.
#include <util/setbaud.h>
struct _S_DATA S_DATA;
int Line[9]; //Array vom Typ int
//------------------------------------------------------------------------------------------
//USART initialisieren
void uart_init(void)
{
//Set Baudrate
UBRRH = UBRR_VAL >> 8;
UBRRL = UBRR_VAL & 0xFF;
UCSRB |= (1<<TXEN) | (1<<RXEN); //UART TX und RX einschalten
UCSRC = (1<<URSEL) |(1<<UCSZ1) | (1<<UCSZ0); // Einstellen des Datenformats: 8 Datenbits, 1 Stoppbit
}
//------------------------------------------------------------------------------------------
struct _S_DATA
{
char Rot[2];
char RG [2];
char GR [2];
char GE [2];
};
//------------------------------------------------------------------------------------------
//Warteschleife
void delay_ms(unsigned int ms)
{
unsigned int zaehler;
while (ms) {
zaehler = F_CPU / 5000;
while (zaehler) {
__asm volatile("nop");
zaehler--;
}
ms--;
}
}
//------------------------------------------------------------------------------------------
// Zeichen senden
int uart_putc(unsigned char c)
{
while (!(UCSRA & (1<<UDRE)))
{
}
UDR = c;
return 0;
}
//------------------------------------------------------------------------------------------
//String senden
void uart_puts(char *s)
{
while (*s)
{ /* so lange *s != '\0' also ungleich dem "String-Endezeichen(Terminator)" */
uart_putc(*s);
s++;
}
}
//------------------------------------------------------------------------------------------
//Zeichen empfangen
uint8_t uart_getc(void)
{
while (!(UCSRA & (1<<RXC))) //warten bis Zeichen verfügbar
;
return UDR; //Zeichen aus UDR an Aufrufer zurückgeben
}
//------------------------------------------------------------------------------------------
//Sting empfangen
void uart_gets(char *Buffer, uint8_t MaxLen)
{
uint8_t NextChar;
uint8_t StringLen = 0;
NextChar = uart_getc(); // Warte auf und empfange das nächste Zeichen
// Sammle solange Zeichen, bis:
// * entweder das String Ende Zeichen kam
// * oder das aufnehmende Array voll ist
while( NextChar != '\n' && StringLen < MaxLen - 1 ) {
*Buffer++ = NextChar;
StringLen++;
NextChar = uart_getc();
}
// Noch ein '\0' anhängen um einen Standard
// C-String daraus zu machen
*Buffer = '\0';
}
//------------------------------------------------------------------------------------------
//String Zerlegung
void string_zer(void)
{
unsigned char i; //Case Hochzählung
char Trennzeichen[]=","; //Trennungszeichen
char *ptr; //Variable zum zwischenspeichern
i = 2; //Variable i auf 2 setzten
ptr=strtok(Line, Trennzeichen); // Line durchsuchen bis zum Trennzeichen und in ptr zwischen speichern
strcpy (S_DATA.Rot, ptr); // Erster Teil in Rot kopiern wo in der Struct _S_DATA liegt
while (ptr != NULL) //weiter durchsuchen bis das nächste Trennzeichen oder Ende kommt
{
ptr = strtok (NULL, Trennzeichen); // Line durchsuchen bis zum Trennzeichen oder Ende und in ptr zwischen speichern
switch (i) //Um in Unterschiedlichen Variablen zu speichern
{
case 2: strcpy(S_DATA.RG,ptr); break;
case 3: strcpy(S_DATA.GR,ptr); break;
case 4: strcpy(S_DATA.GE,ptr); break;
}
i++; //Variable i um eins hochzählen
}
}
//------------------------------------------------------------------------------------------
//Hauptprogramm
int main(void)
{
//Variablen Deklartion
int time = 1000;
int time1 = 1000;
char Buffer[9]; //String mit maximal 8 zeichen
int a; //Umwandlung ascii zu integer
DDRB = 0xFF;
PORTB = 0xFF;
uart_init(); // UART einstellen
while (1)
{
//---------------------------------------------------------------------------------------------
if ((UCSRA & (1<<RXC))) //überprüfen ob neue Zeichen vorhanden sind
{
uart_gets(Line, sizeof(Line)); //Zeichen wurden empfangen, jetzt abholen
string_zer(); //String in seine Teile zerlegen
uart_puts(S_DATA.Rot);
uart_puts(S_DATA.GE);
a = atoi (S_DATA.Rot); //Rot in integer wandeln
time = a *1000; // mal 1000 um auf sekunden zu kommen
itoa (time, Buffer, 10); //time in char umwandeln
uart_puts(Buffer); //Buffer senden
}
//---------------------------------------------------------------------------------------------
else
{
PORTB = 0b00000000;
delay_ms(time1);
PORTB = 0b00001111;
delay_ms(time);
PORTB = 0b11110000;
delay_ms(time1);
PORTB = 0b11111111;
delay_ms(time);
}
}
}
Zitieren
Lesezeichen