Aprenentatge de la programació bàsica d'Arduino: tutorial per als nouvinguts

En aquest tutorial aprenem a fer programacions bàsiques d'Arduino mitjançant exemples de codis i exemples de programes. Aquest tutorial pot ser un curs extremadament valuós per a tots els nouvinguts que vulguin entendre els conceptes bàsics mitjançant un llenguatge fàcil i entenedor.

Introducció

D'acord amb wikipedia un microcontrolador equival a un mini ordinador construït dins d’un sol xip IC, que té el seu propi processador central, entrades programables, perifèrics de memòria i sortida.

Un microcontrolador es fa tan útil per a un usuari, ja que ofereix un processador incorporat, memòria i ports d’entrada / sortida (també anomenats GPIO o pins d’entrada / sortida d’ús general) que l’usuari pot controlar segons les especificacions desitjades.

En aquest tutorial treballarem amb una placa Arduino Uno per aprendre i provar els programes. Per provar i integrar el muntatge de maquinari utilitzarem una taula de treball.

Ara anem a avançar ràpidament i aprendre a començar amb una programació Arduino.

1.2 Instal·lació del programari (Windows)

Per a això, necessitareu accés a Internet, que, òbviament, tindríeu al vostre ordinador. Aneu al següent enllaç i descarregueu-vos el programari IDE:

Fitxer ZIP de Windows per a instal·lacions no administratives

Després de descarregar-lo, trobareu la icona de configuració d'Arduino a la carpeta de descàrrega, que tindria l'aspecte següent:

Un cop aconseguit això, només cal que feu doble clic a sobre i instal·leu Arduino the Integrated Development Environment (IDE) al vostre ordinador. El procés complet es pot visualitzar al següent vídeo:

1.4 Començant pel nostre primer circuit

Abans de començar a aprendre les tècniques de programació reals, per a qualsevol novell seria útil començar amb un component bàsic com ara un LED i entendre com connectar-lo amb un Arduino.

Com sabem, un LED és un díode emissor de llum que té una polaritat i no s’il·lumina si no està connectat amb els pols de subministrament adequats.

Un altre aspecte dels LED és que aquests dispositius funcionen amb poc corrent i es poden danyar instantàniament si una resistència calculada adequadament no s’inclou en sèrie amb un dels seus pins.

Per regla general, un 1/4 de watt de 330 ohms és bastant ideal per a cada pujada de 5V de l’entrada de subministrament per limitar el corrent al nivell de seguretat requerit. Per tant, per a 5V pot ser de 330 ohms, per a 10V pot ser de 680 ohms, etc.

Ús de Breadboard per al muntatge

Assegureu-vos que sabeu utilitzar un taulell de pa abans de provar el tutorial que s’explica en aquest capítol, ja que faríem servir un tauler per a tots els experiments aquí.

A continuació es pot veure la configuració bàsica de la connexió LED:

Podeu veure 3 components bàsics més amunt:

1. Un LED de 5 mm i 20 mA
2. una resistència de 1/4 de watt de 330 ohms
3. An Tauler Arduino

Només cal muntar el sistema segons el diagrama.

A continuació, connecteu el 5V de l’ordinador USB a l’Arduino. Tan bon punt feu això, veureu que el LED s’encén.

Sé que és bastant bàsic, però sempre és bo començar des de zero. Tingueu la seguretat que les coses començaran a ser cada vegada més interessants a mesura que avancem.

1.5 Control de LED amb Arduino

Ara aprendrem a controlar un LED amb un programa Arduino.

Per escriure un programa hem de tenir com a mínim 2 funcions en cada programa.

Una funció es pot entendre com una sèrie d’instruccions de programació que es poden assignar amb un nom, tal com s’indica a continuació:

1. setup () s'anomena o s'executa durant l'inici del programa.
2. loop () s'anomena o s'executa repetidament durant tot el període operatiu de l'Arduino.

Per tant, tot i que pot no tenir cap funcionalitat pràctica, tècnicament un programa Arduino legítim més curt es pot escriure com:

Programa més senzill

void setup()
{
}
void loop()
{
}

És possible que us hàgiu adonat que, en molts dels llenguatges de programació, el sistema comença mostrant una simple impressió 'Hello, World' a la pantalla

L'equivalent electrònic d'aquesta frase en la interpretació del microcontrolador és parpellejar un LED ON i OFF.

Aquest és el programa més bàsic que es pot escriure i implementar per indicar un correcte funcionament del sistema.

Intentarem implementar i entendre el procediment mitjançant el codi següent:

Llistat 1.2: led1 / led1.pde

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
void loop()
{
digitalWrite(kPinLed, HIGH)
delay(500)
digitalWrite(kPinLed, LOW)
delay(500)
}

D'acord, ara entenem què significa cada línia del codi i com funciona per executar la funció:

const int kPinLed = 13

Funciona com una constant que ens permet utilitzar-la durant tot el curs de programació, sense necessitat d’utilitzar el valor real que s’hi estableix.

Segons les regles estàndard, aquestes constants es reconeixen amb la lletra inicial a . Tot i que això no és obligatori, fa que les coses siguin més clares i fàcilment comprensibles sempre que tingueu ganes de revisar els detalls del codi.

void setup()
{
pinMode(kPinLed, OUTPUT)
}

Aquest codi configura el pin específic al qual està connectat el nostre LED. En altres paraules, el codi indica a Arduino que controli l'aspecte 'escriptura' en aquest pin, en lloc de 'llegir-lo'.

void loop()
{
digitalWrite(kPinLed, HIGH)
delay(500)
digitalWrite(kPinLed, LOW)
delay(500)
}

Les línies anteriors indiquen l'execució real de l'aplicació. El codi comença escrivint i renderitzant una sortida ALTA a la connexió LED corresponent, encenent el LED.

Aquí, el terme HIGH significa simplement obtenir + 5 V al pin corresponent de l'Arduino. El terme complementari BAIX simplement indica un zero o 0V al pin designat.

A continuació, anomenem delay() la funció del qual és crear un retard de mil·lisegons (1/1000 de segon). Com que s’introdueix la xifra 500, el retard implementat serà de 1/2 segon.

Tan bon punt transcorri aquest mig segon, s'executa la següent línia que apaga el LED amb el terme BAIX al mateix pin.

La línia posterior torna a generar un retard de 1/2 segon, per tal de permetre que el LED romangui apagat durant 1/2 segon.

I el procés continua infinitament mitjançant l'execució de les línies de codi, sempre que l'Arduino es mantingui alimentat.

Abans de passar al següent nivell, us recomanaria que programeu el codi anterior i comproveu si podeu implementar la seqüència LED ON / OF correctament o no.

Com que el LED per defecte d'Arduino està connectat amb el pin # 13, hauria de respondre immediatament al programa anterior i començar a parpellejar. Tanmateix, si trobeu que el LED extern no parpelleja, és possible que hi hagi un error de connexió amb el LED, és possible que intenteu invertir la polaritat del LED i, amb sort, que parpellegi.

Podeu jugar amb el temps de retard modificant la figura '500' a algun altre valor i trobar el LED 'escoltant' les ordres i fent que parpellegi segons els valors de retard especificats.

Però recordeu, si veieu que el LED no parpelleja amb una velocitat constant d’1 segon, independentment de l’alteració del temps de retard, això pot indicar que el codi no funciona a causa d’un error. Perquè per defecte l’Arduino es programarà amb una velocitat de parpelleig d’1 segon. Per tant, aquesta tarifa ha de variar segons el vostre codi per confirmar el seu funcionament correcte.

1.7 Comentaris

Les línies de codis que hem entès anteriorment s’han escrit específicament per al programari de l’ordinador.

Tanmateix, per tal de garantir que l'usuari sigui capaç de referir el significat de les línies i entendre-les, sovint pot ser útil i raonable escriure l'explicació al costat de les línies de codis desitjades.

Aquests es diuen comentaris que s’escriuen només per a referència humana o d’usuari i estan codificats per permetre als equips ignorar-lo amb seguretat.

L’idioma d’aquests comentaris s’escriu amb un parell de formats:

1. L'estil de bloc de comentari, on la descripció del comentari s'inclou sota el símbol inicial / * i el símbol final * /
2. Això no ha de restringir-se en una línia, sinó que es pot estendre a les següents línies següents, en funció de la longitud del comentari o de la descripció, tal com es mostra a l'exemple següent:

