4. Creiere robot
ROBOT BRAINS
Introducere:
Pentru a lua decizii, un robot utilizează un computer sau un microcontroler. Pentru necunoscători, un microcontroller este o componentă electronică care poate face trei lucruri. Poate interpreta intrări din lumea fizică, procesează aceste informații și controlează dispozitivele de ieșire în lumea fizică. Într-un sens de bază, un microcontroler poate citi senzori, să ia decizii, și controlează lumini, difuzoare și motoare.
Fiind capabil să simtă și să răspundă lumii, puteți crea o buclă de feedback între ieșire și intrare. Cu alte cuvinte, puteți crea roboți și dispozitive care sunt cu adevărat interactive. Un alt mod de a gândi este că roboții pot să acorde atenție la ceea ce se întâmplă în jurul lor, să ia decizii folosind Arduino și apoi să răspundă în mod semnificativ la aceasta. În acest fel, se comportă un pic ca cele mai multe alte creaturi simțitoare.
Arduino
Arduino este un tip foarte general de microcontroller. Ceea ce pune Arduino aparte de alte microcontrolere este faptul că este ușor de utilizat, bine documentat și are o comunitate vastă online de oameni care îl folosesc. Acest lucru înseamnă că, indiferent ce poate merge prost, puteți găsi probabil o soluție documentată online sau cineva care dorește să vă ajute. Acest lucru este extrem de benefic atunci când începeți.
Există o serie de tipuri diferite de Arduino, dar pentru această clasă vom folosi un Arduino Uno. Aceasta este în prezent cea mai omniprezentă versiune a microcontroller-elor Arduino. Până când această lecție va fi terminată, veți avea o înțelegere succintă a modului de utilizare a plăcii, dar în nici un caz nu veți fi un expert.
Deși Arduino are o mulțime de caracteristici, sunt câteva la care trebuie să acordați atenție. Există un port USB care este folosit pentru programare. Există o priză electrică care este utilizată pentru alimentarea dispozitivului Arduino când nu este conectat la computer. Există, de asemenea, două rânduri de prize mamă de-a lungul marginii plăcii. Fiecare dintre aceste găuri mici se conectează la ceva diferit pe placă și îndeplinește o funcție diferită. Ele ar trebui să fie etichetatei destul de bine pentru a indica ceea ce sunt.
Dacă și când vei fi confuz, poți găsi o privire de ansamblu mult mai detaliată, verificând clasa Arduino.
Cuplare (mp4) - se aprinde LED-ul galben
Pentru a alimenta placa, conectați-o la computer cu ajutorul unui cablu USB-A la USB-B. Acesta este, în principiu, un cablu USB standard care e ceva asemănător unei imprimante de calculatoare.
3. Programarea Arduino
Pentru a programa Arduino vom folosi Arduino IDE (Integrated Development Environment). Versiunea cea mai recentă a software-ului poate fi descărcată gratuit de pe site-ul Arduino sau poate fi utilizată direct pe internet (în curând).
4. O notă despre programare
Cel mai important lucru pe care trebuie să-l cunoașteți despre programare este să îl falsificați până când îl faceți. Practic, de fapt, nu trebuie să știți cum să programați pentru a lucra cu cod. Există deja o tonă de cod exemplu. Trebuie doar să înțelegeți structura sa de bază. Odată ce ați făcut acest lucru, este doar o chestiune de găsire și modificare a codului care există deja. Dacă stați cu această abordare, păstrați o minte deschisă și un spirit neînfricat, în cele din urmă veți învăța să programați.
5. Sintaxă
Fiecare limbaj de programare are o sintaxă pentru modul în care codul trebuie formatat. Aceasta este în esență echivalentul cunoașterii gramaticale corecte. De exemplu, cele mai multe expresii în programare se termină cu un punct și virgulă - cum ar fi ; Acesta este un pic ca scrierea unui punct la sfârșitul propoziției. Dacă scrieți un eseu fără puncte, veți deruta ca naiba cititorul. De asemenea, dacă scrieți un program Arduino fără sintaxă, veți deruta ca naiba compilatorul. Compilatorul interpretează codul și este un fel de cititor al unui eseu în analogia noastră.
Dacă primiți vreodată erori ciudate și nu puteți spune de ce, sunt șanse să aveți ruptă una din regulile de sintaxă (de ex. formatare).
Expresiile codului
Când citiți și scrieți cod, veți întâlni câteva blocuri de bază, la fel cum ați proceda în orice alt limbaj. De exemplu, engleza are substantive, adjective și verbe. Aceste componente sunt apoi structurate în propoziții. Programarea la rândul său are constante, variabile și operatori. Acestea sunt apoi structurate în funcții.
Iată câteva definiții de bază ale componentelor comune de programare:
Constantele sunt termeni care sunt definiți odată și nu se schimbă.
Variabilele sunt termeni care sunt substituenți pentru alte valori și se pot schimba.
Operatorii sunt termeni care efectuează o acțiune, care este de obicei o formă de matematică sau comparație logică între valori.
Funcțiile sunt o colecție structurată de constante, operatori și variabile. De fiecare dată când este apelată o funcție, ea citește și execută aceeași rutină de acțiune specifică.
7. Structura programului
Odată ce ați învățat componentele gramaticii engleze și ați început să scrieți propoziții, următorul pas logic este de a scrie o compoziție precum un eseu. Așa cum un eseu are o structură cu un paragraf de deschidere, un text conținut și un paragraf de închidere, tot așa are și un program Arduino. Dar, structura programului Arduino este puțin diferită.
Un program tipic este prezentat după cum urmează:
//####################
//### THE HEADER ###
//####################
// The header explains to you as a human what the program is doing
// It is not processed by the compiler
// Also note that anything preceeded by two slashes like so '//'
// is considered a comment and not processed by the compiler.
// Comments explain to you what is happening in the code.
//#####################
//### DEFINITIONS ###
//#####################
// Definitions are things that we want to establish globally throughout the code.
// We do this first thing before the code starts.
// It only happens once when the code runs.
// Libraries are often required to add additional functionality to the Arduino software.
// One example we will be using a lot is the servo library.
// By adding the servo library we get servo-specific commands which makes life easier.
#include <libraries.h>
// We can also define variables and constants
// that we want to establish globally throughout the code.
// There are different types of variables and constants
// Learn more here under 'constant' and 'data types':
// http://www.arduino.cc/en/Reference/HomePage
// For instance, we can establish an intenger variable
int definition1;
// We can also both establish a long variable and give it a starting value.
long definition2 = 3000;
// We can also name something a constant, and give it a value which won't change
const thisIsAConstant = 2;
//################
//### SETUP ###
//################
void setup() {
// The setup code goes here.
// Like definitions it only runs once.
// The difference is that in the setup you include things you want to do,
// not things you want to define.
// For instance, you may want to move a servo motor to it's default position
// Or engage the Serial Monitor for debugging your code
// Or blink an LED test pattern to let you know the application has started
}
//###################
//### MAIN LOOP ###
//###################
void loop() {
// Anything put here will run over and over.
// This is where the bulk of your code should live.
// The Arduino will loop through whatever is here indefinately until it runs out of power.
}
//##############################
//### ADDITIONAL FUNCTIONS ###
//##############################
// If you write your own custom functions, they would be placed down here below the main loop.
// You can call these functions from either the setup or main loop.
// They are useful if you need to do a particular set of things frequently
// Instead of writing it over, and over, you can just call the function
void yourcustomfunction(){
// Here is where you write your custom function
// It can be a particular routine such as configuring motors
// to drive forwards, backwards, right or left.
// Or it can be a routine to check a sensor.
}
//####################
//### THAT'S ALL ###
//####################
// Don't worry. This is all super-confusing at first.
// This will make more sense as you do it.
Compilatorul citește de obicei de la stânga la dreapta de la o linie la alta. Ei bine - în cea mai mare parte. Există câteva diferențe cheie față de modul în care o persoană obișnuită citește și este esențial pentru a înțelege.
O modalitate bună de a vă gândi la un program de calculator este un pic ca a alege propria dvs. poveste de aventură. Compilatorul citește povestea ca și oricare alta, dar atunci când compilatorul citește o funcție, în loc să citească linia următoare, sare la locul în care există această funcție și o citește linie cu linie. După ce face citirea funcției, el se întoarce la următoarea linie din codul de unde a rămas. De asemenea, funcțiile pot avea alte funcții imbricate în ele. Deci, o funcție, poate duce la o altă funcție, la o altă funcție, înainte de a reveni la rutina principală.
Dacă aceasta nu a fost confuzie în sine, programul citește pagina în jos - până la un punct! Și acest lucru este important de reținut ... Când compilatorul ajunge la bucla principală (), orice este conținut în această buclă este repetat mereu și mereu până când Arduino nu mai are alimentare. Bucla principală () reprezintă locul unde există conținutul codului. Orice încercați să realizați ar trebui să existe în bucla principală ().
Toate acestea sunt foarte confuze și străine pentru dvs. Este în regulă. Învățarea limbajului de programare Arduino este un fel de învățare a oricărei limbi. Este nevoie de timp pentru a te obișnui cu ea, și chiar și atunci este nevoie de mult timp pentru a fi cu adevărat fluent.
Pentru a afla mai multe despre programare, un loc bun pentru a începe este Codecadamy.
8. Rulați un program
Rularea unui program pe Arduino este destul de simplă.
Pentru a începe, trebuie să specificați tipul de placă pe care o utilizați. Este ușor, selectați opțiunea "Arduino/Genuino Uno".
De asemenea, vă înscrieți pentru a specifica portul în care se găsește Arduino. Acesta este un pic mai complicat, dar nu prea tare. Doar selectați opțiunea care arată "/dev/cu.usbmodem [random numbers]"
Deschideți exemplul Blink din meniul Exemplu 01.Basics. Apoi, găsiți butonul de încărcare (aceasta arată ca o săgeată îndreptată spre dreapta) și apăsați-o. Dacă totul este configurat corect, ar trebui ca LED-ul de pe placa Arduino să clipească în mod constant.
Încercați să modificați valoarea numerică în cadrul funcțiilor de întârziere și reîncărcați codul. Observați că modifică rata la care clipește.
Acum, că ați reușit acest lucru, să încercăm să clipească un LED extern care nu a fost lipit direct la placa Arduino.
Totul despre plăcile de testare
Când aveți nevoie să faceți un circuit care se conectează la Arduino, ar trebui să folosiți o placă de testare (breadboard). Plăcile de testare sunt destinate să realizeze conexiuni rapide non-permanente între componentele electronice. Ele sunt străbătute de găuri mici, care sunt conectate în rânduri. Placa însăși este împărțită în patru secțiuni. Există două secțiuni interioare pline cu rânduri orizontale scurte și două secțiuni exterioare cu rânduri verticale mai lungi.
Secțiunile interioare sunt utilizate în mod obișnuit pentru conectarea componentelor, iar secțiunile exterioare sunt în mod obișnuit folosite ca linii de magistrale. Cu alte cuvinte, puteți conecta o baterie la una dintre liniile exterioare și apoi componentele de alimentare pe secțiunea interioară prin conectarea unui cablu la această secțiune.
În figura de mai sus, puteți vedea modul în care rândurile de pe panouri sunt conectate electric. Cele două secțiuni interioare au rânduri orizontale scurte repetate pe placă. Cele două secțiuni exterioare au câte două rânduri verticale lungi. Acestea sunt marcate în roșu și albastru și sunt menite să însemne un rând pentru alimentare (roșu) și un rând pentru masă (albastru). Nu toate plăcile detestare sunt marcate cu linii ca aceasta, dar toate sunt așezate în același mod.
Pentru mai multe informații despre panourile de testare, verificați acest tutorial Breadboard.
10. O notă rapidă privind LED-urile
Deși oamenii cred că LED-urile sunt mici becuri, ele sunt de fapt destul de diferite. LED-urile sunt un tip de componentă electronică numită diodă. De fapt, LED-ul este o abreviere pentru dioda emițătoare de lumină. Există multe de spus despre statutul lor unic de diodă, dar pentru scopurile noastre, singurul lucru pe care trebuie să-l cunoașteți este că diodele permit doar electricității să curgă într-o direcție. Aceasta este ceea ce ați numi "polarizat".
Există un terminal care ar trebui să fie întotdeauna conectat la alimentare și unul care ar trebui să fie conectat la masă. Dacă le conectați invers, curentul nu va curge. Terminalul care este conectat la alimentare se numește anod. Terminalul care este conectat la masă se numește catod.
Există trei moduri de a deosebi un anod LED de catodul său.
1) Terminalul conectat la anod este de obicei mai lung decât cel conectat la catod.
2) Corpul LED-ului are de obicei o porțiune plată pe partea catodică.
3) Dacă priviți în interiorul LED-ului, bucățica mică metalică conectată la conductorul anodic este mult mai mică decât catodul.
11. Rezistoare
Rezistoarele, în principiu, adăugă rezistență la un circuit. Există multe motive pentru a face acest lucru. Practic, avem nevoie de un rezistor în circuitul pe cale să construim pentru că un LED nu oferă nici o rezistență. Dacă conectăm alimentarea printr-un LED fără rezistență, atunci este în principiu același lucru ca și crearea unui scurtcircuit prin conectarea sursei de alimentare la masă. Adăugăm un rezistor în serie la LED-ul pentru a utiliza o parte din putere și pentru a preveni un scurt-circuit. Dacă doriți să aflați mai multe, puteți afla mai multe despre rezistoare și rezistență din tutorialul Basic Electronics.
Singurul lucru pe care trebuie să-l cunoaștem despre rezistențe în această conjuncție este că, deși arată aproximativ la fel, toate au valori diferite. Puteți spune cât de multă rezistență oferă fiecare prin citirea codurilor de rezistor marcate pe ele. Codurile rezistorului sunt citite de la stânga la dreapta spre banda aurie (sau argintie).
Pentru a începe, cel mai simplu mod de a interpreta codurile este să utilizați un calculator grafic rezistor on-line. Odată ce utilizați acest lucru suficient, veți începe să învățați să le interpretați pe cont propriu fără calculator.
12. Placa de testare a unui circuit
Introduceți un LED într-un breadboard. Conectați un rezistor de 150 ohmi în serie cu catodul LED-ului. Folosind un fir cu miez solid de culoare neagră, conectați capătul opus al rezistorului (partea care nu este conectată la LED) la masă pe Arduino. Folosind un fir roșu solid, conectați anodul LED-ului la pinul digital 7 de pe Arduino.
Puteți face să clipească un LED extern deschizând codul de exemplu Blink și modificând acest cod înlocuind peste tot numărul 13 cu numărul 7 ori de câte ori acesta apare. Făcând acest lucru, pur și simplu schimbați pinul digital care este pulsat On și OFF de la 13 la 7, pentru a se potrivi cu circuitul pe care l-ai construit pe placa de testare.
Pe lângă clipirea unui LED, putem face și o estompare. Pentru a face acest lucru trebuie să folosim un pin PWM. Pinii PWM sunt pini digitali speciali pe Arduino care permit pentru o ieșire analogică să simuleze o tensiune de ieșire între 0 și 5V. Acestea sunt toate etichetate cu un ~ în fața numărului de pin.
PWM înseamnă modulația lățimii pulsului. Spus altfel, PWM basculează un pin ON și OFF atât de repede încât acesta oferă aspectul de estompare a LED-ului.
Un LED strălucind la 1/4 luminozitate înseamnă că semnalul trimis către acesta este basculat OFF mult mai mult decât este basculat ON. De exemplu, este oprit 75% din timp și activat 25% din timp. Un LED mai luminos la 3/4 luminozitate primește un semnal PWM care este opusul. Deci, ar fi ON în 75% din timp și OFF pe 25%. Lucrul este că se întâmplă atât de repede, încât nu vedeți că este pornit și oprit, dar lumina LED-ului este doar puțin diminuată.
Oricum, dacă doriți să estompați LED-ul, din meniul de exemple selectați:
03.Analog -> Fading
După ce ați terminat, schimbați firul conectat de la pinul digital 7 la pinul digital 9 și încărcați codul dvs. Arduino.
LED-ul ar trebui să se estompeze și să se stingă.
Odată ce ați stăpânit clipirea și estomparea LED-ului, puteți transfera aceste cunoștințe pentru a controla un motor. Dar, nu puteți conecta un motor direct la pinul Arduino din două motive. În primul rând, pinul Arduino este capabil să furnizeze doar puțin curent și un motor este un consumator de curent (mai ales atunci când pornește și se oprește). De asemenea, atunci când un motor se oprește, produce un curent de polaritate opusă celui la care rulează. Acest curent este cunoscut pentru distrugerea pinilor Arduino și trebuie oprit să lucreze. Astfel, este utilă construirea unui circuit tampon.
Tot ce aveți nevoie pentru a controla un motor folosind un Arduino este un rezistor de 2K, un tranzistor NPN (TIP120 în acest caz) și o diodă 1N4001. Rezistorul 2K funcționează pentru a proteja pinul Arduino, tranzistorul servind ca o supapă care permite mai mult sau mai puțin curgerea curentului prin motor. Acesta este ceea ce pornește și oprește motorul și controlează viteza acestuia.
Dioda este folosită ca tampon. Când electricitatea curge prin motor, dioda nu face nimic. Dar, atunci când motorul se oprește, curentul inversat trece prin diodă și înapoi prin motor. Aceasta protejează circuitul de vârfurile de tensiune bruște.
Dacă toate acestea sună confuz, puteți afla mai multe despre aceste componente de bază din clasa electronică.
Dacă doriți să activați și să dezactivați motorul utilizând circuitul din imagine, trebuie să efectuați alte două conexiuni. Mai întâi, conectați masa bateriei externe la pinul de masă al lui Arduino. Aceasta se numește "partajarea masei" și este necesară pentru funcționarea circuitului. Apoi, conectați pinul 13 de la Arduino la rezistorul 2K conectat la baza tranzistorului. Odată ce ați terminat acest lucru, descărcați exemplul Blink și încărcați-l în Arduino. În loc să clipească un LED, acesta va porni și opri motorul.
Dacă doriți să controlați viteza motorului, schimbați cablajul la pinul 13 și descărcați exemplul de estompare pentru a crește și a reduce viteza motorului.
Acum s-ar putea să fi văzut că nici una dintre aceste soluții nu va inversa motorul. Pentru a face un motor să se rotească înapoi, veți avea nevoie de o punte H.
O punte-H este un circuit care permite ca orientarea motorului să fie inversată. Mai multe punți-H avansate - cum ar fi cele găsite în interiorul servomotoarelor - vă permit, de asemenea, să controlați viteza motorului.
În esență, o punte-H constă din patru comutatoare sau tranzistoare. În exemplul de mai sus, există un comutator între fiecare pol al motorului și masă. Există, de asemenea, un alt set de comutatoare între fiecare pol al motorului și sursă.
Când aceste întrerupătoare sunt extrase într-o diagramă, ele arată ca un "H". De aici numele de H-bridge.
Când setul de întrerupătoare etichetate cu "A" este închis, curentul trece prin motor în așa fel încât să se rotească în sensul acelor de ceasornic.
Când celălalt set "B" este închis, curentul curge în direcția opusă, iar motorul se rotește în sens invers acelor de ceasornic.
Lucrul important de reținut atunci când se lucrează cu punți-H este acela că ambele seturi nu pot fi închise în același timp, sau sursa și masa vor fi conectate direct și veți avea un scurtcircuit.
De asemenea, dacă amestecați și potriviți întrerupătoarele, cum ar fi închiderea A1 și B2, veți crea, de asemenea, un scurtcircuit. Este important ca întrerupătoarele "A" să fie închise sau comutatoarele "B". Niciodată ambele, sau o combinație a acestora.
Dacă doriți să controlați viteza, ați folosi patru tranzistoare în locul comutatoarelor și controlați baza fiecărui tranzistor folosind Arduino.
Mai sus este un exemplu al unei punți-H DIY care utilizează două tranzistoare PNP (2N3906) și două NPN (2N3904). Înainte de a construi acest circuit și a-l pune în proiectul dvs., este important să rețineți că acești tranzistori nu pot manevra mult curent la toate. Acest exemplu ar trebui să fie încercat numai cu motoare relativ "foarte mici" (nu mai mari decât cele ilustrate) și nu este necesar să se construiască. Este în primul rând aici doar pentru a explica conceptul acesteia. Vom folosi plăcile de controller motor cu punți-H prefabricate pe măsură ce vom continua cursul.
Acum hai să discutăm pe scurt ce se întâmplă. Fiecare parte a "H" constă dintr-un tranzistor PNP pe "sus" și un tranzistor NPN pe "jos". Baza fiecăruia dintre aceste tranzistoare este conectată la o șină comună printr-un rezistor de 1K (pentru a proteja Arduino), iar această șină se conectează la un pin Arduino. Emitorul tranzistorului PNP este conectat la sursă, iar emitorul tranzistorului NPN este conectat la masă. Pe fiecare parte a lui "H", ambele colectoare se conectează împreună pentru a se lega într-un singur pin la motor. De asemenea, în circuit sunt incluse patru diode de protecție din siliciu 1N4001, care sunt polarizate invers între fiecare pin al motorului și sursa de tensiune pozitivă și masă.
Prin utilizarea unei combinații de tranzistoare PNP și NPN - spre deosebire de patru tranzistoare NPN - se realizează două lucruri. În primul rând, creează un aranjament în care un tranzistor de pe fiecare parte este întotdeauna decuplat, împiedicând scurtcircuitele. În al doilea rând, permite controlul punții-H cu doar doi pini digitali de la Arduino.
De exemplu, dacă aveți un pin Arduino care trimite un semnal high la o parte a lui 'H', iar celălalt pin Arduino trimite un semnal low către cealaltă parte, curentul va curge de la PNP pe o parte la NPN pe cealaltă. Dacă inversați pinii Arduino, curentul va curge prin perechea opusă de tranzistori, inversând direcția motorului.
Viteza motorului poate fi de asemenea controlată folosind o punte-H ca aceasta prin intermediul PWM la pinul pozitiv Arduino în loc să-l setați pe HIGH.
Dacă ați construit acest circuit, puteți folosi următorul cod pentru a-l vedea în acțiune:
void setup() {
// set the digital pins as outputs
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
}
void loop() {
//spin clockwise
digitalWrite(5, LOW);
digitalWrite(6, HIGH);
delay(2000);
//spin counterclockwise
digitalWrite(5, HIGH);
digitalWrite(6, LOW);
delay(2000);
}
Dacă doriți să testați controlul vitezei în ambele direcții, încercați PWM la pinii bazelor tranzistoarelor cu acest cod:
void setup() {
// set the digital pins as outputs
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
}
void loop() {
//spin slowly clockwise
digitalWrite(5, LOW);
analogWrite(6, 80);
delay(2000);
//spin faster counterclockwise
analogWrite(5, 180);
digitalWrite(6, LOW);
delay(2000);
}
Construirea unei punți-H foarte fiabile este o formă de artă în sine și în afara scopului acestei clase. În schimb, vom folosi shield și module controller motor. Acestea sunt în principiu plăci de circuite cu punți-H pre-fabricate pentru controlul motoarelor.
Unele motoare au chiar propria lor punte-H încorporată, așa cum veți învăța în continuare în lecția servo.