Facebook

Untitled safest cryptocurrency exchange

From xbary, 5 Years ago, written in C++.
URL https://pastebin.pl/view/d62218ad
Embed
Download Paste or View Raw
Hits: 216
  1. #include "xb_CAYENNE_MOD.h"
  2. #include <xb_board.h>
  3. #include <xb_GUI_Gadget.h>
  4. #include <xb_GUI.h>
  5. #include <Preferences.h>
  6. #include <CAYENNEMQTTESP32.h>
  7.  
  8. CayenneMQTTWiFiClient *Cayenne;
  9.  
  10. CAYENNE_IN_DEFAULT()
  11. {
  12.         board.Log(String("Request channel "+String(request.channel)).c_str(),true,true);
  13.         board.Log(String("Request Value " + String(getValue.asStr())).c_str(), true, true);
  14. }
  15.  
  16. CAYENNE_OUT_DEFAULT()
  17. {
  18.         Cayenne->digitalSensorWrite(20, 1);
  19. }
  20.  
  21.  
  22. TCayenneFrameItem *CayenneFrameItemList;
  23. uint32_t CayenneFrameItemList_Count;
  24.  
  25.  
  26. TIDROM ChannelAsIDROM[CAYENNE_CHANNELS_USE];
  27.  
  28. bool XB_CAYENNE_MOD_DoMessage(TMessageBoard *Am);
  29. void XB_CAYENNE_MOD_Setup();
  30. uint32_t XB_CAYENNE_MOD_DoLoop();
  31.  
  32. TTaskDef XB_CAYENNE_MOD_DefTask = { &XB_CAYENNE_MOD_Setup,&XB_CAYENNE_MOD_DoLoop,&XB_CAYENNE_MOD_DoMessage,NULL,1 };
  33.  
  34. typedef enum { fscIDLE, fscLoadConfig, fscInit, fscDeInit, fscConnected } TFunctionStepCAYENNE_MOD;
  35. TFunctionStepCAYENNE_MOD  FunctionStepCAYENNE_MOD;
  36. bool XB_CAYENNE_MOD_DEBUG = true;
  37.  
  38. Preferences cfg;
  39. String CAYENNE_MOD_MQTT_USERNAME;
  40. String CAYENNE_MOD_MQTT_PASSWORD;
  41. String CAYENNE_MOD_CLIENTID;
  42. String CAYENNE_MOD_MQTT_SERVER;
  43. uint16_t CAYENNE_MOD_MQTT_PORT;
  44.  
  45. TCayenneFrameItem *XB_CAYENNE_MOD_NEW_TCayenneFrameItem()
  46. {
  47.         TCayenneFrameItem *cfi = (TCayenneFrameItem *)board.malloc_psram(sizeof(TCayenneFrameItem));
  48.         if (cfi != NULL)
  49.         {
  50.                 ADD_TO_LIST_STR(CayenneFrameItemList, TCayenneFrameItem, cfi);
  51.                 CayenneFrameItemList_Count++;
  52.         }
  53.         return cfi;
  54. }
  55.  
  56. void XB_CAYENNE_MOD_DELETE_TCayenneFrameItem(TCayenneFrameItem *Acfi)
  57. {
  58.         if (Acfi != NULL)
  59.         {
  60.                 DELETE_FROM_LIST_STR(CayenneFrameItemList, Acfi);
  61.                 board.free(Acfi);
  62.                 CayenneFrameItemList_Count--;
  63.         }
  64. }
  65.  
  66. void XB_CAYENNE_MOD_SetupServer()
  67. {
  68.         if (Cayenne != NULL)
  69.         {
  70.                 delete(Cayenne);
  71.                 Cayenne = NULL;
  72.         }
  73.         Cayenne = new CayenneMQTTWiFiClient();
  74.         Cayenne->begin(CAYENNE_MOD_MQTT_USERNAME.c_str(), CAYENNE_MOD_MQTT_PASSWORD.c_str(), CAYENNE_MOD_CLIENTID.c_str());
  75. }
  76.  
  77. bool XB_CAYENNE_MOD_LoopServer()
  78. {
  79.         Cayenne->loop();
  80.         return true;
  81. }
  82.  
  83. uint8_t XB_CAYENNE_MOD_GetChannelByIDROM(TIDROM Aidrom)
  84. {
  85.         uint8_t res = 255;
  86.  
  87.         for (uint8_t i = 0; i < CAYENNE_CHANNELS_USE; i++)
  88.         {
  89.                 if (Aidrom.ROM == ChannelAsIDROM[i].ROM)
  90.                 {
  91.                         res = i;
  92.                         break;
  93.                 }
  94.         }
  95.         return res;
  96. }
  97.  
  98. uint8_t XB_CAYENNE_MOD_GetFreeChannel()
  99. {
  100.         uint8_t res = 255;
  101.  
  102.         for (uint8_t i = 0; i < CAYENNE_CHANNELS_USE; i++)
  103.         {
  104.                 if (ChannelAsIDROM[i].ROM==0)
  105.                 {
  106.                         res = i;
  107.                         break;
  108.                 }
  109.         }
  110.         return res;
  111. }
  112.  
  113. void XB_CAYENNE_MOD_ClearChannelAsIDROM()
  114. {
  115.         if (XB_CAYENNE_MOD_DEBUG) board.Log("Clear Channel as IDROM table", true, true);
  116.  
  117.         for (uint8_t i = 0; i < CAYENNE_CHANNELS_USE; i++)
  118.         {
  119.                 if (XB_CAYENNE_MOD_DEBUG) board.Log('.');
  120.                 ChannelAsIDROM[i].ROM = 0;
  121.         }
  122.  
  123.         if (XB_CAYENNE_MOD_DEBUG) board.Log("OK");
  124. }
  125.  
  126. bool XB_CAYENNE_MOD_LoadConfig()
  127. {
  128.         if (XB_CAYENNE_MOD_DEBUG) board.Log(FSS("Load config"), true, true);
  129.         cfg.begin("CAYENNE_MOD");
  130.         if (XB_CAYENNE_MOD_DEBUG) board.Log('.');
  131.         CAYENNE_MOD_MQTT_USERNAME = cfg.getString("MQTT_USERNAME", CAYENNE_DEFAULT_MQTT_USERNAME);
  132.         if (XB_CAYENNE_MOD_DEBUG) board.Log('.');
  133.         CAYENNE_MOD_MQTT_PASSWORD = cfg.getString("MQTT_PASSWORD", CAYENNE_DEFAULT_MQTT_PASSWORD);
  134.         if (XB_CAYENNE_MOD_DEBUG) board.Log('.');
  135.         CAYENNE_MOD_CLIENTID = cfg.getString("CLIENTID", CAYENNE_DEFAULT_CLIENTID);
  136.         if (XB_CAYENNE_MOD_DEBUG) board.Log('.');
  137.         CAYENNE_MOD_MQTT_SERVER = cfg.getString("MQTT_SERVER", CAYENNE_DEFAULT_MQTT_SERVER);
  138.         if (XB_CAYENNE_MOD_DEBUG) board.Log('.');
  139.         CAYENNE_MOD_MQTT_PORT = cfg.getUShort("MQTT_PORT", CAYENNE_DEFAULT_MQTT_PORT);
  140.         cfg.getBytes("ChannelAsIDROM", &ChannelAsIDROM, sizeof(ChannelAsIDROM));
  141.         cfg.end();
  142.         if (XB_CAYENNE_MOD_DEBUG) board.Log(FSS("OK"));
  143.         return true;
  144. }
  145.  
  146. bool XB_CAYENNE_MOD_SaveConfig()
  147. {
  148.         if (XB_CAYENNE_MOD_DEBUG) board.Log(FSS("Save config"), true, true);
  149.         cfg.begin("CAYENNE_MOD");
  150.         if (XB_CAYENNE_MOD_DEBUG) board.Log('.');
  151.         cfg.putString("MQTT_USERNAME", CAYENNE_MOD_MQTT_USERNAME);
  152.         if (XB_CAYENNE_MOD_DEBUG) board.Log('.');
  153.         cfg.putString("MQTT_PASSWORD", CAYENNE_MOD_MQTT_PASSWORD);
  154.         if (XB_CAYENNE_MOD_DEBUG) board.Log('.');
  155.         cfg.putString("CLIENTID", CAYENNE_MOD_CLIENTID);
  156.         if (XB_CAYENNE_MOD_DEBUG) board.Log('.');
  157.         cfg.putString("MQTT_SERVER", CAYENNE_MOD_MQTT_SERVER);
  158.         if (XB_CAYENNE_MOD_DEBUG) board.Log('.');
  159.         cfg.putUShort("MQTT_PORT", CAYENNE_MOD_MQTT_PORT);
  160.         if (XB_CAYENNE_MOD_DEBUG) board.Log('.');
  161.         cfg.putBytes("ChannelAsIDROM", &ChannelAsIDROM, sizeof(ChannelAsIDROM));
  162.         if (XB_CAYENNE_MOD_DEBUG) board.Log('.');
  163.         cfg.end();
  164.         if (XB_CAYENNE_MOD_DEBUG) board.Log(FSS("OK"));
  165.         return true;
  166. }
  167.  
  168. void XB_CAYENNE_MOD_Setup()
  169. {
  170.         board.Log(FSS("Init."), true, true, &XB_CAYENNE_MOD_DefTask);
  171.         FunctionStepCAYENNE_MOD = fscLoadConfig;
  172.         board.Log(FSS("..OK"));
  173. }
  174.  
  175. uint32_t XB_CAYENNE_MOD_DoLoop()
  176. {
  177.         switch (FunctionStepCAYENNE_MOD)
  178.         {
  179.         case fscIDLE:
  180.         {
  181.                 return 5000;
  182.         }
  183.         case fscLoadConfig:
  184.         {
  185.                 XB_CAYENNE_MOD_LoadConfig();
  186.                 FunctionStepCAYENNE_MOD = fscIDLE;
  187.                 break;
  188.         }
  189.         case fscInit:
  190.         {
  191.                 if (XB_CAYENNE_MOD_DEBUG) board.Log("Connect..", true, true);
  192.                 XB_CAYENNE_MOD_SetupServer();
  193.                 if (XB_CAYENNE_MOD_DEBUG) board.Log(".OK");
  194.                 FunctionStepCAYENNE_MOD = fscConnected;
  195.                 return 10;
  196.         }
  197.         case fscDeInit:
  198.         {
  199.                 if (XB_CAYENNE_MOD_DEBUG) board.Log("Internet is disconnect, Wait for connection...", true, true);
  200.  
  201.                 if (!NetworkConnected(&Cayenne->_network) || !CayenneMQTTConnected(&Cayenne->_mqttClient))
  202.                 {
  203.                         CayenneMQTTDisconnect(&Cayenne->_mqttClient);
  204.                         NetworkDisconnect(&Cayenne->_network);
  205.                 }
  206.  
  207.                 delete(Cayenne);
  208.                 Cayenne = NULL;
  209.                 FunctionStepCAYENNE_MOD = fscIDLE;
  210.                 return 0;
  211.         }
  212.         case fscConnected:
  213.         {
  214.                 DEF_WAITMS_VAR(ccl);
  215.                 BEGIN_WAITMS(ccl,100)
  216.                 {
  217.                         if (NetworkConnected(&Cayenne->_network) && CayenneMQTTConnected(&Cayenne->_mqttClient))
  218.                         {
  219.                                 MQTTYield(&Cayenne->_mqttClient.mqttClient, 10);
  220.                                 TCayenneFrameItem *CayenneFrameItem = CayenneFrameItemList;
  221.                                 if (CayenneFrameItem != NULL)
  222.                                 {
  223.                                         switch (CayenneFrameItem->CayenneFrameTransport.type)
  224.                                         {
  225.                                         case ctfSetChannel:
  226.                                         {
  227.                                                 uint8_t Channel = CayenneFrameItem->CayenneFrameTransport.Data.SetChannel.Channel;
  228.                                                 if ((Channel == 255) || (Channel >= CAYENNE_CHANNELS_USE))
  229.                                                 {
  230.                                                         Channel = XB_CAYENNE_MOD_GetChannelByIDROM(CayenneFrameItem->CayenneFrameTransport.Data.SetChannel.idrom);
  231.                                                         if (Channel == 255)
  232.                                                         {
  233.                                                                 Channel = XB_CAYENNE_MOD_GetFreeChannel();
  234.                                                                 if (Channel == 255)
  235.                                                                 {
  236.                                                                         XB_CAYENNE_MOD_DELETE_TCayenneFrameItem(CayenneFrameItem);
  237.                                                                         break;
  238.                                                                 }
  239.                                                                 ChannelAsIDROM[Channel].ROM = CayenneFrameItem->CayenneFrameTransport.Data.SetChannel.idrom.ROM;
  240.                                                         }
  241.                                                 }
  242.                                                 else
  243.                                                 {
  244.                                                         ChannelAsIDROM[Channel].ROM = CayenneFrameItem->CayenneFrameTransport.Data.SetChannel.idrom.ROM;
  245.                                                 }
  246.  
  247.                                                 switch (CayenneFrameItem->CayenneFrameTransport.Data.SetChannel.SensorValue.Type)
  248.                                                 {
  249.                                                 case svtTemperature:
  250.                                                 {
  251.                                                         if (Cayenne == NULL) XB_CAYENNE_MOD_SetupServer();
  252.                                                         Cayenne->celsiusWrite(Channel, CayenneFrameItem->CayenneFrameTransport.Data.SetChannel.SensorValue.Data.Temperature);
  253.                                                         break;
  254.                                                 }
  255.                                                 default:
  256.                                                 {
  257.                                                         if (XB_CAYENNE_MOD_DEBUG) board.Log("Frame, type value not support!", true, true);
  258.                                                         break;
  259.                                                 }
  260.                                                 }
  261.  
  262.                                                 XB_CAYENNE_MOD_DELETE_TCayenneFrameItem(CayenneFrameItem);
  263.                                                 break;
  264.                                         }
  265.                                         default:
  266.                                         {
  267.                                                 if (XB_CAYENNE_MOD_DEBUG) board.Log("Type frame transport is not support!", true, true);
  268.                                                 break;
  269.                                         }
  270.                                         }
  271.                                 }
  272.                         }
  273.                         else
  274.                         {
  275.                                 DEF_WAITMS_VAR(cpc);
  276.                                 BEGIN_WAITMS(cpc, 5000);
  277.                                 {
  278.                                         if (XB_CAYENNE_MOD_DEBUG) board.Log("Client problem connection.!", true, true);
  279.                                         if (XB_CAYENNE_MOD_DEBUG) board.Log("Reconnect.", true, true);
  280.                                         CayenneMQTTDisconnect(&Cayenne->_mqttClient);
  281.                                         if (XB_CAYENNE_MOD_DEBUG) board.Log(".");
  282.                                         NetworkDisconnect(&Cayenne->_network);
  283.                                         if (XB_CAYENNE_MOD_DEBUG) board.Log(".");
  284.                                         Cayenne->connect();
  285.                                         if (XB_CAYENNE_MOD_DEBUG) board.Log(".OK");
  286.                                 }
  287.                                 END_WAITMS(cpc);
  288.                                
  289.  
  290.  
  291.                         }
  292.                 }
  293.                 END_WAITMS(ccl);
  294.                 break;
  295.         }
  296.         default: FunctionStepCAYENNE_MOD = fscIDLE;
  297.         }
  298.         return 0;
  299. }
  300.  
  301.  
  302. bool XB_CAYENNE_MOD_DoMessage(TMessageBoard *Am)
  303. {
  304.         switch (Am->IDMessage)
  305.         {
  306.         case IM_FRAME_RECEIVE:
  307.         {
  308.                 TCayenneFrameTransport *src_cft = (TCayenneFrameTransport *)Am->Data.FrameReceiveData.DataFrame;
  309.                 TCayenneFrameItem *cfi = XB_CAYENNE_MOD_NEW_TCayenneFrameItem();
  310.                 xb_memorycopy(src_cft, &cfi->CayenneFrameTransport, sizeof(TCayenneFrameTransport));
  311.                 return true;
  312.         }
  313.         case IM_INTERNET_CONNECT:
  314.         {
  315.                 if (FunctionStepCAYENNE_MOD == fscIDLE)
  316.                 {
  317.                         FunctionStepCAYENNE_MOD = fscInit;
  318.                 }
  319.                 return true;
  320.         }
  321.         case IM_INTERNET_DISCONNECT:
  322.         {
  323.                 if ((FunctionStepCAYENNE_MOD == fscConnected ) || (FunctionStepCAYENNE_MOD == fscInit))
  324.                 {
  325.                         FunctionStepCAYENNE_MOD = fscDeInit;
  326.                 }
  327.                 return true;
  328.         }
  329.         case IM_GET_TASKNAME_STRING:
  330.         {
  331.                 *(Am->Data.PointerString) = FSS("CAYENNE_MOD");
  332.                 return true;
  333.         }
  334.         case IM_GET_TASKSTATUS_STRING:
  335.         {
  336.                 switch (FunctionStepCAYENNE_MOD)
  337.                 {
  338.                 case fscIDLE:           *(Am->Data.PointerString) = "IDLE       "; break;
  339.                 case fscLoadConfig:     *(Am->Data.PointerString) = "LoadConfig "; break;
  340.                 case fscInit:           *(Am->Data.PointerString) = "Init       "; break;
  341.                 case fscConnected:      *(Am->Data.PointerString) = "Connected  "; break;
  342.                 default:                        *(Am->Data.PointerString) = "???        "; break;
  343.                 }
  344.                 *(Am->Data.PointerString) += "(FC:" + String(CayenneFrameItemList_Count) + ") ";
  345.                 return true;
  346.         }
  347.         case IM_MENU:
  348.         {
  349.                 TGADGETMenu *menuhandle=NULL;
  350.                 switch (Am->Data.MenuData.TypeMenuAction)
  351.                 {
  352.                 case tmaOPEN_MAINMENU:
  353.                 {
  354.                         menuhandle = GUIGADGET_CreateMenu(&XB_CAYENNE_MOD_DefTask, 1);
  355.                         break;
  356.                 }
  357.                 case tmaGET_INIT_MENU:
  358.                 {
  359.                         Am->Data.MenuData.ActionData.MenuInitData.ItemCount = 4;
  360.                         Am->Data.MenuData.ActionData.MenuInitData.Width = 32;
  361.                         Am->Data.MenuData.ActionData.MenuInitData.CurrentSelect = 0;
  362.                         break;
  363.                 }
  364.                 case tmaGET_ITEM_MENU_STRING:
  365.                 {
  366.                         (XB_CAYENNE_MOD_DEBUG == true ? "*" : " ");
  367.                         switch (Am->Data.MenuData.ActionData.MenuItemData.ItemIndex)
  368.                         {
  369.                                 DEF_MENUITEMNAME(0, "Load configuration");
  370.                                 DEF_MENUITEMNAME(1, "Save configuration");
  371.                                 DEF_MENUITEMNAME(2, "Clear Channel as IDROM");
  372.                                 case 3: *Am->Data.MenuData.ActionData.MenuItemData.PointerString = "Debug info [" + String(XB_CAYENNE_MOD_DEBUG == true ? "*" : " ") + "]"; break;
  373.                         default:
  374.                                 break;
  375.                         }
  376.                        
  377.                         break;
  378.                 }
  379.                 case tmaCLICK_ITEM_MENU:
  380.                 {
  381.                         switch (Am->Data.MenuData.ActionData.MenuClickData.ItemIndex)
  382.                         {
  383.                         case 0:
  384.                         {
  385.                                 XB_CAYENNE_MOD_LoadConfig();
  386.                                 break;
  387.                         }
  388.                         case 1:
  389.                         {
  390.                                 XB_CAYENNE_MOD_SaveConfig();
  391.                                 break;
  392.                         }
  393.                         case 2:
  394.                         {
  395.                                 XB_CAYENNE_MOD_ClearChannelAsIDROM();
  396.                                 break;
  397.                         }
  398.                         case 3:
  399.                         {
  400.                                 XB_CAYENNE_MOD_DEBUG = !XB_CAYENNE_MOD_DEBUG;
  401.                                 break;
  402.                         }
  403.                         default: break;
  404.                         }
  405.                 }
  406.                 default: break;
  407.                 }
  408.                
  409.                 return true;
  410.         }
  411.         default: break;
  412.         }
  413.        
  414.  
  415.         return false;
  416. }
  417.  
  418.  
  419.  
  420.  
  421.  
  422.  

Reply to "Untitled"