HAPO WS22 / Mbed 2 deprecated HAPO_WS22_Labor3_1

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Dependencies:   mbed

main.cpp

Committer:
alexander0707
Date:
2022-12-04
Revision:
7:94c73e4168d8
Parent:
6:4e55101c65f4
Child:
8:6f91c39dbabc

File content as of revision 7:94c73e4168d8:

/***************************************************************************
* Titel        : main.cpp
*
* Description  : Labormodul "HAPOA"
*
* Revision List:
  --------------------------------------------------------------------------
  Date     | Author          | Change
  --------------------------------------------------------------------------
  24.10.22 | J. Altenburg    | Ersterstellung
  --------------------------------------------------------------------------
           |                 |
  ---------------------------------------------------------------------------
  
  Editor List:
  --------------------------------------------------------------------------
  Date     | Author          | Change
  --------------------------------------------------------------------------
  30.11.22 |Tobias Zinke     | Labor03
  --------------------------------------------------------------------------
  30.11.22 |Alexander Pitthan| Labor03
  ---------------------------------------------------------------------------
****************************************************************************/
#include "mbed.h"
#include "cdef.h"

AnalogIn    pinPoti (A0);

/* Vereinbarungen zu den Tasteneingängen */
DigitalIn   pinS1(A1);
DigitalIn   pinS2(A2);
DigitalIn   pinS3(A3);

BusOut      bLedShield(D10, D11, D12, D13);

/* Anschlüsse der Schieberegister */
DigitalOut  pinSdo(PA_9);
DigitalOut  pinSck(PA_8);
DigitalOut  pinLoad(PB_5);
DigitalOut  pinBeep(PB_3);

/* ISR */
Ticker      stTimer;

/***************************************************************************
*   Defines und Makros                                                       *
***************************************************************************/
#define nTastShort  20      /* Taste 50 Millisekunden gedrückt */    
#define nTastLong   600     /* Taste 1.5 Sekunden gedrückt */ 
#define nCircleTime 2500    /* Laufzeit der Main in us */

#define nSegA           0x01
#define nSegB           0x02
#define nSegC           0x04
#define nSegD           0x08
#define nSegE           0x10
#define nSegF           0x20
#define nSegG           0x40
#define nSegH           0x80

#define nZiffer0    ~(nSegA | nSegB | nSegC | nSegD | nSegE | nSegF)
#define nZiffer1    ~(nSegB | nSegC)
#define nZiffer2    ~(nSegA | nSegB | nSegD | nSegE | nSegG)
#define nZiffer3    ~(nSegA | nSegB | nSegC | nSegD | nSegG)
#define nZiffer4    ~(nSegB | nSegC | nSegF | nSegG)
#define nZiffer5    ~(nSegA | nSegC | nSegD | nSegF | nSegG)
#define nZiffer6    ~(nSegA | nSegC | nSegD | nSegE | nSegF | nSegG)
#define nZiffer7    ~(nSegA | nSegB | nSegC)
#define nZiffer8    ~(nSegA | nSegB | nSegC | nSegD | nSegE | nSegF | nSegG)
#define nZiffer9    ~(nSegA | nSegB | nSegC | nSegD | nSegF | nSegG)
#define nZifferA    ~(nSegA | nSegB | nSegC | nSegE | nSegF | nSegG)
#define nZifferB    ~(nSegC | nSegD | nSegE | nSegF | nSegG)
#define nZifferC    ~(nSegA | nSegD | nSegE | nSegF)
#define nZifferD    ~(nSegB | nSegC | nSegD | nSegE | nSegG)
#define nZifferE    ~(nSegA | nSegD | nSegE | nSegF | nSegG)
#define nZifferF    ~(nSegA | nSegE | nSegF | nSegG)
#define nZifferOff   (nSegA | nSegB | nSegC | nSegD | nSegE | nSegF | nSegG | nSegH)

byte bIdx; /*
* Description : Index auf Ausgabe
*/

byte bDigit; /*
* Description : aktives Digit
*/

byte bBargraph; /*
* Description : Bargraph durchschalten
*/

byte bS1Timer; /*
* Description : Timer für Taste S1
*/

byte bS2Timer; /*
* Description : Timer für Taste S2
*/

byte bS3Timer; /*
* Description : Timer für Taste S3
*/

byte bDisplayState; /*
* Description : 
*/
const byte enSchwellenwert=0x00;
const byte enPotiAnzeige = 0x01;
const byte enVergleich = 0x02;
//const byte enShowError = 0x03;
//const byte enWaitForRun = 0x04;


byte bState; /*
* Description : 
*/

byte bTimerDot; /*
* Description : Zähler für Dots
*/

byte bHotKey; /*
* Description : Auswahl der Taste
*/

byte bDisplayDot; /*
* Description : 
*/

byte bMainState; /*
* Description : Hauptzustand
*/

