Arduino рдФрд░ рдкреНрд░рд╕рдВрд╕реНрдХрд░рдгред COM рдкреЛрд░реНрдЯ рдХреЗ рдорд╛рдзреНрдпрдо рд╕реЗ рдорд╛рдЗрдХреНрд░реЛрдХрдВрдЯреНрд░реЛрд▓рд░ рдХреЛ рдХреИрд╕реЗ рдирд┐рдпрдВрддреНрд░рд┐рдд рдХрд░реЗрдВред рджреЛ рддрд░рд╣ рд╕реЗ рд╕рдВрдЪрд╛рд░

рд╕рднреА рдХреЛ рдирдорд╕реНрдХрд╛рд░! рдЗрдВрдЯрд░рдиреЗрдЯ рдкрд░ рдПрдХ рдЧрд▓рдд рдзрд╛рд░рдгрд╛ рд╣реИ рдХрд┐ рдШрд░-рдирд┐рд░реНрдорд┐рдд рдЗрд▓реЗрдХреНрдЯреНрд░реЙрдирд┐рдХреНрд╕ рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рдХреЗ рдХрдВрдкреНрдпреВрдЯрд░ рдХреЛ рдирд┐рдпрдВрддреНрд░рд┐рдд рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП рдХреЗрд╡рд▓ рд╡рд┐рд╢реЗрд╖ рдмреЛрд░реНрдбреЛрдВ рдХреА рдЖрд╡рд╢реНрдпрдХрддрд╛ рд╣реЛрддреА рд╣реИ рдЬрд┐рдиреНрд╣реЗрдВ рдпреВрдПрд╕рдмреА рдЫрд┐рдкрд╛рдИ рдЙрдкрдХрд░рдгреЛрдВ рдХреЗ рд░реВрдк рдореЗрдВ рдкрд╣рдЪрд╛рдирд╛ рдЬрд╛ рд╕рдХрддрд╛ рд╣реИред рдФрд░ Arduino рдХреЗ рд╕рдВрдмрдВрдз рдореЗрдВ, рд╣рд░ рдХреЛрдИ рдХреЗрд╡рд▓ Arduino Leanardo рдХреЗ рдмрд╛рд░реЗ рдореЗрдВ рдмрд╛рдд рдХрд░рддрд╛ рд╣реИред рдХреАрдмреЛрд░реНрдб рдФрд░ рдорд╛рдЙрд╕ рдХреЗ рд░реВрдк рдореЗрдВ рдЗрд╕ рддрд░рд╣ рдХреЗ рд▓реЛрдХрдкреНрд░рд┐рдп рдкреБрд╕реНрддрдХрд╛рд▓рдп, рдЬреЛ рдЖрдкрдХреЛ рдорд╛рдЗрдХреНрд░реЛрдХрдВрдЯреНрд░реЛрд▓рд░ рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рдХреЗ рдорд╛рдЙрд╕ рдпрд╛ рдХреАрдмреЛрд░реНрдб рдХрд╛ рдЕрдиреБрдХрд░рдг рдмрдирд╛рдиреЗ рдХреА рдЕрдиреБрдорддрд┐ рджреЗрддреЗ рд╣реИрдВ, рдХреЗрд╡рд▓ рдЕрд░реБрдбрд┐рдиреЛ, рд▓рд┐рдпреЛрдирд╛рд░реНрдбреЛ рдмреЛрд░реНрдбреЛрдВ рдХреА рдПрдХ рдЬреЛрдбрд╝реА рдХреЗ рд▓рд┐рдП рдЕрднрд┐рдкреНрд░реЗрдд рд╣реИрдВред

рдореИрдВ рдХрд┐рд╕реА рднреА Arduino microcontroller (рдЙрджрд╛рд╣рд░рдг рдХреЗ рд▓рд┐рдП, Arduino Uno рдХреЛ рд▓рд┐рдпрд╛ рдЧрдпрд╛) рдФрд░ рдЙрд╕рдХреЗ рдкреНрд░рд╕рдВрд╕реНрдХрд░рдг рдХрд╛рд░реНрдпрдХреНрд░рдо рдХреЛ рдХреИрд╕реЗ рдХрдиреЗрдХреНрдЯ рдХрд░реВрдВ, рдЗрд╕ рдмрд╛рд░реЗ рдореЗрдВ рдмрд╛рдд рдХрд░реВрдВрдЧрд╛ред рдЬрд╛рд╡рд╛ рдХреЗ рдЬреНрдЮрд╛рди рдХреЗ рд╕рд╛рде рдФрд░ рд╕рдм рдХреБрдЫ рдЬреЛрдбрд╝ рджрд┐рдпрд╛ рдЧрдпрд╛ рд╣реИ, рдЬрд┐рд╕ рдкрд░ рдкреНрд░рд╕рдВрд╕реНрдХрд░рдг рдЖрдзрд╛рд░рд┐рдд рд╣реИ, рдкреВрд░реЗ рдХрдВрдкреНрдпреВрдЯрд░ рдХреЗ рдирд┐рдпрдВрддреНрд░рдг рдореЗрдВ рдПрдХ рдкрд░рд┐рдпреЛрдЬрдирд╛ рдХреЛ рдЬреЛрдбрд╝рдирд╛ рд╕рдВрднрд╡ рд╣реЛрдЧрд╛, рди рдХрд┐ рдХреЗрд╡рд▓ рдЕрдкрдиреЗ рд╕реНрд╡рдпрдВ рдХреЗ рдЕрдиреБрдкреНрд░рдпреЛрдЧ рдХреЗ рд▓рд┐рдПред рдЬрд╛рд╡рд╛ рдореЗрдВ рдХрдВрдкреНрдпреВрдЯрд░ рдкреНрд░реЛрдЧреНрд░рд╛рдо рдХреЛ рдирд┐рдпрдВрддреНрд░рд┐рдд рдХрд░рдиреЗ рдХрд╛ рд╡рд┐рд╖рдп рдХреБрдЫ рдЧреБрдкреНрдд рдирд╣реАрдВ рд╣реИ, Google рдФрд░ рдЖрдкрдХреЛ рд╕рдм рдХреБрдЫ рдорд┐рд▓ рдЬрд╛рдПрдЧрд╛, рдореИрдВ рдЖрдкрдХреЛ рдЖрд╢реНрд╡рд╛рд╕рди рджреЗрддрд╛ рд╣реВрдВред