/ * Aquest és un comentari * /

/ * Així és això * /

/ * I
* això
* com
* bé */

Per escriure una descripció ràpida d'una sola línia per a un comentari, n'hi ha prou amb dues barres diagonals // al començament. Això indica a l’ordinador que aquesta línia no té res a veure amb el codi real i que s’ha d’ignorar. Per exemple:

// Aquest és un comentari que els ordinadors ignoraran.

Aquí teniu un exemple de referència:

/*
* Program Name: Blink
* Author: Alan Smith
* Description:
* Turns an LED on for one half second, then off for one half second repeatedly.
*/

/* Pin Definitions */
const int kPinLed = 13
/*
* Function Name: setup
* Purpose: Run once when the system powers up.
*/
void setup()
{
pinMode(kPinLed, OUTPUT)
}
/*
* Function name: loop
* Purpose: Runs over and over again, as long as the Arduino has power
*/
void loop()
{
digitalWrite(kPinLed, HIGH)
delay(500)
digitalWrite(kPinLed, LOW)
delay(500)
}

1.8 Resolució de problemes

Si el vostre programa mostra un 'error' durant la compilació o algun altre problema, els consells següents probablement us ajudaran a tornar a comprovar el vostre codi per eliminar l’obstacle.

1. El llenguatge del vostre programa distingirà entre majúscules i minúscules. Per exemple l’expressió myVar no es pot escriure com MyVar.
2. Tot tipus d’espais en blanc que es poden executar mitjançant l’escriptura del teclat es representen en última instància com un únic espai i només són visibles o entesos per vosaltres, l’ordinador no ho tindrà en compte. En poques paraules, els espais lliures de qualsevol tipus no tindran cap efecte en els resultats del codi.
3. Cada bloc de codi ha d'anar inclòs amb claudàtors esquerra i dreta, '{' i '}'
4. Els dígits numèrics no s’han de separar amb comes. Per exemple, 1000 no es poden escriure com a 1.000.
5. Totes les línies de codi incloses entre claudàtors han d'acabar amb un punt i coma

Creació d’interessants seqüències de llum LED amb Arduino

Al capítol anterior vam aprendre a parpellejar un LED ON / OFF contínuament amb una taxa de retard constant.

Ara aprendrem com es podrien executar diferents patrons de retard en el mateix LED actualitzant el codi del programa.

No utilitzarem un LED extern, sinó el LED predeterminat integrat a la placa Arduino al pin # 13. Podeu trobar aquest petit LED SMD darrere del connector USB.

2.2 Comprensió de les declaracions IF

En aquesta secció aprendrem com les estructures de control ens permeten executar codis individuals i, fins i tot, de manera repetitiva, segons sigui necessari.

La declaració si esdevé la primera estructura de control. La següent implementació mostra com s’utilitza:

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
int delayTime = 1000
void loop()
{
delayTime = delayTime - 100
if(delayTime <= 0){ // If the delay time is zero or less, reset it.
delayTime = 1000
}
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}

Intentarem entendre el codi anterior per passos i aprendrem com es pot utilitzar per a altres execucions similars.

Els codis entre la 1a i la 7a línia són exactament similars al nostre programa inicial.

La primera modificació passa realment a la vuitena línia.

int delayTime = 1000

Podeu trobar que és similar al codi de la primera línia, tret que falti el terme const.

Això es deu simplement a que aquest codi no és una constant. En lloc d'això, es defineix com a variable , que té la propietat d'un valor variable en el transcurs de la programació.

A l'exemple anterior es pot veure que aquesta variable s'atribueix amb un valor de 1000. Recordeu que aquestes variables que estan incloses entre claudàtors s'han d'escriure estrictament només entre parells de claudàtors i es denominen variables 'locals'.

Alternativament, les variables que se suposa que estan fora de claudàtors arrissats, com ara el que discutim ara, es reconeixen com a 'globals' i es poden executar gairebé a qualsevol lloc del codi del programa.

Seguint endavant, podeu veure que els codis entre la línia 9 i la 11 també són similars al primer programa, tot i que les coses comencen a ser interessants després de la línia 11. A veure com!

delayTime = delayTime - 100

En aquest codi veiem que el valor per defecte del fitxer temps de retard s'està modificant restant-ne 100.

El significat 100 es dedueix del seu valor inicial de 1000, proporcionant-li un nou valor de 900.

A través de la següent imatge intentarem comprendre alguns dels operadors matemàtics utilitzats en el llenguatge Arduino.

Ara avaluem els codis entre la línia 13 i la 15.

if(delayTime <= 0){ // If the delay time is zero or less, reset it.
delayTime = 1000
}

L'objectiu principal del codi anterior és garantir que el LED continuï parpellejant sense interrupcions.

A causa del fet que se’n descompten 100 de l’original temps de retard , evita que el parpelleig del LED arribi a zero i permet que el parpelleig continuï.

La imatge següent mostra uns quants operadors de comparació que faríem servir als nostres codis:

Al nostre codi anterior, podríem haver provat que el codi sigui if(delayTime == 0).

Tot i això, com que ser xifra negativa pot ser igual de dolent, no hi vam anar, i aquesta és una pràctica recomanada.

Penseu quin podria haver estat el resultat si haguéssim intentat deduir 300 en lloc de 100 de delayTime?

Per tant, ara us heu adonat que si | | + _ | s'escriu com a menor o igual a zero, el temps de retard es tornaria a la figura original 1000.

delayTime

Les darreres 4 línies del codi, tal com es mostra més amunt, es fan responsables d’encendre / apagar el LED, ON / OFF continuament.

Aquí podeu notar clarament que, en lloc d’utilitzar una sèrie de xifres, hem utilitzat una variable per assignar el temps de retard, de manera que puguem ajustar-lo com vulguem durant el període operatiu del codi. És genial, oi?

2.3 Declaracions ELSE

Aquí aprendrem per què i com si terme pot tenir una clàusula en cas contrari perquè decideixi la situació per si de cas si l'afirmació és falsa.

Ho sento si sembla massa confús, no us preocupeu, intentarem entendre-ho amb el següent exemple:

digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)

A l’anterior es pot veure que a la 10a línia el codi només s’executa quan el const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
int delayTime = 1000
void loop()
{
if(delayTime <= 100){ // If it is less than or equal to 100, reset it
delayTime = 1000
}
else{
delayTime = delayTime - 100
}
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
} és menor o igual a 100, si no és així, s'executa el codi de la 13a línia, però mai no es poden produir tots dos junts, ni s'implementaran la 10a línia ni el 13è codi de línia, mai ambdues.

És possible que us hàgiu adonat que, a diferència del que vam fer a la nostra secció 2.2 anterior, aquí no vam comparar amb 0, sinó amb 100. Això es deu al fet que en aquest exemple comparat ABANS de restar 100, contràriament a la secció 2.2, vam comparar DESPRÉS restat. Pots dir què podria haver passat si haguéssim comparat 0 en lloc de 100?

2.4 MENTRE declaracions

A mentre afirmació és bastant similar a si , excepte la veritat que provoca l'execució repetida d'un bloc de codi (que pot estar entre claudàtors) durant el temps que s'apliquin les condicions, i això funciona sense en cas contrari declaració.

L’exemple següent l’ajudarà a entendre-ho millor

delayTime

Podeu endevinar què està programat per fer el codi anterior? Bé, està dissenyat per parpellejar el LED més ràpidament i després més lentament.

2.5 Què és cert i fals?

En llenguatge de programació, fals fa referència a zero (0). En realitat, no s'utilitza 'veritable', en lloc d'això, se suposa que quan res és fals, tot el que s'inclou és veritat.

Sembla poc estrany, però fa la feina força bé.

Intentarem copsar la situació a través del següent exemple.

De vegades us podeu trobar amb un codi com es mostra a continuació:

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
int delayTime = 1000
void loop()
{
while(delayTime > 0){ // while delayTime is greater than 0
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
delayTime = delayTime - 100
}
while(delayTime <1000){ // while delayTime is less than 1000
delayTime = delayTime + 100 // do this first so we don’t have a loop with delayTime = 0
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}
}

Això està codificat i sembla que l'execució del LED continuarà circulant per sempre, ja que hi haurà molta energia disponible.

Tanmateix, un inconvenient d’aquest tipus de codi pot aparèixer quan accidentalment l’usuari aplica un = en lloc de ==.

