Subversion Repositories NedoOS

Rev

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

  1. ////////////////////////ESP32 PROCEDURES//////////////////////
  2. void portOutput(char port, char data)
  3. {
  4.         disable_interrupt();
  5.         output(0xfb, port);
  6.         output(0xfa, data);
  7.         enable_interrupt();
  8. }
  9.  
  10. char portInput(char port)
  11. {
  12.         char byte;
  13.         disable_interrupt();
  14.         output(0xfb, port);
  15.         byte = input(0xfa);
  16.         enable_interrupt();
  17.         return byte;
  18. }
  19.  
  20. void uart_write(unsigned char data)
  21. {
  22.         unsigned char status;
  23.         switch (comType)
  24.         {
  25.         case 0:
  26.         case 2:
  27.                 while ((input(LSR) & 32) == 0)
  28.                 {
  29.                 }
  30.                 output(RBR_THR, data);
  31.                 break;
  32.         case 1:
  33.                 disable_interrupt();
  34.                 do
  35.                 {
  36.                         input(0x55fe);                  // Переход в режим команд
  37.                         status = input(0x42fe); // Команда прочесть статус
  38.                 } while ((status & 32) == 0); // Проверяем 5 бит
  39.  
  40.                 input(0x55fe);                           // Переход в режим команд
  41.                 input(0x03fe);                           // Команда записать в порт
  42.                 input((data << 8) | 0x00fe); // Записываем data в порт
  43.                 enable_interrupt();
  44.                 break;
  45.         case 3:
  46.                 while ((portInput(LSR) & 32) == 0)
  47.                 {
  48.                 }
  49.                 disable_interrupt();
  50.                 output(0xfb, RBR_THR);
  51.                 output(0xfa, data);
  52.                 enable_interrupt();
  53.                 break;
  54.         }
  55. }
  56.  
  57. void uart_setrts(unsigned char mode)
  58. {
  59.         switch (comType)
  60.         {
  61.         case 0:
  62.                 switch (mode)
  63.                 {
  64.                 case 1: // Enable flow
  65.                         output(MCR, 2);
  66.                         break;
  67.                 case 0: // Stop flow
  68.                         output(MCR, 0);
  69.                         break;
  70.                 default:
  71.                         disable_interrupt();
  72.                         output(MCR, 2);
  73.                         output(MCR, 0);
  74.                         enable_interrupt();
  75.                         break;
  76.                 }
  77.         case 1:
  78.                 switch (mode)
  79.                 {
  80.                 case 1:
  81.                         disable_interrupt();
  82.                         input(0x55fe); // Переход в режим команд
  83.                         input(0x43fe); // Команда установить статус
  84.                         input(0x03fe); // Устанавливаем готовность DTR и RTS
  85.                         enable_interrupt();
  86.                         break;
  87.                 case 0:
  88.                         disable_interrupt();
  89.                         input(0x55fe); // Переход в режим команд
  90.                         input(0x43fe); // Команда установить статус
  91.                         input(0x00fe); // Снимаем готовность DTR и RTS
  92.                         enable_interrupt();
  93.                         break;
  94.                 default:
  95.                         disable_interrupt();
  96.                         input(0x55fe); // Переход в режим команд
  97.                         input(0x43fe); // Команда установить статус
  98.                         input(0x03fe); // Устанавливаем готовность DTR и RTS
  99.                         input(0x55fe); // Переход в режим команд
  100.                         input(0x43fe); // Команда установить статус
  101.                         input(0x00fe); // Снимаем готовность DTR и RTS
  102.                         enable_interrupt();
  103.                         break;
  104.                 }
  105.         case 2:
  106.                 break;
  107.         case 3:
  108.                 switch (mode)
  109.                 {
  110.                 case 1:
  111.                         disable_interrupt();
  112.                         output(0xfb, MCR);
  113.                         output(0xfa, 2);
  114.                         enable_interrupt();
  115.                         break;
  116.                 case 0:
  117.                         disable_interrupt();
  118.                         output(0xfb, MCR);
  119.                         output(0xfa, 0);
  120.                         enable_interrupt();
  121.                         break;
  122.                 default:
  123.                         disable_interrupt();
  124.                         output(0xfb, MCR);
  125.                         output(0xfa, 2);
  126.                         output(0xfa, 0);
  127.                         enable_interrupt();
  128.                         break;
  129.                 }
  130.                 break;
  131.         }
  132. }
  133. void uart_init(unsigned char divisor)
  134. {
  135.         switch (comType)
  136.         {
  137.         case 0:
  138.         case 2:
  139.                 output(IIR_FCR, 0x87);    // Enable fifo 8 level, and clear it
  140.                 output(LCR, 0x83);                // 8n1, DLAB=1
  141.                 output(RBR_THR, divisor); // 115200 (divider 1-115200, 3 - 38400)
  142.                 output(IER, 0x00);                // (divider 0). Divider is 16 bit, so we get (#0002 divider)
  143.                 output(LCR, 0x03);                // 8n1, DLAB=0
  144.                 output(IER, 0x00);                // Disable int
  145.                 output(MCR, 0x2f);                // Enable AFE
  146.                 break;
  147.         case 1:
  148.                 disable_interrupt();
  149.                 input(0x55fe);
  150.                 input(0xc3fe);
  151.                 input((divisor << 8) | 0x00fe);
  152.                 enable_interrupt();
  153.                 uart_setrts(0);
  154.                 break;
  155.         case 3:
  156.                 portOutput(IIR_FCR, 0x87);        // Enable fifo 8 level, and clear it
  157.                 portOutput(LCR, 0x83);            // 8n1, DLAB=1
  158.                 portOutput(RBR_THR, divisor); // 115200 (divider 1-115200, 3 - 38400)
  159.                 portOutput(IER, 0x00);            // (divider 0). Divider is 16 bit, so we get (#0002 divider)
  160.                 portOutput(LCR, 0x03);            // 8n1, DLAB=0
  161.                 portOutput(IER, 0x00);            // Disable int
  162.                 portOutput(MCR, 0x22);            // Enable AFE
  163.                 enable_interrupt();
  164.                 uart_setrts(0);
  165.                 break;
  166.         }
  167. }
  168.  
  169. unsigned char uart_hasByte(void)
  170. {
  171.         unsigned char queue;
  172.         switch (comType)
  173.         {
  174.         case 0: // Kondratyev  NO AFC
  175.         case 2:
  176.                 return (1 & input(LSR));
  177.         case 1:
  178.                 disable_interrupt();
  179.                 input(0x55fe);             // Переход в режим команд
  180.                 queue = input(0xc2fe); // Получаем количество байт в приемном буфере
  181.                 enable_interrupt();
  182.                 return queue;
  183.         case 3:
  184.                 return 1 & portInput(LSR);
  185.         }
  186.         printf("uart_hasByte () Error 001: Unknown port Type:[%d]", comType);
  187.         getchar();
  188.         return 255;
  189. }
  190.  
  191. unsigned char uart_read(void)
  192. {
  193.         unsigned char data;
  194.         switch (comType)
  195.         {
  196.         case 0: // Kondratyev  NO AFC
  197.         case 2:
  198.                 return input(RBR_THR);
  199.         case 1:
  200.                 disable_interrupt();
  201.                 input(0x55fe);            // Переход в режим команд
  202.                 data = input(0x02fe); // Команда прочесть из порта
  203.                 enable_interrupt();
  204.                 return data;
  205.         case 3:
  206.                 disable_interrupt();
  207.                 output(0xfb, RBR_THR);
  208.                 data = input(0xfa);
  209.                 output(0xfb, 0x00);
  210.                 enable_interrupt();
  211.                 return data;
  212.         }
  213.         return 255;
  214. }
  215.  
  216. unsigned char uart_readBlock(void)
  217. {
  218.         unsigned char data;
  219.         unsigned long timer;
  220.         timer = espRetry;
  221.         switch (comType)
  222.         {
  223.         case 0: // Kondratyev  NO AFC
  224.                 while ((1 & input(LSR)) == 0)
  225.                 {
  226.                         if (timer-- == 0)
  227.                         {
  228.                                 puts("\r[uart_readBlock] receiving timeout. returning 0.");
  229.                                 return false;
  230.                         }
  231.                         disable_interrupt();
  232.                         output(MCR, 2);
  233.                         output(MCR, 0);
  234.                         enable_interrupt();
  235.                 }
  236.                 return input(RBR_THR);
  237.         case 1: // ATM2 COM port
  238.                 while (uart_hasByte() == 0)
  239.                 {
  240.                         if (timer-- == 0)
  241.                         {
  242.                                 puts("\r[uart_readBlock] receiving timeout. returning 0.");
  243.                                 return false;
  244.                         }
  245.                         disable_interrupt();
  246.                         input(0x55fe); // Переход в режим команд
  247.                         input(0x43fe); // Команда установить статус
  248.                         input(0x03fe); // Устанавливаем готовность DTR и RTS
  249.                         input(0x55fe); // Переход в режим команд
  250.                         input(0x43fe); // Команда установить статус
  251.                         input(0x00fe); // Снимаем готовность DTR и RTS
  252.                         enable_interrupt();
  253.                 }
  254.                 disable_interrupt();
  255.                 input(0x55fe);            // Переход в режим команд
  256.                 data = input(0x02fe); // Команда прочесть из порта
  257.                 enable_interrupt();
  258.                 return data;
  259.         case 2: // Kondratyev AFC
  260.                 while ((1 & input(LSR)) == 0)
  261.                 {
  262.                         if (timer-- == 0)
  263.                         {
  264.                                 puts("\r[uart_readBlock] receiving timeout. Returning 0.");
  265.                                 return false;
  266.                         }
  267.                 }
  268.                 return input(RBR_THR);
  269.         case 3: // ATM2IOESP
  270.                 // disable_interrupt();
  271.                 output(0xfb, LSR);
  272.                 while ((1 & input(0xfa)) == 0)
  273.                 {
  274.                         if (timer-- == 0)
  275.                         {
  276.                                 enable_interrupt();
  277.                                 puts("\r[uart_readBlock] receiving timeout. Returning 0.");
  278.                                 return false;
  279.                         }
  280.                         disable_interrupt();
  281.                         output(0xfb, MCR);
  282.                         output(0xfa, 2);
  283.                         output(0xfa, 0);
  284.                         output(0xfb, LSR);
  285.                         enable_interrupt();
  286.                 }
  287.                 output(0xfb, RBR_THR);
  288.                 data = input(0xfa);
  289.                 // enable_interrupt();
  290.                 return data;
  291.         }
  292.         return 255;
  293. }
  294.  
  295. void uart_flush(void)
  296. {
  297.         uart_setrts(1);
  298.         delay(200);
  299.         uart_setrts(0);
  300. }
  301.  
  302. void uartFlush(unsigned int millis)
  303. {
  304.         uart_setrts(1);
  305.         delay(millis);
  306.         uart_setrts(0);
  307. }
  308.  
  309. char getdataEsp(unsigned int counted)
  310. {
  311.         unsigned int counter;
  312.         unsigned long timer;
  313.         switch (comType)
  314.         {
  315.         case 0: // Kondratyev  NO AFC
  316.                 for (counter = 0; counter < counted; counter++)
  317.                 {
  318.                         timer = espRetry;
  319.                         while ((1 & input(LSR)) == 0)
  320.                         {
  321.                                 if (timer-- == 0)
  322.                                 {
  323.                                         return false;
  324.                                 }
  325.                                 disable_interrupt();
  326.                                 output(MCR, 2);
  327.                                 output(MCR, 0);
  328.                                 enable_interrupt();
  329.                         };
  330.                         netbuf[counter] = input(RBR_THR);
  331.                 }
  332.                 break;
  333.         case 1: // ATM2 COM port
  334.                 for (counter = 0; counter < counted; counter++)
  335.                 {
  336.                         timer = espRetry;
  337.                         while (uart_hasByte() == 0)
  338.                         {
  339.                                 if (timer-- == 0)
  340.                                 {
  341.                                         return false;
  342.                                 }
  343.                                 disable_interrupt();
  344.                                 input(0x55fe); // Переход в режим команд
  345.                                 input(0x43fe); // Команда установить статус
  346.                                 input(0x03fe); // Устанавливаем готовность DTR и RTS
  347.                                 input(0x55fe); // Переход в режим команд
  348.                                 input(0x43fe); // Команда установить статус
  349.                                 input(0x00fe); // Снимаем готовность DTR и RTS
  350.                                 enable_interrupt();
  351.                         }
  352.                         disable_interrupt();
  353.                         input(0x55fe);                                   // Переход в режим команд
  354.                         netbuf[counter] = input(0x02fe); // Команда прочесть из порта
  355.                         enable_interrupt();
  356.                 }
  357.                 break;
  358.         case 2: // Kondratyev AFC
  359.                 for (counter = 0; counter < counted; counter++)
  360.                 {
  361.                         timer = espRetry;
  362.                         while ((1 & input(LSR)) == 0)
  363.                         {
  364.                                 if (timer-- == 0)
  365.                                 {
  366.                                         return false;
  367.                                 }
  368.                         }
  369.                         netbuf[counter] = input(RBR_THR);
  370.                 }
  371.                 break;
  372.         case 3: // ATM2IOESP
  373.                 for (counter = 0; counter < counted; counter++)
  374.                 {
  375.                         timer = espRetry;
  376.                         output(0xfb, LSR);
  377.                         while ((1 & input(0xfa)) == 0)
  378.                         {
  379.                                         if (timer-- == 0)
  380.                                         {
  381.                                                 return false;
  382.                                         }
  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.                         netbuf[counter] = input(0xfa);
  393.                 }
  394.                 break;
  395.         }
  396.         return true;
  397. }
  398.  
  399. void sendcommand(const char *commandline)
  400. {
  401.         unsigned int count, cmdLen;
  402.         cmdLen = strlen(commandline);
  403.         for (count = 0; count < cmdLen; count++)
  404.         {
  405.                 uart_write(commandline[count]);
  406.         }
  407.         uart_write('\r');
  408.         uart_write('\n');
  409.         // printf("Sended:[%s] \r\n", commandline);
  410. }
  411.  
  412. void sendcommandNrn(const char *commandline)
  413. {
  414.         unsigned int count, cmdLen;
  415.         cmdLen = strlen(commandline);
  416.         for (count = 0; count < cmdLen; count++)
  417.         {
  418.                 uart_write(commandline[count]);
  419.         }
  420.         // printf("[Nrn]Sended:[%s] \r\n", commandline);
  421. }
  422.  
  423. unsigned char getAnswer2(void)
  424. {
  425.         unsigned char readbyte;
  426.         unsigned int curPos = 0;
  427.         do
  428.         {
  429.                 readbyte = uart_readBlock();
  430.         } while (((readbyte == 0x0a) || (readbyte == 0x0d)));
  431.  
  432.         netbuf[curPos] = readbyte;
  433.         curPos++;
  434.         do
  435.         {
  436.                 readbyte = uart_readBlock();
  437.                 netbuf[curPos] = readbyte;
  438.                 curPos++;
  439.         } while (readbyte != 0x0d);
  440.         netbuf[curPos - 1] = 0;
  441.         uart_readBlock(); // 0xa
  442.         // printf("Answer:[%s]\r\n", netbuf);
  443.         // getchar();
  444.         return curPos;
  445. }
  446.  
  447. void espReBoot(void)
  448. {
  449.         unsigned char byte, count;
  450.         clearStatus();
  451.         printf("Resetting ESP...");
  452.  
  453.         uartFlush(200);
  454.  
  455.         sendcommand("AT+RST");
  456.         count = 0;
  457.  
  458.         do
  459.         {
  460.                 byte = uart_readBlock();
  461.                 if (byte == gotWiFi[count])
  462.                 {
  463.                         count++;
  464.                 }
  465.                 else
  466.                 {
  467.                         count = 0;
  468.                 }
  469.         } while (count < strlen(gotWiFi));
  470.         uart_readBlock(); // CR
  471.         uart_readBlock(); // LF
  472.         clearStatus();
  473.         printf("Reset complete.");
  474.         sendcommand("ATE0");
  475.         do
  476.         {
  477.                 byte = uart_readBlock();
  478.         } while (byte != 'K'); // OK
  479.         uart_readBlock(); // CR
  480.         uart_readBlock(); // LN
  481.         // puts("ATE0 Answer:[OK]");
  482.         sendcommand("AT+CIPCLOSE");
  483.         getAnswer2();
  484.         sendcommand("AT+CIPDINFO=0");
  485.         getAnswer2();
  486.         sendcommand("AT+CIPMUX=0");
  487.         getAnswer2();
  488.         sendcommand("AT+CIPSERVER=0");
  489.         getAnswer2();
  490.         sendcommand("AT+CIPRECVMODE=0");
  491.         getAnswer2();
  492. }
  493.  
  494. int recvHead(void)
  495. {
  496.         unsigned char byte, dataRead;
  497.         int todo = 0, count = 0, countErr = 0;
  498.         const char closed[] = "CLOSED";
  499.         const char error[] = "ERROR";
  500.         //+IPD<,length>:<data>
  501.         //+CIPRECVDATA:<actual_len>,<data>
  502.         dataRead = 0;
  503.         do
  504.         {
  505.                 byte = uart_readBlock();
  506.                 // printf("[%c]", byte);
  507.  
  508.                 if (byte == closed[count])
  509.                 {
  510.                         count++;
  511.                 }
  512.                 else
  513.                 {
  514.                         count = 0;
  515.                 }
  516.  
  517.                 if (byte == error[countErr])
  518.                 {
  519.                         countErr++;
  520.                 }
  521.                 else
  522.                 {
  523.                         countErr = 0;
  524.                 }
  525.                 if ((count == strlen(closed)) || (countErr == strlen(error)))
  526.                 {
  527.                         // uart_readBlock(); // CR
  528.                         // uart_readBlock(); // LF
  529.                         return todo;
  530.                 }
  531.         } while (byte != ',');
  532.  
  533.         do
  534.         {
  535.                 byte = uart_readBlock();
  536.                 netbuf[dataRead] = byte;
  537.                 dataRead++;
  538.         } while (byte != ':');
  539.         todo = atoi(netbuf);
  540.         // <actual_len>
  541.         // printf("recvHead(); todo = %d   ", todo);
  542.  
  543.         return todo;
  544. }
  545.  
  546. void loadEspConfig(void)
  547. {
  548.         unsigned char curParam[256];
  549.         unsigned char res;
  550.         FILE *espcom;
  551.         OS_SETSYSDRV();
  552.         OS_CHDIR("../ini");
  553.         espcom = OS_OPENHANDLE("espcom.ini", 0x80);
  554.         if (((int)espcom) & 0xff)
  555.         {
  556.                 clearStatus();
  557.                 printf("espcom.ini opening error");
  558.                 return;
  559.         }
  560.         OS_READHANDLE(curParam, espcom, 250);
  561.         OS_CLOSEHANDLE(espcom);
  562.  
  563.         res = sscanf(curParam, "%x %x %x %x %x %x %x %x %u %u %u %lu", &RBR_THR, &IER, &IIR_FCR, &LCR, &MCR, &LSR, &MSR, &SR, &divider, &comType, &espType, &espRetry);
  564.  
  565.         if (espRetry == 0)
  566.         {
  567.                 espRetry = 500000;
  568.         }
  569.  
  570.         puts("Config loaded:");
  571.         if (comType == 1)
  572.         {
  573.                 puts("     Controller IO port: 0x55fe");
  574.         }
  575.         else
  576.         {
  577.                 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);
  578.                 printf("     MCR    :0x%4x     LSR    :0x%4x\r\n     MSR    :0x%4x     SR     :0x%4x\r\n", MCR, LSR, MSR, SR);
  579.         }
  580.         printf("     DIV    :%u    TYPE    :%u    ESP    :%u    Retry  :%lu  \r\n", divider, comType, espType, espRetry);
  581.         switch (comType)
  582.         {
  583.         case 0:
  584.                 puts("     Port (16550 like w/o AFC)");
  585.                 break;
  586.         case 1:
  587.                 puts("     Port (ATM Turbo 2+)");
  588.                 break;
  589.         case 2:
  590.                 puts("     Port (16550 with AFC)");
  591.                 break;
  592.         case 3:
  593.                 puts("     Port (ATM2IOESP Card)");
  594.                 break;
  595.         default:
  596.                 puts("     Port (Unknown type)");
  597.                 break;
  598.         }
  599.         puts(" ");
  600.         YIELD();
  601. }
  602. ////////////////////////ESP32 PROCEDURES//////////////////////