?login_element?

Subversion Repositories NedoOS

Rev

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

  1. ////////////////////////ESP32 PROCEDURES//////////////////////
  2. void uart_write(unsigned char data)
  3. {
  4.         unsigned char status;
  5.         switch (comType)
  6.         {
  7.         case 0:
  8.         case 2:
  9.                 while ((input(LSR) & 64) == 0)
  10.                 {
  11.                 }
  12.                 output(RBR_THR, data);
  13.                 break;
  14.         case 1:
  15.                 disable_interrupt();
  16.                 do
  17.                 {
  18.                         input(0x55fe);                  // Переход в режим команд
  19.                         status = input(0x42fe); // Команда прочесть статус
  20.                 } while ((status & 64) == 0); // Проверяем 6 бит
  21.  
  22.                 input(0x55fe);                           // Переход в режим команд
  23.                 input(0x03fe);                           // Команда записать в порт
  24.                 input((data << 8) | 0x00fe); // Записываем data в порт
  25.                 enable_interrupt();
  26.                 break;
  27.         }
  28. }
  29.  
  30. void uart_setrts(unsigned char mode)
  31. {
  32.         switch (comType)
  33.         {
  34.         case 0:
  35.                 switch (mode)
  36.                 {
  37.                 case 1:
  38.                         output(MCR, 2);
  39.                         break;
  40.                 case 0:
  41.                         output(MCR, 0);
  42.                         break;
  43.                 default:
  44.                         disable_interrupt();
  45.                         output(MCR, 2);
  46.                         output(MCR, 0);
  47.                         enable_interrupt();
  48.                         break;
  49.                 }
  50.         case 1:
  51.                 switch (mode)
  52.                 {
  53.                 case 1:
  54.                         disable_interrupt();
  55.                         input(0x55fe); // Переход в режим команд
  56.                         input(0x43fe); // Команда установить статус
  57.                         input(0x03fe); // Устанавливаем готовность DTR и RTS
  58.                         enable_interrupt();
  59.                         break;
  60.                 case 0:
  61.                         disable_interrupt();
  62.                         input(0x55fe); // Переход в режим команд
  63.                         input(0x43fe); // Команда установить статус
  64.                         input(0x00fe); // Снимаем готовность DTR и RTS
  65.                         enable_interrupt();
  66.                         break;
  67.                 default:
  68.                         disable_interrupt();
  69.                         input(0x55fe); // Переход в режим команд
  70.                         input(0x43fe); // Команда установить статус
  71.                         input(0x03fe); // Устанавливаем готовность DTR и RTS
  72.                         input(0x55fe); // Переход в режим команд
  73.                         input(0x43fe); // Команда установить статус
  74.                         input(0x00fe); // Снимаем готовность DTR и RTS
  75.                         enable_interrupt();
  76.                         break;
  77.                 }
  78.         case 2:
  79.                 break;
  80.         }
  81. }
  82.  
  83. void uart_init(unsigned char divisor)
  84. {
  85.         switch (comType)
  86.         {
  87.         case 0:
  88.         case 2:
  89.                 // output(MCR, 0x00);             // Disable input
  90.                 output(IIR_FCR, 0x87);    // Enable fifo 8 level, and clear it
  91.                 output(LCR, 0x83);                // 8n1, DLAB=1
  92.                 output(RBR_THR, divisor); // 115200 (divider 1-115200, 3 - 38400)
  93.                 output(IER, 0x00);                // (divider 0). Divider is 16 bit, so we get (#0002 divider)
  94.                 output(LCR, 0x03);                // 8n1, DLAB=0
  95.                 output(IER, 0x00);                // Disable int
  96.                 output(MCR, 0x2f);                // Enable AFE
  97.                 break;
  98.         case 1:
  99.                 disable_interrupt();
  100.                 input(0x55fe);
  101.                 input(0xc3fe);
  102.                 input((divisor << 8) | 0x00fe);
  103.                 enable_interrupt();
  104.                 uart_setrts(1);
  105.                 break;
  106.         }
  107. }
  108.  
  109. unsigned char uart_hasByte(void)
  110. {
  111.         unsigned char queue;
  112.         switch (comType)
  113.         {
  114.         case 0:
  115.         case 2:
  116.                 return (1 & input(LSR));
  117.         case 1:
  118.                 disable_interrupt();
  119.                 input(0x55fe);             // Переход в режим команд
  120.                 queue = input(0xc2fe); // Получаем количество байт в приемном буфере
  121.                 enable_interrupt();
  122.                 return queue;
  123.         }
  124.         return 255;
  125. }
  126.  
  127. unsigned char uart_read(void)
  128. {
  129.         unsigned char data;
  130.         switch (comType)
  131.         {
  132.         case 0:
  133.         case 2:
  134.                 return input(RBR_THR);
  135.         case 1:
  136.                 disable_interrupt();
  137.                 input(0x55fe);            // Переход в режим команд
  138.                 data = input(0x02fe); // Команда прочесть из порта
  139.                 enable_interrupt();
  140.                 return data;
  141.         }
  142.         return 255;
  143. }
  144.  
  145. unsigned char uart_readBlock(void)
  146. {
  147.         unsigned char data;
  148.         switch (comType)
  149.         {
  150.         case 0:
  151.                 while (uart_hasByte() == 0)
  152.                 {
  153.                         uart_setrts(2);
  154.                 }
  155.                 return input(RBR_THR);
  156.         case 1:
  157.                 while (uart_hasByte() == 0)
  158.                 {
  159.                         uart_setrts(2);
  160.                 }
  161.                 disable_interrupt();
  162.                 input(0x55fe);            // Переход в режим команд
  163.                 data = input(0x02fe); // Команда прочесть из порта
  164.                 enable_interrupt();
  165.                 return data;
  166.         case 2:
  167.                 while (uart_hasByte() == 0)
  168.                 {
  169.                 }
  170.                 return input(RBR_THR);
  171.         }
  172.         return 255;
  173. }
  174.  
  175. void uart_flush(void)
  176. {
  177.         unsigned int count;
  178.         for (count = 0; count < 6000; count++)
  179.         {
  180.                 uart_setrts(1);
  181.                 uart_read();
  182.         }
  183. }
  184.  
  185. void getdataEsp(unsigned int counted)
  186. {
  187.         unsigned int counter;
  188.         for (counter = 0; counter < counted; counter++)
  189.         {
  190.                 if (counter == sizeof(netbuf) - 1)
  191.                 {
  192.                         printf("netbuf overflow [%u] of [%u]\r\n", counter, sizeof(netbuf));
  193.                         getchar();
  194.                         break;
  195.                 }
  196.                 netbuf[counter] = uart_readBlock();
  197.         }
  198. }
  199.  
  200. void sendcommand(const char *commandline)
  201. {
  202.         unsigned int count, cmdLen;
  203.         cmdLen = strlen(commandline);
  204.         for (count = 0; count < cmdLen; count++)
  205.         {
  206.                 uart_write(commandline[count]);
  207.         }
  208.         uart_write('\r');
  209.         uart_write('\n');
  210.         // printf("Sended:[%s] \r\n", commandline);
  211. }
  212.  
  213. void sendcommandNrn(const char *commandline)
  214. {
  215.         unsigned int count, cmdLen;
  216.         cmdLen = strlen(commandline);
  217.         for (count = 0; count < cmdLen; count++)
  218.         {
  219.                 uart_write(commandline[count]);
  220.         }
  221.         // printf("Sended:[%s] \r\n", commandline);
  222. }
  223.  
  224. unsigned char getAnswer2(void)
  225. {
  226.         unsigned char readbyte;
  227.         unsigned int curPos = 0;
  228.         do
  229.         {
  230.                 readbyte = uart_readBlock();
  231.                 // putdec(readbyte);
  232.         } while (((readbyte == 0x0a) || (readbyte == 0x0d)));
  233.  
  234.         netbuf[curPos] = readbyte;
  235.         curPos++;
  236.         do
  237.         {
  238.                 readbyte = uart_readBlock();
  239.                 netbuf[curPos] = readbyte;
  240.                 curPos++;
  241.         } while (readbyte != 0x0d);
  242.         netbuf[curPos - 1] = 0;
  243.         uart_readBlock(); // 0xa
  244.         // printf("Answer:[%s]\r\n", netbuf);
  245.         // getchar();
  246.         return curPos;
  247. }
  248.  
  249. void espReBoot(void)
  250. {
  251.         unsigned char byte, count;
  252.         uart_flush();
  253.         sendcommand("AT+RST");
  254.         clearStatus();
  255.         printf("Resetting ESP...");
  256.         count = 0;
  257.  
  258.         do
  259.         {
  260.                 byte = uart_readBlock();
  261.                 if (byte == gotWiFi[count])
  262.                 {
  263.                         count++;
  264.                 }
  265.                 else
  266.                 {
  267.                         count = 0;
  268.                 }
  269.         } while (count < strlen(gotWiFi));
  270.         uart_readBlock(); // CR
  271.         uart_readBlock(); // LF
  272.         clearStatus();
  273.         printf("Reset complete.");
  274.  
  275.         sendcommand("ATE0");
  276.         do
  277.         {
  278.                 byte = uart_readBlock();
  279.         } while (byte != 'K'); // OK
  280.         // puts("ATE0 Answer:[OK]");
  281.         uart_readBlock(); // CR
  282.         uart_readBlock(); // LN
  283.  
  284.         sendcommand("AT+CIPCLOSE");
  285.         getAnswer2();
  286.         sendcommand("AT+CIPDINFO=0");
  287.         getAnswer2();
  288.         sendcommand("AT+CIPMUX=0");
  289.         getAnswer2();
  290.         sendcommand("AT+CIPSERVER=0");
  291.         getAnswer2();
  292.         sendcommand("AT+CIPRECVMODE=0");
  293.         getAnswer2();
  294. }
  295.  
  296. unsigned int recvHead(void)
  297. {
  298.         unsigned char byte, dataRead;
  299.         unsigned int loaded, count = 0;
  300.         const char closed[] = "CLOSED";
  301.         do
  302.         {
  303.                 byte = uart_readBlock();
  304.                 if (byte == closed[count])
  305.                 {
  306.                         count++;
  307.                 }
  308.                 else
  309.                 {
  310.                         count = 0;
  311.                 }
  312.                 if (count == strlen(closed))
  313.                 {
  314.                         return 0;
  315.                 }
  316.         } while (byte != ',');
  317.         dataRead = 0;
  318.         do
  319.         {
  320.                 byte = uart_readBlock();
  321.                 netbuf[dataRead] = byte;
  322.                 dataRead++;
  323.         } while (byte != ':');
  324.         // netbuf[dataRead] = 0;
  325.         loaded = atoi(netbuf); // <actual_len>
  326.         // printf("\r\n loaded %u\r\n", loaded);
  327.         return loaded;
  328. }
  329.  
  330. void loadEspConfig(void)
  331. {
  332.         unsigned char curParam[256];
  333.         unsigned char res;
  334.         FILE *espcom;
  335.         OS_SETSYSDRV();
  336.         OS_CHDIR("../ini");
  337.         espcom = OS_OPENHANDLE("espcom.ini", 0x80);
  338.         if (((int)espcom) & 0xff)
  339.         {
  340.                 clearStatus();
  341.                 printf("espcom.ini opening error");
  342.                 return;
  343.         }
  344.         OS_READHANDLE(curParam, espcom, 250);
  345.         OS_CLOSEHANDLE(espcom);
  346.  
  347.         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);
  348.         puts("Config loaded:");
  349.         if (comType == 1)
  350.         {
  351.                 puts("     Controller base port: 0x55fe");
  352.         }
  353.         else
  354.         {
  355.                 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);
  356.                 printf("     MCR    :0x%4x     LSR    :0x%4x\r\n     MSR    :0x%4x     SR     :0x%4x\r\n", MCR, LSR, MSR, SR);
  357.         }
  358.         printf("     DIV    :%u    TYPE    :%u    ESP    :%u ", divider, comType, espType);
  359.         switch (comType)
  360.         {
  361.         case 0:
  362.                 puts("(16550 like w/o AFC)");
  363.                 break;
  364.         case 1:
  365.                 puts("(ATM Turbo 2+)");
  366.                 break;
  367.         case 2:
  368.                 puts("(16550 with AFC)");
  369.         default:
  370.                 puts("(Unknown type)");
  371.                 break;
  372.         }
  373. }
  374. ////////////////////////ESP32 PROCEDURES//////////////////////