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