main.cpp

00001 /***************************************************************************
00002 * Titel        : main.cpp
00003 *
00004 * Description  : Labormodul "HAPOA"
00005 *
00006 * Revision List:
00007   --------------------------------------------------------------------------
00008   Date     | Author          | Change
00009   --------------------------------------------------------------------------
00010   24.10.22 | J. Altenburg    | Ersterstellung
00011   --------------------------------------------------------------------------
00012            |                 |
00013   ---------------------------------------------------------------------------
00014   
00015   Editor List:
00016   --------------------------------------------------------------------------
00017   Date     | Author          | Change
00018   --------------------------------------------------------------------------
00019   30.11.22 |Tobias Zinke     | Labor03
00020   --------------------------------------------------------------------------
00021   30.11.22 |Alexander Pitthan| Labor03
00022   ---------------------------------------------------------------------------
00023 ****************************************************************************/
00024 #include "mbed.h"
00025 #include "cdef.h"
00026 
00027 AnalogIn    pinPoti (A0);
00028 
00029 /* Vereinbarungen zu den Tasteneingängen */
00030 DigitalIn   pinS1(A1);
00031 DigitalIn   pinS2(A2);
00032 DigitalIn   pinS3(A3);
00033 
00034 BusOut      bLedShield(D10, D11, D12, D13);
00035 
00036 /* Anschlüsse der Schieberegister */
00037 DigitalOut  pinSdo(PA_9);
00038 DigitalOut  pinSck(PA_8);
00039 DigitalOut  pinLoad(PB_5);
00040 //DigitalOut  pinBeep(PB_3);
00041 
00042 /* ISR */
00043 Ticker      stTimer;
00044 
00045 /***************************************************************************
00046 *   Defines und Makros                                                       *
00047 ***************************************************************************/
00048 #define nTastShort  20      /* Taste 50 Millisekunden gedrückt */    
00049 #define nTastLong   600     /* Taste 1.5 Sekunden gedrückt */ 
00050 #define nCircleTime 2500    /* Laufzeit der Main in us */
00051 
00052 #define nSegA           0x01
00053 #define nSegB           0x02
00054 #define nSegC           0x04
00055 #define nSegD           0x08
00056 #define nSegE           0x10
00057 #define nSegF           0x20
00058 #define nSegG           0x40
00059 #define nSegH           0x80
00060 
00061 #define nZiffer0    ~(nSegA | nSegB | nSegC | nSegD | nSegE | nSegF)
00062 #define nZiffer1    ~(nSegB | nSegC)
00063 #define nZiffer2    ~(nSegA | nSegB | nSegD | nSegE | nSegG)
00064 #define nZiffer3    ~(nSegA | nSegB | nSegC | nSegD | nSegG)
00065 #define nZiffer4    ~(nSegB | nSegC | nSegF | nSegG)
00066 #define nZiffer5    ~(nSegA | nSegC | nSegD | nSegF | nSegG)
00067 #define nZiffer6    ~(nSegA | nSegC | nSegD | nSegE | nSegF | nSegG)
00068 #define nZiffer7    ~(nSegA | nSegB | nSegC)
00069 #define nZiffer8    ~(nSegA | nSegB | nSegC | nSegD | nSegE | nSegF | nSegG)
00070 #define nZiffer9    ~(nSegA | nSegB | nSegC | nSegD | nSegF | nSegG)
00071 #define nZifferA    ~(nSegA | nSegB | nSegC | nSegE | nSegF | nSegG)
00072 #define nZifferB    ~(nSegC | nSegD | nSegE | nSegF | nSegG)
00073 #define nZifferC    ~(nSegA | nSegD | nSegE | nSegF)
00074 #define nZifferD    ~(nSegB | nSegC | nSegD | nSegE | nSegG)
00075 #define nZifferE    ~(nSegA | nSegD | nSegE | nSegF | nSegG)
00076 #define nZifferF    ~(nSegA | nSegE | nSegF | nSegG)
00077 #define nZifferOff   (nSegA | nSegB | nSegC | nSegD | nSegE | nSegF | nSegG | nSegH)
00078 
00079 byte bIdx; /*
00080 * Description : Index auf Ausgabe
00081 */
00082 
00083 byte bDigit; /*
00084 * Description : aktives Digit
00085 */
00086 
00087 byte bBargraph; /*
00088 * Description : Bargraph durchschalten
00089 */
00090 
00091 byte bS1Timer; /*
00092 * Description : Timer für Taste S1
00093 */
00094 
00095 byte bS2Timer; /*
00096 * Description : Timer für Taste S2
00097 */
00098 
00099 byte bS3Timer; /*
00100 * Description : Timer für Taste S3
00101 */
00102 
00103 byte bDisplayState; /*
00104 * Description : 
00105 */
00106 const byte enSchwellenwert=0x00;
00107 const byte enPotiAnzeige = 0x01;
00108 const byte enVergleich = 0x02;
00109 //const byte enShowError = 0x03;
00110 //const byte enWaitForRun = 0x04;
00111 
00112 
00113 byte bState; /*
00114 * Description : 
00115 */
00116 
00117 byte bTimerDot; /*
00118 * Description : Zähler für Dots
00119 */
00120 
00121 byte bHotKey; /*
00122 * Description : Auswahl der Taste
00123 */
00124 
00125 byte bDisplayDot; /*
00126 * Description : 
00127 */
00128 
00129 byte bMainState; /*
00130 * Description : Hauptzustand
00131 */
00132 
00133 byte bBeepTime; /*
00134 * Description : Tondauer 
00135 */
00136 
00137 byte bEinstellungsModus;/*
00138 * Description : Einstellungszustand 
00139 */
00140 
00141 byte bSchwellenwertVergleich;/*
00142 * Description : Einstellungszustand 
00143 */
00144 
00145 
00146 word wSerial; /*
00147 * Description : serielles Ausgaberegister
00148 */
00149 
00150 word wClockTime; /*
00151 *Description : Timer für verstrichene Zeit
00152 */
00153 
00154 word wClockShow; /*
00155 *Description : Timer für verstrichene Zeit
00156 */
00157 
00158 word wDelayGame; /*
00159 * Description : Verzögerungstimer
00160 */
00161 
00162 word wPotiWert; /*
00163 * Description : Wert des Potis
00164 */
00165 
00166 word wVorgabeWert; /*
00167 * Description : engestellter Vorgabewert
00168 */
00169 
00170 /* Bitmuster */
00171 const byte abZiffer[] = {nZiffer0, nZiffer1, nZiffer2, nZiffer3, nZiffer4, nZiffer5, nZiffer6, nZiffer7, nZiffer8, nZiffer9, nZifferA, nZifferB, nZifferC, nZifferD, nZifferE, nZifferF, nZifferOff};
00172 const byte abBargraph[] = {~Bit0, ~(Bit0|Bit1), ~(Bit0|Bit1|Bit2), ~(Bit0|Bit1|Bit2|Bit3), 0x0f};
00173 
00174 
00175 void vShiftLoad(word wLoad){
00176     word wMask = Bit15;
00177     pinLoad = 0;
00178     while(wMask){
00179         if(wMask & wLoad) pinSdo = 1;
00180         else              pinSdo = 0;
00181         pinSck = 1;
00182         wMask >>= 1;
00183         pinSck = 0;
00184         }    
00185     pinLoad = 1;
00186     }
00187 
00188 
00189 byte abDisplayMemory[] = {16,16,16,16}; /* alle Segmente aus */
00190 
00191 void vDisplayClock( word w )
00192 {
00193     int16 v;
00194     abDisplayMemory[0] = 16; /* Aus */
00195     v = (byte)(w / 100);
00196     abDisplayMemory[1] = v; /* Hunderter */
00197     w = w - (v * 100);
00198     v = (byte)(w / 10);
00199     abDisplayMemory[2] = v; /* Zehner */
00200     w = w - (v * 10);
00201     abDisplayMemory[3] = (byte)w; /* Einer */
00202 }
00203 /*
00204 void vSetWaitForStart( void )
00205 {
00206     abDisplayMemory[0] = 16; /* 7-Segment-Display ausschalten 
00207     abDisplayMemory[1] = 16;
00208     abDisplayMemory[2] = 16;
00209     abDisplayMemory[3] = 16;
00210     bDisplayState = enWaitForStart;
00211     bTimerDot = 0;
00212     bDigit = 0;
00213 }
00214 
00215 void vSetRunClock( void )
00216 {
00217     wClockTime = 0;
00218     bDigit = 0;
00219     abDisplayMemory[0] = 16; /* 7-Segment-Display ausschalten 
00220     abDisplayMemory[1] = 0;
00221     abDisplayMemory[2] = 0;
00222     abDisplayMemory[3] = 0;
00223     bDisplayState = enRunClock;
00224 }
00225 */
00226 /*
00227 byte bCheckTasten( byte bState )
00228 {
00229     if((pinS1 == 0) || (pinS2 == 0) || (pinS3 == 0)) { /* Tastendruck erkannt 
00230         wClockShow = 1200;
00231         if((pinS1 == 0) && (bHotKey == 0)) {
00232             wDelayGame = 0;
00233             bState = enShowResult;
00234             bDisplayState = enShowResult;
00235         } else if((pinS2 == 0) && (bHotKey == 1)) {
00236             wDelayGame = 0;
00237             bState = enShowResult;
00238             bDisplayState = enShowResult;
00239         } else if((pinS3 == 0) && (bHotKey == 2)) {
00240             wDelayGame = 0;
00241             bState = enShowResult;
00242             bDisplayState = enShowResult;
00243         } else {
00244             wDelayGame = 200;
00245             abDisplayMemory[1] = 15;
00246             abDisplayMemory[2] = 15;
00247             abDisplayMemory[3] = 15;
00248             bState = enShowError;
00249             bDisplayState = enShowResult;
00250             pinBeep = 0;
00251         }
00252     }
00253     return bState;
00254 }
00255 */
00256 /* Tastenabfrage */
00257 void vTasteS1( void ){
00258     if(pinS1 == 0){                             /* User-Taste gedrückt */
00259         if(bS1Timer < nTastLong+1){             /* Abfrage max. bis Taste lange gedrückt */
00260             if(bS1Timer == nTastShort){         /* Taste "kurz gedrückt" erkannt */
00261                 //...
00262                 }
00263             if(bS1Timer == nTastLong){          /* Taste "lange gedrückt" erkannt */ 
00264                 if(bDisplayState = enSchwellenwert){
00265                     bDisplayState = enPotiAnzeige; 
00266                     bMainState = enPotiAnzeige;
00267                     }
00268                 else{ 
00269                     bDisplayState = enSchwellenwert;
00270                     bMainState= enSchwellenwert;
00271                     }
00272                 }
00273             bS1Timer++;
00274             }
00275         }
00276     else{                                       /* Taste nicht gedrückt */ 
00277         if((bS1Timer >= nTastShort) && (bS1Timer <= nTastLong)){             /* Taste wurde bereits erkannt */
00278             if(bDisplayState = enSchwellenwert || bDisplayState = enPotiAnzeige){
00279                 bDisplayState = enVergleich;
00280                 bMainState = enVergleich;
00281                 }
00282             else{
00283                 bDisplayState = enSchwellenwert;
00284                 bMainState = enSchwellenwert;
00285                 }
00286             }
00287         bS1Timer = 0;
00288         }
00289     } 
00290 
00291 void vTasteS2( void ){
00292     if(pinS2 == 0){                             /* User-Taste gedrückt */
00293         if(bS2Timer < nTastLong+1){             /* Abfrage max. bis Taste lange gedrückt */
00294             if(bS2Timer == nTastShort){         /* Taste "kurz gedrückt" erkannt */
00295                 //...
00296                 }
00297             if(bS2Timer == nTastLong){          /* Taste "lange gedrückt" erkannt */ 
00298                 //...
00299                 }
00300             bS2Timer++;
00301             }
00302         }
00303     else{                                       /* Taste nicht gedrückt */ 
00304         if((bS2Timer >= nTastShort) && (bS2Timer <= nTastLong)){             /* Taste wurde bereits erkannt */
00305             //...
00306             }
00307         bS2Timer = 0;
00308         }
00309     } 
00310 
00311 void vTasteS3( void ){
00312     if(pinS3 == 0){                             /* User-Taste gedrückt */
00313         if(bS3Timer < nTastLong+1){             /* Abfrage max. bis Taste lange gedrückt */
00314             if(bS3Timer == nTastShort){         /* Taste "kurz gedrückt" erkannt */
00315                 //...
00316                 }
00317             if(bS3Timer == nTastLong){          /* Taste "lange gedrückt" erkannt */ 
00318                 //...
00319                 }
00320             bS3Timer++;
00321             }
00322         }
00323     else{                                       /* Taste nicht gedrückt */ 
00324         if((bS3Timer >= nTastShort) && (bS3Timer <= nTastLong)){             /* Taste wurde bereits erkannt */
00325             //...
00326             }
00327         bS3Timer = 0;
00328         }
00329     } 
00330 
00331 
00332 
00333 void vCheckTasten( void ){
00334     vTasteS1();
00335     vTasteS2();
00336     vTasteS3();
00337     }
00338 void vSegmentDigit( void ) //wichtig!!
00339 {
00340     bDigit++;
00341     wSerial = abZiffer[abDisplayMemory[bDigit&0x03]];
00342     switch(bDisplayState) {
00343         case enSchwellenwert:
00344             bTimerDot++; /* Zähler für Punktwechsel */
00345             if(bTimerDot == 50) {
00346                 bTimerDot = 0;
00347                 bDisplayDot = (bDisplayDot + 1) & 0x03;
00348             }
00349             if(bDisplayDot == (bDigit&0x03)) {
00350                 wSerial = wSerial & ~nSegH; /* Punktanzeigen */
00351             }
00352             break;
00353         case enPotiAnzeige:
00354             if((bDigit&0x03) == 0x03){ /* Ablauf von 10 ms */
00355                 wClockTime++;
00356                 if(wClockTime > 999) {
00357                     wClockTime = 0;
00358                 }
00359                 vDisplayClock(wClockTime);
00360             }
00361             if((bDigit&0x03) == 0x01) { /* Dezimalpunkt setzen */
00362                 wSerial = wSerial & ~nSegH;
00363             }
00364             break;
00365         case enVergleich:
00366             if((bDigit&0x03) == 0x01) { /* Dezimalpunkt setzen */
00367                 wSerial = wSerial & ~nSegH;
00368                 }
00369             break;
00370     }
00371     vShiftLoad(((wSerial << 8) & 0xfff0)| (1 << (bDigit&0x03)));
00372 }
00373 
00374 void vBargraph(byte bTaste){
00375     switch(bTaste){
00376         case 0 :
00377             bLedShield =0b1110;
00378             break;
00379         case 1 :
00380             bLedShield =0b1101;
00381             break;
00382         case 2 :
00383             bLedShield =0b1011;
00384             break;
00385     }
00386 }
00387 
00388 /***************************************************************************
00389 *   main()
00390 ***************************************************************************/
00391 int main() {
00392     /* Variablen initialisieren */    
00393     byte bRandomTaste = 0;
00394     word wRandomClock = 0;
00395     bMainState = enWaitForStart;
00396     bDisplayState = enWaitForStart;
00397     pinBeep = 1;
00398     vSetWaitForStart();
00399     
00400     Seriel.begin(9600);
00401     
00402     while(1) {        
00403         bRandomTaste++;
00404         if(bRandomTaste > 2) bRandomTaste = 0; /* zufällige LED/Taste bestimmen */
00405         wRandomClock++;
00406         if(wRandomClock > 800) wRandomClock = 0; /* Zufallszeit erzeugen */
00407         switch(bMainState) {
00408             case enWaitForStart:
00409                 wDelayGame++;
00410                 bLedShield =0b1111;
00411                 if(wDelayGame > 1200) { /* 3 Sekundenminimum */
00412                     wDelayGame = wRandomClock;
00413                     bMainState = enWaitForRun;
00414                 }
00415                 break;
00416             case enRunClock:
00417                 bBeepTime--;
00418                 if(bBeepTime == 0)pinBeep = 1;
00419                 bMainState = bCheckTasten(enRunClock);
00420                 break;
00421             case enWaitForRun:
00422                 wDelayGame--;
00423                 if(wDelayGame == 0){
00424                     bMainState = enRunClock;
00425                     bDisplayState = enRunClock;
00426                     bBeepTime = 20;
00427                     bHotKey = bRandomTaste;
00428                     vBargraph(bRandomTaste);
00429                     vSetRunClock();
00430                     pinBeep = 0;
00431                     }
00432                 break;
00433             case enShowResult:
00434                 wClockShow--;
00435                 if(wClockShow==0){
00436                     bMainState = enWaitForStart;
00437                     bDisplayState = enWaitForStart;
00438                     vSetWaitForStart();
00439                     }
00440                 break;
00441             case enShowError:
00442                 wDelayGame--;
00443                 if(wDelayGame == 0)pinBeep = 1;
00444                 wClockShow--;
00445                 if(wClockShow==0){
00446                     bMainState = enWaitForStart;
00447                     bDisplayState = enWaitForStart;
00448                     wDelayGame = 0;
00449                     vSetWaitForStart();
00450                     }
00451                 break;
00452         }
00453         vSegmentDigit();
00454         wait_us(n   CircleTime);
00455     }
00456 }