Proyecto Final TermoHigrometro

Termohigrometro


Descripción del Laboratorio

El termohigrómetro es un equipo que mide la temperatura y la humedad relativa del aire y del

 medio ambiente.

Es utilizado especialmente en los centros hospitalarios  (EPS, IPS)  ya que debe haber un manejo y control de los medicamentos en dicho recinto para prevenir reaciiones adeversas a medicamentos(RAM) que me afecten tanto como al paciente y el personal medico asistencial, Igualmente se puede en cualquier tipo de recinto, que queramos conocer la temperatura y humedad.

Lista de los Elementos utilizados

• Computador con el IDE de Arduino y Processing 
• Tarjeta Arduino
• Cable USB; COM7
• Protoboard
• Cables macho-macho
• Sensor DHT 11
• IC MAX 7219
• Matriz LED 8x8

Proceso del Montaje paso a paso (Fotos)

El sensor DHT11 se encuentra conectado a 3.3v y la matriz a 5v.

Código Fuente en Arduino (con comentarios)

//Proyecto Final Sistemas embebidos.
//Angelica maria campo mancilla
//Universidad santiago de cali

//Libreria del sensor y de la matrix.
#include <MaxMatrix.h>
#include <LedControl.h>
#include "DHT.h"
#define DHTPIN 7     // Pin al que esta conectado el DHT11
#define DHTTYPE DHT11   // Tipo de sensor DHT11
DHT dht(DHTPIN, DHTTYPE);

