C:PWM und Temperaturerfassung

Jörg

Neues Mitglied
28. Dez. 2011
23
0
0
Sprachen
hallo
ich möcht eine temperaturmessung über das twi modul von myavr machen und diese dann per twi an das mk2 weitergeben. danach möchte ich eine stufenweise steuerung der pwm geschwindigkeit anhand der temperatur durchführen. die temperatur muss ich noch über twi befehle einbinden jedoch hab ich hab bei meinem bisherigen code das problem dass mir zwei fehler angezeigt werden ich jedoch aber nicht weiß woran es liegt hab schon viel gegoogelt aber nichts gefunden. anbei mein programmcode und die beiden fehlermeldungen vielleicht kann mir ja jemand behilflich sein meine fehler zu finden.

Code:
/***************************************************************************************/
/*PWM-Steuerung über Temperaturfühler LM75 eines Lüfters an PB1
und Sollwertanhebung über Poti an PC0*/
/***************************************************************************************/
/***************************************************************************************/
#define F_CPU 3686400 								// Taktfrequenz des myAVR-Boards
#include <avr\io.h>									// AVR Register und Konstantendefinitionen
#include <avr\interrupt.h> 							// Weitere Interruptdefinitionen
#include "lcd.h"									// bindet die LCD Headerdatei ein
/***************************************************************************************/
/*******************************Variablen***********************************************/
int wert=0;											// legt die Variable wert als int mit dem Wert 0 an
int i=0;											// legt die Variable i als int mit dem Wert 0 an
float result = 0;									// legt die Variable result als float mit dem Wert 0 an
int anhebung = 0;									// legt die Variable anhebung als int mit dem Wert 0 an
float begrenzung = 0.5;								// legt die Variable begrenzung als float mit dem Wert 0.5 an
float temperatur = 0;								// legt die Variable temperatur als float mit dem Wert 0 an
int geschwindigkeit = 0;							// legt die Variable geschwinigkeit als int mit dem Wert 0 an
int auslastung = 0;
/***************************************************************************************/
/*******************************Unterprogramme******************************************/

void Timer_init (){
	TCCR1A = (1<<WGM11) | (1<<COM1A1) | (1<<COM1B1);	// Fast-PWM Mode 14(ICR1); verknüpfung auf PB1 und RESET OC1B
	TCCR1B = (1<<WGM12) | (1<<WGM13) | (1<<CS11);		// Prescaler 8; FAST-PWM Mode 14(ICR1)
	ICR1 = 0x1ff; 										// setzt Maximalwert des Timers (511)
}

void wandler_init (){
	ADMUX  |= (1<<REFS0);								// auf interne Referenz schalten
	ADCSRA |= (1<<ADEN); 								// Wandler einschalten
}

void wandlung (){
	ADCSRA |= (1<<ADSC);              					// eine AD-Wandlung
while (ADCSRA & (1<<ADSC)) {;}						// auf Abschluss der Konvertierung warten
result = ADCW;  									// AD Wandler muss einmal gelesen werden, sonst wird Ergebnis der nächsten Wandlung nicht übernommen.
result = 0; 										// Variable result wieder auf 0 setzen
for(i=0; i<4; i++)	{								// Eigentliche Messung - Mittelwert aus 4 aufeinanderfolgenden Wandlungen hochzählen bis 4
ADCSRA |= (1<<ADSC);           					// eine Wandlung
    while (ADCSRA & (1<<ADSC)) {;}					// auf Abschluss der Konvertierung warten								
    result += ADCW;        							// Wandlungsergebnisse aufaddieren
   }
  	result /= 4;                     				// Summe durch vier teilen = arithm. Mittelwert
}

