?login_element?

Subversion Repositories NedoOS

Rev

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

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