Xwork's Blog

 Hola de nuevo a todos, el día de hoy empezaremos a ver la versión final del velocímetro.

Este proyecto fue iniciado mas o menos por el 2018 y ha sufrido una serie de cambios a lo largo del tiempo, si bien la última versión que fue publicada funcionaba bien, poco a poco se fueron agregando funciones para hacerlo funcionar de manera optima con el mínimo de hardware posible (de ahí que nunca le agregue ningún tipo de botón). Finalmente, tras días de pruebas y pruebas, he decidido finalizar con este proyecto porque finalmente ha alcanzado el nivel de confiabilidad para poder usarse en el día a día.

// Incluir la libreria para la pantalla
#include <LiquidCrystal.h>
// Pines usados en la pantalla extraido de los ejemplos incluidos en la libreria
const int rs = 13, en = 12, d4 = 11, d5 = 10, d6 = 9, d7 = 8;
// iniciar el objeto LiquidCrystal
LiquidCrystal lcd(rs , en , d4 , d5 , d6 , d7);
// Este es el valor que debes de modificar para que funcione correctamente
// Puedes ver instrucciones en https://xworkforall.blogspot.mx/2018/03/vamos-programar-49.html
const float Llanta = 1.9572;
//Algunas variables
const int HallSensor1 = 3;
const int LED1 =  7;
const int LED2 = 6;
const int LED3 = 5;
int Vuelta = 0;
unsigned long OldTime = 0;
float Distancia = 0.0;
float Speed = 0.0;
int ledState = LOW;
int VoltSensor = 0;
float BattVolt = 0.0;

// v=99.99
char BuffVelocity[15];
//d=999.99
char BuffDistance[15];
//R=999999
char BuffRevolution[15]; 
//V=4.2
char BuffBattery[15];

//Incializar todo
void setup() {
  //Serial.begin(9600);
  lcd.begin(16, 2);
  lcd.setCursor(0, 0);
  lcd.print("@XWork");
  pinMode(HallSensor1, INPUT);
  attachInterrupt(digitalPinToInterrupt(HallSensor1) , GetVelocity , LOW);
  pinMode(LED1 , OUTPUT);
  pinMode(LED2 , OUTPUT);
  pinMode(LED3 , OUTPUT);
}

// Calcular la velocidad
void GetVelocity() {
  if (millis() - OldTime > 70) {
    Speed = Llanta / ((float)( millis() - OldTime) / 1000) * 3.6;
    OldTime = millis();
    Distancia = Distancia + Llanta / 1000;
    Vuelta += 1;
    if (ledState == LOW)
      ledState = HIGH;
    else 
      ledState = LOW;
  }
}
//Bucle principal
void loop() {
  VoltSensor = analogRead(A5);
  BattVolt = (VoltSensor * (10.0 / 1023.0));

  dtostrf(Speed , 5 , 2 , BuffVelocity);
  dtostrf(Distancia , 6 , 2, BuffDistance);
  sprintf(BuffRevolution , "R=%6d", Vuelta);
  dtostrf(BattVolt , 5 , 1, BuffBattery);
  
  lcd.setCursor(0, 0);
  lcd.print("d=");
  lcd.setCursor(2 , 0);
  lcd.print(BuffDistance);
  
  lcd.setCursor(9, 0);
  lcd.print("v=");
  lcd.setCursor(11, 0);
  lcd.print(BuffVelocity);
  
  lcd.setCursor(0,1);
  lcd.print(BuffRevolution);
  
  lcd.setCursor(9,1);
  lcd.print("V=");
  lcd.print(BuffBattery);
  
  digitalWrite(LED1 , ledState);
  digitalWrite(LED2 , ledState);
  digitalWrite(LED3 , ledState);
  
  if ((millis() - OldTime) > 3000){
    ledState = LOW;
    Speed = 0.0;
  }
}

Hola de nuevo a todos, el día de hoy vamos a continuar con mas partes para llegar a la versión final del velocímetro.

Leyendo algunos comentarios que hace la gente sobre que más se le podría modificar al velocímetro, muchos de ellos coincidían que había que corregir algunos de ellos. Los principales "detalles" estaban en la pantalla. Si bien no eran errores, aprovechando que se va a actualizar, decidí arreglarlos de una vez.