void ausgabeLcdauslastung(int auslastung1, int l){
	static int auslastungold=0;						//statischen integer erzeugen mit dem namen "wertold"
	if (auslastungold!= auslastung1){				//Abfrage ob die alte Ausgabe gleich der neuen ist
		lcd_clear();								//LCD löschen
		char *str, buffer[10];			
		str= utoa(auslastung1, buffer, 10);			//Umwandlung von int nach string	
		lcd_writeText(str,l); 						//wandlerwert ausgeben
		auslastungold = auslastung1;				//aktuelle Ausgabe in die Variable old überschreiben
		lcd_goto(1,4);								//Cursor-Sprung auf Zeile 1;Spalte4
  		lcd_writeText("% Auslastung",12);			//Das Zeichenhette"% Auslastung" wird an der Cursor-Position ausgegeben
	}
	else {
		auslastungold = auslastung1;				//aktuelle Ausgabe in die Variable old überschreiben 
	}

void ausgabeLcdtemperatur(int temperatur1, int l){
	static int temperaturold=0;						//statischen integer erzeugen mit dem namen "wertold"
	if (temperaturold!= temperatur1){				//Abfrage ob die alte Ausgabe gleich der neuen ist
		lcd_clear();								//LCD löschen
		char *str, buffer[10];			
		str= utoa(temperatur1, buffer, 10);			//Umwandlung von int nach string	
		lcd_writeText(str,l); 						//wandlerwert ausgeben
		temperaturold = temperatur1;				//aktuelle Ausgabe in die Variable old überschreiben
		lcd_goto(1,4);								//Cursor-Sprung auf Zeile 1;Spalte4
  		lcd_writeText("°C",3);						//Das Zeichenhette"% Auslastung" wird an der Cursor-Position ausgegeben
	}
	else {
		temperaturold = temperatur1;				//aktuelle Ausgabe in die Variable old überschreiben 
	}
}
/***************************************************************************************/

int main (void){

/*******************************Konfiguration*******************************************/
DDRB |= (1<<PB1) ; 									// PB1 als Ausgang den Rest als Eingang
DDRC |= (1<<PC1) | (1<<PC2) | (1<<PC3) | (1<<PC4) | (1<<PC5) | (1<<PC6); 	// PC0 als Eingang den Rest als Ausgang
lcd_init();											// LCD initialisieren durch Unterprogrammaufruf
Timer_init(); 										// Timer initialisieren
wandler_init(); 									// AD-Wandler initilisieren
/***************************************************************************************/

while (1){

	wandlung();										// ruft das Unterprogramm wandlung auf

	ausgabeLcdtemperatur(temperatur,3);				// ruft das Unterprogramm ausgabeLcdtemperatur auf und übergibt den Temperatur Wert

	wert=(int)result;								// impliziten Integer aus dem float result erstellen
	
	if (wert>100<=200){								// überprüft ob die Variable größer 100 kleiner gleich 200 ist
	anhebung = 20;									// setzt die Variable anhebung auf den Wert 20
	}

	else if (wert>200<=400){						// überprüft ob die Variable größer 200 kleiner gleich 400 ist
	anhebung = 30;									// setzt die Variable anhebung auf den Wert 30
	}

	else if (wert>400<=600){						// überprüft ob die Variable größer 400 kleiner gleich 600 ist
	anhebung = 40;									// setzt die Variable anhebung auf den Wert 40
	}

	else if (wert>600<=800){						// überprüft ob die Variable größer 600 kleiner gleich 800 ist
	anhebung = 50;									// setzt die Variable anhebung auf den Wert 50
	}

	else if (wert > 800){								// überprüft ob die Variable größer 800ist
	anhebung = 60;									// setzt die Variable anhebung auf den Wert 60
	}

	if (temperatur<=5){								// überprüft ob die Variable kleiner gleich 5 ist
	geschwindigkeit = 150; 							// setzt die Variable auf den Wert 150
	}

	else if (temperatur>5<=10){						// überprüft ob die Variable größer 5 und kleiner gleich 10 ist
	geschwindigkeit = 250;							// setzt die Variable auf den Wert 250
	}

	else if (temperatur>10<=15){					// überprüft ob die Variable größer 10 und kleiner gleich 15 ist
	geschwindigkeit = 400;							// setzt die Variable auf den Wert 400
	}

	else if (temperatur>15){							// überprüft ob die Variable größer 15 ist
	geschwindigkeit = 551;							// setzt die Variable auf den Wert 511
	}

	OCR1A = (int)(geschwindigkeit+anhebung); 		// schaltet PB1 von 1 auf 0
	auslastung = ((OCR1A/511)*100);					// Prozentuale Auslastung berechnen und Wert in die Variable schreiben
	ausgabeLcdauslastung(auslastung,3);				// ruft das Unterprogramm ausgabeLcdauslastung auf und übergibt den Wert von auslastung
	
  
 }
}

Fehlermeldung 1: expected '(' before wert
Fehlermeldung 2: expected declaration or statement at end of input

Mir ist klar dass ich irgendwo entsprechende Zeichen gefunden habe aber ich habe bisher noch keine lösung für das problem gefunden

mfg
 
Hallo Jörg,

bei diesen Platinchen kann ich dir leider nicht helfen. :)