рд╡рд┐рдХрд╛рд╕ рдкрд░реНрдпрд╛рд╡рд░рдг рдбрд╛рдЙрдирд▓реЛрдб рдХрд░реЗрдВ (IDE)


рд╢реБрджреНрдз рд╕реА рдореЗрдВ рдкреНрд░реЛрдЧреНрд░рд╛рдорд┐рдВрдЧ рдорд╛рдЗрдХреНрд░реЛрдХрдВрдЯреНрд░реЛрд▓рд░ рдХреЗ рд▓рд┐рдП рдХрдИ рдПрдХреАрдХреГрдд рд╡рд┐рдХрд╛рд╕ рд╡рд╛рддрд╛рд╡рд░рдг рд╣реИрдВред рдЗрдирдореЗрдВ рд╕реЗ, рд╕рдмрд╕реЗ рд╕реБрд╡рд┐рдзрд╛рдЬрдирдХ рдиреЛрдЯ рдХрд┐рдпрд╛ рдЬрд╛ рд╕рдХрддрд╛ рд╣реИ: рдПрдЯреЛрд▓рд┐рдХ, рдПрдХреНрд▓рд┐рдкреНрд╕, рдХреЗрдЗрд▓ред

рд╣рд╛рд▓рд╛рдВрдХрд┐, рдЗрд╕ рдЧрд╛рдЗрдб рдХреА рд╕рд╛рджрдЧреА рдФрд░ рдкрд╣реБрдВрдЪ рдХреЗ рд▓рд┐рдП, рдореИрдВ Arduino IDE рд╕рдВрдкрд╛рджрдХ рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░реВрдВрдЧрд╛ рдФрд░ Arduino C рдореЗрдВ рд▓рд┐рдЦреВрдВрдЧрд╛ред рдЖрдк рдЗрд╕ рддрд░рд╣ рдХреЗ рд╕рдВрдкрд╛рджрдХ рдХреЛ Arduino рдХреА рдЖрдзрд┐рдХрд╛рд░рд┐рдХ рд╡реЗрдмрд╕рд╛рдЗрдЯ рд╕реЗ рдбрд╛рдЙрдирд▓реЛрдб рдХрд░ рд╕рдХрддреЗ рд╣реИрдВред

рдкреНрд░реЛрдЧреНрд░рд╛рдорд┐рдВрдЧ рдХреЗ рд▓рд┐рдП рд╡рд┐рдХрд╛рд╕ рдХрд╛ рд╡рд╛рддрд╛рд╡рд░рдг рдЖрдзрд┐рдХрд╛рд░рд┐рдХ рд╡реЗрдмрд╕рд╛рдЗрдЯ рд╕реЗ рднреА рдбрд╛рдЙрдирд▓реЛрдб рдХрд┐рдпрд╛ рдЬрд╛ рд╕рдХрддрд╛ рд╣реИред

рдпрд╣ рдзреНрдпрд╛рди рджреЗрдиреЗ рдпреЛрдЧреНрдп рд╣реИ, рд╢рд╛рд▓реАрдирддрд╛ рдХреЗ рд▓рд┐рдП, рдХрд┐ рдЖрдИрдбреАрдИ рдбреЗрдЯрд╛ рдмрд╣реБрдд рд╕рдорд╛рди рд╣реИрдВ, рдХреНрдпреЛрдВрдХрд┐ рд╡реЗ рдПрдХ рд╣реА рдЗрдВрдЬрди рдкрд░ рд▓рд┐рдЦреЗ рдЧрдП рд╣реИрдВред рдФрд░ рдЬрдм Arduino рдмрдирд╛рдпрд╛ рдЧрдпрд╛, рддреЛ рд╕рдВрд╕реНрдерд╛рдкрдХреЛрдВ рдиреЗ рдЕрдкрдиреЗ рдХреЛрдб рд╕рдВрдкрд╛рджрдХ рдХреЛ рдпрдерд╛рд╕рдВрднрд╡ рд╕рд░рд▓ рдмрдирд╛рдиреЗ рдХреА рдХреЛрд╢рд┐рд╢ рдХреА, рдЬреИрд╕рд╛ рдХрд┐ рдкреНрд░рд╕рдВрд╕реНрдХрд░рдг рд╕рдВрдкрд╛рджрдХ рдореЗрдВ рдХрд┐рдпрд╛ рдЧрдпрд╛ рдерд╛ред

Arduinoред рд╣рдо рд╕рд░реНрдХрд┐рдЯ рдХреЛ рдЗрдХрдЯреНрдард╛ рдХрд░рддреЗ рд╣реИрдВ рдФрд░ рдХреЛрдб рд▓рд┐рдЦрддреЗ рд╣реИрдВ