byte bBeepTime; /*
* Description : Tondauer 
*/

byte bEinstellungsModus;/*
* Description : Einstellungszustand 
*/

byte bSchwellenwertVergleich;/*
* Description : Einstellungszustand 
*/

byte bTimeLong;/*
* Description : Ob Taste bereits lange gedrückt war 
*/


word wSerial; /*
* Description : serielles Ausgaberegister
*/

word wClockTime; /*
*Description : Timer für verstrichene Zeit
*/

word wClockShow; /*
*Description : Timer für verstrichene Zeit
*/

word wDelayGame; /*
* Description : Verzögerungstimer
*/

word wPotiWert; /*
* Description : Wert des Potis
*/

word wVorgabeWert; /*
* Description : engestellter Vorgabewert
*/

word wDiffWert; /*
* Description : Differenz zwischen Vorgabe und Eingang
*/

/* Bitmuster */
const byte abZiffer[] = {nZiffer0, nZiffer1, nZiffer2, nZiffer3, nZiffer4, nZiffer5, nZiffer6, nZiffer7, nZiffer8, nZiffer9, nZifferA, nZifferB, nZifferC, nZifferD, nZifferE, nZifferF, nZifferOff};
const byte abBargraph[] = {~Bit0, ~(Bit0|Bit1), ~(Bit0|Bit1|Bit2), ~(Bit0|Bit1|Bit2|Bit3), 0x0f};


void vShiftLoad(word wLoad){
    word wMask = Bit15;
    pinLoad = 0;
    while(wMask){
        if(wMask & wLoad) pinSdo = 1;
        else              pinSdo = 0;
        pinSck = 1;
        wMask >>= 1;
        pinSck = 0;
        }    
    pinLoad = 1;
    }


byte abDisplayMemory[] = {16,16,16,16}; /* alle Segmente aus */

void vDisplayVolt( word w )
{
    int16 v;
    abDisplayMemory[0] = 16; /* Aus */
    v = (byte)(w / 100);
    abDisplayMemory[1] = v; /* Hunderter */
    w = w - (v * 100);
    v = (byte)(w / 10);
    abDisplayMemory[2] = v; /* Zehner */
    w = w - (v * 10);
    abDisplayMemory[3] = (byte)w; /* Einer */
}

void vDisplayDiff( word w )
{
    int16 v;
    abDisplayMemory[0] = 12; /* "C" */
    v = (byte)(w / 100);
    abDisplayMemory[1] = v; /* Hunderter */
    w = w - (v * 100);
    v = (byte)(w / 10);
    abDisplayMemory[2] = v; /* Zehner */
    w = w - (v * 10);
    abDisplayMemory[3] = (byte)w; /* Einer */
}

void vSetForStart( void )
{
    abDisplayMemory[0] = 16; /* 7-Segment-Display ausschalten */
    abDisplayMemory[1] = 16;
    abDisplayMemory[2] = 16;
    abDisplayMemory[3] = 16;
    bTimerDot = 0;
    bDigit = 0;
    bMainState = enSchwellenwert;
    bDisplayState = enSchwellenwert;
    pinBeep = 1;
    wVorgabeWert = 0;
}
/*
void vSetRunClock( void )
{
    wClockTime = 0;
    bDigit = 0;
    abDisplayMemory[0] = 16; 7-Segment-Display ausschalten 
    abDisplayMemory[1] = 0;
    abDisplayMemory[2] = 0;
    abDisplayMemory[3] = 0;
    bDisplayState = enRunClock;
}
*/
/*
byte bCheckTasten( byte bState )
{
    if((pinS1 == 0) || (pinS2 == 0) || (pinS3 == 0)) {  Tastendruck erkannt 
        wClockShow = 1200;
        if((pinS1 == 0) && (bHotKey == 0)) {
            wDelayGame = 0;
            bState = enShowResult;
            bDisplayState = enShowResult;
        } else if((pinS2 == 0) && (bHotKey == 1)) {
            wDelayGame = 0;
            bState = enShowResult;
            bDisplayState = enShowResult;
        } else if((pinS3 == 0) && (bHotKey == 2)) {
            wDelayGame = 0;
            bState = enShowResult;
            bDisplayState = enShowResult;
        } else {
            wDelayGame = 200;
            abDisplayMemory[1] = 15;
            abDisplayMemory[2] = 15;
            abDisplayMemory[3] = 15;
            bState = enShowError;
            bDisplayState = enShowResult;
            pinBeep = 0;
        }
    }
    return bState;
}
*/
/* Tastenabfrage */
void vTasteS1( void ){
    if(pinS1 == 0){                             /* User-Taste gedrückt */
        if(bS1Timer < nTastLong+1){             /* Abfrage max. bis Taste lange gedrückt */
            if(bS1Timer == nTastShort){         /* Taste "kurz gedrückt" erkannt */
                //...
                }
            if(bS1Timer == nTastLong){          /* Taste "lange gedrückt" erkannt */ 
                if(bDisplayState == enSchwellenwert || bDisplayState == enPotiAnzeige){
                    bDisplayState = enVergleich;
                    bMainState = enVergleich;
                    }
                else{
                    bDisplayState = enSchwellenwert;
                    bMainState = enSchwellenwert;
                    }
                }
            bS1Timer++;
            }
        }
    else{                                       /* Taste nicht gedrückt */ 
        if((bS1Timer >= nTastShort) && (bS1Timer <= nTastLong)){             /* Taste wurde bereits erkannt */
            if(bDisplayState == enSchwellenwert){
                    bDisplayState = enPotiAnzeige; 
                    bMainState = enPotiAnzeige;
                    }
                else{ 
                    bDisplayState = enSchwellenwert;
                    bMainState= enSchwellenwert;
                    }
            }
        bS1Timer = 0;
        }
    } 