Estic segur que ja sabeu que = significa una assignació, és a dir, s'utilitza per designar un valor seleccionat a una variable, mentre que un == s'utilitza per aplicar una prova si el valor era el mateix.

Per exemple, suposem que necessiteu un LED per parpellejar amb un patró d’acceleració seqüencial i repetitiu, però que heu utilitzat incorrectament un = en lloc de ==.

El codi apareixerà així:

while (1){
digitalWrite(kPinLed, HIGH)
delay(100)
digitalWrite(kPinLed, LOW)
delay(100)
}

L'error assignarà 0 a int delayTime = 1000
void loop()
{
if(delayTime = 0){ // WRONG!!! the = should have been ==
delayTime = 1000
}
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
delayTime = delayTime - 100
} i conduirà al fitxer si declaració per comprovar si 0 era cert o no. Com que 0 fa referència a fals, pensarà que no és cert i deixarà d'aplicar el delayTime, sinó la funció delayTime = 1000 es manté a 0 durant el curs del bucle ().

Sembla molt indesitjable !!

Per tant, comproveu sempre el programa per assegurar-vos que no heu comès cap error tan ximple.

2.6 Combinacions

De vegades és possible que sentiu la necessitat de provar diverses coses junts. Igual, és possible que vulgueu examinar si una variable estava entre dos nombres. Tot i que es pot implementar utilitzant la sentència if diverses vegades, pot ser més convenient utilitzar combinacions lògiques per a una lectura millor i més fàcil.

La implementació de combinacions en termes lògics es podria fer amb 3 mètodes, tal com es mostra a la taula següent:

Seria interessant saber que l'operador NOT pot funcionar com a commutador d'una variable que es pot designar com a qualsevol cert o bé fals (o BAIX o ALT).

L'exemple següent il·lustra la condició:

delayTime

Aquí el int ledState = LOW
void loop()
{
ledState = !ledState // toggle value of ledState
digitalWrite(kPinLed, ledState)
delay(1000)
} serà BAIX i, posteriorment, tan aviat com ledState, es convertirà en ALTA. El següent bucle provocarà ledState = !ledState ser ALT quan ledState és BAIX.

2.7 FOR declaracions

Ara intentarem entendre sobre una altra estructura de control que és per bucle. Això pot ser molt útil quan vulgueu implementar alguna cosa diverses vegades.

Entenguem això amb el següent exemple:

ledState = !ledState

Podeu trobar quelcom únic a la línia de per.

És el codi i ++? . Això és útil per a programadors que són més mandrosos i que volen implementar la codificació mitjançant dreceres convenients

El terme anterior es coneix com a operadors compostos, ja que fan la feina de combinar un operador d'assignació amb un altre operador d'assignació. Els més populars es poden visualitzar a la taula següent:

Trobareu que hi ha 3 subafirmats en una declaració for. Està estructurat de la manera següent:

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
void loop()
{
for(int i = 0 i <4 i++){
digitalWrite(kPinLed, HIGH)
delay(200)
digitalWrite(kPinLed, LOW)
delay(200)
}
delay(1000) // 1 second
}

La declaració # 1 es produeix just al principi i només una vegada. La condició es prova cada vegada durant el curs del bucle. Sempre que ho sigui cert dins dels claudàtors, la declaració següent # 2 s'aplica. En cas de fals, el sistema salta al següent bloc de codi.

Connexió de més LEDs

D'acord, ara veurem com podem connectar més nombre de LEds per obtenir efectes més interessants.

Connecteu els LED i l'Arduino com es mostra a continuació. El cable vermell en realitat no és necessari, però com que sempre és una bona idea que tots dos rails de subministrament s’incloguin a la taula de configuració, té sentit.

Ara solucionem un programa que ens permetrà comprovar si el nostre maquinari està configurat correctament o no.

Sempre es recomana codificar i executar petits fragments de programes per comprovar si els respectius programaris estan connectats correctament o no.

Això ajuda a resoldre ràpidament un possible error.

L'exemple de codi següent proporciona als LED 2 a 5 un patró específic girant-los un darrere l'altre de manera cíclica.

for (statement1conditionstatement2){
// statements
}

Com podeu notar, el codi no té res de dolent, excepte el fet que sembla llarg i, per tant, propens a errors.

Per descomptat, hi ha millors maneres d’escriure el codi anterior, la secció següent ho revelarà.

2.9 Introducció de matrius

Les matrius poden ser un grup de variables que es poden indexar amb números índex. L’exemple següent ens ajudarà a entendre-ho millor.

const int kPinLed1 = 2
const int kPinLed2 = 3
const int kPinLed3 = 4
const int kPinLed4 = 5
void setup()
{
pinMode(kPinLed1, OUTPUT)
pinMode(kPinLed2, OUTPUT)
pinMode(kPinLed3, OUTPUT)
pinMode(kPinLed4, OUTPUT)
}
void loop()
{
// turn on each of the LEDs in order
digitalWrite(kPinLed1, HIGH)
delay(100)
digitalWrite(kPinLed2, HIGH)
delay(100)
digitalWrite(kPinLed3, HIGH)
delay(100)
digitalWrite(kPinLed4, HIGH)
delay(100)
// turn off each of the LEDs in order
digitalWrite(kPinLed1, LOW)
delay(100)
digitalWrite(kPinLed2, LOW)
delay(100)
digitalWrite(kPinLed3, LOW)
delay(100)
digitalWrite(kPinLed4, LOW)
}

D'acord, ara anem a revisar cada secció i entenem com funcionen realment.

const int k_numLEDs = 4
const int kPinLeds[k_numLEDs] = {2,3,4,5} // LEDs connected to pins 2-5
void setup()
{
for(int i = 0 i pinMode(kPinLeds[i], OUTPUT)
}
}
void loop()
{
for(int i = 0 i digitalWrite(kPinLeds[i], HIGH)
delay(100)
}
for(int i = k_numLEDs - 1 i >= 0 i--){
digitalWrite(kPinLeds[i], LOW)
delay(100)
}
}

El codi anterior defineix quants elements màxims se suposa que tenim a la matriu. Aquest codi ens ajuda a les seccions posteriors a assegurar-nos que tot s’escrigui dins d’una matriu i res quan un acabi.

const int k_numLEDs = 4

En aquesta següent línia configurem l'estructura de matriu. Els números dins del claudàtor indiquen el nombre d'elements de la matriu. Tot i que es podria haver escrit la quantitat real, escriure com a constants funciona millor. Els valors es poden veure normalment dins del claudàtor amb comes i designar els valors a la matriu.

Quan trobeu una matriu indexada amb el número 0, això indica el primer element de la matriu, tal com es mostra a const int kPinLeds[k_numLEDs] = {2,3,4,5} // LEDs connected to pins 2-5.

De la mateixa manera, l'últim element es mostrarà com code: k_LEDPins is k_LEDPins[0], ja que el recompte de 0 a 3 és 4.

k_LEDPins[3]

El codi anterior mostra l'ús del bucle per procedir a través de cada element de la matriu i establir-los com a SORTIDES. Implementem claudàtors junt amb l'índex per arribar a cadascun dels elements de la matriu.

si us pregunteu si és possible utilitzar el pin número 2 al pin número 5 sense matrius, la resposta és sí, és possible. Però en aquest exemple no es fa perquè no ho hem fet així. A les seccions següents podeu eliminar l'enfocament de matriu si els pins de sortida seleccionats no estan en línia.

Seguint endavant, vegem què fa el següent bloc de codi:

void setup()
{
for(int i = 0 i pinMode(kPinLeds[i], OUTPUT)
}
}

Aquí el codi avança a través de cadascun dels LED per activar-los de manera seqüencial amb un buit o retard de 100 mil·lisegons.

for(int i = 0 i digitalWrite(kPinLeds[i], HIGH)
delay(100)
}

L'ús del codi anterior mostra com s'aplica el fitxer per a bucle es podria utilitzar per moure's pel bucle fins i tot en l'ordre invers.

Comença des de for(int i = k_numLEDs - 1 i >= 0 i--){
digitalWrite(kPinLeds[i], LOW)
delay(100)
} perquè les matrius estan indexades a zero. No partim de k_numLEDs - 1 perquè això resultaria en creuar l’acabat de la matriu.

El codi utilitza> = 0 per comprovar que el primer element de l’índex 0 no es perdi ni s’ignori.

