CURSO EMBEBIDOS

LABORATORIO NUMERO 11

En este laboratorio se usara una matriz de 8x8 de catodo comun para reemplazar la que se usaría en este laboratorio, la cual era una matriz de 8x5 de cátodo comun.

hay dos formas de mostrar letras o caracteres en las matrices de leds. el metodo show y el metodo como frecuencytimmer.

METODO SHOW

En este metodo se mostrara el manejo por completo de la matriz de 8x8 de catodo comun, lo cual nos permitira mostrar el mensaje letra por letra, pero sin un desplazamiento.

METODO FRECUENCY TIMER

Usaramos la libreria FrequencyTimer2 para hacer un mejor manejo de los tiempos de aparicion y recorrido de las letras al igual del encendido de los mismos leds.

Los Métodos

todos los métodos son estáticos, los llaman con un FrequencyTimer2: frente.

setPeriod (microsegundos largos sin signo): Establezca el período para el número especificado de microsegundos. El límite inferior es 1, el límite superior es una función de la velocidad de reloj, 2 ^ 18 relojes. Se resuelve a cerca de 30 Hz en un reloj de 16MHz. Si usted piensa en hercios, y luego pasar 1000000L/hertz.
unsigned long getPeriod(): Devuelva el período real. Esto puede ser diferente, ya que pidió a uno de los límites, o el código tenía que utilizar un divisor de reloj para mantener el contador en el rango. A menos que usted salió de los límites que usted debe esperar que se trata de menos de 0,5% de su valor solicitado.
enable (); Comience moviendo el pin de salida. Usted todavía tiene que hacer un pinMode (11, OUTPUT) si desea sacar activamente, de lo contrario, sólo tiene que utilizar la resistencia de pull-up.
disable(:): Detener moviendo el pin de salida. Lleve la unidad a un uso general. (No PWM.)
setOnOverflow (void (* func) ()): Ajuste la función de desbordamiento. Esto se llama al final de cada ciclo. . Ajuste en 0 para desactivar la alarma Nota bien: si el período es demasiado rápido se bloqueará sólo el manejo de las interrupciones. Un simple incrementor contador se bloquea en algún lugar bajo 15US. gcc se ve obligado a generar una gran cantidad de registro se mueve para apoyar las funciones de C y C + + como manejador de interrupciones. Funciones más complicadas tendrán períodos de fracaso más altas. Recuerde estas palabras cuando el boceto se bloquea.

Ventajas

-Usted recibe una señal de salida estable, sin fluctuaciones.

-No hay limitaciones de tiempo en su código.

-Usted puede conectar fácilmente el código en una interrupción periódica con un intervalo de tiempo de su elección.

Desventajas

-Te cuesta Timer2 y sus salidas PWM asociados, 11 y 3 (sobre un ATmega168).

tamaño

-La biblioteca es de aproximadamente 600 bytes más 4 bytes de SRAM.

MATERIALES

1 arduino mega adk

matriz de leds 8x8 catodo comun

computador

DIAGRAMA DE MONTAJE EN PROTOBOARD

DIAGRAMA ESQUEMÁTICO

DIAGRAMA PARA MONTAJE EN TARJETA PERFORADA

FOTOS

foto 1

foto 2

foto 3

foto 4

CÓDIGO ARDUINO MÉTODO SHOW

byte A[]={

B00111100,

B01000010,

B10000001,

B11111111,

B10000001,

B10000001};

byte I[]={

B01111100,

B00010000,

B01111100};

byte J[]={

B01111100,

B00010000,

B10010000,

B01100000};

byte L[]={

B10000000,

B10000001,

B11111111};

byte N[]={

B10000001,

B11000001,

B10100001,

B10010001,

B10001001,

B10000101,

B10000011,

B10000001};

byte U[]={

B10000001,

B01000010,

B00111100};

byte blanco[]={

B00000000,

B00000000};

byte smiley[] = {

B00111100,

B01000010,

B10010101,

B10100001,

B10010101,

B01000010,

B00111100};

const int columnPins[] = { 2, 3, 4, 5, 6, 7, 8, 9};

const int rowPins[] = { 22,23,24,25,26,27,28,29};