Aber vielleicht hilft dir folgendes weiter:

Die abschließende geschweifte "Klammer zu" fehlt bei der Routine
void ausgabeLcdauslastung(int auslastung1, int l).

Komplett konnte ich dein Programm nicht kompilieren, da mir lcd.h/c fehlt, es ist also möglich, dass weitere Fehler vorhanden sind.

Dirk :ciao:
 
Hey Dirk

danke für den Tip der war schonmal gold wert hab die klammer komplett übersehen.
kannst du mir denn sagen wie die syntax von einem between befehl in c aussieht ich muss bei diesen if abfragen und dem between klammern setzen laut fehlercode ich kenne die genaue syntax dieses befehls nicht sondern habe ihn aus einer anderen programmiersprache genutzt.

mfg
 
Hallo Jörg,
wie die syntax von einem between befehl in c aussieht

uuuups, das hatte ich ganz übersehen, du meinst zum Beispiel dies:
Code:
if (wert>100<=200){                                // überprüft ob die Variable größer 100 kleiner gleich 200 ist
anhebung = 20;                                    // setzt die Variable anhebung auf den Wert 20
    }

So wäre es richtig:

Code:
if ( (wert > 100) && (wert <= 200) )

&& steht für UND-Verknüpfung der beiden Bedingungen,
|| steht für ODER-Verknüfpung der beiden Bedingungen.


Dirk :ciao:
 
ich habe nun noch leider ein problem mit der pwm kann ich prima meinen lüfter hoch und runter reglen jedoch nicht bis auf null. ich habe immer einen rest und ich weiß absolut nicht woran es liegt und die erste zeile die für die auslastung reserviert ist wird nicht ausgegeben.vielleicht hatja jemand noch einen tip.
hier meine dateien:
Code:
/***************************************************************************************/
/*PWM-Steuerung über Temperaturfühler LM75 eines Lüfters an PB1
und Sollwertanhebung über Poti an PC0*/
/***************************************************************************************/
/***************************************************************************************/
#define F_CPU 3686400 								// Taktfrequenz des myAVR-Boards
#include <avr\io.h>									// AVR Register und Konstantendefinitionen
#include <avr\interrupt.h> 							// Weitere Interruptdefinitionen
#include "lcd.h"									// bindet die LCD Headerdatei ein
/***************************************************************************************/
/*******************************Variablen***********************************************/
int wert=0;											// legt die Variable wert als int mit dem Wert 0 an
int i=0;											// legt die Variable i als int mit dem Wert 0 an
float result = 0;									// legt die Variable result als float mit dem Wert 0 an
int anhebung = 0;									// legt die Variable anhebung als int mit dem Wert 0 an
float temperatur = 6;								// legt die Variable temperatur als float mit dem Wert 0 an
unsigned int geschwindigkeit = 0;					// legt die Variable geschwinigkeit als int mit dem Wert 0 an
unsigned int auslastung = 0;
unsigned int zwischensumme = 0;
/***************************************************************************************/
/*******************************Unterprogramme******************************************/

void Timer_init (){
	TCCR1A = (1<<WGM11) | (1<<COM1A1) | (1<<COM1B1);	// Fast-PWM Mode 14(ICR1); verknüpfung auf PB1 und RESET OC1B
	TCCR1B = (1<<WGM12) | (1<<WGM13) | (1<<CS11);		// Prescaler 8; FAST-PWM Mode 14(ICR1)
	ICR1 = 0x1ff; 										// setzt Maximalwert des Timers (511)
}

