#include <Reg517a.h>

#include <stdio.h>

#include <intrins.h>

 

#include <String.h>

#include <stdlib.h>

 

#include "hardware.h" //Hardware Routinen für die LEDs, die Echtzeituhr und den Türöffner

#include "serial.h"  //Routinen für die serielle Schnittstelle

#include "flash.h" //Routinen für die flashkarte

 

 

 

 

#define MAXDATEN 2000   //gibt an wieviele Datensätze maximal gespeichert werden

#define uchar unsigned char

#define fadr 0xd0   //Adresse der Flashkarte

 

struct time                  // Struct für die Zeit

      {

      uchar seconds;

      uchar minutes;

      uchar hours;

      };

 

sbit sda=P5^0;               //I2C Pin für die Daten-Leitung

sbit scl=P5^1;               //I2C Pin für die Clock-Leitung

 

 

//Arays für die Daten

unsigned long xdata nummern[MAXDATEN];  

unsigned char xdata tag1[MAXDATEN];

unsigned char xdata tag2[MAXDATEN];

unsigned char xdata anfang1[MAXDATEN];

unsigned char xdata anfang2[MAXDATEN];

unsigned char xdata ende1[MAXDATEN];

unsigned char xdata ende2[MAXDATEN];

 

unsigned int letztedaten=MAXDATEN;  //Hilfsvariable für die Datensätze

 

 

//Funktionsprototypen

 

void terminal();

void s_hilfe();

void format();

void s_zeit();

void s_zeitneu();

void s_wochentag();

void s_wochentagneu();

 

void s_laden();

void s_anzeige();

void speichern();

void lesen();

 

 

 

uchar seconds();

void warten(uchar sek);

void erste_taste(uchar ged_taste);

void tur_auf();

 

 

 

 

/********************************************

*     Funktion für die Ein- und Ausgabe über*

*     die serielle Schnittstelle            *

********************************************/

 

void terminal()

      {

      uchar xdata eingabe[20]="                    ";

      uchar xdata stlinie[]=       "******************************\r";

      uchar xdata st_zwei[]=       "*                            *\r";

      uchar xdata prj[]=           "* Projekt Zugangskontrolle   *\r";

      uchar xdata st_ret[]=        " statt Return \"#\" benutzen! \r";

      uchar xdata hilfe[]=   " Befehlsuebersicht mit hilfe# \r";

      uchar xdata wichtig[]= " WICHTIG, IMMER MIT ende# BEENDEN !!!! ";

      s_stringout(stlinie);

      s_stringout(st_zwei);

      s_stringout(prj);

      s_stringout(st_zwei);

      s_stringout(stlinie);

      s_charout('\r');

      s_stringout(st_ret);

      s_charout('\r');

      s_charout('\r');

      s_stringout(wichtig);

      s_stringout(hilfe);

      while(1)

            {

            s_charout('\r');

            s_charout('>');

            s_stringin(eingabe);

            s_charout('\r');

            if (s_stringvergl(eingabe,"ende#")==1) return;

            if (s_stringvergl(eingabe,"laden#")==1) s_laden();

            if (s_stringvergl(eingabe,"daten#")==1) s_anzeige();

            if (s_stringvergl(eingabe,"hilfe#")==1) s_hilfe();

            if (s_stringvergl(eingabe,"format#")==1) format();

            if (s_stringvergl(eingabe,"lesen#")==1) lesen();

            if (s_stringvergl(eingabe,"speichern#")==1) speichern();

            if (s_stringvergl(eingabe,"zeit#")==1) s_zeit();

            if (s_stringvergl(eingabe,"zeitneu#")==1) s_zeitneu();

            if (s_stringvergl(eingabe,"tag#")==1) s_wochentag();

            if (s_stringvergl(eingabe,"tagneu#")==1) s_wochentagneu();

            };

      }

 

 

 

 

/********************************************************

*     Gibt den Hilfe Text aus                           *

********************************************************/

 

void s_hilfe()

      {

      s_stringout("*****************************************************\r");

      s_stringout("*  HILFE FUER DIE BENUTZUNG                         *\r");

      s_stringout("*                                                   *\r");

      s_stringout("* ende#       Datenverwaltung beenden               *\r");

      s_stringout("* laden#      Neue Daten in Speicher laden          *\r");

      s_stringout("* daten#      Aktuelle Daten im Speicher anzeigen   *\r");

      s_stringout("* hilfe#      Dieser Text                           *\r");

      s_stringout("* speichern#  Daten im Speicher auf Flash speichern *\r");

      s_stringout("*             (alte Daten werden ueberschrieben !)  *\r");

      s_stringout("* format#     Flash loeschen                        *\r");

      s_stringout("* lesen#      Daten aus Flash in Speicher lesen     *\r");

      s_stringout("* zeit#       Aktuelle Zeit anzeigen                *\r");

      s_stringout("* zeitneu#    Zeit neu setzen                       *\r");

      s_stringout("* tag#        Aktuellen Wochentag anzeigen          *\r");

      s_stringout("* tagneu#    Wochentag neu setzen                   *\r");

      s_stringout("*****************************************************\r");

      s_charout('\r');

      }

 

