?login_element?

Subversion Repositories NedoOS

Rev

Rev 2045 | Rev 2074 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download

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