cash2ecash

cash2ecash.cpp (8587B)

---

 // This is the main function for the cash2ecash program
 #include <iostream>
 #include <ostream>
 #include <vector>
 #include <mutex>
 #include "cashacceptors.hpp"
 #include "utils.hpp"
 #include "gui.hpp"
 #include "global.hpp"
 #include "bank.hpp"
 
 // Global Definitions
 enum state_e {
   INIT,
   SLEEP,
   IDLE,
   CONNECTION,
   ACCEPTCASH,
   DONE,
   IDENTIFICATION,
   ENUM_STATE_END
 };
 #define NUMBER_OF_STATES 7
 
 enum state_e state = INIT;
 
 const char *withdrawal_id;
 const char *taler_withdraw_uri;
 
 std::vector<event_e> eventFIFO;
 std::mutex eventFIFOMutex;
 
 
 char hello[] = "hello";
 char world[] = "wold";
 char *string = hello;
 Gui gui;
 Timer withdrawalStatusTimer;
 
 
 ScreenWelcome *screenWelcome = new ScreenWelcome;
 ScreenIdentification *screenIdentification = new ScreenIdentification;
 ScreenConnection  *screenConnection = new ScreenConnection;
 ScreenAcceptCash  *screenAcceptCash = new ScreenAcceptCash(string);
 void guiDriver();
 BankCommunication bankCommunication;
 char serialpath[] = "/dev/ttyAMA3";
 DG600F Cashaccepor(serialpath);
 TALER_Amount confirmedAmount;
 
 typedef void(*action_t)();
 
 typedef struct {
   action_t action;
   state_e nextState;
 } stateEventPair;
 
 stateEventPair stateEventTable[NUMBER_OF_STATES][NUMBER_OF_EVENTS];
 //std::vector< std::vector<stateEventPair> >stateEvent2dVector(6, std::vector<stateEventPair>(4));
 
 
 void actionEventInitialize() {
   std::cout << "Event action initialze called" << std::endl;
   gui.setActiveScreen(screenWelcome);
 }
 
 void actionEventUnexpected(){
   std::cerr << "Event not expected in this state: " << state << std::endl;
 }
 
 void actionEventStart(){
   std::cout << "Action Event Start called" << std::endl;
   //gui.setActiveScreen(screenIdentification);
   gui.setActiveScreen(screenIdentification);
 }
 
 void actionEventAbortIdent(){
   std::cout << "Action Event Abort Ident called" << std::endl;
   gui.setActiveScreen(screenWelcome);
 }
 
 void actionEventAbortConnection(){
   std::cout << "Action Abort Connection called" << std::endl;
   gui.setActiveScreen(screenWelcome);
 }
 
 void actionEventFinishCashin(){
   std::cout << "Action Event Finish Cashin called" << std::endl;
   Cashaccepor.readAccumulated(&confirmedAmount);
   Cashaccepor.stopMoneyAcceptance();
   bankCommunication.withdrawalConfirmRequest(withdrawal_id, &confirmedAmount);
   gui.setActiveScreen(screenWelcome);
 }
 
 void actionEventSleep() { std::cout << "Action Event xx called" << std::endl; }
 
 void actionEventWakeup() { std::cout << "Action Event xx called" << std::endl; }
 
 void actionEventIdentificationSuccess(){
   std::cout << "Action Event Identification Success called" << std::endl;
   gui.setActiveScreen(screenConnection);
   bankCommunication.init();
 }
 
 void actionEventBankTokenDone(){
   std::cout << "Action Event Bank Token Done called" << std::endl;
   //static struct TALER_Amount amountZero;
   //TALER_amount_set_zero("KUDOS", &amountZero);
   //amountZero.fraction = 5000000;
   static bool noAmountToWallet = true;
   bankCommunication.withdrawalRequest(NULL, NULL, &noAmountToWallet, &withdrawal_id, &taler_withdraw_uri);
 }
 
 void actionEventBankWithdrawalDone(){
   std::cout << "Action Event Bank Withdrawal Done called" << std::endl;
   screenConnection->generateQR(taler_withdraw_uri);
   bankCommunication.withrawalStatusRequest(withdrawal_id);
 }
 
 void actionEventBankWStatusSelected(){
   std::cout << "Action Event Bank Withdrawal Status Confirmed called" << std::endl;
   gui.setActiveScreen(screenAcceptCash);
   Cashaccepor.startMoneyAcceptance();
 }
 
 void actionEventBankWStatusPending(){
   std::cout << "Action Event Bank Withdrawal Status Pending called" << std::endl;
   bankCommunication.withrawalStatusRequest(withdrawal_id);
 }
 
 void actionEventWConfirmationDone(){
   std::cout << "Action Event Bank Confirmation Done called" << std::endl;
   gui.setActiveScreen(screenWelcome);
 }
 
 void actionEventIdentificationTimeout(){
   std::cout << "Action Event Identification Timeout called" << std::endl;
   gui.setActiveScreen(screenWelcome);
 }
 
 void actionEventAcceptCashTimeout(){
   std::cout << "Action Event Acceptcash Timeout called" << std::endl;
   Cashaccepor.readAccumulated(&confirmedAmount);
   Cashaccepor.stopMoneyAcceptance();
   bankCommunication.withdrawalConfirmRequest(withdrawal_id, &confirmedAmount);
 }
 
 void actionEventConnectionTimeout(){
   std::cout << "Action Event Connection Timeout called" << std::endl;
   gui.setActiveScreen(screenWelcome);
 }
 
 void actionEventDoneTimeout() {
   std::cout << "Action Event Done Timeout called" << std::endl;
   gui.setActiveScreen(screenWelcome);
 }
 
 
 
 
 void initStateEvent(){
   //Runtime initialzation is used due to convienient array indexing.
   //Initzialize all state-event pairs to handleuUnexpectedEvent
   int state, event;
   for (state = 0; state < ENUM_STATE_END; state++) {
     for (event = 0; event < ENUM_EVENT_END; event++) {
       stateEventTable[state][event].action = &actionEventUnexpected;
       stateEventTable[state][event].nextState = (state_e)state;
     }
   }
 
   //Overwrite desired state-event pairs to provide actual functionality
   stateEventTable[INIT][EVENT_INITIALIZE].action = actionEventInitialize;
   stateEventTable[INIT][EVENT_INITIALIZE].nextState = IDLE;
   stateEventTable[IDLE][EVENT_BUTTON_START].action = actionEventStart;
   stateEventTable[IDLE][EVENT_BUTTON_START].nextState = IDENTIFICATION; //needs to be changed to initialization later
   stateEventTable[IDLE][EVENT_SLEEP].action = actionEventSleep;
   stateEventTable[IDLE][EVENT_SLEEP].nextState = SLEEP;
   
   stateEventTable[SLEEP][EVENT_WAKEUP].action = actionEventWakeup;
   stateEventTable[SLEEP][EVENT_WAKEUP].nextState = IDLE;
   
   stateEventTable[IDENTIFICATION][EVENT_BUTTON_ABORT].action = actionEventAbortIdent;
   stateEventTable[IDENTIFICATION][EVENT_BUTTON_ABORT].nextState = IDLE;
   stateEventTable[IDENTIFICATION][EVENT_IDENTIFICATION_SUCCESS].action = actionEventIdentificationSuccess;
   stateEventTable[IDENTIFICATION][EVENT_IDENTIFICATION_SUCCESS].nextState = CONNECTION;
   stateEventTable[IDENTIFICATION][EVENT_TIMEOUT].action = actionEventIdentificationTimeout;
   stateEventTable[IDENTIFICATION][EVENT_TIMEOUT].nextState = IDLE;
 
   stateEventTable[CONNECTION][EVENT_BUTTON_ABORT].action = actionEventAbortConnection;
   stateEventTable[CONNECTION][EVENT_BUTTON_ABORT].nextState = IDLE;
   stateEventTable[CONNECTION][EVENT_BANK_TOKEN_DONE].action = actionEventBankTokenDone;
   stateEventTable[CONNECTION][EVENT_BANK_TOKEN_DONE].nextState = CONNECTION;
   stateEventTable[CONNECTION][EVENT_BANK_WITHDRAWAL_DONE].action = actionEventBankWithdrawalDone;
   stateEventTable[CONNECTION][EVENT_BANK_WITHDRAWAL_DONE].nextState = CONNECTION;
   stateEventTable[CONNECTION][EVENT_BANK_W_STATUS_PENDING].action = actionEventBankWStatusPending;
   stateEventTable[CONNECTION][EVENT_BANK_W_STATUS_PENDING].nextState = CONNECTION;
   stateEventTable[CONNECTION][EVENT_BANK_W_STATUS_SELECTED].action = actionEventBankWStatusSelected;
   stateEventTable[CONNECTION][EVENT_BANK_W_STATUS_SELECTED].nextState = ACCEPTCASH;
   stateEventTable[CONNECTION][EVENT_TIMEOUT].action = actionEventConnectionTimeout;
   stateEventTable[CONNECTION][EVENT_TIMEOUT].nextState = IDLE;
   
   stateEventTable[ACCEPTCASH][EVENT_BUTTON_FINISH_CASHIN].action = actionEventFinishCashin;
   stateEventTable[ACCEPTCASH][EVENT_BUTTON_FINISH_CASHIN].nextState = DONE;
   stateEventTable[ACCEPTCASH][EVENT_TIMEOUT].action = actionEventAcceptCashTimeout;
   stateEventTable[ACCEPTCASH][EVENT_TIMEOUT].nextState = DONE;
   stateEventTable[DONE][EVENT_TIMEOUT].action = actionEventDoneTimeout;
   stateEventTable[DONE][EVENT_TIMEOUT].nextState = IDLE;
 }
 
 
 void event(event_e event){
   eventFIFOMutex.lock();
   eventFIFO.push_back(event);
   eventFIFOMutex.unlock();
 }
 
 void eventHandler(){
   state_e oldstate;
   event_e event;
   eventFIFOMutex.lock();
   while (0 < eventFIFO.size()) {
     oldstate = state;
     event = eventFIFO.front();
     eventFIFOMutex.unlock();
     state = stateEventTable[state][event].nextState;
     stateEventTable[oldstate][event].action();
     eventFIFOMutex.lock();
     eventFIFO.erase(eventFIFO.begin());
   }
   eventFIFOMutex.unlock();
 }
 
 int main(int argc, char *argv[]){
   
   std::cout << "The Program is running" <<std::endl;
   Timer timer1;
   timer1.setTimeMillis(10000);
   TALER_Amount testamount;
 
   //Initialize State Machine
   initStateEvent();
   
   //Trigger Initialzation Event
   event(EVENT_INITIALIZE);
   
   while (true) {
     guiDriver();
     eventHandler();
   }
 }
 
 
 void guiDriver(){
   static Timer guiSleep;
   if (guiSleep.over()){
     guiSleep.setTimeMillis(gui.timerHandler());
     guiSleep.start();
   }
 }