PROGMEM unsigned char const CH[] = {
3, 8, B00000000, B00000000, B00000000, B00000000, B00000000, // space
1, 8, B01011111, B00000000, B00000000, B00000000, B00000000, // !
3, 8, B00000011, B00000000, B00000011, B00000000, B00000000, // "
5, 8, B00010100, B00111110, B00010100, B00111110, B00010100, // #
4, 8, B00100100, B01101010, B00101011, B00010010, B00000000, // $
5, 8, B01100011, B00010011, B00001000, B01100100, B01100011, // %
5, 8, B00110110, B01001001, B01010110, B00100000, B01010000, // &
1, 8, B00000011, B00000000, B00000000, B00000000, B00000000, // '
3, 8, B00011100, B00100010, B01000001, B00000000, B00000000, // (
3, 8, B01000001, B00100010, B00011100, B00000000, B00000000, // )
5, 8, B00101000, B00011000, B00001110, B00011000, B00101000, // *
5, 8, B00001000, B00001000, B00111110, B00001000, B00001000, // +
2, 8, B10110000, B01110000, B00000000, B00000000, B00000000, // ,
4, 8, B00001000, B00001000, B00001000, B00001000, B00000000, // -
2, 8, B01100000, B01100000, B00000000, B00000000, B00000000, // .
4, 8, B01100000, B00011000, B00000110, B00000001, B00000000, // /
4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // 0
3, 8, B01000010, B01111111, B01000000, B00000000, B00000000, // 1
4, 8, B01100010, B01010001, B01001001, B01000110, B00000000, // 2
4, 8, B00100010, B01000001, B01001001, B00110110, B00000000, // 3
4, 8, B00011000, B00010100, B00010010, B01111111, B00000000, // 4
4, 8, B00100111, B01000101, B01000101, B00111001, B00000000, // 5
4, 8, B00111110, B01001001, B01001001, B00110000, B00000000, // 6
4, 8, B01100001, B00010001, B00001001, B00000111, B00000000, // 7
4, 8, B00110110, B01001001, B01001001, B00110110, B00000000, // 8
4, 8, B00000110, B01001001, B01001001, B00111110, B00000000, // 9
2, 8, B01010000, B00000000, B00000000, B00000000, B00000000, // :
2, 8, B10000000, B01010000, B00000000, B00000000, B00000000, // ;
3, 8, B00010000, B00101000, B01000100, B00000000, B00000000, // <
3, 8, B00010100, B00010100, B00010100, B00000000, B00000000, // =
3, 8, B01000100, B00101000, B00010000, B00000000, B00000000, // >
4, 8, B00000010, B01011001, B00001001, B00000110, B00000000, // ?
5, 8, B00111110, B01001001, B01010101, B01011101, B00001110, // @
4, 8, B01111110, B00010001, B00010001, B01111110, B00000000, // A
4, 8, B01111111, B01001001, B01001001, B00110110, B00000000, // B
4, 8, B00111110, B01000001, B01000001, B00100010, B00000000, // C
4, 8, B01111111, B01000001, B01000001, B00111110, B00000000, // D
4, 8, B01111111, B01001001, B01001001, B01000001, B00000000, // E
4, 8, B01111111, B00001001, B00001001, B00000001, B00000000, // F
4, 8, B00111110, B01000001, B01001001, B01111010, B00000000, // G
4, 8, B01111111, B00001000, B00001000, B01111111, B00000000, // H
3, 8, B01000001, B01111111, B01000001, B00000000, B00000000, // I
4, 8, B00110000, B01000000, B01000001, B00111111, B00000000, // J
4, 8, B01111111, B00001000, B00010100, B01100011, B00000000, // K
4, 8, B01111111, B01000000, B01000000, B01000000, B00000000, // L
5, 8, B01111111, B00000010, B00001100, B00000010, B01111111, // M
5, 8, B01111111, B00000100, B00001000, B00010000, B01111111, // N
4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // O
4, 8, B01111111, B00001001, B00001001, B00000110, B00000000, // P
4, 8, B00111110, B01000001, B01000001, B10111110, B00000000, // Q
4, 8, B01111111, B00001001, B00001001, B01110110, B00000000, // R
4, 8, B01000110, B01001001, B01001001, B00110010, B00000000, // S
5, 8, B00000001, B00000001, B01111111, B00000001, B00000001, // T
4, 8, B00111111, B01000000, B01000000, B00111111, B00000000, // U
5, 8, B00001111, B00110000, B01000000, B00110000, B00001111, // V
5, 8, B00111111, B01000000, B00111000, B01000000, B00111111, // W
5, 8, B01100011, B00010100, B00001000, B00010100, B01100011, // X
5, 8, B00000111, B00001000, B01110000, B00001000, B00000111, // Y
4, 8, B01100001, B01010001, B01001001, B01000111, B00000000, // Z
2, 8, B01111111, B01000001, B00000000, B00000000, B00000000, // [
4, 8, B00000001, B00000110, B00011000, B01100000, B00000000, // \ backslash
2, 8, B01000001, B01111111, B00000000, B00000000, B00000000, // ]
3, 8, B00000010, B00000001, B00000010, B00000000, B00000000, // hat
4, 8, B01000000, B01000000, B01000000, B01000000, B00000000, // _
2, 8, B00000001, B00000010, B00000000, B00000000, B00000000, // `
4, 8, B00100000, B01010100, B01010100, B01111000, B00000000, // a
4, 8, B01111111, B01000100, B01000100, B00111000, B00000000, // b
4, 8, B00111000, B01000100, B01000100, B00101000, B00000000, // c
4, 8, B00111000, B01000100, B01000100, B01111111, B00000000, // d
4, 8, B00111000, B01010100, B01010100, B00011000, B00000000, // e
3, 8, B00000100, B01111110, B00000101, B00000000, B00000000, // f
4, 8, B10011000, B10100100, B10100100, B01111000, B00000000, // g
4, 8, B01111111, B00000100, B00000100, B01111000, B00000000, // h
3, 8, B01000100, B01111101, B01000000, B00000000, B00000000, // i
4, 8, B01000000, B10000000, B10000100, B01111101, B00000000, // j
4, 8, B01111111, B00010000, B00101000, B01000100, B00000000, // k
3, 8, B01000001, B01111111, B01000000, B00000000, B00000000, // l
5, 8, B01111100, B00000100, B01111100, B00000100, B01111000, // m
4, 8, B01111100, B00000100, B00000100, B01111000, B00000000, // n
4, 8, B00111000, B01000100, B01000100, B00111000, B00000000, // o
4, 8, B11111100, B00100100, B00100100, B00011000, B00000000, // p
4, 8, B00011000, B00100100, B00100100, B11111100, B00000000, // q
4, 8, B01111100, B00001000, B00000100, B00000100, B00000000, // r
4, 8, B01001000, B01010100, B01010100, B00100100, B00000000, // s
3, 8, B00000100, B00111111, B01000100, B00000000, B00000000, // t
4, 8, B00111100, B01000000, B01000000, B01111100, B00000000, // u
5, 8, B00011100, B00100000, B01000000, B00100000, B00011100, // v
5, 8, B00111100, B01000000, B00111100, B01000000, B00111100, // w
5, 8, B01000100, B00101000, B00010000, B00101000, B01000100, // x
4, 8, B10011100, B10100000, B10100000, B01111100, B00000000, // y
3, 8, B01100100, B01010100, B01001100, B00000000, B00000000, // z
3, 8, B00001000, B00110110, B01000001, B00000000, B00000000, // {
1, 8, B01111111, B00000000, B00000000, B00000000, B00000000, // |
3, 8, B01000001, B00110110, B00001000, B00000000, B00000000, // }
4, 8, B00001000, B00000100, B00001000, B00000100, B00000000, // ~
};

int data = 8;    // DIN pin del módulo MAX7219
int load = 9;    // CS pin del módulo MAX7219
int clock = 10;  // CLK pin del módulo MAX7219
int maxInUse = 1;    // Cuantos módulos MAX7219 se estan usando
MaxMatrix m(data, load, clock, maxInUse);
byte buffer[10];

void setup(){
  pinMode(2,INPUT); // Entrada de Botón
  m.init();
  m.setIntensity(15); // Intensidad luminosa de la matriz
  Serial.begin(9600);
  Serial.println("Iniciando sensor");
  dht.begin();
}

void loop(){
 
  printStringWithShift("Temperatura y Humedad ", 75);
  int t = dht.readTemperature();
  char temp[4];
  itoa(t,temp,10);
  Serial.println(temp);
  printStringWithShift("Temperatura: ", 100);
  printStringWithShift(temp, 100);
  printStringWithShift("C ", 100);
  delay(100);
  m.shiftLeft(false, true);
  int h = dht.readHumidity();
  char hum[4];
  itoa(h,hum,10);
  Serial.println(hum);
  printStringWithShift(" Humedad: ", 100);
  printStringWithShift(hum, 100);
  printStringWithShift("% ", 100);
  delay(100);
  m.shiftLeft(false, true);
  }


