ICs

jueves, 30 de agosto de 2018

Sensor de Sonido

El sensor de sonido puede usarse a través de una entrada digital para detectar un aplauso o un silbido.
Ejemplo 
Vamos a ejemplificar el uso del sensor para encender un LED con un aplauso



Actividad
Modificar el sketch anterior para que el led quede encendido hasta un nuevo aplauso, donde se apaga.

Actividad
Modificar el sketch anterior para que cada vez que detecte un ruido vaya encendiendo un led de una fila de 5 led's.

domingo, 26 de agosto de 2018

Controlando una Luz a 220V con arduino

El relé  o relevador es un dispositivo electromagnético que funciona como un interruptor. 
Con una tensión de 5 Volt puede controlarse otros dispositivos que funcionan con tensiones mayores, como por ejemplo una lámpara de 220 Volt. 


Sensor de Temperatura y Humedad DHT11

El DHT11 es un  sensores que permite realizar la medición simultánea de temperatura y humedad.
Dispone de un procesador interno que realiza el proceso de medición, proporcionando la medición mediante una señal digital, por lo que resulta muy sencillo obtener la medición desde un microprocesador como Arduino.

viernes, 24 de agosto de 2018

Sensor de movimiento Infra Rojo (PIR)

Los sensores infrarrojos pasivos (PIR) son dispositivos para la detección de movimiento. 
Los sensores PIR se basan en la medición de la radiación infrarroja. Todos los cuerpos  emiten una cierta cantidad de energía infrarroja (especialmente los seres vivos), mayor cuanto mayor es su temperatura. Los dispositivos PIR disponen de un sensor  capaz de captar esta radiación y convertirla en una señal eléctrica.

Sensor Ultrasónico para medir distancia

El funcionamiento es simple, envía una señal ultrasónica inaudible y nos entrega el tiempo que demoro en ir y venir hasta el obstáculo mas cercano que detecto.

miércoles, 22 de agosto de 2018

Sensor LDR

Un fotoresistor, o LDR (light-dependent resistor) es un dispositivo cuya resistencia varia en función de la luz recibida. Podemos usar esta variación para medir, a través de las entradas analógicas, una estimación del nivel del luz.
Por lo tanto, un fotoresistor disminuye su resistencia a medida que aumenta la luz sobre él. Los valores típicos son de 1 Mohm (MegaOhm) en total oscuridad, a 50-100 Ohm bajo luz brillante.




viernes, 10 de agosto de 2018

Motores

Uno de los posibles actuadores  con los que podemos trabajar son aquellos que transforman las señales eléctricas en movimiento

Vamos a ver  tres  tipos de motores:


  1. Servomotor o simplemente Servo 
  2. Motor Paso a Paso conocido como PAP. Stepper en ingles
  3. Motor CC (corriente continua).  DC en inglés


domingo, 5 de agosto de 2018

Entradas Analógicas



Hemos visto que en las entradas digitales admite los estados lógicos 0 y 1. Como ejemplo usamos un pulsador.

La función para leer su estado digitalRead (2);  //leemos el pin 2

Si quisiéramos medir la temperatura tenemos que usar un sensor que de un rango de valores. Es necesario un sensor que dé más que un 0 y un 1.
Para registrar los valores de este sensor se necesita una entrada analógica. 
La placa ARDUINO UNO tiene seis pines especiales. de A0  a  A5



miércoles, 1 de agosto de 2018

Salidas Analógicas

Ya hemos visto las entradas y salidas digitales. Son aquellas que admiten dos estados:


Estados
Apagado
Encendido
Eléctricamente
0 Volt
5 Volt
Lógicamente
0
1

Como salida digital hemos visto un Led. Puede estar apagado o encendido totalmente.
Pero ¿Cómo puede un led ir variando su intensidad de forma gradual? ¿Cómo puede controlarse la velocidad de un motor?
Para ello se necesita una salida analógica que sea capaz de darnos los valores intermedios de tensión entre 0 Volt y 5 Volt.
En Arduino se simulan éstas salidas a través de algunos pines que están señalados con el símbolo ~
Éstos son los pines : 3; 5; 6; 9; 10 y  11


