Entrada Analogica

 

 

Ejemplo de uso de las entradas y salidas analogicas junto con un monitor serial

/*
Este ejemplo lee el valor de un potenciometro y lo pone en la salida
en forma de un solo led controlando el brillo
 
Ideal para aprender, entradas analogicas, salidas analogicas, comunicacion serial
 
Codigo de dominio publico wwww.suallabs.com 2014
 
 */
int analogInPin = A0;  
// Entrada analogica donde se pone el potenciometro
int led = 9;
// El pin donde estara el LED
int sensorValue = 0;        
// Variable donde se guarda el valor del sensor
int outputValue = 0;        
// Variable para guardar el valor de la salida
 
void setup() {
  Serial.begin(9600);
// Inicializa la comunicacion serial
  pinMode(led, OUTPUT);
// Inicializa la salida  
}
 
void loop() {
  sensorValue = analogRead(analogInPin);            
// lee la entrada del potenciometro
  outputValue = map(sensorValue, 0, 1023, 0, 255);
// mapea el valor de entrada de 0 a 1023 a un nuevo valor de 0 a 255
  analogWrite(led, outputValue);  
// escribe el valor mapeado en la salida analogica
 
   Serial.print("sensor = " );                       
   Serial.print(sensorValue);      
   Serial.print(" salida = ");      
   Serial.println(outputValue);   
  // Escribe los resultados en el monitor serial
 
  delay(10);                     
// espera dos milisegundos antes de la siguente interaccion
}
 
 
Material Necesario:
 

Lector de IR

 

/*
Recibidor de comandos IR, demuestra el uso de la libreria IRrecv
el sensor IR debe ser conectado al PIN 11 que en este caso es donde
se leen los codigos.
Copyright 2009 Ken Shirriff
http://arcfn.com
*/
 
#include <IRremote.h>
// Llama a la libreria que controla el IR
 
int RECV_PIN = 11;
IRrecv irrecv(RECV_PIN);
// Define donde se conectara el sensor IR
decode_results results;
// Define la variable results
void setup()
{
  Serial.begin(9600);
// Inicia la comunicacion serial
  irrecv.enableIRIn(); 
// Inicia el recibidor
}
 
void loop() {
  if (irrecv.decode(&results)) {
    Serial.println(results.value, HEX);
    irrecv.resume(); 
// Recibe el proximo valor
  }
}
 
Material Necesario:

 


Control de un relevador con IR

 

/*
Este pequeño programa lee un codigo IR y con el enciende un relevador.
El sensor IR debe ser conectado al PIN 11 que en este caso es donde
se leen los codigos.
En el pin 10 un relevador
Copyright 2009 Ken Shirriff
http://arcfn.com
*/
 
#include <IRremote.h>
// Llama a la libreria que controla el IR
 
int RECV_PIN = 11;
//Pin donde se conecta el sensor IR
int relevador = 10;
//Pin donde se conecta el relevador
long valor = 0x000000;
//Variable de trabajo
long valorUno = 0x20DF10EF;
//Valor para encender el Relevador
long valorDos = 0xFFFFFFFF;
//Valor que se envia cuando se pulsa dos veces la misma tecla
long temp = 0xFFFFFFFF;
//Valor temporal de trabajo
IRrecv irrecv(RECV_PIN);
//Inicializa el sensor IR
decode_results results;
// Define la variable results
void setup()
{
  Serial.begin(9600);
// Inicia la comunicacion serial
  irrecv.enableIRIn(); 
// Inicia el recibidor de IR
 pinMode(relevador, OUTPUT);    
}
 