рдЗрд╕ рдЙрджрд╛рд╣рд░рдг рдореЗрдВ, рдореИрдВ Arduino Uno рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░реВрдВрдЧрд╛ред рдПрдХ рдмрдЯрди, рдПрдХ рдкреЛрдЯреЗрдВрд╢рд┐рдпреЛрдореАрдЯрд░ рдФрд░ рдПрдХ рдПрд▓рдИрдбреА рдЗрд╕рд╕реЗ рдЬреБрдбрд╝рд╛ рд╣реЛрдЧрд╛ред рддрджрдиреБрд╕рд╛рд░, рдореИрдВ рдПрдХ рддрд╛рд░реНрдХрд┐рдХ 0 рдпрд╛ 1. рдЖрдЙрдЯрдкреБрдЯ рдХрд░ рд╕рдХрддрд╛ рд╣реВрдВ рдФрд░ рдПрдХ рддрд╛рд░реНрдХрд┐рдХ 0 рдпрд╛ 1. рдкрдврд╝ рд╕рдХрддрд╛ рд╣реВрдВ рдФрд░ рдПрдХ рдПрдирд╛рд▓реЙрдЧ-рдбрд┐рдЬрд┐рдЯрд▓ рд░реВрдкрд╛рдВрддрд░рдг (рдПрдбреАрд╕реА рдпрд╛ рдПрдбреАрд╕реА) рдХрд░ рд╕рдХрддрд╛ рд╣реВрдВ, рдЬреЛ рдХрд┐ рдкреЛрдЯреЗрдВрд╢рд┐рдпреЛрдореАрдЯрд░ рдХреА рд╕реНрдерд┐рддрд┐ рдХреЗ рдЖрдзрд╛рд░ рдкрд░ 0 рд╕реЗ 1023 (Arduino Uno 10-рдмрд┐рдЯ ADC рдореЗрдВ) рдХреА рд╕рдВрдЦреНрдпрд╛ рдкреНрд░рд╛рдкреНрдд рдХрд░ рд░рд╣рд╛ рд╣реИред рдЖрдкрдХреЛ рдПрдХ рдЙрджрд╛рд╣рд░рдг рдХреЗ рд▓рд┐рдП рдФрд░ рдЕрдзрд┐рдХ рдХреА рдЖрд╡рд╢реНрдпрдХрддрд╛ рдирд╣реАрдВ рд╣реИ, рдХреНрдпреЛрдВрдХрд┐ рдпреЗ рдореБрдЦреНрдп рдХрд╛рд░реНрдп рд╣реИрдВ рдЬреЛ рдПрдХ рдорд╛рдЗрдХреНрд░реЛрдХрдВрдЯреНрд░реЛрд▓рд░ рдХрд░ рд╕рдХрддрд╛ рд╣реИред

рддрд╛рд░реЛрдВ рдЖрд░реЗрдЦ:



рдЪрд┐рддреНрд░ рдореЗрдВ, рдПрдиреЛрдб рдПрд▓рдИрдбреА 5V рд╕реЗ рдЬреБрдбрд╝рд╛ рд╣реИ, рдПрдХ рд╕реАрдорд┐рдд рдЕрд╡рд░реЛрдзрдХ (рдХрдо рд╕реЗ рдХрдо 220 рдУрдо, рдЕрдзрд┐рдорд╛рдирддрдГ 500 рдУрдо) рдХреЗ рдорд╛рдзреНрдпрдо рд╕реЗ, рдХреИрдереЛрдб рджреНрд╡рд╛рд░рд╛ рдбреА 11 рдХреЛ рдкрд┐рди рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдПред рдмрдЯрди рдЬрдореАрди рдХреЛ рдмрдВрдж рдХрд░ рджреЗрддрд╛ рд╣реИ рдФрд░ D2 рдХреЛ рдкрд┐рди рдХрд░рддрд╛ рд╣реИред рдкрд┐рди 1 рдкрд░ рдкреЛрдЯреЗрдВрд╢рд┐рдпреЛрдореАрдЯрд░ рдкрд░рд┐рд╡рд░реНрддрди рдХреНрд╖рдорддрд╛ред

рдорд╛рдЗрдХреНрд░реЛрдХрдВрдЯреНрд░реЛрд▓рд░ рдХрд╛ рдХрд╛рд░реНрдп рдирд┐рдореНрдирд╛рдиреБрд╕рд╛рд░ рд╣реИ: рдпрджрд┐ рд╕рдВрджреЗрд╢ "рдПрд▓рдИрдбреА - рдПрдЪ" рд╕реАрд░рд┐рдпрд▓ рдЗрдВрдЯрд░рдлрд╝реЗрд╕ (рд╕реАрд░рд┐рдпрд▓ COM рдкреЛрд░реНрдЯ) рдкрд░ рдЖрддрд╛ рд╣реИ - рдПрд▓рдИрдбреА рдХреЛ рдкреНрд░рдХрд╛рд╢ред рдпрджрд┐ рд╕рдВрджреЗрд╢ "рдПрд▓рдИрдбреА - рдПрд▓" рдЖрддрд╛ рд╣реИ, рддреЛ рдПрд▓рдИрдбреА рдХреЛ рдмреБрдЭрд╛ рджреЗрдВред рдкреНрд░рддреНрдпреЗрдХ 250ms рд╕реАрд░рд┐рдпрд▓ рдкреЛрд░реНрдЯ (рдЗрд╕ рдорд╛рдорд▓реЗ рдореЗрдВ, рдХрдВрдкреНрдпреВрдЯрд░ рд╕реНрдХреНрд░реАрди рдкрд░) рд╕рдВрджреЗрд╢ "рдкреЙрдЯ -" рдФрд░ рдкрд┐рди A1 рдХреЗ рдПрдирд╛рд▓реЙрдЧ рд░реАрдбрд┐рдВрдЧ рджреНрд╡рд╛рд░рд╛ рдкреНрд░рд╛рдкреНрдд рд╕рдВрдЦреНрдпрд╛ рдХреЛ рд╕рдВрджреЗрд╢ рднреЗрдЬрддреЗ рд╣реИрдВред рдЬрдм рдПрдХ рдмрдЯрди рджрдмрд╛рдпрд╛ рдЬрд╛рддрд╛ рд╣реИ, рддреЛ рдПрдХ рд╕рдВрджреЗрд╢ рднреЗрдЬреЗрдВ "рдмрдЯрди рджрдмрд╛рдпрд╛ рдЬрд╛рддрд╛ рд╣реИ!" рдПрдХ рдмрд╛рд░ред

рдЗрд╕ рд╕рдорд╕реНрдпрд╛ рдХреЛ рд╣рд▓ рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП рдореЗрд░рд╛ рд╕реБрдЭрд╛рд╡ рд╣реИ (рдЕрдиреБрд╕рд░рдг рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП рдЙрджрд╛рд╣рд░рдг рдирд╣реАрдВ):