void s_wochentag()

      {

      s_stringout(" Aktueller Wochentag: ");

      s_charout(get_wochentag()+0x30);

      s_charout('\r');

      }

 

void s_wochentagneu()

      {

      uchar temp;

      s_stringout(" Bitte neuen Wochentag eingeben:");

      temp=s_charin();

      temp=temp-0x30;

      set_wochentag(temp);

      s_stringout(" Neuer Wochentag: ");

      s_charout(get_wochentag()+0x30);

      s_charout('\r');

      }

 

void s_zeit()

      {

      struct time zeits;

      uchar zeitstring[10];

      get_zeit(&zeits);

      sprintf(zeitstring,"%d:%d:%d",zeits.hours,zeits.minutes,zeits.seconds);

      s_stringout(zeitstring);

      s_charout('\r');

      }

 

void s_zeitneu()

      {

      struct time zeits;

      uchar eingabe[5];

      uchar temp;

      s_stringout("Neue Zeit eingeben");

      s_charout('\r');

      s_stringout("Wieder mit # abschließen");

      s_charout('\r');

      s_stringout("Stunden:");

      s_stringin(eingabe);

      temp=atoi(eingabe);

      zeits.hours=temp;

      s_charout('\r');

      s_stringout("Minuten:");

      s_stringin(eingabe);

      temp=atoi(eingabe);

      zeits.minutes=temp;

      s_charout('\r');

      set_zeit(&zeits);

      }

 

 

void format()

      {

      s_stringout(" Flashkarte wird gelöscht, bitte warten ...");

      s_charout('\r');

      erase_flash(fadr);

      s_stringout(" Flash gelöscht, bitte neue Daten einspielen!");

      s_charout('\r');

      }

 

 

 

 

 

 

 

 

/****************************************************

*     Lädt neue Werte aus einer an die serielle     *

*     Schnittstelle gesendeten Textdatei in den RAM *

****************************************************/

 

void s_laden()

      {

      const uchar senden[]="Bitte neue Zugangsdaten schicken ....\r";

      const uchar erfolg[]="DATEN ERFOLGREICH EMPFANGEN\r";

      int i,j;

      uchar idata temp;

      uchar xdata temp2[10];

      bit abr=0;

      s_stringout(senden);

      for (i=0;i<MAXDATEN;i++)

            {

            for (j=0;j<10;j++)

                  {

                  temp2[j]='X';

                  temp=s_charin();

                  if (temp=='b') break;

                  temp2[j]=temp;

                  if (temp=='a') break;

                  };

            nummern[i]=atol(temp2);

            if (temp=='b') 

                        {

                        letztedaten=i;

                        abr=1;

                        };

            if (abr==1) break;

            for (j=0;j<10;j++)

                  {

                  temp=s_charin();

                  if (temp=='b') break;

                  temp2[j]=temp;

                  if (temp=='a') break;

                  };

            tag1[i]=atol(temp2);

            if (temp=='b') break;

            for (j=0;j<10;j++)

                  {

                  temp=s_charin();

                  if (temp=='b') break;

                  temp2[j]=temp;

                  if (temp=='a') break;

                  };

            tag2[i]=atol(temp2);

            if (temp=='b') break;

            for (j=0;j<10;j++)

                  {

                  temp=s_charin();

                  if (temp=='b') break;

                  temp2[j]=temp;

                  if (temp=='a') break;

                  };

            anfang1[i]=atol(temp2);

            if (temp=='b') break;

            for (j=0;j<10;j++)

                  {

                  temp=s_charin();

                  if (temp=='b') break;

                  temp2[j]=temp;

                  if (temp=='a') break;

                  };

            ende1[i]=atol(temp2);

            if (temp=='b') break;

            for (j=0;j<10;j++)

                  {

                  temp=s_charin();

                  if (temp=='b') break;

                  temp2[j]=temp;

                  if (temp=='a') break;

                  };

            anfang2[i]=atol(temp2);

            if (temp=='b') break;

            for (j=0;j<10;j++)

                  {

                  temp=s_charin();

                  if (temp=='b') break;

                  temp2[j]=temp;

                  if (temp=='a') break;

                  };

            ende2[i]=atol(temp2);

            if (temp=='b') break;

            };

      s_stringout(erfolg);

      }

 

 

/********************************************************

*     Zeigt die aktuellen Werte im Speicher an          *

********************************************************/

 

