lunes, 23 de junio de 2014

Proyecto Arbolduino Navideño



1.- INTRODUCCIÓN
Este proyecto consiste en hacer prototipo de árbol de navidad con Arduino. Es una caja de zapatos forrada de papel de regalo, que aparentemente se ha hecho para que parezca un regalo de navidad. En la planta de la caja está el dibujo de un árbol de navidad en el que el árbol está adornado con los leds que se ha incrustado en el.
Los leds están conectados al Arduino y con la ayuda del potenciómetro podremos elegir el tipo de juego de luces que queramos asignar.
También se ha adaptado un buzzer para que suenen los tonos navideños, enciendo o apagando según se quiera con el interruptor.

2.- MATERIALES
Relación de los materiales utilizados son:

-      Caja de zapatos
-      Papel de regalo
-      Pegamento de cola
-      Tijeras
-      Alfiler
-      Papel fotográfico
-      Impresora
-      18 Leds
-      5 Resistencias
-      Protoboard
-      Cables de conexión
-      Soldador de estaño
-      Termofusible
-      Portátil
-      2 Arduino
-      Buzzer
-      Potenciómetro
-      Botón


3.- DESARROLLO PRÁCTICO
-    Circuito con fritzing.

-    Montaje.


1º Buscar una caja de zapatos y forrar con papel de regalo.

2º Escoger una foto de un árbol de navidad en internet, imprimirlo con papel fotográfico y pegarlo con cola. Una vez hecho esto, se procederá a clavar los 18 leds ayudándonos con un alfiler para hacer los agujeros en la caja.

3º Una vez tengamos la distribución de los leds colocados, procederemos a soldar con estaño formando el circuito. En este caso, se ha formado 5 líneas de leds en paralelo, para que cada línea vaya a un pin del Arduino. Se ha soldado con estaño uniéndolos con cable las patillas de los leds. Cada una de las 5 líneas van unidas al ánodo pasando por una resistencia cada una, llegando hasta los pines (positivo) del Arduino. Por último, todos los leds estarán unidos al cátodo e irán directos a masa (negativo).

4º Seguidamente como queremos que los leds hagan diferentes juegos de luz en las luces del árbol, colocaremos un potenciómetro para que cuando variemos el valor de este (entre 0 y 1024), podamos elegir el juego de luz que queramos. Se conectará a positivo y masa, y el del medio irá a Analogic 0.
    

5º Una vez que ya tenemos toda la parte de los leds hecha, ahora procederemos a crear la parte de sonido, para que suene la caja con tonos navideños. Utilizaremos otro Arduino para esto. Pondremos un botón para poder cerrar y abrir el circuito cuando queramos, es decir, encender o apagar el buzzer.


-    Programación Arduino.
Utilizaremos dos Arduinos. Esto se divide en dos partes. Primero la parte de los leds y segundo la parte del sonido. Lo que pretendía era conectar todo en un Arduino, pero esto no se puede conseguir ya que el Arduino ejecuta las órdenes de forma ordenada y en forma secuencial.

PROGRAMACION JUEGO DE LOS LEDS