Arduino Uno рдХреЗ рд▓рд┐рдП рдлрд░реНрдорд╡реЗрдпрд░
 #define pinPot A1 #define pinLed 11 #define pinBtn 2 void setup() { pinMode(pinPot, INPUT); pinMode(pinLed, OUTPUT); pinMode(pinBtn, INPUT_PULLUP); Serial.begin(9600); Serial.println("The program starts.\n\n"); } void loop() { /* INITIAL VARIABLES. Segment 1 */ static char potMes[] = "Pot - "; static char btnMes[] = "Button is pressed!"; static char passLight[] = "Led - "; static int passLength = sizeof(passLight) - 1; static int sizepm = sizeof(potMes) - 1; static int sizebtn = sizeof(btnMes) - 1; static bool flagLedState = LOW; static bool flagBtnPress = false; static long int curTime = 0; static const int period = 200; static bool flagEnableRead = false; /* INITIAL VARIABLES. Segment 1 */ /* FUNCTIONS CALL. Segment 2 */ /* * Led is attached to HIGH voltage from one side * And to pin on the other side * By that the inverting logic */ ReadSerialForLed(passLight, passLength, &flagLedState); digitalWrite(pinLed, !flagLedState); /* * Button pin always is pulled to the HIGH voltage * And only when button is pressed - Voltage on pin goes to GROUND * So it is need to invert logic when read pins */ if(!Bounce(pinBtn) && flagBtnPress == false){ for(int i = 0; i < sizebtn; i++){ Serial.write(btnMes[i]); } Serial.print("\n"); flagBtnPress = true; if(!flagEnableRead){ curTime = millis(); flagEnableRead = true; } }else if(Bounce(pinBtn)){ flagBtnPress = false; } /* * Read and send Info "Pot - " + var Only after first press on button * Every 'period'ms */ if(millis() - curTime > period && flagEnableRead){ SendData(pinPot, potMes, sizepm); curTime = millis(); } /* FUNCTIONS CALL. Segment 2 */ } /* * Pot - pin with potentiometer * pMes - Array with message before Pot value * sp - size of potentiometer message */ void SendData(int Pot, char* pMes, int sp){ static int varP[2]; varP[0] = analogRead(Pot); varP[1] = varP[0]/256; // 0 - 3 (256 - 1024) varP[0] = varP[0]%256; // 0 - 255 //Send Message for(int i = 0; i < sp; i++){ Serial.write(char(pMes[i])); } //Send 2 bits of data //Serial.write(varP[0]); //Serial.write(varP[1]); Serial.print(analogRead(Pot)); Serial.print("\n"); } /* * Function, which is reads button pin with the bounce */ bool Bounce(int btn){ if(digitalRead(btn) == true){ delay(15); if(digitalRead(btn) == true){ return true; }else{ return false; } }else{ return false; } } /* * If Message from Serial port, which you read will be the same to passLight * So look at the next symbol after Pass Message. If it is symbol 'H' - make LED to light * If it is 'L' - make LED off. */ void ReadSerialForLed(char *passLight_f, int passLength_f, bool* flagLedState_f){ static char sym; static int cntPass = 0; static bool readyGetLed = LOW; while (Serial.available() > 0) { sym = Serial.read(); if(sym == passLight_f[cntPass] && !readyGetLed){ cntPass++; }else if (!readyGetLed){ cntPass = 0; }else if(readyGetLed){ if(sym == 'H'){ *flagLedState_f = HIGH; }else if(sym == 'L'){ *flagLedState_f = LOW; } } if(cntPass == passLength_f){ readyGetLed = HIGH; } } } 

рдЯрд┐рдкреНрдкрдгреА: рдПрд▓рдИрдбреА рдПрдиреЛрдб рджреНрд╡рд╛рд░рд╛ рдмрд┐рдЬрд▓реА рдХреА рдЖрдкреВрд░реНрддрд┐ рд╕реЗ рдЬреБрдбрд╝рд╛ рд╣реИред рдпрд╣ рдПрд▓рдИрдбреА рдХреА рд╕реНрдерд┐рддрд┐ рдХреЗ рддрд░реНрдХ рдХрд╛ рд╡рд┐рд░реЛрдз рдХрд░рддрд╛ рд╣реИ рдФрд░ рдЕрдм рд▓рд╛рдн рдирд╣реАрдВ рдХрд░рддрд╛ рд╣реИред рдмрдЯрди рдХреЛ рдЕрд░реНрдерд╡реНрдпрд╡рд╕реНрдерд╛ рдХреЗ рдХрд╛рд░рдгреЛрдВ рдХреЗ рд▓рд┐рдП рдкреБрд▓-рдЕрдк рд░реЛрдХрдиреЗрд╡рд╛рд▓рд╛ рдХреЗ рд╕рд╛рде рдмрд╛рдВрдзрд╛ рдирд╣реАрдВ рдЧрдпрд╛ рд╣реИ, рдХреНрдпреЛрдВрдХрд┐ Arduino Uno рдиреЗ рдЕрдВрддрд░реНрдирд┐рд░реНрдорд┐рдд рдкреБрд▓-рдЕрдк рдкреНрд░рддрд┐рд░реЛрдзреЛрдВ рдХреЛ рдмрдирд╛рдпрд╛ рд╣реИ рдЬреЛ рдХрд┐ рд╕рд░реНрдХрд┐рдЯ рдореЗрдВ рд╢рд╛рдорд┐рд▓ рд╣реЛрддреЗ рд╣реИрдВ рдЬрдм рдкрд┐рди INPUT_PULLUP рдореЛрдб рдореЗрдВ рдкреНрд░рд╛рд░рдВрдн рд╣реЛрддрд╛ рд╣реИред
рдлрд░реНрдорд╡реЗрдпрд░ рдореЗрдВ рднреА, рдкреЛрдЯреЗрдВрд╢рд┐рдпреЛрдореАрдЯрд░ рд╕реЗ рд▓рд┐рдП рдЧрдП рдореВрд▓реНрдп рдХреЗ рдмрд╛рд░реЗ рдореЗрдВ рд╕рдВрджреЗрд╢ рдХреЗрд╡рд▓ рдПрдХ рдмрдЯрди рдХреЗ рдкрд╣рд▓реЗ рдкреНрд░реЗрд╕ рдХреЗ рдмрд╛рдж рднреЗрдЬреЗ рдЬрд╛рддреЗ рд╣реИрдВ!