void loop() {
  if (irrecv.decode(&results)) {
    //Recibe el primer valor IR
    irrecv.resume(); 
    //Para la recepcion de señales IR
  }
  valor = results.value;
  //Extrae el valor IR
  delay (10);
  //Retardo de seguridad
  if (valor != valorDos){
  temp = valor;
  //Si el valor recibido es diferente de valorDos guarda el valor en Temp
  Serial.print("temp ");
  Serial.println(temp, HEX);
  //Despliega el valor Temporal
  }
  else {
  valor = temp;
  //Se recibio una tecla repetida asi que se recupera el valor guardado
  Serial.print("valor ");
  Serial.println(valor, HEX);
  //Despliega el valor guardado
  }
  if (valor == valorUno){
    //El valor es igual a valorUno
    digitalWrite(relevador, HIGH);
    //Enciende el relevador
    Serial.println("  -- on");
    //Despliega la instruccion
  }
  else{
    digitalWrite(relevador, LOW);  
    //Apaga el relevador
    Serial.println(" -- Off");
    //Despliega la instruccion
  }
}
 
 

Control de un display 5x7 matriz de LEDs

 

 

/*
* Fuente: http://www.arduino.cc/playground/Main/DirectDriveLEDMatrix
*
* Modificaciones para display 5x7 
* por Stefan Wolfrum en July 2012.
* ----------------------------------------
*
* Muestra un mensaje en un display de 5x7 ledsx,
* haciendo un scrolling de derecha a izquierda.
*
* Usa la libreria FrequencyTimer2 para
* constantemente correr una rutina de interrupcion
* a una freciuencia especifica. Esta
* refresca el display sin necesidad de que el loop
* principal haga nada
*
*/
 
#include <FrequencyTimer2.h>
 
#define SPACE { \
{0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0} \
}
 
#define S { \
{0, 1, 1, 1, 0}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 0}, \
{0, 1, 1, 1, 0}, \
{0, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{0, 1, 1, 1, 0} \
}
 
 #define U { \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{0, 1, 1, 1, 0} \
}
 
#define A { \
{0, 0, 1, 0, 0}, \
{0, 1, 0, 1, 0}, \
{1, 0, 0, 0, 1}, \
{1, 1, 1, 1, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1} \
}
 
#define L { \
{1, 0, 0, 0, 0}, \
{1, 0, 0, 0, 0}, \
{1, 0, 0, 0, 0}, \
{1, 0, 0, 0, 0}, \
{1, 0, 0, 0, 0}, \
{1, 0, 0, 0, 0}, \
{1, 1, 1, 1, 1} \
}
 
#define B { \
{1, 1, 1, 1, 0}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 1, 1, 1, 0}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 1, 1, 1, 0} \
 
#define H { \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 1, 1, 1, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1} \
}
 
#define E { \
{1, 1, 1, 1, 1}, \
{1, 0, 0, 0, 0}, \
{1, 0, 0, 0, 0}, \
{1, 1, 1, 1, 0}, \
{1, 0, 0, 0, 0}, \
{1, 0, 0, 0, 0}, \
{1, 1, 1, 1, 1} \
}
 
#define small_E { \
{0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0}, \
{0, 1, 1, 1, 0}, \
{1, 0, 0, 0, 1}, \
{1, 1, 1, 1, 0}, \
{1, 0, 0, 0, 0}, \
{0, 1, 1, 1, 0} \
}
 
#define L { \
{1, 0, 0, 0, 0}, \
{1, 0, 0, 0, 0}, \
{1, 0, 0, 0, 0}, \
{1, 0, 0, 0, 0}, \
{1, 0, 0, 0, 0}, \
{1, 0, 0, 0, 0}, \
{1, 1, 1, 1, 1} \
}
 
#define small_L { \
{0, 1, 1, 0, 0}, \
{0, 0, 1, 0, 0}, \
{0, 0, 1, 0, 0}, \
{0, 0, 1, 0, 0}, \
{0, 0, 1, 0, 0}, \
{0, 0, 1, 0, 0}, \
{0, 1, 1, 1, 0} \
}
 
#define O { \
{0, 1, 1, 1, 0}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{0, 1, 1, 1, 0} \
}
 
