En el meu interès per aconseguir instrumentació assequible per a la presa de dades en l’experimentació als laboratoris escolars he estat ocupat els últims mesos en les possibilitats dels dispositius mòbils, telèfons i tauletes intel·ligents. En la passada primavera vaig acabar una recopilació d’experiments a realitzar amb ells, i des de llavors he estat donant tombs a l’utilització d’Arduino per a completar el número de sensors dels que puguem disposar a baix cost, com és el cas del sensor de temperatura o de distància.

Si ja disposeu de dataloggers com el Multilog o similars pot ser no cal que us compliqueu la vida, però sinó, continueu llegint a veure si us animeu a fer algun muntatge dels que us proposaré. Crec que paga la pena fer-lo ja que és un sistema que te moltes possibilitats a un preu molt reduït.

He de començar dient que en microprocesadors i programació soc un autèntic principiant i que les solucions que oferiré seran les que he aconseguit que funcionin, encara que no siguin ni les més elegants, ni les més eficients, pot ser tot el contrari, però si teniu ganes ja les esmenareu. Així, les propostes que faré seran còpies i adaptacions del que ja han fet altres persones, que afortunadament és molt, ja que els nostres companys de Tecnologia fa uns quants anys que venen treballant amb Arduino.

De fet, va ser gràcies al fantàstic professor de Tecno i millor amic Pere Picoy que vaig iniciar-me en aquest mon amb un curs d’Arduino que ens va fer gratis i et amore fa un parell d’anys en el marc d’un seminari CTM (Ciències, Tecnologia, Matemàtiques) que teníem organitzat a Lleida. (Us enllaço al material del curs d’introducció a Arduino del Pere: Mòdul 1, Mòdul 2, Modul 3).

Per començar a treballar amb sensors i Arduino, en aquesta entrada mostraré com mesurar distàncies amb el sensor d’ultrasons HC-SR04, que és fàcil de connectar i que es pot fer servir sense llibreries. Pot utilitzar-se per portar a terme molts experiments de Física, per exemple, per a realitzar estudis com el de la pèrdua d’energia en el bot d’una pilota que ens proposaven al 2002 Aparicio i Lozano (protocol alumnat, material professorat) però usant el Multilog.

El sensor d’ultrasons

El sensor d’ultrasons HC-SR04 és un dispositiu per mesurar distàncies. El seu funcionament es basa en l’enviament d’un pols d’alta freqüència, no audible per l’ésser humà, que rebota en els objectes propers i és reflectit cap al sensor, que disposa d’un micròfon adequat per aquesta freqüència.

Característiques del sensor

• Dimensions del circuit: 43 x 20 x 17 mm
• Tensió d’alimentació: 5 Vcc
• Freqüència de treball: 40 KHz
• Distància màxima: 4 m
• Distancia mínima: 2 cm
• Angle de treball òptim: <15º
• Duració mínima del pols de disparo (nivell TTL): 10 μS.
• Duració del pols eco de sortida (nivell TTL): 100-25000 μS.
• Temps mínim de espera entre una mesura i l’inici d’una altra 20 mS.
• Pins de connexió: VCC (5 Vcc), Trig (Tret de l’ultrasò), Echo (Recepció de l’ultrasò) i GND (terra).

És un dispositiu molt fàcil d’aconseguir. Segur que els companys de Tecnologia us poden facilitar un d’aquestos sensors, així com la pròpia placa d’Arduino, però sinó tant a la botiga d’electrònica de la ciutat com, encara més, per internet el podeu comprar a partir de 2 €.

El sensor mesura el temps en microsegons entre l’enviament i la recepció d’un pols sonor (temps entre Trig i Echo). La velocitat del so és 343 m/s en condicions de temperatura 20 ºC, 50% d’humitat i a pressió atmosfèrica normal. Si transformem les unitats de la velocitat del so, resulta:

És a dir, el so triga 29,15 microsegons a recórrer un centímetre. Per tant, podem obtenir la distància a partir del temps entre l’emissió i recepció del pols mitjançant la següent equació:

El motiu de dividir per dos el temps és perquè es mesura el temps que triga el pols a anar i tornar, de manera que la distància recorreguda pel pols és el doble de la que es vol mesurar. A l’hora d’introduir aquesta equació en l’sketsh (programeta) d’Arduino s’ha d’indicar el valor 58.3 amb separació decimal punt, i no coma.