рдмреЛрд░реНрдб рдореЗрдВ рдлрд░реНрдорд╡реЗрдпрд░ рднрд░рдиреЗ рдХреЗ рд▓рд┐рдП, рдкреЛрд░реНрдЯ рдФрд░ рдмреЛрд░реНрдб рдХрд╛ рдЪрдпрди рдХрд░рдирд╛ рди рднреВрд▓реЗрдВред



рдпрджрд┐ рдЖрдкрдХреЛ рдкрддрд╛ рдирд╣реАрдВ рд╣реИ рдХрд┐ рдЖрдкрдХреЗ рдкрд╛рд╕ Arduino рдмреЛрд░реНрдб рдХреЗ рд▓рд┐рдП рдХреМрди рд╕рд╛ COM рдкреЛрд░реНрдЯ рд╣реИ, рддреЛ Windows рдкрд░, рдкрд░ рдЬрд╛рдПрдВ
рдХрдВрдЯреНрд░реЛрд▓ рдкреИрдирд▓ -> рдбрд┐рд╡рд╛рдЗрд╕ рдореИрдиреЗрдЬрд░ рдФрд░ "COM рдкреЛрд░реНрдЯреНрд╕" рдЯреИрдм рдкрд░ рдХреНрд▓рд┐рдХ рдХрд░реЗрдВ



рдпрджрд┐ рдЖрдкрдХреЗ COM рдкреЛрд░реНрдЯ рдкрд░ рдореЗрд░рд╛ рд╣рд╕реНрддрд╛рдХреНрд╖рд░ рдирд╣реАрдВ рд╣реИ, рддреЛ рдЖрдк рд╣рдореЗрд╢рд╛ Arduino рдХреЛ рдбрд┐рд╕реНрдХрдиреЗрдХреНрдЯ рдХрд░ рд╕рдХрддреЗ рд╣реИрдВ рдФрд░ рджреЗрдЦ рд╕рдХрддреЗ рд╣реИрдВ рдХрд┐ рдХреМрди рд╕рд╛ рдкреЛрд░реНрдЯ рдЪрд▓рд╛ рдЧрдпрд╛ рд╣реИред рд▓реЗрдХрд┐рди рдЕрдЧрд░ рдХреЛрдИ рднреА рдЧрд╛рдпрдм рдирд╣реАрдВ рд╣реБрдЖ рд╣реИ рдФрд░ Arduin рдХреЛ рдХрдВрдкреНрдпреВрдЯрд░ рджреНрд╡рд╛рд░рд╛ рдмрд┐рд▓реНрдХреБрд▓ рднреА рдорд╛рдиреНрдпрддрд╛ рдирд╣реАрдВ рджреА рдЧрдИ рд╣реИ, рддреЛ рдпрд╣ рдЗрдВрдЯрд░рдиреЗрдЯ рдкрд░ рд╕рдорд╛рдзрд╛рди рджреЗрдЦрдиреЗ рдХрд╛ рд╕рдордп рд╣реИред рд▓реЗрдХрд┐рди рдбреНрд░рд╛рдЗрд╡рд░реЛрдВ рдХреЛ рдЕрдкрдбреЗрдЯ рдХрд░рдиреЗ рдпрд╛ рдмреЛрд░реНрдб рдХреЛ рдмрджрд▓рдиреЗ рд╕реЗ рд╢реБрд░реВ рдХрд░реЗрдВред

рдЬрдм рд╕рдм рдХреБрдЫ рдХрд╛рдо рдХрд░рддрд╛ рд╣реИ, рддреЛ рдкреЛрд░реНрдЯ рдореЙрдирд┐рдЯрд░ рдЦреЛрд▓рдиреЗ рдФрд░ "LED-H", "LED-L" рджрд░реНрдЬ рдХрд░рдиреЗ рдХрд╛ рдкреНрд░рдпрд╛рд╕ рдХрд░реЗрдВ, рдмрдЯрди рджрдмрд╛рдПрдВ, рдкреЛрдЯреЗрдВрд╢рд┐рдпреЛрдореАрдЯрд░ рдХреЛ рдЪрд╛рд▓реВ рдХрд░реЗрдВ рдФрд░ рд╕реНрдХреНрд░реАрди рдкрд░ рджреЗрдЦреЗрдВ рдХрд┐ рдХреНрдпрд╛ рд╕рдм рдХреБрдЫ рд╕рд╣реА рддрд░реАрдХреЗ рд╕реЗ рдкреНрд░рджрд░реНрд╢рд┐рдд рд╣реЛрддрд╛ рд╣реИред

рдкрд░реНрдпрд╛рдкреНрдд рдЦреЗрд▓реЗ - рдХреЛрдб рдХреЛ рдереЛрдбрд╝рд╛ рдмрджрд▓реЗрдВред

рдЕрдВрддрд┐рдо рдкрдВрдХреНрддрд┐ рдХреЛ рдЯрд┐рдкреНрдкрдгреА рд╕реЗ рдХреЛрдб рдХреЗ рд╕рд╛рде рдмрджрд▓реЗрдВред

  //Send 2 bits of data //Serial.write(varP[0]); //Serial.write(varP[1]); Serial.print(analogRead(Pot)); 

рдЕрдм рдкреЛрдЯреЗрдВрд╢рд┐рдпреЛрдореАрдЯрд░ рд╕реЗ рдорд╛рди рдкрдардиреАрдп рдирд╣реАрдВ рджрд┐рдЦреЗрдВрдЧреЗ, рд▓реЗрдХрд┐рди рдкреНрд░рд╕рдВрд╕реНрдХрд░рдг рдХрд╛рд░реНрдпрдХреНрд░рдо рдХреЗ рд▓рд┐рдП рдЗрд╕ рддрд░рд╣ рдХреЗ рдкреИрдВрддрд░реЗрдмрд╛рдЬрд╝реА рдХреА рдЖрд╡рд╢реНрдпрдХрддрд╛ рд╣реЛрддреА рд╣реИред