void printCharWithShift(char c, int shift_speed){
  if (c < 32) return;
  c -= 32;
  memcpy_P(buffer, CH + 7*c, 7);
  m.writeSprite(32, 0, buffer);
  m.setColumn(32 + buffer[0], 0);
 
  for (int i=0; i<buffer[0]+1; i++)
  {
    delay(shift_speed);
    m.shiftLeft(false, false);
  }
}

void printStringWithShift(char* s, int shift_speed){
  while (*s != 0){
    printCharWithShift(*s, shift_speed);
    s++;
  }
}

void printString(char* s)
{
  int col = 0;
  while (*s != 0)
  {
    if (*s < 32) continue;
    char c = *s - 32;
    memcpy_P(buffer, CH + 7*c, 7);
    m.writeSprite(col, 0, buffer);
    m.setColumn(col + buffer[0], 0);
    col += buffer[0] + 1;
    s++;
  }
}

Vídeo del Funcionamiento

Laboratorio 9

Laboratorio 9
Descripción del Laboratorio
El objetivo del siguiente laboratorio es el de Controlar desde una interfaz en Processing, los patrones de movimiento de los colores ( rojo, verde y azul)  de un módulo de 8 LEDs RGB controlados con el Arduino.
Lista de los Elementos utilizados
Computador con el IDE de Arduino y Processing 
Tarjeta Arduino
Cable USB; COM7
Protoboard
Cables macho-macho
 2 LEDS RGB
 6 LEDS ROJO
Diagrama del Montaje en la Protoboard

Diagrama Esquemático del Circuito

Diagrama PCB equivalente

Proceso del Montaje paso a paso (Fotos)

Código Fuente en Arduino (con comentarios)
//****** Proyecto *****//
// Universidad Santiago de Cali
// Angelica maria campo mancilla
// Laboratorio #9
// Descripcion: Manejo del modulo Led RGB( 2 leds rgb y 6 leds rojo) a través de una interfaz
// grafica en processing

/********** Variables **********/
// se nombran las variables y sus respectivos pines

#define TOTAL 8
#define MAX 8

//Declaracion de pines y de arreglos
// Conectamos el LED a los pines,9,10,11 que es PWM

// salida pwm  para el color rojo
int pin_r = 9;
// salida pwm  para el color verde
int pin_g = 10;
// salida pwm  para el color rojo
int pin_b = 11;

// Indica los pines en el que debe estar conectado el modulo

int led[TOTAL] = {2, 3, 4, 5, 6, 7, 8, 12};

// Se inicializan los datos de cada variable de color

int R[TOTAL]={0,0,0,0,0,0,0,0};
int G[TOTAL]={0,0,0,0,0,0,0,0};
int B[TOTAL]={0,0,0,0,0,0,0,0};

// Variables de cada componenten Inicializadas

int pos = 0;
int color = 0;
int estado = 0;
String str = "";

 /********** Configuracion **********/
void setup() {

 //comunicacion serial sera a 9600 baudios y pines inicializados con sus estados

  Serial.begin(9600);
  for (int i = 0; i < TOTAL; i++) {
  pinMode(led[i], OUTPUT);
  digitalWrite(led[i], HIGH);
  }

  // se configuran las salidas PWM usadas
    // pin de salida, color rojo

  pinMode(pin_r, OUTPUT);
  digitalWrite(pin_r, HIGH);

  // pin de salida, color verde
  pinMode(pin_g, OUTPUT);
  digitalWrite(pin_g, HIGH);

  // pin de salida, color azul
  pinMode(pin_b, OUTPUT);
  digitalWrite(pin_b, HIGH);
}
  /********** Ciclo Principal **********/
 // Solo se ejecuta una vez, al iniciar o resetear el Arduino
// Ciclo infinito de ejecucion

void loop() {
  leerSerial();
  for (int i=0; i<TOTAL; i++) {
    encender(led[i], R[i], G[i], B[i]);
  }
}
    // aqui se condiciona si el valor enviado  para
    // la intensidad del pin R, G o B del modulo
 
//metodo necesario para leer la informacion serial

void leerSerial() {
  if (Serial.available() > 0) {
    str = Serial.readString();
    pos = int(str[1] - '0');
    estado = int(str[2] - '0');
    switch (str[0]) {
      case 'r': R[pos] = estado; break;;
      case 'g': G[pos] = estado; break;;
      case 'b': B[pos] = estado; break;; }}}
   
//metodo para encender cada led deacuardo al pin usado
void encender (int pin_led, int r, int g, int b)
{
  digitalWrite(pin_led, LOW);
  digitalWrite(pin_r, r == 0 ? HIGH : LOW);
  digitalWrite(pin_g, g == 0 ? HIGH : LOW);
  digitalWrite(pin_b, b == 0 ? HIGH : LOW);

  delay(2);

  digitalWrite(pin_led, HIGH);
  digitalWrite(pin_r, HIGH);
  digitalWrite(pin_g, HIGH);
  digitalWrite(pin_b, HIGH);
}

/*********** Fin**************/
Código Fuente en Processing (con comentarios)
/********** Proyecto **********
 * Universidad santiago de cali
 * Angelica maria campo Mancilla.
 * Laboratorio 09: se controlan los patrones de movimiento de colores ( rojo, verde y azul)  de un
 * módulo de 8 LEDs RGB controlados desde una interfaz gráfica en Processing/ControlP5.*/

 // Importamos las librerías de ControlP5 y Serial