Capítol 3

Què és una entrada

També hem après a manejar les coses amb Arduino. En aquest capítol analitzarem com detectar el món real mitjançant la interfície d’entrades des de paràmetres externs.

3.1 Ús de polsadors

Tots sabem què és i com funciona un polsador. És una mena d’interruptor o botó que connecta momentàniament un senyal d’un circuit a un altre mentre es troba en estat deprimit i trenca el senyal quan es deixa anar.

3.1.1 Un botó i un LED

Connectarem l'Arduino amb un polsador amb Arduino segons els detalls mostrats anteriorment i coneixerem el funcionament bàsic i la implementació de la configuració.

El polsador indicat, que també s'anomena polsador de microinterruptor, té 4 pins en total (2 parells a cada costat). Quan s’empeny, cada parell de pins s’uneix internament i permet una connexió o conducció a través d’ells.

En aquest exemple estem utilitzant només un parell d’aquests pins o contactes, l’altre parell és irrellevant i, per tant, s’ignora.

Continuem aplicant el següent codi i comprovant que funciona.

k_LEDPins[4]

Aquí podeu trobar algunes coses que semblen inusuals. Esbrinem-los pas a pas.

const int kPinButton1 = 2
const int kPinLed = 9
void setup()
{
pinMode(kPinButton1, INPUT)
digitalWrite(kPinButton1, HIGH) // turn on pull-up resistor
pinMode(kPinLed, OUTPUT)
}
void loop()
{
if(digitalRead(kPinButton1) == LOW){
digitalWrite(kPinLed, HIGH)
}
else{
digitalWrite(kPinLed, LOW)
}
}

El primer que fem és arreglar el fitxer buttonPin com el ENTRADA. Doncs això és bastant bàsic, ho sé.

A continuació, assignem ALTA fins al ENTRADA pin. Us pregunteu, com pot ser possible escriure qualsevol cosa a l'entrada? És clar, això pot ser interessant.

En realitat, assignar un HIGH a una entrada Arduino commuta una resistència interna de 20k Ohm activada (un LOW en aquest pin el desactiva).

Una altra qüestió que podeu fer és què és una resistència de tracció. He tractat una publicació completa sobre les resistències pull-up que vostè aprèn-lo aquí .

D'acord, seguint endavant, ara mirem el codi del bucle principal:

void setup()
{
pinMode(kPinButton1, INPUT)
digitalWrite(kPinButton1, HIGH) // turn on pull-up resistor
pinMode(kPinLed, OUTPUT)
}

En prémer el polsador, el pin cablejat es connecta a terra, cosa que fa que un BAIX a aquest passador. I mentre no es prem, es manté el mateix passador ALTA o + 5V mitjançant la resistència de tracció interna de 20K.

Aquí volem que l'Arduino il·lumini el LED quan es prem el botó (BAIX), per tant, escrivim HIGH per a la sortida per a cada resposta d'un BAIX des del botó mentre es prem.

3.1.2 Dos botons i un LED

Bé, us podeu preguntar que l'acció mostrada anteriorment també s'hauria pogut fer sense un Arduino. Entenc, però, que és una pedra empinada per aprendre com es pot utilitzar el botó amb Arduno.

Fins aquest punt, hem estudiat escriure codis per encendre (HIGH) o apagar (LOW) un LED.

Ara anem a veure com es pot controlar la brillantor del LED amb un Arduino.

Es pot fer mitjançant dos mètodes:

1. En restringir la quantitat de corrent al LED
2. Mitjançant l'ús de PWM o modulació d'ample de pols, en què l'alimentació del LED s'encén / apaga a una velocitat desitjada molt ràpidament, produint una il·luminació mitjana la intensitat de la qual dependria del PWM.

En una placa Arduino, el suport PWM està disponible als pins marcats amb un títol (~), que són els pins 3, 4,5,9,10 i 11) a 500Hz (500 vegades per segon). L'usuari pot proporcionar qualsevol valor entre 0 i 255, on 0 fa referència a cap HIGH o no + 5V, i 255 diu a Arduino que obtingui un HIGH o + 5V tot el temps. Per iniciar aquestes ordres, haureu d’accedir a analogWrite () amb el valor desitjat.

Podeu suposar que PWM és x / 255 on x és el valor desitjat que voleu enviar mitjançant void loop()
{
if(digitalRead(kPinButton1) == LOW){
digitalWrite(kPinLed, HIGH)
}
else{
digitalWrite(kPinLed, LOW)
}
}.

Configureu l'Arduino i altres paràmetres com es mostra a la part anterior.

analogWrite()

Aquí podeu trobar 3 línies que necessitin alguna explicació.

const int kPinButton1 = 2
const int kPinButton2 = 3
const int kPinLed = 9
void setup()
{
pinMode(kPinButton1, INPUT)
pinMode(kPinButton2, INPUT)
pinMode(kPinLed, OUTPUT)
digitalWrite(kPinButton1, HIGH) // turn on pullup resistor
digitalWrite(kPinButton2, HIGH) // turn on pullup resistor
}
int ledBrightness = 128
void loop()
{
if(digitalRead(kPinButton1) == LOW){
ledBrightness--
}
else if(digitalRead(kPinButton2) == LOW){
ledBrightness++
}
ledBrightness = constrain(ledBrightness, 0, 255)
analogWrite(kPinLed, ledBrightness)
delay(20)
}

La línia: ledBrightness = constrain(ledBrightness, 0, 255)
25 analogWrite(kPinLed, ledBrightness)
26 delay(20) il·lustra una funció única dins d'Arduino coneguda com a constrain ().

Aquesta funció interna comprèn un codi similar al següent:

int constrain (valor int, int min, int max)
ledBrightness = constrain(ledBrightness, 0, 255)

Tots els codis discutits anteriorment van començar amb buit , que significava no retornar res (buit). Mentre que el codi anterior comença per int , que indica que retorna un nombre enter. En parlarem més a les seccions posteriors, de moment només cal recordar que un nombre enter no té parts fraccionàries.

D’acord, per tant, això implica, el codi: {
if(value > max){
value = max
}
if(value value = min
}
return value
} assigna el ledBrightness = constrain(ledBrightness, 0, 255).

La següent línia utilitza ledBrightness to be within the range of 0 and 255 a ordres Arduino per aplicar PWM al pin seleccionat amb el valor desitjat.

La següent línia crea un retard de 20 mil·lisegons, per assegurar-nos que no ajustem el menjar més ràpid de 50 Hz o 50 vegades per segon. Això es deu al fet que els humans poden ser molt més lents que un Arduino. Per tant, si no es produeix el retard, el programa pot fer-nos sentir que si premeu el primer botó es va apagar el LED i, si es prem el segon, el va encendre (proveu-ho vosaltres mateixos per confirmar-ho).

3.2 Potenciòmetres

Seguim endavant i aprenem a utilitzar-lo potenciòmetres amb Arduino.

Per saber com funciona el potenciòmetre o una olla, podeu llegir això article .

Connecteu els paràmetres mostrats amb el vostre Arduino tal com es mostra a la part anterior.

Un pot tindrà 3 terminals. El terminasl mitjà es connectarà amb ANALOG IN 0 a l'Arduino. Els altres dos terminals exteriors es poden connectar a rails d'alimentació de + 5V i 0V.

Programem i comprovem els resultats:

analogWrite

Trobareu un parell de coses que poden semblar completament noves i no incloses en cap dels nostres codis anteriors.

1. La constant const int kPinPot = A0
const int kPinLed = 9
void setup()
{
pinMode(kPinPot, INPUT)
pinMode(kPinLed, OUTPUT)
}
void loop()
{
int ledBrightness
int sensorValue = 0
sensorValue = analogRead(kPinPot)
ledBrightness = map(sensorValue, 0, 1023, 0, 255)
analogWrite(kPinLed, ledBrightness)
} s'assigna com A0, en què A és la drecera per descriure un dels pins analògics. Tanmateix, A0 també fa referència al pin 14, A1 al pin 15 i així successivament, i us permeten utilitzar-vos com a entrades / sortides digitals en cas que us quedeu sense pins per a un experiment. Però recordeu que no podeu utilitzar pins digitals com a pins analògics.
2. La línia: kPinPot presenta una nova funció interior a Arduino coneguda com mapa (). Aquesta característica es torna a calibrar d'un interval determinat a un altre, anomenat com mapa (valor, des de baix, des d’alt, fins a baix, fins a alt). Això pot esdevenir crucial ja que ledBrightness = map(sensorValue, 0, 1023, 0, 255) dóna un valor dins de l'interval de 0-1023, però analogWrite pot acceptar un valor de 0-255.