void wandler_init (){
	ADMUX  |= (1<<REFS0);								// auf interne Referenz schalten
	ADCSRA |= (1<<ADEN); 								// Wandler einschalten
}

void wandlung (){
	ADCSRA |= (1<<ADSC);              					// eine AD-Wandlung
while (ADCSRA & (1<<ADSC)) {;}						// auf Abschluss der Konvertierung warten
result = ADCW;  									// AD Wandler muss einmal gelesen werden, sonst wird Ergebnis der nächsten Wandlung nicht übernommen.
result = 0; 										// Variable result wieder auf 0 setzen
for(i=0; i<4; i++)	{								// Eigentliche Messung - Mittelwert aus 4 aufeinanderfolgenden Wandlungen hochzählen bis 4
ADCSRA |= (1<<ADSC);           					// eine Wandlung
    while (ADCSRA & (1<<ADSC)) {;}					// auf Abschluss der Konvertierung warten								
    result += ADCW;        							// Wandlungsergebnisse aufaddieren
   }
  	result /= 4;                     				// Summe durch vier teilen = arithm. Mittelwert
}

void ausgabeLcdauslastung(int auslastung, int k){
	static int auslastungold=0;						//statischen integer erzeugen mit dem namen "wertold"
	if (auslastungold!= auslastung){				//Abfrage ob die alte Ausgabe gleich der neuen ist
		lcd_clear();								//LCD löschen
		char *str, buffer[10];			
		str= utoa(auslastung, buffer, 10);			//Umwandlung von int nach string	
		lcd_writeText(str,k); 						//wandlerwert ausgeben
		auslastungold = auslastung;				//aktuelle Ausgabe in die Variable old überschreiben
		lcd_goto(1,4);								//Cursor-Sprung auf Zeile 1;Spalte4
  		lcd_writeText("% Auslastung",12);			//Das Zeichenhette"% Auslastung" wird an der Cursor-Position ausgegeben
	}
	else {
		auslastungold = auslastung;				//aktuelle Ausgabe in die Variable old überschreiben 
	}
}
void ausgabeLcdtemperatur(int temperatur, int l){
	static int temperaturold=0;						//statischen integer erzeugen mit dem namen "wertold"
	if (temperaturold!= temperatur){				//Abfrage ob die alte Ausgabe gleich der neuen ist
		lcd_clear();								//LCD löschen
		char *str, buffer[10];			
		str= utoa(temperatur, buffer, 10);			//Umwandlung von int nach string	
		lcd_goto(2,1);
		lcd_writeText(str,l); 						//wandlerwert ausgeben
		temperaturold = temperatur;				//aktuelle Ausgabe in die Variable old überschreiben
		lcd_goto(2,3);								//Cursor-Sprung auf Zeile 2;Spalte4
  		lcd_writeText("Grad",4);						//Das Zeichenhette"% Auslastung" wird an der Cursor-Position ausgegeben
	}
	else {
		temperaturold = temperatur;				//aktuelle Ausgabe in die Variable old überschreiben 
	}
}
/***************************************************************************************/

