Het gebruik van het Simplex3 68HC11 bord in het inbraakalarm project.

© Harry Broeders.

Deze pagina is bestemd voor EPv studenten van de THRijswijk.

Inleiding.

Het inbraakalarmproject wordt beschreven in het dictaat van het practicum Praktische vaardigheden elektrotechniek. Op deze webpagina kun je de benodigde software vinden. Er is een testprogramma beschikbaar waarmee je de hardware kunt testen. Verder zijn er verschillende functies beschikbaar waarmee de hardware kan worden aangestuurd en ingelezen. Er is echter geen volledig inbraakalarm programma beschikbaar. Dat kunnen jullie met behulp van de gegeven functies best zelf maken! 

Het hart van het inbraakalarm is de Simplex3 print met daarop de 68HC11 microcontroller. Aan dit bord wordt een door jou zelf gemaakt inbraakalarmbordje gekoppeld. In het schema van het inbraakalarmbordje kun je zien dat ingangssignalen afkomstig van het toetsenbord en de detectie-ingangen worden ingelezen via de pinnen C15 t/m C21 van de connector. Om het toetsenbord te kunnen "scannen" moeten bepaalde lijnen van het toetsenbord worden aangestuurd, dit gebeurt via de pinnen A1 t/m A4 van de connector. De leds, de buzzer en het relais kunnen door het Simplex3 bord worden aangestuurd via de pinnen A19 t/m A26 van de connector. In de beschrijving van de Simplex3 connector kun je opzoeken dat de pinnen C15 t/m C21 van de connector verbonden zijn met respectievelijk de pinnen PE7 t/m PE1 van de 68HC11. Dit zijn ingangspinnen van de 68HC11 waarmee zowel analoge als digitale ingangen kunnen worden ingelezen. De pinnen A1 t/m A4 zijn verbonden met de pinnen PAA0 t/m PAA3 van de PSD 833F290J. De afkorting PSD betekent in dit geval Programmable System Device (en dus niet Programma Structuur Diagram). De pinnen A19 t/m A26 zijn verbonden met PPB0 t/m PPB7 van de PSD. Deze PSD is een vrij ingewikkelde component waarin verschillende soorten geheugen (RAM en EEPROM), verschillende I/O poorten, een aantal configureerbare logische blokken en een JTAG interface om deze blokken te configureren op één chip zijn geïntegreerd. De datasheet van deze component is veel te ingewikkeld om nu (in de P fase) al te kunnen begrijpen. Wij gebruiken alleen de A en B Input/Output poorten van deze chip en het RAM geheugen om ons programma te testen. Er zijn C functies beschikbaar om naar de A en B poorten van de PSD te schrijven. RAM staat voor Random Access Memory en dit is geheugen dat zowel gelezen als beschreven kan worden maar dat zijn informatie verliest als de spanning wegvalt. Tijdens het testen gebruik je het RAM geheugen van de PSD om je programma in op te slaan. Je kunt het programma later ook in het EEPROM geheugen van de PSD laden. EEPROM staat voor Electrically Erasable Programmable Read Only Memory dit geheugen kan alleen uitgelezen worden en niet worden beschreven. Wel kan dit geheugen op een speciale manier worden geladen (geprogrammeerd) en ook kan het indien nodig weer worden gewist (niet per byte maar in blokken).  Als je programma in het EEPROM geheugen geladen is hoef je het niet opnieuw te laden als de spanning wegvalt.

Test programma om de LED's , de buzzer en het relais aan te sturen.

We beginnen met een programma waarmee we de B poort van de PSD kunnen aansturen om de leds, de buzzer en het relais te kunnen testen. Let op! De 68HC11 heeft zelf ook I/O poorten waaronder ook een A en B poort maar deze 68HC11 I/O poorten worden in dit eerste testprogramma niet gebruikt. De PSD op het Simplex3 bordje is zodanig geconfigureerd dat de A en B poorten van de PSD eenvoudig als input of als output te gebruiken zijn. In het zogenaamde Direction registers van de PSD kun je voor elke pin van poort A en poort B aangeven of deze pin als input (default) of als output wordt gebruikt. Vervolgens kun de Data In registers van de PSD gebruiken voor invoer en de Data Out registers voor output. Een overzicht van deze registers, met de adressen waar deze registers zich in de memory map van het Simplex bord, kun je vinden in de onderstaande tabel.