Supongamos que en la pantalla tenemos una velocidad de 10.09 km/h pero si desaceleramos, a por ejemplo 9.1 la pantalla mostraba algo cómo 9.19, y la cosa era peor si nos deteníamos ya que se mostraba 0.09. La razón por la que pasaba esto es por cómo se maneja la pantalla. Para ponerlo de forma simple, solo cuando se escribe algo en cierta posición, la pantalla se actualiza pero solo en esa zona, cuando escribimos "v=10.09" se usan siete espacios y mientras los usemos con números que usen el mismo "ancho" no se verá ningún problema, pero cuando tenemos cualquier número inferior a 10.00 cómo 9.9 ahora solo se usan menos espacios por lo que en lugar de actualizar los mismos siete de antes, solo se actualizan cinco o seis. Para poder solucionarlo, podemos escribir número que si importar cual sea, siempre ocupen la misma cantidad de espacios.

En C existen varias formas de formatear números, pero algunas de ellas no están disponibles para usarse en arduino (y debo de admitirlo, eso no lo sabia hasta apenas) y por eso veremos cómo es posible usar el reemplazo que arduino ofrece.

Primero que nada, hay que definir cual es el "estilo" que queremos que cada número tenga. En el caso del velocímetro, hay cuatro números importantes: la velocidad, la distancia, las revoluciones (o vuletas) y el voltaje de la batería. En el caso de la velocidad, una velocidad máxima de 99.99km/h es mas que suficiente para una bicicleta por lo que el numero ocuparía cinco espacios (con el punto incluido). Para las distancia, un viaje de 999.99 km es mas que suficiente para la mayoría de los ciclistas, por lo que seis digitos parecen suficiente, para las revoluciones, 999999 parecen suficientes por lo que seis espacios parecen suficientes y finalmente la batería, ya que el voltaje máximo de una sola pila es 4.2v, con solo reservar tres espacios es mas que suficiente.

Ahora veamos un código hipotético en C que serviría para usarse en un programa de computadora (por ejemplo) pero que no produciría el resultado esperado en arduino. EL código es el siguiente:

#include <stdio.h>

float Speed = 9.1;
float Distance = 9.04;
int Revolution = 16384;
float Battery = 2.0;

char BuffSpeed[20];
char BuffDistance[20];
char BuffRevolution[20];
char BuffBattery[20];

int main()
{

    sprintf(BuffBattery , "R=%3.1f\n", Battery);
    sprintf(BuffRevolution , "R=%6d\n", Revolution);
    sprintf(BuffDistance , "d=%6.2f\n", Distance);
    sprintf(BuffSpeed, "V=%5.2f\n", Speed);

    printf(BuffSpeed);
    printf(BuffDistance);
    printf(BuffRevolution);
    printf(BuffBattery);

    return 0;
}

Al compilarlo con los valores asignados, produce el siguiente resultado:

V= 9.10

d=  9.04

R= 16384

R=2.0

Pero cómo no es muy fácil de apreciar, solo para este ejemplo vamos a poner "0" en lugar de espacios en blanco para que se mas fácil de apreciar (en la pantalla no para poder preservarla un poco mas.) por lo que probamos con el siguiente código:

#include <stdio.h>

float Speed = 9.1;
float Distance = 9.04;
int Revolution = 16384;
float Battery = 2.0;

char BuffSpeed[20];
char BuffDistance[20];
char BuffRevolution[20];
char BuffBattery[20];

int main()
{

    sprintf(BuffBattery , "R=%3.1f\n", Battery);
    sprintf(BuffRevolution , "R=%06d\n", Revolution);
    sprintf(BuffDistance , "d=%06.2f\n", Distance);
    sprintf(BuffSpeed, "V=%05.2f\n", Speed);

    printf(BuffSpeed);
    printf(BuffDistance);
    printf(BuffRevolution);
    printf(BuffBattery);

    return 0;
}

Al compilarlo con los valores asignados, produce el siguiente resultado:

V=09.10

d=009.04

R=016384

R=2.0