void setup() {

for (int i = 0; i < 8; i++)

{

pinMode(rowPins[i], OUTPUT); // make all the LED pins outputs

pinMode(columnPins[i], OUTPUT);

digitalWrite(columnPins[i], HIGH); // disconnect column pins from Ground

}

void loop() {

int pulseDelay = 800 ; // milliseconds to wait between beats

show(J, 1000); // show the small heart image for 100 ms

show(U, 1000); // followed by the big heart for 200ms

show(L, 1000); // show the small heart image for 100 ms

show(I, 1000); // followed by the big heart for 200ms

show(A, 1000); // show the small heart image for 100 ms

show(N, 1000); // followed by the big heart for 200ms

show(smiley, 1000); // followed by the big heart for 200ms

delay(pulseDelay); // show nothing between beats

}

// routine to show a frame of an image stored in the array pointed to by the

// image parameter.

// the frame is repeated for the given duration in milliseconds

void show( byte * image, unsigned long duration)

{

unsigned long start = millis(); // begin timing the animation

while (start + duration > millis()) // loop until the duration period has passed

{

for(int row = 0; row < 8; row++)

{

digitalWrite(rowPins[row], HIGH); // connect row to +5 volts

for(int column = 0; column < 8; column++)

{

boolean pixel = bitRead(image[row],column);

if(pixel == 1)

{

digitalWrite(columnPins[column], LOW); // connect column to Gnd

}

delayMicroseconds(300); // a small delay for each LED

digitalWrite(columnPins[column], HIGH); // disconnect column from Gnd

}

digitalWrite(rowPins[row], LOW); // disconnect LEDs

}

CÓDIGO ARDUINO MÉTODO TIMMER FRECUENCY

//Se incluye la libreria FrequencyTimer2

#include <FrequencyTimer2.h>

//matrix 5x5

//se declara la variable temCol de tipo entero inicializada en 5

int temCol = 5;

//se declara la variable temFil de tipo entero inicializada en 5

int temFil = 5;

//se definen las matrices de letras [A-Z]

#define A { \

{1, 1, 1, 1, 1}, \

{1, 0, 0, 0, 1}, \

{1, 1, 1, 1, 1}, \

{1, 0, 0, 0, 1}, \

{1, 0, 0, 0, 1} \

}

#define B { \

{1, 1, 1, 1, 0}, \

{1, 0, 0, 0, 1}, \

{1, 1, 1, 1, 0}, \

{1, 0, 0, 0, 1}, \

{1, 1, 1, 1, 0} \

}

#define C { \

{1, 1, 1, 1, 1}, \

{1, 0, 0, 0, 0}, \

{1, 1, 1, 1, 1} \

}

#define D { \

{1, 1, 1, 1, 0}, \

{1, 0, 0, 0, 1}, \

{1, 1, 1, 1, 0} \

}

#define E { \

{1, 1, 1, 1, 1}, \

{1, 0, 0, 0, 0}, \

{1, 1, 1, 1, 1}, \

{1, 0, 0, 0, 0}, \

{1, 1, 1, 1, 1} \

}

#define F { \

{1, 1, 1, 1, 1}, \

{1, 0, 0, 0, 0}, \

{1, 1, 1, 1, 0}, \

{1, 0, 0, 0, 0}, \

{1, 0, 0, 0, 0} \

}

#define G { \

{1, 0, 1, 1, 1}, \

{1, 0, 0, 0, 0}, \

{1, 1, 1, 1, 1}, \

{1, 0, 0, 0, 1}, \

{1, 1, 1, 1, 1} \

}

#define H { \

{1, 0, 0, 0, 1}, \

{1, 1, 1, 1, 1}, \

{1, 0, 0, 0, 1}, \

{1, 0, 0, 0, 1} \

}

#define I { \

{1, 1, 1, 1, 1}, \

{0, 0, 1, 0, 0}, \

{1, 1, 1, 1, 1} \

}

#define J { \

{1, 1, 1, 1, 1}, \

{1, 0, 1, 0, 0}, \

{0, 0, 1, 0, 0}, \

{1, 1, 1, 0, 0} \

}

#define K { \

{1, 0, 0, 0, 1}, \

{1, 0, 0, 1, 0}, \

{1, 1, 1, 0, 0}, \

{1, 0, 0, 1, 0}, \

{1, 0, 0, 0, 1} \

}

#define L { \

{1, 0, 0, 0, 0}, \

{1, 1, 1, 1, 1} \

}

#define M { \

{1, 1, 0, 1, 1}, \

{1, 0, 1, 0, 1}, \

{1, 0, 0, 0, 1}, \

{1, 0, 0, 0, 1} \

}

#define N { \

{1, 0, 0, 0, 1}, \

{1, 1, 0, 0, 1}, \

{1, 0, 1, 0, 1}, \

{1, 0, 0, 1, 1}, \

{1, 0, 0, 0, 1} \

}

#define O { \

{0, 1, 1, 1, 0}, \

{1, 0, 0, 0, 1}, \

{0, 1, 1, 1, 0} \

}

#define P { \

{1, 1, 1, 1, 1}, \

{1, 0, 0, 0, 1}, \

{1, 1, 1, 1, 1}, \

{1, 0, 0, 0, 0}, \

{1, 0, 0, 0, 0} \

}

#define Q { \

{1, 1, 1, 1, 1}, \

{1, 0, 0, 0, 1}, \

{1, 0, 0, 1, 1}, \

{1, 1, 1, 1, 1} \

}

#define R { \

{1, 1, 1, 1, 0}, \

{1, 0, 0, 0, 1}, \

{1, 1, 1, 1, 0}, \

{1, 0, 0, 1, 0}, \

{1, 0, 0, 0, 1} \

}

#define S { \

{0, 1, 1, 1, 1}, \

{1, 0, 0, 0, 0}, \

{0, 1, 1, 1, 0}, \

{0, 0, 0, 0, 1}, \

{1, 1, 1, 1, 0} \

}

#define T { \

{1, 1, 1, 1, 1}, \

{0, 0, 1, 0, 0}, \

