lunes, 5 de marzo de 2018

Raspberry Pi para encender y apagar un LED con los GPIO

El miniordenador Raspberry Pi dispone de los puertos GPIO que de permiten interactuar con el mundo físico y con el que podemos introducirnos en el IoT (Internet of Things) el Internet de las cosas.

En este caso vamos a ver lo más básico que consiste en encender y apagar un LED utilizando código Python.


  • Conectaremos GND, a uno de los GPIO de tierra mediante cable negro. En nuestro caso usaremos el GPIO 6.
  • Conectaremos el cable rojo, al GPIO 18.
  • Incluiremos una resistencia de 200 ohomios, da igual que la pongamos por una patilla o por la otra del led.
  • Un par de cables, hembra-macho
  • Una pequeña placa protoboard
  • La Raspberry Pi versión 1. Tener en cuenta que los pines GPIO de las versiones 2 y 3 son iguales pero difieren de los de la versión 1. Aunque, en este caso los GPIO usados el 6 y el 18 coinciden en las tres versiones.
  • Cable RJ45 para conectar al router
  • Alimentación de la Raspberry Pi con un cargador de movil. Para la versión 1 con uno normalito de 0,5A es suficiente.
  • Tarjeta SD, con el sistema operativo Raspbian. En nuestro caso la versión 4.9 (RASPBIAN STRETCH).
  • Usaremos la versión Python 3, concretamente la versión 3.5.3.
El código en Python es el siguiente.

 import RPi.GPIO  
 import time  
 RPi.GPIO.setmode (RPi.GPIO.BCM)  
 RPi.GPIO.setup (18,RPi.GPIO.OUT)  
 while True:  
  RPi.GPIO.output (18, True)  
  time.sleep(1)  
  RPi.GPIO.output (18, False)  
  time.sleep(1)  

Esto lo que consigue es hacer un blink, esto es que el led se encienda y se apague ininterrumpidamente cada segundo.



Con un bucle infinito del tipo while True la Raspberry Pi se queda ejecutando el procedimiento Python de forma indefinida y se tiene que finalizar en algún momento pulsando Control+c. Al lanzar de nuevo el programa ledonoff.py surge un mensaje avisando de que el procedimiento está en uso.


Para evitar los mensaje podemos añadir la siguiente línea.

RPi.GPIO.setwarnings(False)

Por estos motivos, hemos optado por implementar una segunda versión, que mostramos seguidamente.

Blink de un led durante un tiempo

Ahora el led permanece encendido un décimo de segundo y permanece apagado otro décimo de segundo. Esto se repite 30 veces.


 import RPi.GPIO  
 import time  
 RPi.GPIO.setmode (RPi.GPIO.BCM)  
 RPi.GPIO.setup (18,RPi.GPIO.OUT)  
   
 for i in range(30):  
  RPi.GPIO.output (18, True)  
  time.sleep(.1)  
  RPi.GPIO.output (18, False)  
  time.sleep(.1)  
 RPi.GPIO.cleanup(18)  

En esta segunda versión del código hemos sustituido el bucle while por un for que hace que la duración total del procedimiento sea aproximadamente de 6 segundos.

La última línea de código lo que hace es limpiar el uso del GPIO 18 que es el que hemos usado, por si luego se desea emplear en otros menesteres.


Con una función de Python

Esta es otra variante del programa anterior donde hemos creado la función parpadea.

 import RPi.GPIO as GPIO  
 import time  
 GPIO.setmode(GPIO.BCM)  
 GPIO.setup(18,GPIO.OUT)  
   
 def parpadea():  
  print("Comienza a parpadear el led ...")  
  for i in range(30):  
   GPIO.output(18,True)  
   print("|",end="",flush=True)  
   time.sleep(.1)  
   GPIO.output(18,False)  
   time.sleep(.1)  
  print("")  
  print("Fin")  
  GPIO.cleanup()  
   
 parpadea()  


miércoles, 25 de octubre de 2017

Hola mundo con Arduino en una LCD con bus I2C

Material utilizado

  • Arduino UNO
  • LCD 16x2
  • I2C
  • cables

Conexiones

El bus I2C se conecta al LCD por la parte de atrás de la pantalla. Luego el I2C utiliza cuatro cables para conectarse al Arduino, con esto ahorramos cables. Este es un bus muy utilizado desde hace muchos años.
  • GND --> GND
  • VCC  --> 5V
  • SDA  --> A4 pin analógico del Arduino
  • SCL  --> A5 pin analógico del Arduino

SDA es la señal de datos y SCL es la señal de reloj que usa el I2C.

Código

