Subversion Repositories NedoOS

Rev

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