void s_anzeige()

      {

      int i;

      for (i=0;i<letztedaten;i++)

            {

            s_stringout("\r");

            s_stringout(longtoascii(nummern[i]));

            s_stringout("\r");

            s_stringout(longtoascii(tag1[i]));

            s_stringout("\r");

            s_stringout(longtoascii(tag2[i]));

            s_stringout("\r");

            s_stringout(longtoascii(anfang1[i]));

            s_stringout("\r");

            s_stringout(longtoascii(ende1[i]));

            s_stringout("\r");

            s_stringout(longtoascii(anfang2[i]));

            s_stringout("\r");

            s_stringout(longtoascii(ende2[i]));

            s_stringout("\r");

            };

      }

 

 

 

 

void speichern()

      {

      unsigned int i,j;

      uchar n1,n2,n3,n4;

      s_stringout(" Daten werden auf Flash abgespeichert, bitte warten...");

      s_charout('\r');

      erase_flash(fadr);

      for (i=0;i<letztedaten;i++)

            {

            j=(i*10)|(0xd0000000);

            n1=nummern[i];

            n2=nummern[i]>>8;

            n3=nummern[i]>>16;

            n4=nummern[i]>>24;

 

            write_flash(j,n1);

            write_flash(j+1,n2);

            write_flash(j+2,n3);

            write_flash(j+3,n4);

            write_flash(j+4,tag1[i]);

            write_flash(j+5,tag2[i]);

            write_flash(j+6,anfang1[i]);

            write_flash(j+7,anfang2[i]);

            write_flash(j+8,ende1[i]);

            write_flash(j+9,ende2[i]);

            };

      s_stringout(" Daten abgespeichert");

      s_charout('\r');

      }

 

void lesen()

      {

      unsigned int i;

      unsigned long j;

      uchar n1,n2,n3,n4;

      s_stringout(" Daten werden von Flash gelesen, bitte warten...");

      s_charout('\r');

      for (i=0;i<letztedaten;i++)

            {

            j=(i*10)|(0xd0000000);

            n1=read_flash(j);

            n2=read_flash(j+1);

            n3=read_flash(j+2);

            n4=read_flash(j+3);

            tag1[i]=read_flash(j+4);

            tag2[i]=read_flash(j+5);

            anfang1[i]=read_flash(j+6);

            anfang2[i]=read_flash(j+7);

            ende1[i]=read_flash(j+8);

            ende2[i]=read_flash(j+9);

            nummern[i]=n1+(n2<<8)+(n3<<16)+(n4<<24);

            };

      s_stringout(" Daten gelesen");

      s_charout('\r');

      }

 

 

 

bit prufen(long gesuchteNummer)

{

      

      int i = 0;

      bit gef = 0;

      struct time zeit;

      bit zutritt = 0;

      int a = 0;

      int b = 0;

 

      while(gef == 0 && i<letztedaten)

      {

            if (nummern[i] == gesuchteNummer)

            {

                  gef = 1;

                  a = get_wochentag();

                  if (tag1[i]==8) zutritt=1;

                  else 

                  {

                  if (tag1[i] == a)

                  {

                        get_zeit(&zeit);

                        b = zeit.hours;

                        if (anfang1[i] <= b < ende1[i])

                        {

                             zutritt = 1;

                        }

                        else 

                        {

                             zutritt = 0;

                        }     

                  }

                  else 

                  {

                        if(tag2[i] == a)

                        {

                             get_zeit(&zeit);

                             b = zeit.hours;

                             if (anfang2[i] <= b < ende2[i])

                             {

                                   zutritt = 1;

                             }

                             else 

                             {

                                   zutritt = 0;

                             }

                        }

                  }

                }

            }

            i = i + 1;  

      }

      return (zutritt); 

}

 

 

 

 

/************************************************

*  Sekunden Funktion                           *

*  gibt die aktuelle Sekunde zurück            *

************************************************/

 

uchar seconds()

      {

      struct time zeit;

      get_zeit(&zeit);

      return zeit.seconds;

      }     

 

 

/************************************************

*  Wartefunktion                               *

*  wartet sek Sekunden lang                    *

************************************************/

 

void warten(uchar sek)

{

      uchar zeit;

      uchar temp,temp2;

      temp=sek;

      zeit=seconds();

      temp2=zeit;

      while(temp!=0)

            {

            zeit=seconds();;

            if (zeit!=temp2)

                  {

                  temp--;

                  temp2=zeit;

                  };

            };

}

 

 

/************************************************

*  Funktion für die Tastenabfrage              *          

*  wird aufgerufen sobald die 1. Taste          *

*  gedrueckt wurde                             *

************************************************/

 

void erste_taste(uchar ged_taste)

