22 d’oct. 2016

Calibració del sensor de llum

La resposta del sensor de llum depén dels valors ambientals, que en cada lloc i en cada moment poden ser diferents.
Si volem que no sigui així, cal calibrar-lo, és a dir, donar-li uns valors màxim i mínim de referència.
Evidentment, cal calibrar el sensor abans d'executar qualsevol altra cosa en el programa.
Referència: web Arduino

Per a la nostra calibració utilitzarem un Led com indicador: s'encendrà en començar la calibració, i quan s'apagui indicarà que la calibració s'ha realitzat.




Programa de calibració
Es tracta que durant els primers 5 segons de l'execució del programa es llegirà el valor mínim i el valor màxim rebuts del sensor de llum i es desarà cada un en una variable.
Un LED actuarà com indicador de la calibració.


Les variables:

const int sensorPin = A0;    // pin de connexió del sensor
const int ledPin = 13;       // pin de connexió del Led

int sensorValor = 0;         // per desar el valor del sensor
int sensorMin = 1023;        // mínim valor llegit pel sensor
int sensorMax = 0;           // màxim valor llegit pel sensor


En aquest cas no podem utilitzar la instrucció delay, perquè aquesta atura l'execució.
Per establir que l'execució de la calibració s'ha de realitzar durant els primers 5 segons de l'execució, utilitzarem la instrucció millis(); que retorna el temps des del darrer reset de la placa.

El bucle l'establim amb while (mentre) el temps d'execució (millis) sigui menor que 5 segons.
Així doncs, el void setup quedarà:

void setup() 
{
  pinMode(ledPin, OUTPUT);  // configuració del pin digital de connexió del LED
  digitalWrite(ledPin, HIGH);   // encén el LED indicador de calibració

  while (millis() < 5000) // calibra durant els primers 5 segons  
  {
    sensorValor = analogRead(sensorPin);  

    if (sensorValor > sensorMax) 
    { sensorMax = sensorValor; } // registra el valor màxim del sensor
    if (sensorValor < sensorMin) 
    { sensorMin = sensorValor; } // registra el valor mínim del sensor
  }

  digitalWrite(ledPin, LOW); // indica el final de la calibració
}

Ara, ja podem definir al void loop les instruccions que ens interessin.

12 d’oct. 2016

Sensor de temperatura LM35


Aquest sensor de temperatura és un circuit integrat que retorna un valor de tensió directament proporcional a la temperatura a la que està sotmés.

El nostre és un LM35DZ. Segons el seu data sheet:
* Mesura la temperatura en graus centigraus.
* Funciona entre 0ºC i 100ºC
* Té un marge d'error de ± 1ºC (suficient precisió per als nostres projectes)

El pin central és el de senyal, es connecta a un pin analògic d'entrada.
Posant la cara plana mirant cap a nosaltres, el pin de l'esquerra és el d'alimentació (5V), i el de la dreta, GND.


Càlcul de la temperatura

El primer que cal és passar el valor llegit pel pin analògic (entre 0 per a 0V i 1023 per a 5V) al seu valor de tensió.
Com que els possibles valors llegits per un pin analògic són 1024, el valor en volts de la mesura serà: (5 / 1024) · lectura
I com que, segons el data sheet, la sortida de tensió és de 10 mV per a cada ºC (1V equival a 100ºC), la temperatura serà el valor en volts de la mesura · 100

Monitoritzem la temperatura
int sensor = A0 ;

void setup()
{
  Serial.begin(9600);
}

void loop()
{
  int lectura = analogRead(sensor);
  float tensio = 5.0 / 1024 * lectura; // float: variable de valor un nombre decimal
  float temp = tensio * 100;
  Serial.print ("temperatura = ");
  Serial.print (temp);
  Serial.println (" ºC");
  delay (100);
}

Què podem fer amb un sensor de temperatura?

* Encendre i apagar un LED en funció d'un valor llindar de temperatura.
* Alarma d'incendi: encendre LED si la temperatura està per sobre d'un llindar.
* Activar un o altre color d'un LED RGB si la temperatura està per sobre o per sota d'un llindar >>
* Encendre més o menys segments d'una barra de LEDs en funció de la temperatura.
* Posar en marxa un ventilador quan la temperatura pugi per sobre d'un llindar >>
* Mostrar els valors de la temperatura en una pantalla LCD >>
* Mostrar els valors de temperatura amb displays de 7 segments >>
* ...

13 de març 2016

Motor vibrador





Podem aconseguir-lo desmuntant un mòbil.
També podem comprar-lo aqui >>





