API tools faq
paste
Advertisement
Guest User

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

a guest
Nov 19th, 2020
286
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Arduino 37.70 KB | None | 0 0
raw download clone embed print report
  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. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!