También se puede utilizar en una pantalla LCD 20x4.

 //Objetivo de este código: saludar en un LCD 16x2 con I2C en un arduino UNO  
 //El I2C del LCD tiene cuatro cables que van al arduino así:  
 // GND --> GND  
 // VCC --> 5V  
 // SDA --> A4  
 // SCL --> A5  
 #include <Wire.h>  
 #include <LiquidCrystal_I2C.h>  
 //Crear el objeto lcd dirección 0x3F y 16 columnas x 2 filas  
 LiquidCrystal_I2C lcd(0x3F,16,2); //  
 void setup() {  
  lcd.init();        // Inicializar el LCD  
  lcd.backlight();     //Encender la luz de fondo  
  lcd.print("Hola Mundo"); // Escribimos el Mensaje en el LCD  
 }  
 void loop() {  
  // Ubicamos el cursor en la primera posición(columna:0) de la segunda línea(fila:1)  
  lcd.setCursor(0, 1);  
  // Escribimos el número de segundos trascurridos  
  lcd.print(millis()/1000);  
  lcd.print(" Segundos");  
  delay(1000);  
 }  

Fecha y hora con el RTC DS1302 y una LCD 16x2 con I2C

Vamos a ver cómo se muestra la fecha y hora dada por un reloj de tiempo real (RTC) en una pantalla LCD de 16 caracteres por 2 filas.

Material utilizado:
  • Arduino UNO
  • pantalla LCD 16x2
  • el bus I2C para comunicarnos con la pantalla LCD
  • RTC modelo DS1302
Existen otros relojes de tiempo real (RTC) como son los modelos: DS1305, DS331. En nuestro caso el que teníamos disponible en este momento es el DS1302. Se diferencias en ciertas características técnicas y en especial en las librerías disponibles. En nuestro caso usaremos la librería DS1302.

Este es el enlace a la librería.

Las conexiones del DS1302 al Arduino UNO son las siguientes.
  • VCC pin  -> Arduino 5V
  • GND pin  -> Arduino GND
  • CLK pin  -> Arduino Digital
  • DAT pin  -> Arduino Digital 3
  • RST pin  -> Arduino Digital 2

El bus I2C nos ahorra cables para conectar la pantalla LCD. Se conecta el bus I2C a la pantalla por la parte de atrás de ésta, y luego los cuatro cables del I2C van al Arduino UNO de la siguiente manera.
  • GND --> GND
  • VCC  --> 5V
  • SDA  --> A4 pin analógico del Arduino
  • SCL  --> A5 pin analógico del Arduino
SDA es la señal de datos y SCL es la señal de reloj que usa el I2C.


El reloj de tiempo real DS1302 utiliza una pila botón grande de 3 voltios para memorizar la hora en caso de desconexión. La pila puede durar 2 o 3 años.



El código es el siguiente.

 // DS1302: RST pin -> Arduino Digital 2  
 //     DAT pin -> Arduino Digital 3  
 //     CLK pin -> Arduino Digital 4  
 //     GND pin -> Arduino GND  
 //     VCC pin -> Arduino 5V  
 #include <Wire.h>  
 #include <LiquidCrystal_I2C.h>  
 #include <DS1302.h>  
 LiquidCrystal_I2C lcd(0x3F,16,2);// if your LCD does not display,change it to 0x27 or other address  
 //to detect correct LCD i2c address, read http://osoyoo.com/2014/12/07/16x2-i2c-liquidcrystal-displaylcd/  
 DS1302 rtc(2, 3, 4);  
 void clockdate()   
 {  
     lcd.clear();   
     lcd.setCursor(0,0);  
     lcd.print(rtc.getDateStr(FORMAT_LONG,FORMAT_LITTLEENDIAN, '/'));// check 1302 library and see FORMAT_BIGENDIAN:2010-01-01;FORMAT_LITTLEENDIAN:01-01-2010  
     lcd.setCursor(11,0);  
     lcd.print(rtc.getDOWStr());  
     lcd.setCursor(14,0);  
     lcd.print("  ");  
     lcd.setCursor(0, 1) ;  
     lcd.print(rtc.getTimeStr());  
 }  
 void setup()  
 {  
  lcd.init();           // initialize the lcd  
  lcd.backlight();   
  rtc.halt(false);  
  rtc.writeProtect(false);  
  rtc.setDOW(WEDNESDAY);    //Estas tres líneas con set se han de subir la primera vez y luego  
  rtc.setTime(20,59,00);    //se han de subir una segunda vez convertidas en comentarios  
  rtc.setDate(25,10,2017);  //para que la fecha y hora no se reinicien siempre al mismo valor.  
  rtc.writeProtect(true);  
  }  
 void loop()  
 {   
  clockdate();  
  delay(1000);  
 }  


En el código existen tres líneas que utilizamos para que la placa Arduino obtenga la fecha y hora actuales. Estas son las que yo he utilizado:

  • rtc.setDOW(WEDNESDAY); 
  • rtc.setTime(20,59,00);
  • rtc.setDate(25,10,2017);

