Subversion Repositories NedoOS

Rev

Rev 2385 | 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.                                 unsigned char cmd[128];
  295.                                 sprintf(cmd, "[AFC] receiving timeout.[c=%lu][t=%lu]", count, time() - strt);
  296.                                 writeLog(cmd, "uartReadBlock  ");
  297.                                 return 0xffff;
  298.                         }
  299.                         timerok = timerok - 1;
  300.                 }
  301.                 return input(RBR_THR);
  302.         case 3: // ATM2IOESP
  303.                 disable_interrupt();
  304.                 output(0xfb, LSR);
  305.                 while ((1 & input(0xfa)) == 0)
  306.                 {
  307.                         if (timerok == 0)
  308.                         {
  309.                                 unsigned char cmd[128];
  310.                                 enable_interrupt();
  311.                                 sprintf(cmd, "[ATM2IOESP] receiving timeout.[c=%lu][t=%lu]", count, time() - strt);
  312.                                 writeLog(cmd, "uartReadBlock  ");
  313.                                 return 0xffff;
  314.                         }
  315.                         timerok = timerok - 1;
  316.                         // disable_interrupt();
  317.                         output(0xfb, MCR);
  318.                         output(0xfa, 2);
  319.                         output(0xfa, 0);
  320.                         output(0xfb, LSR);
  321.                         // enable_interrupt();
  322.                 }
  323.                 output(0xfb, RBR_THR);
  324.                 data = input(0xfa);
  325.                 enable_interrupt();
  326.                 return data;
  327.         }
  328.         puts("Error, Unknown COM port");
  329.         getchar();
  330.         return 0xffff;
  331. }
  332.  
  333. void uartFlush(unsigned int millis)
  334. {
  335.         unsigned long finish;
  336.         finish = time() + (millis / 20);
  337.         uart_setrts(1);
  338.         while (time() < finish)
  339.         {
  340.                 uart_read();
  341.         }
  342.         uart_setrts(0);
  343.         // writeLog("Flushed data", "uartFlush      ");
  344. }
  345.  
  346. char getdataEsp(unsigned int counted)
  347. {
  348.         unsigned int counter;
  349.         switch (comType)
  350.         {
  351.         case 0: // Kondratyev  NO AFC
  352.                 for (counter = 0; counter < counted; counter++)
  353.                 {
  354.                         timerok = factor;
  355.                         while ((1 & input(LSR)) == 0)
  356.                         {
  357.                                 if (timerok == 0)
  358.                                 {
  359.                                         sprintf(cmd, "[NO AFC] receiving timeout.[c=%lu]", count);
  360.                                         writeLog(cmd, "getDataEsp     ");
  361.                                         return false;
  362.                                 }
  363.                                 timerok = timerok - 1;
  364.                                 disable_interrupt();
  365.                                 output(MCR, 2);
  366.                                 output(MCR, 0);
  367.                                 enable_interrupt();
  368.                         };
  369.                         netbuf[counter] = input(RBR_THR);
  370.                 }
  371.                 return true;
  372.         case 1: // ATM2 COM port
  373.                 for (counter = 0; counter < counted; counter++)
  374.                 {
  375.                         timerok = factor;
  376.                         while (uart_hasByte() == 0)
  377.                         {
  378.                                 if (timerok == 0)
  379.                                 {
  380.                                         sprintf(cmd, "[ATM2 COM] receiving timeout.[c=%lu]", count);
  381.                                         writeLog(cmd, "getDataEsp     ");
  382.                                         return false;
  383.                                 }
  384.                                 timerok = timerok - 1;
  385.                                 disable_interrupt();
  386.                                 input(0x55fe); // Переход в режим команд
  387.                                 input(0x43fe); // Команда установить статус
  388.                                 input(0x03fe); // Устанавливаем готовность DTR и RTS
  389.                                 input(0x55fe); // Переход в режим команд
  390.                                 input(0x43fe); // Команда установить статус
  391.                                 input(0x00fe); // Снимаем готовность DTR и RTS
  392.                                 enable_interrupt();
  393.                         }
  394.                         disable_interrupt();
  395.                         input(0x55fe);                                   // Переход в режим команд
  396.                         netbuf[counter] = input(0x02fe); // Команда прочесть из порта
  397.                         enable_interrupt();
  398.                 }
  399.                 return true;
  400.         case 2: // Kondratyev AFC
  401.                 for (counter = 0; counter < counted; counter++)
  402.                 {
  403.                         timerok = factor;
  404.                         while ((1 & input(LSR)) == 0)
  405.                         {
  406.                                 if (timerok == 0)
  407.                                 {
  408.                                         sprintf(cmd, "[AFC] receiving timeout.[c=%lu]", count);
  409.                                         writeLog(cmd, "getDataEsp     ");
  410.                                         return false;
  411.                                 }
  412.                                 timerok = timerok - 1;
  413.                         }
  414.                         netbuf[counter] = input(RBR_THR);
  415.                 }
  416.                 return true;
  417.         case 3: // ATM2IOESP
  418.                 for (counter = 0; counter < counted; counter++)
  419.                 {
  420.                         timerok = factor;
  421.                         disable_interrupt();
  422.                         output(0xfb, LSR);
  423.                         while ((1 & input(0xfa)) == 0)
  424.                         {
  425.                                 if (timerok == 0)
  426.                                 {
  427.                                         sprintf(cmd, "[ATM2IOESP] receiving timeout.[c=%lu]", count);
  428.                                         writeLog(cmd, "getDataEsp     ");
  429.                                         return false;
  430.                                 }
  431.                                 timerok = timerok - 1;
  432.                                 // disable_interrupt();
  433.                                 output(0xfb, MCR);
  434.                                 output(0xfa, 2);
  435.                                 output(0xfa, 0);
  436.                                 output(0xfb, LSR);
  437.                                 // enable_interrupt();
  438.                         }
  439.                         output(0xfb, RBR_THR);
  440.                         netbuf[counter] = input(0xfa);
  441.                         enable_interrupt();
  442.                 }
  443.         }
  444.         return true;
  445. }
  446.  
  447. void sendcommand(const char *commandline)
  448. {
  449.         unsigned int count, cmdLen;
  450.         cmdLen = strlen(commandline);
  451.         YIELD();
  452.         for (count = 0; count < cmdLen; count++)
  453.         {
  454.                 uart_write(commandline[count]);
  455.         }
  456.         uart_write('\r');
  457.         uart_write('\n');
  458.         YIELD();
  459.         // writeLog(commandline, "sendcommand    ");
  460. }
  461.  
  462. void sendcommandNrn(const char *commandline)
  463. {
  464.         unsigned int count, cmdLen;
  465.         cmdLen = strlen(commandline);
  466.         for (count = 0; count < cmdLen; count++)
  467.         {
  468.                 uart_write(commandline[count]);
  469.         }
  470. }
  471.  
  472. unsigned char getAnswer3(void)
  473. {
  474.         unsigned int readbyte;
  475.         unsigned int curPos = 0;
  476.         do
  477.         {
  478.                 readbyte = uartReadBlock(); // Очистка всех лишних CRLF перед ответом.
  479.                 if (readbyte > 255)
  480.                 {
  481.                         writeLog("Timeout while (readbyte == 0x0a) || (readbyte == 0x0d) ", "getAnswer3     ");
  482.                         return false;
  483.                 }
  484.  
  485.         } while (((readbyte == 0x0a) || (readbyte == 0x0d)));
  486.         netbuf[curPos] = readbyte;
  487.         curPos++;
  488.         do // Чтение сообщения
  489.         {
  490.                 readbyte = uartReadBlock();
  491.                 if (readbyte > 255)
  492.                 {
  493.                         writeLog("Timeout while reading answer", "getAnswer3     ");
  494.                         return false;
  495.                 }
  496.                 netbuf[curPos] = readbyte;
  497.                 curPos++;
  498.         } while (readbyte != 0x0d);
  499.         netbuf[curPos - 1] = 0;
  500.  
  501.         readbyte = uartReadBlock(); // 0x0a
  502.         if (readbyte > 255)
  503.         {
  504.                 writeLog("Timeout while reading tail's 0x0a", "getAnswer3     ");
  505.                 return false;
  506.         }
  507.  
  508.         // writeLog(netbuf, "getAnswer3     ");
  509.         YIELD();
  510.         return true;
  511. }
  512.  
  513. unsigned long uartBench(void)
  514. {
  515.         unsigned char data;
  516.         unsigned int count;
  517.         unsigned long start, finish;
  518.  
  519.         // scanf("enter comType %u", &comType);
  520.         start = time();
  521.         switch (comType)
  522.         {
  523.         case 0: // Kondratyev  NO AFC
  524.                 for (count = 0; count < 10000; count++)
  525.                 {
  526.                         data = (1 & input(LSR));
  527.                         data = (1 & input(LSR));
  528.                         if (count == 0)
  529.                         {
  530.                         }
  531.                         output(MCR, 2);
  532.                         output(MCR, 0);
  533.                         data = input(RBR_THR);
  534.                 }
  535.                 break;
  536.         case 1: // ATM2 COM port
  537.                 for (count = 0; count < 10000; count++)
  538.                 {
  539.                         enable_interrupt();
  540.                         input(0x55fe);            // Переход в режим команд
  541.                         data = input(0xc2fe); // Получаем количество байт в приемном буфере
  542.                         data = input(0xc2fe); // Получаем количество байт в приемном буфере
  543.                         if (count == 0)
  544.                         {
  545.                         }
  546.                         enable_interrupt();
  547.                         enable_interrupt();
  548.                         input(0x55fe);            // Переход в режим команд
  549.                         input(0x43fe);            // Команда установить статус
  550.                         input(0x03fe);            // Устанавливаем готовность DTR и RTS
  551.                         input(0x55fe);            // Переход в режим команд
  552.                         input(0x43fe);            // Команда установить статус
  553.                         input(0x00fe);            // Снимаем готовность DTR и RTS
  554.                         input(0x55fe);            // Переход в режим команд
  555.                         data = input(0x02fe); // Команда прочесть из порта
  556.                         enable_interrupt();
  557.                 }
  558.                 break;
  559.         case 2: // Kondratyev AFC
  560.                 for (count = 0; count < 10000; count++)
  561.                 {
  562.                         data = (1 & input(LSR));
  563.                         data = (1 & input(LSR));
  564.                         data = (1 & input(LSR));
  565.                         input(RBR_THR);
  566.                 }
  567.                 break;
  568.         case 3: // ATM2IOESP
  569.                 for (count = 0; count < 10000; count++)
  570.                 {
  571.                         enable_interrupt();
  572.                         output(0xfb, LSR);
  573.                         data = (1 & input(0xfa));
  574.                         output(0xfb, MCR);
  575.                         output(0xfa, 2);
  576.                         output(0xfa, 0);
  577.                         output(0xfb, LSR);
  578.                         output(0xfb, RBR_THR);
  579.                         data = (input(0xfa));
  580.                         enable_interrupt();
  581.                 }
  582.                 break;
  583.         }
  584.         finish = time();
  585.  
  586.         factor = (unsigned long)(espRetry * magic * 50000 / (finish - start)); // magic number  15 * (espRetry * 10000 * 50 / (finish - start)) /10
  587.         printf(". Factor = %lu.", factor);
  588.         return factor;
  589. }
  590.  
  591. char espReBoot(void)
  592. {
  593.         unsigned char count;
  594.         unsigned int byte;
  595.         unsigned long finish;
  596.         printf("Resetting ESP");
  597.         timerok = uartBench();
  598.  
  599.         // getAnswer3();
  600.  
  601.         sendcommand("AT+RST");
  602.         count = 0;
  603.         finish = time() + (10 * 50);
  604.         do
  605.         {
  606.                 byte = uartReadBlock();
  607.                 // putchar(byte);
  608.                 if (byte > 255)
  609.                 {
  610.                         clearStatus();
  611.                         printf("\r\nuartReadBlock() timeout Finish Continue\r\n");
  612.                         writeLog("Reboot waiting error. Continue; ", "espReBoot      ");
  613.                         if (time() > finish)
  614.                         {
  615.                                 printf("espReBoot timeout Finish exit %lu > %lu\r\n", time(), finish);
  616.                                 writeLog("Reboot waiting error. Timeout. ", "espReBoot      ");
  617.                                 return false;
  618.                         }
  619.                         else
  620.                         {
  621.                                 continue;
  622.                         }
  623.                 }
  624.  
  625.                 if (byte == gotWiFi[count])
  626.                 {
  627.                         count++;
  628.                 }
  629.                 else
  630.                 {
  631.                         count = 0;
  632.                 }
  633.         } while (count < strlen(gotWiFi));
  634.         printf(". Reset complete.");
  635.  
  636.         sendcommand("ATE0");
  637.  
  638.         do
  639.         {
  640.                 byte = uartReadBlock();
  641.                 if (byte > 255)
  642.                 {
  643.                         writeLog("ATE0. OK answer waiting error. ", "espReBoot      ");
  644.                 }
  645.  
  646.         } while (byte != 'K'); // OK
  647.  
  648.         if (uartReadBlock() > 255) // CR
  649.         {
  650.                 writeLog("ATE0. CR answer waiting error.", "espReBoot      ");
  651.         }
  652.  
  653.         if (uartReadBlock() > 255) // LN
  654.         {
  655.                 writeLog("ATE0. CR answer waiting error. ", "espReBoot      ");
  656.         }
  657.  
  658.         sendcommand("AT+CIPCLOSE");
  659.         getAnswer3();
  660.         sendcommand("AT+CIPDINFO=0");
  661.         getAnswer3();
  662.         sendcommand("AT+CIPMUX=0");
  663.         getAnswer3();
  664.         sendcommand("AT+CIPSERVER=0");
  665.         getAnswer3();
  666.         sendcommand("AT+CIPRECVMODE=0");
  667.         getAnswer3();
  668.         uartFlush(200);
  669.  
  670.         return true;
  671. }
  672.  
  673. int recvHead(void)
  674. {
  675.         unsigned char dataRead;
  676.         int byte, todo = 0, count = 0, countErr = 0;
  677.         const char closed[] = "CLOSED";
  678.         const char error[] = "ERROR";
  679.         //+IPD<,length>:<data>
  680.         //+CIPRECVDATA:<actual_len>,<data>
  681.         dataRead = 0;
  682.         do
  683.         {
  684.                 byte = uartReadBlock();
  685.  
  686.                 if (byte > 255)
  687.                 {
  688.                         writeLog("Timeout reading head ", "recvHead       ");
  689.                         return false;
  690.                 }
  691.  
  692.                 // printf("[%c]", byte);
  693.  
  694.                 if (byte == closed[count])
  695.                 {
  696.                         count++;
  697.                 }
  698.                 else
  699.                 {
  700.                         count = 0;
  701.                 }
  702.  
  703.                 if (byte == error[countErr])
  704.                 {
  705.                         countErr++;
  706.                 }
  707.                 else
  708.                 {
  709.                         countErr = 0;
  710.                 }
  711.                 if ((count == strlen(closed)) || (countErr == strlen(error)))
  712.                 {
  713.                         writeLog("Recieved  'closed' or 'error' ", "recvHead       ");
  714.                         return false;
  715.                 }
  716.         } while (byte != ',');
  717.  
  718.         do
  719.         {
  720.                 byte = uartReadBlock();
  721.                 if (byte > 255)
  722.                 {
  723.                         writeLog("Timeout waiting ':' ", "recvHead       ");
  724.                         return false;
  725.                 }
  726.                 netbuf[dataRead] = byte;
  727.                 dataRead++;
  728.         } while (byte != ':');
  729.         todo = atoi(netbuf);
  730.         // <actual_len>
  731.         // printf("recvHead(); todo = %d   ", todo);
  732.  
  733.         return todo;
  734. }
  735.  
  736. void loadEspConfig(void)
  737. {
  738.         unsigned char curParam[256];
  739.         FILE *espcom;
  740.  
  741.         OS_SETSYSDRV();
  742.         OS_CHDIR("../ini");
  743.         espcom = OS_OPENHANDLE("espcom.ini", 0x80);
  744.         if (((int)espcom) & 0xff)
  745.         {
  746.                 clearStatus();
  747.                 printf("espcom.ini opening error");
  748.                 return;
  749.         }
  750.         OS_READHANDLE(curParam, espcom, 250);
  751.         OS_CLOSEHANDLE(espcom);
  752.  
  753.         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);
  754.  
  755.         puts("Config loaded:");
  756.  
  757.         if (comType == 1)
  758.         {
  759.                 puts("     Controller IO port: 0x55fe");
  760.         }
  761.         else
  762.         {
  763.                 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);
  764.                 printf("     MCR    :0x%4x     LSR    :0x%4x\r\n     MSR    :0x%4x     SR     :0x%4x\r\n", MCR, LSR, MSR, SR);
  765.         }
  766.         printf("     DIV    :%u    TYPE    :%u    ESP    :%u    Retry  :%u  \r\n", divider, comType, espType, espRetry);
  767.         switch (comType)
  768.         {
  769.         case 0:
  770.                 puts("     Port (16550 like w/o AFC)");
  771.                 break;
  772.         case 1:
  773.                 puts("     Port (ATM Turbo 2+)");
  774.                 break;
  775.         case 2:
  776.                 puts("     Port (16550 with AFC)");
  777.                 break;
  778.         case 3:
  779.                 puts("     Port (ATM2IOESP Card)");
  780.                 break;
  781.         default:
  782.                 puts("     Port (Unknown type)");
  783.                 break;
  784.         }
  785.         YIELD();
  786. }
  787. ////////////////////////ESP32 PROCEDURES//////////////////////