?login_element?

Subversion Repositories NedoOS

Rev

Rev 1932 | Rev 2041 | 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. #define RBR_THR 0xF8EF
  9. #define IER 0xF9EF
  10. #define IIR_FCR 0xFAEF
  11. #define LCR 0xFBEF
  12. #define MCR 0xFCEF
  13. #define LSR 0xFDEF
  14. #define MSR 0xFEEF
  15. #define SR 0xFFEF
  16.  
  17. unsigned char key;
  18. unsigned char buffer[8500] = "";
  19. int bufferPos;
  20. int endPos;
  21. int curpos;
  22. int oldpos;
  23.  
  24. void delay(unsigned long counter)
  25. {
  26.   unsigned long start, finish;
  27.   counter = counter / 20;
  28.   if (counter < 1)
  29.   {
  30.     counter = 1;
  31.   }
  32.   start = time();
  33.   finish = start + counter;
  34.  
  35.   while (start < finish)
  36.   {
  37.     start = time();
  38.   }
  39. }
  40.  
  41. void uart_init(unsigned char divisor)
  42. {
  43.   output(MCR, 0x00);        // Disable input
  44.   output(IIR_FCR, 0x87);    // Enable fifo 8 level, and clear it
  45.   output(LCR, 0x83);        // 8n1, DLAB=1
  46.   output(RBR_THR, divisor); // 115200 (divider 1-115200, 3 - 38400)
  47.   output(IER, 0x00);        // (divider 0). Divider is 16 bit, so we get (#0002 divider)
  48.   output(LCR, 0x03);        // 8n1, DLAB=0
  49.   output(IER, 0x00);        // Disable int
  50. }
  51.  
  52. void uart_write(unsigned char data)
  53. {
  54.   while ((input(LSR) & 32) >> 5 == 0)
  55.   {
  56.   }
  57.   output(RBR_THR, data);
  58. }
  59.  
  60. void uart_flashrts(void)
  61. {
  62.   disable_interrupt();
  63.   output(MCR, 2);
  64.   output(MCR, 0);
  65.   enable_interrupt();
  66. }
  67.  
  68. unsigned char uart_hasByte(void)
  69. {
  70.   unsigned char queue;
  71.   queue = input(LSR);
  72.   queue = queue & 1;
  73.   return queue;
  74. }
  75.  
  76. unsigned char uart_read(void)
  77. {
  78.   unsigned char data;
  79.   data = input(RBR_THR);
  80.   return data;
  81. }
  82.  
  83. void getdata(void)
  84. {
  85.   unsigned char readbyte;
  86.   uart_flashrts();
  87.   while (uart_hasByte() != 0)
  88.   {
  89.     uart_flashrts();
  90.     readbyte = uart_read();
  91.     buffer[bufferPos] = readbyte;
  92.     bufferPos++;
  93.   }
  94.   if (bufferPos > 8191)
  95.   {
  96.     endPos = bufferPos;
  97.     bufferPos = 0;
  98.   }
  99. }
  100.  
  101. void renderWin(void)
  102. {
  103.   for (curpos = oldpos; curpos < bufferPos; curpos++)
  104.   {
  105.     putchar(buffer[curpos]);
  106.   }
  107.   oldpos = curpos;
  108. }
  109.  
  110. void sendcommand(char commandline[])
  111. {
  112.   int pos = 0;
  113.   while (commandline[pos] != '\0')
  114.   {
  115.     uart_write(commandline[pos]);
  116.     pos++;
  117.   }
  118.   uart_write('\r');
  119.   uart_write('\n');
  120.   delay(100);
  121. }
  122.  
  123. void saveBuff(void)
  124. {
  125.   int len;
  126.   unsigned long size;
  127.   FILE *fp1;
  128.   unsigned char crlf[2] = {13, 10};
  129.   fp1 = OS_OPENHANDLE("buffer.log", 0x80);
  130.   if (((int)fp1) & 0xff)
  131.   {
  132.     puts("Open buffer.log error");
  133.     puts("Creating buffer.log file");
  134.     fp1 = OS_CREATEHANDLE("buffer.log", 0x80);
  135.     if (((int)fp1) & 0xff)
  136.     {
  137.       puts("Create buffer.log error");
  138.       return;
  139.     }
  140.     OS_CLOSEHANDLE(fp1);
  141.     fp1 = OS_OPENHANDLE("buffer.log", 0x80);
  142.     if (((int)fp1) & 0xff)
  143.     {
  144.       puts("Open buffer.log error");
  145.       return;
  146.     }
  147.   }
  148.   size = OS_GETFILESIZE(fp1);
  149.   len = curpos;
  150.   OS_SEEKHANDLE(fp1, size);
  151.   OS_WRITEHANDLE(crlf, fp1, 2);
  152.   OS_WRITEHANDLE("********************************************************************************", fp1, 80);
  153.   OS_WRITEHANDLE(crlf, fp1, 2);
  154.   OS_WRITEHANDLE(buffer, fp1, len);
  155.   OS_CLOSEHANDLE(fp1);
  156.   puts("buffer.log saved.");
  157. }
  158.  
  159. void flushbuf(void)
  160. {
  161.   while (uart_hasByte() != 0)
  162.   {
  163.     uart_read();
  164.   }
  165. }
  166.  
  167. void testQueue(void)
  168. {
  169.   unsigned char cmd[6000];
  170.   sendcommand("AT+CIPMUX=0\0");
  171.   sendcommand("AT+CIPSERVER=0\0");
  172.   sendcommand("AT+CIPDINFO=0\0");
  173.   sendcommand("AT+CIPRECVMODE=1\0");
  174.   sendcommand("AT+CIPSTART=\"TCP\",\"ti6.nedopc.com\",80\0");
  175.   delay(1000);
  176.   strcpy(cmd, "AT+CIPSEND=");
  177.   strcat(cmd, "132\0");
  178.   sendcommand(cmd);
  179.   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\0");
  180.   delay(1000);
  181.   sendcommand("AT+CIPRECVDATA=5000\0");
  182. }
  183. C_task main(void)
  184. {
  185.   unsigned char cmd[256];
  186.   unsigned char cmdpos;
  187.   os_initstdio();
  188.   BOX(1, 1, 80, 25, 40);
  189.   AT(1, 1);
  190.   ATRIB(92);
  191.   puts("EVO UART TESTER. SEND AND RECEIVE BYTES.");
  192.   uart_init(1);
  193.   puts("Uart inited @ 115200\r\n");
  194.   delay(250);
  195.   cmd[0] = '\0';
  196.   cmdpos = 0;
  197.   while (1)
  198.   {
  199.     unsigned char count;
  200.     getdata();
  201.     renderWin();
  202.     key = _low_level_get();
  203.     if (key != 0)
  204.     {
  205.       // printf("key = %u   ", key);
  206.       switch (key)
  207.       {
  208.       case 177:
  209.         uart_init(1);
  210.         puts("Uart inited @ 115200");
  211.         key = 0;
  212.         break;
  213.  
  214.       case 178:
  215.         uart_init(2);
  216.         puts("Uart inited @ 57600");
  217.         key = 0;
  218.         break;
  219.  
  220.       case 179:
  221.         uart_init(3);
  222.         puts("Uart inited @ 38400");
  223.         key = 0;
  224.         break;
  225.  
  226.       case 180:
  227.         uart_init(4);
  228.         puts("Uart inited @ 28800");
  229.         key = 0;
  230.         break;
  231.  
  232.       case 181:
  233.         uart_init(6);
  234.         puts("Uart inited @ 19200");
  235.         key = 0;
  236.         break;
  237.  
  238.       case 182:
  239.         uart_init(8);
  240.         puts("Uart inited @ 14400");
  241.         key = 0;
  242.         break;
  243.  
  244.       case 183:
  245.         uart_init(12);
  246.         puts("Uart inited @ 9600");
  247.         key = 0;
  248.         break;
  249.  
  250.       case 184:
  251.         uart_init(24);
  252.         puts("Uart inited @ 4800");
  253.         key = 0;
  254.         break;
  255.  
  256.       case 185:
  257.         uart_init(48);
  258.         puts("Uart inited @ 2400");
  259.         key = 0;
  260.         break;
  261.  
  262.       case 176:
  263.         uart_init(96);
  264.         puts("Uart inited @ 1200");
  265.         key = 0;
  266.         break;
  267.  
  268.       case 13:
  269.         cmd[cmdpos] = '\0';
  270.         sendcommand(cmd);
  271.         cmdpos = 0;
  272.         cmd[cmdpos] = '\0';
  273.         putchar('\r');
  274.         putchar('\n');
  275.         key = 0;
  276.         break;
  277.  
  278.       case 19:
  279.         saveBuff();
  280.         key = 0;
  281.         break;
  282.  
  283.       case 27:
  284.         exit(0);
  285.  
  286.       case 8:
  287.         if (cmdpos != 0)
  288.         {
  289.           cmdpos--;
  290.           cmd[cmdpos] = '\0';
  291.           putchar('\r');
  292.           for (count = 0; count < cmdpos + 1; count++)
  293.           {
  294.             putchar(' ');
  295.           }
  296.           putchar('\r');
  297.           count = 0;
  298.           while (cmd[count] != '\0')
  299.           {
  300.             putchar(cmd[count]);
  301.             count++;
  302.           }
  303.         }
  304.         key = 0;
  305.         break;
  306.  
  307.       case 246: // +
  308.         sendcommand("AT+GMR\0");
  309.         key = 0;
  310.         break;
  311.  
  312.       case 247: // -
  313.         key = 0;
  314.         break;
  315.  
  316.       case 28: // home
  317.         testQueue();
  318.         key = 0;
  319.         break;
  320.       }
  321.     }
  322.  
  323.     if (key != 0)
  324.     {
  325.       cmd[cmdpos] = key;
  326.       cmdpos++;
  327.       putchar(key);
  328.     }
  329.   }
  330.   return 0;
  331. }