Guest User

Komunikácia - Arduino + PC - HW UART + MEGA COMPATIBLE

a guest
Nov 19th, 2020
138
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. /*|----------------------------------------|*/
  2. /*|Projekt: UART komunikácia Arduino + PC  |*/
  3. /*|Hardvér: Arduino Uno / Nano / Mega      |*/
  4. /*|Autor: Martin Chlebovec                 |*/
  5. /*|E-mail: martinius96@gmail.com           |*/
  6. /*|Revízia: 18. November 2020              |*/
  7. /*|----------------------------------------|*/
  8.  
  9. //UPRAVIT PRE ARDUINO UNO
  10. #if defined(__AVR_ATmega328P__)
  11. int OutPut_ledArray[] = {2, 3, 4, 5, 6, 7}; //piny VYSTUPU
  12. int Input_ledArray[] = {8}; //piny vstupu - INPUT
  13. int Input_PULLUP_ledArray[] = {9, 10, 11, 12, 13}; //piny INPUT - standardne HIGH (interny pullup 20kohm rezistor)
  14.  
  15.  
  16. //UPRAVIŤ PRE ARDUINO MEGA
  17. #elif defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
  18. int OutPut_ledArray[] = {2, 3, 4, 5, 6, 7}; //piny VYSTUPU
  19. int Input_ledArray[] = {8}; //piny vstupu - INPUT
  20. int Input_PULLUP_ledArray[] = {9, 10, 11, 12, 13}; //piny INPUT - standardne HIGH (interny pullup 20kohm rezistor)
  21. #endif
  22. void setup() {
  23.  
  24.   for (byte i = 0; i < (sizeof(OutPut_ledArray) / sizeof(OutPut_ledArray[0])); i++) {
  25.     pinMode(OutPut_ledArray[i], OUTPUT); //nastav vsetky prvky pola na vystup
  26.     //digitalWrite(OutPut_ledArray[i], HIGH); //AK CHCEME NASTAVIT AJ NEJAKU POCIATOCNU UROVEN VYSTUPOV
  27.   }
  28.   for (byte i = 0; i < (sizeof(Input_ledArray) / sizeof(Input_ledArray[0])); i++) {
  29.     pinMode(Input_ledArray[i], INPUT); //nastav vsetky prvky pola na vstup
  30.   }
  31.  
  32.   for (byte i = 0; i < (sizeof(Input_PULLUP_ledArray) / sizeof(Input_PULLUP_ledArray[0])); i++) {
  33.     pinMode(Input_PULLUP_ledArray[i], INPUT_PULLUP); //nastav vsetky prvky pola na pullup vstup
  34.   }
  35.   Serial.begin(115200);
  36.   while (Serial.available() <= 0) {
  37.     //-----------------PRIKLAD POUZITIA-------------
  38.     //Input? --> Vypíše všetky vstupy a výstupy
  39.     //SET DCISLO HIGH --> nastaví na číslo D pinu hodnotu HIGH
  40.     //SET DCISLO LOW --> nastaví na číslo D pinu hodnotu LOW
  41.     //SET HIGH --> nastaví na vsetky vystupy HIGH
  42.     //SET LOW --> nastaví na vsetky vystupy LOW
  43.     Serial.println(F("Zadajte prikaz - Input? / SET D2 HIGH / SET D2 LOW / SET HIGH / SET LOW "));
  44.     delay(1000);
  45.   }
  46. }
  47.  
  48. void loop() {
  49.   if (Serial.available() > 0) {
  50.     String value = Serial.readStringUntil('\n');
  51.     if (value == "Input?") {
  52.       Serial.print(F("Output - "));
  53. #if defined(__AVR_ATmega328P__)
  54.       int i = 13; //POCET D GPIO
  55. #elif defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
  56.       int i = 53; //POCET D GPIO
  57. #endif
  58.       while (i >= 2) {
  59.         Serial.print(digitalRead(i)); //Vypis od D13 po D2
  60.         i--;
  61.       }
  62. #if defined(__AVR_ATmega328P__)
  63.       i = 5; //POCET ANALOG VSTUPOV
  64. #elif defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
  65.       i = 15; //POCET ANALOG VSTUPOV
  66. #endif
  67.       while (i >= 0) {
  68.         Serial.print(F("("));
  69.         Serial.print(analogRead(i)); //Vypis od A5 po A0
  70.         Serial.print(F(")"));
  71.         i--;
  72.       }
  73.       Serial.println();
  74.     } else if (value.startsWith("SET")) {
  75.       if (value.indexOf("D") > 0) {
  76.         String sub = value.substring(5, 7);
  77.         sub.trim(); //pri jednocifernych cislach zmaze medzeru (pri dvojcifernom cisle medzera nie je)
  78.         int cislo = sub.toInt(); //pretypovanie String --> Int, mozno cez switch overit hodnotu
  79.         if (value.indexOf("HIGH") > 0) {
  80.           switch (cislo)
  81.           {
  82.             case 2:
  83.               digitalWrite(2, HIGH);
  84.               if (digitalRead(2)) {
  85.                 Serial.println(F("D2 nastaveny na hodnotu HIGH"));
  86.               } else {
  87.                 Serial.println(F("Problem, D2 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  88.               }
  89.               break;
  90.             case 3:
  91.               digitalWrite(3, HIGH);
  92.               if (digitalRead(3)) {
  93.                 Serial.println(F("D3 nastaveny na hodnotu HIGH"));
  94.               } else {
  95.                 Serial.println(F("Problem, D3 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  96.               }
  97.               break;
  98.             case 4:
  99.               digitalWrite(4, HIGH);
  100.               if (digitalRead(4)) {
  101.                 Serial.println(F("D4 nastaveny na hodnotu HIGH"));
  102.               } else {
  103.                 Serial.println(F("Problem, D4 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  104.               }
  105.               break;
  106.             case 5:
  107.               digitalWrite(5, HIGH);
  108.               if (digitalRead(5)) {
  109.                 Serial.println(F("D5 nastaveny na hodnotu HIGH"));
  110.               } else {
  111.                 Serial.println(F("Problem, D5 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  112.               }
  113.               break;
  114.             case 6:
  115.               digitalWrite(6, HIGH);
  116.               if (digitalRead(6)) {
  117.                 Serial.println(F("D6 nastaveny na hodnotu HIGH"));
  118.               } else {
  119.                 Serial.println(F("Problem, D6 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  120.               }
  121.               break;
  122.             case 7:
  123.               digitalWrite(7, HIGH);
  124.               if (digitalRead(7)) {
  125.                 Serial.println(F("D7 nastaveny na hodnotu HIGH"));
  126.               } else {
  127.                 Serial.println(F("Problem, D7 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  128.               }
  129.               break;
  130.             case 8:
  131.               digitalWrite(8, HIGH);
  132.               if (digitalRead(8)) {
  133.                 Serial.println(F("D8 nastaveny na hodnotu HIGH"));
  134.               } else {
  135.                 Serial.println(F("Problem, D8 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  136.               }
  137.               break;
  138.             case 9:
  139.               digitalWrite(9, HIGH);
  140.               if (digitalRead(9)) {
  141.                 Serial.println(F("D9 nastaveny na hodnotu HIGH"));
  142.               } else {
  143.                 Serial.println(F("Problem, D9 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  144.               }
  145.               break;
  146.             case 10:
  147.               digitalWrite(10, HIGH);
  148.               if (digitalRead(10)) {
  149.                 Serial.println(F("D10 nastaveny na hodnotu HIGH"));
  150.               } else {
  151.                 Serial.println(F("Problem, D10 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  152.               }
  153.               break;
  154.             case 11:
  155.               digitalWrite(11, HIGH);
  156.               if (digitalRead(11)) {
  157.                 Serial.println(F("D11 nastaveny na hodnotu HIGH"));
  158.               } else {
  159.                 Serial.println(F("Problem, D11 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  160.               }
  161.               break;
  162.             case 12:
  163.               digitalWrite(12, HIGH);
  164.               if (digitalRead(12)) {
  165.                 Serial.println(F("D12 nastaveny na hodnotu HIGH"));
  166.               } else {
  167.                 Serial.println(F("Problem, D12 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  168.               }
  169.               break;
  170.             case 13:
  171.               digitalWrite(13, HIGH);
  172.               if (digitalRead(13)) {
  173.                 Serial.println(F("D13 nastaveny na hodnotu HIGH"));
  174.               } else {
  175.                 Serial.println(F("Problem, D13 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  176.               }
  177.               break;
  178. #if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
  179.             case 14:
  180.               digitalWrite(14, HIGH);
  181.               if (digitalRead(14)) {
  182.                 Serial.println(F("D14 nastaveny na hodnotu HIGH"));
  183.               } else {
  184.                 Serial.println(F("Problem, D14 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  185.               }
  186.               break;
  187.             case 15:
  188.               digitalWrite(15, HIGH);
  189.               if (digitalRead(15)) {
  190.                 Serial.println(F("D15 nastaveny na hodnotu HIGH"));
  191.               } else {
  192.                 Serial.println(F("Problem, D15 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  193.               }
  194.               break;
  195.             case 16:
  196.               digitalWrite(16, HIGH);
  197.               if (digitalRead(16)) {
  198.                 Serial.println(F("D16 nastaveny na hodnotu HIGH"));
  199.               } else {
  200.                 Serial.println(F("Problem, D16 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  201.               }
  202.               break;
  203.             case 17:
  204.               digitalWrite(17, HIGH);
  205.               if (digitalRead(17)) {
  206.                 Serial.println(F("D17 nastaveny na hodnotu HIGH"));
  207.               } else {
  208.                 Serial.println(F("Problem, D17 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  209.               }
  210.               break;
  211.             case 18:
  212.               digitalWrite(18, HIGH);
  213.               if (digitalRead(18)) {
  214.                 Serial.println(F("D18 nastaveny na hodnotu HIGH"));
  215.               } else {
  216.                 Serial.println(F("Problem, D18 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  217.               }
  218.               break;
  219.             case 19:
  220.               digitalWrite(19, HIGH);
  221.               if (digitalRead(19)) {
  222.                 Serial.println(F("D19 nastaveny na hodnotu HIGH"));
  223.               } else {
  224.                 Serial.println(F("Problem, D19 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  225.               }
  226.               break;
  227.             case 20:
  228.               digitalWrite(20, HIGH);
  229.               if (digitalRead(20)) {
  230.                 Serial.println(F("D20 nastaveny na hodnotu HIGH"));
  231.               } else {
  232.                 Serial.println(F("Problem, D20 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  233.               }
  234.               break;
  235.             case 21:
  236.               digitalWrite(21, HIGH);
  237.               if (digitalRead(21)) {
  238.                 Serial.println(F("D21 nastaveny na hodnotu HIGH"));
  239.               } else {
  240.                 Serial.println(F("Problem, D21 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  241.               }
  242.               break;
  243.             case 22:
  244.               digitalWrite(22, HIGH);
  245.               if (digitalRead(22)) {
  246.                 Serial.println(F("D22 nastaveny na hodnotu HIGH"));
  247.               } else {
  248.                 Serial.println(F("Problem, D22 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  249.               }
  250.               break;
  251.             case 23:
  252.               digitalWrite(23, HIGH);
  253.               if (digitalRead(23)) {
  254.                 Serial.println(F("D23 nastaveny na hodnotu HIGH"));
  255.               } else {
  256.                 Serial.println(F("Problem, D23 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  257.               }
  258.               break;
  259.             case 24:
  260.               digitalWrite(24, HIGH);
  261.               if (digitalRead(24)) {
  262.                 Serial.println(F("D24 nastaveny na hodnotu HIGH"));
  263.               } else {
  264.                 Serial.println(F("Problem, D24 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  265.               }
  266.               break;
  267.             case 25:
  268.               digitalWrite(25, HIGH);
  269.               if (digitalRead(25)) {
  270.                 Serial.println(F("D25 nastaveny na hodnotu HIGH"));
  271.               } else {
  272.                 Serial.println(F("Problem, D25 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  273.               }
  274.               break;
  275.             case 26:
  276.               digitalWrite(26, HIGH);
  277.               if (digitalRead(26)) {
  278.                 Serial.println(F("D26 nastaveny na hodnotu HIGH"));
  279.               } else {
  280.                 Serial.println(F("Problem, D26 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  281.               }
  282.               break;
  283.             case 27:
  284.               digitalWrite(27, HIGH);
  285.               if (digitalRead(27)) {
  286.                 Serial.println(F("D27 nastaveny na hodnotu HIGH"));
  287.               } else {
  288.                 Serial.println(F("Problem, D27 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  289.               }
  290.               break;
  291.             case 28:
  292.               digitalWrite(28, HIGH);
  293.               if (digitalRead(28)) {
  294.                 Serial.println(F("D28 nastaveny na hodnotu HIGH"));
  295.               } else {
  296.                 Serial.println(F("Problem, D28 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  297.               }
  298.               break;
  299.             case 29:
  300.               digitalWrite(29, HIGH);
  301.               if (digitalRead(29)) {
  302.                 Serial.println(F("D29 nastaveny na hodnotu HIGH"));
  303.               } else {
  304.                 Serial.println(F("Problem, D29 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  305.               }
  306.               break;
  307.             case 30:
  308.               digitalWrite(30, HIGH);
  309.               if (digitalRead(30)) {
  310.                 Serial.println(F("D30 nastaveny na hodnotu HIGH"));
  311.               } else {
  312.                 Serial.println(F("Problem, D30 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  313.               }
  314.               break;
  315.             case 31:
  316.               digitalWrite(31, HIGH);
  317.               if (digitalRead(31)) {
  318.                 Serial.println(F("D31 nastaveny na hodnotu HIGH"));
  319.               } else {
  320.                 Serial.println(F("Problem, D31 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  321.               }
  322.               break;
  323.             case 32:
  324.               digitalWrite(32, HIGH);
  325.               if (digitalRead(32)) {
  326.                 Serial.println(F("D32 nastaveny na hodnotu HIGH"));
  327.               } else {
  328.                 Serial.println(F("Problem, D32 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  329.               }
  330.               break;
  331.             case 33:
  332.               digitalWrite(33, HIGH);
  333.               if (digitalRead(33)) {
  334.                 Serial.println(F("D33 nastaveny na hodnotu HIGH"));
  335.               } else {
  336.                 Serial.println(F("Problem, D33 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  337.               }
  338.               break;
  339.             case 34:
  340.               digitalWrite(34, HIGH);
  341.               if (digitalRead(34)) {
  342.                 Serial.println(F("D34 nastaveny na hodnotu HIGH"));
  343.               } else {
  344.                 Serial.println(F("Problem, D34 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  345.               }
  346.               break;
  347.             case 35:
  348.               digitalWrite(35, HIGH);
  349.               if (digitalRead(35)) {
  350.                 Serial.println(F("D35 nastaveny na hodnotu HIGH"));
  351.               } else {
  352.                 Serial.println(F("Problem, D35 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  353.               }
  354.               break;
  355.             case 36:
  356.               digitalWrite(36, HIGH);
  357.               if (digitalRead(36)) {
  358.                 Serial.println(F("D36 nastaveny na hodnotu HIGH"));
  359.               } else {
  360.                 Serial.println(F("Problem, D36 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  361.               }
  362.               break;
  363.             case 37:
  364.               digitalWrite(37, HIGH);
  365.               if (digitalRead(37)) {
  366.                 Serial.println(F("D37 nastaveny na hodnotu HIGH"));
  367.               } else {
  368.                 Serial.println(F("Problem, D37 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  369.               }
  370.               break;
  371.             case 38:
  372.               digitalWrite(38, HIGH);
  373.               if (digitalRead(38)) {
  374.                 Serial.println(F("D38 nastaveny na hodnotu HIGH"));
  375.               } else {
  376.                 Serial.println(F("Problem, D38 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  377.               }
  378.               break;
  379.             case 39:
  380.               digitalWrite(39, HIGH);
  381.               if (digitalRead(39)) {
  382.                 Serial.println(F("D39 nastaveny na hodnotu HIGH"));
  383.               } else {
  384.                 Serial.println(F("Problem, D39 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  385.               }
  386.               break;
  387.             case 40:
  388.               digitalWrite(40, HIGH);
  389.               if (digitalRead(40)) {
  390.                 Serial.println(F("D40 nastaveny na hodnotu HIGH"));
  391.               } else {
  392.                 Serial.println(F("Problem, D40 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  393.               }
  394.               break;
  395.             case 41:
  396.               digitalWrite(41, HIGH);
  397.               if (digitalRead(41)) {
  398.                 Serial.println(F("D41 nastaveny na hodnotu HIGH"));
  399.               } else {
  400.                 Serial.println(F("Problem, D41 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  401.               }
  402.               break;
  403.             case 42:
  404.               digitalWrite(42, HIGH);
  405.               if (digitalRead(42)) {
  406.                 Serial.println(F("D42 nastaveny na hodnotu HIGH"));
  407.               } else {
  408.                 Serial.println(F("Problem, D42 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  409.               }
  410.               break;
  411.             case 43:
  412.               digitalWrite(43, HIGH);
  413.               if (digitalRead(43)) {
  414.                 Serial.println(F("D43 nastaveny na hodnotu HIGH"));
  415.               } else {
  416.                 Serial.println(F("Problem, D43 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  417.               }
  418.               break;
  419.             case 44:
  420.               digitalWrite(44, HIGH);
  421.               if (digitalRead(44)) {
  422.                 Serial.println(F("D44 nastaveny na hodnotu HIGH"));
  423.               } else {
  424.                 Serial.println(F("Problem, D44 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  425.               }
  426.               break;
  427.             case 45:
  428.               digitalWrite(45, HIGH);
  429.               if (digitalRead(45)) {
  430.                 Serial.println(F("D45 nastaveny na hodnotu HIGH"));
  431.               } else {
  432.                 Serial.println(F("Problem, D45 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  433.               }
  434.               break;
  435.             case 46:
  436.               digitalWrite(46, HIGH);
  437.               if (digitalRead(46)) {
  438.                 Serial.println(F("D46 nastaveny na hodnotu HIGH"));
  439.               } else {
  440.                 Serial.println(F("Problem, D46 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  441.               }
  442.               break;
  443.             case 47:
  444.               digitalWrite(47, HIGH);
  445.               if (digitalRead(47)) {
  446.                 Serial.println(F("D47 nastaveny na hodnotu HIGH"));
  447.               } else {
  448.                 Serial.println(F("Problem, D47 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  449.               }
  450.               break;
  451.             case 48:
  452.               digitalWrite(48, HIGH);
  453.               if (digitalRead(48)) {
  454.                 Serial.println(F("D48 nastaveny na hodnotu HIGH"));
  455.               } else {
  456.                 Serial.println(F("Problem, D48 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  457.               }
  458.               break;
  459.             case 49:
  460.               digitalWrite(49, HIGH);
  461.               if (digitalRead(49)) {
  462.                 Serial.println(F("D49 nastaveny na hodnotu HIGH"));
  463.               } else {
  464.                 Serial.println(F("Problem, D49 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  465.               }
  466.               break;
  467.             case 50:
  468.               digitalWrite(50, HIGH);
  469.               if (digitalRead(50)) {
  470.                 Serial.println(F("D50 nastaveny na hodnotu HIGH"));
  471.               } else {
  472.                 Serial.println(F("Problem, D50 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  473.               }
  474.               break;
  475.             case 51:
  476.               digitalWrite(51, HIGH);
  477.               if (digitalRead(51)) {
  478.                 Serial.println(F("D51 nastaveny na hodnotu HIGH"));
  479.               } else {
  480.                 Serial.println(F("Problem, D51 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  481.               }
  482.               break;
  483.             case 52:
  484.               digitalWrite(52, HIGH);
  485.               if (digitalRead(52)) {
  486.                 Serial.println(F("D52 nastaveny na hodnotu HIGH"));
  487.               } else {
  488.                 Serial.println(F("Problem, D52 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  489.               }
  490.               break;
  491.             case 53:
  492.               digitalWrite(53, HIGH);
  493.               if (digitalRead(53)) {
  494.                 Serial.println(F("D53 nastaveny na hodnotu HIGH"));
  495.               } else {
  496.                 Serial.println(F("Problem, D53 je nastaveny ako vstup, nemozno nastavit HIGH!"));
  497.               }
  498.               break;
  499. #endif
  500.             default:  // ignore the rest
  501. #if defined(__AVR_ATmega328P__)
  502.               Serial.println(F("CHYBA, NEPODPOROVANE CISLO D PINU ( ROZSAH D2 - D13)"));
  503. #elif defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
  504.               Serial.println(F("CHYBA, NEPODPOROVANE CISLO D PINU ( ROZSAH D2 - D53)"));
  505. #endif
  506.               break;
  507.           }
  508.         } else if (value.indexOf("LOW") > 0) {
  509.           switch (cislo)
  510.           {
  511.             case 2:
  512.               digitalWrite(2, LOW);
  513.               if (!digitalRead(2)) {
  514.                 Serial.println(F("D2 nastaveny na hodnotu LOW"));
  515.               } else {
  516.                 Serial.println(F("Problem, D2 je nastaveny ako vstup - PULLUP!"));
  517.               }
  518.               break;
  519.             case 3:
  520.               digitalWrite(3, LOW);
  521.               if (!digitalRead(3)) {
  522.                 Serial.println(F("D3 nastaveny na hodnotu LOW"));
  523.               } else {
  524.                 Serial.println(F("Problem, D3 je nastaveny ako vstup - PULLUP!"));
  525.               }
  526.               break;
  527.             case 4:
  528.               digitalWrite(4, LOW);
  529.               if (!digitalRead(4)) {
  530.                 Serial.println(F("D4 nastaveny na hodnotu LOW"));
  531.               } else {
  532.                 Serial.println(F("Problem, D4 je nastaveny ako vstup - PULLUP!"));
  533.               }
  534.               break;
  535.             case 5:
  536.               digitalWrite(5, LOW);
  537.               if (!digitalRead(5)) {
  538.                 Serial.println(F("D5 nastaveny na hodnotu LOW"));
  539.               } else {
  540.                 Serial.println(F("Problem, D5 je nastaveny ako vstup - PULLUP!"));
  541.               }
  542.               break;
  543.             case 6:
  544.               digitalWrite(6, LOW);
  545.               if (!digitalRead(6)) {
  546.                 Serial.println(F("D6 nastaveny na hodnotu LOW"));
  547.               } else {
  548.                 Serial.println(F("Problem, D6 je nastaveny ako vstup - PULLUP!"));
  549.               }
  550.               break;
  551.             case 7:
  552.               digitalWrite(7, LOW);
  553.               if (!digitalRead(7)) {
  554.                 Serial.println(F("D7 nastaveny na hodnotu LOW"));
  555.               } else {
  556.                 Serial.println(F("Problem, D7 je nastaveny ako vstup - PULLUP!"));
  557.               }
  558.               break;
  559.             case 8:
  560.               digitalWrite(8, LOW);
  561.               if (!digitalRead(8)) {
  562.                 Serial.println(F("D8 nastaveny na hodnotu LOW"));
  563.               } else {
  564.                 Serial.println(F("Problem, D8 je nastaveny ako vstup - PULLUP!"));
  565.               }
  566.               break;
  567.             case 9:
  568.               digitalWrite(9, LOW);
  569.               if (!digitalRead(9)) {
  570.                 Serial.println(F("D9 nastaveny na hodnotu LOW"));
  571.               } else {
  572.                 Serial.println(F("Problem, D9 je nastaveny ako vstup - PULLUP!"));
  573.               }
  574.               break;
  575.             case 10:
  576.               digitalWrite(10, LOW);
  577.               if (!digitalRead(10)) {
  578.                 Serial.println(F("D10 nastaveny na hodnotu LOW"));
  579.               } else {
  580.                 Serial.println(F("Problem, D10 je nastaveny ako vstup - PULLUP!"));
  581.               }
  582.               break;
  583.             case 11:
  584.               digitalWrite(11, LOW);
  585.               if (!digitalRead(11)) {
  586.                 Serial.println(F("D11 nastaveny na hodnotu LOW"));
  587.               } else {
  588.                 Serial.println(F("Problem, D11 je nastaveny ako vstup - PULLUP!"));
  589.               }
  590.               break;
  591.             case 12:
  592.               digitalWrite(12, LOW);
  593.               if (!digitalRead(12)) {
  594.                 Serial.println(F("D12 nastaveny na hodnotu LOW"));
  595.               } else {
  596.                 Serial.println(F("Problem, D12 je nastaveny ako vstup - PULLUP!"));
  597.               }
  598.               break;
  599.             case 13:
  600.               digitalWrite(13, LOW);
  601.               if (!digitalRead(13)) {
  602.                 Serial.println(F("D13 nastaveny na hodnotu LOW"));
  603.               } else {
  604.                 Serial.println(F("Problem, D13 je nastaveny ako vstup - PULLUP!"));
  605.               }
  606.               break;
  607. #if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
  608.             case 14:
  609.               digitalWrite(14, LOW);
  610.               if (digitalRead(14)) {
  611.                 Serial.println(F("D14 nastaveny na hodnotu LOW"));
  612.               } else {
  613.                 Serial.println(F("Problem, D14 je nastaveny ako vstup - PULLUP!"));
  614.               }
  615.               break;
  616.             case 15:
  617.               digitalWrite(15, LOW);
  618.               if (digitalRead(15)) {
  619.                 Serial.println(F("D15 nastaveny na hodnotu LOW"));
  620.               } else {
  621.                 Serial.println(F("Problem, D15 je nastaveny ako vstup - PULLUP!"));
  622.               }
  623.               break;
  624.             case 16:
  625.               digitalWrite(16, LOW);
  626.               if (digitalRead(16)) {
  627.                 Serial.println(F("D16 nastaveny na hodnotu LOW"));
  628.               } else {
  629.                 Serial.println(F("Problem, D16 je nastaveny ako vstup - PULLUP!"));
  630.               }
  631.               break;
  632.             case 17:
  633.               digitalWrite(17, LOW);
  634.               if (digitalRead(17)) {
  635.                 Serial.println(F("D17 nastaveny na hodnotu LOW"));
  636.               } else {
  637.                 Serial.println(F("Problem, D17 je nastaveny ako vstup - PULLUP!"));
  638.               }
  639.               break;
  640.             case 18:
  641.               digitalWrite(18, LOW);
  642.               if (digitalRead(18)) {
  643.                 Serial.println(F("D18 nastaveny na hodnotu LOW"));
  644.               } else {
  645.                 Serial.println(F("Problem, D18 je nastaveny ako vstup - PULLUP!"));
  646.               }
  647.               break;
  648.             case 19:
  649.               digitalWrite(19, LOW);
  650.               if (digitalRead(19)) {
  651.                 Serial.println(F("D19 nastaveny na hodnotu LOW"));
  652.               } else {
  653.                 Serial.println(F("Problem, D19 je nastaveny ako vstup - PULLUP!"));
  654.               }
  655.               break;
  656.             case 20:
  657.               digitalWrite(20, LOW);
  658.               if (digitalRead(20)) {
  659.                 Serial.println(F("D20 nastaveny na hodnotu LOW"));
  660.               } else {
  661.                 Serial.println(F("Problem, D20 je nastaveny ako vstup - PULLUP!"));
  662.               }
  663.               break;
  664.             case 21:
  665.               digitalWrite(21, LOW);
  666.               if (digitalRead(21)) {
  667.                 Serial.println(F("D21 nastaveny na hodnotu LOW"));
  668.               } else {
  669.                 Serial.println(F("Problem, D21 je nastaveny ako vstup - PULLUP!"));
  670.               }
  671.               break;
  672.             case 22:
  673.               digitalWrite(22, LOW);
  674.               if (digitalRead(22)) {
  675.                 Serial.println(F("D22 nastaveny na hodnotu LOW"));
  676.               } else {
  677.                 Serial.println(F("Problem, D22 je nastaveny ako vstup - PULLUP!"));
  678.               }
  679.               break;
  680.             case 23:
  681.               digitalWrite(23, LOW);
  682.               if (digitalRead(23)) {
  683.                 Serial.println(F("D23 nastaveny na hodnotu LOW"));
  684.               } else {
  685.                 Serial.println(F("Problem, D23 je nastaveny ako vstup - PULLUP!"));
  686.               }
  687.               break;
  688.             case 24:
  689.               digitalWrite(24, LOW);
  690.               if (digitalRead(24)) {
  691.                 Serial.println(F("D24 nastaveny na hodnotu LOW"));
  692.               } else {
  693.                 Serial.println(F("Problem, D24 je nastaveny ako vstup - PULLUP!"));
  694.               }
  695.               break;
  696.             case 25:
  697.               digitalWrite(25, LOW);
  698.               if (digitalRead(25)) {
  699.                 Serial.println(F("D25 nastaveny na hodnotu LOW"));
  700.               } else {
  701.                 Serial.println(F("Problem, D25 je nastaveny ako vstup - PULLUP!"));
  702.               }
  703.               break;
  704.             case 26:
  705.               digitalWrite(26, LOW);
  706.               if (digitalRead(26)) {
  707.                 Serial.println(F("D26 nastaveny na hodnotu LOW"));
  708.               } else {
  709.                 Serial.println(F("Problem, D26 je nastaveny ako vstup - PULLUP!"));
  710.               }
  711.               break;
  712.             case 27:
  713.               digitalWrite(27, LOW);
  714.               if (digitalRead(27)) {
  715.                 Serial.println(F("D27 nastaveny na hodnotu LOW"));
  716.               } else {
  717.                 Serial.println(F("Problem, D27 je nastaveny ako vstup - PULLUP!"));
  718.               }
  719.               break;
  720.             case 28:
  721.               digitalWrite(28, LOW);
  722.               if (digitalRead(28)) {
  723.                 Serial.println(F("D28 nastaveny na hodnotu LOW"));
  724.               } else {
  725.                 Serial.println(F("Problem, D28 je nastaveny ako vstup - PULLUP!"));
  726.               }
  727.               break;
  728.             case 29:
  729.               digitalWrite(29, LOW);
  730.               if (digitalRead(29)) {
  731.                 Serial.println(F("D29 nastaveny na hodnotu LOW"));
  732.               } else {
  733.                 Serial.println(F("Problem, D29 je nastaveny ako vstup - PULLUP!"));
  734.               }
  735.               break;
  736.             case 30:
  737.               digitalWrite(30, LOW);
  738.               if (digitalRead(30)) {
  739.                 Serial.println(F("D30 nastaveny na hodnotu LOW"));
  740.               } else {
  741.                 Serial.println(F("Problem, D30 je nastaveny ako vstup - PULLUP!"));
  742.               }
  743.               break;
  744.             case 31:
  745.               digitalWrite(31, LOW);
  746.               if (digitalRead(31)) {
  747.                 Serial.println(F("D31 nastaveny na hodnotu LOW"));
  748.               } else {
  749.                 Serial.println(F("Problem, D31 je nastaveny ako vstup - PULLUP!"));
  750.               }
  751.               break;
  752.             case 32:
  753.               digitalWrite(32, LOW);
  754.               if (digitalRead(32)) {
  755.                 Serial.println(F("D32 nastaveny na hodnotu LOW"));
  756.               } else {
  757.                 Serial.println(F("Problem, D32 je nastaveny ako vstup - PULLUP!"));
  758.               }
  759.               break;
  760.             case 33:
  761.               digitalWrite(33, LOW);
  762.               if (digitalRead(33)) {
  763.                 Serial.println(F("D33 nastaveny na hodnotu LOW"));
  764.               } else {
  765.                 Serial.println(F("Problem, D33 je nastaveny ako vstup - PULLUP!"));
  766.               }
  767.               break;
  768.             case 34:
  769.               digitalWrite(34, LOW);
  770.               if (digitalRead(34)) {
  771.                 Serial.println(F("D34 nastaveny na hodnotu LOW"));
  772.               } else {
  773.                 Serial.println(F("Problem, D34 je nastaveny ako vstup - PULLUP!"));
  774.               }
  775.               break;
  776.             case 35:
  777.               digitalWrite(35, LOW);
  778.               if (digitalRead(35)) {
  779.                 Serial.println(F("D35 nastaveny na hodnotu LOW"));
  780.               } else {
  781.                 Serial.println(F("Problem, D35 je nastaveny ako vstup - PULLUP!"));
  782.               }
  783.               break;
  784.             case 36:
  785.               digitalWrite(36, LOW);
  786.               if (digitalRead(36)) {
  787.                 Serial.println(F("D36 nastaveny na hodnotu LOW"));
  788.               } else {
  789.                 Serial.println(F("Problem, D36 je nastaveny ako vstup - PULLUP!"));
  790.               }
  791.               break;
  792.             case 37:
  793.               digitalWrite(37, LOW);
  794.               if (digitalRead(37)) {
  795.                 Serial.println(F("D37 nastaveny na hodnotu LOW"));
  796.               } else {
  797.                 Serial.println(F("Problem, D37 je nastaveny ako vstup - PULLUP!"));
  798.               }
  799.               break;
  800.             case 38:
  801.               digitalWrite(38, LOW);
  802.               if (digitalRead(38)) {
  803.                 Serial.println(F("D38 nastaveny na hodnotu LOW"));
  804.               } else {
  805.                 Serial.println(F("Problem, D38 je nastaveny ako vstup - PULLUP!"));
  806.               }
  807.               break;
  808.             case 39:
  809.               digitalWrite(39, LOW);
  810.               if (digitalRead(39)) {
  811.                 Serial.println(F("D39 nastaveny na hodnotu LOW"));
  812.               } else {
  813.                 Serial.println(F("Problem, D39 je nastaveny ako vstup - PULLUP!"));
  814.               }
  815.               break;
  816.             case 40:
  817.               digitalWrite(40, LOW);
  818.               if (digitalRead(40)) {
  819.                 Serial.println(F("D40 nastaveny na hodnotu LOW"));
  820.               } else {
  821.                 Serial.println(F("Problem, D40 je nastaveny ako vstup - PULLUP!"));
  822.               }
  823.               break;
  824.             case 41:
  825.               digitalWrite(41, LOW);
  826.               if (digitalRead(41)) {
  827.                 Serial.println(F("D41 nastaveny na hodnotu LOW"));
  828.               } else {
  829.                 Serial.println(F("Problem, D41 je nastaveny ako vstup - PULLUP!"));
  830.               }
  831.               break;
  832.             case 42:
  833.               digitalWrite(42, LOW);
  834.               if (digitalRead(42)) {
  835.                 Serial.println(F("D42 nastaveny na hodnotu LOW"));
  836.               } else {
  837.                 Serial.println(F("Problem, D42 je nastaveny ako vstup - PULLUP!"));
  838.               }
  839.               break;
  840.             case 43:
  841.               digitalWrite(43, LOW);
  842.               if (digitalRead(43)) {
  843.                 Serial.println(F("D43 nastaveny na hodnotu LOW"));
  844.               } else {
  845.                 Serial.println(F("Problem, D43 je nastaveny ako vstup - PULLUP!"));
  846.               }
  847.               break;
  848.             case 44:
  849.               digitalWrite(44, LOW);
  850.               if (digitalRead(44)) {
  851.                 Serial.println(F("D44 nastaveny na hodnotu LOW"));
  852.               } else {
  853.                 Serial.println(F("Problem, D44 je nastaveny ako vstup - PULLUP!"));
  854.               }
  855.               break;
  856.             case 45:
  857.               digitalWrite(45, LOW);
  858.               if (digitalRead(45)) {
  859.                 Serial.println(F("D45 nastaveny na hodnotu LOW"));
  860.               } else {
  861.                 Serial.println(F("Problem, D45 je nastaveny ako vstup - PULLUP!"));
  862.               }
  863.               break;
  864.             case 46:
  865.               digitalWrite(46, LOW);
  866.               if (digitalRead(46)) {
  867.                 Serial.println(F("D46 nastaveny na hodnotu LOW"));
  868.               } else {
  869.                 Serial.println(F("Problem, D46 je nastaveny ako vstup - PULLUP!"));
  870.               }
  871.               break;
  872.             case 47:
  873.               digitalWrite(47, LOW);
  874.               if (digitalRead(47)) {
  875.                 Serial.println(F("D47 nastaveny na hodnotu LOW"));
  876.               } else {
  877.                 Serial.println(F("Problem, D47 je nastaveny ako vstup - PULLUP!"));
  878.               }
  879.               break;
  880.             case 48:
  881.               digitalWrite(48, LOW);
  882.               if (digitalRead(48)) {
  883.                 Serial.println(F("D48 nastaveny na hodnotu LOW"));
  884.               } else {
  885.                 Serial.println(F("Problem, D48 je nastaveny ako vstup - PULLUP!"));
  886.               }
  887.               break;
  888.             case 49:
  889.               digitalWrite(49, LOW);
  890.               if (digitalRead(49)) {
  891.                 Serial.println(F("D49 nastaveny na hodnotu LOW"));
  892.               } else {
  893.                 Serial.println(F("Problem, D49 je nastaveny ako vstup - PULLUP!"));
  894.               }
  895.               break;
  896.             case 50:
  897.               digitalWrite(50, LOW);
  898.               if (digitalRead(50)) {
  899.                 Serial.println(F("D50 nastaveny na hodnotu LOW"));
  900.               } else {
  901.                 Serial.println(F("Problem, D50 je nastaveny ako vstup - PULLUP!"));
  902.               }
  903.               break;
  904.             case 51:
  905.               digitalWrite(51, LOW);
  906.               if (digitalRead(51)) {
  907.                 Serial.println(F("D51 nastaveny na hodnotu LOW"));
  908.               } else {
  909.                 Serial.println(F("Problem, D51 je nastaveny ako vstup - PULLUP!"));
  910.               }
  911.               break;
  912.             case 52:
  913.               digitalWrite(52, LOW);
  914.               if (digitalRead(52)) {
  915.                 Serial.println(F("D52 nastaveny na hodnotu LOW"));
  916.               } else {
  917.                 Serial.println(F("Problem, D52 je nastaveny ako vstup - PULLUP!"));
  918.               }
  919.               break;
  920.             case 53:
  921.               digitalWrite(53, LOW);
  922.               if (digitalRead(53)) {
  923.                 Serial.println(F("D53 nastaveny na hodnotu LOW"));
  924.               } else {
  925.                 Serial.println(F("Problem, D53 je nastaveny ako vstup - PULLUP!"));
  926.               }
  927.               break;
  928. #endif
  929.             default:  // ignore the rest
  930. #if defined(__AVR_ATmega328P__)
  931.               Serial.println(F("CHYBA, NEPODPOROVANE CISLO D PINU ( ROZSAH D2 - D13)"));
  932. #elif defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
  933.               Serial.println(F("CHYBA, NEPODPOROVANE CISLO D PINU ( ROZSAH D2 - D53)"));
  934. #endif
  935.               break;
  936.           }
  937.         }
  938.  
  939.       } else if (value.indexOf("HIGH") > 0) {
  940.         for (byte i = 0; i < (sizeof(OutPut_ledArray) / sizeof(OutPut_ledArray[0])); i++) {
  941.           digitalWrite(OutPut_ledArray[i], HIGH);
  942.           Serial.print(F("Vystup D"));
  943.           Serial.print(OutPut_ledArray[i]);
  944.           Serial.println(F(" nastaveny na HIGH"));
  945.         }
  946.       } else if (value.indexOf("LOW") > 0) {
  947.         for (byte i = 0; i < (sizeof(OutPut_ledArray) / sizeof(OutPut_ledArray[0])); i++) {
  948.           digitalWrite(OutPut_ledArray[i], LOW);
  949.           Serial.print(F("Vystup D"));
  950.           Serial.print(OutPut_ledArray[i]);
  951.           Serial.println(F(" nastaveny na LOW"));
  952.         }
  953.       } else {
  954.         Serial.println(F("Nekompletny prikaz"));
  955.       }
  956.     }
  957.     else {
  958.       Serial.println(F("Nepodporovany prikaz"));
  959.     }
  960.   }
  961. }
RAW Paste Data