#define small_O { \
{0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0}, \
{0, 1, 1, 1, 0}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{0, 1, 1, 1, 0} \
}
 
#define small_W { \
{0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 1, 0, 1}, \
{1, 0, 1, 0, 1}, \
{0, 1, 0, 1, 0} \
}
 
#define small_R { \
{0, 0, 0, 0, 0}, \
{0, 0, 0, 0, 0}, \
{0, 1, 0, 1, 1}, \
{0, 1, 1, 0, 0}, \
{0, 1, 0, 0, 0}, \
{0, 1, 0, 0, 0}, \
{0, 1, 0, 0, 0} \
}
 
#define small_D { \
{0, 0, 0, 0, 1}, \
{0, 0, 0, 0, 1}, \
{0, 1, 1, 0, 1}, \
{1, 0, 0, 1, 1}, \
{1, 0, 0, 0, 1}, \
{1, 0, 0, 0, 1}, \
{0, 1, 1, 1, 1} \
}
 
// Definicion de todas las letras que se usan en el programa
byte col = 0;
byte leds[5][7];
// columnas y renglones
 
// pin[xx] en la matriz de leds conectados a nn en Arduino
// (-1 es un ajuste para hacer que el array empiece en la posicion 1)
int pins[13]= {-1, 2, 9, 3, 11, 12, 13, 5, 6, 10, 4, 8, 7};
 
// col[xx] de leds = pin yy en la matriz de leds
int cols[5] = {pins[1], pins[3], pins[10], pins[7], pins[8]};
 
// row[xx] de leds = pin yy en la matriz de leds
int rows[7] = {pins[12], pins[11], pins[2], pins[9],
 pins[4], pins[5], pins[6]};
 
//const int numPatterns = 12;
//byte patterns[numPatterns][7][5] = {
// SPACE, H, small_E, small_L, small_L, small_O,
// SPACE, small_W, small_O, small_R, small_L, small_D
//};
 
const int numPatterns = 10;
byte patterns[numPatterns][7][5] = {
 SPACE, S, U, A, L, SPACE, L, A, B, S
};
// Mensaje a desplegar
 
int pattern = 0;
 
void setup()
{
  // Define estos pines como salida
  for (int i = 1; i <= 12; i++) {
    pinMode(pins[i], OUTPUT);
  }
 
  // Pone un cero en las columnas y los renglones
  for (int i = 1; i <= 5; i++) {
    digitalWrite(cols[i - 1], LOW);
  }
 
  for (int i = 1; i <= 7; i++) {
    digitalWrite(rows[i - 1], LOW);
  }
 
  clearLeds();
 
  // Apaga el toggle del pin 11
  FrequencyTimer2::disable();
  // Define la taza de refresqueo (periodo de tiempo de las interrupciones)
  FrequencyTimer2::setPeriod(2000);
  // Define la interrupcion para que sea llamada
  FrequencyTimer2::setOnOverflow(display);
 
  setPattern(pattern);
}
 
void loop()
{
  pattern = ++pattern % numPatterns;
  slidePattern(pattern, 100);
}
 
void clearLeds()
{
  // Limpia el arreglo del display
  for (int i = 0; i < 5; i++) {
    for (int j = 0; j < 7; j++) {
      leds[i][j] = 0;
    }
  }
}
 
void setPattern(int pattern)
{
// Llena la variable leds con el contenido de la letra 
  for (int i = 0; i < 5; i++) {
    for (int j = 0; j < 7; j++) {
      leds[i][j] = patterns[pattern][j][i];
    }
  }
}
 
void slidePattern(int pattern, int del)
{
  for (int newcol = 0; newcol <= 4; newcol++) {
 
    // Rota las primeras cuatro columnas a la izquierda
    for (int row = 0; row <= 6; row++)
      for (int col = 0; col <= 3; col++)
        leds[col][row] = leds[col+1][row];
 
    // Llena la ultima columna (Quinta) con el
    // 1st (2nd, 3rd, ...) columna del nuevo patron o letra
    for (int row = 0; row <= 6; row++)
      leds[4][row] = patterns[pattern][row][newcol];
 
    delay(del);
  }
}
 