рдкреНрд░реЛрд╕реЗрд╕ рд╣реЛ рд░рд╣рд╛ рд╣реИред рд╣рдо рдПрдХ рдкреНрд░реЛрдЧреНрд░рд╛рдо рд▓рд┐рдЦ рд░рд╣реЗ рд╣реИрдВ рдЬреЛ рдПрдХ рдорд╛рдЗрдХреНрд░реЛрдХрдВрдЯреНрд░реЛрд▓рд░ рдХреЗ рд╕рд╛рде рдЗрдВрдЯрд░реИрдХреНрдЯ рдХрд░рддрд╛ рд╣реИ


рдкреНрд░рд╕рдВрд╕реНрдХрд░рдг рдХрд╛рд░реНрдпрдХреНрд░рдо рдФрд░ рдорд╛рдЗрдХреНрд░реЛрдХрдВрдЯреНрд░реЛрд▓рд░ рдХреЗ рдмреАрдЪ рд╕рдВрдЪрд╛рд░ рдХрд╛ рд╕рд╛рд░ рдмрд╣реБрдд рд╕рд░рд▓ рд╣реИред рдЗрд╕ рдкреНрд░реЛрдЧреНрд░рд╛рдорд┐рдВрдЧ рднрд╛рд╖рд╛ рдХреЗ рд▓рд┐рдП рдПрдХ рд╕реАрд░рд┐рдпрд▓ рд▓рд╛рдЗрдмреНрд░реЗрд░реА рд╣реИ, рдЬреЛ рдЖрдкрдХреЛ Serial.write(); рд░реВрдк рдореЗрдВ рднреЗрдЬреЗ рдЧрдП рд╕рдВрджреЗрд╢реЛрдВ рдХреЛ рдкреНрд░рд╛рдкреНрдд рдХрд░рдиреЗ рдХреА рдЕрдиреБрдорддрд┐ рджреЗрддреА рд╣реИ Serial.write(); , рдФрд░ рдЖрдкрдХреЛ Serial.print(); рд░реВрдк рдореЗрдВ рд╕рдВрджреЗрд╢ рднреЗрдЬрдиреЗ рдХреА рдЕрдиреБрдорддрд┐ рджреЗрддрд╛ рд╣реИ Serial.print(); ред рдпрд╣ рдзреНрдпрд╛рди рд░рдЦрдирд╛ рдорд╣рддреНрд╡рдкреВрд░реНрдг рд╣реИ рдХрд┐ рднреЗрдЬреЗ рдЧрдП рдЗрд╕ рддрд░рд╣ рдХреЗ рд╕рдВрджреЗрд╢ рдХреЗ рд╕рд╛рде, рдпрд╣ рдкреЛрд░реНрдЯ рдмрдлрд░ рдХреЛ рд▓рд┐рдЦрд╛ рдЬрд╛рдПрдЧрд╛, рдЬрд┐рд╕рдХрд╛ рдЕрд░реНрде рд╣реИ рдХрд┐ рдпрд╣ рдорд╛рдЗрдХреНрд░реЛрдХрдВрдЯреНрд░реЛрд▓рд░ рджреНрд╡рд╛рд░рд╛ рдкрдврд╝рд╛ рдЬрд╛рдПрдЧрд╛ред рддреЛ рд╣рдореЗрдВ рдмрд╕ рд╡рд╛рдВрдЫрд┐рдд рд╕реАрд░рд┐рдпрд▓ рдкреЛрд░реНрдЯ рд╕реЗ рдХрдиреЗрдХреНрдЯ рдХрд░рдирд╛ рд╣реЛрдЧрд╛ рдФрд░ рдЗрд╕реЗ рд╕рдВрджреЗрд╢ рднреЗрдЬрдирд╛ / рдкреНрд░рд╛рдкреНрдд рдХрд░рдирд╛ рд╣реЛрдЧрд╛ред

рдирд┐рдореНрдирд▓рд┐рдЦрд┐рдд рдХрд╛рд░реНрдпрдХреНрд░рдо рд╕реАрд░рд┐рдпрд▓ рд▓рд╛рдЗрдмреНрд░реЗрд░реА рдХреЛ рдХрдиреЗрдХреНрдЯ рдХрд░реЗрдЧрд╛ рдФрд░ рд╕рдВрдкрд╛рджрдХ рдореЗрдВ рд▓рд┐рдЦреЗрдЧрд╛ рд╕рднреА COM рдкреЛрд░реНрдЯ рдХреА рдПрдХ рд╕реВрдЪреА рдЬрд┐рд╕реЗ рдЖрдк рдХрдиреЗрдХреНрдЯ рдХрд░ рд╕рдХрддреЗ рд╣реИрдВред

 import processing.serial.*; void setup() { String[] port = Serial.list(); for(int i = 0; i < port.length; i++){ print("Port number #" + i + " "); println(Serial.list()[0]); } } void draw() {} 

рдЬрдм рдЖрдк рд╕рдВрдкрд╛рджрдХ рдХреЛ рдХреЛрдб рд▓рд┐рдЦрддреЗ рд╣реИрдВ рдФрд░ "рд╕реНрдЯрд╛рд░реНрдЯ" рдмрдЯрди (рдЪрд┐рддреНрд░ рдореЗрдВ рддреАрд░ 1) рдкрд░ рдХреНрд▓рд┐рдХ рдХрд░рддреЗ рд╣реИрдВ, рддреЛ рдПрдкреНрд▓рд┐рдХреЗрд╢рди рд╡рд┐рдВрдбреЛ рджрд┐рдЦрд╛рдИ рджреЗрдЧреА (2) рдФрд░ COM рдкреЛрд░реНрдЯ рдХреА рд╕реВрдЪреА рдХрдВрд╕реЛрд▓ (3) рдореЗрдВ рдкреНрд░рджрд░реНрд╢рд┐рдд рд╣реЛрдЧреАред