void vTasteS2( void ){
    if(pinS2 == 0){                             /* User-Taste gedrückt */
        if(bS2Timer < nTastLong+1){             /* Abfrage max. bis Taste lange gedrückt */
            if(bS2Timer == nTastShort){         /* Taste "kurz gedrückt" erkannt */
                //...
                }
            if(bS2Timer == nTastLong){          /* Taste "lange gedrückt" erkannt */ 
                bTimeLong = 1;
                wVorgabeWert += 100;
                bS2Timer -= 40;
                }
            bS2Timer++;
            }
        }
    else{                                       /* Taste nicht gedrückt */ 
        if((bS2Timer >= nTastShort) && (bS2Timer <= nTastLong)){             /* Taste wurde bereits erkannt */
            if(bTimeLong==1) wVorgabeWert += 10;
            }
        bS2Timer = 0;
        bTimeLong= 0;
        }
    } 

void vTasteS3( void ){
    if(pinS3 == 0){                             /* User-Taste gedrückt */
        if(bS3Timer < nTastLong+1){             /* Abfrage max. bis Taste lange gedrückt */
            if(bS3Timer == nTastShort){         /* Taste "kurz gedrückt" erkannt */
                //...
                }
            if(bS3Timer == nTastLong){          /* Taste "lange gedrückt" erkannt */ 
                bTimeLong = 1;
                wVorgabeWert -= 100;
                bS2Timer -= 40;
                }
            bS3Timer++;
            }
        }
    else{                                       /* Taste nicht gedrückt */ 
        if((bS3Timer >= nTastShort) && (bS3Timer <= nTastLong)){             /* Taste wurde bereits erkannt */
            if(bTimeLong==1) wVorgabeWert += 10;
            }
        bS3Timer = 0;
        bTimeLong= 0;
        }
    } 



void vCheckTasten( void ){
    vTasteS1();
    vTasteS2();
    vTasteS3();
    }
void vSegmentDigit( void ) //wichtig!!
{
    bDigit++;
    wSerial = abZiffer[abDisplayMemory[bDigit&0x03]];
    switch(bDisplayState) {
        case enSchwellenwert:
            bTimerDot++; /* Zähler für Punktwechsel */
            vDisplayVolt(wVorgabeWert);
            if(bTimerDot == 400) {
                if((bDigit&0x03) == 0x01) {
                    wSerial = wSerial & ~nSegH; /* Punktanzeigen */
                }
                bTimerDot = 0;
            }
            break;
        case enPotiAnzeige:
                vDisplayVolt(wPotiWert);
            if((bDigit&0x03) == 0x01) { /* Dezimalpunkt setzen */
                wSerial = wSerial & ~nSegH;
            }
            break;
        case enVergleich:
            vDisplayDiff(wDiffWert);
            if((bDigit&0x03) == 0x01) { /* Dezimalpunkt setzen */
                wSerial = wSerial & ~nSegH;
                }
            break;
    }
    vShiftLoad(((wSerial << 8) & 0xfff0)| (1 << (bDigit&0x03)));
}


/***************************************************************************
*   main()
***************************************************************************/
int main() {
    /* Variablen initialisieren */    
    vSetForStart();
    
    //Seriel.begin(9600);
    
    while(1) {    
        wPotiWert = pinPoti*3,3;    
        vCheckTasten();
        wDiffWert = wVorgabeWert - wPotiWert;
        switch(bMainState) {
            case enSchwellenwert:
                if(wVorgabeWert>3300){
                    wVorgabeWert=3300;
                }
                if(wVorgabeWert<0){
                    wVorgabeWert=0;
                }
                break;
            case enPotiAnzeige:
                break;
            case enVergleich:
                if(wDiffWert<0) pinBeep=0;
                else pinBeep=1;
                break;
        }
        vSegmentDigit();
        wait_us(nCircleTime);
    }
}