int main (void){

/*******************************Konfiguration*******************************************/
DDRB |= (1<<PB1) ; 									// PB1 als Ausgang den Rest als Eingang
DDRC |= (1<<PC1) | (1<<PC2) | (1<<PC3) | (1<<PC4) | (1<<PC5) | (1<<PC6); 	// PC0 als Eingang den Rest als Ausgang
lcd_init();											// LCD initialisieren durch Unterprogrammaufruf
Timer_init(); 										// Timer initialisieren
wandler_init(); 									// AD-Wandler initilisieren
/***************************************************************************************/

while (1){

	wandlung();										// ruft das Unterprogramm wandlung auf
	temperatur = (int) temperatur;
	ausgabeLcdtemperatur(temperatur,3);				// ruft das Unterprogramm ausgabeLcdtemperatur auf und übergibt den Temperatur Wert

	wert=(int)result;								// impliziten Integer aus dem float result erstellen
	
	if ( (wert > 100) && (wert <= 200) ){								// überprüft ob die Variable größer 100 kleiner gleich 200 ist
	anhebung = 20;									// setzt die Variable anhebung auf den Wert 20
	}

	if ( (wert > 200) && (wert <= 400) ){						// überprüft ob die Variable größer 200 kleiner gleich 400 ist
	anhebung = 30;									// setzt die Variable anhebung auf den Wert 30
	}

	if ( (wert > 400) && (wert <= 600) ){						// überprüft ob die Variable größer 400 kleiner gleich 600 ist
	anhebung = 40;									// setzt die Variable anhebung auf den Wert 40
	}

	if ( (wert > 600) && (wert <= 800) ){						// überprüft ob die Variable größer 600 kleiner gleich 800 ist
	anhebung = 50;									// setzt die Variable anhebung auf den Wert 50
	}

	if (wert > 800){								// überprüft ob die Variable größer 800ist
	anhebung = 60;									// setzt die Variable anhebung auf den Wert 60
	}
	
	if (temperatur<=5){								// überprüft ob die Variable kleiner gleich 5 ist
	geschwindigkeit = 0; 							// setzt die Variable auf den Wert 150
	}

	if ( (temperatur > 5) && (temperatur <= 10) ){						// überprüft ob die Variable größer 5 und kleiner gleich 10 ist
	geschwindigkeit = 200;							// setzt die Variable auf den Wert 250
	}

	if ( (temperatur > 10) && (temperatur <= 15) ){					// überprüft ob die Variable größer 10 und kleiner gleich 15 ist
	geschwindigkeit = 400;							// setzt die Variable auf den Wert 400
	}

	if (temperatur>15){							// überprüft ob die Variable größer 15 ist
	geschwindigkeit = 551;							// setzt die Variable auf den Wert 511
	}

	zwischensumme = (geschwindigkeit+anhebung);
	OCR1A = zwischensumme;
	auslastung = ((OCR1A/511)*100);					// Prozentuale Auslastung berechnen und Wert in die Variable schreiben
	ausgabeLcdauslastung(auslastung,3);				// ruft das Unterprogramm ausgabeLcdauslastung auf und übergibt den Wert von auslastung
 }
}
und hier die lcd.c
Code:
//--------------------------------------------------------------------------
// Titel		: LCD-Bibliothek
// Funktion		: Beinhaltet Funktionen f?r die LCD-Anzeige
// Schaltung	: Anschluss ?ber die Leiste
// Prozessor	: ATmega8 mit 3,6864 MHz
// Sprache		: C
// Datum		: 26.01.2011
// Version		: 1.1
// Autor		: Dr. Ulf Milanese
//--------------------------------------------------------------------------
#include <avr/io.h>
#include "lcd.h"
#include <util/delay.h>


//-------------------------------------------------------------------------
//	lcd_enable() - setzt das Enable-Signal f?r eine Millisekunde auf HI
//	PE:	keine
//	PA:	keine
//-------------------------------------------------------------------------
void lcd_enable()
{
	PORTD |= (1<<3);
	_delay_ms(1);
	PORTD &= ~(1<<3);
}


//-------------------------------------------------------------------------
//	lcd_init(..) - Initialisiert das myAVR LCD 16x2, 4 Bit Modus
//	PE:	keine
//	PA:	keine
//-------------------------------------------------------------------------
void lcd_init()
{
	// Port D = Ausgang
	DDRD = 0b11111111;
	PORTD = 0b00000000;
	// muss 3mal hintereinander gesendet werden zur Initialisierung
 
	/*
	_delay_ms(15);
	lcd_enable();
 
	_delay_ms(5);
	lcd_enable();
 
	_delay_ms(1);
	lcd_enable();
	_delay_ms(1);
	*/
	
	// warten bis LCD-Controller gebootet
	_delay_ms(200);
	// 4-Bit-Modus einschalten
	PORTD |= (1<<5);
	// Zeit zum Umschalten lassen
	_delay_ms(10);
	// Schreibsignal Enable-Impuls
	lcd_enable();
	// Zeit zum Umschalten lassen
	_delay_ms(10);
	// Enable Impuls noch ein 2. mal schicken, ansonsten wurde Display
	// teilweise nicht richtig initialisiert
//	lcd_enable();
	// Zeit zum Umschalten lassen
//	_delay_ms(10);
	// ab hier im 4-Bit-Modus
	// Funktions-Set: 2 Zeilen, 5x7 Matrix, 4 Bit
	lcd_cmd(0b00101000);
	lcd_off();
	lcd_clear();
	// Entry Mode
	lcd_cmd(0b00000110);
	lcd_on();
}


