?login_element?

Subversion Repositories NedoOS

Rev

Rev 2051 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <string.h>
  4. #include <oscalls.h>
  5. #include <osfs.h>
  6. #include <intrz80.h>
  7. #include <terminal.c>
  8. unsigned int RBR_THR = 0xf8ef;
  9. unsigned int IER = 0xf9ef;
  10. unsigned int IIR_FCR = 0xfaef;
  11. unsigned int LCR = 0xfbef;
  12. unsigned int MCR = 0xfcef;
  13. unsigned int LSR = 0xfdef;
  14. unsigned int MSR = 0xfeef;
  15. unsigned int SR = 0xffef;
  16. unsigned int divider = 1;
  17. unsigned char comType = 0;
  18. unsigned int espType = 32;
  19. unsigned char directMode = 0;
  20.  
  21. unsigned char key;
  22. int bufferPos = 0;
  23. int endPos = 0;
  24. int curpos = 0;
  25. int oldpos = 0;
  26.  
  27. unsigned char buffer[8500];
  28.  
  29. void delay(unsigned long counter)
  30. {
  31.   unsigned long start, finish;
  32.   counter = counter / 20;
  33.   if (counter < 1)
  34.   {
  35.     counter = 1;
  36.   }
  37.   start = time();
  38.   finish = start + counter;
  39.  
  40.   while (start < finish)
  41.   {
  42.     start = time();
  43.   }
  44. }
  45.  
  46. void loadEspConfig(void)
  47. {
  48.   unsigned char curParam[256];
  49.   unsigned char res;
  50.   FILE *espcom;
  51.   OS_SETSYSDRV();
  52.   OS_CHDIR("browser");
  53.   espcom = OS_OPENHANDLE("espcom.ini", 0x80);
  54.   if (((int)espcom) & 0xff)
  55.   {
  56.     printf("mrfesp.ini opening error\r\n");
  57.     return;
  58.   }
  59.  
  60.   OS_READHANDLE(curParam, espcom, 256);
  61.  
  62.   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);
  63.  
  64.   if (comType == 1)
  65.   {
  66.     puts("     Controller base port: 0x55fe");
  67.   }
  68.   else
  69.   {
  70.     printf("     RBR_THR:0x%4x\r\n     IER    :0x%4x\r\n     IIR_FCR:0x%4x\r\n     LCR    :0x%4x\r\n", RBR_THR, IER, IIR_FCR, LCR);
  71.     printf("     MCR    :0x%4x\r\n     LSR    :0x%4x\r\n     MSR    :0x%4x\r\n     SR     :0x%4x\r\n", MCR, LSR, MSR, SR);
  72.   }
  73.   printf("     DIVIDER:%u  ESP:%u  TYPE:%u", divider, espType, comType);
  74.  
  75.   switch (comType)
  76.   {
  77.   case 0:
  78.     puts("(16550 like w/o AFC)");
  79.     break;
  80.   case 1:
  81.     puts("(ATM Turbo 2+)");
  82.     break;
  83.   case 2:
  84.     puts("(16550 like with AFC)");
  85.   default:
  86.     puts("(Unknown type)");
  87.     break;
  88.   }
  89. }
  90.  
  91. void uart_init(unsigned char divisor)
  92. {
  93.   switch (comType)
  94.   {
  95.   case 0:
  96.   case 2:
  97.     output(MCR, 0x00);        // Disable input
  98.     output(IIR_FCR, 0x87);    // Enable fifo 8 level, and clear it
  99.     output(LCR, 0x83);        // 8n1, DLAB=1
  100.     output(RBR_THR, divisor); // 115200 (divider 1-115200, 3 - 38400)
  101.     output(IER, 0x00);        // (divider 0). Divider is 16 bit, so we get (#0002 divider)
  102.     output(LCR, 0x03);        // 8n1, DLAB=0
  103.     output(IER, 0x00);        // Disable int
  104.     output(MCR, 0x2f);        // Enable AFE
  105.     break;
  106.   case 1:
  107.     disable_interrupt();
  108.     input(0x55fe);
  109.     input(0xc3fe);
  110.     input((divisor << 8) | 0x00fe);
  111.     enable_interrupt();
  112.     break;
  113.   }
  114. }
  115.  
  116. void uart_write(unsigned char data)
  117. {
  118.   unsigned char status;
  119.   switch (comType)
  120.   {
  121.   case 0:
  122.   case 2:
  123.     while ((input(LSR) & 64) == 0)
  124.     {
  125.     }
  126.     output(RBR_THR, data);
  127.     break;
  128.   case 1:
  129.     disable_interrupt();
  130.     do
  131.     {
  132.       input(0x55fe);          // Переход в режим команд
  133.       status = input(0x42fe); // Команда прочесть статус
  134.     } while ((status & 64) == 0); // Проверяем 6 бит
  135.  
  136.     input(0x55fe);               // Переход в режим команд
  137.     input(0x03fe);               // Команда записать в порт
  138.     input((data << 8) | 0x00fe); // Записываем data в порт
  139.     enable_interrupt();
  140.     break;
  141.   }
  142. }
  143.  
  144. void uart_setrts(unsigned char mode)
  145. {
  146.   switch (comType)
  147.   {
  148.   case 0:
  149.     switch (mode)
  150.     {
  151.     case 1:
  152.       output(MCR, 2);
  153.       break;
  154.     case 0:
  155.       output(MCR, 0);
  156.       break;
  157.     default:
  158.       disable_interrupt();
  159.       output(MCR, 2);
  160.       output(MCR, 0);
  161.       enable_interrupt();
  162.       break;
  163.     }
  164.   case 1:
  165.     switch (mode)
  166.     {
  167.     case 1:
  168.       disable_interrupt();
  169.       input(0x55fe); // Переход в режим команд
  170.       input(0x43fe); // Команда установить статус
  171.       input(0x03fe); // Устанавливаем готовность DTR и RTS
  172.       enable_interrupt();
  173.       break;
  174.     case 0:
  175.       disable_interrupt();
  176.       input(0x55fe); // Переход в режим команд
  177.       input(0x43fe); // Команда установить статус
  178.       input(0x00fe); // Снимаем готовность DTR и RTS
  179.       enable_interrupt();
  180.       break;
  181.     default:
  182.       disable_interrupt();
  183.       input(0x55fe); // Переход в режим команд
  184.       input(0x43fe); // Команда установить статус
  185.       input(0x03fe); // Устанавливаем готовность DTR и RTS
  186.       input(0x55fe); // Переход в режим команд
  187.       input(0x43fe); // Команда установить статус
  188.       input(0x00fe); // Снимаем готовность DTR и RTS
  189.       enable_interrupt();
  190.       break;
  191.     }
  192.   case 2:
  193.     break;
  194.   }
  195. }
  196. unsigned char uart_hasByte(void)
  197. {
  198.   unsigned char queue;
  199.   switch (comType)
  200.   {
  201.   case 0:
  202.   case 2:
  203.     return (1 & input(LSR));
  204.   case 1:
  205.     disable_interrupt();
  206.     input(0x55fe);         // Переход в режим команд
  207.     queue = input(0xc2fe); // Получаем количество байт в приемном буфере
  208.     enable_interrupt();
  209.     return queue;
  210.   }
  211.   return 255;
  212. }
  213.  
  214. unsigned char uart_readBlock(void)
  215. {
  216.   unsigned char data;
  217.   switch (comType)
  218.   {
  219.   case 0:
  220.     while (uart_hasByte() == 0)
  221.     {
  222.       uart_setrts(2);
  223.     }
  224.     return input(RBR_THR);
  225.   case 1:
  226.     while (uart_hasByte == 0)
  227.     {
  228.       uart_setrts(2);
  229.     }
  230.     disable_interrupt();
  231.     input(0x55fe);        // Переход в режим команд
  232.     data = input(0x02fe); // Команда прочесть из порта
  233.     enable_interrupt();
  234.     return data;
  235.   case 2:
  236.     while (uart_hasByte() == 0)
  237.     {
  238.     }
  239.     return input(RBR_THR);
  240.   }
  241.   return 255;
  242. }
  243.  
  244. unsigned char uart_read(void)
  245. {
  246.   unsigned char data;
  247.   switch (comType)
  248.   {
  249.   case 0:
  250.   case 2:
  251.     return input(RBR_THR);
  252.   case 1:
  253.     disable_interrupt();
  254.     input(0x55fe);        // Переход в режим команд
  255.     data = input(0x02fe); // Команда прочесть из порта
  256.     enable_interrupt();
  257.     return data;
  258.   }
  259.   return 255;
  260. }
  261.  
  262. void getdata(void)
  263. {
  264.   uart_setrts(2);
  265.   while (uart_hasByte() != 0)
  266.   {
  267.     buffer[bufferPos] = uart_read();
  268.     bufferPos++;
  269.     uart_setrts(2);
  270.   }
  271.   if (bufferPos > 8191)
  272.   {
  273.     endPos = bufferPos;
  274.     bufferPos = 0;
  275.   }
  276. }
  277.  
  278. void renderWin(void)
  279. {
  280.   for (curpos = oldpos; curpos < bufferPos; curpos++)
  281.   {
  282.     putchar(buffer[curpos]);
  283.   }
  284.   oldpos = curpos;
  285. }
  286.  
  287. void sendcommand(char *commandline)
  288. {
  289.   unsigned int count, cmdLen;
  290.   cmdLen = strlen(commandline);
  291.   for (count = 0; count < cmdLen; count++)
  292.   {
  293.     uart_write(commandline[count]);
  294.   }
  295.   uart_write('\r');
  296.   uart_write('\n');
  297.   // printf("Sended:[%s] \r\n", commandline);
  298.   YIELD();
  299. }
  300.  
  301. void saveBuff(void)
  302. {
  303.   int len;
  304.   unsigned long size;
  305.   FILE *fp1;
  306.   unsigned char crlf[2] = {13, 10};
  307.   fp1 = OS_OPENHANDLE("buffer.log", 0x80);
  308.   if (((int)fp1) & 0xff)
  309.   {
  310.     puts("Open buffer.log error");
  311.     puts("Creating buffer.log file");
  312.     fp1 = OS_CREATEHANDLE("buffer.log", 0x80);
  313.     if (((int)fp1) & 0xff)
  314.     {
  315.       puts("Create buffer.log error");
  316.       return;
  317.     }
  318.     OS_CLOSEHANDLE(fp1);
  319.     fp1 = OS_OPENHANDLE("buffer.log", 0x80);
  320.     if (((int)fp1) & 0xff)
  321.     {
  322.       puts("Open buffer.log error");
  323.       return;
  324.     }
  325.   }
  326.   size = OS_GETFILESIZE(fp1);
  327.   len = curpos;
  328.   OS_SEEKHANDLE(fp1, size);
  329.   OS_WRITEHANDLE(crlf, fp1, 2);
  330.   OS_WRITEHANDLE("********************************************************************************", fp1, 80);
  331.   OS_WRITEHANDLE(crlf, fp1, 2);
  332.   OS_WRITEHANDLE(buffer, fp1, len);
  333.   OS_CLOSEHANDLE(fp1);
  334.   puts("buffer.log saved.");
  335. }
  336.  
  337. void testQueue(void)
  338. {
  339.   sendcommand("AT+CIPMUX=0");
  340.  
  341.   sendcommand("AT+CIPSERVER=0");
  342.   sendcommand("AT+CIPDINFO=0");
  343.   sendcommand("AT+CIPRECVMODE=1");
  344.   sendcommand("AT+CIPSTART=\"TCP\",\"ti6.nedopc.com\",80");
  345.   delay(1000);
  346.   sendcommand("AT+CIPSEND=132");
  347.   sendcommand("GET /attachments/pages/your_game6_160.png HTTP/1.1\r\nHost: ti6.nedopc.com\r\nUser-Agent: Mozilla/4.0 (compatible; MSIE5.01; NedoOS)\r\n");
  348.   delay(1000);
  349.   sendcommand("AT+CIPRECVDATA=5000");
  350. }
  351. C_task main(void)
  352. {
  353.   unsigned char cmd[512];
  354.   unsigned char cmdpos;
  355.   os_initstdio();
  356.   BOX(1, 1, 80, 25, 40);
  357.   AT(25, 1);
  358.   ATRIB(92);
  359.   puts("[UART COMMUNICATION PROGRAMM]");
  360.   loadEspConfig();
  361.  
  362.   uart_init(divider);
  363.   printf("\r\nUart inited. Divider (%u)\r\n", divider);
  364.   puts("===============================================================================");
  365.   delay(250);
  366.   cmd[0] = 0;
  367.   cmdpos = 0;
  368.   while (1)
  369.   {
  370.     unsigned char count;
  371.     getdata();
  372.     renderWin();
  373.     key = _low_level_get();
  374.  
  375.     if (directMode == 1 && key != 0)
  376.     {
  377.       if (key == 30)
  378.       {
  379.         directMode = 0;
  380.         key = 0;
  381.         puts("\r\nDirect mode disabled.");
  382.       }
  383.       else
  384.       {
  385.         uart_write(key);
  386.         if (key == 13)
  387.         {
  388.           uart_write(10);
  389.           putchar('\r');
  390.           putchar('\n');
  391.         }
  392.       }
  393.     }
  394.     if (key != 0 && directMode == 0)
  395.     {
  396.       // printf("key = %u   ", key);
  397.       switch (key)
  398.       {
  399.       case 177:
  400.         uart_init(1);
  401.         puts("Uart inited @ 115200 [Div:1]");
  402.         key = 0;
  403.         break;
  404.  
  405.       case 178:
  406.         uart_init(2);
  407.         puts("Uart inited @ 57600 [Div:2]");
  408.         key = 0;
  409.         break;
  410.  
  411.       case 179:
  412.         uart_init(3);
  413.         puts("Uart inited @ 38400 [Div:3]");
  414.         key = 0;
  415.         break;
  416.  
  417.       case 180:
  418.         uart_init(4);
  419.         puts("Uart inited @ 28800 [Div:4]");
  420.         key = 0;
  421.         break;
  422.  
  423.       case 181:
  424.         uart_init(6);
  425.         puts("Uart inited @ 19200 [Div:6]");
  426.         key = 0;
  427.         break;
  428.  
  429.       case 182:
  430.         uart_init(8);
  431.         puts("Uart inited @ 14400 [Div:8]");
  432.         key = 0;
  433.         break;
  434.  
  435.       case 183:
  436.         uart_init(12);
  437.         puts("Uart inited @ 9600 [Div:12]");
  438.         key = 0;
  439.         break;
  440.  
  441.       case 184:
  442.         uart_init(24);
  443.         puts("Uart inited @ 4800 [Div:24]");
  444.         key = 0;
  445.         break;
  446.  
  447.       case 185:
  448.         uart_init(48);
  449.         puts("Uart inited @ 2400 [Div:48]");
  450.         key = 0;
  451.         break;
  452.  
  453.       case 176:
  454.         uart_init(96);
  455.         puts("Uart inited @ 1200 [Div:96]");
  456.         key = 0;
  457.         break;
  458.  
  459.       case 13:
  460.         cmd[cmdpos] = 0;
  461.         sendcommand(cmd);
  462.         cmdpos = 0;
  463.         cmd[cmdpos] = 0;
  464.         putchar('\r');
  465.         putchar('\n');
  466.         key = 0;
  467.         break;
  468.  
  469.       case 19:
  470.         saveBuff();
  471.         key = 0;
  472.         break;
  473.  
  474.       case 27:
  475.         exit(0);
  476.  
  477.       case 8:
  478.         if (cmdpos != 0)
  479.         {
  480.           cmdpos--;
  481.           cmd[cmdpos] = 0;
  482.           putchar('\r');
  483.           for (count = 0; count < cmdpos + 1; count++)
  484.           {
  485.             putchar(' ');
  486.           }
  487.           putchar('\r');
  488.           count = 0;
  489.           while (cmd[count] != 0)
  490.           {
  491.             putchar(cmd[count]);
  492.             count++;
  493.           }
  494.         }
  495.         key = 0;
  496.         break;
  497.  
  498.       case 246: // PgUp
  499.         sendcommand("AT+GMR");
  500.         key = 0;
  501.         break;
  502.  
  503.       case 30: // End
  504.         directMode = 1;
  505.         puts("\r\nDirect mode enabled.");
  506.  
  507.         key = 0;
  508.         break;
  509.  
  510.       case 28: // home
  511.         testQueue();
  512.         key = 0;
  513.         break;
  514.  
  515.       case 21: // <ext> + <U>
  516.         // sendcommand("AT+CIUPDATE");
  517.         sendcommand("AT+CIPSNTPTIME?");
  518.         delay(1000);
  519.         sendcommand("AT+CIPSNTPCFG=1,300,\"0.pool.ntp.org\",\"time.google.com\"");
  520.         delay(1000);
  521.         sendcommand("AT+CIPSNTPTIME?");
  522.         key = 0;
  523.         break;
  524.       }
  525.     }
  526.  
  527.     if (key != 0)
  528.     {
  529.       cmd[cmdpos] = key;
  530.       cmdpos++;
  531.       putchar(key);
  532.     }
  533.   }
  534.   return 0;
  535. }
  536.