UART Probleme
Im Unterforum Microcontroller - Beschreibung: Hardware - Software - Ideen - Projekte
| Autor |
|
|
|
BID = 527254
Rambodischien
Schreibmaschine
Beiträge: 1341
Wohnort: Österreich
|
|
Hallo
Ich habe beim Programmieren der UART-Schnittstelle folgendes Problem.
Das senden eines char[] funktioniert einwandfrei. Aber leider kann ich kein richtiges Zeichen empfangen. Ich hätte das ganze auch gerne gespeichert in einem char[].
Hier mal der Code den ich zusammengeschrieben habe (AVR Studio):
| Code : |
unsigned char uart_getc(void)
{
while ( !(UCSRA & (1<<RXC)) ) //Warten bis etwas empfangen wurde
;
return UDR; //Empfangenes zeichen zurückgeben
}
char uart_empfangen(void)
{
do
{
c=uart_getc();
if (c!='\r')
{
ergebnis[j]=c;
j++;
}
}
while(j!=99 && c!='\r');
ergebnis[100]="[1code]
unsigned char uart_getc(void)
{
while ( !(UCSRA & (1<<RXC)) ) //Warten bis etwas empfangen wurde
;
return UDR; //Empfangenes zeichen zurückgeben
}
char uart_empfangen(void)
{
do
{
c=uart_getc();
if (c!='\r')
{
ergebnis[j]=c;
j++;
}
}
while(j!=99 && c!='\r');
ergebnis[100]="\0";
return ergebnis;
}
[/code1]";
return ergebnis;
}
|
|
Ich hoffe ihr könnt mir dabei helfen.
Mfg
Rambodischien |
|
BID = 527274
DonComi
Inventar
Beiträge: 8605
Wohnort: Amerika
|
|
Zusammengeschrieben triffts 100%.
Vorallem hast du vergessen, einige andere Kodeteile zu liefern, oder wo ist die Deklaration von c, *empfangen und j?
Bitte den ganzen Quelltext posten.
Aber, so wie der Kode jetzt grade aussieht, wirds nur einige Fehlermeldungen vom Compiler geben, das ist ja alles wild durcheinander.
Als ernstgemeinter Tipp:
Deklarationen von (globalen) Funktionen in entsprechende Headerdateien, samt eventuell globalen Variablen (ich gehe eben davon aus, dass *ergebnis und c und j global sind, sonst würde der Compiler meckern), den Programmkode in eine Kodedatei (Programmcode) schreiben. Alles andere ist murks.
Edit:
Ah, du hast wohl einige [ code ]-Tags durcheinandergeworfen. Die Routine uart_empfangen(void) gibt einen char zurück, am Ende willst du aber ein char[100] als Returnwert übergeben. Das haut so nicht hin.
Es gibt viele Möglichkeiten, das besser zu machen. Das ist aber hier nicht gefragt.
_________________
[ Diese Nachricht wurde geändert von: DonComi am 11 Jun 2008 16:00 ] |
|
BID = 527282
Rambodischien
Schreibmaschine
Beiträge: 1341
Wohnort: Österreich
|
Danke für die schnelle Antwort.
Hier einmal der ganze Code:
| Code : |
#include <avr/io.h>
#include <inttypes.h>
#include <AVR/io.h> //Definition der Ports
#include <string.h>
#include <AVR/interrupt.h>
#include <AVR/signal.h>
#define BAUD 9600UL
#define UBRR_BAUD ((F_CPU/(16UL*BAUD))-1)
uint8_t buffer;
char *UARTText;
char UARTzeichen;
int i=0;
int j=0;
char ergebnis[100];
char c;
void uart_init(void)
{
UBRRH = (uint8_t) (UBRR_BAUD>>8); // Baudrate einstellen (Normaler Modus)
UBRRL = (uint8_t) (UBRR_BAUD & 0x0ff);
UCSRB = (1<<RXEN)|(1<<TXEN); // Aktivieren von receiver und transmitter
UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0);// Einstellen des Datenformats: 8 Datenbits, 1 Stoppbit
}
void uart_senden(char Text [])
{
int i=0;
UARTText=(char*) Text;
UARTzeichen=*(UARTText+i);
while(UARTzeichen !='[1code]
#include <avr/io.h>
#include <inttypes.h>
#include <AVR/io.h> //Definition der Ports
#include <string.h>
#include <AVR/interrupt.h>
#include <AVR/signal.h>
#define BAUD 9600UL
#define UBRR_BAUD ((F_CPU/(16UL*BAUD))-1)
uint8_t buffer;
char *UARTText;
char UARTzeichen;
int i=0;
int j=0;
char ergebnis[100];
char c;
void uart_init(void)
{
UBRRH = (uint8_t) (UBRR_BAUD>>8); // Baudrate einstellen (Normaler Modus)
UBRRL = (uint8_t) (UBRR_BAUD & 0x0ff);
UCSRB = (1<<RXEN)|(1<<TXEN); // Aktivieren von receiver und transmitter
UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0);// Einstellen des Datenformats: 8 Datenbits, 1 Stoppbit
}
void uart_senden(char Text [])
{
int i=0;
UARTText=(char*) Text;
UARTzeichen=*(UARTText+i);
while(UARTzeichen !='\0')
{
UARTzeichen=*(UARTText+i);
while ( !( UCSRA & (1<<UDRE)) )// Warten bis Buffer frei
;
UDR = UARTzeichen;//Daten in buffer laden und absenden
i++;
}
}
unsigned char uart_getc(void)
{
while ( !(UCSRA & (1<<RXC)) ) //Warten bis etwas empfangen wurde
;
return UDR; //Empfangenes zeichen zurückgeben
}
char uart_empfangen(void)
{
do
{
c=uart_getc();
if (c!='\r')
{
ergebnis[j]=c;
j++;
}
}
while(j!=99 && c!='\r');
ergebnis[100]='\0';
return ergebnis;
}
[/code1]')
{
UARTzeichen=*(UARTText+i);
while ( !( UCSRA & (1<<UDRE)) )// Warten bis Buffer frei
;
UDR = UARTzeichen;//Daten in buffer laden und absenden
i++;
}
}
unsigned char uart_getc(void)
{
while ( !(UCSRA & (1<<RXC)) ) //Warten bis etwas empfangen wurde
;
return UDR; //Empfangenes zeichen zurückgeben
}
char uart_empfangen(void)
{
do
{
c=uart_getc();
if (c!='\r')
{
ergebnis[j]=c;
j++;
}
}
while(j!=99 && c!='\r');
ergebnis[100]='[1code]
#include <avr/io.h>
#include <inttypes.h>
#include <AVR/io.h> //Definition der Ports
#include <string.h>
#include <AVR/interrupt.h>
#include <AVR/signal.h>
#define BAUD 9600UL
#define UBRR_BAUD ((F_CPU/(16UL*BAUD))-1)
uint8_t buffer;
char *UARTText;
char UARTzeichen;
int i=0;
int j=0;
char ergebnis[100];
char c;
void uart_init(void)
{
UBRRH = (uint8_t) (UBRR_BAUD>>8); // Baudrate einstellen (Normaler Modus)
UBRRL = (uint8_t) (UBRR_BAUD & 0x0ff);
UCSRB = (1<<RXEN)|(1<<TXEN); // Aktivieren von receiver und transmitter
UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0);// Einstellen des Datenformats: 8 Datenbits, 1 Stoppbit
}
void uart_senden(char Text [])
{
int i=0;
UARTText=(char*) Text;
UARTzeichen=*(UARTText+i);
while(UARTzeichen !='\0')
{
UARTzeichen=*(UARTText+i);
while ( !( UCSRA & (1<<UDRE)) )// Warten bis Buffer frei
;
UDR = UARTzeichen;//Daten in buffer laden und absenden
i++;
}
}
unsigned char uart_getc(void)
{
while ( !(UCSRA & (1<<RXC)) ) //Warten bis etwas empfangen wurde
;
return UDR; //Empfangenes zeichen zurückgeben
}
char uart_empfangen(void)
{
do
{
c=uart_getc();
if (c!='\r')
{
ergebnis[j]=c;
j++;
}
}
while(j!=99 && c!='\r');
ergebnis[100]='\0';
return ergebnis;
}
[/code1]';
return ergebnis;
}
|
|
Headerfile:
| Code : |
#ifndef _AVR_Headerfiles_h_
#define _AVR_Headerfiles_h_
void uart_init(void); //UART
void uart_senden(char data);
unsigned char uart_empfangen(void);
#endif
|
|
jetzt müsste es alles sein. Sorry dachte ich schreibe nur die Empfangsroutine hinein damit nicht so viel Code zu lesen ist.
Das mit dem Senden funktioniert ja einwandfrei nur möchte ich die Empfangene Zeichen in ein char[] schreiben.
Mfg
Rambodischien
|
BID = 527311
DonComi
Inventar
Beiträge: 8605
Wohnort: Amerika
|
So richtig konsequent programmierst du nicht grade:
* wenn im Header steht, dass der Rückgabetyp unsigned char ist, dann muss das auch so bei der implementierten Funktion sein!
* warum benutzt du int? int ist signed int, und prinzipiell größer-gleich 16 Bit breit. Nimm auch für die Iteratoren unsigned char. (man kann zwar sowohl einstellen, dass einfach nur 'char' unsigned ist, und auch int nur 8 Bit ohne Vorzeichen belegt, aber das ist nicht standardkonform). Wenn du aber schon u_int8 benutzt (also typedef unsigned char u_int8), dann bleib doch dabei  , oder eben unsigned char.
* ergebnis[100] ist 100 Byte lang, wenn du auf ergebnis[100] allerdings zugreifst, schreibst du eventuell in eine Speicherzelle, in der du nichts zu suchen hast! Bedenke, man beginnt bei 0 zu zählen.
* du kannst in einer Funktion, die einen Rückgabetyp von char hat, kein Array zurückgeben! Höchstens die Dereferenzierung in Form von ergebnis[n] aber nicht einfach ergebnis! Mit Zeigern lässt sich das lösen.
Ich würde in diesem Fall das ganze statisch machen, eventuell gleich in einer ISR:
/* Global im Header /*
unsigned char *rxData;
/* Anfang */ ISR()
{
static unsigned char ptr;
static unsigned char ergebnis[100];
if(ergebnis[ptr]=get_uart()!='r' && ptr<99)
ptr++;
else{
ergebnis[ptr]=0;
rxdata=&ergebnis[0];
setze_flagge;
ptr=0;
};
};
Mit setze_flagge meine ich, dass damit zum Beispeil global mitgeteil werden kann, dass der Puffer voll ist oder ein Return Carriage empfangen wurde.
Die Daten stehen danach in rxdata und sind nullterminiert.
Mann kann auch einen Funktionspointer einrichten, der dereferenziert wird, sobald der Puffer entweder voll ist oder ein r empfangen wurde. Dann entfällt das Pollen der Flagge.
Edit: Ich habe hier noch get_uart() oder so ähnlich drin. Das macht natürlich in einer ISR keinen Sinn, denn die ISR wird ja ausgeführt, sobald das I-Flag dafür gesetzt ist. Du kannst also gleich die Daten aus dem UART Data Register abholen:
if(ergebnis[ptr]=UDR!='\r' && ...)
_________________
[ Diese Nachricht wurde geändert von: DonComi am 11 Jun 2008 19:45 ]
|
BID = 527340
Rambodischien
Schreibmaschine
Beiträge: 1341
Wohnort: Österreich
|
Zitat :
DonComi hat am 11 Jun 2008 19:41 geschrieben :
|
So richtig konsequent programmierst du nicht grade:
|
Kommt von daher das ich so gut wie keine Ahnung habe und ich seit ca. einem halben Jahr programmiere.
Aber ich habe es geschafft(dank deiner Hilfe ) nur habe ich ein kleines Problem das die Zeichen die ich empfange werden immer wieder darangehängt.
| Code : |
char *UARTText;
char UARTzeichen;
int i=0;
char c;
char *empfangen;
char ergebnis[100];
int j=0;
unsigned char uart_getc(void)
{
while ( !(UCSRA & (1<<RXC)) ) //Warten bis etwas empfangen wurde
;
return UDR; //Empfangenes zeichen zurückgeben
}
char* uart_empfangen(void)
{
do
{
c=uart_getc();
if (c!='\r')
{
ergebnis[j]=c;
j++;
}
}
while(j!=99 && c!='\r');
ergebnis[j]='[1code]
char *UARTText;
char UARTzeichen;
int i=0;
char c;
char *empfangen;
char ergebnis[100];
int j=0;
unsigned char uart_getc(void)
{
while ( !(UCSRA & (1<<RXC)) ) //Warten bis etwas empfangen wurde
;
return UDR; //Empfangenes zeichen zurückgeben
}
char* uart_empfangen(void)
{
do
{
c=uart_getc();
if (c!='\r')
{
ergebnis[j]=c;
j++;
}
}
while(j!=99 && c!='\r');
ergebnis[j]='\0';
return empfangen=(char*)ergebnis;
}
[/code1]';
return empfangen=(char*)ergebnis;
}
|
|
Mfg
Rambodischien
|
BID = 527344
DonComi
Inventar
Beiträge: 8605
Wohnort: Amerika
|
Bitte auch hier konkreter:
Am besten mal ein Beispeil oder die Ausgabe hier posten.
_________________
|
BID = 527348
Rambodischien
Schreibmaschine
Beiträge: 1341
Wohnort: Österreich
|
Es ist halt verdammt viel Code zum lesen und ich wollte nicht jemand qualifiziertes verschrecken  .
also gut:
UART.c
| Code : |
#include <avr/io.h>
#include <inttypes.h>
#include <AVR/io.h> //Definition der Ports
#include <string.h>
#include <AVR/interrupt.h>
#include <AVR/signal.h>
#define BAUD 9600UL
#define UBRR_BAUD ((F_CPU/(16UL*BAUD))-1)
uint8_t buffer;
char *UARTText;
char UARTzeichen;
int i=0;
char c;
char *empfangen;
char ergebnis[100];
int j=0;
void uart_init(void)
{
UBRRH = (uint8_t) (UBRR_BAUD>>8); // Baudrate einstellen (Normaler Modus)
UBRRL = (uint8_t) (UBRR_BAUD & 0x0ff);
UCSRB = (1<<RXEN)|(1<<TXEN); // Aktivieren von receiver und transmitter
UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0);// Einstellen des Datenformats: 8 Datenbits, 1 Stoppbit
}
void uart_senden(char Text [])
{
int i=0;
UARTText=(char*) Text;
UARTzeichen=*(UARTText+i);
while(UARTzeichen !='[1code]
#include <avr/io.h>
#include <inttypes.h>
#include <AVR/io.h> //Definition der Ports
#include <string.h>
#include <AVR/interrupt.h>
#include <AVR/signal.h>
| Code : |
#define BAUD 9600UL
#define UBRR_BAUD ((F_CPU/(16UL*BAUD))-1)
uint8_t buffer;
char *UARTText;
char UARTzeichen;
int i=0;
char c;
char *empfangen;
char ergebnis[100];
int j=0;
void uart_init(void)
{
UBRRH = (uint8_t) (UBRR_BAUD>>8); // Baudrate einstellen (Normaler Modus)
UBRRL = (uint8_t) (UBRR_BAUD & 0x0ff);
UCSRB = (1<<RXEN)|(1<<TXEN); // Aktivieren von receiver und transmitter
UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0);// Einstellen des Datenformats: 8 Datenbits, 1 Stoppbit
}
void uart_senden(char Text [])
{ |
|
int i=0;
UARTText=(char*) Text;
UARTzeichen=*(UARTText+i);
while(UARTzeichen !='�')
{
UARTzeichen=*(UARTText+i);
while ( !( UCSRA & (1<<UDRE)) )// Warten bis Buffer frei
;
UDR = UARTzeichen;//Daten in buffer laden und absenden
i++;
}
}
unsigned char uart_getc(void)
{
while ( !(UCSRA & (1<<RXC)) ) //Warten bis etwas empfangen wurde
;
return UDR; //Empfangenes zeichen zurückgeben
}
char* uart_empfangen(void)
{
do
{
c=uart_getc();
if (c!='r')
{
ergebnis[j]=c;
j++;
}
}
while(j!=99 && c!='r');
ergebnis[j]='�';
return empfangen=(char*)ergebnis;
}
[/code1]')
{
UARTzeichen=*(UARTText+i);
while ( !( UCSRA & (1<<UDRE)) )// Warten bis Buffer frei
;
UDR = UARTzeichen;//Daten in buffer laden und absenden
i++;
}
}
unsigned char uart_getc(void)
{
while ( !(UCSRA & (1<<RXC)) ) //Warten bis etwas empfangen wurde
;
return UDR; //Empfangenes zeichen zurückgeben
}
char* uart_empfangen(void)
{
do
{
c=uart_getc();
if (c!='r')
{
ergebnis[j]=c;
j++;
}
}
while(j!=99 && c!='r');
ergebnis[j]='[1code]
#include <avr/io.h>
#include <inttypes.h>
#include <AVR/io.h> //Definition der Ports
#include <string.h>
#include <AVR/interrupt.h>
#include <AVR/signal.h>
| Code : |
#define BAUD 9600UL
#define UBRR_BAUD ((F_CPU/(16UL*BAUD))-1)
uint8_t buffer;
char *UARTText;
char UARTzeichen;
int i=0;
char c;
char *empfangen;
char ergebnis[100];
int j=0;
void uart_init(void)
{
UBRRH = (uint8_t) (UBRR_BAUD>>8); // Baudrate einstellen (Normaler Modus)
UBRRL = (uint8_t) (UBRR_BAUD & 0x0ff);
UCSRB = (1<<RXEN)|(1<<TXEN); // Aktivieren von receiver und transmitter
UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0);// Einstellen des Datenformats: 8 Datenbits, 1 Stoppbit
}
void uart_senden(char Text [])
{ |
|
int i=0;
UARTText=(char*) Text;
UARTzeichen=*(UARTText+i);
while(UARTzeichen !='�')
{
UARTzeichen=*(UARTText+i);
while ( !( UCSRA & (1<<UDRE)) )// Warten bis Buffer frei
;
UDR = UARTzeichen;//Daten in buffer laden und absenden
i++;
}
}
unsigned char uart_getc(void)
{
while ( !(UCSRA & (1<<RXC)) ) //Warten bis etwas empfangen wurde
;
return UDR; //Empfangenes zeichen zurückgeben
}
char* uart_empfangen(void)
{
do
{
c=uart_getc();
if (c!='r')
{
ergebnis[j]=c;
j++;
}
}
while(j!=99 && c!='r');
ergebnis[j]='�';
return empfangen=(char*)ergebnis;
}
[/code1]';
return empfangen=(char*)ergebnis;
}
|
|
Headerfile.h
| Code : |
#ifndef _AVR_Headerfiles_h_
#define _AVR_Headerfiles_h_
void delay_us(int x); //Verzögerungsschleife
void delay_ms(int y);
void lcd_init(void); //LCD
void lcd_home(void);
void lcd_zToLCD(char dataC);
void lcd_text(char Position);
int sensor_start(void); //Notfallsensor
void summer_init(void); //Summer
void summer_einzeln(void);
void summer_hoehe(int diff);
void uart_init(void); //UART
void uart_senden(char data);
char* uart_empfangen(void);
void bluetooth_init(char BTA []); //Bluetooth
#endif
|
|
mainprogramm
| Code : |
#include "Headerfiles.h"
#include <AVR/io.h> //Definition der Ports
#include <string.h>
#include <AVR/interrupt.h>
#include <AVR/signal.h>
char *ZText;
char Text1[]=" VRF ""[1code]
#include "Headerfiles.h"
#include <AVR/io.h> //Definition der Ports
#include <string.h>
#include <AVR/interrupt.h>
#include <AVR/signal.h>
char *ZText;
char Text1[]=" VRF ""�"; //Begruessungstext 1. Zeile
char Text2[]=" Diplomarbeit ""�"; //Begruessungstext 2. Zeile
char Text3[]="VRF wird geladen""�";
char Text4[]="Bitte warten ...""�";
char vario[5]; //ADC-Ergebnis
char hohe[5]; //ADC-Ergebnis
char Textn[]=" ""�"; //Zeile löschen
char Null[]={0x00};
char Adresse[]="atd001CA451615""r""�";
int altwert=0;
int diff=0;
int test=1;
int i;
int main(void)
{
DDRC=0b1110001;
DDRB=0xFF; //PortB als Aussgabe für LCD
DDRD=0xFF; //PortD als Ausgabe
lcd_init(); //LCD-Anzeige inzialisieren
lcd_home(); //LCD-Anzeige Cursor auf 1. Position
ZText=(char*) Text1; //Ausgabe des Begruessungstextes 1. Zeile
lcd_text(0x00);
ZText=(char*) Text2; //Ausgabe des Begruessungstextes 2. Zeile
lcd_text(0x40);
warten(1);
ZText=(char*) Text3;
lcd_text(0x00);
ZText =(char*) Text4;
lcd_text(0x40);
summer_init();
ADMUX=0b00000001; //ADC-Uref = 5V, Eingang MUX0
ADCSRA=0x85; //ADC-Controllregister einrichten
uart_init();
//bluetooth_init(Adresse);
for(;;)
{
sensor_start();
if(sensor_start()== 1)
{
ADCSRA|=0x40; //ADC Start
while(!(ADCSRA & (1<<4))); //Warten auf ADC-Wandlung
//diff=ADCW-altwert;
diff=diff++;
summer_hoehe(diff);
ZText=(char*) Textn; //Übergabe des Textes
lcd_text(0x40);
ZText= uart_empfangen(); //Übergabe des Textes
lcd_text(0x40);
warten(4);
itoa(diff,vario,10); //Ergebnis in String umwandeln
strcat(vario,Null);
itoa(ADCW,hohe,10); //Ergebnis in String umwandeln
strcat(hohe,Null); //Endzeichen zum String hinzufügen
ZText=(char*) Textn; //Übergabe des Textes
lcd_text(0x40);
ZText=(char*) Textn; //Übergabe des Textes
lcd_text(0x00);
//ZText=(char*) hohe; //Übergabe des Textes
//lcd_text(0x00);
ZText=(char*) vario; //Übergabe des Textes
lcd_text(0x40);
warten(1);
altwert=ADCW;
}
}
}
[/code1]"; //Begruessungstext 1. Zeile
char Text2[]=" Diplomarbeit ""[1code]
#include "Headerfiles.h"
#include <AVR/io.h> //Definition der Ports
#include <string.h>
#include <AVR/interrupt.h>
#include <AVR/signal.h>
char *ZText;
char Text1[]=" VRF ""�"; //Begruessungstext 1. Zeile
char Text2[]=" Diplomarbeit ""�"; //Begruessungstext 2. Zeile
char Text3[]="VRF wird geladen""�";
char Text4[]="Bitte warten ...""�";
char vario[5]; //ADC-Ergebnis
char hohe[5]; //ADC-Ergebnis
char Textn[]=" ""�"; //Zeile löschen
char Null[]={0x00};
char Adresse[]="atd001CA451615""r""�";
int altwert=0;
int diff=0;
int test=1;
int i;
int main(void)
{
DDRC=0b1110001;
DDRB=0xFF; //PortB als Aussgabe für LCD
DDRD=0xFF; //PortD als Ausgabe
lcd_init(); //LCD-Anzeige inzialisieren
lcd_home(); //LCD-Anzeige Cursor auf 1. Position
ZText=(char*) Text1; //Ausgabe des Begruessungstextes 1. Zeile
lcd_text(0x00);
ZText=(char*) Text2; //Ausgabe des Begruessungstextes 2. Zeile
lcd_text(0x40);
warten(1);
ZText=(char*) Text3;
lcd_text(0x00);
ZText =(char*) Text4;
lcd_text(0x40);
summer_init();
ADMUX=0b00000001; //ADC-Uref = 5V, Eingang MUX0
ADCSRA=0x85; //ADC-Controllregister einrichten
uart_init();
//bluetooth_init(Adresse);
for(;;)
{
sensor_start();
if(sensor_start()== 1)
{
ADCSRA|=0x40; //ADC Start
while(!(ADCSRA & (1<<4))); //Warten auf ADC-Wandlung
//diff=ADCW-altwert;
diff=diff++;
summer_hoehe(diff);
ZText=(char*) Textn; //Übergabe des Textes
lcd_text(0x40);
ZText= uart_empfangen(); //Übergabe des Textes
lcd_text(0x40);
warten(4);
itoa(diff,vario,10); //Ergebnis in String umwandeln
strcat(vario,Null);
itoa(ADCW,hohe,10); //Ergebnis in String umwandeln
strcat(hohe,Null); //Endzeichen zum String hinzufügen
ZText=(char*) Textn; //Übergabe des Textes
lcd_text(0x40);
ZText=(char*) Textn; //Übergabe des Textes
lcd_text(0x00);
//ZText=(char*) hohe; //Übergabe des Textes
//lcd_text(0x00);
ZText=(char*) vario; //Übergabe des Textes
lcd_text(0x40);
warten(1);
altwert=ADCW;
}
}
}
[/code1]"; //Begruessungstext 2. Zeile
char Text3[]="VRF wird geladen""[1code]
#include "Headerfiles.h"
#include <AVR/io.h> //Definition der Ports
#include <string.h>
#include <AVR/interrupt.h>
#include <AVR/signal.h>
char *ZText;
char Text1[]=" VRF ""�"; //Begruessungstext 1. Zeile
char Text2[]=" Diplomarbeit ""�"; //Begruessungstext 2. Zeile
char Text3[]="VRF wird geladen""�";
char Text4[]="Bitte warten ...""�";
char vario[5]; //ADC-Ergebnis
char hohe[5]; //ADC-Ergebnis
char Textn[]=" ""�"; //Zeile löschen
char Null[]={0x00};
char Adresse[]="atd001CA451615""r""�";
int altwert=0;
int diff=0;
int test=1;
int i;
int main(void)
{
DDRC=0b1110001;
DDRB=0xFF; //PortB als Aussgabe für LCD
DDRD=0xFF; //PortD als Ausgabe
lcd_init(); //LCD-Anzeige inzialisieren
lcd_home(); //LCD-Anzeige Cursor auf 1. Position
ZText=(char*) Text1; //Ausgabe des Begruessungstextes 1. Zeile
lcd_text(0x00);
ZText=(char*) Text2; //Ausgabe des Begruessungstextes 2. Zeile
lcd_text(0x40);
warten(1);
ZText=(char*) Text3;
lcd_text(0x00);
ZText =(char*) Text4;
lcd_text(0x40);
summer_init();
ADMUX=0b00000001; //ADC-Uref = 5V, Eingang MUX0
ADCSRA=0x85; //ADC-Controllregister einrichten
uart_init();
//bluetooth_init(Adresse);
for(;;)
{
sensor_start();
if(sensor_start()== 1)
{
ADCSRA|=0x40; //ADC Start
while(!(ADCSRA & (1<<4))); //Warten auf ADC-Wandlung
//diff=ADCW-altwert;
diff=diff++;
summer_hoehe(diff);
ZText=(char*) Textn; //Übergabe des Textes
lcd_text(0x40);
ZText= uart_empfangen(); //Übergabe des Textes
lcd_text(0x40);
warten(4);
itoa(diff,vario,10); //Ergebnis in String umwandeln
strcat(vario,Null);
itoa(ADCW,hohe,10); //Ergebnis in String umwandeln
strcat(hohe,Null); //Endzeichen zum String hinzufügen
ZText=(char*) Textn; //Übergabe des Textes
lcd_text(0x40);
ZText=(char*) Textn; //Übergabe des Textes
lcd_text(0x00);
//ZText=(char*) hohe; //Übergabe des Textes
//lcd_text(0x00);
ZText=(char*) vario; //Übergabe des Textes
lcd_text(0x40);
warten(1);
altwert=ADCW;
}
}
}
[/code1]";
char Text4[]="Bitte warten ...""[1code]
#include "Headerfiles.h"
#include <AVR/io.h> //Definition der Ports
#include <string.h>
#include <AVR/interrupt.h>
#include <AVR/signal.h>
char *ZText;
char Text1[]=" VRF ""�"; //Begruessungstext 1. Zeile
char Text2[]=" Diplomarbeit ""�"; //Begruessungstext 2. Zeile
char Text3[]="VRF wird geladen""�";
char Text4[]="Bitte warten ...""�";
char vario[5]; //ADC-Ergebnis
char hohe[5]; //ADC-Ergebnis
char Textn[]=" ""�"; //Zeile löschen
char Null[]={0x00};
char Adresse[]="atd001CA451615""r""�";
int altwert=0;
int diff=0;
int test=1;
int i;
int main(void)
{
DDRC=0b1110001;
DDRB=0xFF; //PortB als Aussgabe für LCD
DDRD=0xFF; //PortD als Ausgabe
lcd_init(); //LCD-Anzeige inzialisieren
lcd_home(); //LCD-Anzeige Cursor auf 1. Position
ZText=(char*) Text1; //Ausgabe des Begruessungstextes 1. Zeile
lcd_text(0x00);
ZText=(char*) Text2; //Ausgabe des Begruessungstextes 2. Zeile
lcd_text(0x40);
warten(1);
ZText=(char*) Text3;
lcd_text(0x00);
ZText =(char*) Text4;
lcd_text(0x40);
summer_init();
ADMUX=0b00000001; //ADC-Uref = 5V, Eingang MUX0
ADCSRA=0x85; //ADC-Controllregister einrichten
uart_init();
//bluetooth_init(Adresse);
for(;;)
{
sensor_start();
if(sensor_start()== 1)
{
ADCSRA|=0x40; //ADC Start
while(!(ADCSRA & (1<<4))); //Warten auf ADC-Wandlung
//diff=ADCW-altwert;
diff=diff++;
summer_hoehe(diff);
ZText=(char*) Textn; //Übergabe des Textes
lcd_text(0x40);
ZText= uart_empfangen(); //Übergabe des Textes
lcd_text(0x40);
warten(4);
itoa(diff,vario,10); //Ergebnis in String umwandeln
strcat(vario,Null);
itoa(ADCW,hohe,10); //Ergebnis in String umwandeln
strcat(hohe,Null); //Endzeichen zum String hinzufügen
ZText=(char*) Textn; //Übergabe des Textes
lcd_text(0x40);
ZText=(char*) Textn; //Übergabe des Textes
lcd_text(0x00);
//ZText=(char*) hohe; //Übergabe des Textes
//lcd_text(0x00);
ZText=(char*) vario; //Übergabe des Textes
lcd_text(0x40);
warten(1);
altwert=ADCW;
}
}
}
[/code1]";
char vario[5]; //ADC-Ergebnis
char hohe[5]; //ADC-Ergebnis
char Textn[]=" ""[1code]
#include "Headerfiles.h"
#include <AVR/io.h> //Definition der Ports
#include <string.h>
#include <AVR/interrupt.h>
#include <AVR/signal.h>
char *ZText;
char Text1[]=" VRF ""�"; //Begruessungstext 1. Zeile
char Text2[]=" Diplomarbeit ""�"; //Begruessungstext 2. Zeile
char Text3[]="VRF wird geladen""�";
char Text4[]="Bitte warten ...""�";
char vario[5]; //ADC-Ergebnis
char hohe[5]; //ADC-Ergebnis
char Textn[]=" ""�"; //Zeile löschen
char Null[]={0x00};
char Adresse[]="atd001CA451615""r""�";
int altwert=0;
int diff=0;
int test=1;
int i;
int main(void)
{
DDRC=0b1110001;
DDRB=0xFF; //PortB als Aussgabe für LCD
DDRD=0xFF; //PortD als Ausgabe
lcd_init(); //LCD-Anzeige inzialisieren
lcd_home(); //LCD-Anzeige Cursor auf 1. Position
ZText=(char*) Text1; //Ausgabe des Begruessungstextes 1. Zeile
lcd_text(0x00);
ZText=(char*) Text2; //Ausgabe des Begruessungstextes 2. Zeile
lcd_text(0x40);
warten(1);
ZText=(char*) Text3;
lcd_text(0x00);
ZText =(char*) Text4;
lcd_text(0x40);
summer_init();
ADMUX=0b00000001; //ADC-Uref = 5V, Eingang MUX0
ADCSRA=0x85; //ADC-Controllregister einrichten
uart_init();
//bluetooth_init(Adresse);
for(;;)
{
sensor_start();
if(sensor_start()== 1)
{
ADCSRA|=0x40; //ADC Start
while(!(ADCSRA & (1<<4))); //Warten auf ADC-Wandlung
//diff=ADCW-altwert;
diff=diff++;
summer_hoehe(diff);
ZText=(char*) Textn; //Übergabe des Textes
lcd_text(0x40);
ZText= uart_empfangen(); //Übergabe des Textes
lcd_text(0x40);
warten(4);
itoa(diff,vario,10); //Ergebnis in String umwandeln
strcat(vario,Null);
itoa(ADCW,hohe,10); //Ergebnis in String umwandeln
strcat(hohe,Null); //Endzeichen zum String hinzufügen
ZText=(char*) Textn; //Übergabe des Textes
lcd_text(0x40);
ZText=(char*) Textn; //Übergabe des Textes
lcd_text(0x00);
//ZText=(char*) hohe; //Übergabe des Textes
//lcd_text(0x00);
ZText=(char*) vario; //Übergabe des Textes
lcd_text(0x40);
warten(1);
altwert=ADCW;
}
}
}
[/code1]"; //Zeile löschen
char Null[]={0x00};
char Adresse[]="atd001CA451615""r""[1code]
#include "Headerfiles.h"
#include <AVR/io.h> //Definition der Ports
#include <string.h>
#include <AVR/interrupt.h>
#include <AVR/signal.h>
char *ZText;
char Text1[]=" VRF ""�"; //Begruessungstext 1. Zeile
char Text2[]=" Diplomarbeit ""�"; //Begruessungstext 2. Zeile
char Text3[]="VRF wird geladen""�";
char Text4[]="Bitte warten ...""�";
char vario[5]; //ADC-Ergebnis
char hohe[5]; //ADC-Ergebnis
char Textn[]=" ""�"; //Zeile löschen
char Null[]={0x00};
char Adresse[]="atd001CA451615""r""�";
int altwert=0;
int diff=0;
int test=1;
int i;
int main(void)
{
DDRC=0b1110001;
DDRB=0xFF; //PortB als Aussgabe für LCD
DDRD=0xFF; //PortD als Ausgabe
lcd_init(); //LCD-Anzeige inzialisieren
lcd_home(); //LCD-Anzeige Cursor auf 1. Position
ZText=(char*) Text1; //Ausgabe des Begruessungstextes 1. Zeile
lcd_text(0x00);
ZText=(char*) Text2; //Ausgabe des Begruessungstextes 2. Zeile
lcd_text(0x40);
warten(1);
ZText=(char*) Text3;
lcd_text(0x00);
ZText =(char*) Text4;
lcd_text(0x40);
summer_init();
ADMUX=0b00000001; //ADC-Uref = 5V, Eingang MUX0
ADCSRA=0x85; //ADC-Controllregister einrichten
uart_init();
//bluetooth_init(Adresse);
for(;;)
{
sensor_start();
if(sensor_start()== 1)
{
ADCSRA|=0x40; //ADC Start
while(!(ADCSRA & (1<<4))); //Warten auf ADC-Wandlung
//diff=ADCW-altwert;
diff=diff++;
summer_hoehe(diff);
ZText=(char*) Textn; //Übergabe des Textes
lcd_text(0x40);
ZText= uart_empfangen(); //Übergabe des Textes
lcd_text(0x40);
warten(4);
itoa(diff,vario,10); //Ergebnis in String umwandeln
strcat(vario,Null);
itoa(ADCW,hohe,10); //Ergebnis in String umwandeln
strcat(hohe,Null); //Endzeichen zum String hinzufügen
ZText=(char*) Textn; //Übergabe des Textes
lcd_text(0x40);
ZText=(char*) Textn; //Übergabe des Textes
lcd_text(0x00);
//ZText=(char*) hohe; //Übergabe des Textes
//lcd_text(0x00);
ZText=(char*) vario; //Übergabe des Textes
lcd_text(0x40);
warten(1);
altwert=ADCW;
}
}
}
[/code1]";
int altwert=0;
int diff=0;
int test=1;
int i;
int main(void)
{
DDRC=0b1110001;
DDRB=0xFF; //PortB als Aussgabe für LCD
DDRD=0xFF; //PortD als Ausgabe
lcd_init(); //LCD-Anzeige inzialisieren
lcd_home(); //LCD-Anzeige Cursor auf 1. Position
ZText=(char*) Text1; //Ausgabe des Begruessungstextes 1. Zeile
lcd_text(0x00);
ZText=(char*) Text2; //Ausgabe des Begruessungstextes 2. Zeile
lcd_text(0x40);
warten(1);
ZText=(char*) Text3;
lcd_text(0x00);
ZText =(char*) Text4;
lcd_text(0x40);
summer_init();
ADMUX=0b00000001; //ADC-Uref = 5V, Eingang MUX0
ADCSRA=0x85; //ADC-Controllregister einrichten
uart_init();
//bluetooth_init(Adresse);
for(;;)
{
sensor_start();
if(sensor_start()== 1)
{
ADCSRA|=0x40; //ADC Start
while(!(ADCSRA & (1<<4))); //Warten auf ADC-Wandlung
//diff=ADCW-altwert;
diff=diff++;
summer_hoehe(diff);
ZText=(char*) Textn; //Übergabe des Textes
lcd_text(0x40);
ZText= uart_empfangen(); //Übergabe des Textes
lcd_text(0x40);
warten(4);
itoa(diff,vario,10); //Ergebnis in String umwandeln
strcat(vario,Null);
itoa(ADCW,hohe,10); //Ergebnis in String umwandeln
strcat(hohe,Null); //Endzeichen zum String hinzufügen
ZText=(char*) Textn; //Übergabe des Textes
lcd_text(0x40);
ZText=(char*) Textn; //Übergabe des Textes
lcd_text(0x00);
//ZText=(char*) hohe; //Übergabe des Textes
//lcd_text(0x00);
ZText=(char*) vario; //Übergabe des Textes
lcd_text(0x40);
warten(1);
altwert=ADCW;
}
}
}
|
|
LCD.c
| Code : |
#include "Headerfiles.h" //Einbinder des Headerfiles
#include <AVR/io.h> //Definition der Ports
char i, Zeichen;
char *ZText;
void lcd_init(void)
{
delay_ms(45); //Wartezeit 50ms
lcd_zToLCD(0b00001100); // Function set
delay_ms(7); //Wartezeit 2ms
lcd_zToLCD(0b00001100); // Funktion set
delay_us(30); //Wartezeit 30us
lcd_zToLCD(0b00001100); // Funktion set
delay_us(30); //Wartezeit 30us
lcd_zToLCD(0b00001000); // Funktion set
delay_us(30); //Wartezeit 30us
lcd_zToLCD(0b00001000); // Funktion set
delay_us(30);
lcd_zToLCD(0b00100100); //
delay_us(30); //Wartezeit 30us
lcd_zToLCD(0b00000100); // Internal OSC frequency
delay_us(30);
lcd_zToLCD(0b00110000); //
delay_us(30); //Wartezeit 30us
lcd_zToLCD(0b00011100); // Contrast set
delay_us(30);
lcd_zToLCD(0b00010000); //
delay_us(30); //Wartezeit 30us
lcd_zToLCD(0b00010100); // Power/ICON/Contrast control
delay_us(30);
lcd_zToLCD(0b00001000); //
delay_us(30); //Wartezeit 30us
lcd_zToLCD(0b00011000); // Follower control
delay_us(30);
lcd_zToLCD(0b00100100); //
delay_us(30); //Wartezeit 30us
lcd_zToLCD(0b00000000); // Display ON/OFF control
delay_us(30);
lcd_zToLCD(0b00110000); //
delay_us(30); //Wartezeit 30us
}
void lcd_home(void)
/*************************************************************
Return Home mit Void lcd_home(void)
setzt den Adresszaehler des DD-RAM auf Adresse 0. Der Inhalt des DD-RAMS
bleibt unveraendert. Der Cursor wird auf die erste Position der ersten
Zeile gesetzt.
*************************************************************/
{
delay_ms(2); //Wartezeit 200us
lcd_zToLCD(0b00000000); // LCD-Return-Home 1
delay_us(30); //Wartezeit 200us
lcd_zToLCD(0b00001000);
delay_ms(2);
}
void lcd_zToLCD(char dataC)
/*************************************************************
Mit Void lcd_home(char dataD) wird EN auf 1 gesetzt, dann erfolt
die Datenausgabe. Mit 0 werden die Daten in das DD-Ram uebernommen.
Zuerst wird das High Byte, dann das Low Byte übertragen.
/-------------------
/ Daten D7 D6 D5 D4
EN---------/ --------
*************************************************************/
{
PORTB=0b00000010; //EN = 1
delay_us(30); //Wartezeit 100us
PORTB|=dataC; //Rausschreiben
delay_us(30); //Wartezeit 100us
PORTB&=0b11111101; //EN = 0
delay_us(30);
}
void lcd_text(char Pos)
/*****************************************************************
Ausgabe eines Textes. Der Pointer zeigt mit ZText=*&Text2 zum Beginn
des Textes. Der Pointer wird 16 mal erhöht (Ausgabe von 16 ASCII-Zeichen).
Die Ausgabe wird vorzeitig mit '[1code]
#include "Headerfiles.h" //Einbinder des Headerfiles
#include <AVR/io.h> //Definition der Ports
char i, Zeichen;
char *ZText;
void lcd_init(void)
{
delay_ms(45); //Wartezeit 50ms
lcd_zToLCD(0b00001100); // Function set
delay_ms(7); //Wartezeit 2ms
lcd_zToLCD(0b00001100); // Funktion set
delay_us(30); //Wartezeit 30us
lcd_zToLCD(0b00001100); // Funktion set
delay_us(30); //Wartezeit 30us
lcd_zToLCD(0b00001000); // Funktion set
delay_us(30); //Wartezeit 30us
lcd_zToLCD(0b00001000); // Funktion set
delay_us(30);
lcd_zToLCD(0b00100100); //
delay_us(30); //Wartezeit 30us
lcd_zToLCD(0b00000100); // Internal OSC frequency
delay_us(30);
lcd_zToLCD(0b00110000); //
delay_us(30); //Wartezeit 30us
lcd_zToLCD(0b00011100); // Contrast set
delay_us(30);
lcd_zToLCD(0b00010000); //
delay_us(30); //Wartezeit 30us
lcd_zToLCD(0b00010100); // Power/ICON/Contrast control
delay_us(30);
lcd_zToLCD(0b00001000); //
delay_us(30); //Wartezeit 30us
lcd_zToLCD(0b00011000); // Follower control
delay_us(30);
lcd_zToLCD(0b00100100); //
delay_us(30); //Wartezeit 30us
lcd_zToLCD(0b00000000); // Display ON/OFF control
delay_us(30);
lcd_zToLCD(0b00110000); //
delay_us(30); //Wartezeit 30us
}
void lcd_home(void)
/*************************************************************
Return Home mit Void lcd_home(void)
setzt den Adresszaehler des DD-RAM auf Adresse 0. Der Inhalt des DD-RAMS
bleibt unveraendert. Der Cursor wird auf die erste Position der ersten
Zeile gesetzt.
*************************************************************/
{
delay_ms(2); //Wartezeit 200us
lcd_zToLCD(0b00000000); // LCD-Return-Home 1
delay_us(30); //Wartezeit 200us
lcd_zToLCD(0b00001000);
delay_ms(2);
}
void lcd_zToLCD(char dataC)
/*************************************************************
Mit Void lcd_home(char dataD) wird EN auf 1 gesetzt, dann erfolt
die Datenausgabe. Mit 0 werden die Daten in das DD-Ram uebernommen.
Zuerst wird das High Byte, dann das Low Byte übertragen.
/-------------------
/ Daten D7 D6 D5 D4
EN---------/ --------
*************************************************************/
{
PORTB=0b00000010; //EN = 1
delay_us(30); //Wartezeit 100us
PORTB|=dataC; //Rausschreiben
delay_us(30); //Wartezeit 100us
PORTB&=0b11111101; //EN = 0
delay_us(30);
}
void lcd_text(char Pos)
/*****************************************************************
Ausgabe eines Textes. Der Pointer zeigt mit ZText=*&Text2 zum Beginn
des Textes. Der Pointer wird 16 mal erhöht (Ausgabe von 16 ASCII-Zeichen).
Die Ausgabe wird vorzeitig mit '�' beendet. Zuerst erfolgt die Ausgabe
des High Bytes, dann das Low Byte.
Die 1. Zeile beginnt mit der DD-Adresse 0x00.
Die 2. Zeile beginnt mit der DD-Adresse 0x40.
*****************************************************************/
{
Zeichen=Pos; //Ausgabe der DD-Ram-Adresse
Zeichen>>=2;
Zeichen&=0b00011100;
Zeichen|=0b00100000;
delay_us(30); //Wartezeit 200us
lcd_zToLCD(Zeichen); //Zeichenausgabe High Bytes
Zeichen=Pos;
Zeichen<<=2;
Zeichen&=0b00111100;
delay_us(30); //Wartezeit 200us
lcd_zToLCD(Zeichen); //Zeichenausgabe Low Byte
for(i=0;i<16;i++) //Ausgabe des Textes
{
Zeichen = *(ZText+i);
if (Zeichen == '�') //Ende der Textausgabe mit ascii 0
break;
Zeichen>>=2;
Zeichen&=0b00111100;
Zeichen|=0b00000001;
delay_us(30); //Wartezeit 200us
lcd_zToLCD(Zeichen); //Zeichenausgabe High Bytes
Zeichen = *(ZText+i);
Zeichen<<=2;
Zeichen&=0b00111100;
Zeichen|=0b00000001;
delay_us(30); //Wartezeit 200us
lcd_zToLCD(Zeichen); //Zeichenausgabe Low Byte
}
}
[/code1]' beendet. Zuerst erfolgt die Ausgabe
des High Bytes, dann das Low Byte.
Die 1. Zeile beginnt mit der DD-Adresse 0x00.
Die 2. Zeile beginnt mit der DD-Adresse 0x40.
*****************************************************************/
{
Zeichen=Pos; //Ausgabe der DD-Ram-Adresse
Zeichen>>=2;
Zeichen&=0b00011100;
Zeichen|=0b00100000;
delay_us(30); //Wartezeit 200us
lcd_zToLCD(Zeichen); //Zeichenausgabe High Bytes
Zeichen=Pos;
Zeichen<<=2;
Zeichen&=0b00111100;
delay_us(30); //Wartezeit 200us
lcd_zToLCD(Zeichen); //Zeichenausgabe Low Byte
for(i=0;i<16;i++) //Ausgabe des Textes
{
Zeichen = *(ZText+i);
if (Zeichen == '[1code]
#include "Headerfiles.h" //Einbinder des Headerfiles
#include <AVR/io.h> //Definition der Ports
char i, Zeichen;
char *ZText;
void lcd_init(void)
{
delay_ms(45); //Wartezeit 50ms
lcd_zToLCD(0b00001100); // Function set
delay_ms(7); //Wartezeit 2ms
lcd_zToLCD(0b00001100); // Funktion set
delay_us(30); //Wartezeit 30us
lcd_zToLCD(0b00001100); // Funktion set
delay_us(30); //Wartezeit 30us
lcd_zToLCD(0b00001000); // Funktion set
delay_us(30); //Wartezeit 30us
lcd_zToLCD(0b00001000); // Funktion set
delay_us(30);
lcd_zToLCD(0b00100100); //
delay_us(30); //Wartezeit 30us
lcd_zToLCD(0b00000100); // Internal OSC frequency
delay_us(30);
lcd_zToLCD(0b00110000); //
delay_us(30); //Wartezeit 30us
lcd_zToLCD(0b00011100); // Contrast set
delay_us(30);
lcd_zToLCD(0b00010000); //
delay_us(30); //Wartezeit 30us
lcd_zToLCD(0b00010100); // Power/ICON/Contrast control
delay_us(30);
lcd_zToLCD(0b00001000); //
delay_us(30); //Wartezeit 30us
lcd_zToLCD(0b00011000); // Follower control
delay_us(30);
lcd_zToLCD(0b00100100); //
delay_us(30); //Wartezeit 30us
lcd_zToLCD(0b00000000); // Display ON/OFF control
delay_us(30);
lcd_zToLCD(0b00110000); //
delay_us(30); //Wartezeit 30us
}
void lcd_home(void)
/*************************************************************
Return Home mit Void lcd_home(void)
setzt den Adresszaehler des DD-RAM auf Adresse 0. Der Inhalt des DD-RAMS
bleibt unveraendert. Der Cursor wird auf die erste Position der ersten
Zeile gesetzt.
*************************************************************/
{
delay_ms(2); //Wartezeit 200us
lcd_zToLCD(0b00000000); // LCD-Return-Home 1
delay_us(30); //Wartezeit 200us
lcd_zToLCD(0b00001000);
delay_ms(2);
}
void lcd_zToLCD(char dataC)
/*************************************************************
Mit Void lcd_home(char dataD) wird EN auf 1 gesetzt, dann erfolt
die Datenausgabe. Mit 0 werden die Daten in das DD-Ram uebernommen.
Zuerst wird das High Byte, dann das Low Byte übertragen.
/-------------------
/ Daten D7 D6 D5 D4
EN---------/ --------
*************************************************************/
{
PORTB=0b00000010; //EN = 1
delay_us(30); //Wartezeit 100us
PORTB|=dataC; //Rausschreiben
delay_us(30); //Wartezeit 100us
PORTB&=0b11111101; //EN = 0
delay_us(30);
}
void lcd_text(char Pos)
/*****************************************************************
Ausgabe eines Textes. Der Pointer zeigt mit ZText=*&Text2 zum Beginn
des Textes. Der Pointer wird 16 mal erhöht (Ausgabe von 16 ASCII-Zeichen).
Die Ausgabe wird vorzeitig mit '�' beendet. Zuerst erfolgt die Ausgabe
des High Bytes, dann das Low Byte.
Die 1. Zeile beginnt mit der DD-Adresse 0x00.
Die 2. Zeile beginnt mit der DD-Adresse 0x40.
*****************************************************************/
{
Zeichen=Pos; //Ausgabe der DD-Ram-Adresse
Zeichen>>=2;
Zeichen&=0b00011100;
Zeichen|=0b00100000;
delay_us(30); //Wartezeit 200us
lcd_zToLCD(Zeichen); //Zeichenausgabe High Bytes
Zeichen=Pos;
Zeichen<<=2;
Zeichen&=0b00111100;
delay_us(30); //Wartezeit 200us
lcd_zToLCD(Zeichen); //Zeichenausgabe Low Byte
for(i=0;i<16;i++) //Ausgabe des Textes
{
Zeichen = *(ZText+i);
if (Zeichen == '�') //Ende der Textausgabe mit ascii 0
break;
Zeichen>>=2;
Zeichen&=0b00111100;
Zeichen|=0b00000001;
delay_us(30); //Wartezeit 200us
lcd_zToLCD(Zeichen); //Zeichenausgabe High Bytes
Zeichen = *(ZText+i);
Zeichen<<=2;
Zeichen&=0b00111100;
Zeichen|=0b00000001;
delay_us(30); //Wartezeit 200us
lcd_zToLCD(Zeichen); //Zeichenausgabe Low Byte
}
}
[/code1]') //Ende der Textausgabe mit ascii 0
break;
Zeichen>>=2;
Zeichen&=0b00111100;
Zeichen|=0b00000001;
delay_us(30); //Wartezeit 200us
lcd_zToLCD(Zeichen); //Zeichenausgabe High Bytes
Zeichen = *(ZText+i);
Zeichen<<=2;
Zeichen&=0b00111100;
Zeichen|=0b00000001;
delay_us(30); //Wartezeit 200us
lcd_zToLCD(Zeichen); //Zeichenausgabe Low Byte
}
}
|
|
Mfg
Rambodischien
[ Diese Nachricht wurde geändert von: Rambodischien am 11 Jun 2008 21:47 ]
|
BID = 527355
DonComi
Inventar
Beiträge: 8605
Wohnort: Amerika
|
Hallo Rambodieschen,
Zitat :
| | [...] das die Zeichen die ich empfange werden immer wieder darangehängt. [...] |
Dieser Inhalt der Strings ist es, was mich interessiert .
Daran kann man eventuell schon erkennen, woran der Fehler liegt. Was oft vorkommt:
* eine while(..); -Instruktion wird wegoptimiert, da sie augenscheinlich keinen Sinn macht (hier eher weniger, da dort volatile Variablen sind, die von der Hardware geändert werden können, das ist es ergo nicht)
* Nullterminierungen, die im Speicherbereich liegen, und das Ende des Strings ankündigen, auch wenn danach noch Zeichen kommen.
* Zeiger werden im Programm geändert. Bestimmte Zeiger dürfen nicht verändert werden, da sie dann eventuelle Speicherlecks verursachen.
Also, versuch mal an den Inhalt der Strings zu kommen, z.b. mit dem Display, sofern es, und sein Treiber, sicher funktionieren. Den habe ich mir übrigens nicht angeschaut .
_________________
|
BID = 527364
Rambodischien
Schreibmaschine
Beiträge: 1341
Wohnort: Österreich
|
Hmmm die Inhalte der Strings??
Du meinst das was ich zu dem uC sende?
Wenn ich z.B.: test sende dann erscheint auf dem Display test und wenn ich danach hallo sende erscheint auf dem Display testhallo.
Mfg
Rambodischien
|
BID = 527366
Jornbyte
Moderator
Beiträge: 7178
|
Ja, du musst den Pointer wieder auf den Anfang des Puffer setzen. Das macht man, wenn die 0 (NULL) Terminierung den String beendet und alle Zeichen aus dem Puffer gelesen wurden.
Deinen Quelltext habe ich nicht gelesen.
_________________
mfg Jornbyte
Es handelt sich bei dem Tipp nicht um eine Rechtsverbindliche Auskunft und
wer Tippfehler findet, kann sie behalten.
|
BID = 527367
DonComi
Inventar
Beiträge: 8605
Wohnort: Amerika
|
Ist ja auch klar, dass es so ist, schließlich änderst du j ja nicht mehr.
Wenn du jetzt noch ans Ende der Routine j=0; schreibst, läuft die Sache.
Das ist aus meinem obigem Kode aber auch ersichtlich, dass der indirekte Zeiger auf den Speicherbereich bei jedem neuen Einlesen auf 0 gesetzt werden muss.
Aber normalerweise packt man j als lokale Variable in die Routine rein!
Das ist blödsinnig, die global zu deklarieren, v.a. weil der Kode dadurch geringfügig größer wird. Mach j lokal, initialisiere es mit 0! Dann hast du den Fehler nichtmehr. Wo der String anfängt und wo er aufhört, sagt dir ja der Zeiger und dessen Dereferenzierung.
Edit: Jorn war eine Sekunde schneller  .
Das ist es halt. Hat j 99 erreicht, werden die Daten verworfen, weil der Puffer (mit alten Daten) voll ist.
_________________
[ Diese Nachricht wurde geändert von: DonComi am 11 Jun 2008 23:02 ]
|
BID = 527369
Rambodischien
Schreibmaschine
Beiträge: 1341
Wohnort: Österreich
|
 Das ich das übersehen habe
Vielen vielen vielen Dank für deine Hilfe und deine übergroße Geduld
Ich werde mich sicher wegen irgendeinem Problem wieder melden 
Noch einmal Danke 
Mfg
Rambodischien
EDIT: Auch Jornbyte ein Herzliches Dankeschön (Habe dich überlesen Sorry)
[ Diese Nachricht wurde geändert von: Rambodischien am 11 Jun 2008 23:04 ]
|
BID = 527483
Rambodischien
Schreibmaschine
Beiträge: 1341
Wohnort: Österreich
|
Nachdem ich das ganze Programmiert habe und es funktioniert, habe ich weitere Fragen die indirekt zu UART passen.
1) Ich will ein GPS an die UART Schnittstelle hängen und die Daten die ich zurückbekomme (Koordinaten) speichern. Am besten in eine Art Array. Weil es sind mehrer Koordinaten die ich empfange und ich wollte die Daten beisammen haben.
2) Wenn ich jetzt etwas empfange wie kann ich die Daten mit einem anderen char[] vergleichen? Ich wollte wenn ich ein bestimmtes Wort empfange etwas spezielles Ausführen.
Danke
Mfg
Rambodischien
|
BID = 527488
DonComi
Inventar
Beiträge: 8605
Wohnort: Amerika
|
Gibt diverse Möglichkeiten:
string.h zeigt die Prototypen zur Verwendung von Strings.
Dort sind auch Funktionen, die zwei nullterminierte Strings vergleichen. Du solltest dir dazu die Funktion strcmp oder strncmp anschauen.
Es geht auch "generischer", indem man memcmp benutzt, dort kannst du alle Datentypen vergleichen, und auch nullterminierte Strings, die danach weitergehen sollen, also du kannst auch über die Terminierung hinweg weitertesten .
Edit:
Zitat :
| | 1) Ich will ein GPS an die UART Schnittstelle hängen und die Daten die ich zurückbekomme (Koordinaten) speichern. Am besten in eine Art Array. Weil es sind mehrer Koordinaten die ich empfange und ich wollte die Daten beisammen haben. |
Kannst du ja auch so machen. Nur musst du von vornerein eine Puffergröße einstellen.
Das Problem, dass C++/C-Programmierer auf so niedlichen Systemen wie AVRs haben, ist, dass man dynamische Speicherallozierung vergessen kann. Erstens ist der Aufwand an Kode und Geschwindigkeit der Alloziierung zu groß und zweitens haben AVRs einfach zuwenig SRAM.
Da hilft nur, und das ist eigentlich auch wesentlich effektiver, eine feste Puffergröße vornerein festzulegen und darauf zu hoffen, dass das Gegenstück an der UART Handshakes versteht. Ist der Puffer voll, dem Sender mitteilen, dass er warten soll, bis die Daten verarbeitet wurden. Aber nicht vergessen, beim weiteren Empfang den Zeiger auf den Puffer wieder zum Anfang zeigen zu lassen .
P.S.: bei AVRs ist es noch effektiver, wenn man Vergleichsstrings aus dem ROM holt, dann benötigen die kein SRAM. Dies ist ein entscheidener Nachtteil bei AVRs: sie haben zwei getrennte Adressbusse für Daten- und Programmbereich.
Das macht aber auch auf der anderen Seite die recht schnelle Datenverarbeitung aus.
_________________
[ Diese Nachricht wurde geändert von: DonComi am 12 Jun 2008 17:15 ]
|
BID = 527553
Rambodischien
Schreibmaschine
Beiträge: 1341
Wohnort: Österreich
|
Vielen Dank für die Antwort. Ich werde mich morgen genauer damit beschäftigen.
Aber eine Frage hätte ich da noch:
Zitat :
|
1) Ich will ein GPS an die UART Schnittstelle hängen und die Daten die ich zurückbekomme (Koordinaten) speichern. Am besten in eine Art Array. Weil es sind mehrer Koordinaten die ich empfange und ich wollte die Daten beisammen haben.
|
Das mit dem Array habe ich verstanden nur wie schreibe ich die Daten auf einen anderen Speicherplatz? Weil ich kriege nur einen Pointer auf die Empfangenen char. Wie speichere ich diese in ein char[]?
MFg
Rambodischien
[ Diese Nachricht wurde geändert von: Rambodischien am 12 Jun 2008 22:04 ]
|
|
Zum Ersatzteileshop
Bezeichnungen von Produkten, Abbildungen und Logos , die in diesem Forum oder im Shop verwendet werden, sind Eigentum des entsprechenden Herstellers oder Besitzers. Diese dienen lediglich zur Identifikation!
Impressum
Datenschutz
Copyright © Baldur Brock Fernsehtechnik und Versand Ersatzteile in Heilbronn Deutschland
gerechnet auf die letzten 30 Tage haben wir 19 Beiträge im Durchschnitt pro Tag heute wurden bisher 9 Beiträge verfasst
© x sparkkelsputz Besucher : 182389078 Heute : 3813 Gestern : 6874 Online : 483 24.11.2024 14:24
3 Besucher in den letzten 60 Sekunden alle 20.00 Sekunden ein neuer Besucher ---- logout ----viewtopic ---- logout ----
|
xcvb
ycvb
0.0704920291901
|