{

      uchar sekunden,i,tas;

      unsigned long cod;

      cod=ged_taste*10000; // Matrikelnummer(Code) ist fünfstellig,deswegen      

                              die erste Ziffer mal 10000

 

      sekunden=seconds();

 

     //2. Taste  (Kommentare nur hier, weil die anderen Teile gleich sind        

       bis auf die Abspeicherung des Codes

      i=0;

 

      while(taste()==ged_taste) {led_gelb_an(); } ;                          //warten solange Taste noch gedrückt ist

      led_gelb_aus();

      do{

            if (sekunden!=seconds())

                  {

                  i++;

                  sekunden=seconds();

                  }

            tas=taste();                                   //Taste einlesen

            if ((i==10)||(tas=='*')||(tas=='#')) 

                  {

                  led_rot_an();

                  led_gruen_aus();

                  warten(2);

                  led_gruen_an();

                  led_rot_aus();

                  return;

                  }

      }while(tas=='x');       

      cod+=tas*1000;                                             //gedrückte Taste in cod abspeichern

 

      //3. Taste

 

      i=0;

      while(taste()==tas) {led_gelb_an(); };

      led_gelb_aus();

      do{

            if (sekunden!=seconds())

                  {

                  i++;

                  sekunden=seconds();

                  }

            tas=taste();

            if ((i==10)||(tas=='*')||(tas=='#')) 

                  {

                  led_rot_an();

                  led_gruen_aus();

                  warten(2);

                  led_gruen_an();

                  led_rot_aus();

                  return;

                  }

            }while(tas=='x');       

      cod+=tas*100;

 

      //4. Taste

 

      i=0;

      while(taste()==tas) {led_gelb_an(); };

      led_gelb_aus();

      do{

            if (sekunden!=seconds())

                  {

                  i++;

                  sekunden=seconds();

                  }

            tas=taste();

            if ((i==10)||(tas=='*')||(tas=='#')) 

                  {

                  led_rot_an();

                  led_gruen_aus();

                  warten(2);

                  led_gruen_an();

                  led_rot_aus();

                  return;

                  }

      }while(tas=='x');       

      cod+=tas*10;

 

      //5. Taste

      

      i=0;

      while(taste()==tas) {led_gelb_an(); };

      led_gelb_aus();

      do{

            if (sekunden!=seconds())

                  {

                  i++;

                  sekunden=seconds();

                  }

            tas=taste();

            if ((i==10)||(tas=='*')||(tas=='#')) 

                  {

                  led_rot_an();

                  led_gruen_aus();

                  warten(2);

                  led_gruen_an();

                  led_rot_aus();

                  return;

                  }

      }while(tas=='x');       

      cod+=tas;

      while(taste()==tas) {led_gelb_an(); };

      led_gelb_aus();

 

 

      //Code überprüfen

      if (prufen(cod)) tur_auf();

      else

      {

            led_rot_an();

            led_gruen_aus();

            warten(2);             // falscher Code, die rote LED an für 2s

            led_gruen_an();

            led_rot_aus();

            return;

            };

}

 

 

/************************************************

*  Tür-Auf Funktion                            *

************************************************/

 

void tur_auf()

{

      led_gruen_aus();

      led_gelb_an();

      relais_an();

      warten(5);                    // Relais bleibt 5s lang angezogen

      relais_aus();

      led_gelb_aus();

      led_gruen_an();

}

 

 

/************************************************

*  Hauptfunktion                               * 

************************************************/

 

void main ()

{

 

 

// Initialisierung 

uchar ged_taste;

init_uart();                       //Serielle Schnittstelle initialisieren

init_flash(0xd0);                  //Flashkarte initialisieren

relais_aus();                      //Tür zu

lesen();                           //Werte vom Flash in Speicher lesen

 

 

// Hauptschleife

while(1)

{

      led_gruen_an();              //grüne LED an(Grundzustand)

      while(taste()=='x')          //warten bis Taste gedrückt wird

            {

            if (s_charinint()!=0xff)  //Abfrage ob etwas an die serielle   

                                       Schnittstelle gesendet wurde,

                                       falls ja Terminal aufrufen           

                  {

                  led_gruen_aus();

                  led_rot_an();

                  terminal();

                  led_rot_aus();

                  led_gruen_an();

                  };

            };

 

      ged_taste=taste();                             //Taste einlesen

      switch (ged_taste){

            case '*'    : break;

            case '#'    : break;                      //bei # nichts machen

            case 'x'    : break;

            default     : erste_taste(ged_taste);    //wenn Zahl dann 

                                                     Funktion erste_taste

                                                     aufrufen

                             break;

      };

      led_rot_aus();                     //rote LED aus

      relais_aus();                      //Tür zu (nur zur Sicherheit)

}

}