La placa Arduino

Arduino és una placa de circuit imprès basada en un microcontrolador de codi obert amb tots els elements necessaris per a connectar perifèrics a les seves entrades i sortides, dissenyada amb l’objectiu de fer més simple i accessible el disseny de circuits electrònics amb microcontroladors. Quan dic que és una placa no estic dient la veritat ja que d’aquest projecte han sortit multitud de plaques i amb diferents microcontroladors.

Jo utilitzo bàsicament dos, l’Aduino UNO R3, amb un processador ATmega, que és el que usarem ara, i el Wemos D1, amb un processador esp32, que ja veurem més endavant. L’Arduino UNO és una de les plaques més utilitzades per a fer muntatges a Tecnologia i segurament és la que us deixarien els companys.

Les característiques de la placa les podeu mirar amb deteniment a la web del projecte o a wikipedia. La placa funciona a 5 V, però com es veu en el dibuix, te dues connexions per subministrar-li electricitat, una negra per un jack a la que es poden connectar de 7 a 12 Vcc (per exemple una pila de 9 V), i una metàl·lica a la que es pot endollar un cable de impressora a 5Vcc (per exemple un carregador de mòbil) i que és la que s’utilitza per a connectar-se a l’ordinador.

A més, la placa Arduino te gran quantitat d’entrades analògiques i de sortides i entrades digitals, com es veu en l’esquema de sota, a les que es poden connectar sensors, motors, relés, etc., etc.

La connexió

El sensor d’ultrasons té quatre pins de connexió. Dos per subministrar-li corrent, el marcat amb VCC que s’ha de connectar a 5 V i el GNG que es connecta a terra, i altres dos per enviar l’ordre per al tret (Trig) i per a recollir la senyal de l’eco (Echo), que els he connectat a les entrades/sortides digitals 3 i 2, respectivament.

Els sensor es pot connectar directament a la placa Arduino mitjançant cables, però moltes vegades és més còmode el utilitzar una placa de proves (protoboard) on punxar el sensor i els cables. Hi ha plaques de proves de diferents mides i són també prou barates (a partir d’1 €). A sota hi són l’esquema i una fotografia del muntatge

El programari

Per a relacionar el ordinador amb la placa Arduino hi ha un programari d’accés lliure i codi obert anomenat IDE (Integrated Development Environment) d’Arduino que s’ha de descarregar de la web del projecte i instalar-lo com qualsevol programari. Hi és per a per Linux, per Mac i per Windows. En obrir el programa es disposa d’un editor on escriure el codi que es vulgui implementar i tota una sèrie de desplegables que permeten seleccionar el maquinari i les llibreries que es necessitin. També permet enviar el codi a la placa Arduino i visualitzar amb el Monitor sèrie la informació que retorna la placa.

Com es veu a la pantalla de dalt el codi mínim que ha de tenir un programa (sketch) en Arduino consta d’una primera part en la que se realitza la configuració inicial de variables, i una segona part en la que el codi es repeteix de forma indefinida. Abans del setup també es poden declarar variables o cridar a llibreries. No pretén ensenyar com es fa, així que passo a indicar el que es pot escriure com a programa per a mesurar distàncies en funció del temps, encara que he procurat explicar el significat de cada línia de codi que he escrit, iniciant cada comentari amb dues barres inclinades // de manera que el programa no les considera instruccions.

Podeu copiar i pegar el codi de sota o, alternativament, baixar de aquí l’sketch (Ultrasonido_distancia_con_tiempo.ino) en format d’Arduino i obrir-lo clicant sobre el. S’ha de descomprimir el zip conservant la carpeta i l’arxiu amb el mateix nom.

//Código para realizar medidas de distancia por ecos de ultrasonido en Arduino Uno
//Se obtienen los valores por el puerto serie del ordenador
//Los datos se pueden visualizar en el monitor serie del IDE de Arduino 
//y con el programa para ordenador RealTerm, https://sourceforge.net/projects/realterm/

//Sensor ultrasónico HC-SR04
//Conexiones: GND a Gnd, Vcc a +5V, Echo a pin 3, Trig a pin 2