//-------------------------------------------------------------------------
//	lcd_send(..) - sendet ein Byte an LCD im 4-Bit-Modus
//	RS muss vorher richtig gesetzt sein
//	PE:	data=zu sendendes Byte
//-------------------------------------------------------------------------
void lcd_send(char data)
{
	char tmp = data;
	// aktuelles RS ermitteln
	char rs = PORTD;
	rs &= (1<<2);
	// High-Teil senden
	tmp &= 0b11110000;
	tmp |= rs;
	PORTD = tmp;
	// Schreibsignal
	lcd_enable();
	// Low-Teil senden
	tmp = data;
	tmp &= 0b00001111;
	tmp <<= 4;	// Die 4 Bits um 4 Stellen nach links schieben
	tmp |= rs;
	PORTD = tmp;	
	// Schreibsignal
	lcd_enable();
	// verarbeiten lassen
	_delay_ms(1);
}


//-------------------------------------------------------------------------
//    lcd_cmd(..) - sendet ein Kommando an LCD
//	PE:	cmd=Kommando-Byte
//-------------------------------------------------------------------------
void lcd_cmd(char cmd)
{
	PORTD &= ~(1<<2);
	lcd_send(cmd);
}


//-------------------------------------------------------------------------
//    lcd_clear(..) - l?scht die Anzeige im LCD
//-------------------------------------------------------------------------
void lcd_clear()
{
	lcd_cmd(0b00000001);
	_delay_ms(2);			// warten
}
//-------------------------------------------------------------------------
//    lcd_home(..) - Cursor auf Position 1,1
//-------------------------------------------------------------------------
void lcd_home()
{
	lcd_cmd(0b00000010);
	_delay_ms(2);			// warten
}


//-------------------------------------------------------------------------
//    lcd_on(..) - Schaltet das LCD an
//-------------------------------------------------------------------------
void lcd_on()
{
	lcd_cmd(0b00001110);
}

//-------------------------------------------------------------------------
//    lcd_off(..) - Schaltet das LCD aus
//-------------------------------------------------------------------------
void lcd_off()
{
	lcd_cmd(0b00001000);
}

//-------------------------------------------------------------------------
//	lcd_goto(..) - setzt die Cursorposition
//	PE:	row = Zeile 1/2
//		col = Spalte 1..16
//-------------------------------------------------------------------------
void lcd_goto(int row, int col)
{
	char tmp;   
	row--;				// Null-basierend
	row &= (1<<0);			// sicherheitshalber
	row *= 64;				// Zeile nach Bit 6 bringen
	col--;				// Null-basierend
	col &= 0b00001111;		// sicherheitshalber
	tmp = row | col;			// Adresse bilden
	tmp |= (1<<7);			// Cursor setzen
	lcd_cmd(tmp);			// setzen
}

//-------------------------------------------------------------------------
//	lcd_light(..) - schaltet die LCD Hintergrundbeleuchtung ein oder aus
//	PE:	on_off=0..1 = Beleuchtung ein- bzw. ausschalten
//-------------------------------------------------------------------------
int lcd_dimmer_is_init=0;
void lcd_light(int on_off)
{
	// wenn dimmer an -> PWM deinit
	if (lcd_dimmer_is_init == 1)
	{
		TCCR1A = 0;
		lcd_dimmer_is_init = 0;
	}
	DDRB |= (1<<1);		// PORTB1 als Ausgang
	if (on_off == 1)
	{
		PORTB |= (1<<1);	// an
	} else {
		PORTB &= ~(1<<1);	// aus
	}
}

//-------------------------------------------------------------------------
//    lcd_dimmer(..) - legt die Helligkeit der Hintergrundbeleuchtung fest
//	PE:	light=0..255 Helligkeit der Anzeige
//-------------------------------------------------------------------------
void lcd_dimmer(char light)
{
	// init
	if (lcd_dimmer_is_init == 0)
	{
		DDRB |= (1<<1);		// PORTB1 als Ausgang
		TCCR1A = 0b10000001;			// PWM Mode 1, Channel A
		TCCR1B = (1<<1);			// PWM Frequenz CLK/8
		lcd_dimmer_is_init = 1;
	}
	OCR1A = light;					// PWM Vergleichswert
}