import controlP5.*;
import processing.serial.*;

// Se Definen las variables necesarias

ControlP5 cp5;
Serial serial;

// define las variables del texto, tipo Textlabel

Textlabel texto1, texto2;
Textlabel texto5, texto6;

//****** Objetos ********//

// Areglos para las variables de cada color: rojo, verde, azul.

int[] r = new int[] {0, 0, 0, 0, 0, 0, 0, 0};
int[] g= new int[] {0, 0, 0, 0, 0, 0, 0, 0};
int[] b= new int[] {0, 0, 0, 0, 0, 0, 0, 0};

//**** variables*****//

int colorDeFondo = color (200,100,100);

//***********configuracion*********************//

// Solo se ejecuta una vez, al iniciar el Sketch//

void setup() {

  size(600, 300); // tamaño de la ventana

   // crear el objeto ControlP5
  cp5 = new ControlP5(this);

  // crear un botón para encender/apagar cada LED
  // para el color rojo

  for (int i=0; i<r.length; i++)
    cp5.addToggle("r"+i, 35+i*70, 60, 50, 40);

  // para el color verde

  for (int j=0; j<g.length; j++)
    cp5.addToggle("g"+j, 35+j*70, 130, 50, 40);

   // para el color azul

  for (int k=0; k<b.length; k++)
    cp5.addToggle("b"+k, 35+k*70, 200, 50, 40);
 
  // Creamos el objeto del puerto Serial
   serial = new Serial(this, Serial.list()[0], 9600);
 
   // Se crea el texto principal
 
texto1 = cp5.addTextlabel("label")


                    .setText("CONTROLES DE ENCENDIDO Y APAGADO")
                    .setPosition(100,10)
                    .setColorValue(0xfffffFFF)
                    .setFont(createFont("Arial",20))
                    ;

// crea texto indicativo

texto2 = cp5.addTextlabel("label1")

                    .setText("COLOR ROJO VERDE Y AZUL")
                    .setPosition(180,30)
                    .setColorValue(0xffffffFF)
                    .setFont(createFont("Comic Sans MS",15))
                    ;            

}

// se dibujar cada frame y se asigna el color de fondo

void draw()
{
 {background(colorDeFondo);}
}

// actua cuando ocurra un evento con los botones

void controlEvent(ControlEvent theEvent)
{
  // guardar el nombre y valor del evento
  String nombre = theEvent.getController().getName();
  int valor = int(theEvent.getController().getValue());

  println("evento: " + nombre + " / valor: "+valor);
  //serial.write(nombre+valor);
  println(nombre+valor);
  serial.write(nombre+valor);


}


// ****** Fin ***** //
Video del Funcionamiento

Laboratorio 11

Laboratorio 11.
Descripción del Laboratorio

El objetivo del siguiente laboratorio es el de Enviar desde una interfaz en Processing; el mensaje que deseamos para que se visualice en una matriz LED 8x8 (desplazándose de izquierda a derecha) a través del integrado IC MAX7219 y el control se dará a través de arduino.

Lista de los Elementos utilizados

Computador con el IDE de Arduino y Processing

Tarjeta Arduino

Cable USB; COM5

Protoboard

Cables macho-macho

IC MAX 7219

Matriz LED 8x8

Diagrama del Montaje en la Protoboard

Diagrama Esquemático del Circuito

Proceso del Montaje paso a paso (Fotos)

Código Fuente en Arduino (con comentarios)

/********** Proyecto **********
 * Universidad Santiago de Cali
 * Angelica maria campo
 * Laboratorio 11: Envio de mensajes utilizando processing y se visualiza en Matriz LED
 * Descripcion: Mostrar un mensaje desplazándose de izquierda
 * a derecha en una matriz LED 8x8 a través de IC MAX7219 enviado
 * desde un Arduino, usando una interfaz en Processing.*/

 /********** Librerías **********/
 #include <LedControl.h>



/********** Variables **********/
// se nombran las variables y sus respectivos pines

//se inicializa la variable data_in en el PIN 9
int data_in = 9;
 //se inicializa la variable clock en el PIN 7
int clock = 7;
//se inicializa la variable CS en el PIN 8
int cs = 8;  

String texto = "ABCDE abcde 01234 ";

/********** Objetos **********/

//se instacia un objeto de ledControl para utilizar los PINES
LedControl lc = LedControl(data_in, clock, cs, 1);  

// Tiempo que esperamos entre las actualizaciones del display * /

 unsigned long delaytime = 100;

/********** Configuración **********/
 void setup() {
//comunicacion serial sera a 9600 baudios y pines inicializados con sus estados
  Serial.begin(9600);

 //El MAX72XX está en modo de ahorro de energía en el arranque,
   //tenemos que llamadarlo para encenderlo  */

  lc.shutdown(0, false);
  // se Establece e brillo del display.
  lc.setIntensity(0, 8);

//Se encarga de limpiar el Display/
  lc.clearDisplay(0);
}
// Se crea el arreglo necesario para las letras en mayuscula, minusculas y números.