Registers voor het besturen van poort A en B van de PSD
Naam Adres Beschrijving
Data In A $1200 Via dit register kun je de pinnen van poort A inlezen.
Data In B $1201 Via dit register kun je de pinnen van poort B inlezen.
Data Out A $1204 Via dit register kun je de output pinnen van poort A aansturen.
Data Out B $1205 Via dit register kun je de output pinnen van poort B aansturen.
Direction A $1206 Via dit register kun je voor elke pin van poort A aangeven of het een input (0) of output (1) pin moet zijn.
Direction B $1207 Via dit register kun je voor elke pin van poort B aangeven of het een input (0) of output (1) pin moet zijn.

Alle uitgangssignalen waarmee de leds, de buzzer en het relais worden aangestuurd zijn actief laag. Dat wil zeggen dat ze kunnen worden aangezet door het signaal 0 te maken en dat ze kunnen worden uitgezet door het signaal 1 te maken. Het is erg fijn dat de ontwerpers hier voor hebben gekozen. Als het Simplex bord wordt aangezet zijn alle PPB pinnen geconfigureerd als ingangen. De ingangen van de inverterende buffers (HEF4049) worden dan dus niet aangestuurd. Dit wordt door de inverterende buffers gezien als een logische 1 en de uitgangen van alle buffers zijn dus 0. Daardoor zijn alle ledjes uit, staat het relais uit en (nog veel prettiger) is de buzzer stil. Als we de leds, het relais of de buzzer willen aanzetten moeten we de PPB pinnen configureren als ouput en een 0 schrijven naar een pin om het bijbehorende device aan te zetten.

Het PSD (Programma Structuur Diagram) van een eenvoudig programma om outputs te testen ziet er als volgt uit.

In C kan dit als volgt (testoutputs.c) geïmplementeerd worden:

typedef unsigned char byte;
typedef unsigned short word;

void wacht() {
   /* hou de processor even bezig... */
   word i;
   for (i=0; i<10000; ++i) {
      /* niets */
   }
}

int main() {
   volatile byte* dob=(byte*)0x1205; /* Data Out B register van de PSD */
   volatile byte* db= (byte*)0x1207; /* Direction B register van de PSD */
   byte patroon[]={0x80, 0x40, 0xc0, 0x20, 0x10, 0x30, 0x08, 0x04, 0x0c, 0x02, 0x01, 0x00};
   byte i;
   *db=0xff; /* PPB0 t/m PPB7 output */

   while (1) {
      for (i=0; patroon[i]!=0x00; ++i) { /* Voor alle testpatronen: */
         /* Haal testpatroon op uit een array met testpatronen */
         /* en stuur dit testpatroon geïnverteerd naar de PPB pinnen */
         *dob=~patroon[i];
         wacht(); /* Wacht enige tijd */
      }
   }

   return 0;
}

Verklaring:

Dit programma kun je met behulp van THRSim11 op je Simplex3 bord draaien. Het THRSim11 programma is een simulatieprogramma voor de 68HC11 microcontroller. Dit programma is al geïnstalleerd op de PC's op school en kun je ook thuis installeren. Zie: http://bd.thrijswijk.nl/thrsim11_4_thuis/index.htm