Connexió a Arduino

Tot i els colors dels cables, no té polaritat´(cal comprovar-ho).

Funciona com un actuador digital:
Connectant-lo a un pin digital podem fer-lo vibrar / no vibrar.
Connectant-lo a un pin PWM podem ajustar la velocitat de vibració.

Com que funciona a 3V i Arduino proporciona 5V, cal una resistència de protecció de 220 .

Fem vibrar el motor

Amb la instrucció digitalRead (pin,HIGH); el farem vibrar.
Amb la instrucció digitalRead (pin,LOW); farem que deixi de vibrar.
Utilitzeu el programa d'exemple Blink i ajusteu els temps de vibració / no vibració.


Ajust de la intensitat de la vibració

Utilitzant la tècnica PWM podem ajustar els polsos pel pin de connexió amb valors entre 0 i 255.
La intensitat de la vibració serà proporcional a aquest valor.
Recordeu els nostres aprenentatges sobre sortides analògiques >>


Vibració com a resposta a la detecció

Podem provar afegint un polsador al circuit:


I fer que la vibració es produeixi en prèmer el polsador:



14 de febr. 2016

Joystick



El joystick és un comandament capaç de girar 360 graus i de retornar la posició en la que es trova.
Si li treiem el caputxó veurem que està format per dos potenciòmetres i un polsador. 
Amb un dels potenciòmetres (VRx) podem mesurar la posició en l'eix X, i amb l'altre (VRy) la posició en l'eix Y. La sotida SW correspón al polsador.
El nostre joystick l'hem comprat aqui >>
Tutorial Sparkfun >>


Connexió a Arduino
Els potenciòmetres (VRx - VRy) es connecten cada un a un pin analògic, i el polsador (SW) si el volem utilitzar, a un pin digital.



Exemple 1. Mostrar els valors pel monitor sèrie

Valors amb que treballem
const int Eix_X = A0;  // pin de connexió potenciòmetre eix X
const int Eix_Y = A1;  // pin de connexió potenciòmetre eix Y
const int Boto = 8;    // pin de connexió polsador
Configuració
void setup() 
{
  pinMode (Boto,INPUT_PULLUP);  // el botó és una entrada digital*
  Serial.begin(9600);    // inici de la comunicació sèrie
}
Definició de les accions
void loop() 
{
  Serial.print ("X = ");
  Serial.println (analogRead(Eix_X));  // lectura analògica pin A0

  Serial.print ("Y = ");
  Serial.println (analogRead(Eix_Y));  // lectura analògica pin A1

  Serial.print ("Estat Botó = ");
  Serial.println (digitalRead(Boto));  // lectura digital pin 2
  
  delay (100);  // pausa per comoditat de lectura
}
* El botó del joystick s'ha definit com a INPUT_PULLUP en comptes de INPUT perquè així no cal connectar una resistència, Arduino connecta un pullup internament.
La lectura és 0 quan premem el botó, i 1 quan no el premem.

Exemple 2. Encesa de LEDs
.


Exemple 3. Control de servos
#include <Servo.h>     // llibreria per treballar amb servos

const int Eix_X = A0;  // pin de connexió potenciòmetre eix X
const int Eix_Y = A1;  // pin de connexió potenciòmetre eix Y

Servo ServoX;         // asignem l'eix X a un servo       
Servo ServoY;         // assignem l'eix Y a l'altre servo      

int JoystickVal;  // variable per llegir el valor del pin analògic
int ServoVal;     // variable per assignar la posició del servo

void setup()
{
  ServoX.attach(9);    // servo connectat al pin 9
  ServoY.attach(10);   // servo connectat al pin 10
  Serial.begin(9600);  // per monitoritzar
}

void loop()
{
  // ---------- Control Servo X ----------
  // lectura de la posició del joystick en X:
  JoystickVal = analogRead(Eix_X); 
  // transforma el valor llegit en un valor dins del rang de moviment del servo: 
  ServoVal = map (JoystickVal, 0, 1023, 0, 180);  
  // Mou el servo a la posició corresponent:
  ServoX.write (ServoVal);  

  // ---------- Control Servo Y ----------
  // lectura de la posició del joystick en Y:
  JoystickVal = analogRead(Eix_Y); 
  // transforma el valor llegit en un valor dins del rang de moviment del servo: 
  ServoVal = map (JoystickVal, 0, 1023, 0, 180);  
  // Mou el servo a la posició corresponent:
  ServoY.write (ServoVal); 

  delay (20); // temps per moure els servos abans d'una nova lectura
}