Podeu pensar que, atès que és possible controlar la brillantor d'un LED mitjançant una resistència canviant, simplement una olla hauria estat suficient per al propòsit, per què l'ús d'Arduino. Bé, de nou és només la base, per mostrar com es pot configurar un pot amb un Arduino.

No hi ha problemes, ara farem alguna cosa que no es pugui fer sense un Arduino.

En aquest experiment veurem com es pot utilitzar la resistència variable d'un pot per controlar la velocitat o la velocitat de parpelleig d'un LED.

Aquí teniu el programa:

analogueRead

3.2.3 Evitar el retard ()

El codi anterior es veu bé, però el LED no pot comprovar el valor del pot fins que no passa per cada cicle complet. Per a retards més llargs, aquest procés es fa més llarg, l'usuari ha d'esperar per veure la resposta del pot mentre el mou. Aquest retard es pot evitar amb una programació intel·ligent, de manera que permet a l'usuari comprovar el valor sense retards mínims. Aquí teniu el codi.

const int kPinPot = A0
const int kPinLed = 9
void setup()
{
pinMode(kPinLed, OUTPUT)
}
void loop()
{
int sensorValue
sensorValue = analogRead(kPinPot)
digitalWrite(kPinLed, HIGH)
delay(sensorValue)
digitalWrite(kPinLed, LOW)
delay(sensorValue)
}

Què hi ha de diferent al codi anterior? És la següent línia la que marca la diferència.

const int kPinPot = A0
const int kPinLed = 9
void setup()
{
pinMode(kPinLed, OUTPUT)
}
long lastTime = 0
int ledValue = LOW
void loop()
{
int sensorValue
sensorValue = analogRead(kPinPot)
if(millis() > lastTime + sensorValue){
if(ledValue == LOW){
ledValue = HIGH
}
else{
ledValue = LOW
}
lastTime = millis()
digitalWrite(kPinLed, ledValue)
}
}

Fins a aquesta secció, hem debatut sobre la variable int. Tanmateix, pot haver-hi molts més tipus de variables als quals pugueu accedir. La llista es pot llegir a continuació:

Actualment, només pot ser crucial saber-ho per emmagatzemar un nombre relativament gran per a int variable, podeu utilitzar el terme llarg o a llarga int.

Aquí podeu veure una altra funció interessant anomenada millis ().

Això produeix el període de temps en mil·lisegons que l'Arduino va treballar durant el seu funcionament des del principi (es restablirà a 0 després de cada 50 dies). Aquí torna molt perquè si tornava int , no es pot comptar per períodes llargs. Podríeu respondre exactament quant de temps? La resposta és de 32.767 segons.

Per tant, en lloc d’utilitzar delay (), comprovem si hi ha mil·lis () i, tan aviat com caduca el nombre particular de mil·lisegons, canviem el LED. En conseqüència, emmagatzemem l'última vegada que l'hem canviat la darrera vegada variable, de manera que ens permet comprovar-ho de nou sempre que ho desitgeu.

3.3 LED RGB

Fins ara hem jugat amb un LED de color únic. Tot i que el color del LED es pot canviar substituint el LED per un altre color, però, què us sembla si utilitzeu LED RGB per canviar els colors del LED sense canviar els LED?

Un LED RGB és bàsicament un LED que té un LED vermell, verd i blau incrustat i combinat en un únic LED. Té un cable comú que va al terra o al rail d’alimentació de 0 V mentre que els altres 3 cables s’alimenten amb senyals PWM positius diversificats per implementar els objectius previstos. barreja de colors .

Podeu connectar la configuració de la manera següent:

Pot semblar una mica complex, però en realitat és una rèplica del nostre anterior disseny de control LED mitjançant PWM.

Aquí teniu un codi de programa de pràctiques:

long lastTime = 0

Després de penjar aquest codi, només heu de veure com els ajustos del pot generen un efecte de llum interessant al RGB, pot ser una gran diversió.

Trobareu que quan es mouen els 3 testos les posicions màximes, en lloc d’un color blanc, veureu el vermell. Això es deu al fet que el color vermell és el més destacat entre els 3 colors i, per tant, domina en aquesta situació. Tanmateix, podeu experimentar amb la funció mapa () , abans d'executar-lo a la part vermella del LED, per tal de crear un equilibri més sensat.

Àudio amb Arduino

En aquesta secció aprendrem com afegir so i música bàsica a una configuració d’Arduino.

Veurem com canviar un senyal a un altaveu connectat amb la freqüència desitjada.

Per ser més precisos, s’intentarà una nota central A, que és una nota de freqüència de 440 Hz.

Per fer-ho, simplement tocarem una nota A del mig i optimitzarem el senyal d'ona sinusoïdal amb ona quadrada.

A més, calcularem el temps que un altaveu pot romandre activat demandant la fórmula:

timeDelay = 1 segon / 2 x freqüència de to.

timeDelay = 1 segon / 2 x 440

timeDelay = 1136 microsegons

4.1 Connectem la placa Arduino

4.2 Afegir una nota simple

Ja hem parlat sobre la funció retard() on la unitat es troba en mil·lisegons (segon / 1000), però trobareu una altra funció const int kPinPot1 = A0
const int kPinPot2 = A1
const int kPinPot3 = A2
const int kPinLed_R = 6
const int kPinLed_G = 10
const int kPinLed_B = 11
void setup()
{
pinMode(kPinLed_R, OUTPUT)
pinMode(kPinLed_G, OUTPUT)
pinMode(kPinLed_B, OUTPUT)
}
void loop()
{
int potValue
int ledValue
potValue = analogRead(kPinPot1)
ledValue = map(potValue, 0, 1023, 0, 255)
analogWrite(kPinLed_R, ledValue)
potValue = analogRead(kPinPot2)
ledValue = map(potValue, 0, 1023, 0, 255)
analogWrite(kPinLed_G, ledValue)
potValue = analogRead(kPinPot3)
ledValue = map(potValue, 0, 1023, 0, 255)
analogWrite(kPinLed_B, ledValue)
} on la unitat es troba en microsegons, (mil·lisegons / 1000).

Per a la configuració actual, programem un codi per canviar + 5V ON / OFF al pin seleccionat enllaçat amb l’altaveu, a una velocitat de 440 impulsos per segon.

Recordem, en l'última discussió vam determinar el valor de 1136 microsegons per a la nota d'àudio prevista.

Així doncs, aquí teniu el programa per a això, que us permetrà escoltar una nota d’àudio de 440 Hz tan bon punt programeu l’arduino amb un altaveu connectat.

delayMicroseconds()

Amb l'aplicació anterior es pot fer una nota d'àudio, cosa que també significa que podem crear una música segons la nostra pròpia elecció.

Del codi entenem que Arduino inclou un parell de funcions integrades que contribueixen addicionalment a la creació de música.

El primer és to () que funciona amb 2 elements juntament amb un 3r element opcional, designat com a to (pin, freqüència, durada). o bé to (pin, freqüència)

Tots dos estan designats per executar el període de temps assignat per vosaltres.

Si no hi ha un període de temps, la música continuarà sonant fins a la trucada to () es torna a executar o fins que executeu notone ().

Això s'haurà de fer mitjançant una funció de retard en cas que la reproducció de música sigui l'única cosa fonamental que esteu implementant.

La durada del temps pot ser crucial, ja que permet proporcionar un temps durant el temps que es reprodueix la música, de manera que podeu fer altres coses lliurement. Tan aviat com transcorri la durada, la música s’atura.

La següent funció noTone () gestiona un sol paràmetre i atura el to seleccionat en un pin assignat concret.

Una advertència peculiar: en qualsevol moment to () La funció PWM dels pins 3 i 11 deixarà d'operar.

Per tant, sempre que s’utilitzi un fitxer adjunt d’altaveu al programa, assegureu-vos de no fer servir el pin esmentat per als altaveus; en lloc d’això, proveu altres pins per al fitxer adjunt.

D'acord, doncs, aquí teniu el programa per implementar música en un altaveu, tot i que no és una música real, sinó una nota C a escala bàsica.

