Subversion Repositories NedoOS

Rev

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