?login_element?

Subversion Repositories NedoOS

Rev

Rev 2176 | Blame | Compare with Previous | Last modification | View Log | Download

  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <oscalls.h>
  4. #include <tcp.h>
  5. #include <intrz80.h>
  6. #include <stdlib.h>
  7. #include <../common/terminal.c>
  8. #include <osfs.h>
  9.  
  10. #define true 1
  11. #define false 0
  12.  
  13. FILE *fp2;
  14.  
  15. char cmd[128];
  16. char curPath[256];
  17. char holidays[13][32];
  18. unsigned char netbuf[2048];
  19. char calbuf[24000];
  20. struct window
  21. {
  22.         unsigned char x;
  23.         unsigned char y;
  24.         unsigned char w;
  25.         unsigned char h;
  26.         unsigned char text;
  27.         unsigned char back;
  28.         unsigned char tittle[80];
  29. } curWin;
  30.  
  31. struct rtc
  32. {
  33.         unsigned char hours;
  34.         unsigned char minutes;
  35.         unsigned char seconds;
  36.         unsigned char day;
  37.         unsigned char month;
  38.         unsigned int year;
  39. } clock;
  40.  
  41. struct params
  42. {
  43.         char useProdCalendar;
  44.         char currentCountry[3];
  45.         char machineType;
  46. } ini;
  47.  
  48. struct sockaddr_in dnsaddress;
  49. struct sockaddr_in targetadr;
  50. struct readstructure readStruct;
  51.  
  52. unsigned int RBR_THR = 0xf8ef;
  53. unsigned int IER = 0xf9ef;
  54. unsigned int IIR_FCR = 0xfaef;
  55. unsigned int LCR = 0xfbef;
  56. unsigned int MCR = 0xfcef;
  57. unsigned int LSR = 0xfdef;
  58. unsigned int MSR = 0xfeef;
  59. unsigned int SR = 0xffef;
  60. unsigned int divider = 1;
  61. unsigned char comType = 0;
  62. unsigned int espType = 32;
  63.  
  64. unsigned int odoa = 12;
  65. char foreColor;
  66. unsigned int errn, headlng;
  67. unsigned long contLen;
  68. const unsigned char sendOk[] = "SEND OK";
  69. const unsigned char gotWiFi[] = "WIFI GOT IP";
  70. unsigned char userAgent[] = "Host: xmlcalendar.ru\r\nConnection: keep-alive\r\nUser-Agent: Mozilla/4.0 (compatible; MSIE5.01; NedoOS)\r\n\r\n";
  71. char country2[5][2] = {"ru", "kz", "by", "uz", "ua"};
  72. char country10[5][11] = {"Россия", "Казахстан", "Беларусь", "Узбекистан", "Украина"};
  73.  
  74. void delay(unsigned long counter)
  75. {
  76.         unsigned long start, finish;
  77.         counter = counter / 20;
  78.         if (counter < 1)
  79.         {
  80.                 counter = 1;
  81.         }
  82.         start = time();
  83.         finish = start + counter;
  84.  
  85.         while (start < finish)
  86.         {
  87.                 start = time();
  88.         }
  89. }
  90.  
  91. void spaces(unsigned char number)
  92. {
  93.         while (number > 0)
  94.         {
  95.                 putchar(' ');
  96.                 number--;
  97.         }
  98. }
  99.  
  100. void clearStatus(void)
  101. {
  102.         ATRIB(40);
  103.         AT(1, 24);
  104.         spaces(80);
  105.         AT(1, 24);
  106. }
  107.  
  108. void readClock(void)
  109. {
  110.         unsigned long dosTime;
  111.         dosTime = OS_GETTIME();
  112.  
  113.         clock.hours = dosTime >> 11 & 31;        // 0b00011111
  114.         clock.minutes = (dosTime >> 5) & 63; // 0b00111111
  115.         clock.seconds = (dosTime & 31) * 2;      // 0b00011111
  116.         clock.day = dosTime >> 16 & 31;
  117.         clock.month = dosTime >> 21 & 15;
  118.         clock.year = (dosTime >> 25 & 63) + 1980;
  119. }
  120.  
  121. void calendarBox(struct window w, unsigned char *message)
  122. {
  123.         unsigned char wcount, tempx, tittleStart;
  124.  
  125.         w.h++;
  126.         AT(w.x, w.y - 1);
  127.         BOX(w.x, w.y, w.w + 1, w.h, w.back, 32);
  128.         AT(w.x, w.y);
  129.         ATRIB(w.text);
  130.         putchar(201);
  131.         for (wcount = 0; wcount < w.w; wcount++)
  132.         {
  133.                 putchar(205);
  134.         }
  135.         putchar(187);
  136.         AT(w.x, w.y + w.h);
  137.         putchar(200);
  138.         for (wcount = 0; wcount < w.w; wcount++)
  139.         {
  140.                 putchar(205);
  141.         }
  142.         putchar(188);
  143.  
  144.         tempx = w.x + w.w + 1;
  145.         for (wcount = 1; wcount < w.h; wcount++)
  146.         {
  147.                 AT(w.x, w.y + wcount);
  148.                 putchar(186);
  149.                 AT(tempx, w.y + wcount);
  150.                 putchar(186);
  151.         }
  152.         tittleStart = w.x + (w.w / 2) - (strlen(w.tittle) / 2);
  153.         AT(tittleStart, w.y);
  154.         printf("[%s]", w.tittle);
  155.         AT(w.x + 1, w.y + 1);
  156.         ATRIB(w.back);
  157.         tittleStart = w.x + (w.w / 2) - (strlen(message) / 2);
  158.         AT(tittleStart, w.y + 1);
  159.         printf("%s", message);
  160. }
  161.  
  162. void printMonthNoProdCal(int month, int year, char xPos, char yPos)
  163. {
  164.         int y, k, j, count, prevMonth;
  165.         char monthsList[12][10] = {"Январь", "Февраль", "Март", "Апрель", "Май", "Июнь", "Июль", "Август", "Сентябрь", "Октябрь", "Ноябрь", "Декабрь"};
  166.         int mDays[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
  167.         static int t[] = {6, 2, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4};
  168.         int days;
  169.         int current;
  170.         char toDay = 0;
  171.  
  172.         curWin.w = 22;
  173.         curWin.x = xPos;
  174.         curWin.y = yPos;
  175.         curWin.h = 7;
  176.         curWin.text = 30;
  177.         curWin.back = 47;
  178.         strcpy(curWin.tittle, monthsList[month - 1]);
  179.         calendarBox(curWin, "");
  180.  
  181.         /*
  182.          1) Определим номер дня недели, где:
  183.  
  184.          0 - Понедельник
  185.          1 - Вторник
  186.          2 - Среда
  187.          3 - Четверг
  188.          4 - Пятница
  189.          5 - Суббота
  190.          6 - Воскресенье
  191.  
  192.          */
  193.  
  194.         if (month == clock.month && year == clock.year)
  195.         {
  196.                 toDay = true;
  197.         }
  198.         else
  199.         {
  200.                 toDay = false;
  201.         }
  202.  
  203.         y = year % 100;
  204.         current = y / 12 + y % 12 + y % 12 / 4 + t[month - 1] +
  205.                           (20 - year / 100);
  206.  
  207.         if ((year % 400 == 0 || (year % 4 == 0 && year % 100 != 0)) &&
  208.                 month <= 2)
  209.                 current--;
  210.  
  211.         current = current % 7;
  212.  
  213.         /*
  214.          2) Проверка на високосность начиная с нулевого месяца:
  215.          0 - январь
  216.          ...
  217.          11 - декабрь
  218.          */
  219.         if (month ==
  220.                 2) // 1 - это февраль месяц, так как счёт начинается с 0.
  221.                 if (year % 400 == 0 || (year % 4 == 0 && year % 100 != 0))
  222.                         days = 29; // Если високосный
  223.                 else
  224.                         days = mDays[month - 1];
  225.         else
  226.                 days = mDays[month - 1];
  227.  
  228.         AT(curWin.x + 1, curWin.y + 1);
  229.         puts(" Пн Вт Ср Чт Пт Сб Вс");
  230.         /*
  231.          4) Вводим доп. переменные k и j:
  232.          k - количество дней в неделе от 0 до 6 (0 - ПН; 6 - ВС)
  233.          j - количество дней в месяце (от 1 до общего в месяце)
  234.          */
  235.         AT(curWin.x + 1, curWin.y + 2);
  236.         ATRIB(47);
  237.  
  238.         if (month != 1)
  239.         {
  240.                 prevMonth = month - 2;
  241.         }
  242.         else
  243.         {
  244.                 prevMonth = 11;
  245.         }
  246.         ATRIB(90);
  247.         for (k = 0; k < current; k++)
  248.         {
  249.                 printf("%3d", k + 1 + mDays[prevMonth] - current);
  250.         }
  251.         ATRIB(foreColor);
  252.         for (j = 1; j <= days; j++)
  253.         {
  254.                 k++;
  255.  
  256.                 if (k > 5)
  257.                 {
  258.                         ATRIB(31);
  259.                 }
  260.  
  261.                 if (toDay && (j == clock.day))
  262.                 {
  263.                         putchar(' ');
  264.                         ATRIB(44);
  265.                         if (k > 5)
  266.                         {
  267.                                 ATRIB(41);
  268.                                 ATRIB(foreColor);
  269.                         }
  270.                         printf("%2d", j);
  271.                 }
  272.                 else
  273.                 {
  274.                         printf("%3d", j);
  275.                 }
  276.  
  277.                 if (toDay && (j == clock.day))
  278.                 {
  279.                         ATRIB(47);
  280.                 }
  281.  
  282.                 if (k > 6)
  283.                 {
  284.                         k = 0;
  285.                         ATRIB(foreColor);
  286.                         AT(curWin.x + 1, curWin.y++ + 3);
  287.                 }
  288.         }
  289.         ATRIB(90);
  290.         for (count = 1; count < 8 - k; count++)
  291.         {
  292.                 printf("%3d", count);
  293.         }
  294. }
  295.  
  296. void printMonth(int month, int year, char xPos, char yPos)
  297. {
  298.         int y, k, j, count, prevMonth;
  299.         char monthsList[12][10] = {"Январь", "Февраль", "Март", "Апрель", "Май", "Июнь", "Июль", "Август", "Сентябрь", "Октябрь", "Ноябрь", "Декабрь"};
  300.         int mDays[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
  301.         static int t[] = {6, 2, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4};
  302.         int days;
  303.         int current;
  304.         char toDay = 0;
  305.  
  306.         curWin.w = 22;
  307.         curWin.x = xPos;
  308.         curWin.y = yPos;
  309.         curWin.h = 7;
  310.         curWin.text = 30;
  311.         curWin.back = 47;
  312.         strcpy(curWin.tittle, monthsList[month - 1]);
  313.         calendarBox(curWin, "");
  314.  
  315.         /*
  316.          1) Определим номер дня недели, где:
  317.  
  318.          0 - Понедельник
  319.          1 - Вторник
  320.          2 - Среда
  321.          3 - Четверг
  322.          4 - Пятница
  323.          5 - Суббота
  324.          6 - Воскресенье
  325.  
  326.          */
  327.  
  328.         if (month == clock.month && year == clock.year)
  329.         {
  330.                 toDay = true;
  331.         }
  332.         else
  333.         {
  334.                 toDay = false;
  335.         }
  336.  
  337.         y = year % 100;
  338.         current = y / 12 + y % 12 + y % 12 / 4 + t[month - 1] +
  339.                           (20 - year / 100);
  340.  
  341.         if ((year % 400 == 0 || (year % 4 == 0 && year % 100 != 0)) &&
  342.                 month <= 2)
  343.                 current--;
  344.  
  345.         current = current % 7;
  346.  
  347.         /*
  348.          2) Проверка на високосность начиная с нулевого месяца:
  349.          0 - январь
  350.          ...
  351.          11 - декабрь
  352.          */
  353.         if (month ==
  354.                 2) // 1 - это февраль месяц, так как счёт начинается с 0.
  355.                 if (year % 400 == 0 || (year % 4 == 0 && year % 100 != 0))
  356.                         days = 29; // Если високосный
  357.                 else
  358.                         days = mDays[month - 1];
  359.         else
  360.                 days = mDays[month - 1];
  361.  
  362.         AT(curWin.x + 1, curWin.y + 1);
  363.         puts(" Пн Вт Ср Чт Пт Сб Вс");
  364.         /*
  365.          4) Вводим доп. переменные k и j:
  366.          k - количество дней в неделе от 0 до 6 (0 - ПН; 6 - ВС)
  367.          j - количество дней в месяце (от 1 до общего в месяце)
  368.          */
  369.         AT(curWin.x + 1, curWin.y + 2);
  370.         ATRIB(47);
  371.  
  372.         if (month != 1)
  373.         {
  374.                 prevMonth = month - 2;
  375.         }
  376.         else
  377.         {
  378.                 prevMonth = 11;
  379.         }
  380.         ATRIB(90);
  381.         for (k = 0; k < current; k++)
  382.         {
  383.                 printf("%3d", k + 1 + mDays[prevMonth] - current);
  384.         }
  385.         ATRIB(foreColor);
  386.         for (j = 1; j <= days; j++)
  387.         {
  388.                 k++;
  389.                 if (holidays[month][j])
  390.                 {
  391.                         ATRIB(31);
  392.                 }
  393.                 else
  394.                 {
  395.                         ATRIB(foreColor);
  396.                 }
  397.                 if (toDay && (j == clock.day))
  398.                 {
  399.                         putchar(' ');
  400.                         ATRIB(44);
  401.                         if (holidays[month][j])
  402.                         {
  403.                                 ATRIB(41);
  404.                                 ATRIB(foreColor);
  405.                         }
  406.                         printf("%2d", j);
  407.                 }
  408.                 else
  409.                 {
  410.                         printf("%3d", j);
  411.                 }
  412.  
  413.                 if (toDay && (j == clock.day))
  414.                 {
  415.                         ATRIB(47);
  416.                 }
  417.  
  418.                 if (k > 6)
  419.                 {
  420.                         k = 0;
  421.                         AT(curWin.x + 1, curWin.y++ + 3);
  422.                 }
  423.         }
  424.         ATRIB(90);
  425.         for (count = 1; count < 8 - k; count++)
  426.         {
  427.                 printf("%3d", count);
  428.         }
  429. }
  430.  
  431. unsigned char inputBox(struct window w, unsigned char *prefilled)
  432. {
  433.         unsigned char wcount, tempx, tittleStart;
  434.         unsigned char byte, counter;
  435.         w.h++;
  436.         AT(w.x, w.y - 1);
  437.         BOX(w.x, w.y, w.w + 1, w.h, w.back, 32);
  438.         AT(w.x, w.y);
  439.         ATRIB(w.text);
  440.         putchar(201);
  441.         for (wcount = 0; wcount < w.w; wcount++)
  442.         {
  443.                 putchar(205);
  444.         }
  445.         putchar(187);
  446.         AT(w.x, w.y + w.h);
  447.         putchar(200);
  448.         for (wcount = 0; wcount < w.w; wcount++)
  449.         {
  450.                 putchar(205);
  451.         }
  452.         putchar(188);
  453.  
  454.         tempx = w.x + w.w + 1;
  455.         for (wcount = 1; wcount < w.h; wcount++)
  456.         {
  457.                 AT(w.x, w.y + wcount);
  458.                 putchar(186);
  459.                 AT(tempx, w.y + wcount);
  460.                 putchar(186);
  461.         }
  462.         tittleStart = w.x + (w.w / 2) - (strlen(w.tittle) / 2);
  463.         AT(tittleStart, w.y);
  464.         printf("[%s]", w.tittle);
  465.         AT(w.x + 1, w.y + 1);
  466.         ATRIB(w.back);
  467.         // putchar(219);
  468.  
  469.         cmd[0] = 0;
  470.  
  471.         counter = strlen(prefilled);
  472.         if (counter != 0)
  473.         {
  474.                 strcpy(cmd, prefilled);
  475.                 goto skipKeys;
  476.         }
  477.  
  478.         do
  479.         {
  480.                 byte = getchar();
  481.                 if (byte != 0)
  482.                 {
  483.                         switch (byte)
  484.                         {
  485.                         case 0x08:
  486.                                 if (counter > 0)
  487.                                 {
  488.                                         counter--;
  489.                                         cmd[counter] = 0;
  490.                                 }
  491.                                 break;
  492.                         case 0x0d:
  493.  
  494.                                 if (counter == 0)
  495.                                 {
  496.                                         return false;
  497.                                 }
  498.                                 else
  499.                                 {
  500.                                         return true;
  501.                                 }
  502.  
  503.                         case 31:
  504.                                 break;
  505.                         case 250:
  506.                                 break;
  507.                         case 249:
  508.                                 break;
  509.                         case 248:
  510.                                 break;
  511.                         case 251: // Right
  512.                                 break;
  513.                         case 252: // Del
  514.                                 AT(w.x + 1, w.y + 1);
  515.                                 spaces(counter + 1);
  516.                                 cmd[0] = 0;
  517.                                 counter = 0;
  518.                                 break;
  519.                         case 27:
  520.                                 cmd[0] = 0;
  521.                                 return false;
  522.                         default:
  523.                                 if (counter < w.w - 1)
  524.                                 {
  525.                                         cmd[counter] = byte;
  526.                                         counter++;
  527.                                         cmd[counter] = 0;
  528.                                 }
  529.                                 break;
  530.                         }
  531.                 skipKeys:
  532.                         AT(w.x + 1, w.y + 1);
  533.                         printf("%s", cmd);
  534.                         // putchar(219);
  535.                         if (byte == 0x08)
  536.                         {
  537.                                 putchar(' ');
  538.                         }
  539.                 }
  540.                 YIELD();
  541.         } while (42);
  542.         return false;
  543. }
  544.  
  545. void clearHolidays(void)
  546. {
  547.         char month, day;
  548.         for (month = 0; month < 13; month++)
  549.         {
  550.                 for (day = 0; day < 32; day++)
  551.                 {
  552.                         holidays[month][day] = false;
  553.                 }
  554.         }
  555. }
  556.  
  557. char readParamFromIni(void)
  558. {
  559.         FILE *fpini;
  560.         char skip2end = false;
  561.         unsigned int count = 0;
  562.         unsigned long loop;
  563.         unsigned char *count1;
  564.  
  565.         char useProdCalendar[] = "useProdCalendar";
  566.         char currentCountry[] = "currentCountry";
  567.  
  568.         OS_GETPATH((unsigned int)&curPath);
  569.         OS_SETSYSDRV();
  570.         OS_CHDIR("/");
  571.         OS_CHDIR("ini");
  572.  
  573.         fpini = OS_OPENHANDLE("calendar.ini", 0x80);
  574.         if (((int)fpini) & 0xff)
  575.         {
  576.                 clearStatus();
  577.                 printf("calendar.ini not found.\r\n");
  578.                 getchar();
  579.                 return false;
  580.         }
  581.  
  582.         OS_READHANDLE(calbuf, fpini, 512);
  583.         OS_CLOSEHANDLE(fpini);
  584.  
  585.         calbuf[loop + 1] = 0;
  586.  
  587.         count1 = strstr(calbuf, useProdCalendar);
  588.         if (count1 != NULL)
  589.         {
  590.                 sscanf(count1 + strlen(useProdCalendar) + 1, "%d", &ini.useProdCalendar);
  591.         }
  592.  
  593.         count1 = strstr(calbuf, currentCountry);
  594.         if (count1 != NULL)
  595.         {
  596.                 sscanf(count1 + strlen(currentCountry) + 1, "%c", &ini.currentCountry[0]);
  597.                 sscanf(count1 + strlen(currentCountry) + 2, "%c", &ini.currentCountry[1]);
  598.                 ini.currentCountry[2] = 0;
  599.         }
  600.  
  601.         OS_CHDIR(curPath);
  602.         return true;
  603. }
  604.  
  605. char loadProdCalDisk(int year)
  606. {
  607.         FILE *fpdat;
  608.         unsigned long loaded, total = 0;
  609.         int lineYear = 0;
  610.         int lineMonth = 0;
  611.         int lineDay = 0;
  612.         odoa = 12;
  613.         clearStatus();
  614.         printf("Загрузка производственного кадендаря с диска на %d год", year);
  615.  
  616.         OS_GETPATH((unsigned int)&curPath);
  617.         OS_SETSYSDRV();
  618.         OS_CHDIR("/");
  619.         OS_CHDIR("ini");
  620.         fpdat = OS_OPENHANDLE("calendar.ini", 0x80);
  621.         if (((int)fpdat) & 0xff)
  622.         {
  623.                 clearStatus();
  624.                 printf("calendar.ini not found.\r\n");
  625.                 getchar();
  626.                 return false;
  627.         }
  628.  
  629.         do
  630.         {
  631.                 loaded = OS_READHANDLE(calbuf + total, fpdat, sizeof(calbuf));
  632.                 total = total + loaded;
  633.         } while (loaded != 0);
  634.         OS_CLOSEHANDLE(fpdat);
  635.         OS_CHDIR(curPath);
  636.         return 1;
  637. }
  638.  
  639. char fillProdCal(int year)
  640. {
  641.         int lineYear = 0;
  642.         int lineMonth = 0;
  643.         int lineDay = 0;
  644.         char result = false;
  645.         unsigned int count;
  646.         char *yptr;
  647.  
  648.         clearHolidays();
  649.  
  650.         sprintf(cmd, "%d", year);
  651.         yptr = strstr(calbuf, cmd);
  652.  
  653.         if (yptr == NULL)
  654.         {
  655.                 return result;
  656.         }
  657.  
  658.         count = 0;
  659.         clearStatus();
  660.         while (42)
  661.         {
  662.  
  663.                 // 2024.01.01CL
  664.                 sscanf(yptr + 0 + count, "%d", &lineYear);
  665.                 sscanf(yptr + 5 + count, "%d", &lineMonth);
  666.                 sscanf(yptr + 8 + count, "%d", &lineDay);
  667.                 count = count + odoa;
  668.  
  669.                 if (lineYear != year)
  670.                 {
  671.                         return result;
  672.                 }
  673.  
  674.                 if (lineDay < 32 && lineMonth < 13 && lineDay > 0 && lineMonth > 0)
  675.                 {
  676.                         holidays[lineMonth][lineDay] = true;
  677.                         result = true;
  678.                         //      printf("lineDay=[%02d] lineMonth=[%02d] lineYear=[%04d]\r\n", lineDay, lineMonth, lineYear);
  679.                 }
  680.         }
  681.         return result;
  682. }
  683.  
  684. #include <../common/network.c>
  685. #include <../common/esp-com.c>
  686.  
  687. int cutHeader(unsigned int todo)
  688. {
  689.         unsigned int err;
  690.         unsigned char *count1;
  691.  
  692.         err = httpError();
  693.         if (err != 200)
  694.         {
  695.                 /*
  696.                                 BOX(1, 1, 80, 25, 40, 32);
  697.                                 AT(1, 1);
  698.                                 printf("HTTP ERROR %u", err);
  699.                                 puts("^^^^^^^^^^^^^^^^^^^^^");
  700.                                 puts(netbuf);
  701.                                 getchar();
  702.                 */
  703.                 return -1;
  704.         }
  705.         count1 = strstr(netbuf, "Content-Length:");
  706.         if (count1 == NULL)
  707.         {
  708.                 printf("contLen  not found \r\n");
  709.                 contLen = 0;
  710.         }
  711.         else
  712.         {
  713.                 contLen = atol(count1 + 15);
  714.                 // printf("Content-Length: %lu \n\r", contLen);
  715.         }
  716.  
  717.         count1 = strstr(netbuf, "\r\n\r\n");
  718.         if (count1 == NULL)
  719.         {
  720.                 printf("header not found\r\n");
  721.         }
  722.         else
  723.         {
  724.                 headlng = ((unsigned int)count1 - (unsigned int)netbuf + 4);
  725.                 // printf("header %u bytes\r\n", headlng);
  726.         }
  727.         return todo - headlng;
  728. }
  729.  
  730. char fillBuffer(signed char socket)
  731. {
  732.         int todo;
  733.         unsigned int w, pPos, headskip;
  734.  
  735.         headskip = 0;
  736.         pPos = 0;
  737.         while (42)
  738.         {
  739.                 headlng = 0;
  740.                 todo = tcpRead(socket, 20);
  741.                 testOperation("OS_WIZNETREAD", todo);
  742.  
  743.                 if (headskip == 0)
  744.                 {
  745.                         headskip = 1;
  746.                         todo = cutHeader(todo);
  747.  
  748.                         if (todo == -1)
  749.                         {
  750.                                 return false;
  751.                         }
  752.                 }
  753.                 for (w = 0; w < todo; w++)
  754.                 {
  755.                         calbuf[w + pPos] = netbuf[w + headlng];
  756.                 }
  757.                 pPos = pPos + todo;
  758.                 if (pPos == contLen)
  759.                 {
  760.                         break;
  761.                 }
  762.         }
  763.         netShutDown(socket, 0);
  764.         calbuf[pPos + 0] = 0;
  765.         strcat(calbuf, "\n9999.12.31\n");
  766.         return true;
  767. }
  768.  
  769. unsigned char loadProdCalNet(int year, char *country)
  770. {
  771.         int todo;
  772.         char socket;
  773.         odoa = 11;
  774.  
  775.         clearStatus();
  776.         printf("Загрузка производственного кадендаря через NedoNet на %d год", year);
  777.  
  778.         dnsResolve("xmlcalendar.ru");
  779.         socket = OpenSock(AF_INET, SOCK_STREAM);
  780.         testOperation("OS_NETSOCKET", socket);
  781.  
  782.         todo = netConnect(socket, 10);
  783.         testOperation("OS_NETCONNECT", todo);
  784.  
  785.         sprintf(netbuf, "GET /data/%s/%d/calendar.txt HTTP/1.1\r\n%s", country, year, userAgent);
  786.  
  787.         todo = tcpSend(socket, (unsigned int)&netbuf, strlen(netbuf), 10);
  788.         testOperation("OS_WIZNETWRITE", todo);
  789.         fillBuffer(socket);
  790.         return 2;
  791. }
  792.  
  793. unsigned char loadProdCalEsp(int year, char *country)
  794. {
  795.         unsigned char sizeLink = 0;
  796.         unsigned long downloaded = 0;
  797.         unsigned char byte, count = 0, try = 0;
  798.         unsigned int dataSize = 0;
  799.         unsigned char skipHeader = 0;
  800.         unsigned char *count1;
  801.         odoa = 11;
  802.  
  803.         sprintf(curPath, "GET /data/%s/%d/calendar.txt HTTP/1.1\r\n%s", country, year, userAgent);
  804.         sizeLink = strlen(curPath);
  805.         try = 0;
  806.         do
  807.         {
  808.                 try++;
  809.                 if (try > 1)
  810.                 {
  811.                         printf("----->Retry:%u\r\n", try);
  812.                         delay(500);
  813.                 }
  814.                 sendcommand("AT+CIPSTART=\"TCP\",\"xmlcalendar.ru\",80");
  815.                 getAnswer2(); // CONNECT or ERROR or link is not valid
  816.                 count1 = strstr(netbuf, "CONNECT");
  817.         } while (count1 == NULL);
  818.  
  819.         getAnswer2(); // OK
  820.  
  821.         sprintf(netbuf, "AT+CIPSEND=%u", sizeLink + 2); // second CRLF in send command
  822.         sendcommand(netbuf);
  823.         getAnswer2();
  824.         do
  825.         {
  826.                 byte = uart_readBlock();
  827.                 // putchar(byte);
  828.         } while (byte != '>');
  829.         sendcommand(curPath);
  830.  
  831.         count = 0;
  832.  
  833.         do
  834.         {
  835.                 byte = uart_readBlock();
  836.                 if (byte == sendOk[count])
  837.                 {
  838.                         count++;
  839.                 }
  840.                 else
  841.                 {
  842.                         count = 0;
  843.                 }
  844.         } while (count < strlen(sendOk));
  845.         uart_readBlock(); // CR
  846.         uart_readBlock(); // LF
  847.         skipHeader = 0;
  848.         downloaded = 0;
  849.         do
  850.         {
  851.                 headlng = 0;
  852.                 dataSize = recvHead();
  853.                 getdataEsp(dataSize); // Requested size
  854.                 if (skipHeader == 0)
  855.                 {
  856.                         dataSize = cutHeader(dataSize);
  857.                         skipHeader = 1;
  858.                         if (dataSize == -1)
  859.                         {
  860.                                 return false;
  861.                         }
  862.                 }
  863.                 memcpy(calbuf + downloaded, netbuf + headlng, dataSize);
  864.                 downloaded = downloaded + dataSize;
  865.  
  866.         } while (downloaded < contLen);
  867.         sendcommand("AT+CIPCLOSE");
  868.         getAnswer2(); // CLOSED
  869.         getAnswer2(); // OK
  870.         calbuf[downloaded + 1] = 0;
  871.         strcat(calbuf, "\n9999.12.31\n");
  872.  
  873.         return 3;
  874. }
  875.  
  876. C_task main(int argc, char *argv[])
  877. {
  878.         int x, y, year, half;
  879.         char key;
  880.         char ci = 0;
  881.  
  882.         targetadr.porth = 00;
  883.         targetadr.portl = 80;
  884.         strcpy(ini.currentCountry, "ru");
  885.         ini.useProdCalendar = false;
  886.  
  887.         os_initstdio();
  888.         CLS();
  889.         loadEspConfig();
  890.         get_dns();
  891.         AT(3, 25);
  892.         ATRIB(40);
  893.         ATRIB(90);
  894.         printf("Онлайн производственный календарь предоставлен сайтом http://xmlcalendar.ru/");
  895.         ATRIB(97);
  896.         YIELD();
  897.  
  898.         readParamFromIni();
  899.  
  900.         ini.machineType = (unsigned char)OS_GETCONFIG();
  901.         // L= 1-Evo 2-ATM2 3-ATM3 6-p2.666 ;E=pgsys(system page) D= TR-DOS page
  902.         if (ini.machineType == 1)
  903.         {
  904.                 foreColor = 97;
  905.         }
  906.         else
  907.         {
  908.                 foreColor = 30;
  909.         }
  910.  
  911.         if (ini.useProdCalendar == 3)
  912.         {
  913.                 uart_init(divider);
  914.                 espReBoot();
  915.         }
  916.  
  917.         BOX(1, 1, 80, 24, 44, 32);
  918.  
  919.         AT(1, 1);
  920.         ATRIB(97);
  921.         ATRIB(44);
  922.  
  923.         half = 0;
  924.  
  925.         if (argc == 1)
  926.         {
  927.                 readClock();
  928.                 year = clock.year;
  929.                 AT(4, 2);
  930.                 printf("Сегодня: %02u-%02u-%04u", clock.day, clock.month, clock.year);
  931.  
  932.                 if (clock.month > 5)
  933.                 {
  934.                         half = 6;
  935.                 }
  936.         }
  937.         else if (argc == 2)
  938.         {
  939.                 char *p = argv[1];
  940.                 sscanf(p, "%d", &year);
  941.         }
  942.  
  943.         x = 4;
  944.         y = 4;
  945.  
  946.         AT(1, 25);
  947.         ATRIB(40);
  948.         spaces(79);
  949.  
  950. loop:
  951.         clearStatus();
  952.         switch (ini.useProdCalendar)
  953.         {
  954.         case 0:
  955.                 break;
  956.         case 1:
  957.                 ini.useProdCalendar = loadProdCalDisk(year);
  958.                 break;
  959.         case 2:
  960.                 ini.useProdCalendar = loadProdCalNet(year, ini.currentCountry);
  961.                 break;
  962.         case 3:
  963.                 ini.useProdCalendar = loadProdCalEsp(year, ini.currentCountry);
  964.                 break;
  965.         default:
  966.                 break;
  967.         }
  968.         if (ini.useProdCalendar != 0)
  969.         {
  970.                 if (fillProdCal(year) == false)
  971.                 {
  972.                         ini.useProdCalendar = false;
  973.                         clearStatus();
  974.                         printf("Не найден и выключен производственный календарь на %d год. ", year);
  975.                 }
  976.         }
  977. loop2:
  978.  
  979.         // 0 - not use; 1 - use file; 2 - use NedoNet; 3 - use ESP-COM;
  980.         switch (ini.useProdCalendar)
  981.         {
  982.         case 0:
  983.                 strcpy(cmd, "Выключены");
  984.                 break;
  985.  
  986.         case 1:
  987.                 strcpy(cmd, " Из файла");
  988.                 break;
  989.         case 2:
  990.         case 3:
  991.                 strcpy(cmd, "  Сетевые");
  992.                 break;
  993.         default:
  994.                 break;
  995.         }
  996.  
  997.         AT(60, 2);
  998.         ATRIB(97);
  999.         ATRIB(44);
  1000.         printf("Выходные:%s", cmd);
  1001.         clearStatus();
  1002.  
  1003.         ATRIB(93);
  1004.         ATRIB(44);
  1005.  
  1006.         switch (ini.currentCountry[0])
  1007.         {
  1008.         case 'r':
  1009.                 ci = 0;
  1010.                 break;
  1011.         case 'k':
  1012.                 ci = 1;
  1013.                 break;
  1014.         case 'b':
  1015.                 ci = 2;
  1016.                 break;
  1017.         case 'u':
  1018.                 if (ini.currentCountry[1] == 'z')
  1019.                 {
  1020.                         ci = 3;
  1021.                 }
  1022.                 else if (ini.currentCountry[1] == 'a')
  1023.                 {
  1024.                         ci = 4;
  1025.                 }
  1026.                 break;
  1027.         }
  1028.         AT(40 - (strlen(country10[ci]) / 2) - 3, 2);
  1029.         printf("[%s %d]", country10[ci], year);
  1030.  
  1031.         if (ini.useProdCalendar == 0)
  1032.         {
  1033.                 printMonthNoProdCal(1 + half, year, x + 00, y + 00);
  1034.                 printMonthNoProdCal(2 + half, year, x + 25, y + 00);
  1035.                 printMonthNoProdCal(3 + half, year, x + 50, y + 00);
  1036.                 printMonthNoProdCal(4 + half, year, x + 00, y + 10);
  1037.                 printMonthNoProdCal(5 + half, year, x + 25, y + 10);
  1038.                 printMonthNoProdCal(6 + half, year, x + 50, y + 10);
  1039.                 ATRIB(40);
  1040.                 ATRIB(37);
  1041.         }
  1042.         else
  1043.         {
  1044.                 printMonth(1 + half, year, x + 00, y + 00);
  1045.                 printMonth(2 + half, year, x + 25, y + 00);
  1046.                 printMonth(3 + half, year, x + 50, y + 00);
  1047.                 printMonth(4 + half, year, x + 00, y + 10);
  1048.                 printMonth(5 + half, year, x + 25, y + 10);
  1049.                 printMonth(6 + half, year, x + 50, y + 10);
  1050.                 ATRIB(40);
  1051.                 ATRIB(37);
  1052.         }
  1053.  
  1054.         key = getchar();
  1055.         switch (key)
  1056.         {
  1057.         case 250: // Up
  1058.                 year++;
  1059.                 half = 0;
  1060.                 break;
  1061.         case 249: // down
  1062.                 year--;
  1063.                 half = 0;
  1064.                 break;
  1065.         case 'Y':
  1066.         case 'y':
  1067.  
  1068.                 curWin.w = 14;
  1069.                 curWin.x = 80 / 2 - curWin.w / 2;
  1070.                 curWin.y = 9;
  1071.                 curWin.h = 1;
  1072.                 curWin.text = 97;
  1073.                 curWin.back = 42;
  1074.                 strcpy(curWin.tittle, "Введите год:");
  1075.  
  1076.                 if (inputBox(curWin, ""))
  1077.                 {
  1078.                         sscanf(cmd, "%d", &year);
  1079.                         half = 0;
  1080.                 }
  1081.  
  1082.                 break;
  1083.  
  1084.         case 'h': // File
  1085.         case 'H':
  1086.                 if (ini.useProdCalendar != 0)
  1087.                         ini.useProdCalendar = 0;
  1088.                 else
  1089.                         ini.useProdCalendar = 1;
  1090.                 break;
  1091.  
  1092.         case 'n': // NedoNET
  1093.         case 'N':
  1094.                 ini.useProdCalendar = 2;
  1095.                 break;
  1096.         case 'e': // ESP-COM
  1097.         case 'E':
  1098.                 ini.useProdCalendar = 3;
  1099.                 break;
  1100.         default:
  1101.                 if (half == 0)
  1102.                 {
  1103.                         half = 6;
  1104.                 }
  1105.                 else
  1106.                 {
  1107.                         half = 0;
  1108.                 }
  1109.                 goto loop2;
  1110.         }
  1111.         goto loop;
  1112. }
  1113.