Hier volgt een stap voor stap beschrijving waarmee je het testprogramma op jou bordje kan uitvoeren:

  1. Verbind het zelfgemaakte inbraakalarmbordje met het Simplex3 bordje.
  2. De jumper JP1 (TRACE) op het Simplex bordje moet op de stand PA3 staan. De twee dipswitches DIPSW1 (MODA) en DIPSW2 (MODB) moeten beide in de OFF stand staan.
  3. De jumper op het inbraakalarmbordje (naast de 64 polige connector) moet zijn verwijderd.
  4. Start THRSim11.
  5. Kies de menu optie File, Options, Memory Configuration...
  6. Configureer het geheugen als volgt:

    Klik hier voor een verklaring van deze instellingen (indien gewenst).

  7. Controleer de memory map via het View, Memory, Memory Map... menu.
  8. Om het programma te kunnen compileren heb je een zogenaamde makefile en een linker script nodig. Klik hier voor meer uitleg over het linker script en de makefile (indien gewenst). Maak een nieuwe directory aan en kopieer de files: testoutputs.c, simplex3.ld en makefile in dit directory. Je kunt deze files kopiëren door met de cursor op de link te gaan staan en op de rechterknop van de muis te klikken en vervolgens "Save Target As..." te kiezen.  Let op: Internet Explorer zet de extensie .txt achter de makefile (na het downloaden). Deze extensie moet je verwijderen.
  9. Laad het programma testoutputs.c in THRSim11 via het File, Open... menu. Als het goed is wordt het programma nu automatisch in de editor SciTe geopend.
  10. Compileer het programma en laad het resultaat met behulp van de sneltoets F5.
  11. Om dit programma in het Simplex bordje te kunnen laden moet je de seriële poort van het Simplex3 bordje verbinden met een seriële poort van de PC.
  12. In THRSim11 moet je de communicatie opties via het menu Target, Target Communications Options... als volgt instellen:

  13. Je kunt nu, via de sneltoets Ctrl+D, het programma in het Simplex3 bord downloaden. Let er op dat het window waarin de listing zichtbaar is actief is als je op Ctrl+D drukt. (Als dat niet zo is verschijnt een file select dialog box. Druk als deze dialog verschijnt op Cancel en probeer het opnieuw.)
  14. Via de spatiebalk kun je het programma instructie voor instructie op het bord uitvoeren. Met de sneltoets Ctrl+F9 kun je het programma op het target bord starten. De enige manier om het programma daarna te stoppen is via de reset switch (SW2). De reset switch zit op het Simplex3 bordje vlak naast de seriële connector.

Als het goed gaat zie je de ledjes 1 voor 1 en kleur voor kleur aangestuurd worden, daarna wordt het relais even aangestuurd en tot slot hoor je de buzzer (misschien kun je dit programma gebruiken als je het inbraakalarmsysteem met Kerst in de boom hangt ;-).

Testprogramma voor het toetsenbord.

Het scannen van het toetenbord is redelijk ingewikkelde code en deze code wordt nu dan ook niet verder uitgelegd. Deze software kan op dezelfde manier geladen en gestart worden als het testprogramma voor de outputs.

  1. Maak een nieuw directory aan en kopieer de files: testkeyboard.c, simplex3.ld en makefile in dit directory. Je kunt deze files kopiëren door met de cursor op de link te gaan staan en op de rechterknop van de muis te klikken en vervolgens "Save Target As..." te kiezen.  Let op: Internet Explorer zet de extensie .txt achter de makefile (na het downloaden). Deze extensie moet je verwijderen.
  2. Laad het programma testkeyboard.c in THRSim11 via het File, Open... menu. Als het goed is wordt het programma nu automatisch in de editor SciTe geopend.
  3. Compileer het programma en laad het resultaat met behulp van de sneltoets F5.
  4. Laad het programma in het Simplex3 bord via de sneltoets Ctrl+D. Let er op dat het window waarin de listing zichtbaar is actief is als je op Ctrl+D drukt. (Als dat niet zo is verschijnt een file select dialog box. Druk als deze dialog verschijnt op Cancel en probeer het opnieuw.)
  5. Met de sneltoets Ctrl+F9 kun je het programma op het target bord starten. De enige manier om het programma daarna te stoppen is via de reset switch (SW2). De reset switch zit op het Simplex3 bordje vlak naast de seriële connector.