рдореЗрд░реЗ рдкрд╛рд╕ рдХреЗрд╡рд▓ рдПрдХ рдРрд╕рд╛ COM рдкреЛрд░реНрдЯ рдФрд░ рд╢реАрдЯ рдореЗрдВ рд╣реИ, рдЬреИрд╕рд╛ рдХрд┐ рдПрд░реЗ рдореЗрдВ рд╣реИ, рдпрд╣ рдирдВрдмрд░ 0. рдкрд░ рд╣реЛрдЧрд╛ред рдЗрди рдХрд╛рд░рдгреЛрдВ рд╕реЗ, рд╕реАрд░рд┐рдпрд▓ рдХреНрд▓рд╛рд╕ рдХрд╛ рдСрдмреНрдЬреЗрдХреНрдЯ: Serial port; рдЬрдм рдЗрд╕реЗ рдмрдирд╛рдпрд╛ рдЬрд╛рддрд╛ рд╣реИ, рддреЛ рдЗрд╕реЗ рдкреЛрд░реНрдЯ рд▓рд┐рд╕реНрдЯ рдХреЗ рдкрд╣рд▓реЗ рддрддреНрд╡ port = new Serial(this, Serial.list()[0], 9600); рдирд┐рд░реНрджрд┐рд╖реНрдЯ рдХрд┐рдпрд╛ рдЬрд╛рдПрдЧрд╛ port = new Serial(this, Serial.list()[0], 9600);

рдПрдХ рдкрд░рд┐рд╡рд░реНрддрди рдХреЗ рд╕рд╛рде рд╣рдорд╛рд░реЗ рдирд╡реАрдирддрдо рдлрд░реНрдорд╡реЗрдпрд░ Arduin рдореЗрдВ рдбрд╛рд▓реЛред рдлрд┐рд░ рдЗрд╕ рдХрд╛рд░реНрдпрдХреНрд░рдо рдХреЛ рд▓рд┐рдЦреЗрдВ рдФрд░ рдЗрд╕реЗ рдЪрд▓рд╛рдПрдВред рдЗрд╕рдореЗрдВ рд╣рд░ 500 рдорд┐рд▓реАрд╕реЗрдХрдВрдб рдкрд░ рдПрдХ рд╕рдВрджреЗрд╢ рдХреЛ COM рдкреЛрд░реНрдЯ рдореЗрдВ рдбрд╛рд▓рдиреЗ рдпрд╛ рдПрд▓рдИрдбреА рдХреЛ рд╣рд▓реНрдХрд╛ рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП рднреЗрдЬрд╛ рдЬрд╛рддрд╛ рд╣реИред рдФрд░ рдЕрдЧрд░ рд╕рдм рдХреБрдЫ рд╕рд╣реА рдврдВрдЧ рд╕реЗ рдХрд┐рдпрд╛ рдЬрд╛рддрд╛ рд╣реИ, рддреЛ рдЖрд╡реЗрджрди рд╢реБрд░реВ рдХрд░рдиреЗ рдХреЗ рдмрд╛рдж рдПрд▓рдИрдбреА рдХреЛ рдЭрдкрдХреА рд▓реЗрдирд╛ рдЪрд╛рд╣рд┐рдПред

 import processing.serial.*; Serial port; // Create object from Serial class void setup(){ port = new Serial(this, Serial.list()[0], 9600); } void draw(){ delay(500); port.write("Led - H"); delay(500); port.write("Led - L"); } 

рдпрд╛ рдпрд╣рд╛рдБ рдПрдХ рдФрд░ рдЙрджрд╛рд╣рд░рдг рд╣реИред рдорд╛рдЙрд╕ рдмрдЯрди рдХреЗ рд╕рд╛рде рдПрдкреНрд▓рд┐рдХреЗрд╢рди рд╡рд┐рдВрдбреЛ (рдЬрд┐рд╕рдХрд╛ рдЖрдпрд╛рдо 800x800px рд╣реИ) рдкрд░ рдХрд┐рд╕реА рднреА рдХреНрд▓рд┐рдХ рдХреЗ рдмрд╛рдж рдПрд▓рдИрдбреА рдЕрдкрдиреА рд╕реНрдерд┐рддрд┐ рдХреЛ рдмрджрд▓ рджреЗрдЧрд╛ред

 import processing.serial.*; Serial port; // Create object from Serial class int cnt = 0; void setup(){ size(800, 800); port = new Serial(this, Serial.list()[0], 9600); } void draw(){} void mousePressed() { cnt++; if(cnt % 2 == 1){ port.write("Led - H"); }else{ port.write("Led - L"); } } 

рдкреНрд░реЛрд╕реЗрд╕ рд╣реЛ рд░рд╣рд╛ рд╣реИред рдЕрдореАрд░ рдЖрд╡реЗрджрди рдЙрджрд╛рд╣рд░рдг рдХреА рд╕реБрд╡рд┐рдзрд╛


рдпрд╣ рдкреНрд░рд╛рдердорд┐рдХ рдЕрдиреБрдкреНрд░рдпреЛрдЧ "рдЕрдВрддрд░рд┐рдХреНрд╖ рдореЗрдВ рдЙрдбрд╝рд╛рди" рдХрд╛ рдЕрдиреБрдХрд░рдг рдХрд░рддрд╛ рд╣реИ, рдпрджрд┐ рдЖрдк рдЗрд╕реЗ рдХрд╣ рд╕рдХрддреЗ рд╣реИрдВред рдкреЛрдЯреЗрдВрд╢рд┐рдпреЛрдореАрдЯрд░ рд╕реЗ рдореВрд▓реНрдп рдЙрдбрд╝рд╛рди рдХреА рдЧрддрд┐ рдХреЛ рдмрджрд▓рддрд╛ рд╣реИ, рдмрдЯрди рджрдмрд╛рдиреЗ рд╕реЗ рдЙрдбрд╝рд╛рди рдХреА рджрд┐рд╢рд╛ рдмрджрд▓ рдЬрд╛рддреА рд╣реИред рдФрд░ рдПрдкреНрд▓рд┐рдХреЗрд╢рди рд╡рд┐рдВрдбреЛ рдкрд░ рдорд╛рдЙрд╕ рдмрдЯрди рдХреЗ рдХрд┐рд╕реА рднреА рдХреНрд▓рд┐рдХ рд╕реЗ рдПрд▓рдИрдбреА рдХреА рд╕реНрдерд┐рддрд┐ рдмрджрд▓ рдЬрд╛рддреА рд╣реИ (рд╣рд╛рдВ, рдореБрдЭреЗ рдХреБрдЫ рдЕрдзрд┐рдХ рдореВрд▓ рдирд╣реАрдВ рдЖрдпрд╛ рд╣реИ)ред