byte letras[63][5] = { {B11111110, B00010001, B00010001, B00010001, B11111110}, //A

  {0xFF, 0x89, 0x89, 0x89, 0x76},//B

  {B01111110, B10000001, B10000001, B10000001, B01000110}, //C

  {0xff, 0x81, 0x81, 0x81, 0x7e},//D
  {0x7e, 0x89, 0x89, 0x89, 0x89},//E
  {0xff, 0x09, 0x09, 0x09, 0x01},//F
  {0x7e, 0x89, 0x89, 0x89, 0xf2},//G
  {0xFF, 0x18, 0x18, 0x18, 0xff}, //H

  {B00000000, B10000100, B11111101, B10000000, B00000000}, //I

  {0x71, 0x81, 0x7f, 0x01, 0x01},//J
  {0xff, 0x10, 0x2c, 0x42, 0x81},//K
  {0x7f, 0xc0, 0x80, 0x80, 0x80}, //L
  {0xff, 0x06, 0x0c, 0x06, 0xff},//M

  {B11111111, B00000100, B00001000, B00010000, B11111111}, //N
  {B01111110, B10000001, B10000001, B10000001, B01111110}, //O

  {0xff, 0x09, 0x09, 0x09, 0x06},//P
  {0xbe, 0x41, 0xA1, 0x81, 0x7e}, //Q

  {B11111111, B00010001, B00110001, B01010001, B10001110}, //R

  {0x86, 0x89, 0x89, 0x89, 0x71},//S
  {0x01, 0x01, 0xff, 0x01, 0x01},//T

  {B01111111, B11000000, B11000000, B11000000, B01111111}, //U

  {0x3f, 0x40, 0x80, 0x40, 0x3f},//V
  {0x7f, 0x80, 0x70, 0x80, 0x7f},//W
  {0xe3, 0x14, 0x08, 0x14, 0xe3},//X
  {0x03, 0x04, 0xf8, 0x04, 0x03},//Y
  {0xe1, 0x91, 0x89, 0x85, 0x83},//Z
  {0xd68, 0xd94, 0xd94, 0xd78, 0xd80},//a
  {0xdfc, 0xd60, 0xd90, 0xd90, 0xd60},//b
  {0xd78, 0xd84, 0xd84, 0xd84, 0x48},//c
  {0xd60, 0xd90, 0xd90, 0xd60, 0xdfc},//d
  {0x78, 0x94, 0x94, 0x94, 0x58},//e

   {B11111100, B00100100, B00100100, B00000100, B00000100},//f
  {B00001000, B10010100, B10010100, B10110100, B01001000},//g
  {B11111100, B00100000, B00010000, B00010000, B11100000},//h
  {B00000000, B00000000, B11110100, B00000000, B00000000},//i
  {B10000000, B10000000, B01110100, B00000000, B00000000},//j
  {B11111100, B00100000, B01010000, B10001000, B00000000},//k
  {B00000000, B00000000, B11111100, B10000000, B00000000},//l
  {B11111100, B00001000, B11110000, B00001000, B11110000},//m

  {0x78, 0x94, 0x94, 0x94, 0x58},//n
  {0x78, 0x94, 0x94, 0x94, 0x58},//o
  {0x78, 0x94, 0x94, 0x94, 0x58},//p
  {0x78, 0x94, 0x94, 0x94, 0x58},//q
  {0x78, 0x94, 0x94, 0x94, 0x58},//r
  {0x78, 0x94, 0x94, 0x94, 0x58},//s
  {0x78, 0x94, 0x94, 0x94, 0x58},//t
  {0x78, 0x94, 0x94, 0x94, 0x58},//u
  {0x78, 0x94, 0x94, 0x94, 0x58},//v
  {0x78, 0x94, 0x94, 0x94, 0x58},//w
  {0x78, 0x94, 0x94, 0x94, 0x58},//x
  {0x78, 0x94, 0x94, 0x94, 0x58},//y
  {0x78, 0x94, 0x94, 0x94, 0x58},//z

  {B01111110, B11100001, B10011001, B10000111, B01111110}, //O

  {0x00, 0x82, 0xff, 0x80, 0x00}, //1
  {0xc2, 0xa1, 0x91, 0x89, 0x86},//2
  {0x81, 0x81, 0x85, 0x8b, 0x71}, //3
  {0x18, 0x14, 0x12, 0xff, 0x00}, //4
  {0x8f, 0x89, 0x89, 0x89, 0x71},//5
  {0x7c, 0x8a, 0x89, 0x89, 0x70},//6
  {0x01, 0xf1, 0x09, 0x05, 0x03}, //7
  {0x76, 0x89, 0x89, 0x89, 0x76},//8
  {0x06, 0x89, 0x89, 0x89, 0x7e }, //9

  {0x80, 0x00, 0x80, 0x00, 0x80 } // tres puntos
};

/********** Ciclo Principal **********/

 // Este método mostrará los caracteres para el
 //palabra que enviemos uno tras otro en la matriz.*//

void writeArduinoOnMatrix(String mensajea)
{
 // se escriben los datos de los caracteres//

  for (int j = 0; j < mensajea.length(); j++) {
    int pos = 0;
    char ch = mensajea.charAt(j);
 
    if (ch >= 'A' && ch <= 'Z') pos = ch - 'A';
    else if (ch >= 'a' && ch <= 'z') pos = ch - 'a' + 26;
    else if (ch >= '0' && ch <= '9') pos = ch - '0' + 52;
    else pos = 62;
 
    palabras(letras[pos]);
  }
}