Het indrukken van een toets zal een bepaalde output tot gevolg hebben. Zie onderstaande tabel:

toets bovenste led middelste led onderste led relais buzzer
1 groen uit uit uit uit
2 rood uit uit uit uit
3 uit groen uit uit uit
4 uit rood uit uit uit
5 uit uit groen uit uit
6 uit uit rood uit uit
7 groen groen groen uit uit
8 rood rood rood uit uit
9 oranje oranje oranje uit uit
* uit uit uit uit aan
0 rood oranje groen uit uit
# uit uit uit aan uit

Testprogramma voor de timing.

Om de inbraakalarm software te kunnen programmeren moet je een bepaalde tijd kunnen wachten. Om een bepaalde tijdsduur te wachten maken we gebruik van de zogenaamde "Real Time" counter van de 68HC11. Deze counter zal telkens na 4.096 ms (later in semester H1 zul je leren dat deze waarde instelbaar is) het zogenaamde bit RTIF uit het TFLG2 register van de 68HC11 setten. We kunnen dit bit weer resetten door er een 1 naar toe te schrijven. Nee, dat is geen typefout! Je maakt het RTIF bit 0 door er een 1 naar toe te schrijven, raar maar waar. Dit is te vergelijken met een repeterende wekker die telkens na een bepaalde tijd weer afloopt en die je telkens kunt uitdrukken (je kent dat wel;-). Door nu te tellen hoeveel maal deze "wekker" is afgelopen kun je de verstreken tijd bepalen. Het TFLG2 register bevindt zich op adres $1025 van de memory map en bit RTIF is bit 6 van dit register.

In het testprogramma voor de outputs kan nu telkens een halve seconde worden gewacht door de functie wacht als volgt te implementeren (testoutputs.c):

typedef unsigned char byte;

void wacht() {
   /* wacht 122 * 4.096 ms = (ongeveer) 0.5 sec */
   volatile byte* tflg2=(byte*)0x1025; /* TFLG2 register van de 68HC11 */
   byte i;
   for (i=0; i<122; ++i) { /* wacht 122 keer */
      while ((*tflg2&0x40)!=0x40) { /* wacht tot RTIF == 1 */
         /* niets */
      }
      *tflg2=0x40; /*maak RTIF 0 (door er een 1 naar toe te schrijven) */
   }
}

Verklaring:

De software voor het inbraakalarm systeem.

Het programma voor het inbraakalarmsysteem mag je zelf schrijven met behulp van een aantal functies waarmee je de hardware kunt aansturen en inlezen. De functies zijn beschikbaar in het programma inbraakalarm.c. Hier zijn de bijbehorende makefile en simplex3.ld files.

De beschikbare functies:

Een testprogramma dat gebruik maakt van deze functies is hieronder gegeven:

int main() {
   char c;
   *db=0xff; /* PPB0 t/m PPB7 output */
   *da=0x0f; /* PPA0 t/m PPA4 output */
   *dob=0xff; /* PPB0 t/m PPB7 hoog (uit) */

   while (1) {
/*
   Schrijf hier je eigen inbraakalarm programma!
*/
      c=scankey();
      switch(c) {
         case '0':   led(BOVEN, UIT);
               led(MIDDEN, UIT);
               led(ONDER, UIT);
               relais(UIT);
               buzzer(UIT);
               break;
         case '1':   led(BOVEN, ROOD);
               break;
         case '2':   led(BOVEN, ORANJE);
               break;
         case '3':   led(BOVEN, GROEN);
               break;
         case '4':   led(MIDDEN, ROOD);
               break;
         case '5':   led(MIDDEN, ORANJE);
               break;
         case '6':   led(MIDDEN, GROEN);
               break;
         case '7':   led(ONDER, ROOD);
               break;
         case '8':   led(ONDER, ORANJE);
               break;
         case '9':   led(ONDER, GROEN);
               break;
         case '*':   buzzer(AAN);
               break;
         case '#':   relais(AAN);
               break;
      }
      if (scaninput(0)==VERBONDEN) {
         buzzer(AAN);
         wacht(122);
         buzzer(UIT);
         wacht(122);
      }
   }
   return 0;
}