const int kPinSpeaker = 9
const int k_timeDelay = 1136
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
digitalWrite(kPinSpeaker, HIGH)
delayMicroseconds(k_timeDelay)
digitalWrite(kPinSpeaker, LOW)
delayMicroseconds(k_timeDelay)
}

Al codi anterior és possible que hagueu notat alguna cosa nova i això és així #define .

Aquest terme funciona com una ordre de cerca i substitució de l'ordinador mentre es realitza la compilació.

Sempre que troba el primer que hi ha abans d’un espai, el reemplaça per la part restant de la línia (anomenades macros).

Així doncs, dins d’aquest exemple quan l’ordinador ho veu NOTA_E4 la substitueix ràpidament per la quantitat 330.

Per obtenir més notes i personalització, podeu consultar un fitxer de la vostra memòria USB anomenat parcel·les.h , on es poden trobar la majoria de freqüències segons les vostres preferències.

4.4 Música amb funcions

El codi anterior es veu bé, però sembla que té moltes repeticions, hi hauria d’haver algun mètode per escurçar aquestes repeticions, oi?

Fins ara hem treballat amb dues funcions essencials incloses amb Arduino. Ara potser és hora que creem les nostres pròpies funcions.

Cada funció ha de començar amb el tipus de variable amb què es pugui associar. Per exemple, la funció buit fa referència a un tipus que no retorna res, d’aquí el nom buit. Tingueu en compte que ja hem comentat una llista de variables a les nostres seccions anteriors; és possible que vulgueu consultar-les.

En conseqüència, el nom de la funció particular obté un parèntesi obert '(' seguit d'una llista de paràmetres separats per comes.

Cadascun dels paràmetres adquireix el seu tipus juntament amb un nom i, finalment, un tancament ')' parèntesi.

Aquests paràmetres es poden aplicar dins de la funció en forma de variables.

Vegem un exemple a continuació on desenvolupem una funció anomenada ourTone () dissenyat per combinar el fitxer to () amb retard() línies, de manera que la funció deixi de tornar fins que la nota hagi acabat de reproduir el to.

Implementem aquestes funcions al nostre codi anterior i obtenim el programa següent, vegeu les darreres línies:

#define NOTE_C4 262
#define NOTE_D4 294
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_G4 392
#define NOTE_A4 440
#define NOTE_B4 494
#define NOTE_C5 523
const int kPinSpeaker = 9
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
tone(kPinSpeaker, NOTE_C4, 500)
delay(500)
tone(kPinSpeaker, NOTE_D4, 500)
delay(500)
tone(kPinSpeaker, NOTE_E4, 500)
delay(500)
tone(kPinSpeaker, NOTE_F4, 500)
delay(500)
tone(kPinSpeaker, NOTE_G4, 500)
delay(500)
tone(kPinSpeaker, NOTE_A4, 500)
delay(500)
tone(kPinSpeaker, NOTE_B4, 500)
delay(500)
tone(kPinSpeaker, NOTE_C5, 500)
delay(500)
noTone(kPinSpeaker)
delay(2000)
}

Les funcions poden ser molt útils per facilitar la comprensió d’un programa.

El següent és un exemple en el qual podem especificar l’elecció del to que volem reproduir mitjançant dues matrius. Una matriu per conservar les notes, l’altra per conservar els temps.

#define NOTE_C4 262
#define NOTE_D4 294
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_G4 392
#define NOTE_A4 440
#define NOTE_B4 494
#define NOTE_C5 523
const int kPinSpeaker = 9
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
tone(kPinSpeaker, NOTE_C4, 500)
delay(500)
tone(kPinSpeaker, NOTE_D4, 500)
delay(500)
tone(kPinSpeaker, NOTE_E4, 500)
delay(500)
tone(kPinSpeaker, NOTE_F4, 500)
delay(500)
tone(kPinSpeaker, NOTE_G4, 500)
delay(500)
tone(kPinSpeaker, NOTE_A4, 500)
delay(500)
tone(kPinSpeaker, NOTE_B4, 500)
delay(500)
tone(kPinSpeaker, NOTE_C5, 500)
delay(500)
noTone(kPinSpeaker)
delay(2000)
}
void ourTone(int freq, int duration)
{
tone(kPinSpeaker, freq, duration)
delay(duration)
}

Podeu veure clarament a la primera línia la introducció de #incloure declaració. El treball d'aquesta declaració és recollir tot el fitxer entre les cometes i col·locar-lo a la posició del fitxer #incloure declaració. Segons les normes estàndard, aquestes es col·loquen estrictament al començament del programa.

Capítol 5

Mesurament de la temperatura

Només per recordar, recordeu en lloc d’escriure programes grans, sempre és aconsellable escriure i analitzar petites parts de codis, cosa que ajuda a localitzar els errors ràpidament.

5.1 Monitor de sèrie

Fins ara, els codis que hem comentat no semblen més fàcils de permetre la resolució ràpida de problemes. Aquí intentarem facilitar les coses per controlar i resoldre més fàcilment un possible problema.

L'Arduino té una característica que li permet 'parlar' amb l'ordinador. Es pot observar que pin0 i pin1 estan marcats com a RX i TX un al costat de l’altre. Aquests pins són realment rastrejats per un CI independent d’Arduino que els actualitza per llegir-los a través del cable USB mentre està connectat al PC.

A la secció següent es mostra un programa complet, si us plau, aneu a conèixer les noves entrades del codi més endavant. Aquest codi és el mateix que s'expressa a la secció 2.2, excepte el fet que inclou algunes dades addicionals que ens permeten identificar per a què s'ha codificat.

#include 'pitches.h'
int kPinSpeaker = 9
#define NUM_NOTES 15
const int notes[NUM_NOTES] = // a 0 represents a rest
{
NOTE_C4, NOTE_C4, NOTE_G4, NOTE_G4,
NOTE_A4, NOTE_A4, NOTE_G4, NOTE_F4,
NOTE_F4, NOTE_E4, NOTE_E4, NOTE_D4,
NOTE_D4, NOTE_C4, 0
}
const int beats[NUM_NOTES] = {
1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 2, 4 }
const int beat_length = 300
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
for (int i = 0 i if (notes[i] == 0) {
delay(beats[i] * beat_length) // rest
}
else {
ourTone(notes[i], beats[i] * beat_length)
}
// pause between notes
noTone(kPinSpeaker)
delay(beat_length / 2)
}
}
void ourTone(int freq, int duration)
{
tone(kPinSpeaker, freq, duration)
delay(duration)
}

Aquí podeu identificar dues coses noves, una nova línia a setup () funció.

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
Serial.begin(9600)
}
int delayTime = 1000
void loop()
{
delayTime = delayTime - 100
if(delayTime <= 0){ // If it would have been zero or less, reset it.
delayTime = 1000
}
Serial.print('delayTime = ')
Serial.println(delayTime)
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}

Aquesta línia simplement expressa la necessitat d'utilitzar el fitxer Sèrie1 codi per aplicar-lo amb 9600 baud. (aquí fa referència a la sèrie bits enviat un darrere l’altre i baud significa la velocitat amb què s’envia). Aquest valor en bauds i el que hi ha dins del monitor sèrie (ho sabrem més endavant) han de ser iguals, en cas contrari les dades del monitor sèrie mostraran escombraries. Ser el 9600 estàndard es fa més còmode d’utilitzar.

La segona entrada nova és la següent

Serial.begin(9600)

Aquí la segona línia suggereix que el següent que surti del port sèrie començarà a la següent línia. Així és com la segona línia és diferent de la línia de puny.