domingo, 15 de julio de 2018

Estructuras de Control


Las estructuras de CONTROL permite tomar decisiones dentro del Sketch
Veremos como ejemplo:
  • if, else    Toma la decisión de realizar una sentencia (acción) u otra. 
                         Es preguntar: si pasa "esto" haga tal acción, sino haga otra cosa.
  • for         Permite ejecutar una acción un número determinado de veces.
vamos a agregar otros ejemplos de SALIDAS:
  • Serial   Se crea un Monitor de salida  a través de la pantalla de la computadora.
  • tone  Permite salir con sonido


sábado, 22 de abril de 2017

Radio 2017 Modificaciones

Modificaciones hechas al comando 
de muteadores de Mic y luz de Aire
Al parecer los optoacopladores que ofociaban de interruptores para los circuitos muteadores de los Mic no funcionaban correctamente.. El diodo no llegaba a interrumpir  completamente.
Se reemplazan losoptoacopladores por un módulo de 4 relees. Quedan relees 1y2 ( NA) para los muteadores, 3 Libre y 4 para la luz de Aire (NC). El resto queda como la versión original.
Pulsador de aire entra por Pin7. Las salidas pines 11 y 12 para los relees de lo MI y pin( para luz Aire.
abril 2017

domingo, 11 de diciembre de 2016

Árbol de Navidad 2016

Al árbol que Renata, mi hija, hizo el año pasado con una revista doblando sus hojas le agregue iluminación con Leds de alto brillo y distintos colores. Con un Arduino UNO programe tres secuencias distintas de encendido/apagado que se repiten cíclicamente.

lunes, 2 de mayo de 2016

Pre amplificador para mic eletret

En la asignatura Tecnología de 2º año del colegio "El Taller" debe trabajarse la transmisión de señales. Van a empezar con la construcción de un telégrafo sencillo y creando códigos que permitan transmitirlas (símil código Morse.)
De esta forma se trabajaría con señales digitales (encendido-apagado,sonido-silencio 1-0) La idea es ir llevándolos a la transmisión de señales analógicas  para lo cual se prevé el uso de un micrófono con un pequeño amplificador de 1 watt.
Seleccioné los siguientes prototipos que se ajustan satisfactoriamente para la actividad.

viernes, 15 de abril de 2016

Radio El Taller 2016 V2

En una entrada anterior se planteó un controlador ATtiny 85 para mutear y controlar la luz de aire.
La capacidad de entradas y salidas del controlador estaba saturada. El proyecto no llegó a la luz. Se necesitaba otra acción así que por esta razón y por posibles agregados en el futuro reemplacé el ATtiny por un ATMega 328 (procesador del Arduino UNO).

Una necesidad inmediata era que al hablar por el Talkback desde el control al estudio debía mutearse los micrófonos si es que estuvieran abiertos para evitar que los micrófonos del estudio registraran lo que salía por el monitor. Si eventualmente quisiera que salga lo que dice el operador puede entrar por una entrada de línea en la consola y así salir al aire.

El sketch modificado es:

viernes, 1 de abril de 2016

Sensor de Gas

Sensor de Gas MQ2

Radio El Taller 2016

Dispositivo para mutear ambos micrófonos capacitivos

Características

Microprocesador Attiny 85 con Sketch para mutear dos micrófonos y dar Luz de Aire en el estudio de radio del colegio El Taller.

Al pulsar desde el control comandamos dos opto acopladores que interrumpen el circuito muteador y así evitar  "chasquidos" o ruidos molestos. También se comanda un relé para la luz de Aire.

La luz de Aire necesita tener alta luminosidad dado que debe notarse claramente cuando se esta transmitiendo.Por esa razón se usó una lámpara de auto de 55 W lo que significa una corriente de aproximadamente 4 Amper. Se colocó un modulo de dos relé (uno para posibles ampliaciones) puede manejar hasta 10 Amper.
No estoy seguro cual es la corriente capaz de manejar entre el colector y emisor de manera que sólo los uso para interrumpir el circuito de los muteadores.
Este es el espejo del impreso tal cual debe transferirse del lado del cobre al PCB.
El circuitoi muteador lo obtuve del siguiente enlace:

https://drive.google.com/file/d/0B8MJa3b2n46_bjRIRGFhVHpTZFE/view

Los opto acopladores se ubican en los puntos AB como interruptores. Se eliminan las fichas plug del circuito original.

El sketch es una modificación del ejemplo provisto en el IDE del Arduino "Debounce" que elimina el rebote ocasionado por el pulsador en su accionar (limitación técnica) y ocasiona error de lectura de su estado.
En el sketch original cada vez que se pulsa cambia de prendido a apagado de un Led.lamodificación consistió en reemplazar al led por los dos opto acopladores ( led IR) y un relé. con la salvedad que el relé debe estar en oposición a los optoa copladores. De manera que al estar en alta la bobina del no está energizada.

*********************************************************************************

/* Radio El Taller marzo 2016
basado en el ejemplo debounce para eliminar el rebote de un pulsador
el pulsador comanda dos optoacopladores para manejar los muteadores y un rele para la luzde AIRE

pines Attiny
pulsador ---> A3
opto 1 -----> 1
opto 2 -----> 2
Luz aire(rele) --->0
5Volt pin 8
Gnd pin 4

 The circuit:
 * optoacoplador 4N35 a pin 1 llega del Attiny y lleva  resistencia 220 Ohm  y pin 2 a Gnd
 * en pin 5 y  pin 4  van en serie los MUTEADORES de los MIC puntos A-B
 *

 ********************************************************************************************/

// constantes para seteo de pines

const int buttonPin = A3;    // pin pulsador
const int Opto1 = 1;      // pines Opto
const int Opto2 = 2;    
 

const int LuzAire = 0;      //pin para luz

// Variables
int OptoState = LOW;         // estado inicial para los pines de salida
int ReleState = HIGH;        // estado inicial para el rele bobina no exitada
int buttonState;             //  estado del pulsador
int lastButtonState = LOW;   // estado previo del pulsador

// las siguientes variables son del tipo long, milisegundos que crecen muy rapido
long lastDebounceTime = 0;  // ultimo instante que se digitó el pulsador
long debounceDelay = 50;    // the debounce time; increase if the output flickers

void setup() {
  pinMode(buttonPin, INPUT);
  pinMode(Opto1, OUTPUT);
  pinMode(Opto2, OUTPUT);
  pinMode(LuzAire,OUTPUT);
 
  // seteo inicial de los pines de salida
  digitalWrite(Opto1, OptoState);
  digitalWrite(Opto2, OptoState);

    digitalWrite(LuzAire, ReleState);
}

void loop() {
  // lectura del estado del pulsador. Se guarda en una variable local
  int reading = digitalRead(buttonPin);

  // checkea si se digitó elpulsador
  // cambia de estado
  // y espera para evitar los rebotes antes
  //de ordenar el cambio de estado de los pines de salida

  // si se pulsó, resetea el tiempo
  //y con el siguiente if se pregunta por el tiempo de espera
  if (reading != lastButtonState) {
    // reset the debouncing timer
    lastDebounceTime = millis();
  }

  if ((millis() - lastDebounceTime) > debounceDelay) {
    // whatever the reading is at, it's been there for longer
    // than the debounce delay, so take it as the actual current state:

    // if the button state has changed:
    if (reading != buttonState) {
      buttonState = reading;

      // only toggle the LED if the new button state is HIGH
      if (buttonState == HIGH) {
        OptoState = !OptoState;
      ReleState =!ReleState;
      }
    }
  }

  // set the LED:
  digitalWrite(Opto1, OptoState);
  digitalWrite(Opto2, OptoState);
 // digitalWrite(Opto3, OptoState);
  digitalWrite(LuzAire, ReleState);
  // save the reading.  Next time through the loop,
  // it'll be the lastButtonState:
  lastButtonState = reading;
}

*********************************************************************************

Esquema de conexión

La alimentación es un transformador de 9 Volt y se coloca un regulador 7805 para alimentar el microcontrolador.


viernes, 11 de marzo de 2016

Luz Estroboscópica

Una luz estroboscópica es una luz que parpadea con una determinada frecuencia.
Con Arduino puede variarse esta frecuencia a través de la lectura analógica de un potenciómetro.
Este es un proyecto sencillo que saque del siguiente sitio:

http://superawesomebook.com/strobe/


sólo que se me ocurrió agregarle un control de velocidad a un motor de DC de manera que al iluminarlo con la luz estroboscópica lograra verse detenido.

Detalles para su construcción

Reciclé una linterna de leds de 9 leds alimentados con una fuente externa de 4,5volts. Para controlarlos con Arduino agregar un transistor BC547b.
El motor, también alimentado con 4,5 volt de la fuente externa, se controlo con un Mosfet IRF520. Ambos transistores provistos por el starter kit de Arduino.


Esquema de conexión





Video



Sketch

/***************************************************************************
Luz estroboscopica con Motor DC
Led en pin 13 
Motor en pin PWM  9
Potenciometro Led en A2
potenciometro en A1

marzo 2016
****************************************************************************/  
int analogPin = 2; // entrada analógica para la frecuencia de parpadeo del Led
int velMotor = 1  // entrada analógica para la velocidad del motor
int ledPin = 13; // Salida para Led
int motor =9;  // Salida PWM para motor 
  // How much time should the light stay on between delays, in Microseconds (millionths of a second)?
    /* Big number = more blur, more perceived brightness
     * Small number = less blur, less perceived brightness  */
  long onTime = 250;

  // What should the minimum delay be in milliseconds (thousandths of a second)?
  // This sets the bottom delay range of the strobe, as a delay of 0 doesn't actually flash =P
  // The strobe starts with this as the "fastest" mode, and goes slower from there, adding to the delay
  int minDelay = 1; // 1 is the lowest we can actually do without a better delay function  

  // What should the maximum delay be in milliseconds?
  // This is the longest time that the biggest potentiometer value will be mapped to, and longest
  // time between strobe flashes.
  int maxDelay = 100;




// Initialize the number to hold our strobe delay. Isn't used till we get to the main loop
long strobeDelay = 0;

void setup() {
 pinMode(ledPin, OUTPUT); // Setup ledPin as an output.
pinMode(motor,OUTPUT);
}

void loop() {
  // To make the math easier, we use map(value, fromMin, fromMax, toMin, toMax) to convert the
  // 0 to 1023 range we get from analogRead, into our strobe delay range of 1 to 100 :D
  strobeDelay = map(analogRead(analogPin), 0, 1023, minDelay, maxDelay);

  digitalWrite (ledPin, HIGH); // Switch the ledPin to HIGH, turn it on!
  delay Microseconds(onTime); // Delay while on, for the given onTime.
  digitalWrite(ledPin, LOW); // Switch the ledPin to LOW, turn if off!
  delay (strobeDelay); // Delay while off, for given strobeDelay.
int vel=analogRead(A1);

analogWrite (motor,vel);


}


miércoles, 27 de enero de 2016

Simular presencia encendiendo y apagando luces

Introducción

Este no es el primer proyecto que desarrollo con Arduino pero es el primero que quiero documentar en forma ordenada para poder mostrarlo y compartirlo. Luego de jugar, copiar y modificar proyectos sencillos sacados en la web empecé a pensar en aquellos que sirvieran en satisfacer alguna necesidad. Ante la inminente salida de vacaciones mi esposa me preguntó si podríamos colocar algún dispositivo que simule nuestra presencia en la casa prendiendo y apagando las luces para que puedan verse desde la calle. Existen los relojes que uno puede programar pero consideré que tenía algunas desventajas. Por ejemplo es necesario un reloj por cada luz sobre la que actuar y lo segundo es que debe hacerse un programa para que cada día tenga horarios diferentes de encendido/apagado. Con Arduino se simplifica bastante. Primero con una placa que comande un módulo de relés, uno para cada circuito.Luego con programación se puede pensar fácilmente un algoritmo que varíe el horario para cada día ya sea aleatoriamente o con un array de 7 elementos. Para solucionarlo en pocas horas pensé en una primera versión que en resumen hace:

  •  se introducen en variables arrays la hora y minutos de encendido y de apagado de una sola luz
  • elegí hacerlo en una secuencia que se repite cada  tres días
  • con sólo la elección de éstos tres horarios puedo modificarlos  sumando o restando para tener otros grupos de horarios para encender otras luces.
  • queda pendiente para la próxima versión hacer que sea aleatorio la elección de los horarios. 
Los Materiales
  • Placa Arduino UNO
  • Modulo de 4 relés
  • Modulo Tiny RTC I2C

Sketch

/*VACACIONES
 *  Programa para encendido/apagado automático de 2 luces  
 *  tres dias diferentes
 *  para dos reles
 *  enero 2016
 *  Flavio Ragazzi *  
 */
#include <Wire.h>
#include "RTClib.h"
RTC_DS1307 RTC;

int factor; //determinación de  día 0, 1 ó 3

int HoraIn =21 ; // Hora para el  encendido
int HoraOut = 23; //Hora para el  apagado
int MinIn[] ={45,39,23};  // minutos para el encendido  
int MinOut[] ={8,17,3}; // minutos para el apagado 
int Retraso[] ={7,11,9}; //retraso para en encendido de la segunda luz

void setup () {
    Serial.begin(9600);
    Wire.begin();
    RTC.begin();
    pinMode(10,OUTPUT);  // pin para comando de rele 1
    pinMode(12,OUTPUT);  // pin para comando de rele 2

  
  if (! RTC.isrunning()) {
    Serial.println("RTC  NO FUNCIONA!");
    // setea elmodulo RTC con la fecha  de la PC cuando fue compilado/cargado el sketch
    RTC.adjust(DateTime(__DATE__, __TIME__)); 
  }
}
void loop () {
    DateTime now = RTC.now(); 
    
    Serial.print(now.day(), DEC);
    Serial.print(' ');
    Serial.print(now.hour(), DEC);
    Serial.print(':');
    Serial.println(now.minute(), DEC);
  
        delay(1000);

factor= now.day()%3; //determinación si se trata de día 1,2 ò 3 factor es el resto que resulta de dividir el día por tres

Serial.print("dia:");
Serial.print(factor);
Serial.print(' ');
Serial.print("hora de encendido : ");
Serial.print(HoraIn);
Serial.print(':');
Serial.print(MinIn[factor]);
Serial.print(' ');
Serial.print("hora de apagado : ");
Serial.print(HoraOut);
Serial.print(':');
Serial.println(MinOut[factor]);

// para elencendido
if(now.hour()==HoraIn && now.minute()>=MinIn[factor]){
  digitalWrite(10,LOW);
  if(now.hour()==HoraIn && now.minute()>= (MinIn[factor]+Retraso[factor])){
    digitalWrite(12,LOW);
    }
  }
//para el apagado  
if(now.hour()==HoraOut && now.minute()>= MinOut[factor]){
    digitalWrite(10,HIGH);
    if(now.hour()==HoraOut && now.minute()>= (MinOut[factor]+Retraso[factor])){
    digitalWrite(12,HIGH);
    }
}
}