int i = 0;
int pinPotenciometro =A0;
int valorPotenciometro = 0;
void setup()
{
  pinMode(pinPotenciometro, INPUT);  //Asigna al potenciometro
  for (i = 2; i < 7; i++)  //Las lineas de leds, abren los pines del 2 al 6
  pinMode(i, OUTPUT);
  Serial.begin(9600);
}
void loop()
{
  valorPotenciometro = analogRead(pinPotenciometro);
  Serial.println(valorPotenciometro, DEC);

  //1 Primer juego de luces
  if (valorPotenciometro > 141 && valorPotenciometro < 332) {  
    digitalWrite(2, HIGH);
    digitalWrite(4, HIGH);
    digitalWrite(3, HIGH);
    delay(1000);
    digitalWrite(3, LOW);
    delay(100);
    digitalWrite(5, HIGH);
    delay(1000);
    digitalWrite(5, LOW);
    delay(100);
    digitalWrite(6, HIGH);
    delay(1000);
    digitalWrite(6, LOW);
    digitalWrite(2, LOW);
    delay(100);
  }
  
  //2 Segundo juego de luces
  if (valorPotenciometro >= 333 && valorPotenciometro < 505) {
    for(int fadeValue = 0 ; fadeValue <= 255; fadeValue +=5) {
      analogWrite(2, fadeValue); 
      analogWrite(3, fadeValue);  
      analogWrite(4, fadeValue);    
      analogWrite(5, fadeValue);  
      analogWrite(6, fadeValue);
      delay(20);                            
  } 
    for(int fadeValue = 255 ; fadeValue >= 0; fadeValue -=5) {
      analogWrite(2, fadeValue); 
      analogWrite(3, fadeValue);  
      analogWrite(4, fadeValue);    
      analogWrite(5, fadeValue);  
      analogWrite(6, fadeValue);
      delay(20);                      
  } 
  }
  
  //3 Tercer juego de luces
  if (valorPotenciometro >= 506 && valorPotenciometro < 677) {
        digitalWrite(4, HIGH);
    for(int fadeValue = 0 ; fadeValue <= 255; fadeValue +=5) {
      analogWrite(2, fadeValue); 
      delay(100);  
      analogWrite(3, fadeValue); 
      analogWrite(5, fadeValue);  
      analogWrite(6, fadeValue);    
      delay(20);                            
  } 
    for(int fadeValue = 255 ; fadeValue >= 0; fadeValue -=5) {
      analogWrite(3, fadeValue);
      analogWrite(5, fadeValue);
      analogWrite(6, fadeValue);
      delay(100);                            
  } 
  }
  
  //4 Cuarto juego de luces
  if (valorPotenciometro >= 678 && valorPotenciometro < 850) {
    digitalWrite(2, HIGH);
    digitalWrite(3, HIGH);
    digitalWrite(4, HIGH);
    digitalWrite(5, HIGH);
    digitalWrite(6, HIGH);
    delay(1500);
    digitalWrite(2, LOW);
    digitalWrite(3, LOW);
    digitalWrite(4, LOW);
    digitalWrite(5, LOW);
    digitalWrite(6, LOW);
    delay(200);                         
  }
  
   //APAGA TODOS LOS LEDS
  if (valorPotenciometro <= 140) apagarLeds();
  
  //ENCIENDE TODOS LOS LEDS
  if (valorPotenciometro >= 851) encenderLeds();
  if (valorPotenciometro == 1023) encenderLeds();
}