Si se desconecta de la alimentación el Arduino y luego se vuelve a conectar él ejecuta nuevamente su código aprendido y volverá a iniciarse en la fecha y hora de la programación que conserva en memoria, por lo que los datos que ofrezca ya estarán desactualizados.

Para solucionar este problema debemos convertir estas tres líneas en comentarios y cargar nuevamente el código en la placa Arduino. Cuando desconectemos la placa de la alimentación y luego volvamos a conectarla se tomará la fecha y hora del reloj de tiempo real. De esta forma conseguiremos estar en la fecha y hora correctas.

jueves, 14 de mayo de 2015

Majarduino: Reto 2. Ultrasonidos

Reto 2


Ultrasonidos

  1. Comprender funcionamiento de los sensores de ultrasonidos y darles aplicación
  2. La detección
    • Mostrar por puerto serie como varia la distancia de obstáculos delante del sensor
    • Mostrar como se acerca o aleja un objeto del sensor en un conjunto de 5 leds de tal forma que si está muy lejos el objeto todos los leds estén apagados y a medida que se acerca el objeto se van encendiendo progresivamente.
    • Marcar la proximidad de un objeto con el pitido de un zumbador.
Materiales

  • Arduino 1
  • Protoboard
  • Sensor de ultrasonidos (HC-SR04) x 1
  • Leds de color al gusto x 5
  • Mazo de diferentes cables
  • domingo, 19 de abril de 2015

    Controlar la posición de un servo con un potenciómetro

    Vamos a controlar la posición de un Servo moviendo un potenciómetro o resistencia variable.

    Utilizamos para el Servo el PIN 9 que es de tipo PWM pero al usar la librería Servo.h en un Arduino UNO lo que hace esta librería es deshabilitar la capacidad PWM del PIN 9 y 10. Por este, motivo podríamos usar cualquier PIN digital para controlar el servo ya que el trabajo duro lo hace la librería, que usa pulsos para según la frecuencia y duración indicar al relé a que ángulo debe ir.

    El proyecto se puede ver en el siguiente enlace:





    
    

    El código está obtenido del siguiente enlace: http://www.arduino.cc/en/Tutorial/Knob

    Majarduino: Reto 1. SEÑAL PWM Y LED RGB

    #Majarduino

    Reto 1: SEÑAL PWM Y LED RGB

    • OBJETIVO
      1. COMPRENDER FUNCIONAMIENTO DE LA SEÑAL PWM
      2. SERVOMOTORES
        1. CONTROLAR ÁNGULO DE GIRO DE UN SERVOMOTOR (ENTRE 0 Y 170)
        2. CONTROLAR SENTIDO DE GIRO Y VELOCIDAD DE UN SERVOMOTOR DE ROTACIÓN CONTINUA
      3. LEDS RGB (COLORINES !!!!)
        1. CONTROLAR LA TONALIDAD DE UN LED RGB DE ÁNODO O CÁTODO COMÚN  CON 3 POTENCIÓMETROS (ROJO, VERDE Y AZUL)
    • MATERIAL DE UTILIDAD
      1. ARDUINO 1
      2. PROTOBOARD
      3. SERVOMOTORES
        1. MINISERVO
        2. SERVO DE ROTACIÓN CONTÍNUA
      4. LEDS RGB (COLORINES !!!!)
        1. LED RGB
        2. 3 POTENCIÓMETROS

    Encender una lámpara con un Arduino y un relé

    Vamos a utilizar un relé para encender una lámpara con un Arduino UNO. El relé es el más sencillo y económico que podemos encontrar. Se trata de una unidad que trabaja con 220 V y hasta 10 A. Se puede adquirir en eBay por menos de 3 €.




    También existen relés múltiples, por ejemplo, disponemos de uno de cuatro unidades de 10 A.






    • GND → NEGRO → NEGATIVO → Tierra o masa
    • Vcc → ROJO → POSITIVO → +5v (aquí van lo 5 voltios del Arduino)
    • IN1 → Entrada de CONTROL del Relé 1 → AMARILLO → Al PIN de control del Arduino
    • IN2 → Entrada de CONTROL del Relé 2
    • IN3 → Entrada de CONTROL del Relé 3
    • IN4 → Entrada de CONTROL del Relé 4


    En Arduino UNO el led interno de la placa que ya lleva resistencia de protección está asociado al PIN 13. Si conectamos un led externo al PIN 13 no será necesaria la resistencia de protección.
    En el código del probrama Blink que viene como ejemplo básico en el IDE de Arduino se utiliza el PIN que está asociado a ese led interno. Este es el motivo por el que hemos conectado el cable amarillo que va al PIN de control del relé al PIN 13 de nuestro Arduino UNO.