Una cosa més que podeu veure són les cometes ('). Això es coneix com una cadena, que aquí només s’utilitzarà com a constant, perquè més discussió sobre aquest tema pot ser massa elaborada i fora d’abast.

D'acord, ara podem carregar el codi anterior a Arduino i veure què passa.

Sembla que no ha passat res, el LED del pin Arduino # 13 parpellejava i s’aturava, mentre que el LED Tx seguia parpellejant.

Bé, això es deu al fet que la finestra del monitor sèrie encara no està fixada.

Heu de fer clic al quadre Monitor serial del vostre IDE, tal com es mostra més amunt. No oblideu comprovar la velocitat de transmissió situada a la part inferior dreta, per defecte hauria de ser 9600 i coincidirà amb el codi. Si no és així, assegureu-vos de seleccionar 9600.

El següent videoclip explica com es fa.

Ara anem endavant i aprenem com la funció de monitor serial anterior pot ajudar a processar el fitxer mesurament de la temperatura mitjançant Arduino

Utilitzarem l’IC TMP36 com a sensor de temperatura, amb un abast de -40 a 150 graus centígrads.

La configuració es pot veure a continuació:

El següent codi iniciarà la mesura de la temperatura llegint la sortida del sensor TMP36 i enviant-les al monitor sèrie de l'ID.

Serial.print('delayTime = ')
Serial.println(delayTime)

Anem a entendre el codi des de la part superior.

const int kPinTemp = A0
void setup()
{
Serial.begin(9600)
}
void loop()
{
float temperatureC = getTemperatureC()
Serial.print(temperatureC)
Serial.println(' degrees C')
// now convert to Fahrenheit
float temperatureF = convertToF(temperatureC)
Serial.print(temperatureF)
Serial.println(' degrees F')
delay(500)
}
float getTemperatureC()
{
int reading = analogRead(kPinTemp)
float voltage = (reading * 5.0) / 1024
// convert from 10 mv per degree with 500mV offset
// to degrees ((voltage - 500mV) * 100)
return (voltage - 0.5) * 100
}
float convertToF(float temperatureC)
{
return (temperatureC * 9.0 / 5.0) + 32.0
}

Aquí podeu veure que hem inclòs el tipus de variable surar.

Aquest és l'únic tipus de variable que inclou emmagatzemar tot excepte els nombres enters (nombres sense parts decimals ni fraccionades).

La precisió d'una variable flotant pot ser de fins a 6 a 7 dígits.

El codi adjunt float temperatureC = getTemperatureC() és la nostra pròpia funció que calcula i converteix matemàticament la diferència de tensió detectada del sensor TMP36 en graus Celsius.

getTemperatureC()

A la següent secció dels codis, des del terme float getTemperatureC()
{
int reading = analogRead(kPinTemp)
float voltage = (reading * 5.0) / 1024
// convert from 10 mv per degree with 500mV offset
// to degrees ((voltage - 500mV) * 100)
return (voltage - 0.5) * 100
} s’assigna retornar una xifra entre l’1 i el 1023, ens pot ser possible avaluar la tensió del sensor multiplicant la nostra lectura per 5 i dividint-la per 1024.

El sensor TMP36 s’especifica per generar 0,5V a 0 graus centígrads i, posteriorment, genera 10mV per cada augment de grau centígrad.

Aquí teniu l’aproximació que podem generar mitjançant els càlculs:

Podeu considerar que és la vostra primera funció que retorna un cert valor (tingueu en compte que totes les funcions restants fins ara no van retornar cap valor ja que han estat del tipus buit ).

Podeu entendre que, per obtenir un valor d’una funció, només cal que afegiu tornar seguit del número desitjat que voleu tornar.

Quan diem tornar vol dir que la funció retorna una resposta o una resposta sempre que es crida, que es podria aplicar a una variable.

Quan s’envia al monitor de sèrie, la lectura es converteix a Fahrenheit convertToF ().

analogIn()

Aquesta funció recull el rang Celsius i el converteix en Fahrenheit.

Per convertir Fahrenheit a Celsius, implementem la fórmula Fahrenheit = 9 / 5 (centígrads) + 32.

5.3 Interfície d'una pantalla LCD

Ara estudiarem com connectar o connectar un fitxer Pantalla LCD amb Arduino per obtenir visualització visual de les sortides necessàries.

A la nostra aplicació utilitzarem un LCD gràfic de 84x48, amb 84 píxels o punts horitzontalment i 48 píxels de resolució vertical. Com que un controlador dedicat es fa imprescindible per a totes les pantalles LCD, el dispositiu actual també incorpora un controlador en forma de controlador PCD8544.

En aquest tutorial connectarem el mòdul LCD especificat anteriorment amb Arduino i aplicarem determinades rutines per crear missatges de text a la pantalla.

A la figura següent podeu trobar detalls sobre la interfície de la pantalla LCD, juntament amb una petita Regulador de voltatge de 3,3V . Aquest regulador és necessari ja que la pantalla LCD està especificada per funcionar amb un subministrament de 3,3 V.

També podeu veure 8 pinouts del mòdul LCD; les especificacions de pinout es poden estudiar a la taula següent:

Ara anem a veure com podem connectar la pantalla LCD i els paràmetres rellevants amb el nostre Arduino. Els detalls es poden visualitzar a la següent il·lustració:

5.4 Comunicació a la pantalla LCD

Tot i que és possible escriure coedits elaborats per interactuar amb LCD d'Arduino, més aviat aprendrem a fer el mateix mitjançant les biblioteques.

Les biblioteques inclouen un assortiment de codis que es poden aplicar ràpidament per a un programa Arduino seleccionat.

Això permet a l'usuari trucar a una funció sense esforç sense haver de passar per un treball de codificació complex.

5.4.1 Com instal·lar la biblioteca

Per a això, haureu de crear un directori anomenat biblioteques al vostre equip Arduino IDE, tal com s’explica aquí

5.4.2 Implementació de les operacions LCD

Igual que el nostre enfocament anterior, primer comprovarem tot el codi i després intentarem comprendre els detalls de les línies individuals.

float convertToF(float temperatureC)
{
return (temperatureC * 9.0 / 5.0) + 32.0
}

La línia inclou el codi #include
const int kPin_CLK = 5
const int kPin_DIN = 6
const int kPin_DC = 7
const int kPin_RESET = 8
PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)
void setup()
{
lcd.init()
lcd.setCursor(0,0)
lcd.print('Hello, World!')
}
void loop()
{
lcd.setCursor(0,1)
lcd.print(millis())
}

El codi #include indica al PC que reculli el fitxer esmentat i substituïsca l'element #include pel contingut del fitxer durant la compilació del programa.

L'element #include pot incloure claudàtors que indiquen la cerca al directori de la biblioteca, o bé també pot contenir cometes que indiquen la cerca dins del mateix directori on es troba el programa.

Les següents línies de codi expressen els pinouts LCD i, a continuació, escrivim una nova forma de variable:

#include

Aquí expressem una variable amb el nom lcd que té el tipus PCD8544 i donem instruccions al PC per a la degradació dels seus pinouts associats a l'Arduino.

En aquest procés, descrivim la variable al PC indicant com s’interfacen els pin clk, din, dc i reset amb l’Arduino.

PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)

La línia void setup()
{
lcd.init()
lcd.setCursor(0,0)
lcd.print('Hello, World!')
} inicialitza l'operació LCD. Un cop executat, la següent línia aplica un cursor a la part superior esquerra de la pantalla. I la següent línia següent fa un esforç per imprimir el missatge 'Hola, món'.

Sembla bastant idèntic a la tècnica en què vam enviar missatges a través del monitor sèrie. L'única diferència és l'ús del codi lcd.init() en lloc de serial.print.

El següent bloc de codi s’anomena de manera repetitiva.

lcd.print

Utilitzant aquesta línia void loop()
{
lcd.setCursor(0,1)
lcd.print(millis())
} fixem el cursor a la 0a columna a l'extrem esquerre de la primera fila, sobre la pantalla LCD.

La següent línia utilitza una drecera: lcd.setCursor(0,1)

Si recordeu, hem treballat amb lcd.print(millis()) en els nostres codis anteriors, podríem haver aplicat el mateix aquí també mitjançant els codis:

millis()

Tanmateix, pel fet que aquí no hi ha intervals de temps en mil·lisegons, per tant ho aconseguim simplement enviant long numMillis = millis()
lcd.print(numMillis) funciona directament a millis() .

5.5 Combinació de la cosa sencera

D’acord, ara combinem tots els codis que hem après anteriorment per fer el circuit de temperatura de la pantalla LCD i veiem com queda:

lcd.print()

Tot sembla normal al programa anterior, excepte l'ús de la funció setCursor () . S'utilitza per alinear el text al màxim al voltant del centre de la pantalla.

Genial! I felicitacions, acabeu de programar el vostre propi petit indicador de temperatura LCD mitjançant Arduino.

Aplicacions pràctiques d'Arduino

Atès que, en aquest moment, hem tractat de manera exhaustiva les diverses tècniques de programació, és hora de comprovar-les aplicant-les per a algunes implementacions pràctiques útils.

Començarem per sensors i veurem com es podrien utilitzar dispositius sensorials amb Arduino executant uns quants codis de mostra.

