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   240     /* Taste 0.6 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 bSCounter; /*
00104 * Description : Zähler UART-Auslese für Tasterersatz
00105 */
00106 
00107 byte bDisplayState; /*
00108 * Description : 
00109 */
00110 const byte enSchwellenwert=0x00;
00111 const byte enPotiAnzeige = 0x01;
00112 const byte enVergleich = 0x02;
00113 
00114 
00115 byte bState; /*
00116 * Description : 
00117 */
00118 
00119 byte bTimerDot; /*
00120 * Description : Zähler für Dots
00121 */
00122 
00123 byte bHotKey; /*
00124 * Description : Auswahl der Taste
00125 */
00126 
00127 byte bDisplayDot; /*
00128 * Description : 
00129 */
00130 
00131 byte bMainState; /*
00132 * Description : Hauptzustand
00133 */
00134 
00135 byte bBeepTime; /*
00136 * Description : Tondauer 
00137 */
00138 
00139 byte bEinstellungsModus;/*
00140 * Description : Einstellungszustand 
00141 */
00142 
00143 byte bSchwellenwertVergleich;/*
00144 * Description : Einstellungszustand 
00145 */
00146 
00147 byte bTimeLong;/*
00148 * Description : Ob Taste bereits lange gedrückt war 
00149 */
00150 
00151 byte bSizeData;/*
00152 * Description : Größe der Daten
00153 */
00154 byte *pUartData; /*
00155 * Description : pointer to data
00156 */
00157 
00158 
00159 word wSerial; /*
00160 * Description : serielles Ausgaberegister
00161 */
00162 
00163 word wClockTime; /*
00164 *Description : Timer für verstrichene Zeit
00165 */
00166 
00167 word wClockShow; /*
00168 *Description : Timer für verstrichene Zeit
00169 */
00170 
00171 word wDelayGame; /*
00172 * Description : Verzögerungstimer
00173 */
00174 
00175 word wPotiWert; /*
00176 * Description : Wert des Potis
00177 */
00178 
00179 word wVorgabeWert; /*
00180 * Description : eingestellter Vorgabewert
00181 */
00182 
00183 int nDiffWert; /*
00184 * Description : Differenz zwischen Vorgabe und Eingang
00185 */
00186 
00187 word wSizeData; /*
00188 * Description : Größe der empfangenen Daten
00189 */
00190 
00191 int zaehler;
00192 
00193 /* Bitmuster */
00194 const byte abZiffer[] = {nZiffer0, nZiffer1, nZiffer2, nZiffer3, nZiffer4, nZiffer5, nZiffer6, nZiffer7, nZiffer8, nZiffer9, nZifferA, nZifferB, nZifferC, nZifferD, nZifferE, nZifferF, nZifferOff};
00195 //const byte abBargraph[] = {~Bit0, ~(Bit0|Bit1), ~(Bit0|Bit1|Bit2), ~(Bit0|Bit1|Bit2|Bit3), 0x0f};
00196 byte abTxBuffer[256];
00197 
00198 
00199 
00200 void vShiftLoad(word wLoad){
00201     word wMask = Bit15;
00202     pinLoad = 0;
00203     while(wMask){
00204         if(wMask & wLoad) pinSdo = 1;
00205         else              pinSdo = 0;
00206         pinSck = 1;
00207         wMask >>= 1;
00208         pinSck = 0;
00209         }    
00210     pinLoad = 1;
00211     }
00212 
00213 
00214 byte abDisplayMemory[] = {16,16,16,16}; /* alle Segmente aus */
00215 
00216 void vDisplayVolt( word w )
00217 {
00218     int16 v;
00219     abDisplayMemory[0] = 16; /* Aus */
00220     v = (byte)(w / 1000);
00221     abDisplayMemory[1] = v; /* Hunderter */
00222     w = w - (v * 1000);
00223     v = (byte)(w / 100);
00224     abDisplayMemory[2] = v; /* Zehner */
00225     w = w - (v * 100);
00226     v = (byte)(w / 10);
00227     abDisplayMemory[3] = v; /* Einer */
00228 }
00229 
00230 void vDisplayDiff( word w )
00231 {
00232     int16 v;
00233     abDisplayMemory[0] = 12; /* "C" */
00234     v = (byte)(w / 1000);
00235     abDisplayMemory[1] = v; /* Hunderter */
00236     w = w - (v * 1000);
00237     v = (byte)(w / 100);
00238     abDisplayMemory[2] = v; /* Zehner */
00239     w = w - (v * 100);
00240     v = (byte)(w / 10);
00241     abDisplayMemory[3] = v; /* Einer */
00242 }
00243 
00244 void vSetForStart( void )
00245 {
00246     abDisplayMemory[0] = 16; /* 7-Segment-Display ausschalten */
00247     abDisplayMemory[1] = 16;
00248     abDisplayMemory[2] = 16;
00249     abDisplayMemory[3] = 16;
00250     bTimerDot = 0;
00251     bDigit = 0;
00252     bMainState = enSchwellenwert;
00253     bDisplayState = enSchwellenwert;
00254     pinBeep = 1;
00255     wVorgabeWert = 0;
00256 }
00257 
00258 /* Tastenabfrage */
00259 void vTasteS1( void ){
00260     if(pinS1 == 0){                             /* User-Taste gedrückt */      
00261         if(bS1Timer < nTastLong+1){             /* Abfrage max. bis Taste lange gedrückt */
00262             if(bS1Timer == nTastShort){         /* Taste "kurz gedrückt" erkannt */
00263                 //...
00264                 }
00265             if(bS1Timer == nTastLong){          /* Taste "lange gedrückt" erkannt */ 
00266                 if(bDisplayState == enSchwellenwert){
00267                     bDisplayState = enVergleich;
00268                     bMainState = enVergleich;
00269                     }
00270                 else{
00271                     bDisplayState = enSchwellenwert;
00272                     bMainState = enSchwellenwert;
00273                     }
00274                 }
00275             bS1Timer++;
00276             }
00277         }
00278     else{                                       /* Taste nicht gedrückt */ 
00279         if(((bS1Timer >= nTastShort) && (bS1Timer <= nTastLong))){             /* Taste wurde bereits erkannt */
00280             if(bDisplayState == enSchwellenwert){
00281                     bDisplayState = enPotiAnzeige; 
00282                     bMainState = enPotiAnzeige;
00283                     }
00284                 else{ 
00285                     bDisplayState = enSchwellenwert;
00286                     bMainState= enSchwellenwert;
00287                     }
00288             }
00289         bS1Timer = 0;
00290         }
00291         
00292     if(abTxBuffer[0] == 'a') {                            /* User-Taste gedrückt */
00293 
00294         for(zaehler=0; zaehler<=250; zaehler++) {                                     /*Zaehlen der Tastatur-Eingabe*/
00295             while(abTxBuffer[zaehler] == abTxBuffer[zaehler+1]) if(abTxBuffer[zaehler] == 'a') bSCounter++;
00296         }
00297 
00298         if(bSCounter < nTastLong+1) {            /* Abfrage max. bis Taste lange gedrückt */
00299             if(bS1Timer == nTastShort) {        /* Taste "kurz gedrückt" erkannt */
00300                 //...
00301             }
00302             if(bSCounter == nTastLong) {         /* Taste "lange gedrückt" erkannt */
00303                 if(bDisplayState == enPotiAnzeige) {
00304                     bDisplayState = enVergleich;
00305                     bMainState = enVergleich;
00306                 } else {
00307                     bDisplayState = enSchwellenwert;
00308                     bMainState = enSchwellenwert;
00309                 }
00310             }
00311         }
00312     } else {                                    /* Taste nicht gedrückt */
00313         if(((bSCounter >= nTastShort) && (bSCounter <= nTastLong))) {            /* Taste wurde bereits erkannt */
00314             if(bDisplayState == enSchwellenwert) {
00315                 bDisplayState = enPotiAnzeige;
00316                 bMainState = enPotiAnzeige;
00317             } else {
00318                 bDisplayState = enSchwellenwert;
00319                 bMainState= enSchwellenwert;
00320             }
00321         }
00322         bSCounter = 0;
00323     }
00324     } 
00325 
00326 void vTasteS2( void ){
00327     if((pinS2 == 0) && bMainState == enSchwellenwert){                             /* User-Taste gedrückt */    
00328         if(bS2Timer < nTastLong+1){             /* Abfrage max. bis Taste lange gedrückt */
00329             if(bS2Timer == nTastShort){         /* Taste "kurz gedrückt" erkannt */
00330                 //...
00331                 }
00332             if(bS2Timer == nTastLong){          /* Taste "lange gedrückt" erkannt */ 
00333                 bTimeLong = 1;
00334                 if(wVorgabeWert >=3200) wVorgabeWert = 3300;
00335                 else wVorgabeWert = wVorgabeWert + 100;
00336                 bS2Timer = bS2Timer - 40;
00337                 }
00338             bS2Timer++;
00339             }
00340         }
00341     else{                                       /* Taste nicht gedrückt */ 
00342         if(((bS2Timer >= nTastShort) && (bS2Timer <= nTastLong))){             /* Taste wurde bereits erkannt */
00343             if(bTimeLong==0){
00344                 if(wVorgabeWert >=3290) wVorgabeWert = 3300;
00345                 else wVorgabeWert = wVorgabeWert + 10;
00346             }
00347             }
00348         bS2Timer = 0;
00349         bTimeLong = 0;
00350         }
00351         
00352     if(abTxBuffer[0] == '+' && bMainState == enSchwellenwert){                             /* User-Taste gedrückt */
00353     
00354         for(zaehler=0; zaehler<=250; zaehler++){                                      /*Zaehlen der Tastatur-Eingabe*/
00355              while(abTxBuffer[zaehler] == abTxBuffer[zaehler+1]) if(abTxBuffer[zaehler] == '+') bSCounter++;
00356          }
00357     
00358         if(bSCounter < nTastLong+1){             /* Abfrage max. bis Taste lange gedrückt */
00359             if(bS2Timer == nTastShort){         /* Taste "kurz gedrückt" erkannt */
00360                 //...
00361                 }
00362             if(bSCounter == nTastLong){          /* Taste "lange gedrückt" erkannt */ 
00363                 bTimeLong = 1;
00364                 if(wVorgabeWert >=3200) wVorgabeWert = 3300;
00365                 else wVorgabeWert = wVorgabeWert + 100;
00366                 bS2Timer = bS2Timer - 40;
00367                 }
00368             }
00369         }
00370     else{                                       /* Taste nicht gedrückt */ 
00371         if((bSCounter >= nTastShort) && (bSCounter <= nTastLong)){             /* Taste wurde bereits erkannt */
00372             if(bTimeLong==0){
00373                 if(wVorgabeWert >=3290) wVorgabeWert = 3300;
00374                 else wVorgabeWert = wVorgabeWert + 10;
00375             }
00376             }
00377         bTimeLong = 0;
00378         bSCounter = 0;
00379         }
00380     } 
00381 
00382 void vTasteS3( void ){
00383     if(pinS3 == 0 && bMainState == enSchwellenwert){                             /* User-Taste gedrückt */
00384         if(bS3Timer < nTastLong+1){             /* Abfrage max. bis Taste lange gedrückt */
00385             if(bS3Timer == nTastShort){         /* Taste "kurz gedrückt" erkannt */
00386                 //...
00387                 }
00388             if(bS3Timer == nTastLong){          /* Taste "lange gedrückt" erkannt */ 
00389                 bTimeLong = 1;
00390                 if(wVorgabeWert <=100) wVorgabeWert = 0;
00391                 else wVorgabeWert = wVorgabeWert - 100;
00392                 bS3Timer = bS3Timer - 40;
00393                 }
00394             bS3Timer++;
00395             }
00396         }
00397     else{                                       /* Taste nicht gedrückt */ 
00398         if((bS3Timer >= nTastShort) && (bS3Timer <= nTastLong)){             /* Taste wurde bereits erkannt */
00399             if(bTimeLong==0){
00400                 if(wVorgabeWert <=10) wVorgabeWert = 0;
00401                 else wVorgabeWert = wVorgabeWert - 10;
00402             }
00403             }
00404         bS3Timer = 0;
00405         bTimeLong = 0;
00406         }
00407     
00408     if(abTxBuffer[0] == '-' && bMainState == enSchwellenwert){                             /* User-Taste gedrückt */
00409     
00410         for(zaehler=0; zaehler<=250; zaehler++){                                      /*Zaehlen der Tastatur-Eingabe*/
00411              while(abTxBuffer[zaehler] == abTxBuffer[zaehler+1]) if(abTxBuffer[zaehler] == '-') bSCounter++;
00412          }
00413     
00414         if(bSCounter < nTastLong+1){             /* Abfrage max. bis Taste lange gedrückt */
00415             if(bS3Timer == nTastShort){         /* Taste "kurz gedrückt" erkannt */
00416                 //...
00417                 }
00418             if(bSCounter == nTastLong){          /* Taste "lange gedrückt" erkannt */ 
00419                 bTimeLong = 1;
00420                 if(wVorgabeWert <=100) wVorgabeWert = 0;
00421                 else wVorgabeWert = wVorgabeWert - 100;
00422                 bS3Timer = bS3Timer - 40;
00423                 }
00424             }
00425         }
00426     else{                                       /* Taste nicht gedrückt */ 
00427         if((bSCounter >= nTastShort) && (bSCounter <= nTastLong)){             /* Taste wurde bereits erkannt */
00428             if(bTimeLong==0){
00429                 if(wVorgabeWert <=10) wVorgabeWert = 0;
00430                 else wVorgabeWert = wVorgabeWert - 10;
00431             }
00432             }
00433         bTimeLong = 0;
00434         bSCounter = 0;
00435         }
00436     } 
00437 
00438 
00439 
00440 void vCheckTasten( void ){
00441     vTasteS1();
00442     vTasteS2();
00443     vTasteS3();
00444     }
00445 void vSegmentDigit( void ) //wichtig!!
00446 {
00447     bDigit++;
00448     wSerial = abZiffer[abDisplayMemory[bDigit&0x03]];
00449     switch(bDisplayState) {
00450         case enSchwellenwert:
00451             bTimerDot++; /* Zähler für Punktwechsel */
00452             vDisplayVolt(wVorgabeWert);
00453             if(bTimerDot == 400) {
00454                 wDelayGame=2*nTastShort;
00455                 bTimerDot = 0;
00456             }
00457             if(wDelayGame!=0){
00458                 if((bDigit&0x03) == 0x01) {
00459                     wSerial = wSerial & ~nSegH; /* Punktanzeigen */
00460                 }  
00461                 wDelayGame--;
00462             }
00463             break;
00464         case enPotiAnzeige:
00465                 vDisplayVolt(wPotiWert);
00466             if((bDigit&0x03) == 0x01) { /* Dezimalpunkt setzen */
00467                 wSerial = wSerial & ~nSegH;
00468             }
00469             break;
00470         case enVergleich:
00471             vDisplayDiff(nDiffWert);
00472             if((bDigit&0x03) == 0x01) { /* Dezimalpunkt setzen */
00473                 wSerial = wSerial & ~nSegH;
00474                 }
00475             break;
00476     }
00477     vShiftLoad(((wSerial << 8) & 0xfff0)| (1 << (bDigit&0x03)));
00478 }
00479 
00480 
00481 
00482 
00483 
00484 
00485 
00486 
00487 
00488 
00489 Serial stComX(D1,D0); /* UART-Kommunikation (Txd(D1)/Rxd(D0)) mit dem PC */
00490  
00491  
00492 byte SYS_vStartComX( word wSize, byte *pData ){ /* Start einer Übertragung */
00493 byte i;
00494 if(wSizeData) i = False;
00495 else{
00496 wSizeData = wSize; /* Anzahl der Sendedaten */
00497 pUartData = pData; /* Zeiger auf diese Daten */
00498 stComX.putc(*pUartData); /* erstes Zeichen senden */
00499 pUartData++;
00500 wSizeData--;
00501 USART2->CR1 |= USART_CR1_TXEIE; /* TXE-Interrupt freigeben */
00502 i = True;
00503 }
00504 return i;
00505 }
00506 
00507 
00508 /* Senderoutine zum COM-Port am PC */
00509 void vIsrTxComX( void ){ /* Senderoutine */
00510 if(stComX.writeable()){ /* Sende-ISR */
00511 if(bSizeData){ /* sind Daten vorhanden ? */
00512 stComX.putc(*pUartData); /* daten senden */
00513 pUartData++;
00514 bSizeData--;
00515 }
00516 else{
00517 USART2->CR1 &= ~USART_CR1_TXEIE; /* Interrupt sperren */
00518 }
00519 }
00520 }
00521 
00522 
00523 /* Empfangsroutine vom COM-Port des PC */
00524 void vIsrRxComX( void ){ /* Empfangsroutine */
00525 if(stComX.readable()){ /* Empfangs-ISR */
00526 abTxBuffer[0] = stComX.getc();
00527 SYS_vStartComX(1, &abTxBuffer[0]);
00528 }
00529 }
00530 
00531 
00532 
00533 
00534 
00535 
00536 
00537 
00538 
00539 /***************************************************************************
00540 *   main()
00541 ***************************************************************************/
00542 int main() {
00543     /* Variablen initialisieren */    
00544     vSetForStart();
00545 
00546 
00547     //Seriel.begin(9600);
00548     
00549    
00550     while(1) {    
00551         wPotiWert = pinPoti*3300;  
00552         vCheckTasten();
00553         nDiffWert = wVorgabeWert - wPotiWert;
00554         
00555         
00556         stComX.attach(&vIsrRxComX, Serial::RxIrq); /* ISR zum Datemempfang vom PC */
00557         stComX.attach(&vIsrTxComX, Serial::TxIrq); /* Sende-ISR */
00558     
00559     
00560         switch(bMainState) {
00561             case enSchwellenwert:
00562                 pinBeep = 1;
00563                 break;
00564             case enPotiAnzeige:
00565                 pinBeep = 1;
00566                 break;
00567             case enVergleich:
00568                 if(nDiffWert<0) pinBeep=0;
00569                 else pinBeep=1;
00570                 break;
00571         }
00572         vSegmentDigit();
00573         wait_us(nCircleTime);
00574     }
00575 }