рдореЗрд░рд╛ рдХреЛрдб рдПрдХрджрдо рд╕рд╣реА рд╣реИ, рдЗрд╕реЗ рдПрдХ рдЕрдЪреНрдЫреЗ рдЙрджрд╛рд╣рд░рдг рдХреЗ рд░реВрдк рдореЗрдВ рди рд▓реЗрдВред рдпрд╣ рд╕рд┐рд░реНрдл рдПрдХ рдЙрджрд╛рд╣рд░рдг рд╣реИ рдЬреЛ рдХрд╛рдо рдХрд░рддрд╛ рд╣реИред рдпрд╣рд╛рдБ рд╡рд╣ рд╣реИред

рдЙрджрд╛рд╣рд░рдг рдмрд╣реБрдХреНрд░рд┐рдпрд╛рд╢реАрд▓ рдХрд╛рд░реНрдпрдХреНрд░рдо
 import processing.serial.*; Serial port; // Create object from Serial class int val; // Data received from the serial port (symbol) int pot; // Data from potentiometer String potMes = "Pot - "; String btnMes = "Button is pressed!"; int cntPM = 0; // Counter Potentiometer Message. // When it equals to length of Pot Mess - get value. int cntBM = 0; int cntBtnPress = 0; int cntMousePress = 0; Star[] stars = new Star[1000]; float speed; int dir = 1; void setup(){ size(800, 800); for(int i = 0; i < stars.length; i++){ stars[i] = new Star(); } frameRate(60); // 60 Frames per second port = new Serial(this, Serial.list()[0], 9600); // Wait for first message from Arduino delay(2000); while (port.available() > 0) { val = port.read(); print(char(val)); } } void draw(){ if (port.available() > 0) { val = port.read(); cntPM = CheckSymbol(potMes, cntPM, char(val), cntPM); cntBM = CheckSymbol(btnMes, cntBM, char(val), cntBM); } DrawRain(pot, 0, 1023); } void DrawRain(int speed_f, int min, int max){ background(0); translate(width/2,height/2); speed = dir*map(speed_f, min, max, 0, 50); for(int i = 0; i < stars.length; i++){ stars[i].go(); stars[i].update(); stars[i].show(); } } int CheckSymbol(String mes, int index, char sym, int ret_val){ if(mes.charAt(index) == sym && ret_val < (mes.length() - 1)){ return (ret_val + 1); }else if( ret_val == (mes.length() - 1) && mes.equals(potMes) ){ if(port.available() > 0){ pot = port.read(); // First 0-255 value } if(port.available() > 0){ pot += 256*port.read(); // Last 2 bits 256 - 1024 } }else if( ret_val == (mes.length() - 1) && mes.equals(btnMes) ){ cntBtnPress++; dir = -dir; } return 0; } void mousePressed() { cntMousePress++; if(cntMousePress % 2 == 1){ port.write("Led - H"); }else{ port.write("Led - L"); } } 

рдирд┐рд╖реНрдХрд░реНрд╖


рдореБрдЭреЗ рд▓рдЧрддрд╛ рд╣реИ рдХрд┐ рдпрд╣ рд▓рд┐рдЦрдирд╛ рдЖрд╡рд╢реНрдпрдХ рд╣реИ рдХрд┐ рдореИрдВрдиреЗ рдЖрдЦрд┐рд░реА рдкреНрд░реЛрдЧреНрд░рд╛рдо рдХрд╛ рд╡рд┐рдЪрд╛рд░ рдПрдХ рдкреНрд░реЛрдЧреНрд░рд╛рдорд░ - рдбреИрдирд┐рдпрд▓ рд╢рд┐рдлрдореИрди рд╕реЗ рд▓рд┐рдпрд╛ рдерд╛ , рдЬреЛ рдРрд╕реЗ рд╡реАрдбрд┐рдпреЛ рд╢реВрдЯ рдХрд░рддрд╛ рд╣реИ рдЬреЛ рдкреНрд░рд╕рдВрд╕реНрдХрд░рдг рдкрд░ рдкреНрд░реЛрдЧреНрд░рд╛рдорд┐рдВрдЧ рдХреЗ рдмрд╛рд░реЗ рдореЗрдВ рдмрдЪреНрдЪреЛрдВ рдХреЗ рд▓рд┐рдП рднреА рд╕рдордЭ рдореЗрдВ рдЖрддрд╛ рд╣реИ ( 140 рд╕реЗ рдЕрдзрд┐рдХ рджреГрд╢реНрдп рдХрд╛рд░реНрдп рд╣рд▓ рдХрд┐рдП рдЧрдП рд╣реИрдВ )ред

рдЬрдм рдореИрдВрдиреЗ рдпрд╣ рдкрддрд╛ рд▓рдЧрд╛рдиреЗ рдХреА рдХреЛрд╢рд┐рд╢ рдХреА рдХрд┐ рдкреНрд░рд╕рдВрд╕реНрдХрд░рдг рдФрд░ Arduino рд╕рдВрдЪрд╛рд░ рдХреЛ рдХреНрдпрд╛ рдФрд░ рдХреИрд╕реЗ рдХрд░рдирд╛ рд╣реИ, рддреЛ рдЗрди рд╕рд╛рдЗрдЯреЛрдВ рдиреЗ рд╡рд╛рд╕реНрддрд╡ рдореЗрдВ рдореЗрд░реА рдорджрдж рдХреА:

  1. developer.alexanderklimov.ru/arduino/processing.php
  2. arduino-diy.com/arduino-processing-osnovi

Source: https://habr.com/ru/post/hi450518/


All Articles