// Rutina de interrupciones
void display()
{
  // Apaga todas las columnas previas:
  digitalWrite(cols[col], LOW);
  col++;
  if (col == 5) {
    col = 0;
  }
  for (int row = 0; row < 7; row++) {
    if (leds[col][row] == 1) {
      digitalWrite(rows[row], LOW); // Enciende este led
    }
    else {
      digitalWrite(rows[row], HIGH); // Apaga este led
    }
  }
  // Apaga todas las columnas al mismo tiempo (para iluminar por tiempos iguales):
  digitalWrite(cols[col], HIGH);
}
 

Baja la libreria AQUI

Material Necesario:

 


 
 

Control de un sensor de distancia URM37

 

Codigo para ajustar el sensor

Este codigo se usa para ajustar la distancia a la que el sensor va a emviar la señal de obstaculo
 
 
/*Nombre del producto: Escáner Ultrasónico
      SKU Producto:SEN0001
      Versión :  3.2
 
Descripción:
Este ejemplo muestra como ajustar el modo de evento autónomo modificando la memoria EEPROM
 
Conexión:
      Pin 1 VCC (URM V3.2) -> VCC (Arduino)
      Pin 2 GND (URM V3.2) -> GND (Arduino)
      Pin 8 RXD (URM V3.2) -> RXD Pin 0 (Arduino)
      Pin 9 TXD (URM V3.2) -> TXD Pin 1 (Arduino)
*/
int cmmd1[]={
  0x44,0x00,0x10,0x54};
//byte bajo guardado en el sensor para el umbral de distancia
int cmmd2[]={
  0x44,0x01,0x00,0x45};
//byte alto, escribe 0x0010 en la dirección 0x01 y 0x00 para que el umbral sea 16cms
int cmmd3[]={
  0x44,0x02,0xaa,0xf0};
//modo autónomo. escribe 0xAA en la dirección 0x02
int i;
 
void setup(){                                 
  Serial.begin(9600);                        
//Pone el baud rate a 9600
  A_Mode_Setup();                            
//Llama a la función
}
 
void loop()
{
}                      
 
void A_Mode_Setup(){ 
//escribe los datos en la memoria del URM37
  for (i=0;i<4;i++)
    Serial.write(cmmd3[i]);                             
  delay(200);                                           
 
  for (i=0;i<4;i++)
    Serial.write(cmmd1[i]);
  delay(200);
 
  for (i=0;i<4;i++)
    Serial.write(cmmd2[i]);
  delay(200);
 
}
 
Codigo para leer el sensor
 
 
   
    Este código interpreta el sensor en el led del PIN 13
 
/*
En este programa se usa el LED del PIN13 como testigo
para saber si existe un obstáculo frente al
sensor que está en el PIN2
 
SUAL LABS 2014
Programa de dominio Publico
*/
 
int pinSensor = 2; 
//Pin del sensor 
int pinLed = 13; 
//Pin del led
int estadoSensor = 0; 
// Variable para estado del sensor
 
void setup() { 
pinMode(pinLed, OUTPUT); 
// Pin 13 salida 
pinMode(pinSensor, INPUT); 
// Pin 2 entrada 
 
void loop(){ 
  estadoSensor = digitalRead(pinSensor); 
  // Lee el valor del pin del sensor y lo almacena 
  // en la variable estadoSensor 
  if (estadoSensor == LOW) {
   // Si tenemos obstáculo entonces encendemos el LED
   digitalWrite(pinLed, HIGH);
   } else { 
   // No tenemos obstáculo entonces apagamos el LED
 digitalWrite(pinLed, LOW); 
 } 
 }