//-------------------------------------------------------------------------
//    lcd_write(..) - sendet ein Zeichen (Daten) an LCD
//	PE:	text=Zeichen
//-------------------------------------------------------------------------
void lcd_write(char text)
{
	PORTD |= (1<<2);			// RS setzen = Daten
	lcd_send(text);			// senden
}


//-------------------------------------------------------------------------
//    lcd_writeText(..) - sendet einen String (Daten) an LCD
//	PE:	text=Zeichenkette, laenge=Anzahl von Zeichen
//-------------------------------------------------------------------------
void lcd_writeText(char * text, int laenge)
{
	int zaehler;
	for (zaehler = 0; zaehler < laenge; zaehler++) {
		lcd_write (text[zaehler]);
	}
}
und die lcd.h
Code:
//--------------------------------------------------------------------------
// Titel		: LCD-Bibliothek
// Funktion		: Beinhaltet Funktionen f?r die LCD-Anzeige
// Schaltung	: Anschluss ?ber die Leiste
// Prozessor	: ATmega8 mit 3,6864 MHz
// Sprache		: C
// Datum		: 18.02.2010
// Version		: 1.0
// Autor		: Dr. Ulf Milanese
//--------------------------------------------------------------------------
#ifndef _LCD_H
#define _LCD_H

# define F_CPU 3686400

#include <avr/io.h>
#include <util/delay.h>

void lcd_enable();
//-------------------------------------------------------------------------
//	lcd_init(..) - Initialisiert das myAVR LCD 16x2, 4 Bit Modus
//	PE:	keine
//	PA:	keine
//-------------------------------------------------------------------------
void lcd_init();
//-------------------------------------------------------------------------
//	lcd_send(..) - sendet ein Byte an LCD im 4-Bit-Modus
//	RS muss vorher richtig gesetzt sein
//	PE:	data=zu sendendes Byte
//-------------------------------------------------------------------------
void lcd_send(char data);
//-------------------------------------------------------------------------
//    lcd_cmd(..) - sendet ein Kommando an LCD
//	PE:	cmd=Kommando-Byte
//-------------------------------------------------------------------------
void lcd_cmd(char cmd);
//-------------------------------------------------------------------------
//    lcd_clear(..) - l?scht die Anzeige im LCD
//-------------------------------------------------------------------------
void lcd_clear();
//-------------------------------------------------------------------------
//    lcd_home(..) - Cursor auf Position 1,1
//-------------------------------------------------------------------------
void lcd_home();
//-------------------------------------------------------------------------
//    lcd_on(..) - Schaltet das LCD an
//-------------------------------------------------------------------------
void lcd_on();
//-------------------------------------------------------------------------
//    lcd_off(..) - Schaltet das LCD aus
//-------------------------------------------------------------------------
void lcd_off();
//-------------------------------------------------------------------------
//	lcd_goto(..) - setzt die Cursorposition
//	PE:	row = Zeile 1/2
//		col = Spalte 1..16
//-------------------------------------------------------------------------
void lcd_goto(int row, int col);
//-------------------------------------------------------------------------
//	lcd_light(..) - schaltet die LCD Hintergrundbeleuchtung ein oder aus
//	PE:	on_off=0..1 = Beleuchtung ein- bzw. ausschalten
//-------------------------------------------------------------------------
void lcd_light(int on_off);
//-------------------------------------------------------------------------
//    lcd_dimmer(..) - legt die Helligkeit der Hintergrundbeleuchtung fest
//	PE:	light=0..255 Helligkeit der Anzeige
//-------------------------------------------------------------------------
void lcd_dimmer(char light);
//-------------------------------------------------------------------------
//    lcd_write(..) - sendet ein Zeichen (Daten) an LCD
//	PE:	text=Zeichen
//-------------------------------------------------------------------------
void lcd_write(char text);
//-------------------------------------------------------------------------
//    lcd_writeText(..) - sendet einen String (Daten) an LCD
//	PE:	text=Zeichenkette, laenge=Anzahl der Zeichen
//-------------------------------------------------------------------------
void lcd_writeText(char * text, int laenge);