Programma laden in het EEPROM geheugen van de 68HC11.

Tot nu toe hebben we de programma's in het RAM (Random Access Memory) van het Simplex3 bordje geladen. Het voordeel van het gebruik van RAM is dat dit geheugen zowel gelezen als geschreven kan worden. De programma's kunnen dus eenvoudig in RAM worden geladen. Een nadeel van RAM is dat de hierin opgeslagen informatie verloren gaat zodra de spanning wegvalt. Het Simplex3 bordje bevat ook 160 Kb Flash geheugen (in de PSD) en 0.5 Kb EEPROM geheugen (in de 68HC11). Zowel Flash als EEPROM (Electrical Erasable Programmable Read Only Memory) kunnen alleen gelezen worden maar behouden hun informatie als de spanning wegvalt. Zowel Flash als EEPROM geheugen moet eerst gewist worden voordat er nieuwe informatie in "geprogrammeerd" kan worden. We noemen het schrijven in Flash of EEPROM "programmeren" omdat het vele malen trager is dan het schrijven in RAM en alleen gedaan mag (kan) worden nadat het betreffende geheugen(deel) gewist is.

Het testkeyboard.c programma is klein genoeg om in het EEPROM geheugen van de 68HC11 te passen. Je kunt dit programma als volgt in het EEPROM geheugen "programmeren":

  1. Maak een nieuw directory aan en kopieer de files: testkeyboard.c, simplex3_eeprom.ld en makefile in dit directory. Je kunt deze files kopiëren door met de cursor op de link te gaan staan en op de rechterknop van de muis te klikken en vervolgens "Save Target As..." te kiezen.  Let op: Internet Explorer zet de extensie .txt achter de makefile (na het downloaden). Deze extensie moet je verwijderen.
  2. Laad het programma testkeyboard.c in THRSim11 via het File, Open... menu. Als het goed is wordt het programma nu automatisch in de editor SciTe geopend.
  3. Compileer het programma en laad het resultaat met behulp van de sneltoets F5.
  4. Om dit programma in het Simplex bordje te kunnen laden moet je de seriële poort van het Simplex3 bordje verbinden met een seriële poort van de PC.
  5. Als de communicatie opties juist zijn ingesteld (zie hierboven) dan kun je nu met de menu optie: Target, Target Connect verbinding maken met het Simplex3 bord.
  6. Je kunt nu een window openen om commando's naar het Simplex3 bord te sturen met behulp van de menu optie: Target, Target Command Window. Het EEPROM geheugen kan nu gewist worden door het BULK commando in te typen.
  7. Je kunt dit programma nu in het EEPROM geheugen van de 68HC11 op het Simplex3 bord "programmeren" met behulp van de menu optie: Target, Target Copy, Copy Simulator EEPROM Memory to Target. Je moet er zelf voor zorgen dat het EEPROM geheugen eerst wordt gewist voordat het wordt geprogrammeerd. Om deze optie te kunnen gebruiken moet je versie 5.21c (26 september 2004) of hoger van THRSim11 hebben. Je kunt de laatste versie van THRSim11 hier vinden: http://bd.thrijswijk.nl/thrsim11_4_thuis/index.htm.
  8. Het programma in EEPROM kan worden gestart door de jumper op het inbraakalarmbordje (naast de 64 polige connector) door te verbinden en de reset switch (SW2) in te drukken (en weer los te laten). De reset switch zit op het Simplex3 bordje vlak naast de seriële connector.
  9. Als nu de voedingsspanning wordt weggenomen zal het windmeter.c programma automatisch worden opgestart zodra de voedingspanning weer wordt aangesloten.
  10. Vergeet niet om de jumper op het windmeterbordje (naast de connector) weer te verwijderen als je THRSim11 weer met je bordje wilt laten communiceren.