Ahora resulta mas sencillo observar que por ejemplo la velocidad siempre ocupara cinco espacios a pesar de ser menor a 10km/h y que por ejemplo la distancia ocupa seis espacios a pesar de ser menor a 100km.

Pero que pasa si tratamos de ejecutar el mismo código en arduino?

Cómo puede observarse, la mayor parte del código se compila pero no funciona. Esto se debe principalmente a que a la hora de formatear los números del tipo "float" requiere mas poder de procesamiento por lo que en arduino no se implementó (**o eso es lo que quiero creer**), para el caso del los enteros es posible usar la misma función "sprintf()".

Para poder hacer algo similar, podemos usar la funcion "dtostrf()". Esta funcion lo que hace es convertir un número "double" a su equivalente en "string", para eso la funcion recibe cuatro parametros.

• char * dtostrf (double __val, signed char __width, unsigned char __prec, char *__s)
• __val es el valor que se va a convertir
• __width es el tamaño que debe de tener la cadena.
• __prec Es la cantidad de decimales que usaran
• __s Es el sitio donde se almacenara el resultado.

dtostrf(Speed , 5 , 2 , BuffVelocity);

//YWROBOT
//Compatible with the Arduino IDE 1.0
//Library version:1.1
#include <Wire.h> 
#include <LiquidCrystal_I2C.h>
// Conexiones de la pantalla usando el convertidor a i2c
//SCL - A5
//SDA - A4
LiquidCrystal_I2C lcd(0x27,20,4);  // set the LCD address to 0x27 for a 16 chars and 2 line display

float Speed = 9.1;
float Distance = 9.04;
int Revolution = 16384;
float Battery = 2.0;

char BuffSpeed[20];
char BuffDistance[20];
char BuffRevolution[20];
char BuffBattery[20];


void setup()
{
    lcd.init();
    lcd.backlight();
}


void loop()
{
    dtostrf(Speed , 5 , 2 , BuffSpeed);
    dtostrf(Distance , 6 , 2, BuffDistance);
    sprintf(BuffRevolution , "R=%6d", Revolution);
    dtostrf(Battery , 4 , 2, BuffBattery);

    lcd.setCursor(0, 0);
    lcd.print("v=");
    lcd.setCursor(2 , 0);
    lcd.print(BuffSpeed);

    lcd.setCursor(8, 0);
    lcd.print("d=");
    lcd.setCursor(10, 0);
    lcd.print(BuffDistance);

    lcd.setCursor(0,1);
    lcd.print(BuffRevolution);

    lcd.setCursor(10,1);
    lcd.print("v=");
    lcd.print(BuffBattery);
}

 Hola de nuevo a todos, el día de hoy vamos a ver cómo instalar una mejora a las luces del velocímetro y además, veremos cómo es que los transistores nos pueden ayudar a manejar algunas cosas que no podríamos directamente desde el arduino.

Cuando controlamos los diodos LED directamente desde el arduino, disponemos de una cantidad limitada de potencia. Normalmente el arduino UNO es capaz de suministrar un voltaje de 5v en los pines, pero tienen un limite de corriente de solo 40mA, si conectamos algo que requiera más corriente las cosas pueden ponerse feas.

Por los lugares que suelo andar en bicicleta, los diodos antes mencionados cumplen con su trabajo, pero me llegaron algunas peticiones a mi twitter preguntando por la posibilidad de agregar algo mas fuerte. La mayoría quería agregar los módulos que consisten de tres (o seis) diodos LED 5050.

Si conectamos uno de estos módulos al arduino, simplemente nada pasará, ya que requieren un voltaje de 12V (si hago bien memoria cuando es un solo led 5050 de color blanco consume 60mA a 3.2v), para poder agregar uno de estos módulos, primero que nada, necesitaremos agregar un elevador de voltaje y para controlarlas el transistor.

Para este caso voy a usar un transistor TIP31c (que era lo que tenía a la mano) pero el siguiente diagrama aplica a cualquier transistor NPN. Pero primero que nada ¿Que es un transistor?.

