?login_element?

Subversion Repositories NedoOS

Rev

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