Subversion Repositories NedoOS

Rev

Rev 2388 | Blame | Compare with Previous | Last modification | View Log | Download

  1. ////////////////////////ESP32 PROCEDURES//////////////////////
  2.  
  3. void writeLog(const char *logline, char *place)
  4. {
  5.         FILE *LogFile;
  6.         unsigned long fileSize;
  7.         unsigned char toLog[256];
  8.         // unsigned char cPath[130]; //28102025!!!
  9.  
  10.         OS_GETPATH((unsigned int)&curPath);
  11.         OS_SETSYSDRV();
  12.         LogFile = OS_OPENHANDLE("../espcom.log", 0x80);
  13.         if (((int)LogFile) & 0xff)
  14.         {
  15.                 LogFile = OS_CREATEHANDLE("../espcom.log", 0x80);
  16.                 OS_CLOSEHANDLE(LogFile);
  17.                 LogFile = OS_OPENHANDLE("../espcom.log", 0x80);
  18.         }
  19.  
  20.         fileSize = OS_GETFILESIZE(LogFile);
  21.         OS_SEEKHANDLE(LogFile, fileSize);
  22.  
  23.         sprintf(toLog, "%7lu : %s : %s\r\n", time(), place, logline);
  24.         OS_WRITEHANDLE(toLog, LogFile, strlen(toLog));
  25.         OS_CLOSEHANDLE(LogFile);
  26.         OS_CHDIR(curPath);
  27. }
  28.  
  29. void portOutput(char port, char data)
  30. {
  31.         disable_interrupt();
  32.         output(0xfb, port);
  33.         output(0xfa, data);
  34.         enable_interrupt();
  35. }
  36.  
  37. char portInput(char port)
  38. {
  39.         char byte;
  40.         disable_interrupt();
  41.         output(0xfb, port);
  42.         byte = input(0xfa);
  43.         enable_interrupt();
  44.         return byte;
  45. }
  46.  
  47. void uart_write(unsigned char data)
  48. {
  49.         switch (comType)
  50.         {
  51.         case 0:
  52.         case 2:
  53.                 while ((input(LSR) & 32) == 0)
  54.                 {
  55.                 }
  56.                 output(RBR_THR, data);
  57.                 return;
  58.         case 1: // ATM2COM
  59.                 disable_interrupt();
  60.                 do
  61.                 {
  62.                         input(0x55fe); // Переход в режим команд
  63.                 } while ((input(0x42fe) & 32) == 0); // Команда прочесть статус & Проверяем 5 бит
  64.  
  65.                 input(0x55fe);                           // Переход в режим команд
  66.                 input(0x03fe);                           // Команда записать в порт
  67.                 input((data << 8) | 0x00fe); // Записываем data в порт
  68.                 enable_interrupt();
  69.                 return;
  70.         case 3:
  71.                 while ((portInput(LSR) & 32) == 0)
  72.                 {
  73.                 }
  74.                 disable_interrupt();
  75.                 output(0xfb, RBR_THR);
  76.                 output(0xfa, data);
  77.                 enable_interrupt();
  78.                 return;
  79.         }
  80. }
  81. void uart_setrts(unsigned char mode)
  82. {
  83.         switch (comType)
  84.         {
  85.         case 0:
  86.                 switch (mode)
  87.                 {
  88.                 case 1: // Enable flow
  89.                         output(MCR, 2);
  90.                         break;
  91.                 case 0: // Stop flow
  92.                         output(MCR, 0);
  93.                         break;
  94.                 default:
  95.                         disable_interrupt();
  96.                         output(MCR, 2);
  97.                         output(MCR, 0);
  98.                         enable_interrupt();
  99.                         break;
  100.                 }
  101.         case 1:
  102.                 switch (mode)
  103.                 {
  104.                 case 1:
  105.                         disable_interrupt();
  106.                         input(0x55fe); // Переход в режим команд
  107.                         input(0x43fe); // Команда установить статус
  108.                         input(0x03fe); // Устанавливаем готовность DTR и RTS
  109.                         enable_interrupt();
  110.                         break;
  111.                 case 0:
  112.                         disable_interrupt();
  113.                         input(0x55fe); // Переход в режим команд
  114.                         input(0x43fe); // Команда установить статус
  115.                         input(0x00fe); // Снимаем готовность DTR и RTS
  116.                         enable_interrupt();
  117.                         break;
  118.                 default:
  119.                         disable_interrupt();
  120.                         input(0x55fe); // Переход в режим команд
  121.                         input(0x43fe); // Команда установить статус
  122.                         input(0x03fe); // Устанавливаем готовность DTR и RTS
  123.                         input(0x55fe); // Переход в режим команд
  124.                         input(0x43fe); // Команда установить статус
  125.                         input(0x00fe); // Снимаем готовность DTR и RTS
  126.                         enable_interrupt();
  127.                         break;
  128.                 }
  129.         case 2:
  130.                 break;
  131.         case 3:
  132.                 switch (mode)
  133.                 {
  134.                 case 1:
  135.                         disable_interrupt();
  136.                         output(0xfb, MCR);
  137.                         output(0xfa, 2);
  138.                         enable_interrupt();
  139.                         break;
  140.                 case 0:
  141.                         disable_interrupt();
  142.                         output(0xfb, MCR);
  143.                         output(0xfa, 0);
  144.                         enable_interrupt();
  145.                         break;
  146.                 default:
  147.                         disable_interrupt();
  148.                         output(0xfb, MCR);
  149.                         output(0xfa, 2);
  150.                         output(0xfa, 0);
  151.                         enable_interrupt();
  152.                         break;
  153.                 }
  154.                 break;
  155.         }
  156. }
  157. void uart_init(unsigned char divisor)
  158. {
  159.         switch (comType)
  160.         {
  161.         case 0:
  162.         case 2:
  163.                 output(IIR_FCR, 0x87);    // Enable fifo 8 level, and clear it
  164.                 output(LCR, 0x83);                // 8n1, DLAB=1
  165.                 output(RBR_THR, divisor); // 115200 (divider 1-115200, 3 - 38400)
  166.                 output(IER, 0x00);                // (divider 0). Divider is 16 bit, so we get (#0002 divider)
  167.                 output(LCR, 0x03);                // 8n1, DLAB=0
  168.                 output(IER, 0x00);                // Disable int
  169.                 output(MCR, 0x2f);                // Enable AFE
  170.                 break;
  171.         case 1:
  172.                 disable_interrupt();
  173.                 input(0x55fe);
  174.                 input(0xc3fe);
  175.                 input((divisor << 8) | 0x00fe);
  176.                 enable_interrupt();
  177.                 uart_setrts(0);
  178.                 break;
  179.         case 3:
  180.                 portOutput(IIR_FCR, 0x87);        // Enable fifo 8 level, and clear it
  181.                 portOutput(LCR, 0x83);            // 8n1, DLAB=1
  182.                 portOutput(RBR_THR, divisor); // 115200 (divider 1-115200, 3 - 38400)
  183.                 portOutput(IER, 0x00);            // (divider 0). Divider is 16 bit, so we get (#0002 divider)
  184.                 portOutput(LCR, 0x03);            // 8n1, DLAB=0
  185.                 portOutput(IER, 0x00);            // Disable int
  186.                 portOutput(MCR, 0x22);            // Enable AFE
  187.                 enable_interrupt();
  188.                 uart_setrts(0);
  189.                 break;
  190.         }
  191. }
  192.  
  193. unsigned char uart_hasByte(void)
  194. {
  195.         unsigned char queue;
  196.         switch (comType)
  197.         {
  198.         case 0: // Kondratyev  NO AFC
  199.         case 2:
  200.                 return (1 & input(LSR));
  201.         case 1:
  202.                 disable_interrupt();
  203.                 input(0x55fe);             // Переход в режим команд
  204.                 queue = input(0xc2fe); // Получаем количество байт в приемном буфере
  205.                 enable_interrupt();
  206.                 return queue;
  207.         case 3:
  208.                 return 1 & portInput(LSR);
  209.         }
  210.         return 255;
  211. }
  212.  
  213. unsigned char uart_read(void)
  214. {
  215.         unsigned char data;
  216.         switch (comType)
  217.         {
  218.         case 0: // Kondratyev  NO AFC
  219.         case 2: // Kondratyev AFC
  220.                 return input(RBR_THR);
  221.         case 1: // ATM2 COM port
  222.                 disable_interrupt();
  223.                 input(0x55fe);            // Переход в режим команд
  224.                 data = input(0x02fe); // Команда прочесть из порта
  225.                 enable_interrupt();
  226.                 return data;
  227.         case 3:
  228.                 disable_interrupt();
  229.                 output(0xfb, RBR_THR);
  230.                 data = input(0xfa);
  231.                 output(0xfb, 0x00);
  232.                 enable_interrupt();
  233.                 return data;
  234.         }
  235.         return 255;
  236. }
  237.  
  238. unsigned int uartReadBlock(void)
  239. {
  240.         unsigned char data;
  241.         unsigned long strt;
  242.         strt = time();
  243.  
  244.         timerok = factor;
  245.  
  246.         switch (comType)
  247.         {
  248.         case 0: // Kondratyev  NO AFC
  249.                 while ((1 & input(LSR)) == 0)
  250.                 {
  251.                         if (timerok == 0)
  252.                         {
  253.                                 sprintf(cmd, "[NO AFC] receiving timeout.[c=%lu][t=%lu]", count, time() - strt);
  254.                                 writeLog(cmd, "uartReadBlock  ");
  255.                                 return 0xffff;
  256.                         }
  257.                         timerok = timerok - 1;
  258.                         disable_interrupt();
  259.                         output(MCR, 2);
  260.                         output(MCR, 0);
  261.                         enable_interrupt();
  262.                 }
  263.                 return input(RBR_THR);
  264.         case 1: // ATM2 COM port
  265.                 while (uart_hasByte() == 0)
  266.                 {
  267.                         if (timerok == 0)
  268.                         {
  269.                                 enable_interrupt();
  270.                                 sprintf(cmd, "[ATM2 COM] receiving timeout.[c=%lu][t=%lu]", count, time() - strt);
  271.                                 writeLog(cmd, "uartReadBlock  ");
  272.                                 return 0xffff;
  273.                         }
  274.                         timerok = timerok - 1;
  275.                         disable_interrupt();
  276.                         input(0x55fe); // Переход в режим команд
  277.                         input(0x43fe); // Команда установить статус
  278.                         input(0x03fe); // Устанавливаем готовность DTR и RTS
  279.                         input(0x55fe); // Переход в режим команд
  280.                         input(0x43fe); // Команда установить статус
  281.                         input(0x00fe); // Снимаем готовность DTR и RTS
  282.                                                    // enable_interrupt();
  283.                 }
  284.                 // disable_interrupt();
  285.                 input(0x55fe);            // Переход в режим команд
  286.                 data = input(0x02fe); // Команда прочесть из порта
  287.                 enable_interrupt();
  288.                 return data;
  289.         case 2: // Kondratyev AFC
  290.                 while ((1 & input(LSR)) == 0)
  291.                 {
  292.                         if (timerok == 0)
  293.                         {
  294.                                 sprintf(cmd, "[AFC] receiving timeout.[c=%lu][t=%lu]", count, time() - strt);
  295.                                 writeLog(cmd, "uartReadBlock  ");
  296.                                 return 0xffff;
  297.                         }
  298.                         timerok = timerok - 1;
  299.                 }
  300.                 return input(RBR_THR);
  301.         case 3: // ATM2IOESP
  302.                 disable_interrupt();
  303.                 output(0xfb, LSR);
  304.                 while ((1 & input(0xfa)) == 0)
  305.                 {
  306.                         if (timerok == 0)
  307.                         {
  308.                                 enable_interrupt();
  309.                                 sprintf(cmd, "[ATM2IOESP] receiving timeout.[c=%lu][t=%lu]", count, time() - strt);
  310.                                 writeLog(cmd, "uartReadBlock  ");
  311.                                 return 0xffff;
  312.                         }
  313.                         timerok = timerok - 1;
  314.                         // disable_interrupt();
  315.                         output(0xfb, MCR);
  316.                         output(0xfa, 2);
  317.                         output(0xfa, 0);
  318.                         output(0xfb, LSR);
  319.                         // enable_interrupt();
  320.                 }
  321.                 output(0xfb, RBR_THR);
  322.                 data = input(0xfa);
  323.                 enable_interrupt();
  324.                 return data;
  325.         }
  326.         puts("Error, Unknown COM port");
  327.         getchar();
  328.         return 0xffff;
  329. }
  330.  
  331. void uartFlush(unsigned int millis)
  332. {
  333.         unsigned long finish;
  334.         finish = time() + (millis / 20);
  335.         uart_setrts(1);
  336.         while (time() < finish)
  337.         {
  338.                 uart_read();
  339.         }
  340.         uart_setrts(0);
  341.         // writeLog("Flushed data", "uartFlush      ");
  342. }
  343.  
  344. char getdataEsp(unsigned int counted)
  345. {
  346.         unsigned int counter;
  347.         switch (comType)
  348.         {
  349.         case 0: // Kondratyev  NO AFC
  350.                 for (counter = 0; counter < counted; counter++)
  351.                 {
  352.                         timerok = factor;
  353.                         while ((1 & input(LSR)) == 0)
  354.                         {
  355.                                 if (timerok == 0)
  356.                                 {
  357.                                         sprintf(cmd, "[NO AFC] receiving timeout.[c=%lu]", count);
  358.                                         writeLog(cmd, "getDataEsp     ");
  359.                                         return false;
  360.                                 }
  361.                                 timerok = timerok - 1;
  362.                                 disable_interrupt();
  363.                                 output(MCR, 2);
  364.                                 output(MCR, 0);
  365.                                 enable_interrupt();
  366.                         };
  367.                         netbuf[counter] = input(RBR_THR);
  368.                 }
  369.                 return true;
  370.         case 1: // ATM2 COM port
  371.                 for (counter = 0; counter < counted; counter++)
  372.                 {
  373.                         timerok = factor;
  374.                         while (uart_hasByte() == 0)
  375.                         {
  376.                                 if (timerok == 0)
  377.                                 {
  378.                                         sprintf(cmd, "[ATM2 COM] receiving timeout.[c=%lu]", count);
  379.                                         writeLog(cmd, "getDataEsp     ");
  380.                                         return false;
  381.                                 }
  382.                                 timerok = timerok - 1;
  383.                                 disable_interrupt();
  384.                                 input(0x55fe); // Переход в режим команд
  385.                                 input(0x43fe); // Команда установить статус
  386.                                 input(0x03fe); // Устанавливаем готовность DTR и RTS
  387.                                 input(0x55fe); // Переход в режим команд
  388.                                 input(0x43fe); // Команда установить статус
  389.                                 input(0x00fe); // Снимаем готовность DTR и RTS
  390.                                 enable_interrupt();
  391.                         }
  392.                         disable_interrupt();
  393.                         input(0x55fe);                                   // Переход в режим команд
  394.                         netbuf[counter] = input(0x02fe); // Команда прочесть из порта
  395.                         enable_interrupt();
  396.                 }
  397.                 return true;
  398.         case 2: // Kondratyev AFC
  399.                 for (counter = 0; counter < counted; counter++)
  400.                 {
  401.                         timerok = factor;
  402.                         while ((1 & input(LSR)) == 0)
  403.                         {
  404.                                 if (timerok == 0)
  405.                                 {
  406.                                         sprintf(cmd, "[AFC] receiving timeout.[c=%lu]", count);
  407.                                         writeLog(cmd, "getDataEsp     ");
  408.                                         return false;
  409.                                 }
  410.                                 timerok = timerok - 1;
  411.                         }
  412.                         netbuf[counter] = input(RBR_THR);
  413.                 }
  414.                 return true;
  415.         case 3: // ATM2IOESP
  416.                 for (counter = 0; counter < counted; counter++)
  417.                 {
  418.                         timerok = factor;
  419.                         disable_interrupt();
  420.                         output(0xfb, LSR);
  421.                         while ((1 & input(0xfa)) == 0)
  422.                         {
  423.                                 if (timerok == 0)
  424.                                 {
  425.                                         sprintf(cmd, "[ATM2IOESP] receiving timeout.[c=%lu]", count);
  426.                                         writeLog(cmd, "getDataEsp     ");
  427.                                         return false;
  428.                                 }
  429.                                 timerok = timerok - 1;
  430.                                 // disable_interrupt();
  431.                                 output(0xfb, MCR);
  432.                                 output(0xfa, 2);
  433.                                 output(0xfa, 0);
  434.                                 output(0xfb, LSR);
  435.                                 // enable_interrupt();
  436.                         }
  437.                         output(0xfb, RBR_THR);
  438.                         netbuf[counter] = input(0xfa);
  439.                         enable_interrupt();
  440.                 }
  441.         }
  442.         return true;
  443. }
  444.  
  445. void sendcommand(const char *commandline)
  446. {
  447.         unsigned int count, cmdLen;
  448.         cmdLen = strlen(commandline);
  449.         YIELD();
  450.         for (count = 0; count < cmdLen; count++)
  451.         {
  452.                 uart_write(commandline[count]);
  453.         }
  454.         uart_write('\r');
  455.         uart_write('\n');
  456.         YIELD();
  457.         // writeLog(commandline, "sendcommand    ");
  458. }
  459.  
  460. void sendcommandNrn(const char *commandline)
  461. {
  462.         unsigned int count, cmdLen;
  463.         cmdLen = strlen(commandline);
  464.         for (count = 0; count < cmdLen; count++)
  465.         {
  466.                 uart_write(commandline[count]);
  467.         }
  468. }
  469.  
  470. unsigned char getAnswer3(void)
  471. {
  472.         unsigned int readbyte;
  473.         unsigned int curPos = 0;
  474.         do
  475.         {
  476.                 readbyte = uartReadBlock(); // Очистка всех лишних CRLF перед ответом.
  477.                 if (readbyte > 255)
  478.                 {
  479.                         writeLog("Timeout while (readbyte == 0x0a) || (readbyte == 0x0d) ", "getAnswer3     ");
  480.                         return false;
  481.                 }
  482.  
  483.         } while (((readbyte == 0x0a) || (readbyte == 0x0d)));
  484.         netbuf[curPos] = readbyte;
  485.         curPos++;
  486.         do // Чтение сообщения
  487.         {
  488.                 readbyte = uartReadBlock();
  489.                 if (readbyte > 255)
  490.                 {
  491.                         writeLog("Timeout while reading answer", "getAnswer3     ");
  492.                         return false;
  493.                 }
  494.                 netbuf[curPos] = readbyte;
  495.                 curPos++;
  496.         } while (readbyte != 0x0d);
  497.         netbuf[curPos - 1] = 0;
  498.  
  499.         readbyte = uartReadBlock(); // 0x0a
  500.         if (readbyte > 255)
  501.         {
  502.                 writeLog("Timeout while reading tail's 0x0a", "getAnswer3     ");
  503.                 return false;
  504.         }
  505.  
  506.         // writeLog(netbuf, "getAnswer3     ");
  507.         YIELD();
  508.         return true;
  509. }
  510.  
  511. unsigned long uartBench(void)
  512. {
  513.         unsigned char data;
  514.         unsigned int count;
  515.         unsigned long start, finish;
  516.  
  517.         // scanf("enter comType %u", &comType);
  518.         start = time();
  519.         switch (comType)
  520.         {
  521.         case 0: // Kondratyev  NO AFC
  522.                 for (count = 0; count < 10000; count++)
  523.                 {
  524.                         data = (1 & input(LSR));
  525.                         data = (1 & input(LSR));
  526.                         if (count == 0)
  527.                         {
  528.                         }
  529.                         output(MCR, 2);
  530.                         output(MCR, 0);
  531.                         data = input(RBR_THR);
  532.                 }
  533.                 break;
  534.         case 1: // ATM2 COM port
  535.                 for (count = 0; count < 10000; count++)
  536.                 {
  537.                         enable_interrupt();
  538.                         input(0x55fe);            // Переход в режим команд
  539.                         data = input(0xc2fe); // Получаем количество байт в приемном буфере
  540.                         data = input(0xc2fe); // Получаем количество байт в приемном буфере
  541.                         if (count == 0)
  542.                         {
  543.                         }
  544.                         enable_interrupt();
  545.                         enable_interrupt();
  546.                         input(0x55fe);            // Переход в режим команд
  547.                         input(0x43fe);            // Команда установить статус
  548.                         input(0x03fe);            // Устанавливаем готовность DTR и RTS
  549.                         input(0x55fe);            // Переход в режим команд
  550.                         input(0x43fe);            // Команда установить статус
  551.                         input(0x00fe);            // Снимаем готовность DTR и RTS
  552.                         input(0x55fe);            // Переход в режим команд
  553.                         data = input(0x02fe); // Команда прочесть из порта
  554.                         enable_interrupt();
  555.                 }
  556.                 break;
  557.         case 2: // Kondratyev AFC
  558.                 for (count = 0; count < 10000; count++)
  559.                 {
  560.                         data = (1 & input(LSR));
  561.                         data = (1 & input(LSR));
  562.                         data = (1 & input(LSR));
  563.                         input(RBR_THR);
  564.                 }
  565.                 break;
  566.         case 3: // ATM2IOESP
  567.                 for (count = 0; count < 10000; count++)
  568.                 {
  569.                         enable_interrupt();
  570.                         output(0xfb, LSR);
  571.                         data = (1 & input(0xfa));
  572.                         output(0xfb, MCR);
  573.                         output(0xfa, 2);
  574.                         output(0xfa, 0);
  575.                         output(0xfb, LSR);
  576.                         output(0xfb, RBR_THR);
  577.                         data = (input(0xfa));
  578.                         enable_interrupt();
  579.                 }
  580.                 break;
  581.         }
  582.         finish = time();
  583.  
  584.         factor = (unsigned long)(espRetry * magic * 50000 / (finish - start)); // magic number  15 * (espRetry * 10000 * 50 / (finish - start)) /10
  585.         printf(". Factor = %lu.", factor);
  586.         return factor;
  587. }
  588.  
  589. char espReBoot(void)
  590. {
  591.         unsigned char count;
  592.         unsigned int byte;
  593.         unsigned long finish;
  594.         printf("Resetting ESP");
  595.         timerok = uartBench();
  596.  
  597.         // getAnswer3();
  598.  
  599.         sendcommand("AT+RST");
  600.         count = 0;
  601.         finish = time() + (10 * 50);
  602.         do
  603.         {
  604.                 byte = uartReadBlock();
  605.                 // putchar(byte);
  606.                 if (byte > 255)
  607.                 {
  608.                         clearStatus();
  609.                         printf("\r\nuartReadBlock() timeout Finish Continue\r\n");
  610.                         writeLog("Reboot waiting error. Continue; ", "espReBoot      ");
  611.                         if (time() > finish)
  612.                         {
  613.                                 printf("espReBoot timeout Finish exit %lu > %lu\r\n", time(), finish);
  614.                                 writeLog("Reboot waiting error. Timeout. ", "espReBoot      ");
  615.                                 return false;
  616.                         }
  617.                         else
  618.                         {
  619.                                 continue;
  620.                         }
  621.                 }
  622.  
  623.                 if (byte == gotWiFi[count])
  624.                 {
  625.                         count++;
  626.                 }
  627.                 else
  628.                 {
  629.                         count = 0;
  630.                 }
  631.         } while (count < strlen(gotWiFi));
  632.         printf(". Reset complete.");
  633.  
  634.         sendcommand("ATE0");
  635.  
  636.         do
  637.         {
  638.                 byte = uartReadBlock();
  639.                 if (byte > 255)
  640.                 {
  641.                         writeLog("ATE0. OK answer waiting error. ", "espReBoot      ");
  642.                 }
  643.  
  644.         } while (byte != 'K'); // OK
  645.  
  646.         if (uartReadBlock() > 255) // CR
  647.         {
  648.                 writeLog("ATE0. CR answer waiting error.", "espReBoot      ");
  649.         }
  650.  
  651.         if (uartReadBlock() > 255) // LN
  652.         {
  653.                 writeLog("ATE0. CR answer waiting error. ", "espReBoot      ");
  654.         }
  655.  
  656.         sendcommand("AT+CIPCLOSE");
  657.         getAnswer3();
  658.         sendcommand("AT+CIPDINFO=0");
  659.         getAnswer3();
  660.         sendcommand("AT+CIPMUX=0");
  661.         getAnswer3();
  662.         sendcommand("AT+CIPSERVER=0");
  663.         getAnswer3();
  664.         sendcommand("AT+CIPRECVMODE=0");
  665.         getAnswer3();
  666.         uartFlush(200);
  667.  
  668.         return true;
  669. }
  670.  
  671. int recvHead(void)
  672. {
  673.         unsigned char dataRead;
  674.         int byte, todo = 0, count = 0, countErr = 0;
  675.         const char closed[] = "CLOSED";
  676.         const char error[] = "ERROR";
  677.         //+IPD<,length>:<data>
  678.         //+CIPRECVDATA:<actual_len>,<data>
  679.         dataRead = 0;
  680.         do
  681.         {
  682.                 byte = uartReadBlock();
  683.  
  684.                 if (byte > 255)
  685.                 {
  686.                         writeLog("Timeout reading head ", "recvHead       ");
  687.                         return false;
  688.                 }
  689.  
  690.                 // printf("[%c]", byte);
  691.  
  692.                 if (byte == closed[count])
  693.                 {
  694.                         count++;
  695.                 }
  696.                 else
  697.                 {
  698.                         count = 0;
  699.                 }
  700.  
  701.                 if (byte == error[countErr])
  702.                 {
  703.                         countErr++;
  704.                 }
  705.                 else
  706.                 {
  707.                         countErr = 0;
  708.                 }
  709.                 if ((count == strlen(closed)) || (countErr == strlen(error)))
  710.                 {
  711.                         writeLog("Recieved  'closed' or 'error' ", "recvHead       ");
  712.                         return false;
  713.                 }
  714.         } while (byte != ',');
  715.  
  716.         do
  717.         {
  718.                 byte = uartReadBlock();
  719.                 if (byte > 255)
  720.                 {
  721.                         writeLog("Timeout waiting ':' ", "recvHead       ");
  722.                         return false;
  723.                 }
  724.                 netbuf[dataRead] = byte;
  725.                 dataRead++;
  726.         } while (byte != ':');
  727.         todo = atoi(netbuf);
  728.         // <actual_len>
  729.         // printf("recvHead(); todo = %d   ", todo);
  730.  
  731.         return todo;
  732. }
  733.  
  734. void loadEspConfig(void)
  735. {
  736.         unsigned char curParam[256];
  737.         FILE *espcom;
  738.  
  739.         OS_SETSYSDRV();
  740.         OS_CHDIR("../ini");
  741.         espcom = OS_OPENHANDLE("espcom.ini", 0x80);
  742.         if (((int)espcom) & 0xff)
  743.         {
  744.                 clearStatus();
  745.                 printf("espcom.ini opening error");
  746.                 return;
  747.         }
  748.         OS_READHANDLE(curParam, espcom, 250);
  749.         OS_CLOSEHANDLE(espcom);
  750.  
  751.         sscanf(curParam, "%x %x %x %x %x %x %x %x %u %u %u %u", &RBR_THR, &IER, &IIR_FCR, &LCR, &MCR, &LSR, &MSR, &SR, &divider, &comType, &espType, &espRetry);
  752.  
  753.         puts("Config loaded:");
  754.  
  755.         if (comType == 1)
  756.         {
  757.                 puts("     Controller IO port: 0x55fe");
  758.         }
  759.         else
  760.         {
  761.                 printf("     RBR_THR:0x%4x     IER    :0x%4x\r\n     IIR_FCR:0x%4x     LCR    :0x%4x\r\n", RBR_THR, IER, IIR_FCR, LCR);
  762.                 printf("     MCR    :0x%4x     LSR    :0x%4x\r\n     MSR    :0x%4x     SR     :0x%4x\r\n", MCR, LSR, MSR, SR);
  763.         }
  764.         printf("     DIV    :%u    TYPE    :%u    ESP    :%u    Retry  :%u  \r\n", divider, comType, espType, espRetry);
  765.         switch (comType)
  766.         {
  767.         case 0:
  768.                 puts("     Port (16550 like w/o AFC)");
  769.                 break;
  770.         case 1:
  771.                 puts("     Port (ATM Turbo 2+)");
  772.                 break;
  773.         case 2:
  774.                 puts("     Port (16550 with AFC)");
  775.                 break;
  776.         case 3:
  777.                 puts("     Port (ATM2IOESP Card)");
  778.                 break;
  779.         default:
  780.                 puts("     Port (Unknown type)");
  781.                 break;
  782.         }
  783.         YIELD();
  784. }
  785. ////////////////////////ESP32 PROCEDURES//////////////////////