gnunet-svn
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[cash2ecash] branch master updated: debugging


From: gnunet
Subject: [cash2ecash] branch master updated: debugging
Date: Thu, 02 Jan 2025 19:18:55 +0100

This is an automated email from the git hooks/post-receive script.

manuel-geissbuehler pushed a commit to branch master
in repository cash2ecash.

The following commit(s) were added to refs/heads/master by this push:
     new 45e33f9  debugging
45e33f9 is described below

commit 45e33f9f036797726853e9726d226ae54584366b
Author: Manuel Geissbühler <manuel@debian>
AuthorDate: Thu Jan 2 19:18:42 2025 +0100

    debugging
---
 src/#cash2ecash.cpp#           | 250 +++++++++++++++++++++++++++++++++++++++++
 src/.#cash2ecash.cpp           |   1 +
 src/bank/bankCommunication.hpp |  12 +-
 3 files changed, 257 insertions(+), 6 deletions(-)

diff --git a/src/#cash2ecash.cpp# b/src/#cash2ecash.cpp#
new file mode 100644
index 0000000..02a0472
--- /dev/null
+++ b/src/#cash2ecash.cpp#
@@ -0,0 +1,250 @@
+// This is the main function for the cash2ecash program
+#include <cstdio>
+#include <iostream>
+#include <ostream>
+#include <vector>
+#include <mutex>
+#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;
+
+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;
+  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);
+  bankCommunication.withdrawalRequest(NULL, &amountZero, &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);
+}
+
+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;
+  static struct TALER_Amount confirmedAmount;
+  TALER_string_to_amount("KUDOS:2.0", &confirmedAmount);
+  bankCommunication.withdrawalConfirmReques(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[]){
+  char serialpath[] = "/dev/ttyAMA3";
+  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) {
+    eventHandler();
+    guiDriver();
+  }
+}
+
+
+void guiDriver(){
+  static Timer guiSleep;
+  if (guiSleep.over()){
+    guiSleep.setTimeMillis(gui.timerHandler());
+    guiSleep.start();
+  }
+}
diff --git a/src/.#cash2ecash.cpp b/src/.#cash2ecash.cpp
new file mode 120000
index 0000000..08d23a4
--- /dev/null
+++ b/src/.#cash2ecash.cpp
@@ -0,0 +1 @@
+manuel@debian.5156:1735820266
\ No newline at end of file
diff --git a/src/bank/bankCommunication.hpp b/src/bank/bankCommunication.hpp
index 896663b..11296b2 100644
--- a/src/bank/bankCommunication.hpp
+++ b/src/bank/bankCommunication.hpp
@@ -11,7 +11,7 @@
 class BankCommunication{
   private:
 
-  static const char **status;
+  static const char *status;
 
   static void initCallback(){
     event(EVENT_BANK_TOKEN_DONE);
@@ -26,14 +26,14 @@ class BankCommunication{
   }
 
   static void withdrawalIDInfoRequestCallback(){
-    if  (0 == std::strcmp(*status, "pending")){
+    if  (0 == std::strcmp(status, "pending")){
       event(EVENT_BANK_W_STATUS_PENDING);
-    }else if (0 == std::strcmp(*status, "selected")) {
+    }else if (0 == std::strcmp(status, "selected")) {
       event(EVENT_BANK_W_STATUS_SELECTED);
-    }else if (0 == std::strcmp(*status, "aborted")) {
+    }else if (0 == std::strcmp(status, "aborted")) {
       event(EVENT_BUTTON_ABORT);
     }else{
-      std::cerr << "Unexpected Withdrawal Staus: " << *status << std::endl;
+      std::cerr << "Unexpected Withdrawal Staus: " << status << std::endl;
       exit(EXIT_FAILURE);
     }
   }
@@ -53,7 +53,7 @@ class BankCommunication{
   }
 
   void withrawalStatusRequest(const char *withdrawal_id){
-    bankCommunicationWithdrawalIDInfoRequest(withdrawal_id, status, 
withdrawalIDInfoRequestCallback);
+    bankCommunicationWithdrawalIDInfoRequest(withdrawal_id, &status, 
withdrawalIDInfoRequestCallback);
   }
 };
 

-- 
To stop receiving notification emails like this one, please contact
gnunet@gnunet.org.



reply via email to

[Prev in Thread] Current Thread [Next in Thread]