{0, 0, 1, 0, 0} \

}

#define U { \

{1, 0, 0, 0, 1}, \

{1, 1, 1, 1, 1} \

}

#define V { \

{1, 0, 0, 0, 1}, \

{0, 1, 0, 1, 0}, \

{0, 0, 1, 0, 0} \

}

#define W { \

{1, 0, 0, 0, 1}, \

{1, 0, 1, 0, 1}, \

{1, 1, 0, 1, 1}, \

{1, 0, 0, 0, 1} \

}

#define X { \

{1, 0, 0, 0, 1}, \

{0, 1, 0, 1, 0}, \

{0, 0, 1, 0, 0}, \

{0, 1, 0, 1, 0}, \

{1, 0, 0, 0, 1} \

}

#define Y { \

{1, 0, 0, 0, 1}, \

{0, 1, 1, 1, 0}, \

{0, 0, 1, 0, 0}, \

{0, 0, 1, 0, 0} \

}

#define Z { \

{1, 1, 1, 1, 1}, \

{1, 0, 0, 1, 0}, \

{0, 0, 1, 0, 0}, \

{0, 1, 0, 0, 1}, \

{1, 1, 1, 1, 1} \

}

#define blanco { \

{0, 0, 0, 0, 0}, \

{0, 0, 0, 0, 0} \

}

//se declara la variable col2 de tipo intero enicializada en 0

int col2 = 0;

//se declara la variable tiempoEspera de tipo entero inicializada en 150

int tiempoEspera = 150;

//se declara la variable numLetras de tipo entero inicializada en 27

const int numLetras = 27;

//se declara la variable letras de tipo matrix de entero

int letras [numLetras][5][5] = {

A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,blanco

};

//matrix 5x8

//se declara la variable numCol de tipo entero inicializada en 5

const int numCol = 5;

//se declara la variable numFil de tipo entero inicializada en 8

const int numFil = 8;

//se declara la variable matrixLeds de tipo matrix de entero

int matrixLeds[numFil][numCol];

//filas

//se declara la variable constante fil de tipo vector de entero

const int fil[numFil] = {

22,23,24,25,26,27,28,29};

//columnas

//se declara la variable constante col de tipo vector de entero inicializada en 5

const int col[numCol] = {

2, 3, 4, 5, 6};

void setup(){

for(int i = 0; i < numFil; i++) {

//pines de salida

pinMode(fil[i], OUTPUT);

//Se apaga el led,

digitalWrite(fil[i],LOW);

}

for(int i = 0; i < numCol; i++) {

//pines de salida

pinMode(col[i], OUTPUT);

//Se apaga el led,

digitalWrite(col[i],LOW);

}

//comunicacion serial a 9600bps

Serial.begin(9600);

FrequencyTimer2::disable();

FrequencyTimer2::setPeriod(2000);

FrequencyTimer2::setOnOverflow(display);

}

void loop(){

if(Serial.available() > 0) {

byte dato = Serial.read();

//si el dato esta entre A-Z o a-z

if((64 < dato && dato < 91) || (96 < dato && dato < 123)){

//pasamos a mayuscula el caracter

byte caracterMayuscula = toUpperCase(dato);

//cargamos el caracter en la matrix matrixLeds

//y movemos cada pixel de posicion

moveCharater(caracterMayuscula-65);

} else

//si hay un espacio

if(dato == 32){

moveCharater(numLetras-1);

}

} else {

moveCharater(numLetras-1);

}

void obtenerCaracter(int posicionCaracter){

int posicion = numFil - temCol;

for(int j = 0; j < temFil; j++) {

for(int i = 0; i < temCol; i++) {

matrixLeds[i+posicion][temCol-1-j] = letras[posicionCaracter][j][i];

}

void siguinteCaracter(int posicionCaracter, int temFila){

int matrixTem[temFil][temCol];

for(int i = 0; i < temFil; i++) {

for(int j = 0; j < temCol; j++) {

matrixTem[j][4-i] = letras[posicionCaracter][i][j];

}

for (int j = 0; j < numCol; j++){

matrixLeds[numFil-1][j] = matrixTem[temFila][j];

}

void moveCharater(int posicionCaracter){

int temFila = 0;

do{

for(int i = 0; i < numCol; i++) {

for(int j = 0; j < numFil-1; j++) {

matrixLeds[j][i] = matrixLeds[j+1][i];

}

siguinteCaracter(posicionCaracter, temFila);

delay(tiempoEspera);

temFila++;

} while(temFila < numFil);

}

void display(){

digitalWrite(col[col2], HIGH);

col2++;

if (col2 == 5) {

col2 = 0;

}

for (int row2 = 0; row2 < 8; row2++) {

if (matrixLeds[row2][col2] == 1) {

digitalWrite(fil[row2], HIGH);

}

else {

digitalWrite(fil[row2], LOW);

}

digitalWrite(col[col2], LOW);

}

VÍDEO MÉTODO SHOW

MÉTODO FRENCUENCY TIMMER

CURSO EMBEBIDOS

sábado, 26 de octubre de 2013

No hay comentarios:

Publicar un comentario

Datos personales