const int TrigPin = 2;
const int EchoPin = 3;
float cm; //Se definen los cm como número con decimales
float tiempo; // Se define el tiempo como numero con decimales
float tiempoSegundos; // Se define el tiempo en segundos como número con decimales

void setup()
{
Serial.begin(9600); // Se inicia el monitor serie para mostrar el resultado
pinMode(TrigPin, OUTPUT);
pinMode(EchoPin, INPUT);
  tiempo = millis(); //mide el tiempo en milisegundos desde que se pone en marcha Arduino
}
void loop()
{
digitalWrite(TrigPin, LOW);  //para generar un pulso limpio ponemos a LOW 2μs     
delayMicroseconds(2);
digitalWrite(TrigPin, HIGH); //Genera un pulso ultrasónico...
delayMicroseconds(10); //...que dura 10 micro segundos
digitalWrite(TrigPin, LOW);

cm = pulseIn(EchoPin, HIGH) / 58.3; //Se mide el tiempo en microsegundos que tarda el eco y se transforma en distancia en cm, dividiendo por 58,3

tiempo = millis(); //Actualiza el tiempo actual
tiempoSegundos = tiempo/1000; //cambia los milisegundos a segundos
Serial.print(tiempoSegundos,3); //Escribe el tiempo en segundos con tres decimales
Serial.print("; ");
//Serial.print("s"); //Añade s, de segundos, al valor numérico. Mejor no ponerlo si se quieren tratar después los datos

Serial.print(cm,2); //Escribe la distancia en cm con dos decimales
Serial.println();
//Serial.print("cm"); //Añade cm al valor numérico. Mejor no ponerlo si se quieren tratar después los datos

delay(100); //Tiempo de espera entre medidas, en milisegundos
}

Una vegada carregat el programa a l’IDE es connecta la placa Arduino a l’ordinador a través d’un cable d’impresora i es selecciona en Herramientas/Placa, la placa Arduino/Genuino UNO. A continuació es selecciona el port al que està connectada la placa en Herramientas/Puerto i ja està llesta la placa Arduino per a rebre l’sketch.

Es clica sobre la icona de la fletxa cap a la dreta i l’IDE comprova que el programa no tingui errors i que la placa connectada correspongui a la que se li ha dit, i comença a carregar l’sketch. Si tot va bé indica que l’ha pujat i ja estem en condicions de veure si el sensor està mesurant distàncies. Per fer aixó només s’ha de pitjar en la icona de la lupa i s’obrirà una finestra en la que es visualitzaran les dades. Si no es veuen s’ha de comprovar que la velocitat sigui de 9600 baudis, que és la que s’ha introduït al codi.

El programa indica per defecte que es prenguin unes 8 mesures per segon (delay(100);). Si es vol més velocitat en la presa de mesures es pot canviar el valor, per exemple a delay(50), però no s’ha de baixar de 20 mil·lisegons.

La mesura de distàncies

La primera columna que apareix en el Monitor sèrie correspon al temps des de que es fica en marxa el programari, mesurat en segons amb tres decimals. La segona columna és la de la distància en cm amb dos decimals. La notació decimal és el punt, que és la que utilitzen els anglosaxons, i encara que es pot canviar a la coma per programari, és un lio, així que si convé es substitueix després. Els valors estan separats per punt i coma per tal de no interferir amb la notació decimal.

Si en un moment donat es desconnecta l’Arduino de l’ordinador es deixen de rebre dades i es possible seleccionar amb el ratolí les dades del monitor sèrie i copiar-les a un full de càlcul o a un programa específic de tractament gràfic de dades, com SciDavis, i analitzar-les, però és un procediment una mica ortopèdic.

L’alternativa és utilitzar un altre programari com a monitor sèrie, com és RealTerm que és de codi obert i molt fàcil d’usar pels nostres interessos. S’instala el programa, s’obre i en la pestanya Port s’ha de canviar la velocitat a 9600 baudis i indicar el port al que està connectada la placa Arduino.

Després, en la pestanya Capture s’indica al programa on es volen guardar les dades i amb quin nom, i es prem el botó Start:Overwrite (sobreescriu el arxiu) o Start:Append (afegeig dades a l’arxiu) segons convingui. Per acabar la presa de dades es clica sobre el botó Stop Capture, i ja tenim les dades en format txt.

---