El transistor es un dispositivo electrónico semiconductor utilizado para entregar una señal de salida en respuesta a una señal de entrada. Cumple funciones de amplificador, oscilador, conmutador o rectificador. El término «transistor» es la contracción en inglés de transfer resistor («resistor de transferencia»). Actualmente se encuentra prácticamente en todos los aparatos electrónicos de uso diario tales como radios, televisores, reproductores de audio y video, relojes de cuarzo, computadoras, lámparas fluorescentes, tomógrafos, teléfonos celulares, aunque casi siempre dentro de los llamados circuitos integrados.

https://es.wikipedia.org/wiki/Transistor

Tal y cómo lo dice la definición, necesitamos una señal de entrada para obtener una señal de salida, por lo que en este ejemplo el transistor lo usaremos cómo un apagador (se puede usar para más muchas más aplicaciones pero por ahora solo esto). Antes de continuar, quiero resaltar que usaremos un transistor NPN, existen de más tipos (que eventualmente veremos) pero por ahora y cómo el objetivo no es aprender a usarlos, bastará con usar un transitor del mismo tipo y con las caracteristicas que veremos un poco más adelante.

Para el transistor TIP31c los pines son de la siguiente manera:

1. Base
2. Colector
3. Emisor

.Para hacer las conexiones solo deberás de identificar cual corresponde a cada pin del transistor que elijas y todo debería de funcionar.

Y el diagrama correspondiente sería:

SI todo salió bien las luces deberían de encender cuando el PIN de arduino este en "HIGH".

Cabe aclarar que lo mas recomendable para está situación, sería usar una fuente de energía adicional, puesto que el velocímetro es alimentado por una pila, agregar dos elevadores de voltaje podría reducir la durabilidad de esta de forma drástica. En cambio si agregamos otra pila aparte si se agota el velocímetro podría seguir operando con normalidad.

Aunque la idea me agrado, está no es la solución que agregué a mi bicicleta, la solución que yo le puse la veremos en el siguiente post. Por cierto, se que al inicio del año prometí post cada quincena, pero por razones que son difíciles de entender (aun para mi) los post saldrán pero no de forma periódica.

Los leo luego.

"Mejorando la casa"

Las conexiones y el código.

// Incluir la libreria para la pantalla
#include <LiquidCrystal.h>
// Pines usados en la pantalla extraido de los ejemplos incluidos en la libreria
const int rs = 13, en = 12, d4 = 11, d5 = 10, d6 = 9, d7 = 8;
// iniciar el objeto LiquidCrystal
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
// Este es el valor que debes de modificar para que funcione correctamente
// Puedes ver instrucciones en https://xworkforall.blogspot.mx/2018/03/vamos-programar-49.html
const float Llanta = 1.9572;
//Algunas variables
const int HallSensor1 = 3;
const int LED1 =  7;
const int LED2 = 6;
const int LED3 = 5;
int Vuelta = 0;
unsigned long OldTime = 0;
float Distancia = 0.0;
float Speed = 0.0;
int ledState = LOW;
int VoltSensor = 0;
float BattVolt = 0.0;

const byte Batt100[] = {
	B01110,
	B11111,
	B11111,
	B11111,
	B11111,
	B11111,
	B11111,
	B11111
};

	const byte Batt75[] = {
	B01110,
	B10001,
	B11111,
	B11111,
	B11111,
	B11111,
	B11111,
	B11111
};

	const byte Batt50[] = {
	B01110,
	B10001,
	B10001,
	B10001,
	B11111,
	B11111,
	B11111,
	B11111
};

	const byte Batt25[] = {
	B01110,
	B10001,
	B10001,
	B10001,
	B10001,
	B10001,
	B11111,
	B11111
};

	const byte Batt0[] = {
	B01110,
	B10001,
	B10001,
	B10001,
	B10001,
	B10001,
	B10001,
	B11111
};

