Netzteil Hutschiene
Als Spannungsversorgung der Hutschienen-Module kommt
ebenfalls ein Hutschienen-Modul als Netzteil zur Anwendung. Passend zum
verwendeten Hutschienen-Gehäusedesign ist unter www.conrad.de
ein entsprechendes Netzteil zur C-Control Familie verfügbar. Betriebsparameter
230V, +12V Sekundär, 125mA Dauerbelastungsstrom. Der Prototyp des RS-232
Konverters benötigt ca. 50mA. Es besteht somit noch genügend Reserve für
Erweiterungen zur Verfügung.
Programmierung ab 19.04.2009. Verwendete IDE Version 1.77.
Ab 14.05.2009 steht neue IDE Version 2.0 zur Verfügung. Neue
Library-Funktion Clock
Umstellung ab 24.05.2009. Vorteile: Schnellere Übertragung,
da Interpreter nur dann erneut mit Übertragen wird, wenn eine neuere Version
verwendet wurde.
6.3.6.1.
Listings
/*
File: VRC.cc
Creation: 2009-04-19
Version: 9.12.27 (change
#DEFINE VERSION below)
Author: Michael Gries
(c)2009
IDE-Lib: 2.01 (27.06.2009)
*/
/*
Version history:
2009-04-19 Erstellung
2009-06-14 X-Parameter hinzu
2009-12-13 Versionsangabe im Zeitstempel
*/
// Generic Preprozessor:
http://nothingisreal.com/gpp/gpp.html
//------------------------------------------------------------------------------
// Hauptprogramm
//
/*
Verwendete Module (in config entsprechender
Reihenfolge):
VRC.cc Hauptprogramm
Serial.cc 2xRS232 (Kommandointerpreter von TC65
Terminal)
Datagram.cc Datagramm-Anylsyse von
iroVIT-Signal
Ports.cc Def. benutzter Mega128 Prots der
C-Control Pro
Clock.cc internes Zeitmanagement
EEPROM.cc internes EEProm handling
Debug.cc Diagnoseprozeduren
DirectAccess.cc direkter Zugriff auf die
Register des MEGA128
String_Lib.cc (explicit), d.h. nicht als
Interpreter Lib eingebunden
ascii.ch (include Datei), ascii Zeichen
*/
/*
Signature Bytes
All Atmel
microcontrollers have a three-byte signature code
which identifies the
device. This code can be read in both serial and
parallel mode, also when
the device is locked.
The three bytes reside
in a separate address space.
For the ATmega128 the
signature bytes are:
1. $000: $1E (indicates
manufactured by Atmel)
2. $001: $97 (indicates
128KB Flash memory)
3. $002: $02 (indicates
ATmega128 device when $001 is $97)
*/
#include ascii.ch // ASCII Steuerzeichen
#define PRJ "VRC"
#define PROJECT
"VRC-Monitor"
#define VERSION
"9.12.27"
#define AUTHOR
"Michael Gries"
#define COPYRIGHT
"(c)2009"
#define LIBRARY
"2.01 (27.06.2009)"
#define TRACE false
char buffer0[255];
char buffer1[255];
char message[255];
char filename[128];
char function[128];
void main(void)
{
int sz;
int inv; inv=1;
word wsz;
byte bsz;
word ws0;
byte bs0;
unsigned char value[5];
int count;
byte mode;
/*
Initialisierungen
*/
Ports_InitVRC();
Clock_InitVRC();
DebugMode=0; // Debug mode
deactivated - press 'D' for activation
TraceMode=1; // Trace mode
activated - press 'T' for deactivation
ATempMin=0x0555;
ATempMax=0x0016;
KTempMin=0x0666;
KTempMax=0x0022;
WTempMin=0x0777;
WTempMax=0x0011;
Brenner=0x0000; BrennerDauer=0x0000;
mode = Ports_GetMode();
int baud; baud=mode;
message="\r\nMode: ";
Str_WriteInt(baud,message,STR_APPEND);
Serial_WriteText(0,message); // Text über RS232 ausgeben
char sline[8];
filename=__FILE__;
function=__FUNCTION__;
char nachricht[100]; nachricht=PROJECT; sline=__LINE__; //an dieser Stelle
//debug(__LINE__,__FILE__,"Test");
//EEPROM_Init();
//resetEEPROM(); // auskommentieren nach
Produktstionsstart
Serial_InitVRC(baud);
//prnBetriebsstunden();
float bs;
/* Test EEProm
bs = EEPROM_GetBetriebsstunden(); bs=bs+0.16;
EEPROM_SetBetriebsstunden(bs);
*/
Debug(sline,function,nachricht);
char para2[10]; Str_WriteWord(SR_BD19200,10,para2,0,6);
Str_Copy(nachricht,para2,0); sline=__LINE__;
Debug(sline,function,nachricht);
/*
message="\r\nWait 2 seconds
...\r\n";
Serial_WriteText(0,message); // Text über RS232
ausgeben
AbsDelay(1000); // 1 Sek. Wartezeit
// Abfrage wieviel Zeichen empfangen wurden
count=Serial_IRQ_Info(0,RS232_FIFO_RECV);
// Die Anzahl der Zeichen wird als Meldung
ausgegeben
Msg_WriteWord(count);
Serial_WriteHex(0,count);
message=" Zeichen im IRQ-Modus
empfangen\r\n\n";
Msg_WriteText(message);
Serial_WriteText(0,message);
*/
Debug_Info();
AbsDelay(1000); // 1 Sek. Wartezeit
Debug_ModeDeactivate();
while(true) // Endlosschleife
{
Serial_HandleVRCdata(); // periodische Daten von
der iroVIT-Anlage
Serial_HandleCommands(); // Statusabfragen vom PC
oder TC65T
} // end while
}
/*
File: Serial.cc
Creation: 2009-05-22
Version: 9.12.26
Author: Michael Gries (c)2009
*/
/*
Version history:
2009-05-22 Erstellung
2009-12-26 Bug beseitigt wenn erstes Zeichen FF
*/
void Serial_InitVRC(int baud)
{
// Serial 0 (to PC or
TC65Terminal)
#define TC65T PC
#define PC 0
if(baud==1)
{
Serial_Init_IRQ(0,buffer0,100,100,SR_8BIT|SR_1STOP|SR_NO_PAR,SR_BD19200);
}else
{
Serial_Init_IRQ(0,buffer0,100,100,SR_8BIT|SR_1STOP|SR_NO_PAR,SR_BD115200);
}
// Serial 1 (from
iroVIT-VRC interface)
#define VRC 1
Serial_Init_IRQ(VRC,buffer1,100,100,SR_8BIT|SR_1STOP|SR_NO_PAR,SR_BD2400);
}
void Serial_HandleCommands(void)
{
word w; w=Serial_ReadExt(PC); // read TC65T
Command-buffer
if(!(w==0x100))
{
switch(w)
{
case '?':
case 'h':
case 'H': Debug_Help(); break;
case 'd': Debug_ModeDeactivate(); break;
case 'D': Debug_ModeActivate(); break;
case 'a': EEPROM_PrintAussentempMin(); break;
case 'A': EEPROM_PrintAussentempMax(); break;
case 'b':
case 'B': EEPROM_PrintBetriebsstunden(); break;
case 'c': Clock_PrintTimestamp(); break;
case 'i': Debug_Info(); break;
case 'k': EEPROM_PrintKesseltempMin(); break;
case 'K': EEPROM_PrintKesseltempMax(); break;
case 'w': EEPROM_PrintWassertempMin(); break;
case 'W': EEPROM_PrintWassertempMax(); break;
case 't': Debug_TraceModeActivate(); break;
case 'T': Debug_TraceModeDeactivate(); break;
case '~': Datagram_SMSdata(); break;
case ESC:
case TAB: Serial_WriteNewLine(); break;
case SP: Serial_WriteMarkLine(); break;
case 0x30: Serial_Write(0,'0'); break;
case 0x31: Serial_Write(0,'1'); break;
case 0x32: Serial_Write(0,'2'); break;
case 0x33: Serial_Write(0,'3'); break;
case 0x34: Serial_Write(0,'4'); break;
case 0x35: Serial_Write(0,'5'); break;
case 0x36: Serial_Write(0,'6'); break;
case 0x37: Serial_Write(0,'7'); break;
case 0x38: Serial_Write(0,'8'); break;
case 0x39: Serial_Write(0,'9'); break;
//default:
Serial_Write(0,w); // for test purposes only
}
}
}
void Serial_HandleVRCdata(void)
{
char Text1[40]; // Array
deklariert
char ausgabe[40];
int sz;
int inv; inv=1;
word wsz; byte bsz;
unsigned char value[5];
int dCount;
wsz=Serial_ReadExt(VRC); // Puffer
auslesen
if(!(wsz==0x100)) //0x100 ==
Puffer leer
{
Ports_SetLED();
bsz=wsz;
datagram[pos++]=bsz;
if((pos==1) && (bsz==0xFF)) // bekannter Übertragungsfehler
{
Serial_ErrorFF();
Ports_ResetLED();
pos=0;
}
//datagram[count]=wsz;
message="#";
//Str_Copy(datagram,message,STR_APPEND);
//count=count+1;
if(DebugMode)
{
Str_WriteWord(wsz,16,value,0,2); //formatiert
ausgeben
Serial_WriteText(PC,value);
Serial_Write(PC,' '); Serial_Write(0,' ');
// Formatierung nach Datagram-Grenzen (Nr.
1-3,4,5-6,7-8
if((pos==16)||(pos==31)||(pos==42)||(pos==57))
{
Serial_WriteNewLine();
}
} else
{
if(TraceMode)
{
Serial_Write(0,bsz);
}
}
if((wsz==0x22 || wsz==0x23)
&& (pos>60))
{
Ports_ResetLED();
if(DebugMode)
{
Serial_WriteNewLine();
//wsz=sizeof(datagram)*SIZE;
message="Anzahl
Datagram-Bytes: ";
Serial_WriteText(0,message);
Serial_WriteInt(0,pos);
Serial_WriteNewLine();
AbsDelay(300);
//clearDatagram();
//setDatagram();
//Serial_WriteText(0,datagram);
//Datagram_Debug();
}
Datagram_Analyse();
if(DebugMode)
{
Datagram_Print();
AbsDelay(200);
Serial_WriteMarkLine();
Serial_WriteNewLine();
}
pos=0;
}
} // end serial
1 read
}
void Serial_WriteHex(byte ser, word value)
{
char sValue[10];
Str_WriteWord(value,16,sValue,0,4);
Serial_WriteText(ser,sValue);
}
void Serial_WriteInt(byte ser, word value)
{
char sValue[10];
Str_WriteWord(value,10,sValue,0,1);
Serial_WriteText(ser,sValue);
}
void Serial_WriteNewLine(void)
{
Serial_Write(0,LF); Serial_Write(0,CR);
}
void Serial_WriteMarkLine(void)
{
#define TERMINALSIZE
80
Serial_WriteNewLine();
Clock_UpdateTimestamp(); // into
global variable sTimestamp[]
char cAuthor[40]; cAuthor=" ";
Str_Copy(cAuthor,COPYRIGHT,STR_APPEND);
Str_Copy(cAuthor,",
",STR_APPEND);
Str_Copy(cAuthor,AUTHOR,STR_APPEND);
Str_Copy(cAuthor," ",STR_APPEND);
unsigned int a; a=Str_Len(cAuthor);
char cVersion[20]; cVersion=" ";
Str_Copy(cVersion,PRJ,STR_APPEND);
Str_Copy(cVersion," ",STR_APPEND);
Str_Copy(cVersion,VERSION,STR_APPEND);
Str_Copy(cVersion,"
---",STR_APPEND);
unsigned int v; v=Str_Len(cVersion);
message="---
";
Str_Copy(message,sTimestamp,STR_APPEND);
unsigned int t; t=Str_Len(message);
unsigned int f; f=TERMINALSIZE-t-v-a-3;
char cLine[255]; Str_Fill(cLine,'-',f);
Str_Copy(message,"---",STR_APPEND);
Str_Copy(message,cAuthor,STR_APPEND);
Str_Copy(message,cLine,STR_APPEND);
Str_Copy(message,cVersion,STR_APPEND);
Serial_WriteText(0,message);
Serial_WriteNewLine();
}
void Serial_ErrorFF(void)
{
Serial_WriteNewLine();
Serial_WriteText(PC,"Bus
Error 0xFF at ");
Clock_UpdateTimestamp(); // into
global variable sTimestamp[]
Serial_WriteText(PC,sTimestamp);
Serial_WriteNewLine();
// Abfrage wieviel Zeichen empfangen wurden
word cntBuffer;
cntBuffer=Serial_IRQ_Info(VRC,RS232_FIFO_RECV);
AbsDelay(100);
Serial_WriteText(PC,"No of
received characters: ");
Serial_WriteInt(PC,cntBuffer);
Serial_WriteNewLine();
while(false) //
endlosschleife
{
Serial_Write(PC,'.');
AbsDelay(60000);
}
}
/*
File: Datagram.cc
Creation: 2009-05-24
Version: 9.12.27
Author: Michael Gries
(c)2009
*/
/*
Version history:
9.5.24 Datagram analysis
added
9.6.6 Char
parameterInfo[] added -> Parameter interpretaion
9.6.14 X-Parameter added
(veränderlicher unbekannter Parameter)
9.6.16 Wochentag
encoding added
9.6.21 Wassertemp
Min/Max added
9.12.13 bug fix negative
temperature
9.12.27
Datagram_SMSdata() hinzu
*/
#define SIZE 67
#define posSTATUS 18
// Position Heizstatus
#define posDCF 21 //
DCF77 Status
#define posSEK 22 //
Sekunden (BCD)
#define posMIN 23 //
Minute (BCD)
#define posSTD 24 // Stunde (BCD)
#define posWO 25 // Wochentag (0-6 = M0-S0)
#define posTAG 26 // Tag (BCD)
#define posMON 27 // Monat (BCD)
#define posJAH 28 // Jahr (BCD-zweistellig)
#define posAT 32 // Position Aussentemp
#define posWT 35 // Position Wassertemp
#define posKT 38 // Position Kesseltemp
#define posHK 47 // Position Heizkurve
#define posXPara 52 // Position unbekannter
Parameter
#define posWB 64 // Position Winterbetrieb
byte datagram[SIZE];
char parameterInfo[60];
char datavalueInfo[60];
char SMSdata[255];
unsigned int pos;
word Status;
word Brenner; word BrennerLast; word BrennerDauer;
byte DCFstatus;
byte Sek; byte Min; byte Std;
byte Tag; byte Monat; byte Jahr;
byte Wochentag; char WOT[3];
word ATemp; word ATempMin; word ATempMax;
word WTemp; word WTempMin; word WTempMax;
word KTemp; word KTempMin; word KTempMax;
word HKurve;
word Betriebsart;
word XPara;
void Datagram_Clear(void)
{
for(pos=0;pos<SIZE;pos++) datagram[pos]=0;
}
void Datagram_Set(void)
{
for(pos=0;pos<SIZE;pos++) datagram[pos]=0x23; // '#'
}
void Datagram_Debug(void)
{
word w; char s[5];
for(pos=0;pos<SIZE;pos++)
{
w=datagram[pos];
Str_WriteWord(w,16,s,0,2);
Serial_WriteText(0,s);
AbsDelay(10); // wichtig:
Verzögerung TODO: tuning
}
}
void Datagram_Analyse(void)
{
Status= Datagram_Word(posSTATUS);
DCFstatus= Datagram_Byte(posDCF);
Sek= Datagram_Byte(posSEK);
Min= Datagram_Byte(posMIN);
Std= Datagram_Byte(posSTD);
Wochentag= Datagram_Byte(posWO);
Tag= Datagram_Byte(posTAG);
Monat= Datagram_Byte(posMON);
Jahr= Datagram_Byte(posJAH);
ATemp= Datagram_Word(posAT);
WTemp= Datagram_Word(posWT);
KTemp= Datagram_Word(posKT);
HKurve= Datagram_Word(posHK);
XPara= Datagram_Word(posXPara);
Betriebsart= Datagram_Word(posWB);
Datagram_TestATemp();
Datagram_TestKTemp();
Datagram_TestWTemp();
Datagram_TestBetriebsstunden();
}
void Datagram_Print(void)
{
AbsDelay(500); // wichtig: Verzögerung TODO: tuning
message="\r\nVRC-Status : ";
Serial_WriteText(0,message);
Serial_WriteHex(0,Status);
Datagram_InfoStatus();
Serial_WriteText(0,parameterInfo);
message="\r\nBrenndauer : ";
Serial_WriteText(0,message);
Serial_WriteHex(0,BrennerDauer);
Datagram_InfoBrennerDauer();
Serial_WriteText(0,parameterInfo);
message="\r\nDCF-Status
: ";
Serial_WriteText(0,message);
Serial_WriteHex(0,DCFstatus);
Datagram_InfoDCF();
Serial_WriteText(0,parameterInfo);
AbsDelay(500); // wichtig: Verzögerung TODO: tuning
message="\r\nDCF77 Zeit : ";
Serial_WriteText(0,message);
Datagram_InfoWochentag();
Str_Printf(message,"20%02d-%02d-%02d
%s %02d:%02d:%02d ",
Jahr,Monat,Tag,WOT,Std,Min,Sek);
Serial_WriteText(0,message);
Clock_SetDCF77();
message="\r\nAussentemp.:
";
Serial_WriteText(0,message);
Serial_WriteHex(0,ATemp);
Datagram_InfoTemp(ATemp);
Serial_WriteText(0,parameterInfo);
message="\r\nWassertemp.:
";
Serial_WriteText(0,message);
Serial_WriteHex(0,WTemp);
Datagram_InfoTemp(WTemp);
Serial_WriteText(0,parameterInfo);
message="\r\nKesseltemp.:
";
Serial_WriteText(0,message);
Serial_WriteHex(0,KTemp);
Datagram_InfoTemp(KTemp);
Serial_WriteText(0,parameterInfo);
message="\r\nHeiz-Kurve
: ";
Serial_WriteText(0,message);
Serial_WriteHex(0,HKurve);
Datagram_InfoTemp(HKurve);
Serial_WriteText(0,parameterInfo);
message="\r\nX-Parameter:
";
Serial_WriteText(0,message);
Serial_WriteHex(0,XPara);
//Datagram_InfoTemp(XPara);
//Serial_WriteText(0,parameterInfo);
AbsDelay(500); // wichtig: Verzögerung TODO: tuning
message="\r\nBetriebsart: ";
Serial_WriteText(0,message);
Serial_WriteHex(0,Betriebsart);
Datagram_InfoBetriebsart();
Serial_WriteText(0,parameterInfo);
Serial_WriteNewLine();
Serial_WriteNewLine();
}
word Datagram_Word(unsigned int
ind)
{
word wh; word wl;
wh=datagram[ind]; wh=wh<<8;
wl=datagram[ind+1];
return wh+wl;
}
byte Datagram_Byte(unsigned int
ind)
{ // 9.6.7
byte b;
b=datagram[ind];
return b;
}
void Datagram_InfoBetriebsart(void)
{ // 9.6.6
parameterInfo=" ";
switch(Betriebsart)
{
case 0x00: parameterInfo=" =
Sommerbetrieb"; break;
case 0x01: parameterInfo=" =
Winterbetrieb"; break;
}
}
void Datagram_InfoStatus(void)
{ // 9.6.6
parameterInfo=" ";
switch(Status)
{
case 0x0000: parameterInfo=" =
Bereitschaft";break;
case 0x0001: parameterInfo=" =
Heizbetrieb"; break;
case 0x0002: parameterInfo=" =
Warmwasser"; break;
case 0x0400: parameterInfo=" =
Warmwasser (Pumpenachlauf)"; break;
case 0x0402: parameterInfo=" =
Warmwasser (und Pumpe)"; break;
}
}
void Datagram_InfoBrennerDauer(void)
{ // 9.6.6
parameterInfo=" ";
if(BrennerDauer)
{
parameterInfo=" = Brenner aktiv";
} else
{
parameterInfo=" = Brenner aus";
}
}
void Datagram_InfoDCF(void)
{ // 9.6.6
parameterInfo=" ";
switch(DCFstatus)
{
case 0x00: parameterInfo=" = kein
Empfang"; break;
case 0x01: parameterInfo=" =
Empfang"; break;
case 0x02: parameterInfo=" =
Synchonisierung"; break;
case 0x03: parameterInfo=" =
Signal gueltig"; break;
}
}
void Datagram_InfoWochentag(void)
{ // 9.6.16
WOT="--";
switch(Wochentag)
{
case 0x00: WOT="Mo"; break;
case 0x01: WOT="Di"; break;
case 0x02: WOT="Mi"; break;
case 0x03: WOT="Do"; break;
case 0x04: WOT="Fr"; break;
case 0x05: WOT="Sa"; break;
case 0x06: WOT="So"; break;
}
}
void Datagram_InfoTemp(word temp)
{ // 9.6.6
#define DIVIDER 16
#define OFFSET 0.0
int g; g=temp; // due to
16bit value signed
float f; f=g;
f=f/DIVIDER+OFFSET;
Str_Printf(parameterInfo," (%03.1f`C)",f);
Str_Printf(datavalueInfo,"%03.1f°C
\r\n",f);
// note: char '`'
instead of '°' due to valid ascii range 0..128
}
void Datagram_TestATemp(void)
{ // 9.6.7
#define DIVIDER 16
#define OFFSET 0.0
/*
Serial_WriteHex(0,ATemp);
Serial_WriteHex(0,ATempMin);
Serial_WriteHex(0,ATempMax);
*/
float f; f=ATemp; f=f/DIVIDER+OFFSET;
if(ATemp<ATempMin)
{
EEPROM_SetAussentempMin(f);
ATempMin=ATemp;
}
if(ATemp>ATempMax)
{
EEPROM_SetAussentempMax(f);
ATempMax=ATemp;
}
}
void Datagram_TestKTemp(void)
{ // 9.6.7
#define DIVIDER 16
#define OFFSET 0.0
/*
Serial_WriteHex(0,KTemp);
Serial_WriteHex(0,KTempMin);
Serial_WriteHex(0,KTempMax);
*/
float f; f=KTemp; f=f/DIVIDER+OFFSET;
if(KTemp<KTempMin)
{
EEPROM_SetKesseltempMin(f);
KTempMin=KTemp;
}
if(KTemp>KTempMax)
{
EEPROM_SetKesseltempMax(f);
KTempMax=KTemp;
}
}
void Datagram_TestWTemp(void)
{ // 9.6.21
#define DIVIDER 16
#define OFFSET 0.0
/*
Serial_WriteHex(0,WTemp);
Serial_WriteHex(0,WTempMin);
Serial_WriteHex(0,WTempMax);
*/
float f; f=WTemp; f=f/DIVIDER+OFFSET;
if(WTemp<WTempMin)
{
EEPROM_SetWassertempMin(f);
WTempMin=WTemp;
}
if(WTemp>WTempMax)
{
EEPROM_SetWassertempMax(f);
WTempMax=WTemp;
}
}
void Datagram_TestBetriebsstunden(void)
{ // 9.6.21
#define DIVIDER 60
//hex value in seconds -> set to minutes
#define OFFSET 0.0
Brenner = Status & 0x000F; // !=0 wenn aktiv
if(!Brenner && BrennerLast) // Wechsel auf Brenner
aus
{
float f; f=BrennerDauer; f=f/DIVIDER+OFFSET;
float b;
b = EEPROM_GetBetriebsstunden();
b = b + f;
EEPROM_SetBetriebsstunden(b);
BrennerDauer=0;
}
if(Brenner && !BrennerLast) // Wechsel auf Brenner
an
{
BrennerDauer=0;
}
if (Brenner && BrennerLast) // Brenner noch aktiv
{
BrennerDauer = BrennerDauer + 0x000A;
}
BrennerLast = Brenner;
}
void Datagram_SMSdata(void)
{ // 9.12.27
#define SMSMAXLENGTH
160
SMSdata="Status
Heizung:\r\n";
Str_Copy(SMSdata,"Aussentemperatur:
",STR_APPEND);
Datagram_InfoTemp(ATemp);
Str_Copy(SMSdata,datavalueInfo,STR_APPEND);
Str_Copy(SMSdata,"Wassertemperatur:
",STR_APPEND);
Datagram_InfoTemp(WTemp);
Str_Copy(SMSdata,datavalueInfo,STR_APPEND);
Str_Copy(SMSdata,"Kesseltemperatur:
",STR_APPEND);
Datagram_InfoTemp(KTemp);
Str_Copy(SMSdata,datavalueInfo,STR_APPEND);
word l; l=Str_Len(SMSdata);
if(l>SMSMAXLENGTH)
{
Serial_WriteText(PC,"Maximum
number of SMS characters exceeded");
}else
{
Serial_WriteText(PC,SMSdata);
}
}
/*
File: Ports.cc
Creation: 2009-05-03
Version: 9.6.6
Author: Michael Gries
(c)2009
*/
/*
Version history:
9.5.3 LED feature added
9.5.23 Mode feature
added
9.6.6 pre-processor
define statements added:
concatenated: e.g. MODE
-> PD5 -> 29(MEGA128)
*/
#define MODE PD5 // Mode (0=19k2 oder
1=115k2)
#define LED PG3 // LED
(Datagram Empfang)
#ifdef MEGA128
#define PD5 29 // Mode (0=19k2 oder 1=115k2)
#define PG3 51 // LED
(Datagram Empfang)
#endif
void Ports_InitVRC
(void)
{
Port_DataDirBit(MODE,PORT_IN); // Mode
Port_WriteBit (MODE,1); // Mode
(Pull-up aktivieren)
Port_DataDirBit(LED,PORT_OUT); // LED
}
byte Ports_GetMode(void)
{
return Port_ReadBit(MODE); //
Betriebsart lesen
}
void Ports_SetLED(void)
{
Port_WriteBit(LED,PORT_ON); // LED an
(active low)
}
void Ports_ResetLED(void)
{
Port_WriteBit(LED,PORT_OFF); // LED aus
(active high)
}
/*
File: Clock.cc
Creation: 2009-05-24
Version: 9.5.24
Author: Michael Gries (c)2009
*/
// Interpreter Funktionen ab IDE 2.00 (14.05.2009):
// Clock_GetVal();
// Clock_SetDate();
// Clock_SetTime();
char sTimestamp[30]; // Format:
"YYYY-MM-DD hh.mm.ss "
void Clock_InitVRC(void)
{ // 9.5.24
Clock_SetDate(24,05,09);
Clock_SetTime(21,34,55,0);
}
void Clock_UpdateTimestamp(void)
{
byte Y; byte M; byte D;
byte h; byte m; byte s;
Y=Clock_GetVal(CLOCK_YEAR);
M=Clock_GetVal(CLOCK_MON);
D=Clock_GetVal(CLOCK_DAY);
h=Clock_GetVal(CLOCK_HOUR);
m=Clock_GetVal(CLOCK_MIN);
s=Clock_GetVal(CLOCK_SEC);
sTimestamp="no
clock";
Str_Printf(sTimestamp,"20%02d-%02d-%02d
%02d:%02d:%02d ",Y,M,D,h,m,s);
}
void Clock_PrintTimestamp(void)
{
Clock_UpdateTimestamp(); // into
global variable sTimestamp[]
Serial_WriteText(0,sTimestamp);
}
void Clock_SetDCF77(void)
{
if(DCFstatus==3)
{
Clock_SetDate(Tag,Monat,Jahr);
Clock_SetTime(Std,Min,Sek,0);
}
}
/*
File: EEPROM.cc
Creation: 2009-04-19
Version: 9.6.14
Author: Michael Gries (c)2009
*/
/*
Version history:
9.4.19 Betriebstunden added
9.5.22 Aussen-/Kesseltemperatur added
9.6.14 Warmwassertemperatur added
*/
// EEPROM: Datenspeicherung im internen EEPROM
// erforderliche
Library: IntFunc_Lib.cc
// Globale Parameter
// Datenaufzeichnung alle 10 Sekunden
// *6[==min]*60[==h]*24[==d] = 8640 Datensätze
pro Tag -> Speichergröße: word
#define adrBetriebsstunden 0x1000 // Datentyp
float
#define adrAussentempMin 0x1010 // Datentyp
float
#define adrAussentempMax 0x1020 // Datentyp
float
#define adrWassertempMin 0x1030 // Datentyp
float
#define adrWassertempMax 0x1040 // Datentyp
float
#define adrKesseltempMin 0x1050 // Datentyp
float
#define adrKesseltempMax 0x1060 // Datentyp
float
word Datensatz;
float fBetriebsstunden; // max 65535[h] = 2730[D] = 91[M] = 7[Y]
float fAussentempMin; // -40.0 ...
+80.0 °C
float fAussentempMax; // -40.0 ... +80.0 °C
float fWassertempMin; // +10.0 ... +70.0 °C
float fWassertempMax; // +10.0 ... +70.0 °C
float fKesseltempMin; // +32.0 ... +95.0 °C
float fKesseltempMax; // +32.0 ... +95.0 °C
void EEPROM_Init(void)
{
//adrBetriebsstunden=0x1000;
float fData;
char sData[80];
fData = EEPROM_GetBetriebsstunden();
fData = fData/10;
Str_WriteFloat(fData,1,sData,0);
char sUnit[8]; sUnit = "
[h]";
Str_Copy(sData,sUnit,STR_APPEND);
Debug_Println(adrBetriebsstunden,sData);
}
void EEPROM_Reset(void)
{
EEPROM_SetBetriebsstunden(0.0);
EEPROM_SetAussentempMin(0.0);
EEPROM_SetAussentempMax(0.5);
EEPROM_SetWassertempMin(0.0);
EEPROM_SetWassertempMax(0.5);
EEPROM_SetKesseltempMin(0.0);
EEPROM_SetKesseltempMax(0.5);
}
void EEPROM_SetBetriebsstunden(float value)
{
EEPROM_WriteFloat(adrBetriebsstunden,value);
}
float EEPROM_GetBetriebsstunden(void)
{
fBetriebsstunden=EEPROM_ReadFloat(adrBetriebsstunden);
return fBetriebsstunden;
}
void EEPROM_PrintBetriebsstunden(void)
{
#define DIVIDER 60 // in minutes -> set in
hours
#define OFFSET 0.0
float fData; fData = EEPROM_GetBetriebsstunden();
fData = fData/DIVIDER+OFFSET;
char sData[80]; sData="Betriebsstunden:
";
Str_WriteFloat(fData,3,sData,STR_APPEND);
char sUnit[8]; sUnit = "
[h]";
Str_Copy(sData,sUnit,STR_APPEND);
//println(adrBetriebsstunden,sData);
Debug_Send(adrBetriebsstunden,sData);
}
void EEPROM_SetAussentempMin(float value)
{
EEPROM_WriteFloat(adrAussentempMin,value);
}
void EEPROM_SetAussentempMax(float value)
{
EEPROM_WriteFloat(adrAussentempMax,value);
}
float EEPROM_GetAussentempMin(void)
{
fAussentempMin=EEPROM_ReadFloat(adrAussentempMin);
return fAussentempMin;
}
float EEPROM_GetAussentempMax(void)
{
fAussentempMax=EEPROM_ReadFloat(adrAussentempMax);
return fAussentempMax;
}
void EEPROM_PrintAussentempMin(void)
{
float fData; fData = EEPROM_GetAussentempMin();
char sData[30]; sData="AussentempMin:
";
Str_WriteFloat(fData,1,sData,STR_APPEND);
char sUnit[8]; sUnit = "
[`C]";
Str_Copy(sData,sUnit,STR_APPEND);
//println(adrAussentempMin,sData);
Debug_Send(adrAussentempMin,sData);
}
void EEPROM_PrintAussentempMax(void)
{
float fData; fData = EEPROM_GetAussentempMax();
char sData[30]; sData="AussentempMax:
";
Str_WriteFloat(fData,1,sData,STR_APPEND);
char sUnit[8]; sUnit = "
[`C]";
Str_Copy(sData,sUnit,STR_APPEND);
//println(adrAussentempMax,sData);
Debug_Send(adrAussentempMax,sData);
}
void EEPROM_SetWassertempMin(float value)
{
EEPROM_WriteFloat(adrWassertempMin,value);
}
void EEPROM_SetWassertempMax(float value)
{
EEPROM_WriteFloat(adrWassertempMax,value);
}
float EEPROM_GetWassertempMin(void)
{
fWassertempMin=EEPROM_ReadFloat(adrWassertempMin);
return fWassertempMin;
}
float EEPROM_GetWassertempMax(void)
{
fWassertempMax=EEPROM_ReadFloat(adrWassertempMax);
return fWassertempMax;
}
void EEPROM_PrintWassertempMin(void)
{
float fData; fData = EEPROM_GetWassertempMin();
char sData[20]; sData="WassertempMin:
";
Str_WriteFloat(fData,1,sData,STR_APPEND);
char sUnit[8]; sUnit = "
[`C]";
Str_Copy(sData,sUnit,STR_APPEND);
//println(adrWassertempMin,sData);
Debug_Send(adrWassertempMin,sData);
}
void EEPROM_PrintWassertempMax(void)
{
float fData; fData = EEPROM_GetWassertempMax();
char sData[20]; sData="WassertempMax:
";
Str_WriteFloat(fData,1,sData,STR_APPEND);
char sUnit[8]; sUnit = "
[`C]";
Str_Copy(sData,sUnit,STR_APPEND);
//println(adrWassertempMax,sData);
Debug_Send(adrWassertempMax,sData);
}
void EEPROM_SetKesseltempMin(float value)
{
EEPROM_WriteFloat(adrKesseltempMin,value);
}
void EEPROM_SetKesseltempMax(float value)
{
EEPROM_WriteFloat(adrKesseltempMax,value);
}
float EEPROM_GetKesseltempMin(void)
{
fKesseltempMin=EEPROM_ReadFloat(adrKesseltempMin);
return fKesseltempMin;
}
float EEPROM_GetKesseltempMax(void)
{
fKesseltempMax=EEPROM_ReadFloat(adrKesseltempMax);
return fKesseltempMax;
}
void EEPROM_PrintKesseltempMin(void)
{
float fData; fData = EEPROM_GetKesseltempMin();
char sData[20]; sData="KesseltempMin:
";
Str_WriteFloat(fData,1,sData,STR_APPEND);
char sUnit[8]; sUnit = "
[`C]";
Str_Copy(sData,sUnit,STR_APPEND);
//println(adrKesseltempMin,sData);
Debug_Send(adrKesseltempMin,sData);
}
void EEPROM_PrintKesseltempMax(void)
{
float fData; fData = EEPROM_GetKesseltempMax();
char sData[20]; sData="KesseltempMax:
";
Str_WriteFloat(fData,1,sData,STR_APPEND);
char sUnit[8]; sUnit = "
[`C]";
Str_Copy(sData,sUnit,STR_APPEND);
//println(adrKesseltempMax,sData);
Debug_Send(adrKesseltempMax,sData);
}
void EEPROM_WriteTimestamp(unsigned int
adr)
{
EEPROM_Write(adr+4+1,Jahr);
EEPROM_Write(adr+4+2,Monat);
EEPROM_Write(adr+4+3,Tag);
EEPROM_Write(adr+4+4,Std);
EEPROM_Write(adr+4+5,Min);
EEPROM_Write(adr+4+6,Sek);
}
/*
File: Debug.cc
Creation: 2009-04-19
Version: 9.12.26
Author: Michael Gries (c)2009
*/
/*
Version history:
2009-04-19 Erstellung
2009-05-21 Debug_help() hinzu
2009-12-26 Debug_info() hinzu
*/
#ifdef MEGA128
#pragma Warning "Counter Funktionen
nicht bei Timer0 und Mega128"
#endif
//#ifdef __DEBUG__
#pragma Message
__DATE__
#pragma Message
__TIME__
int DebugMode;
int TraceMode;
void Debug_ModeActivate(void)
{
DebugMode=1;
message="\r\nDebug
mode activated ! - for deactivation press 'd'\r\n";
Serial_WriteText(0,message);
}
void Debug_ModeDeactivate(void)
{
message="\r\nDebug
mode deactivated ! - for activation press 'D'\r\n";
Serial_WriteText(0,message);
DebugMode=0;
}
void Debug_TraceModeActivate(void)
{
TraceMode=1;
message="\r\nTrace
mode activated ! - for deactivation press 'T'\r\n";
Serial_WriteText(0,message);
}
void Debug_TraceModeDeactivate(void)
{
message="\r\nTrace
mode deactivated ! - for activation press 't'\r\n";
Serial_WriteText(0,message);
TraceMode=0;
}
void Debug(char sLine[], char sFunction[], char sMessage[])
{
char txt[81];
//Str_Fill(txt,' ',80);
Str_Copy(txt,sLine,0);
AbsDelay(1000);
Msg_WriteText(txt); // Zeilennummer ausgeben
Msg_WriteChar('-');
//Str_Copy(txt,sFunction,STR_APPEND);
Str_Copy(txt,sFunction,0);
Msg_WriteText(txt); // Funktionsnamenausgeben
Msg_WriteChar(':'); Msg_WriteChar(' ');
//Str_Copy(txt,sMessage,12);
Str_Copy(txt,sMessage,0);
Msg_WriteText(txt); // Nachricht ausgeben
Msg_WriteChar(13); // LF
AbsDelay(1000);
}
void Debug_Print(word adr, byte data)
{
Msg_WriteHex(adr); // Ausgabe der Adresse
Msg_WriteChar(':'); // Ausgabe: :
Msg_WriteHex(data); // Ausgabe des Adressinhaltes
Msg_WriteChar(0x20); // Ausgabe: Leerzeichen
}
void Debug_Println(word adr, char data[])
{
char mem[15]; mem="EEPROM-0x";
Msg_WriteText(mem); // Ausgabe des Adressinhaltes
Msg_WriteHex(adr); // Ausgabe der Adresse
Msg_WriteChar(':'); // Ausgabe: :
Msg_WriteChar(' '); // CR
Msg_WriteText(data); // Ausgabe des Adressinhaltes
Msg_WriteChar(0x20); // Ausgabe: Leerzeichen
Msg_WriteChar('\r'); // CR
Msg_WriteChar('\n'); // LF
}
void Debug_Send(word adr, char data[])
{
Serial_Write(0,CR); // CR
Serial_Write(0,LF); // LF
char mem[15]; mem="EEPROM-0x";
Serial_WriteText(0,mem); // Ausgabe des Adressinhaltes
Serial_WriteHex(0,adr); // Ausgabe der Adresse
Serial_Write(0,':'); // Ausgabe: :
Serial_Write(0,' '); // CR
Serial_WriteText(0,data); // Ausgabe des Adressinhaltes
Serial_Write(0,0x20); // Ausgabe: Leerzeichen
//Serial_Write(0,'\r');
// CR
}
void Debug_Help(void)
{
Serial_WriteNewLine();
message="Helpmenue
\r\n";
Serial_WriteText(0,message);
AbsDelay(100); // wichtig: Verzögerung TODO: tuning
message="i - program info \r\n";
Serial_WriteText(0,message);
AbsDelay(100); // wichtig: Verzögerung TODO: tuning
message="D - debug mode
activation \r\n";
Serial_WriteText(0,message);
AbsDelay(100); // wichtig: Verzögerung TODO: tuning
message="d -
debug mode deactivation (default)\r\n";
Serial_WriteText(0,message);
AbsDelay(100); // wichtig: Verzögerung TODO: tuning
message="T -
trace mode deactivation \r\n";
Serial_WriteText(0,message);
AbsDelay(100); // wichtig: Verzögerung TODO: tuning
message="t - trace mode
activation (default) \r\n";
Serial_WriteText(0,message);
AbsDelay(100); // wichtig: Verzögerung TODO: tuning
message="a - Aussentemperatur min \r\n";
Serial_WriteText(0,message);
message="A - Aussentemperatur max \r\n";
Serial_WriteText(0,message);
AbsDelay(100); // wichtig: Verzögerung TODO: tuning
message="k - Kesseltemperatur min \r\n";
Serial_WriteText(0,message);
message="K - Kesseltemperatur max \r\n";
Serial_WriteText(0,message);
AbsDelay(100); // wichtig: Verzögerung TODO: tuning
message="w - Wassertemperatur min \r\n";
Serial_WriteText(0,message);
message="W - Wassertemperatur max \r\n";
Serial_WriteText(0,message);
AbsDelay(100); // wichtig: Verzögerung TODO: tuning
message="b - Betriebsstunden \r\n";
Serial_WriteText(0,message);
Serial_WriteNewLine();
}
void Debug_Info(void)
{ //9.12.26
Serial_WriteNewLine();
Serial_WriteText(PC,PROJECT); Serial_WriteText(PC,"
version: ");
Serial_WriteText(PC,VERSION); Serial_WriteText(PC,CRLF);
AbsDelay(100); // wichtig:
Verzögerung TODO: tuning
Serial_WriteText(PC,"Compilation:
"); Serial_WriteText(PC,__DATE__);
Serial_WriteText(PC,"_");
Serial_WriteText(PC,__TIME__); Serial_WriteText(PC,CRLF);
AbsDelay(100); // wichtig:
Verzögerung TODO: tuning
Serial_WriteText(PC,"Directory:
");
Serial_WriteText(PC,filename); Serial_WriteText(PC,CRLF);
AbsDelay(100); // wichtig:
Verzögerung TODO: tuning
Serial_WriteText(PC,"Library:
");
Serial_WriteText(PC,LIBRARY); Serial_WriteText(PC,CRLF);
AbsDelay(100); // wichtig: Verzögerung TODO: tuning
byte bFreq;
bFreq=DirectAccess_Frequency();
//MEGA128 14,7456MHz
#define OSC 14.7456
char cValue[20];
Str_Printf(cValue,"%2.4f
MHz\r\n",OSC);
Serial_WriteText(PC,"Frequency:
"); Serial_WriteText(PC,cValue);
Serial_WriteNewLine();
AbsDelay(100); // wichtig: Verzögerung TODO: tuning
Serial_WriteText(PC,COPYRIGHT); Serial_WriteText(PC,",
");
Serial_WriteText(PC,AUTHOR); Serial_WriteText(PC,CRLF);
}
/*
File: DirectAccess.cc
Creation: 2009-12-26
Version: 9.12.26
Author: Michael Gries (c)2009
*/
/*
Interpreter Funktionen ab IDE 2.0:
byte DirAcc_Read(byte
register);
void DirAcc_Write(byte
register, byte val);
for register details see
section
'Register Summary' in
ATmega128_datasheet.pdf
*/
#define OSCCAL 0x6F
byte DirectAccess_Frequency(void)
{ // 9.12.26
byte bReg;
bReg = DirAcc_Read(OSCCAL);
return(bReg);
}
/**************************************************************************
String Library
***************************************************************************/
//-------------------------------------------------------------------------
void Str_Fill(char dest[],char c,word len)
{
word i;
for(i=0;i<len;i++) dest[i]=c;
}
//-------------------------------------------------------------------------
int Str_SubStr(char source[],char search[])
{
int i,j,len;
char s,c,v;
s=search[0];
i=0;
do
{
c=source[i];
if(c==s)
{
j=1;
do
{
v=search[j];
} while(v && v==source[i+j++]);
if(!v) return(i);
}
i++;
} while(c);
return(-1);
}
//-------------------------------------------------------------------------
byte Str_Isalpha(char c)
{
return((c>='a' && c<='z') || (c>='A' && c<='Z'));
}
//-------------------------------------------------------------------------
byte Str_Isalnum(char c)
{
return((c>='0' && c<='9') || Str_Isalpha(c));
}
/*
File: ascii.ch
Creation: 2009-05-22
Version: 9.5.23
Author: Michael Gries (c)2009
*/
// C-Control Pro (Mega128)
C-Compact definition file
#define NUL 0x00
#define TAB 0x09
#define CR '\r'
#define LF '\n'
#define CAN 0x18
#define ESC 0x1B
#define SP 0x20
#define DEL 0x7F
#define CRLF "\r\n"
///
--- 2009-05-24
21:37:52 --------------------------------------------------------
06 02 00 03 EE
98 84 00 02 20 06 02 00 03 F2 84 9A 00 00 00
00 00 00 00 00
00 00 00 00 00 92 AA 01 10 00 03 99 00 03 B2
00 0D 0C 02 00
03 F1 03 22 00 01 00 00 67 83 00 1F 06 00 00
00 08 68 84 00
01 23
Anzahl
Datagram-Bytes: 67
VRC-Status :
0000
Aussentemp.: 0110
(17.0°C)
Wassertemp.: 0399
(57.6°C)
Kesseltemp.: 03B2
(59.1°C)
Heiz-Kurve : 0322
(50.1°C)
Betriebsart: 0001 =
Winterbetrieb
--- 2009-05-24
21:38:03 --------------------------------------------------------
06 02 00 03 EE
98 84 00 02 20 06 02 00 03 F2 84 9A 00 00 00
00 00 00 00 00
00 00 00 00 00 92 AA 01 10 00 03 99 00 03 B2
00 0D 0C 02 00
03 F1 03 22 00 01 00 00 67 83 00 1F 06 00 00
00 08 68 84 00
01 23
Anzahl
Datagram-Bytes: 67
VRC-Status :
0000
Aussentemp.: 0110
(17.0°C)
Wassertemp.: 0399
(57.6°C)
Kesseltemp.: 03B2
(59.1°C)
Heiz-Kurve : 0322
(50.1°C)
Betriebsart: 0001 =
Winterbetrieb
--- 2009-06-15
23:46:19 --------------------------------------------------------
06 02 00 03 EE
98 84 00 02 20 06 02 00 03 F2 84
9A 00 00 00 00
03 1D 2E 17 00 0F 06 09 00 92
AA 00 C8 00 03
B6 00 03 9D 00 06
0C 02 00 03 F1
00 A0 01 00 00 00 E3 83 00 1F
06 00 00 00 08
68 84 00 00 22
Anzahl
Datagram-Bytes: 67
VRC-Status : 0000 =
Bereitschaft
DCF-Status : 0003 =
Signal gültig
DCF77 Zeit :
2009-06-15 23:46:29
Aussentemp.: 00C8
(12.5°C)
Wassertemp.: 03B6
(59.4°C)
Kesseltemp.: 039D
(57.8°C)
Heiz-Kurve : 00A0
(10.0°C)
X-Parameter: 00E3
(10.0°C)
Betriebsart: 0000 =
Sommerbetrieb
--- 2009-06-15
23:46:30 --------------------------------------------------------
06 02 00 03 EE
98 84 00 02 20 06 02 00 03 F2 84
9A 00 00 00 00
03 28 2E 17 00 0F 06 09 00 92
AA 00 C8 00 03
B6 00 03 9D 00 FA
0C 02 00 03 F1 00
A0 01 00 00 00 E3 83 00 1F
06 00 00 00 08
68 84 00 00 22
Anzahl
Datagram-Bytes: 67
VRC-Status : 0000 =
Bereitschaft
DCF-Status : 0003 =
Signal gültig
DCF77 Zeit :
2009-06-15 23:46:40
Aussentemp.: 00C8
(12.5°C)
Wassertemp.: 03B6
(59.4°C)
Kesseltemp.: 039D
(57.8°C)
Heiz-Kurve : 00A0
(10.0°C)
X-Parameter: 00E3
(10.0°C)
Betriebsart: 0000 =
Sommerbetrieb
--- 2009-06-15
23:46:41 --------------------------------------------------------
---
2009-12-15 21:51:46 ---------------------------------------- VRC 9.12.13 ---
VRC-Konverter:
Helpmenue
D -
debug mode activation
d - debug mode
deactivation
a -
Aussentemperatur min/max
k -
Kesseltemperatur min/max
w - Wassertemperatur
min/max
b - Betriebsstunden
a -
Aussentemperatur
--- 2009-12-15
21:51:49 ---------------------------------------- VRC 9.12.13 ---
--- 2009-12-15
21:53:12 ---------------------------------------- VRC 9.12.13 ---
EEPROM-0x1050:
KesseltempMin: 69.2 [¦C]
EEPROM-0x1060:
KesseltempMax: 81.9 [¦C]
--- 2009-12-15
21:53:13 ---------------------------------------- VRC 9.12.13 ---
EEPROM-0x1030:
WassertempMin: 57.6 [¦C]
EEPROM-0x1040:
WassertempMax: 57.6 [¦C]
--- 2009-12-15
21:53:15 ---------------------------------------- VRC 9.12.13 ---
EEPROM-0x1000:
Betriebsstunden: 2335.4 [h]
--- 2009-12-15
21:53:19 ---------------------------------------- VRC 9.12.13 ---
06 02
00 03 EE 98 84 00 02 20 06 02 00 03 F2 84
9A 00
00 00 00 03 15 35 15 01 0F 0C 09 00 92
AA FF
F2 00 03 99 00 04 48 00 8E
0C 02 00 03 F1
04 B8 00 01 00 00 F6 83 00 1F
06 00 00 00 08
68 84 00 01 23
Anzahl
Datagram-Bytes: 67
VRC-Status : 0000 =
Bereitschaft
Brenndauer : 0000 =
Brenner aus
DCF-Status : 0003 =
Signal gueltig
DCF77 Zeit :
2009-12-15 Di 21:53:21
Aussentep.: FFF2
(-0.9`C)
Wassertemp.: 0399
(57.6`C)
Kesseltemp.: 0448
(68.5`C)
Heiz-Kurve : 04B8
(75.5`C)
X-Parameter: 00F6
Betriebsart: 0001 =
Winterbetrieb
Die vom TC65 Terminal empfangenen und im TC65-Verzeichnis
‚Storage’ gespeicherten Rohdaten werden in ein Javascript-Array Format
umgeschrieben und an einen html-Server übertragen. Diese Javascript-Datei wird
über eine html-include Funktion in das entprechende Javascript basierende
html-Diagrammseite mit eingebunden.
Vorgesehene Diagramm-Darstellungen:
·
Heizöl-Verbrauch [l] über Zeit [a]
·
Betriebsparameter [°C] über Zeit [d]
Entwurfsbeispiele siehe Abbildungen x und y
Als preisgünstigen Einstieg wird das folgende Projectboard
für die Prototypen-Erstellung angeboten. Conrad-Artikelnummer: 197313
-xx (Preis 03/2009: 14,95€)
Als Vorbereitung für die Entwicklung des VRC-Konverters
wurde das Projectboard um folgende Funktionen erweitert:
- Zweite RS232-Schnittstelle
- LED Signalisierung
- Betriebsartenschalter
Der Schaltplan, sowie der Bestückungsplan des Kaufteils sind
in den folgenden beiden Abbildungen dargestellt.
Der VRC-Konverter kann über die zweite RS-232 Schnittstelle
mit neuer Software geladen werden. Damit dies auch von „entfernter“ Stelle (bis
ca. 10m) mittels Laptop möglich ist wurde ein spezielles Bootcable entwickelt,
dass direkt zwischen Verbindungskabel und Laptop zwischengeschaltet wird. Es
besitzt in den Stecker integrierte Schalter zum Rücksetzen (Reset) und Booten
(Boot) des C-Control Mega128 Bausteins.
Hinweis:
Auf eine erweiterte Bootlogik wie im Projectboard
ersichtlich wurde aufgrund der leichten Integrierbarkeit in den SUB-D Stecker
verzichtet. Zum Booten müssen daher die beiden Knöpfe derart gedrückt werden,
dass das Bootsignal etwas länger ansteht als das Reset-Signal. Die Praxis hat
gezeigt, dass dies ohne weiteres leicht zu bewerkstelligen ist.
Foto:
Die Voltcraft ÖL-Verbrauchsanzeige (Bestell-Nr. 12 09 90 über