void palabras(byte listd[])
{   for (int j = 7; j > -4; j--)
{    for (int i = 4; i > -1; i--) { lc.setRow(0, j + i, listd[i]); }
 
    delay(delaytime);
 
    for (int o = 0; o < 8 ; o++) {
      lc.setRow(0, o, 0);
    }
  }
}
//Método que recibe la cadena de texto y la escribe en la matriz.

void loop() {  writeArduinoOnMatrix(texto);}

/********** Funciones **********/

//método  que se encuentra pendiente de las instrucciones que vienen del processing.

void serialEvent() {
while (Serial.available()) {
texto = Serial.readString();
  }
}

/********** Fin ***********/

Código Fuente en Processing (con comentarios)


/********** Proyecto **********
 * Universidad santiago de cali
 * Angelica maria campo mancilla.
 * Laboratorio 11: Enviar desde una interfaz en Processing un mensaje a una matriz LED 8x8
 (desplazándose de izquierda a derecha) a través de IC MAX7219.*/

/************* Librerias *********/

// Importamos las librerías de ControlP5 y Serial

import processing.serial.*;  // Importamos la librería Serial

import controlP5.*;   // Importamos librería ControlP5

//********* Objetos ********//

// Se Definen las variables necesarias

ControlP5 cp5;                  // Creamos la variable para ControlP5
Serial serial;                  // Creamos la variable para el puerto Serial

String texto = "";              // se inicializa string para leer
                                // del Textfield

//**** variables*****//

 // Areglos para las variables necesarias//
                               
int colorDeFondo = color (300,200,400); // Da el color que deseamos al Fondo de la interfase

//***********configuracion*********************//
// Solo se ejecuta una vez, al iniciar el Sketch//


void setup() {                  // Inicio config

  size(300, 150);               // Tamaño de la Ventana
  PFont font =
    createFont("comic sans",25);     // Fuente usada en la ventana

  cp5 = new ControlP5(this);    // Creamos el objeto de ControlP5

  Textfield field =             // Creamos los objetos Textfield...
     cp5.addTextfield("input")  // determinando sus propiedades...
     .setPosition(25,50)        // posicion
     .setSize(250,40)           // tamaño
     .setFont(font)             // fuente
     .setFocus(true)            // foco
     .setColor(color(294,0,100))// Color de fondo
     ;
   
  // Creamos el objeto del puerto Serial
  serial =                
     new Serial(this, Serial.list()[0], 9600);}

// se dibujar cada frame de escritura y se asigna el color de fondo

void draw()
{  {background(colorDeFondo);}

  String s = "Ingrese el texto"; // se escribe un mensaje para la
                                 // parte superior de la caja de texto
  fill(100);                     // este es el color del texto
  text(s, 95, 20, 250, 100);     // se determina el texto escrito y posicion
}
// actua cuando ocurra un evento, es decir cuando se escriba alguna palabra.

void controlEvent(ControlEvent evento) {
                                 // Cuando ocurra un evento, aquí lo procesamos
                                 // Obtenemos el string escrito dentro
                               
  String mensaje = evento.getController().getStringValue();
  serial.write(mensaje);         // enviamos el String via serial
  println(mensaje);              // //Imprimimos en la consola, para ver que todo va Ok
}



//********** Fin *************//

Video del Funcionamiento

Laboratorio 10

Laboratorio 10.
Descripción del Laboratorio

El objetivo del siguiente laboratorio es el de Controlar desde el Arduino, una matriz LED 8x8 a través del integrado IC MAX7219, para mostrar los números del 0 al 9, dependiendo de la posición del Potenciómetro que vamos indicándole

Lista de los Elementos utilizados

Computador con el IDE de Arduino

Tarjeta Arduino

Cable USB; COM7

Protoboard

Cables macho-macho

Potenciometro 10 kΩ

IC MAX 7219

Matriz LED 8x8

Diagrama del Montaje en la Protoboard

Diagrama Esquemático del Circuito

Diagrama PCB equivalente

Proceso del Montaje paso a paso (Fotos)

Código Fuente en Arduino (con comentarios)


//****** Proyecto *****//
// Universidad Santiago de Cali
// Angelica maria campo mancilla
// Laboratorio #10
// Descripcion:  Controlar desde el Arduino, una matriz LED 8x8 a través de IC MAX7219,
// para mostrar un número del 0 al 9, dependiendo de la posición del Potenciómetro.

/******** Librerias******/
// libreria para controlar la matriz de LED
 #include <LedControl.h>
/********** Variables **********/
// se nombran las variables y sus respectivos pines

int Data = 9; // Se conecta a Data del MAX7219 Al Arduino
int Clock = 10; // Se conecta a CLK del MAX7219 al Arduino
int Latch = 8; // se conecta CS del MAX7219 Al Larch Del Arduino
int POT = A0;  // Se Conecta el Potenciometro

LedControl lc= LedControl(Data,Clock,Latch,POT);

// Determina el retardo entre el envio de datos

unsigned long delaytime=100;