//Incializar todo
void setup() {
	//Serial.begin(9600);
	lcd.createChar(0, Batt0);
	lcd.createChar(1, Batt25);
	lcd.createChar(2, Batt50);
	lcd.createChar(3, Batt75);
	lcd.createChar(4, Batt100);
	lcd.begin(16, 2);
	lcd.setCursor(0, 0);
	lcd.print("@XWork");
	pinMode(HallSensor1, INPUT);
	attachInterrupt(digitalPinToInterrupt(HallSensor1), GetVelocity, LOW);
	pinMode(LED1, OUTPUT);
	pinMode(LED2, OUTPUT);
	pinMode(LED3, OUTPUT);
}
//Dibujar el icono de bateria***
void DrawBatt(int Value){
	lcd.setCursor(15, 1);
	if (Value > 90)
		lcd.write(byte(4));
	  if (Value < 91 && Value > 75 )
		lcd.write(byte(3));
		if (Value < 76 && Value > 50 )
		lcd.write(byte(2));
		if (Value < 51 && Value > 10 )
		lcd.write(byte(1));
		if (Value < 11 )
		lcd.write(byte(0));
}
// Calcular la velocidad
void GetVelocity() {
  if (millis() - OldTime > 70) {
	Speed = Llanta / ((float)( millis() - OldTime) / 1000) * 3.6;
	OldTime = millis();
	Distancia = Distancia + Llanta / 1000;
	Vuelta += 1;
	if (ledState == LOW) {
	  ledState = HIGH;
	} else {
	  ledState = LOW;
	}
  }
}
//Bucle principal
void loop() {
	VoltSensor = analogRead(A5);
	BattVolt = (VoltSensor * (10 / 1023.0)) * 100;
	lcd.setCursor(0, 0);
	lcd.print("v=");
	lcd.setCursor(2, 0);
	lcd.print(Speed);
	lcd.setCursor(8, 0);
	lcd.print("d=");
	lcd.setCursor(10, 0);
	lcd.print(Distancia);
	lcd.setCursor(0,1);
	lcd.print("Rev=");
	lcd.setCursor(4,1);
	lcd.print(Vuelta);
	DrawBatt(map(BattVolt, 300,405,1,100));
	digitalWrite(LED1, ledState);
	digitalWrite(LED2, ledState);
	digitalWrite(LED3, ledState);
	if ((millis() - OldTime) > 3000){
		ledState = LOW;
		Speed = 0.0;
	}
}

Así luce en el empaque menos prolijo.

El hardware

• De la pantalla 1602A
• VSS va a tierra.
• VDD va a5v.
• VO controla el contraste de la pantalla, un valor aceptable son 2.2KOhms.
• RS va al pin 12 del arduino (se puede modificar).
• RW va a tierra.
• E va al pin 11 del arduino.
• D4 al pin 9 (se puede modificar).
• D5 al pin 8.
• D6 al pin 7.
• D7 al pin 6.
• A va a 5V.
• K va a tierra.
• Del sensor de efecto Hall 1
• Data va al pin 3.
• Del sensor de efecto Hall 2
• Data va al pin 4.

Dicen que en una bicicleta el polvo es sinónimo de uso rudo (o de que no se limpia seguido).

// Incluir la libreria para la pantalla
#include <LiquidCrystal.h>
// Pines usados en la pantalla extraido de los ejemplos incluidos en la libreria
const int rs = 12, en = 11, d4 = 9, d5 = 8, d6 = 7, d7 = 6;
// iniciar el objeto LiquidCrystal
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
// Este es el valor que debes de modificar para que funcione correctamente
// Puedes ver instrucciones en https://xworkforall.blogspot.mx/2018/03/vamos-programar-49.html
const float Llanta = 1.9572;
//Algunas variables
const int HallSensor1 = 3;
const int LED =  13;
int HallState = 0;
int Vuelta = 0;
int OldState = 0;
unsigned long OldTime = 0;
float Distancia = 0;
float Speed = 0;
//Incializar todo
void setup() {
 Serial.begin(9600);
 lcd.begin(16, 2);
 lcd.setCursor(0, 0);
 lcd.print("@XWork");
 pinMode(HallSensor1, INPUT);
 attachInterrupt(digitalPinToInterrupt(HallSensor1), GetVelocity, LOW);
 pinMode(LED, OUTPUT);
}
// Calcular la velocidad
void GetVelocity() {
 if (millis() - OldTime > 70) {
  Speed = Llanta / ((float)( millis() - OldTime) / 1000) * 3.6;
  OldTime = millis();
  Distancia = Distancia + Llanta / 1000; 
 }
}
//Bucle principal
void loop() {
 Serial.println("Velocidad en m/s");
 Serial.println(Speed);
 lcd.setCursor(0, 0);
 lcd.print("v= Km/h D = Km");
 lcd.setCursor(0, 1);
 lcd.print(Speed);
 lcd.setCursor(8, 1);
 lcd.print(Distancia);
  if ((millis() - OldTime) > 2000)
  Speed=0.0; 
}

