Subversion Repositories NedoOS

Rev

Rev 2333 | 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:
  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:
  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.         switch (comType)
  220.         {
  221.         case 0:
  222.                 while ((1 & input(LSR)) == 0)
  223.                 {
  224.                         disable_interrupt();
  225.                         output(MCR, 2);
  226.                         output(MCR, 0);
  227.                         enable_interrupt();
  228.                 }
  229.                 return input(RBR_THR);
  230.         case 1:
  231.                 while (uart_hasByte() == 0)
  232.                 {
  233.                         disable_interrupt();
  234.                         input(0x55fe); // Переход в режим команд
  235.                         input(0x43fe); // Команда установить статус
  236.                         input(0x03fe); // Устанавливаем готовность DTR и RTS
  237.                         input(0x55fe); // Переход в режим команд
  238.                         input(0x43fe); // Команда установить статус
  239.                         input(0x00fe); // Снимаем готовность DTR и RTS
  240.                         enable_interrupt();
  241.                 }
  242.                 disable_interrupt();
  243.                 input(0x55fe);            // Переход в режим команд
  244.                 data = input(0x02fe); // Команда прочесть из порта
  245.                 enable_interrupt();
  246.                 return data;
  247.         case 2:
  248.                 while ((1 & input(LSR)) == 0)
  249.                 {
  250.                 }
  251.                 return input(RBR_THR);
  252.         case 3:
  253.                 while ((1 & portInput(LSR)) == 0)
  254.                 {
  255.                         disable_interrupt();
  256.                         output(0xfb, MCR);
  257.                         output(0xfa, 2);
  258.                         output(0xfa, 0);
  259.                         enable_interrupt();
  260.                 }
  261.                 disable_interrupt();
  262.                 output(0xfb, RBR_THR);
  263.                 data = input(0xfa);
  264.                 enable_interrupt();
  265.                 return data;
  266.         }
  267.         return 255;
  268. }
  269.  
  270. void uart_flush(void)
  271. {
  272.         uart_setrts(1);
  273.         delay(500);
  274.         uart_setrts(0);
  275. }
  276.  
  277. char getdataEsp(unsigned int counted)
  278. {
  279.         unsigned int counter, retry = 20000;
  280.         char status;
  281.         switch (comType)
  282.         {
  283.         case 0: // Kondratyev  NO AFC
  284.                 for (counter = 0; counter < counted; counter++)
  285.                 {
  286.                         do
  287.                         {
  288.                                 if (retry-- == 0)
  289.                                 {
  290.                                         return false;
  291.                                 }
  292.                                 disable_interrupt();
  293.                                 status = 1 & input(LSR);
  294.                                 output(MCR, 2);
  295.                                 output(MCR, 0);
  296.                                 enable_interrupt();
  297.  
  298.                         } while (!status);
  299.                         netbuf[counter] = input(RBR_THR);
  300.                 }
  301.                 break;
  302.         case 1: // ATM2 COM port
  303.                 for (counter = 0; counter < counted; counter++)
  304.                 {
  305.                         while (uart_hasByte() == 0)
  306.                         {
  307.                                 if (retry-- == 0)
  308.                                 {
  309.                                         return false;
  310.                                 }
  311.                                 disable_interrupt();
  312.                                 input(0x55fe); // Переход в режим команд
  313.                                 input(0x43fe); // Команда установить статус
  314.                                 input(0x03fe); // Устанавливаем готовность DTR и RTS
  315.                                 input(0x55fe); // Переход в режим команд
  316.                                 input(0x43fe); // Команда установить статус
  317.                                 input(0x00fe); // Снимаем готовность DTR и RTS
  318.                                 enable_interrupt();
  319.                         }
  320.                         disable_interrupt();
  321.                         input(0x55fe);                                   // Переход в режим команд
  322.                         netbuf[counter] = input(0x02fe); // Команда прочесть из порта
  323.                         enable_interrupt();
  324.                 }
  325.                 break;
  326.         case 2: // Kondratyev AFC
  327.                 for (counter = 0; counter < counted; counter++)
  328.                 {
  329.                         while ((1 & input(LSR)) == 0)
  330.                         {
  331.                                 if (retry-- == 0)
  332.                                 {
  333.                                         return false;
  334.                                 }
  335.                         }
  336.                         netbuf[counter] = input(RBR_THR);
  337.                 }
  338.                 break;
  339.         case 3: // ATM2IOESP
  340.                 for (counter = 0; counter < counted; counter++)
  341.                 {
  342.                         disable_interrupt();
  343.                         do
  344.                         {
  345.                                 if (retry-- == 0)
  346.                                 {
  347.                                         return false;
  348.                                 }
  349.                                 output(0xfb, LSR);
  350.                                 if ((1 & input(0xfa)) != 0)
  351.                                 {
  352.                                         break;
  353.                                 }
  354.                                 output(0xfb, MCR);
  355.                                 output(0xfa, 2);
  356.                                 output(0xfa, 0);
  357.                         } while (42);
  358.                         output(0xfb, RBR_THR);
  359.                         netbuf[counter] = input(0xfa);
  360.                         enable_interrupt();
  361.                 }
  362.                 break;
  363.         }
  364.         return true;
  365. }
  366.  
  367. void sendcommand(const char *commandline)
  368. {
  369.         unsigned int count, cmdLen;
  370.         cmdLen = strlen(commandline);
  371.         for (count = 0; count < cmdLen; count++)
  372.         {
  373.                 uart_write(commandline[count]);
  374.         }
  375.         uart_write('\r');
  376.         uart_write('\n');
  377.         // printf("Sended:[%s] \r\n", commandline);
  378. }
  379.  
  380. void sendcommandNrn(const char *commandline)
  381. {
  382.         unsigned int count, cmdLen;
  383.         cmdLen = strlen(commandline);
  384.         for (count = 0; count < cmdLen; count++)
  385.         {
  386.                 uart_write(commandline[count]);
  387.         }
  388.         // printf("[Nrn]Sended:[%s] \r\n", commandline);
  389. }
  390.  
  391. unsigned char getAnswer2(void)
  392. {
  393.         unsigned char readbyte;
  394.         unsigned int curPos = 0;
  395.         do
  396.         {
  397.                 readbyte = uart_readBlock();
  398.         } while (((readbyte == 0x0a) || (readbyte == 0x0d)));
  399.  
  400.         netbuf[curPos] = readbyte;
  401.         curPos++;
  402.         do
  403.         {
  404.                 readbyte = uart_readBlock();
  405.                 netbuf[curPos] = readbyte;
  406.                 curPos++;
  407.         } while (readbyte != 0x0d);
  408.         netbuf[curPos - 1] = 0;
  409.         uart_readBlock(); // 0xa
  410.         // printf("Answer:[%s]\r\n", netbuf);
  411.         // getchar();
  412.         return curPos;
  413. }
  414.  
  415. void espReBoot(void)
  416. {
  417.         unsigned char byte, count;
  418.         clearStatus();
  419.         printf("Resetting ESP...");
  420.  
  421.         uart_flush();
  422.  
  423.         sendcommand("AT+RST");
  424.         count = 0;
  425.  
  426.         do
  427.         {
  428.                 byte = uart_readBlock();
  429.                 if (byte == gotWiFi[count])
  430.                 {
  431.                         count++;
  432.                 }
  433.                 else
  434.                 {
  435.                         count = 0;
  436.                 }
  437.         } while (count < strlen(gotWiFi));
  438.         uart_readBlock(); // CR
  439.         uart_readBlock(); // LF
  440.         clearStatus();
  441.         printf("Reset complete.");
  442.         sendcommand("ATE0");
  443.         do
  444.         {
  445.                 byte = uart_readBlock();
  446.         } while (byte != 'K'); // OK
  447.         uart_readBlock(); // CR
  448.         uart_readBlock(); // LN
  449.         // puts("ATE0 Answer:[OK]");
  450.         sendcommand("AT+CIPCLOSE");
  451.         getAnswer2();
  452.         sendcommand("AT+CIPDINFO=0");
  453.         getAnswer2();
  454.         sendcommand("AT+CIPMUX=0");
  455.         getAnswer2();
  456.         sendcommand("AT+CIPSERVER=0");
  457.         getAnswer2();
  458.         sendcommand("AT+CIPRECVMODE=0");
  459.         getAnswer2();
  460. }
  461.  
  462. int recvHead(void)
  463. {
  464.         unsigned char byte, dataRead;
  465.         int todo = 0, count = 0, countErr = 0;
  466.         const char closed[] = "CLOSED";
  467.         const char error[] = "ERROR";
  468.         //+IPD<,length>:<data>
  469.         //+CIPRECVDATA:<actual_len>,<data>
  470.         dataRead = 0;
  471.         do
  472.         {
  473.                 byte = uart_readBlock();
  474.                 // printf("[%c]", byte);
  475.  
  476.                 if (byte == closed[count])
  477.                 {
  478.                         count++;
  479.                 }
  480.                 else
  481.                 {
  482.                         count = 0;
  483.                 }
  484.  
  485.                 if (byte == error[countErr])
  486.                 {
  487.                         countErr++;
  488.                 }
  489.                 else
  490.                 {
  491.                         countErr = 0;
  492.                 }
  493.                 if ((count == strlen(closed)) || (countErr == strlen(error)))
  494.                 {
  495.                         // uart_readBlock(); // CR
  496.                         // uart_readBlock(); // LF
  497.                         return todo;
  498.                 }
  499.         } while (byte != ',');
  500.  
  501.         do
  502.         {
  503.                 byte = uart_readBlock();
  504.                 netbuf[dataRead] = byte;
  505.                 dataRead++;
  506.         } while (byte != ':');
  507.         todo = atoi(netbuf);
  508.         // <actual_len>
  509.         // printf("recvHead(); todo = %d   ", todo);
  510.  
  511.         return todo;
  512. }
  513.  
  514. void loadEspConfig(void)
  515. {
  516.         unsigned char curParam[256];
  517.         unsigned char res;
  518.         FILE *espcom;
  519.         OS_SETSYSDRV();
  520.         OS_CHDIR("../ini");
  521.         espcom = OS_OPENHANDLE("espcom.ini", 0x80);
  522.         if (((int)espcom) & 0xff)
  523.         {
  524.                 clearStatus();
  525.                 printf("espcom.ini opening error");
  526.                 return;
  527.         }
  528.         OS_READHANDLE(curParam, espcom, 250);
  529.         OS_CLOSEHANDLE(espcom);
  530.  
  531.         res = sscanf(curParam, "%x %x %x %x %x %x %x %x %u %u %u", &RBR_THR, &IER, &IIR_FCR, &LCR, &MCR, &LSR, &MSR, &SR, &divider, &comType, &espType);
  532.         puts("Config loaded:");
  533.  
  534.         if (comType == 1)
  535.         {
  536.                 puts("     Controller IO port: 0x55fe");
  537.         }
  538.         else
  539.         {
  540.                 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);
  541.                 printf("     MCR    :0x%4x     LSR    :0x%4x\r\n     MSR    :0x%4x     SR     :0x%4x\r\n", MCR, LSR, MSR, SR);
  542.         }
  543.         printf("     DIV    :%u    TYPE    :%u    ESP    :%u ", divider, comType, espType);
  544.         switch (comType)
  545.         {
  546.         case 0:
  547.                 puts("(16550 like w/o AFC)");
  548.                 break;
  549.         case 1:
  550.                 puts("(ATM Turbo 2+)");
  551.                 break;
  552.         case 2:
  553.                 puts("(16550 with AFC)");
  554.                 break;
  555.         case 3:
  556.                 puts("(ATM2IOESP Card)");
  557.                 break;
  558.         default:
  559.                 puts("(Unknown type)");
  560.                 break;
  561.         }
  562.         puts(" ");
  563.         YIELD();
  564. }
  565. ////////////////////////ESP32 PROCEDURES//////////////////////