Don't like ads? PRO users don't see any ads ;-)
Public Pastes
Guest

Untitled

By: a guest on May 1st, 2012  |  syntax: C  |  size: 12.80 KB  |  hits: 27  |  expires: Never
download  |  raw  |  embed  |  report abuse  |  print
Text below is selected. Please press Ctrl+C to copy to your clipboard. (⌘+C on Mac)
  1. # include <stdio.h>
  2. # include <windows.h>
  3. # include <conio.h>
  4.  
  5. void wiev_dcb(HANDLE hCom,HANDLE hConsole,DCB & PortDCB);
  6. void set_dcb(HANDLE hCom,HANDLE hConsole,DCB & PortDCB,int baudrate,int parity, int bytesize,int stopbits);
  7. void time(HANDLE hCom,HANDLE hConsole);
  8. void load(HANDLE hConsole);
  9. HANDLE open_port(HANDLE hCom,HANDLE hConsole);
  10. void send_znak(HANDLE hCom,HANDLE hConsole);
  11. bool IsKeyPressed(int virtualKey);
  12.  
  13. int vysielanie(HANDLE hCom, HANDLE hConsole);
  14. void prijimanie(HANDLE hCom, HANDLE hConsole);
  15. int chat(HANDLE hCom, HANDLE hConsole);
  16.  
  17.  
  18.  
  19.  
  20.  
  21. // *********************************************************************************
  22. // *********************************************************************************
  23. // *********************************************************************************
  24. int main()
  25. {
  26.  
  27.         HANDLE  hConsole;
  28.         hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
  29.  
  30.         SetConsoleTextAttribute(hConsole,15);
  31.  
  32.         system ("cls");
  33.  
  34. // *********************************************************************************
  35. // otvorenie portu
  36.  
  37.         HANDLE hCom;                        // Handle na objekt typu súbor
  38.  
  39.         SetConsoleTextAttribute(hConsole,15);
  40.         printf("Vyber port:\n"
  41.                 "(1) Com1\n"
  42.                 "(2) Com2\n"
  43.                 "(3) Com3\n"
  44.                 "(4) Com4\n");
  45.  
  46.  
  47.         switch(getch())
  48.         {
  49.                 case '1':
  50.                         load(hConsole);
  51.                         hCom = CreateFile(                
  52.                                 "COM1:",                        
  53.                                 GENERIC_READ | GENERIC_WRITE,  
  54.                                 0,                              
  55.                                 NULL,                            
  56.                                 OPEN_EXISTING,                  
  57.                                 0,                              
  58.                                 NULL);
  59.                         break; 
  60.                 case '2':
  61.                         load(hConsole);
  62.                         hCom = CreateFile(                
  63.                                 "COM2:",                        
  64.                                 GENERIC_READ | GENERIC_WRITE,    
  65.                                 0,                              
  66.                                 NULL,                            
  67.                                 OPEN_EXISTING,                  
  68.                                 0,                            
  69.                                 NULL);
  70.                         break;  
  71.                 case '3':
  72.                         load(hConsole);
  73.                         hCom = CreateFile(                
  74.                                 "COM3:",
  75.                                 GENERIC_READ | GENERIC_WRITE,
  76.                                 0,
  77.                                 NULL,
  78.                                 OPEN_EXISTING,
  79.                                 0,
  80.                                 NULL);
  81.                         break;
  82.                 case '4':
  83.                         load(hConsole);
  84.                         hCom = CreateFile(                
  85.                                 "COM4:",
  86.                                 GENERIC_READ | GENERIC_WRITE,
  87.                                 0,
  88.                                 NULL,
  89.                                 OPEN_EXISTING,
  90.                                 0,
  91.                                 NULL);
  92.                         break;
  93.                 default:
  94.                         SetConsoleTextAttribute(hConsole,12);
  95.                         printf("\nZla volba!!\n\n\n");
  96.                         SetConsoleTextAttribute(hConsole,15);
  97.                         return 1;
  98.                         break;
  99.         }
  100.  
  101.         DCB PortDCB;                                            // Štruktúra, v ktorej sú uložené parametre  
  102.         PortDCB.DCBlength = sizeof(DCB);        // Inicializuj položku DCBlength
  103.         GetCommState(hCom,&PortDCB);            // Načítaj aktuálne nastavenia
  104.  
  105. // koniec - otvorenie portu
  106. // *********************************************************************************
  107.  
  108.  
  109. time(hCom,hConsole);                                            //nastavenie timeoutov
  110.  
  111. load(hConsole);
  112.  
  113. wiev_dcb(hCom,hConsole,PortDCB);                        //zobrazenie konfiguracie portu
  114.  
  115. load(hConsole);
  116.  
  117. set_dcb(hCom,hConsole,PortDCB,9600,0,8,1);      //nastavenie konfiguracie portu
  118.  
  119. load(hConsole);
  120.  
  121. wiev_dcb(hCom,hConsole,PortDCB);                        //zobrazenie konfiguracie portu
  122.  
  123. load(hConsole);
  124. Sleep(1000);
  125.  
  126.         while (1)
  127.         {
  128.  
  129.                 system ("cls");
  130.  
  131.                 COORD point = {30,0};
  132.                 SetConsoleCursorPosition(hConsole, point);
  133.  
  134.                 SetConsoleTextAttribute(hConsole,14);
  135.                 printf("RS-232 komunikator v1.20\n\n");
  136.                 SetConsoleTextAttribute(hConsole,15);
  137.  
  138.                 printf("Menu:\n");
  139.                 printf("(1) Chat \n");
  140.                 printf("(2) - - - - - \n");
  141.                 printf("(3) Opakovane odosielanie znaku \n");
  142.                 printf("(4) - - - - - \n");
  143.                 printf("(5) Ukazat nastavenia portu \n");
  144.                 printf("(6) Nastavenit port \n");
  145.                 printf("(7) Nastavenit timeouty \n");
  146.                 printf("(8) Vyber portu \n");
  147.                 printf("(9) - - - - - \n");
  148.                 printf("(0) Koniec \n\n");
  149.  
  150. Sleep(100);
  151.  
  152.                 switch(getch())
  153.                 {
  154.                         case '1':
  155.                                 load(hConsole);
  156.                                 chat(hCom,hConsole);
  157.  
  158.                         SetConsoleTextAttribute(hConsole,12);
  159.                         printf("                                   Koniec\n");
  160. //                      getch();
  161.                         Sleep(1000);
  162.                         SetConsoleTextAttribute(hConsole,15);
  163.  
  164.                                 Sleep(500);
  165.                                 break;
  166.                         case '2':
  167.                                 load(hConsole);
  168.                                
  169.                                 getch();
  170.                                 break;
  171.                         case '3':
  172.                                 load(hConsole);
  173.                                 send_znak(hCom,hConsole);
  174.                                 getch();
  175.                                 break;
  176.                         case '4':
  177.                                 load(hConsole);
  178.                                
  179.                                 getch();
  180.                                 break;
  181.                         case '5':
  182.                                 load(hConsole);
  183.                                 wiev_dcb(hCom,hConsole,PortDCB);
  184.                                 getch();
  185.                                 break;
  186.                         case '6':
  187.  
  188.                                 int baudrate, parity, bytesize, stopbits;
  189.  
  190.                                 SetConsoleTextAttribute(hConsole,15);
  191.                                 printf("\nZadaj parametre:");
  192.                                 printf("\n\nBaudRate(9600):\t");
  193.                                 scanf("%d", &baudrate);
  194.                                 printf("Parity(0): \t");
  195.                                 scanf("%d", &parity);
  196.                                 printf("ByteSize(8): \t");
  197.                                 scanf("%d", &bytesize);
  198.                                 printf("StopBits(1): \t");
  199.                                 scanf("%d", &stopbits);
  200.                                
  201.                                 load(hConsole);
  202.                                 set_dcb(hCom,hConsole,PortDCB,baudrate,parity,bytesize,stopbits);
  203.  
  204.                                 wiev_dcb(hCom,hConsole,PortDCB);
  205.  
  206.                                 getch();
  207.                                 break;
  208.                         case '7':
  209.                                 load(hConsole);
  210.                                 time(hCom,hConsole);
  211.                                 Sleep(500);
  212.                                 break;
  213.                         case '8':
  214.                                 open_port(hCom,hConsole);
  215.                                 Sleep(500);
  216.                                 break;
  217.                         case '0':
  218.                                 SetConsoleTextAttribute(hConsole,14);
  219.                                 printf("Dakujem za pouzivanie tohto programu :D\n\n");
  220.                                 SetConsoleTextAttribute(hConsole,15);
  221.                                 CloseHandle(hCom);
  222.                                 getch();
  223.                                 exit (0);
  224.                                 break;
  225. case VK_ESCAPE:
  226. Sleep(500);
  227. break;
  228.                         default:
  229.                                 SetConsoleTextAttribute(hConsole,12);
  230.                                 printf("Zla volba!!\n\n");
  231.                                 Sleep(500);
  232.                                 break;
  233.                 }
  234.  
  235.         }
  236.  
  237.  
  238.  
  239.         CloseHandle(hCom);                      // zatvorime port
  240.  
  241.         return 1;
  242. }
  243. // *********************************************************************************
  244. // *********************************************************************************
  245. // *********************************************************************************
  246.  
  247.  
  248.  
  249.  
  250.  
  251.  
  252.  
  253.  
  254.  
  255.  
  256. // *********************************************************************************
  257. // funkcia na zobrazenie komunikacnych nastaveni portu
  258. void wiev_dcb(HANDLE hCom,HANDLE hConsole,DCB & PortDCB)
  259. {
  260.  
  261.         SetConsoleTextAttribute(hConsole,15);
  262.     printf("\nAktualne nastavenia portu:\n");
  263.         printf("Baud Rate:  %d\n",PortDCB.BaudRate);
  264.         printf("Parity:     %d\n",PortDCB.Parity);
  265.         printf("Byte Size:  %d\n",PortDCB.ByteSize);
  266.         printf("Stop Bits:  %d\n",PortDCB.StopBits);
  267.         printf("\n");
  268.  
  269. }
  270.  
  271.  
  272.  
  273. // *********************************************************************************
  274. // funkcia na nastavenie komunikacnych nastaveni portu
  275. void set_dcb(HANDLE hCom,HANDLE hConsole,DCB & PortDCB,int baudrate,int parity, int bytesize,int stopbits)
  276. {
  277.  
  278.         PortDCB.BaudRate = baudrate;            // Zmeníme parametere v DCB
  279.         PortDCB.Parity = parity;
  280.         PortDCB.ByteSize = bytesize;
  281.         PortDCB.StopBits = stopbits;
  282.  
  283.         int err;
  284.         err = SetCommState(hCom,&PortDCB);      // Nastav aktuálne nastavenia na port
  285.         if(err)
  286.         {
  287.                 SetConsoleTextAttribute(hConsole,12);
  288.                 printf("Chyba:  Port sa neda nakonfigurovat.\n");
  289.                 return ;
  290.         }
  291.         else
  292.         {
  293.                 SetConsoleTextAttribute(hConsole,10);
  294.                 printf("Port je uspesne nakonfigurovany.\n");
  295.         }
  296.  
  297.  
  298. }
  299.  
  300.  
  301.  
  302. // *********************************************************************************
  303. // funkcia na nastavenie timeoutov
  304. void time(HANDLE hCom,HANDLE hConsole)
  305. {
  306.  
  307.         COMMTIMEOUTS timeouts;
  308.    
  309.         timeouts.ReadIntervalTimeout         =  20; //20
  310.         timeouts.ReadTotalTimeoutMultiplier  =  10; //10
  311.         timeouts.ReadTotalTimeoutConstant    = 10; //100
  312.         timeouts.WriteTotalTimeoutMultiplier =  10; //10
  313.         timeouts.ReadTotalTimeoutConstant    = 10; //100
  314.  
  315.         if (!SetCommTimeouts(hCom,&timeouts))
  316.         {
  317.                 SetConsoleTextAttribute(hConsole,12);
  318.                 printf("Chyba: Timeouty nenastavene.\n");
  319.                 return ;
  320.         }
  321.         else
  322.         {
  323.                 SetConsoleTextAttribute(hConsole,10);
  324.                 printf("Timeouty nastavene \n");
  325.         }
  326. }
  327.  
  328.  
  329.  
  330. // *********************************************************************************
  331. // funkcia na vyber portu
  332. HANDLE open_port(HANDLE hCom,HANDLE hConsole)
  333. {
  334.  
  335.         SetConsoleTextAttribute(hConsole,15);
  336.         printf("\nVyber port:\n"
  337.                 "(1) Com1\n"
  338.                 "(2) Com2\n"
  339.                 "(3) Com3\n"
  340.                 "(4) Com4\n");
  341.  
  342.  
  343.         switch(getch())
  344.         {
  345.                 case '1':
  346. //                      CloseHandle(hCom);
  347.                         load(hConsole);
  348.                         hCom = CreateFile(                
  349.                                 "COM1:",                        
  350.                                 GENERIC_READ | GENERIC_WRITE,  
  351.                                 0,                              
  352.                                 NULL,                            
  353.                                 OPEN_EXISTING,                  
  354.                                 0,                              
  355.                                 NULL);
  356.                         break; 
  357.                 case '2':
  358. //                      CloseHandle(hCom);
  359.                         load(hConsole);
  360.                         hCom = CreateFile(                
  361.                                 "COM2:",                        
  362.                                 GENERIC_READ | GENERIC_WRITE,    
  363.                                 0,                              
  364.                                 NULL,                            
  365.                                 OPEN_EXISTING,                  
  366.                                 0,                            
  367.                                 NULL);
  368.                         break;  
  369.                 case '3':
  370. //                      CloseHandle(hCom);
  371.                         load(hConsole);
  372.                         hCom = CreateFile(                
  373.                                 "COM3:",
  374.                                 GENERIC_READ | GENERIC_WRITE,
  375.                                 0,
  376.                                 NULL,
  377.                                 OPEN_EXISTING,
  378.                                 0,
  379.                                 NULL);
  380.                         break;
  381.                 case '4':
  382. //                      CloseHandle(hCom);
  383.                         load(hConsole);
  384.                         hCom = CreateFile(                
  385.                                 "COM4:",
  386.                                 GENERIC_READ | GENERIC_WRITE,
  387.                                 0,
  388.                                 NULL,
  389.                                 OPEN_EXISTING,
  390.                                 0,
  391.                                 NULL);
  392.                         break;
  393.                 default:
  394.                         SetConsoleTextAttribute(hConsole,12);
  395.                         printf("\nZla volba!!\n\n");
  396.                         return 0;
  397.                         break;
  398.         }
  399.  
  400.  
  401.         if ( hCom == INVALID_HANDLE_VALUE )
  402.         {
  403.                 SetConsoleTextAttribute(hConsole,12);
  404.                 printf("\nChyba:  Port sa neda otvorit.\n\n");
  405.                 return 0;
  406.         }
  407.         else
  408.         {
  409.                 SetConsoleTextAttribute(hConsole,10);
  410.                 printf("\nPort je uspesne otvoreny.\n");
  411.         }
  412.        
  413.         return hCom;
  414. }
  415.  
  416.  
  417.  
  418. // *********************************************************************************
  419. // funkcia load
  420. void load(HANDLE hConsole)
  421. {
  422.         SetConsoleTextAttribute(hConsole,15);
  423.  
  424.         int n;
  425.         for (n=1;n<11;n++)
  426.         {
  427.                 printf(".");
  428.                 Sleep(100);
  429.         }
  430.         printf("\n");
  431. }
  432.  
  433.  
  434.  
  435. // *********************************************************************************
  436. // funkcia opakovane vysielanie znaku na port
  437. void send_znak(HANDLE hCom,HANDLE hConsole)
  438. {
  439.  
  440.         DWORD PocetOdo=0;
  441.  
  442.         SetConsoleTextAttribute(hConsole,14);
  443.         printf("\nZvol odosielany znak");
  444.         char DataOdo=getch();
  445.  
  446.         while (1)
  447.         {
  448.  
  449.                 WriteFile(
  450.                         hCom,                           // Handle portu, ktory ste otvorili CreateFile
  451.                     &DataOdo,                   // Smernik (pointer) na data, ktore chcem vysielat
  452.                         1,                                      // Pocet bytov, ktore chcem vyslat
  453.                     &PocetOdo,                  // Smernik (pointer) na pocet vyslanych dat
  454.                 NULL);                          // Musi byt NULL
  455.  
  456.                 if( PocetOdo != 1 )             // Ak pocet prenesenych dat nesuhlasi
  457.                 {
  458.                         SetConsoleTextAttribute(hConsole,12);
  459.                         printf("\nChyba: Zapis na port sa nepodaril.\n\n");
  460.                         CloseHandle(hCom);
  461.                         Sleep(1000);
  462.                         return;
  463.                 }
  464.                 else
  465.                 {
  466.                         SetConsoleTextAttribute(hConsole,10);
  467.                         printf("\nOdoslany znak ");
  468.                         SetConsoleTextAttribute(hConsole,15);
  469.                         printf("%c", DataOdo);
  470.                 }
  471.  
  472.                 if (IsKeyPressed(VK_ESCAPE))
  473.                 {
  474.                         SetConsoleTextAttribute(hConsole,12);
  475.                         printf("\nKoniec prenosu");
  476.                         Sleep(500);
  477.                         SetConsoleTextAttribute(hConsole,15);
  478.                         return;
  479.                 }
  480.  
  481.                 Sleep(100);
  482.         }
  483.  
  484. }
  485.  
  486.  
  487.  
  488. // *********************************************************************************
  489. // funkcia detekujuca stacenie klavesy
  490. bool IsKeyPressed(int virtualKey)
  491. {
  492.     return ((GetAsyncKeyState(virtualKey)&0x8000)!=0?true:false);
  493. }
  494.  
  495.  
  496.  
  497.  
  498. // *********************************************************************************
  499. // funkcia na chat
  500. int chat(HANDLE hCom, HANDLE hConsole)
  501. {
  502.  
  503.         SetConsoleTextAttribute(hConsole,9);
  504.         printf("\nChat\n\n");
  505.         SetConsoleTextAttribute(hConsole,15);
  506.  
  507. //      unsigned int Data; // povodne char
  508.  
  509.         DWORD Pocet_pri = 0;
  510.         char Data_pri[200]={0};      // Sem ulož prijatý znak
  511.  
  512.         DWORD Pocet_odo = 0;
  513.         char Data_vys[150]={0};
  514.         unsigned int dlzka;
  515.  
  516.  
  517.         PurgeComm(hCom,PURGE_TXCLEAR | PURGE_RXCLEAR);
  518.  
  519.  
  520.         while(1)
  521.         {
  522.  
  523.                 while (1)
  524.                 {
  525.  
  526.                         Pocet_pri=0;
  527.  
  528.                         ReadFile(
  529.                                 hCom,
  530.                                 Data_pri,
  531.                                 100,
  532.                                 &Pocet_pri,
  533.                                 NULL);
  534.  
  535.                         if(Pocet_pri != 0)
  536.                         {
  537.                                 SetConsoleTextAttribute(hConsole, 14);
  538.                                 printf("ON:%s\n", Data_pri);
  539.  
  540.                                 if (strcmp(Data_pri, "KONIEC") == 0)
  541.                                         return 1;
  542.                         }
  543.  
  544. if (IsKeyPressed(VK_SHIFT))            
  545.         break;
  546. if (IsKeyPressed(VK_ESCAPE))            
  547.         return 1;
  548.  
  549.  
  550.                 }
  551.  
  552.                         SetConsoleTextAttribute(hConsole, 10);
  553.                         printf("JA:");
  554.  
  555.                         Sleep(100);
  556.  
  557.                         gets(Data_vys);
  558.  
  559.                         dlzka = strlen(Data_vys);
  560.  
  561.                         WriteFile (
  562.                                 hCom,                                   // Handle portu, z ktorého cítame
  563.                                 &Data_vys,                              // Pointer na buffer, kam ukladáme prijaté dáta
  564.                                 dlzka,                                  // Pocet bytov, na ktoré cakáme
  565.                                 &Pocet_pri,                             // Pointer na skutocný pocet prijatých dát
  566.                                 NULL);                                  // Musí byt NULL
  567.        
  568.                         if( Pocet_pri != dlzka )
  569.                         {
  570.                                 printf("\n Chyba pri posielani spravy.\n");
  571.                                 CloseHandle(hCom);  
  572.                                 return 0;
  573.                         }
  574.  
  575.                         if(strcmp(Data_vys, "KONIEC") == 0)
  576.                                 return 1;
  577.        
  578.                 if (IsKeyPressed(VK_ESCAPE))            
  579.                         return 1;
  580.  
  581.  
  582.         }
  583.  
  584.         return 1;
  585. }
create a new version of this paste RAW Paste Data