• LOW
• CHANGE
• RISING
• FALLING
• HIGH

#include <LiquidCrystal.h>
const int rs = 12, en = 11, d4 = 9, d5 = 8, d6 = 7, d7 = 6;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
const float Llanta = 1.9572;
//Algunas variables
const int HallSensor = 3;
const int LED =  13;
int HallState = 0;
int Vuelta = 0;
int OldState = 0;
unsigned long OldTime = 0;
float Distancia = 0;
float Speed = 0;
//Incializar todo
void setup() {
 Serial.begin(9600);
 lcd.begin(16, 2);
 lcd.setCursor(0, 0);
 lcd.print("@XWork");
 pinMode(HallSensor, INPUT);
 attachInterrupt(digitalPinToInterrupt(HallSensor), GetVelocity, LOW);
 pinMode(LED, OUTPUT);
}
void GetVelocity() {
 if (millis()-OldTime > 70) {
  Speed=Llanta/((float)(millis()-OldTime)/1000)*3.6;
  OldTime=millis();
  Distancia=Distancia+Llanta/1000; 
 }
}
//Bucle principal
void loop() {
 Serial.println("Velocidad en m/s");
 Serial.println(Speed);
 lcd.setCursor(0, 0);
 lcd.print("v= Km/h D = Km");
 lcd.setCursor(0, 1);
 lcd.print(Speed);
 lcd.setCursor(8, 1);
 lcd.print(Distancia);
  if ((millis()-OldTime)>2000){
  Speed=0.0; 
  }
}

1. Velocidad (obviamente).
2. Distancia.
3. RPM (revoluciones por minuto).

Obteniendo la distancia.

// {...}
//obtener la velocidad
float GetVelocity(){
	float Velocity = Distancia/((float)(millis()-OldTime)/1000);
	OldTime=millis();
	return Velocity;
}
// {...}

El sensor de efecto Hall.

El sensor de efecto Hall o simplemente sensor Hall o sonda Hall (denominado según Edwin Herbert Hall) se sirve del efecto Hall para la medición de campos magnéticos o corrientes o para la determinación de la posición en la que está.

Si fluye corriente por un sensor Hall y se aproxima a un campo magnético que fluye en dirección vertical al sensor, entonces el sensor crea un voltaje saliente proporcional al producto de la fuerza del campo magnético y de la corriente. Si se conoce el valor de la corriente, entonces se puede calcular la fuerza del campo magnético; si se crea el campo magnético por medio de corriente que circula por una bobina o un conductor, entonces se puede medir el valor de la corriente en el conductor o bobina.

Si tanto la fuerza del campo magnético como la corriente son conocidos, entonces se puede usar el sensor Hall como detector de metales. Wikipedia/SensorHall

1. Sensor efecto hall.
2. Resistencia 1KΩ  ~10KΩ. 
3. Arduino

1. Supply (4.5~24V).
2. Ground.
3. OutPut.

//Pin al que coenctaremos el sensor
const int HallSensor = 3;
//LED para mostrar el cambio en caso de no disponer del monitor serie
const int LED =  13;
//Estado del sensor
int HallSensorVal = 0;
//Número de vuelta
int Lap = 0;
//Estado anterior del sensor
int OldState = 0;
//Inicializar lo necesario
void setup() {
	Serial.begin(9600);
	pinMode(LED, OUTPUT);
	pinMode(HallSensor, INPUT);
}
//Bucle princial
void loop() {
	HallSensorVal = digitalRead(HallSensor);
	if (OldState != HallSensorVal) {
		if (HallSensorVal == LOW) {
			digitalWrite(LED, HIGH);
			Lap += 1;
			Serial.println("Vuelta:");
			Serial.println(Lap);
			delay(1);
		}
		else {
		digitalWrite(LED, LOW);
		}
	}
	if (Lap > 99)
		Lap = 1;
	OldState = HallSensorVal;
}