das mit dem senden des programms ist so ne sache, wir haben über 10 module mit etlichen funktionen. Einige module dürfen wir aus lizenzrechtlichen gründen nicht veröffentlichen. Aber wir versuchen die wichtigsten teile zu schicken.
Das Programm realisiert (oder soll es zumindest) ein Zugangskontrollsystem für mehrere Türen. Dazu wird eine usertabelle mit pin rechten usw verwaltet. Die identität wird über einen Fingerprint-sensor bestätigt.
Das Problem tritt auf wenn das system ohne äu�ere einwirkung lange zeit (einige stunden) verbleibt. Dabei läuft der watchdog thred, der keyb thred und im main-teil wird periodisch watchdog.safetime aufgerufen.
Wenn du uns helfen könntest, müssten wir uns nicht aus verzweiflung umbringen !!?
gruss ..
das modul fiu_var:
--------------------------------------------------------------
//variablen für alle module
//
//matthias siem� rico körner
//28.05.2000
const ok=1; //rückgabe alles ok
const err=0; //rückgabe fehler
const timeout=2;//rückgabe zeitüberschreitung
const esc=3; //rückgabe * für esc gedrückt
const waittime=20; //wartezeit auf tastendruck in sec
//für das menü und die menüfunktionen
byte usertab[1000*8]; //cache für die UserTabelle (chip 2)
//zur beschleunigung der zugriffe
byte superpin[12]; //nimmt superpin für administratorzugang
//ohne FP auf
//------------------------------------------------------------
// Türtabelle
//
//existenzbyte
//jedes bit steht für eine Tür 1=existiert 0=existiert nicht
const tueren=0b11111001;
//bit 2 und 3 sind gesperrt (von swcom benutzt)!!!
const tuer1="R 317";
//const tuer2="-2-"; für swcom benutzt
//const tuer3="-3-"; für swcom benutzt
const tuer4="-4-";
const tuer5="-5-";
const tuer6="-6-";
const tuer7="-7-";
const tuer8="-8-";
byte perm_open; //sichert welche tür permanennt offen ist
//wird bei reset auf 0 gesetzt
--------------------------------------------------------------
das main-modul:
--------------------------------------------------------------
thread main
{
//bei start keine tür permanent offen
fiu_var.perm_open=0;
//ports auf 0 setzten
ports.setb(1,0);
//für swcom benötigte ports deaktivieren
ports.deact(9);
ports.deact(10);
//anzeige initialisieren
lcdext.init();
//zeit auf zuletzt gesicherten wert setzen
watchdog.recalldata();
keyb.keywert=255;
run keyb.keyb2; //tastaturüberwachung starten
run watchdog.watchdog; //wachhund starten
//testen ob fiu ok
funktion.testfiu();
//-------------------------------------------
// Superpin festlegen
//
fiu_var.superpin[0]=1;
fiu_var.superpin[1]=2;
fiu_var.superpin[2]=3;
fiu_var.superpin[3]=4;
fiu_var.superpin[4]=5;
fiu_var.superpin[5]=6;
fiu_var.superpin[6]=7;
fiu_var.superpin[7]=8;
fiu_var.superpin[8]=9;
fiu_var.superpin[9]=0;
fiu_var.superpin[10]=1;
fiu_var.superpin[11]=2;
string z;
int lastsec;
lcdext.clear();
lcdext.line2();
lcdext.print("Please enter PIN");
while 1
{
if lastsec!=system.second()
{
z="";
str.putintf(z,system.hour(),2);
z=z+':';
str.putintf(z,system.minute(),2);
z=z+':';
str.putintf(z,system.second(),2);
z=z+' '; z=z+' '; z=z+' ';
str.putintf(z,system.day(),2);
z=z+'.';
str.putintf(z,system.month(),2);
lcdext.home();
lcdext.print(z);
lastsec=system.second();
}
watchdog.safetime(); //ich lebe noch
if keyb.keywert != 255
{
if keyb.keywert<10 zugang.zugang();
keyb.keywert=255;
lcdext.clear();
lcdext.line2();
lcdext.print("Please enter PIN");
}
}
quit 1;
}
das modul keyb:
-------------------------------------------------------------------
byte keychar;
byte keywert;
//-----------
thread keyb2
//-----------
{ int x;
while 1 { if ports.adc(7)<900 break; else sleep 125; }
sleep 80;
x=ports.adc(7);
keychar=0;
keywert=255;
if x<875 if x>860 { plm.beep(1500); sleep 25; plm.beep(-1); keychar=0x33; keywert=3;}//3
if x<810 if x>795 { plm.beep(1500); sleep 25; plm.beep(-1); keychar=0x36; keywert=6;}//6
if x<740 if x>725 { plm.beep(1500); sleep 25; plm.beep(-1); keychar=0x39; keywert=9;}//9
if x<675 if x>660 { plm.beep(1500); sleep 25; plm.beep(-1); keychar=0x23; keywert=200;}//#
if x<605 if x>590 { plm.beep(1500); sleep 25; plm.beep(-1); keychar=0x32; keywert=2;}//2
if x<535 if x>520 { plm.beep(1500); sleep 25; plm.beep(-1); keychar=0x35; keywert=5;}//5
if x<465 if x>450 { plm.beep(1500); sleep 25; plm.beep(-1); keychar=0x38; keywert=8;}//8
if x<395 if x>380 { plm.beep(1500); sleep 25; plm.beep(-1); keychar=0x30; keywert=0;}//0
if x<320 if x>305 { plm.beep(1500); sleep 25; plm.beep(-1); keychar=0x31; keywert=1;}//1
if x<245 if x>230 { plm.beep(1500); sleep 25; plm.beep(-1); keychar=0x34; keywert=4;}//4
if x<170 if x>155 { plm.beep(1500); sleep 25; plm.beep(-1); keychar=0x37; keywert=7;}//7
if x<90 if x>75 { plm.beep(1500); sleep 25; plm.beep(-1); keychar=0x2A; keywert=100;}//*
sleep 125;
}
das modul watchdog:
-------------------------------------------------------------------
/* watchdog & safetime
* watchdog:
* überwacht das system,
* bei 1 min keine reaktion -> system aufgehängt => reset
*
* safetime:
* periodisch vom haupttask aufgerufen
* sichert in 10 min intervallen die Zeit im EEPROM
* registriert aktivität des haupt tasks
*
* matthias siem� rico körner
* 28.05.2002 */
long livingcount; //zeitpunkt (timer nicht uhr) ab dem
//das programm als aufgehängt betrachtet wird
int min_lastsafe;
int day_lastcheck; //tag der letzten prüfung
byte verriegelung; //watchdog soll safetime nicht unterbrechen!
thread watchdog
{
capture verriegelung;
long l;
l=system.timer();
if ((l & 0xFFFF0000)shr 16) - ((livingcount & 0xFFFF0000) shr 16) >1
or ((l & 0xFFFF0000)shr 16) - ((livingcount & 0xFFFF0000) shr 16) < -0xFFFE
{
quit -1;
}
release;
sleep 250;
}
//überprüft die usertab und entfernt einträge die länger als
//5 monate nicht benutzt wurden
function check()
{
int i,ii;
//zum löschen benötigte rücksetzwerte
byte puffer[8];
puffer[7]=system.month();
puffer[0]=0;
puffer[1]=0;
puffer[2]=0xFF;
puffer[3]=0xFF;
puffer[4]=0xFF;
puffer[5]=0xFF;
puffer[6]=0xFF;
//meldung ausgeben
lcdext.clear();
lcdext.print("AUTO CHECK ...");
lcdext.line2();
//löschen aller alten einträge
i=0;
while i<1000
{
//vergleich
ii=fiu_var.usertab[(i*8)+7];
ii=ii+5; //+anzahl der Monate
if ii>12 ii=ii-12;
if fiu_var.usertab[(i*8)+2]!=0xFF and ii==system.month()
{
fium.FIUClearIndex(i);
//speichern im eeprom
for ii=0 ... 7 { eeprom.writebyte(2,(i*8)+ii,puffer[i]); }
//speichern im ram durch auslesen aus eeprom
for ii=0 ... 7
{
eeprom.readbyte(2,(i*8)+i);
fiu_var.usertab[(i*8)+i]=eeprom.buf;
}
}
i=i+1;
if i==1000 {break;}
}
}
//sichert die aktuelle zeit in 10 min abständen
//registriert lebenszeichen des hauptprozesses
function safetime()
{
capture verriegelung;
//täglich 1 mal check
if day_lastcheck!=system.day()
{
check();
day_lastcheck=system.day();
}
livingcount=system.timer(); //counter speichern
//zeit alle 10 min sichern
if system.minute()-min_lastsafe > 10 or system.minute()-min_lastsafe < 0
{
// --------------------------------
//aktuelles Datum & Zeit sichern
//
eeprom.writebyte(1,0,system.day() & 0x00FF);
eeprom.writebyte(1,1,(system.day() & 0xFF00) shr 8);
eeprom.writebyte(1,2,system.month() & 0x00FF);
eeprom.writebyte(1,3,(system.month() & 0xFF00) shr 8);
eeprom.writebyte(1,4,system.year() & 0x00FF);
eeprom.writebyte(1,5,(system.year() & 0xFF00) shr 8);
eeprom.writebyte(1,6,system.hour() & 0x00FF);
eeprom.writebyte(1,7,(system.hour() & 0xFF00) shr 8);
eeprom.writebyte(1,8,system.minute() & 0x00FF);
eeprom.writebyte(1,9,(system.minute() & 0xFF00) shr 8);
min_lastsafe=system.minute();
}
release;
}
//holt gesicherte zeit und setzt sie im system
//kopiert die user-tablle in fiu_var.usertab
function recalldata()
{
int i[3]; //zwischenspeicher
//meldung ausgeben
lcdext.clear();
lcdext.print("RESTART!!!");
lcdext.line2();
lcdext.print("Please wait ...");
//---------------------------------------------
//User-tab kopieren
//
for i[1]=0 ... ((1000*8)-1)
{
eeprom.readbyte(2,i[1]);
fiu_var.usertab[i[1]]=eeprom.buf;
}
// --------------------------------
//aktuelles Datum & Zeit aus eeprom lesen und im
//System setzen
//
eeprom.readbyte(1,0);
i[0]=eeprom.buf;
eeprom.readbyte(1,1);
i[0]=i[0]+ 0x0100*eeprom.buf;
eeprom.readbyte(1,2);
i[1]=eeprom.buf;
eeprom.readbyte(1,3);
i[1]=i[1]+ 0x0100*eeprom.buf;
eeprom.readbyte(1,4);
i[2]=eeprom.buf;
eeprom.readbyte(1,5);
i[2]=i[2]+ 0x0100*eeprom.buf;
system.setdate(i[2],i[1],i[0]);
day_lastcheck=i[0];
eeprom.readbyte(1,6);
i[0]=eeprom.buf;
eeprom.readbyte(1,7);
i[0]=i[0]+ 0x0100*eeprom.buf;
eeprom.readbyte(1,8);
i[1]=eeprom.buf;
eeprom.readbyte(1,9);
i[1]=i[1]+ 0x0100*eeprom.buf;
system.settime(i[0],i[1],0);
min_lastsafe=i[1];
lcdext.clear();
}
das modul eeprom:
---------------------------------------------------------------
// Modul zum zugriff auf I^2C BUS Speicher
byte buf; //nimmt empfangenes Byte auf
//ein byte aus einem Speicher lesen
//Rückgabe 0=OK oder -1=ERROR
function readbyte(int speicher,int address) returns int
{
int i; //Zähler
byte addr[2]; //nimmt speicheradresse auf
byte spnr; //nimmt adresse des Speicherbausteins auf
//adresse in adr kopieren
//addr[2] enthält high-teil
//addr[3] enthält low-teil
mem.putint(addr,0,address);
//warten auf sendebereitschaft am IIC Bus
for i=0 ... 255
{
if i2c.ready()==-1 break;
if i==254 return -1;
}
//speichernummer in spnr schreiben
if speicher==1 spnr=0b10100000;
if speicher==2 spnr=0b10100010;
if speicher==3 spnr=0b10100100;
if speicher==4 spnr=0b10100110;
//start mit schreibbefehll
//um die adresse dem EEPROM mitzuteilen
for i=0 ... 255
{
if i2c.start(spnr)==-1 break;
if i==254 return -1;
}
i2c.write(addr[0]);
i2c.write(addr[1]);
//stop generieren und lesen anfordern
i2c.stop();
for i=0 ... 255
{
if i2c.start(spnr+1)==-1 break;
if i==254 return -1;
}
buf=i2c.readlast();
i2c.stop();
return 0;
}
//ein byte in einem Speicher schreiben
//Rückgabe 0=OK oder -1=ERROR
function writebyte(int speicher,int address,byte wert) returns int
{
int i; //Zähler
byte addr[2]; //nimmt speicheradresse auf
byte spnr; //nimmt adresse des Speicherbausteins auf
//adresse in adr kopieren
//addr[2] enthält high-teil
//addr[3] enthält low-teil
mem.putint(addr,0,address);
//warten auf sendebereitschaft am IIC Bus
for i=0 ... 255
{
if i2c.ready()==-1 break;
if i==254 return -1;
}
//speichernummer in spnr schreiben
if speicher==1 spnr=0b10100000;
if speicher==2 spnr=0b10100010;
if speicher==3 spnr=0b10100100;
if speicher==4 spnr=0b10100110;
//start mit schreibbefehll
//um die adresse dem EEPROM mitzuteilen
for i=0 ... 255
{
if i2c.start(spnr)==-1 break;
if i==254 return -1;
}
i2c.write(addr[0]);
i2c.write(addr[1]);
i2c.write(wert);
i2c.stop();
return 0;
}
Antwort schreiben
Antworten:
Re: CC2 hängt sich auf (von André H. - 8.07.2002 12:25)