// Datos para realizar un espacio
byte espacio[5]={ B00000000, B00000000, B00000000, B00000000, B00000000};
// Datos del Numero 0
byte cero[5]={ B00111110, B01000001, B01000001, B00111110, B00000000};
// Datos del Numero 1
byte uno[5]={ B01000010, B01111111, B01000000, B00000000, B00000000};
// Datos del Numero 2
byte dos[5]={ B01100010, B01010001, B01001001, B01000110, B00000000};
// Datos del Numero 3
byte tres[5]={ B00100010, B01000001, B01001001, B00110110, B00000000};
// Datos del Numero 4
byte cuatro[5]={ B00011000, B00010100, B00010010, B01111111, B00000000};
// Datos del Numero 5
byte cinco[5]={ B00100111, B01000101, B01000101, B00111001, B00000000};
// Datos del Numero 6
byte seis[5]={ B00111110, B01001001, B01001001, B00110000, B00000000};
// Datos del Numero 7
byte siete[5]={ B01100001, B00010001, B00001001, B00000111, B00000000};
// Datos del Numero 8
byte ocho[5]={ B00110110, B01001001, B01001001, B00110110, B00000000};
// Datos del Numero 9
byte nueve[5]={ B00000110, B01001001, B01001001, B00111110, B00000000};

// Se condiciona si el numero enviado está entre las
// opciones y ejecuta el patron determinado

byte kar[100] =
{
// Datos del espacio
  B00000000, B00000000, B00000000, B00000000, B00000000,
// Datos del Numero 0
  B00111110, B01000001, B01000001, B00111110, B00000000,
// Datos del Numero espacio
  B00000000, B00000000, B00000000, B00000000, B00000000,
// Datos del Numero 1
  B01000010, B01111111, B01000000, B00000000, B00000000,
// Datos del espacio
  B00000000, B00000000, B00000000, B00000000, B00000000,
// Datos del Numero 2
  B01100010, B01010001, B01001001, B01000110, B00000000,
// Datos del espacio
  B00000000, B00000000, B00000000, B00000000, B00000000,
// Datos del Numero 3
  B00100010, B01000001, B01001001, B00110110, B00000000,
// Datos del espacio
  B00000000, B00000000, B00000000, B00000000, B00000000,
// Datos del Numero 4
  B00011000, B00010100, B00010010, B01111111, B00000000,
// Datos del espacio
  B00000000, B00000000, B00000000, B00000000, B00000000,
// Datos del Numero 5
  B00100111, B01000101, B01000101, B00111001, B00000000,
// Datos del espacio
  B00000000, B00000000, B00000000, B00000000, B00000000,
// Datos del Numero 6
  B00111110, B01001001, B01001001, B00110000, B00000000,
// Datos del espacio
  B00000000, B00000000, B00000000, B00000000, B00000000,
// Datos del Numero 7
  B01100001, B00010001, B00001001, B00000111, B00000000,
// Datos del espacio
  B00000000, B00000000, B00000000, B00000000, B00000000,
// Datos del Numero 8
  B00110110, B01001001, B01001001, B00110110, B00000000,
// Datos del espacio
  B00000000, B00000000, B00000000, B00000000, B00000000,
 // Datos del Numero 9
  B00000110, B01001001, B01001001, B00111110, B00000000};

/********** Configuracion **********/

// Solo se ejecuta una vez, al iniciar o resetear el Arduino

void setup()
{
/* Confifuracion de la matriz Led y el MAX7219 */
  lc.shutdown(0,false);  
  lc.setIntensity(0,4);    // configura el brillo
  lc.clearDisplay(0);      // limpiar la pantalla

//pin de entrada para el potenciometro
 pinMode(POT,INPUT);}

// Ciclo infinito de ejecucion//

void loop()

// Dependiendo de cada dígito, se envía a la función display
{
  // la funcion separa el valor recibido en rangos de datos

  int t1=analogRead(POT);
  int pos=map(t1,0,1023,0,94);
  lc.setRow(0,0,0);

 //recorre el arreglo donde se define la secuencia

    lc.setRow(0,0,kar[pos]);
    lc.setRow(0,1,kar[pos+1]);
    lc.setRow(0,2,kar[pos+2]);
    lc.setRow(0,3,kar[pos+3]);
    lc.setRow(0,4,kar[pos+4]);
    lc.setRow(0,5,kar[pos+5]);
    lc.setRow(0,6,kar[pos+6]);
    lc.setRow(0,7,kar[pos+7]);
    lc.setRow(0,8,kar[pos+8]);
    lc.setRow(0,9,kar[pos+9]);
 
    delay(100);
}

/******** Fin*****/

Video del Funcionamiento

Laboratorio 7

Laboratorio 7
Descripción del Laboratorio
El objetivo del siguiente laboratorio es el de controlar un LED RGB desde el Arduino, vía PWM con una interfaz gráfica en Processing/ControlP5, para controlar el valor de cada color del led.
Lista de los Elementos utilizados

Computador con el IDE de Arduino y Processing

Tarjeta Arduino

Cable USB; COM5

Protoboard

Cables macho-macho

Led RGB

4 resistencias 220 Ω
Diagrama del Montaje en la Protoboard

Diagrama Esquemático del Circuito

Diagrama PCB equivalente

Proceso del Montaje paso a paso (Fotos)

Código Fuente en Arduino (con comentarios)