#endif

danke für eure mühe
 
Hallo Jörg,

wegen der LCD-Ausgbabe müsste ich genauer schauen, so auf Anhieb finde ich es nicht.

Bei der Einstellung der PWM sehe ich den Fehler:


Code:
    if ( (wert > 100) && (wert <= 200) ){                                // überprüft ob die Variable größer 100 kleiner gleich 200 ist
    anhebung = 20;                                    // setzt die Variable anhebung auf den Wert 20
    }

    if ( (wert > 200) && (wert <= 400) ){                        // überprüft ob die Variable größer 200 kleiner gleich 400 ist
    anhebung = 30;                                    // setzt die Variable anhebung auf den Wert 30
    }

    if ( (wert > 400) && (wert <= 600) ){                        // überprüft ob die Variable größer 400 kleiner gleich 600 ist
    anhebung = 40;                                    // setzt die Variable anhebung auf den Wert 40
    }

    if ( (wert > 600) && (wert <= 800) ){                        // überprüft ob die Variable größer 600 kleiner gleich 800 ist
    anhebung = 50;                                    // setzt die Variable anhebung auf den Wert 50
    }

    if (wert > 800){                                // überprüft ob die Variable größer 800ist
    anhebung = 60;                                    // setzt die Variable anhebung auf den Wert 60
    }

Ich denke hier fehlt noch (wert<=100).

Schreibe vielleicht aus so...

Code:
    if ( (wert > 100) && (wert <= 200) ){                                 // überprüft ob die Variable größer 100 kleiner gleich  200 ist
      anhebung = 20;                                    // setzt die Variable anhebung auf den Wert 20
    } [B]else   [/B]if ( (wert > 200) && (wert <= 400) ){                         // überprüft ob die Variable größer 200 kleiner gleich 400 ist
      anhebung = 30;                                    // setzt die Variable anhebung auf den Wert 30
    } [B]else   [/B]if ( (wert > 400) && (wert <= 600) ){                         // überprüft ob die Variable größer 400 kleiner gleich 600 ist
      anhebung = 40;                                    // setzt die Variable anhebung auf den Wert 40
    } [B]else   [/B]if ( (wert > 600) && (wert <= 800) ){                         // überprüft ob die Variable größer 600 kleiner gleich 800 ist
      anhebung = 50;                                    // setzt die Variable anhebung auf den Wert 50
    } [B]else   [/B]if (wert > 800){                                // überprüft ob die Variable größer 800ist
      anhebung = 60;                                    // setzt die Variable anhebung auf den Wert 60
    } [B]else [/B]{
      [B]anhebung = 0; // ?[/B]
    }

(bei der Temperatur vielleicht genauso)

Dirk :ciao:
 

Über uns

  • Makerconnect ist ein Forum, welches wir ausschließlich für einen Gedankenaustausch und als Diskussionsplattform für Interessierte bereitstellen, welche sich privat, durch das Studium oder beruflich mit Mikrocontroller- und Kleinstrechnersystemen beschäftigen wollen oder müssen ;-)
  • Dirk
  • Du bist noch kein Mitglied in unserer freundlichen Community? Werde Teil von uns und registriere dich in unserem Forum.
  •  Registriere dich

User Menu

 Kaffeezeit

  • Wir arbeiten hart daran sicherzustellen, dass unser Forum permanent online und schnell erreichbar ist, unsere Forensoftware auf dem aktuellsten Stand ist und der Server regelmäßig gewartet wird. Auch die Themen Datensicherheit und Datenschutz sind uns wichtig und hier sind wir auch ständig aktiv. Alles in allem, sorgen wir uns darum, dass alles Drumherum stimmt :-)

    Dir gefällt das Forum und unsere Arbeit und du möchtest uns unterstützen? Unterstütze uns durch deine Premium-Mitgliedschaft!
    Wir freuen uns auch über eine Spende für unsere Kaffeekasse :-)
    Vielen Dank! :ciao:


     Spende uns! (Paypal)