7.1 Introducció als sensors

En aquest tutorial aprendrem sobre l’àmplia varietat de sensors que es podrien utilitzar amb Arduino. Aquests poden incloure dispositius com el sensor de llum LDR, el sensor d’efecte magnètic, els sensors d’inclinació, el sensor de vibracions, el sensor de pressió, etc.

Començarem per la interfície de sensor de llum LDR amb Arduino, com es mostra en el següent esquema:

Com tots sabem, LDR és un dispositiu de resistència dependent de la llum la resistència del qual depèn de la intensitat de l’incident ambiental a la seva superfície.

La intensitat de la llum és inversament proporcional a la lectura de resistència del LDR.

Aquí aprendrem com es pot integrar aquesta propietat amb Arduino per executar una aplicació útil:

El codi del programa complet es pot visualitzar tal i com es mostra a continuació:

#include
const int kPin_CLK = 5
const int kPin_DIN = 6
const int kPin_DC = 7
const int kPin_RESET = 8
const int kPin_Temp = A0
PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)
void setup()
{
lcd.init()
lcd.setCursor(10,0)
lcd.print('Temperature:')
}
void loop()
{
float temperatureC = getTemperatureC()
// now convert to Fahrenheit
float temperatureF = convertToF(temperatureC)
lcd.setCursor(21,1)
lcd.print(temperatureC)
lcd.print(' C')
lcd.setCursor(21,2)
lcd.print(temperatureF)
lcd.print(' F')
delay(100)
}
float getTemperatureC()
{
int reading = analogRead(kPin_Temp)
float voltage = (reading * 5.0) / 1024
// convert from 10 mv per degree with 500mV offset
// to degrees ((voltage - 500mV) * 100)
return (voltage - 0.5) * 100
}
float convertToF(float temperatureC)
{
return (temperatureC * 9.0 / 5.0) + 32.0
}

Tots els paràmetres que s’utilitzen al codi ja s’han comentat al curs que hem après fins ara. Podeu consultar les línies fent referència a les seccions corresponents.

Els valors s'han escollit a l'atzar, podeu canviar-los fàcilment segons les vostres preferències.

Sensor d’inclinació

Un sensor d’inclinació és un dispositiu senzill que es pot utilitzar per detectar una acció d’inclinació sobre qualsevol objecte on estigui instal·lat. El dispositiu té bàsicament una bola metàl·lica a l'interior, que en inclinar-se fa rodar un parell de contactes provocant una conducció a través d'aquests contactes. Aquests contactes que s’acaben com a cables del commutador d’inclinació, s’utilitzen amb un circuit extern per detectar la conducció a causa d’una acció d’inclinació i activar l’aplicació de sortida desitjada.

Ara anem a veure com sensor d’inclinació es podria connectar el dispositiu. La imatge següent ens dóna una idea de la configuració completa:

const int kPin_Photocell = A0
void setup()
{
Serial.begin(9600)
}
void loop()
{
int value = analogRead(kPin_Photocell)
Serial.print('Analog Reading = ')
Serial.print(value)
if(value <200){
Serial.println(' - Dark')
}else if(value <400){
Serial.println(' - Dim')
}
else if(value <600){
Serial.println(' - Light')
}
else if(value <800){
Serial.println(' - Bright')
}
else{
Serial.println(' - Very Bright')
}
delay(1000)
}

En aquest exemple, el pin predeterminat # 13 LED s'utilitza com a indicador d'inclinació.

Aquí podeu veure clarament la inclusió de la resistència de tracció, bastant similar a la que vam fer a la secció 3.1. Per tant, el terme BAIX indica que la funció d’inclinació no s’activa.

7.4 Reed Switch Relay (relé activat per imant en miniatura)

Ara anem a veure com connectar un commutador de relé o un sensor de camp magnètic amb Arduino. Un relé de canya és una mena d’interruptor que s’activa o condueix quan s’hi acosta un camp magnètic o un imant. Bàsicament, té un parell de contactes ferromagnètics dins d’un recinte de vidre en miniatura que s’uneixen o es posen en contacte a causa de la tracció magnètica sempre que un magnètic estigui a prop seu. Quan això passa, els terminals dels contactes mostren conducció a causa del tancament dels contactes.

També aquí fem servir el pin número 13 LED per indicar la resposta. Podeu connectar un LED extern des d'aquest pin si es requereix segons les nostres explicacions anteriors.

const int kPin_Tilt = 3
const int kPin_LED = 13
void setup()
{
pinMode(kPin_Tilt, INPUT)
digitalWrite(kPin_Tilt, HIGH) // turn on built-in pull-up resistor
pinMode(kPin_LED, OUTPUT)
}
void loop()
{
if(digitalRead(kPin_Tilt) == HIGH){
digitalWrite(kPin_LED, LOW)
}
else{
digitalWrite(kPin_LED, HIGH)
}
}

Els termes del codi han de ser familiars i autoexplicatius.

7.5 Sensor de vibració mitjançant transductor piezoelèctric

Al següent programa de mostra veurem com transductor piezoelèctric es pot utilitzar com a sensor de vibració per il·luminar un LED mitjançant Arduino.

Un element piezo realment és un dispositiu que genera vibracions o oscil·lacions quan s’aplica una freqüència a través dels seus terminals. Tanmateix, es podria utilitzar el mateix piezo en el procés invers per a generant polsos elèctrics en resposta a les vibracions aplicades al seu cos. Aquesta vibració es podria produir en forma de cop o cop a la superfície del piezo.

Configureu l'Arduino i un element piezo tal com es mostra a la figura següent

const int kPinReedSwitch = 2
const int kPinLed = 13
void setup()
pinMode(kPinReedSwitch, INPUT)
digitalWrite(kPinReedSwitch, HIGH) // turn on pullup resistor
pinMode(kPinLed, OUTPUT)
}
void loop()
{
if(digitalRead(kPinReedSwitch) == LOW){
digitalWrite(kPinLed, HIGH)
}
else{
digitalWrite(kPinLed, LOW)
}
}

El llindar 100 s’introdueix només per assegurar-se que l’Arduino només respon a les vibracions genuïnes mitjançant cops, i no a altres vibracions més petites, com ara els sons forts o les trompes.

La selecció del pin A5 no és obligatòria, podeu seleccionar qualsevol altra entrada analògica segons la vostra preferència i coincidint-la al codi del programa.

Utilització del Servo Motor amb Arduino

Un servomotor és un tipus de motor de corrent continu que es pot girar amb angles precisos segons la demanda d'una aplicació particular. Es pot fer aplicant un ordre calculat a les entrades rellevants del motor per produir un angle de rotació o gir precís dins del rang de 180 graus del motor.

Normalment un servomotor té 3 cables o entrades. Els cables positius són normalment de color vermell, el negatiu o de terra és negre, el cable de comandament o el de senyalització normalment és de color blanc o groc.

Arduino facilita el control del servomotor mitjançant un llenguatge de suport integrat que fa que el control sigui molt convenient i ideal per als servomotors.

L'exemple següent ens mostrarà el programa bàsic de configuració per implementar el control de servomotors a través d'Arduino:

El codi es dóna a continuació:

const int kPinSensor = A5
const int kPinLed = 13
const int k_threshold = 100
int ledState = LOW // variable used to store the last LED status, to toggle the light
void setup()
{
pinMode(kPinLed, OUTPUT) // declare the ledPin as as OUTPUT
}
void loop()
{
int val = analogRead(kPinSensor)
if (val >= k_threshold) {
ledState = !ledState // toggle the value of ledState
digitalWrite(kPinLed, ledState)
delay(20) // for debouncing
}
}

Aquí podem veure un parell de noves entrades. Un que indica el cable adjunt del servo a quin pin està assignat. L'altre és el codi que proporciona al pin un valor entre 0 i 180, per determinar l'angle de rotació del servo.

Conclusió

El tema Arduino pot ser infinitament llarg i, per tant, fora de l’abast d’aquest article. Tot i això, espero que el tutorial anterior us hagi ajudat a aprendre els conceptes bàsics d’Arduino i a entendre paràmetres importants a través dels diversos exemples de codis d’aplicació.

Esperem que es pugui actualitzar més informació de tant en tant aquí, sempre que estigui disponible.

Mentrestant, gaudiu del vostre curs de programació, Happy Arduinoing to you !!