?login_element?

Subversion Repositories NedoOS

Rev

Rev 2046 | 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 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.     data = 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.     data = 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.         key = 0;
  373.         puts("\r\nDirect mode disabled.");
  374.       }
  375.       else
  376.       {
  377.         uart_write(key);
  378.         if (key == 13)
  379.         {
  380.           uart_write(10);
  381.           putchar('\r');
  382.           putchar('\n');
  383.         }
  384.       }
  385.     }
  386.     if (key != 0 && directMode == 0)
  387.     {
  388.       // printf("key = %u   ", key);
  389.       switch (key)
  390.       {
  391.       case 177:
  392.         uart_init(1);
  393.         puts("Uart inited @ 115200 [Div:1]");
  394.         key = 0;
  395.         break;
  396.  
  397.       case 178:
  398.         uart_init(2);
  399.         puts("Uart inited @ 57600 [Div:2]");
  400.         key = 0;
  401.         break;
  402.  
  403.       case 179:
  404.         uart_init(3);
  405.         puts("Uart inited @ 38400 [Div:3]");
  406.         key = 0;
  407.         break;
  408.  
  409.       case 180:
  410.         uart_init(4);
  411.         puts("Uart inited @ 28800 [Div:4]");
  412.         key = 0;
  413.         break;
  414.  
  415.       case 181:
  416.         uart_init(6);
  417.         puts("Uart inited @ 19200 [Div:6]");
  418.         key = 0;
  419.         break;
  420.  
  421.       case 182:
  422.         uart_init(8);
  423.         puts("Uart inited @ 14400 [Div:8]");
  424.         key = 0;
  425.         break;
  426.  
  427.       case 183:
  428.         uart_init(12);
  429.         puts("Uart inited @ 9600 [Div:12]");
  430.         key = 0;
  431.         break;
  432.  
  433.       case 184:
  434.         uart_init(24);
  435.         puts("Uart inited @ 4800 [Div:24]");
  436.         key = 0;
  437.         break;
  438.  
  439.       case 185:
  440.         uart_init(48);
  441.         puts("Uart inited @ 2400 [Div:48]");
  442.         key = 0;
  443.         break;
  444.  
  445.       case 176:
  446.         uart_init(96);
  447.         puts("Uart inited @ 1200 [Div:96]");
  448.         key = 0;
  449.         break;
  450.  
  451.       case 13:
  452.         cmd[cmdpos] = 0;
  453.         sendcommand(cmd);
  454.         cmdpos = 0;
  455.         cmd[cmdpos] = 0;
  456.         putchar('\r');
  457.         putchar('\n');
  458.         key = 0;
  459.         break;
  460.  
  461.       case 19:
  462.         saveBuff();
  463.         key = 0;
  464.         break;
  465.  
  466.       case 27:
  467.         exit(0);
  468.  
  469.       case 8:
  470.         if (cmdpos != 0)
  471.         {
  472.           cmdpos--;
  473.           cmd[cmdpos] = 0;
  474.           putchar('\r');
  475.           for (count = 0; count < cmdpos + 1; count++)
  476.           {
  477.             putchar(' ');
  478.           }
  479.           putchar('\r');
  480.           count = 0;
  481.           while (cmd[count] != 0)
  482.           {
  483.             putchar(cmd[count]);
  484.             count++;
  485.           }
  486.         }
  487.         key = 0;
  488.         break;
  489.  
  490.       case 246: // PgUp
  491.         sendcommand("AT+GMR");
  492.         key = 0;
  493.         break;
  494.  
  495.       case 30: // End
  496.         directMode = 1;
  497.         puts("\r\nDirect mode enabled.");
  498.  
  499.         key = 0;
  500.         break;
  501.  
  502.       case 28: // home
  503.         testQueue();
  504.         key = 0;
  505.         break;
  506.  
  507.       case 21: // <ext> + <U>
  508.         sendcommand("AT+CIUPDATE");
  509.         key = 0;
  510.         break;
  511.       }
  512.     }
  513.  
  514.     if (key != 0)
  515.     {
  516.       cmd[cmdpos] = key;
  517.       cmdpos++;
  518.       putchar(key);
  519.     }
  520.   }
  521.   return 0;
  522. }
  523.