21 de gen. 2016

Servos de rotació contínua

Els servos de rotació contínua giren mentre rebin polsos PWM.

Com que la llibreria Servo que cal utilitzar inhabilita l'ús dels pins 9 i 10 com a sortides analògiques, proposo connectar els servos a aquests pins (9, 10).

Els senyals Servo són trens de polsos PWM (senyals 0-1 de període 20 ms). L'amplada del pols (temps durant el qual està actiu, a 5V) determina el sentit de gir i la velocitat del servo.



Referències del llenguatge:
Per tal de treballar amb servos cal incloure al programa la llibreria Servo.
L'ample dels polsos es defineix amb la instrucció write() o writeMicroseconds()
Les instruccions attach() i detach() permeten associar i deixar d'associar els senyals Servo als pins especificats.

Si utilitzem la instrucció write:
180: sentit horari (?), velocitat màxima
190: aturat
180: sentit antihorari (?), velocitat màxima

Si utilitzem la instrucció writeMicroseconds():
1300: sentit horari, velocitat màxima
1500: aturat
1700: sentit antihorari, velocitat màxima
* les dades corresponen als servos Parallax. Per a altres, cal consultar el datasheet.

Control de la velocitat:
Velocitats intermitges es poden aconseguir aplicant polsos d'amplades intermitges: entre 0 i 90 en un sentit de gir, i entre 90 i 180 en l'altre.
Cal tenir en compte però que la relació velocitat/amplada del pols no és lineal.

Exemple:
Gir d'un servo durant un temps en un sentit a velocitat intermitja, aturada durant un temps, gir en l'altre sentit durant el mateix temps amb la mateixa velocitat:

#include <Servo.h>  // llibreria que cal incloure per treballar amb servos

Servo Servo1;  // creació de l'objecte Servo amb el nom que vulgui
int temps = 100;  // temps durant el qual ha de girar el servo

void setup() 
{ 
  Servo1.attach(9);  // servo connectat al pin 9void loop() 
{
  // gir a velocitat mitja (90+30) en un sentit durant un temps determinat:
  Servo1.write(120);  
  delay(temps);
  // servo aturat durant un temps:
  Servo1.write(90);  
  delay(temps);
  // gir a velocitat mitja (90-30) en l'altre sentit durant el mateix temps:
  Servo1.write(60);  
  delay(temps);
}

Calibració:
Si en posició d'aturada el servo no s'atura del tot cal calibrar-lo ajustant el seu potenciòmetre.

Ajust de velocitat (sincronitzar dos servos)
Si un robot no va recte es que els servos no giren a la mateixa velocitat. Si no podem calibrar els dos posant el potenciòmetre intern en la mateixa posició, podem reduir la velocitat del servo que gira més ràpid.
Podem crear un valor d'ajust que se sumi a la velocitat del servo més ràpid per igualar-lo a l'altre:

int ajuste = 5; // valor a modificar
servo1.write(0+Ajuste);  //Si el servo1 es el mas rapido  
servo2.write(180);       // Si fuera el servo2 deberas utilizar  ser2.write(180-Ajuste);

7 de gen. 2016

BellSmartCity v.2.0

Utilitzarem BellSmartCity com a projecte col·laboratiu entre els alumnes de 4ESO i els de 1BATX.
La idea és millorar-lo un cop avaluat el seu funcionament actual.

Punt feble 1: Sistema d'il·luminació
La il·luminació analògica dels fanals no funciona. Fins ara només hem aconseguit que s'encenguin o s'apaguin en funció de la lectura d'una LDR.
Idea: Separem el circuit dels fanals del dels sensors d'ultrasons del pont, utilitzem una nova placa per la LDR i els LEDs dels fanals. Així el sistema d'il·luminació serà independent del funcionament del sistema detector de vaixells, i no haurà interferències.
Com que hi ha molts fanals proposo dues línies, connectades cada una a un pin PWM diferent.
Caldria dissenyar un sistema difusor de la llum dels LEDs.

Punt feble 2: Accionament del pont
La idea inicial era utilitzar servos per accionar xeringues, però no tenim prou potència.
La solució actual amb un servo penjant de l'estructura del pont és molt dubtosa, poc estable i simplona.
Idea: utilitzem un actuador lineal Lego Technic acoblat a l'estructura del pont amb bigues Lego, i accionat a un servo de rotació contínua.

Punt feble 3: Barreres
El sistema mecànic dissenyat és massa complicat.
Idea: utilizem un servo estàndar i acoblem una tira de fullola o de cartolina. Amb aixó hi haurà prou.