1. #define MAXLED 3 //creamos la variable maxled 3 elementos
3. int led[MAXLED] = {3,5,6}; //creamos un vector para los pines a utilizar
4. int valor = 0; //creamos la variable valor de tipo entero
5. int i = 0; //creamos la variable valor 1 de tipo entero
7. void setup()
8. {
9.  Serial.begin(9600); // la comunicacion serial sera a 9600 baudios
10.  for(int i = 0; i < MAXLED ; i++)
11.  {
12.  pinMode(led[i], OUTPUT); // los pines del 3,5,6 seran de salida
13.  }
14. }
16. void loop()
17. {
18.  if(Serial.available() > 1) // si hay datos en el puerto serial entra a la condicion
19.  {
20.  valor = Serial.read(); // lee lo que hay en el puerto serial
21.  if(valor == 'R')
22.  i = 0;
23.  if(valor == 'G')
24.  i = 1;
25.  if(valor == 'B')
26.  i = 2;
27.  valor = Serial.parseInt(); // lee y toma el siguiente valor convirtiandolo en entero
28.  analogWrite(led[i], valor); // escribe el valor por el pin xx
29.  }
30. }

Código Fuente en Processing (con comentarios)

1. //********** Proyecto **********

   //Lab 7: Controlar un LED RGB desde el Arduino, vía PWM con una interfaz

   // gráfica en Processing/ControlP5 para controlar el valor de cada color

   // Autor: Angelica maria campo Mancilla

   import controlP5.*; // importar libreria controlP5

   import processing.serial.*; // importar libreria serial

   ControlP5 cp5; // definir la variable cp5 del tipo ControlP5

   Knob rojo, verde, azul; // definir la variable rojo,verde y azul del tipo Knob

   Textlabel texto1, texto2, texto3, texto4, texto5, texto6; // definir las variables texto del tipo Textlabel

   Serial serial; // definir la variable serial del tipo Serial

   // configuración inicial

   void setup()

   {

   serial = new Serial(this, Serial.list()[0],9600); // inicializamos el puerto serial a 9600 baudios

   String puerto = Serial.list()[0]; //definimos la variable puerto de tipo cadena

   size(620,400); // tamaño de la ventana

   cp5 = new ControlP5(this); // crear el objeto ControlP5

   // crear el knob para la intensidad de color rojo

   rojo = cp5.addKnob("R",0,255,0,70,120,120);

   rojo.setColor(new CColor(0xFFFFFFFF,0xFFFF0000,0xFF000000,0xFFFFFFFF,0xFFFFFFFF));

   // crear el knob para la intensidad de color verde

   verde = cp5.addKnob("G",0,255,0,260,120,120);

   verde.setColor(new CColor(0xFFFFFFFF,0xFF00FF00,0xFF005F00,0xFFFFFFFF,0xFFFFFFFF));

   // crear el knob para la intensidad de color azul

   azul = cp5.addKnob("B",0,255,0,450,120,120);

   azul.setColor(new CColor(0xFFFFFFFF,0xFF0000FF,0xFF00005f,0xFFFFFFFF,0xFFFFFFFF));

   // crear texto

   texto1 = cp5.addTextlabel("label")

    .setText("Laboratorio 7")

    .setPosition(150,30)

    .setColorValue(0xff000000)

    .setFont(createFont("Tw cen MT",40))

    ;

   texto2 = cp5.addTextlabel("label1")

    .setText("Rojo")

    .setPosition(105,250)

    .setColorValue(0xff000000)

    .setFont(createFont("Comic sans Ms",22))

    ;

   texto3 = cp5.addTextlabel("label2")

    .setText("Verde")

    .setPosition(290,250)

    .setColorValue(0xff000000)

    .setFont(createFont("Comic sans Ms",22))

    ;

   texto4 = cp5.addTextlabel("label3")

    .setText("Azul")

    .setPosition(486,250)

    .setColorValue(0xff000000)

    .setFont(createFont("Comic sans Ms",22))

    ;

   // otra forma de crear texto

   texto4 = new Textlabel(cp5,"Angelica Campo  ",40,290,600,200);

   texto4.setFont(createFont("Tw cen MT",20));

   texto4.setColorValue(0xff000000);

   texto5 = new Textlabel(cp5,"Bioingenieria",40,305,600,200);

   texto5.setFont(createFont("Tw cen MT",20));

   texto5.setColorValue(0xff000000);

   texto6 = new Textlabel(cp5,"USC-2016A",40,320,600,200);

   texto6.setFont(createFont("Tw cen MT",20));

   texto6.setColorValue(0xff000000);

   }

   void draw()

   {

   background(255,255,255); // color de fondo de la ventana

    texto4.draw(this); // introduce el texto en la ventana

    texto5.draw(this);

    texto6.draw(this);

   }

   void controlEvent (ControlEvent evento) // se activa cuando ocurra un evento con los botones

   {

   String nombre = evento.getController().getName(); // recoje el nombre del slider y lo convierte en cadena

   int valor = int(evento.getController().getValue()); // recoje el valor del slider y lo convierte en entero

   serial.write(nombre + ":" + valor); // envia por el puerto serial el nombre y el valor

   println(nombre + ":" + valor); // imprime por pantalla el nombre y el valor

   }

Vídeo del Funcionamiento