Desarmando

Hoy decidimos hacer un ejercicio de ingeniería inversa y desarmar la caja negra de las cosas electrónicas para descubrir sus partes y reciclar para futuros proyectos.

IMG_3244IMG_3251IMG_3260IMG_3263IMG_3265IMG_3266IMG_3269

Anuncios

Pantalla color 1.44 (128×128)

Éste tutorial es para trabajar con una pequeña pantalla a color con Arduino. La pantalla que tengo tiene las siguientes caracteristicas:  1.44` SPI 128*128 v1.1. En este caso, este tipo de pantalla usa una libreria de adafruit llamada GFX library y Sumotoy TFT ILI9163. Si nunca han instalado una libreria, este vínculo explica como instalar las librerias en varios sistemas operativos.

La conexión con arduino es la siguiente:

led – 3.3v
sck – 13
sda – 11
A0 – 9
reset – 12
cs – 10
gnd – gnd
vcc – 5v

img_2484

500px-128x_128_tft_lcd_with_spi_interface_hardware

código y tutorial completo: https://www.elecrow.com/wiki/index.php?title=1.44%27%27_128x_128_TFT_LCD_with_SPI_Interface

Puente H y arduino (y otras cosas)

Como parte de esta sesión, nos dedicamos a mover un motor DC con un puente H (módulo arduino), lo que nos permite controlar las velocidad y dirección del motor, perfecto para robótica y autómatas. Como demostración, vamos a controlar el motor a través de la salida B del módulo. El pin ENB se conectará con el jumper a +5V.

El ejemplo esta desarrollado con Arduino UNO.

IMAG0588.jpg

Código

El programa básicamente activa el motor en un sentido por 4 segundos, luego detiene el motor por 0.5 segundos, después activa el motor en sentido inverso por 2 segundos y por último detiene el motor por 2 segundos. Luego repite la acción indefinidamente.

 

int IN3 = 5;
int IN4 = 4;

void setup(){pinMode(IN4, OUTPUT);pinMode(IN3, OUTPUT);}

void loop()
{
//Motor gira en un sentido
digitalWrite (IN4, HIGH);
digitalWrite(IN33, LOW);
delay(2000);
//motor no gira
digitalWrite(IN4, LOW);
delay(500);
//motor gira en sentido inverso
digitalWrite(IN3, HIGH);
delay(2000);
//motor no gira
digitalWrite(IN3, LOW);
delay(5000);
}

Otros (proyectos en desarrollo): App para domótica con arduino y bluetooth. 

img_1873

Ping-ball con Arduino

img_1872

Motores?

En esta sesión se siguió esta guía: http://robologs.net/2014/09/16/como-construir-un-controlador-de-motores-npn/

El experimento inicial consistió en crear el controlador para encender y apagar el motor DC de forma progresiva utilizando una salida analógica, similar a los ejercicios de encendido y apagado progresivo de un LED que se desarrollaron en sesiones anteriores.

img_1794img_1798

El código utilizado es el siguiente:

int out = 9;                 
int value = 0;      //valor de la salida
int amount = 5;    //tamaño del incremento o decremento

void setup()  {
  pinMode(out, OUTPUT);
}

void loop()  {
  analogWrite(out, value);     
  value = value + amount;
  if (value == 0 || value == 255) { //detecta si se llega a uno de los limites
    amount = -amount ;              //invierte el sentido del incremento o decremento
  }    
  delay(50);
}

Luego se realizó una variación reduciendo y quitando la resistencia que se muestra en el esquemático que está en el enlace y cambiando el código para utilizar una salida digital en lugar de una salida analógica y probando a dejar el motor encendido y apagado en intervalos de 5 segundos. El código utilizado fue el siguiente:

int out = 13;                

void setup()  {
  pinMode(out, OUTPUT);
}

void loop()  {
  digitalWrite(out,HIGH);
  delay(5000);
  digitalWrite(out,LOW);
  delay(5000);
}

 

Más Arduino.

img_1701

img_1705

En esta sesión del grupo de estudio de electrónica experimentamos la integración entre circuitos analógicos creados en una placa con el procesamiento digital que permite la plataforma Arduino.

Se crearon los programas para desarrollar los siguientes ejercicios prácticos:

Control del voltaje en una salida analógica para realizar progresivamente el encendido y apagado de un LED pero utilizando sólo condicionales (if) en lugar de ciclos (for).

int pin = 11;
int v = 0; 
boolean subiendo = true; // controla si el voltaje está subiendo (true) o bajando (false)

void setup() {
  pinMode(pin, OUTPUT);
}

void loop() {
  // Cuando está subiendo
  if (subiendo==true)
  { 
    if(v >= 255)
    {
      subiendo = false;
    } 
    else 
    {
      analogWrite(pin,v);
      delay(10);
      v++;
    }
  }

  // Cuando está bajando
  if(subiendo==false)
  {
    if(v <= 0)
    {
      subiendo = true;
    } 
    else 
    {
      analogWrite(pin,v);
      delay(10);
      v--;
    }
  }
}

Uso de un potenciometro para controlar analógicamente el voltaje de salida para el encendido de un LED.

const int pinEntrada = A0;
const int pinSalida = 9;
int valorPotenciometro; //variable que almacena la lectura analógica
int posicion;           //posicion del potenciometro en porcentaje

void setup() {
  pinMode(pinSalida, OUTPUT);
}

void loop() {
  // Realizar lectura analogica de potenciometro
  valorPotenciometro = analogRead(pinEntrada);      
  // convertir a porcentaje la lectura
  posicion = map(valorPotenciometro, 0, 1023, 0, 100);
  // regla de 3 para calcular en voltaje de salida
  int voltaje = (posicion*255)/100;
  analogWrite(pinSalida, voltaje);
}

Reemplazar el potenciometro por una fotocelda para controlar analógicamente el voltaje de salida para el encendido de un LED.

const int pinEntrada = A0;
const int pinSalida = 9;
int valorFotocelda;         //variable que almacena la lectura analógica
 
void setup() {
  pinMode(pinSalida, OUTPUT);
  // Inicia la comunicción serial de Arduino con el computador a una velocidad de 9600 bits por segundo
  Serial.begin(9600);       
}

void loop() {
  // Realizar lectura analógica del potenciometro
  valorFotocelda = analogRead(pinEntrada); 
  // Imprimir en el monitor serial el valor registrado por la fotocelda
  Serial.println(valorFotocelda);
  // Restringir el valor de la fotocelda para que esté en el rango de 150 a 800
  valorFotocelda = constrain(valorFotocelda, 150, 800);
  // Mapear o convertir el valor registrado por la fotocelda a un valor entre 0 y 255;
  int voltaje = map(valorFotocelda, 150, 800, 0, 255);  
  analogWrite(pinSalida, voltaje);
}

Utilizar una fotocelda para establecer un valor de voltaje específico a partir del cual se encienden o se apagan dos LEDs de forma alternada.

const int pinEntrada = A0;
const int pinSalida1 = 12;
const int pinSalida2 = 13;
int valorFotocelda;     //variable que almacena la lectura analógica
 
void setup() {
  pinMode(pinSalida1, OUTPUT);
  pinMode(pinSalida2, OUTPUT);
  // Inicia la comunicción serial de Arduino con el computador a una velocidad de 9600 bits por segundo
  Serial.begin(9600);
}

void loop() {
  // Realizar lectura analógica del potenciometro
  valorFotocelda = analogRead(pinEntrada);
  // Imprimir en el monitor serial el valor registrado por la fotocelda
  Serial.println(valorFotocelda);
  // Comprobar las condiciones para el apagado o encendido de los LEDs
  if (valorFotocelda <= 512) {
   digitalWrite(pinSalida1, HIGH);
   digitalWrite(pinSalida2, LOW);
  } 
  else {
   digitalWrite(pinSalida1, LOW);
   digitalWrite(pinSalida2, HIGH);
  }
}

img_1708img_1709img_1711img_1713

Tarde de Arduino

En esta nueva sesión de estudio repasamos y aprendimos sobre la plataforma arduino. Lo primero fue bajar el programa al computador, lo cual hicimos usando directamente el centro de software de Ubuntu. Exploramos y conocimos las diferentes partes del entorno integrado de desarrollo (IDE) y conectamos la placa de Arduino UNO para iniciar la experimentación.

img_1618

img_1622

img_1613

Realizados varios ejercicios sencillos para aprender a programar el Arduino. En primer lugar hicimos un programa para controlar el encendido y apagado de un LED utilizando una salida digital con diferentes tiempos de espera.


void setup() {
pinMode(11, OUTPUT);
}
void loop() {
digitalWrite(11, HIGH); // Prende el led
delay(1000); // Espera un segundo
digitalWrite(11, LOW); // Apaga el led
delay(500); // Espera medio segundo
}

El siguiente programa usa una salida PWM (analógica) del Arduino para regular el voltaje del led entre 0 y 5 voltios.


void setup() {
}
void loop() {
analogWrite(11, 128); // prende el led a 2.5v (0=0v , 255=5v)
}

Por último desarrollamos un programa cíclico  usando for, para encender y apagar progresivamente un LED con la salida PWM de la placa de Arduino.


void setup() {
}
void loop() {
for (int pasos = 0 ; pasos <= 255; pasos += 5) { analogWrite(11, pasos); delay(30); } for (int pasos = 255 ; pasos >= 0; pasos -= 5) {
analogWrite(11, pasos);
delay(30);
}
}

Primeros circuitos

Fuente de energía variable

El día de hoy empezamos con un circuito muy sencillo: una fuente de energía variable. Usamos un par de resistencias (R1-6.8k , R2-220), un transistor 3904 (npn) y un potenciómetro (100k).

img_1554img_1561
img_1558

Generador de audio

Para ensamblar este segundo circuito usando de base un circuito integrado 555  para generar señales de audio. El modo del circuito es Astable el cual cambiamos para tener una par de de variaciones…

img_1565img_1562img_1568img_1569

Links