Subversion Repositories NedoOS

Rev

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