void apagarLeds()   //Funcion que apaga todos los leds
{
for (i = 2; i < 7; i++)
digitalWrite(i, LOW);
}
void encenderLeds()   //Funcion que enciende todos los leds
{
for (i = 2; i < 7; i++)
digitalWrite(i, HIGH);


PROGRAMACIÓN DEL TONO MUSICAL
int speakerPin = 9;

int length = 144; //Numero de notas
char notes[] = 
"eeeeeeegcdeffffeeeddedgeeeeeeegcdeffffeeggfdcggeegedggffgggeegedggffgggeegedggffgffcfgfcagbagffedefgaedcCbabagafgedcffefgfcaagabagabagfedcbagf"; //Notas

int beats[] = {1,1,2,1,1,2,1,1,1,1,4,1,1,2,1,1,2,1,1,1,1,2,2,1,1,2,1,1,2,1,1,1,1,4,1,1,2,1,1,2,1,1,1,1,4,1,1,1,1,1,1,3,1,1,1,1,3,1,1,1,1,1,1,3,1,1,1,1,3,1,1,1,1,1,1,3,1,1,1,1,3,1,2,1,1,1,1,2,1,1,1,1,2,1,1,2,1,1,1,1,1,1,2,2,3,1,1,1,2,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,1,2,2,4}; //Tiempo de cada nota
int tempo = 300; //Velocidad del tono

void playTone(int tone, int duration) {
for (long i = 0; i < duration * 1000L; i += tone * 2) {
digitalWrite(speakerPin, HIGH);
delayMicroseconds(tone);
digitalWrite(speakerPin, LOW);
delayMicroseconds(tone);
}
}

void playNote(char note, int duration) {
char names[] = { 'G','c', 'd', 'e', 'f', 'g', 'a', 'b', 'C' };
             /*   si  do   re   mi   fa  sol  la    si   do*/
int tones[] = { 1950,1915, 1700, 1519, 1432, 1275, 1136, 1014, 956 };//La escala del tono que se a elegido

// Reproducir el tono que corresponde al nombre de la nota
for (int i = 0; i < 9; i++) {
if (names[i] == note) {
playTone(tones[i], duration);
}
}
}

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

void loop() {
for (int i = 0; i < length; i++) {
if (notes[i] == ' ') {
delay(beats[i] * tempo); //Tiempo restante
} else {
playNote(notes[i], beats[i] * tempo);
}
//Pausa entre notas
delay(tempo / 2); 
}
}




jueves, 8 de mayo de 2014

Memorias RAM integrado


La memoria principal o RAM (Random Access Memory, Memoria de Acceso Aleatorio) es donde el computador guarda los datos que está utilizando en el momento presente. El almacenamiento es considerado temporal por que los datos y programas permanecen en ella mientras que la computadora este encendida o no sea reiniciada.
La memoria RAM se utiliza frecuentemente para referirse a los módulos de memoria que se usan en los computadores personales y servidores. Los módulos de RAM son la presentación comercial de este tipo de memoria, que se compone de circuitos integrados soldados sobre un circuito impreso, en otros dispositivos como las consolas de videojuegos, esa misma memoria va soldada sobre la placa principal.
Uno de los primeros tipos de memoria RAM fue la memoria de núcleo magnético, desarrollada entre 1949 y 1952 y usada en muchos computadores hasta el desarrollo de circuitos integrados a finales de los años 60 y principios de los 70. En sus inicios, la memoria RAM se componía de hilos de cobre que atravesaban toroides de ferrita, la corriente polariza la ferrita. Con las nuevas tecnologías, las posiciones de la ferrita se ha ido sustituyendo por, válvulas de vacío, transistores y en las últimas generaciones, por un material sólido dieléctrico. Dicho estado sólido dieléctrico tipo DRAM permite que se pueda tanto leer como escribir información.
Se utiliza como memoria de trabajo para el sistema operativo, los programas y la mayoría del software. Es allí donde se cargan todas las instrucciones que ejecutan el procesador y otras unidades de cómputo. Se denominan"de acceso aleatorio" porque se puede leer o escribir en una posición de memoria con un tiempo de espera igual para cualquier posición, no siendo necesario seguir un orden para acceder a la información de la manera más rápida posible.

Hay dos tipos básicos de memoria RAMRAM dinámica (DRAM)- RAM estática (SRAM)
Los dos tipos de memoria RAM se diferencian en la tecnología que utilizan para guardar los datos, la meoria RAM dinámica es la más común.
La memoria RAM dinámica necesita actualizarse miles de veces por segundo, mientras que la memoria RAM estática no necesita actualizarse, por lo que es más rápida, aunque también más cara. Ambos tipos de memoria RAM son volátiles, es decir, que pierden su contenido cuando se apaga el equipo.

PDF - Aquí esta la teoría completa de las memorias ram.
http://www.utp.edu.co/~eduque/arquitec/Memorias.pdf

VIDEO --> Esta es la primera parte de la utilidad de las memorias ram con proteus...




martes, 29 de abril de 2014

Dispositivo Lógico Programable

Descripción.

    El PLD, o Dispositivo Lógico Programable, es un dispositivo con características que pueden ser configuradas por el usuario por medio de un programa y se le pueden implementar funciones lógicas que el usuario necesite en un sistema.
    La mayoría de los PLDs integran una matriz de compuerta AND y una matriz de compuerta OR (fijas o
    programables), una matriz de conexiones, y algunas ocasiones, también registros.

    Usos.

    La flexibilidad y programabilidad de los PLDs hacen que su diseño con ellos sea mucho más rápido que diseñar con lógica discreta. Esto es, se puede utilizar el PLD para implementar la mayoría de las funciones hechas con los cientos de dispositivos de la familia lógica "7400". También cabe recalcar que toman menos  espacio sobre el circuito impreso que con los dispositivos discretos.
    Una vez tomada la decisión de cambiar de lógica discreta a los PLD´s. Hay que escoger PLD's que sean compatibles con los otros dispositivos que se estén utilizando. Hay que tomar en consideración la potencia que se requiere, ya que varia la potencia necesaria de un PLD a otro y otro factor importante es su estabilidad.

    Arquitectura básica de un PLD.

    Las entradas del PLD entran al arreglo lógico los cuales son hechos de columnas y filas (en la figura se muestra  tal arreglo) cada par de columnas representa la entrada negada o complementada y la misma entrada sin negar, cada fila constituye un término AND. Las conexiones lógicas se establecen entre diferentes columnas y  filas en la matriz  para determinar cual combinación de entradas llevaran al termino AND a un nivel alto.  Más de un término AND alimenta una compuerta OR. La salida es la suma de productos.

    PDF
    http://www.uhu.es/rafael.lopezahumada/Cursos_anteriores/fund97_98/plds.pdf




    jueves, 10 de abril de 2014

    Operadores Aritméticos

    SUMADOR

    En electrónica un sumador es un circuito lógico que calcula la operación suma. En los computadores modernos se encuentra en lo que se denomina Unidad aritmético lógica (ALU). Generalmente realizan las operaciones aritméticas en código binario decimal o BCD exceso 3, por regla general los sumadores emplean el sistema binario. En los casos en los que se esté empleando un complemento a dos para representar números negativos el sumador se convertirá en un sumador-restador.
    Las entradas son A,B,Cin que son la entradas de bits A y B, y Cin es la entrada de acarreo. Por otra parte, la salida es S y Cout es la salida de acarreo.

    RESTADOR

    El algoritmo de la resta en sistema binario es el mismo que en el sistema decimal. Pero conviene repasar la operación de restar en decimal para comprender la operación binaria, que es más sencilla. Los términos que intervienen en la resta se llaman minuendo, sustraendo y diferencia.
    Las restas básicas 0 - 0, 1 - 0 y 1 - 1 son evidentes:
    • 0 - 0 = 0
    • 1 - 0 = 1
    • 1 - 1 = 0
    • 0 - 1 = 1 (se transforma en 10 - 1 = 1) (en sistema decimal equivale a 2 - 1 = 1)
    La resta 0 - 1 se resuelve igual que en el sistema decimal, tomando una unidad prestada de la posición siguiente: 0 - 1 = 1 y me llevo 1 (este valor se resta al resultado que obtenga, entre el minuendo y el sustraendo de la siguiente columna), lo que equivale a decir en el sistema decimal, 2 - 1 = 1.

    PDF




    martes, 25 de marzo de 2014

    Multivibradores

    En electrónica, un multivibrador es un circuito oscilador capaz de generar una onda cuadrada. Según su funcionamiento, los multivibradores se pueden dividir en dos clases:
    • De funcionamiento continuo, astable o de oscilación libre: genera ondas a partir de la propia fuente de alimentación.
    • De funcionamiento impulsado: a partir de una señal de disparo o impulso sale de su estado de reposo.
    En su forma más simple son dos sencillos transistores realimentados entre sí. Usando redes de resistencias y condensadores en esa realimentación se pueden definir los periodos de inestabilidad.
    Un circuito integrado multivibrador muy popular es el 555, que usa un sofisticado diseño para lograr una gran precisión y flexibilidad con muy pocos componentes externos.


    PDF

    jueves, 20 de febrero de 2014

    Conversores ADC y DAC



    Un conversor de señal analógica a digital, es un dispositivo electrónico capaz de convertir una señal analógica de voltaje en una señal digital con un valor binario. Se utiliza en equipos electrónicos como computadora, grabadores de sonido y de vídeo, y equipos de telecomunicaciones. La señal analógica, que varía de forma continua en el tiempo, se conecta a la entrada del dispositivo y se somete a un muestreo a una velocidad fija, obteniéndose así una señal digital a la salida del mismo.
     
     Para profundizar más sobre este tema he encontrado este pdf:

    PDF --> http://www.ing.unlp.edu.ar/islyd/Tema%2011%20Conversores%202008%20BYN.pdf





    jueves, 6 de febrero de 2014

    Proyectos de Instructables

    Pensando en nuevos proyectos para realizar, nuestra profesora nos ha mandado que mirásemos la página de Instructables ----> http://www.instructables.com/
    La verdad que la página está genial, se pueden ver los proyectos que crea la gente siendo creativos e ingeniosos. Suben videos y fotos explicando como lo han hecho con los materiales que han necesitado.
    Pidiéndonos que eligiésemos el que más nos guste, yo me he decantado por un robot sobre ruedas. Entre los dos que he escogido, se miraría como se han realizado para obtener mejoras y realizar uno más avanzado.

    FuzzBot

    http://www.instructables.com/id/FuzzBot/


    Artoo

    http://www.instructables.com/id/ArtooR2-ATtiny2313-Wall-Avoiding-Robot/
     

    lunes, 27 de enero de 2014

    Juego de Luces con Arduino + Módulo TM1638


    Muy buenas bloggeros!!

    Pues acabamos de terminar de presentar y exponer las prácticas que hemos hecho cada grupo en clase. Yo os dejo para que veais la mia y os explico un poco.
     
    Esta práctica la he realizado con Arduino y un Módulo TM1638. Consiste en realizar 8 secuencias diferentes en los 8 diodos leds, en la que hemos llamado a cada secuencia; juego de luces, un juego por cada botón. Al presionar dicho botón, los 8 leds se iluminaran de color rojo o verde, o puede que estén apagados, estos se iluminaran según la secuencia que hemos programado en cada juego. En el display informará del número de juego que se ha seleccionado, por ejemplo, en el primer botón pondrá “PLAY 1”, en el segundo “PLAY 2”, y así sucesivamente. 
    No me a parecido una práctica muy complicada, es ir probando poco a poco, lo que le vas ordenando con el Arduino al módulo, y ir entendiendo su funcionamiento.
    Bueno aquí os dejo el video...