jueves, 11 de junio de 2015

PROYECTO FINAL SISTEMAS EMBEBIDOS


Descripción: 

PLANTEAMIENTO DEL PROYECTO Se desea desarrollar un “carrito” que sea controlado por un microcontrolador PIC, mediante el uso de diferentes dispositivos electrónicos, tales como sensores, motores de corriente directa, etc. El objetivo principal del “carrito” es evadir obstáculos que se encuentren enfrente de su trayectoria de movimiento. Para ello, el microcontrolador que controla el carrito, utilizará un sensor de donde obtendrá lecturas, no solo de la trayectoria de movimiento, sino que también de otros ángulos para tener opciones para decidir el cambio de la trayectoria para evadir el obstáculo.Tambien puede ser controlado via bluetooth desde un celular android, el carro se comunica con la aplicacion por medio de un modulo bluetooth HC-05. El movimiento se realiza con dos micro servos con giro de 360° alimentados externamente con un bloque de baterias AA (4 pilas = 6V), la placa Arduino tambien se alimenta externamente por una bateria de 9V.  La solución a la problemática planteada en los párrafos anteriores se puede dividir en “hardware” y en “software”, cada una de estas soluciones se menciona en los siguientes apartados, pero antes se menciona una descripción general del proceso de solución y construcción del “carrito”.


 DESCRIPCIÓN GENERAL DEL PROCESO DE SOLUCIÓN Y CONSTRUCCIÓN DEL CARRITO En el planteamiento de la construcción de este robot se consideraron los siguientes puntos: • Nivel físico: comprende la estructura física, las unidades motoras, y las etapas de potencia. • Nivel de reacción: esta formado por el conjunto de sensores y los sistemas básicos para su manejo. • Nivel de inteligencia: abarca la planificación a largo plazo. Para llegar al modelo final del robot se paso por un proceso de experimentación, ya que se probaron diferentes carrocerías y diferentes tipos de motores.


Materiales
  • Placa Arduino UNO R3
  • Modulo Bluetooth HC-05
  • arduino motor shield
  • 2 Microservos trucados para funcionar con giro continuo
  • 2 llantas de robotica
  • 1 rueda loca 
  • madera 
  • 4 pilas AA
  • 1 pila 9V
  • bloque conector de 4 pilas AA
Conector de corriente DC

Diagrama de coneccion de el arduino y arduino motor shield

Esquematico

 pcb

en protoboar 
 fotos 







Códigos Arduino



Vídeo de funcionamiento







también lo puedes ver en youtube 

www.youtube.com/watch?v=i-hIDENTwu4



jueves, 28 de mayo de 2015

laboratorio 10

DESCRIPCIÓN:
Este laboratorio consiste   Mostrar un mensaje desplazándose de izquierda a derecha en una matriz LED 8x8 a través de IC MAX7219 enviado desde un Arduino, pueden usar una interfaz Processing.

MATERIALES:
Placa ARDUINO UNO
Protoboard
Modulo Matriz 8x8 entrada serial desde Interface Max7219
Cables
Computador con programa de desarrollo Arduino y Processing

Diagrama
Esquemático



montaje


Codigo ARDUINO

codigo processing

laboratorio 7


DESCRIPCIÓN:

Este laboratorio consiste en controlar desde el Arduino, un display LED de 7 segmentos, a través de un 74HC595, para mostrar un número de 0 a 9, dependiendo de la posición de un  Potenciómetro.


MATERIALES:
  • Arduino 
  • 1 Display LED 7 segmentos
  • resistencia
  • 1 integrado 74HC545
  • 1 potenciometro
MONTAJE PASO A PASO:
  • montamos el display LED 7 segmentos en la protoboard
.

  • montamos el integrado 74HC545 cin sus respectivas conexiones a 5V y a tierra.

  • montamos el potenciometro
  • realizamos las conexiones desde el 74HC545 al display de7 segmentos y a los respectivos pines del Arduino que escogimos en nuestra programación.




DIAGRAMAS  (USANDO FRITZING)

  • En protoboard

  • Esquemático 
  •  En PCB

codigo arduino 


laboratorio 8

DESCRIPCIÓN:
 Este laboratorio consiste  en manipular en la pantalla del computador un objeto gráfico usando Processing, con los datos leídos en el Arduino desde un Joystick shield.

MATERIALES:


  • MONTAJE PASO A PASO:
  •  Se monta sobre el arduino un joystick shield.


Diagrama del Montaje en Protoboard

Diagrama Esquemático .
Vídeo de Funcionamiento.



Código Processing.






Codigo Arduino.

laboratorio 9

DESCRIPCIÓN:
Este laboratorio consiste  en Controlar desde una interfaz en Processing, el patrón de movimiento y colores en un módulo de 8 LEDs RGB controlado con un Arduino.
MATERIALES:
  • Arduino 
  •  módulo de 8 LEDs RGB 

  • MONTAJE PASO A PASO:
    • montamos el módulo de 8 LEDs RGB  en la protoboard  con sus respectivas conexiones entradas salidas  a 5V y a tierra.
  • DIAGRAMAS  (USANDO FRITZING)

    • En protoboard



VIDEO DEL FUNCIONAMIENTO:



CÓDIGO FUENTE EN ARDUINO:




Codigo Processing.

jueves, 26 de marzo de 2015

LABORATORIO 6

DESCRIPCIÓN:

Este laboratorio consiste  en controlar 8 LEDs desde el Arduino, a través de un 74HC545, definiendo mínimo 8 patrones de movimiento que son controlados desde una interfaz gráfica en Processing/ControlP5.


MATERIALES:
  • Arduino 
  • 8 LEDs
  • resistencias
  • 1 integrado 74HC545 
  • MONTAJE PASO A PASO:
    • montamos los LEDs en la protoboard

    • posteriormente le añadimos una resistencia a cada LED para protegerlos.

    • montamos el integrado 74HC545 cin sus respectivas conexiones a 5V y a tierra.

    • realizamos las conexiones desde el 74HC545 a los diodos LEDs y a los respectivos pines del Arduino que escogimos en nuestra programación.

  • DIAGRAMAS  (USANDO FRITZING)

    • En protoboard

    • Esquemático 
    • En PCB
  • VIDEO DEL FUNCIONAMIENTO:
  • CÓDIGO FUENTE EN ARDUINO:
    1:  /** Laboratorio 6: controlar 8 LEDS desde Processing/ControlP5  
    2:   * utilizando un 74HC525  
    3:   * Autor: FANOR STIWAR ZAPATA  
    4:   */  
    5:     
    6:  // definimos la cantidad de pines que vamos a usar como PIN //  
    7:  #define PIN 3  
    8:     
    9:  // se declaran los pines que utilizaremos  
    10:  // que van a ser usados por el integrado respectivamente  
    11:     
    12:  const int Latch = 8;  
    13:  const int Clock = 9; //el pin SH_CP osea Clock debe ser PWM(~) //  
    14:  const int Data = 7;  
    15:     
    16:  int Pins[PIN] = {Data,Latch,Clock};  
    17:     
    18:  // Inicializamos las variables que vamos a utilizar  
    19:  int Lect = 0;  
    20:  boolean OnLed = false;  
    21:  int Dato = 0;  
    22:  int i = 0;  
    23:  int Led[]={1,2,4,8,16,32,64,128};  
    24:     
    25:  // Ciclo para activar los tres pines como salida  
    26:  void setup() {  
    27:   for (int j=0; j<PIN; j++){  
    28:    pinMode(Pins[j], OUTPUT);  
    29:   }  
    30:   //Comunicación serial a 9600bps  
    31:   Serial.begin(9600);  
    32:  }  
    33:     
    34:  // Recibe la información de manera serial del processing  
    35:  void loop()  
    36:  {  
    37:   if (Serial.available()>0) {  
    38:      
    39:    Lect = Serial.read(); //Leemos el Dato  
    40:      
    41:    //Se ingresa cuando OnLed es verdadero  
    42:    //osea cuando algun Led esta en On "1"  
    43:    if (OnLed)  
    44:    {  
    45:     Suma(Lect);  
    46:     On(Dato);  
    47:     OnLed = false;  
    48:    }  
    49:    else  
    50:    {  
    51:     //Se recibe la info si el Led esta On u Off "1" o "0"  
    52:     i = Lect;  
    53:     OnLed = true;  
    54:    }  
    55:   }  
    56:  }  
    57:     
    58:  // Le va adicionando o sustraendo al Dato el valor del  
    59:  // Led encendido o apagado  
    60:  void Suma(int estadoLED){  
    61:   if(estadoLED==0)  
    62:   {  
    63:    Dato = Dato-Led[i];  
    64:   }else{  
    65:    Dato = Dato+Led[i];  
    66:   }   
    67:  }  
    68:     
    69:  // Función para enviar los datos al Integrado IC 74HC595  
    70:  // y se usa shiftOut para que el valor se lea en los ocho Leds  
    71:  void On(int Valor)  
    72:  {  
    73:   digitalWrite(Latch, LOW);  
    74:   shiftOut(Data, Clock, MSBFIRST, Valor);  
    75:   digitalWrite(Latch, HIGH);  
    76:  }  
    
  • CÓDIGO FUENTE EN PROCESSING:
  • 1:  /** Laboratorio 6: controlar 8 LEDS desde Processing/ControlP5  
    2:   * utilizando un 74HC525  
    3:   * Autor: fanor stiwar zapata   
    4:   */  
    5:     
    6:  // Se utiliza las librerias ControlP5 y Serial del Processing  
    7:  import controlP5.*;  
    8:  import processing.serial.*;  
    9:     
    10:  // Se define la variable cP5 del tipo ControlP5  
    11:  ControlP5 cP5;  
    12:     
    13:  // Se le da nombres al Serial  
    14:  Serial serial;  
    15:     
    16:  int[] led = new int[] {  
    17:   0, 0, 0, 0, 0, 0, 0, 0  
    18:  };  
    19:     
    20:  // Configuración inicial  
    21:  void setup() {  
    22:   size(590, 250); //Tamaño de la ventana  
    23:   noStroke();  
    24:     
    25:   cP5 = new ControlP5(this); //Crea el objeto ControlP5  
    26:     
    27:   // Crea el Knob del color Rojo  
    28:   for (int i=0; i<led.length; i++)  
    29:   {  
    30:    cP5.addToggle("led"+i, 35+i*70, 140, 30, 30)  
    31:     .setMode(ControlP5.SWITCH);  
    32:   }  
    33:     
    34:   String puerto = Serial.list()[0];  
    35:   //Comunicación serial a 9600bps  
    36:   serial = new Serial(this, puerto, 9600);  
    37:  }  
    38:     
    39:  // Cada uno de los circuilos hecho toma el color determinado  
    40:  // del Led que se tiene en la protoboard  
    41:  void draw() {  
    42:   background(0xFF444444);  
    43:   fill(led[0] == 0 ? 0xFF222222 : color(255, 255, 0));  
    44:   ellipse(50, 100, 50, 50);  
    45:   for (int i=1; i<4; i++) {  
    46:    fill(led[i] == 0 ? 0xFF222222 : color(255, 0, 0));  
    47:    ellipse(50+i*70, 100, 50, 50);  
    48:   }  
    49:   for (int i=4; i<led.length; i++) {  
    50:    fill(led[i] == 0 ? 0xFF222222 : color(0, 255, 0));  
    51:    ellipse(50+i*70, 100, 50, 50);  
    52:   }  
    53:    fill(255);  
    54:    textFont(createFont("Gill Sans Ultra Bold", 50));  
    55:    text("Enciende un LED", 40, 50);  
    56:    fill(255);  
    57:    textSize(25);  
    58:    text("Juan Camilo Fernández López", 120, 230);  
    59:  }  
    60:     
    61:  // Como se va a actuar cuando ocurra un evento con los botones  
    62:  void controlEvent(ControlEvent evento) {  
    63:   String nombre = evento.getController().getName();  
    64:   int valor = int(evento.getController().getValue());  
    65:     
    66:   // Guarda el valor de cada boton  
    67:   for (int i=0; i<led.length; i++) {  
    68:    if (nombre.equals("led"+i)) {  
    69:     led[i] = valor;  
    70:     serial.write(i);  
    71:     serial.write(valor);  
    72:     println("evento: " + i + " / valor: "+valor);  
    73:    }  
    74:   }  
    75:  }  
    


LABORATORIO 5

DESCRIPCIÓN:

 consiste el controlar un LED RGB desde el Arduino, via una interfaz grafica en Processing/ControlP5 para controlar la intensidad de  los LEDs (rojo, verde, azul) del RGB. 


MATERIALES:
  • Arduino 
  • 1 LED RGB
  • 3 resistencias

MONTAJE PASO A PASO:
  • montamos el LED RGB en la protoboard
  • realizamos las conexiones del cicuito en la protoboard con el arduino, teniendo el cuenta el GND y el pin out para cada color del  LED según nuestra programación.

  • Haga clic en Opciones
  • DIAGRAMAS  (FRITZING)

    • En protoboard
    • ESQUEMATICO



    •  








    • En PCB










    • VIDEO DEL FUNCIONAMIENTO:












CÓDIGO FUENTE EN ARDUINO:

1:  //** Laboratorio #5: controlar 1 LED RGB desde Processing/ControlP5  
2:  para controlar la intensidad de cada color del RGB  
3:   * Autor: FANOR ZAPATA   
4:   */  
5:     
6:  int valor=0;  
7:     
8:  #define MAX 9  
9:  int led[MAX]={2, 3 , 5};  
10:  int valorR=100;  
11:  int valorG=100;  
12:  int valorB=100;  
13:     
14:     
15:  void setup(){  
16:   Serial.begin(9600);  
17:   for(int pin=0; pin<=MAX;pin++){  
18:    pinMode(led[pin], OUTPUT);  
19:      
20:   }  
21:  }  
22:     
23:     
24:  void loop(){  
25:     
26:   if (Serial.available()>0){  
27:    valor=Serial.read();  
28:    if (valor=='R'){  
29:    valorR=Serial.parseInt();  
30:    }  
31:    if (valor=='G'){  
32:    valorG=Serial.parseInt();  
33:    }  
34:      
35:    if (valor=='B'){  
36:    valorB=Serial.parseInt();  
37:    }  
38:   }  
39:   prender(led[0], valorR);  
40:   prender(led[1], valorG);  
41:   prender(led[2], valorB);  
42:  }  
43:  void prender(int le, int tem){  
44:   analogWrite(le, tem);  
45:     
46:  }  
47:  void apagar(int le, int tem){  
48:   analogWrite(le, tem);  
49:     
50:     
51:  }  
52:   pinMode(A2, INPUT);  
53:   pinMode(A3, INPUT);  
54:     
55:   pinMode(4, OUTPUT);  
56:   pinMode(5, OUTPUT);  
57:   pinMode(6, OUTPUT);  
58:  }  
59:     
60:  void loop() {  
61:     
62:   // codigo para que sea repetitivo y dependa de las entradas analogas//  
63:  int valorR=analogRead (A1)/4;  
64:  int valorB=analogRead (A2)/4;  
65:  int valorG=analogRead (A3)/4;  
66:     
67:  analogWrite (4, valorR);  
68:  analogWrite (5, valorB);  
69:  analogWrite (6, valorR);  
70:     
71:     
72:  }  

CODIGO FUENTE EN PROCESSING/CONTROLP5:
1:  //** Laboratorio #5: controlar 1 LED RGB desde Processing/ControlP5  
2:  para controlar la intensidad de cada color del RGB  
3:   * Autor: FANOR STIWAR ZAPATA   
4:   */  
5:     
6:   // Importamos las librerias de controlP5 y serial//  
7:     
8:  import controlP5.*;  
9:  import processing.serial.*;  
10:     
11:  // creamos las variables para controlP5, el Slider y el puerto serial  
12:     
13:  ControlP5 cp5;  
14:  Knob KnobA;  
15:  Knob KnobB;  
16:  Knob KnobC;  
17:  Serial serial;  
18:  int valR = 128;   
19:  int valG = 128;   
20:  int valB = 128;  
21:     
22:   // Solo se ejecuta una vez, al iniciar el Sketch//  
23:     
24:  void setup() {  
25:     
26:   // Tamaño de la Ventana //   
27:     
28:   size(800, 450);  
29:   noStroke();  
30:     
31:   // Creamos el objeto de ControlP5//  
32:     
33:   cp5 = new ControlP5(this);  
34:     
35:   // Creamos el objeto de Slider//  
36:     
37:   KnobA = cp5.addKnob("R", 0, 255, 128, 40, 40, 200);  
38:   KnobA.setColor( new CColor(  
39:   0xFFAA0000, 0xFF550000, 0xFFFF0000,   
40:   0xFFFFFFFF, 0xFFFFFFFF));  
41:     
42:   KnobB = cp5.addKnob("G", 0, 255, 128, 240+10, 40, 200);  
43:   KnobB.setColor( new CColor(  
44:   0xFF00AA00, 0xFF005500, 0xFF00FF00,   
45:   0xFFFFFFFF, 0xFFFFFFFF));  
46:     
47:   KnobC = cp5.addKnob("B", 0, 255, 128, 440+20, 40, 200);  
48:   KnobC.setColor( new CColor(  
49:   0xFF0000AA, 0xFF000055, 0xFF0000FF,   
50:   0xFFFFFFFF, 0xFFFFFFFF));  
51:     
52:   // Creamos el objeto del serial//  
53:     
54:   serial = new Serial(this, Serial.list()[1], 9600);  
55:  }  
56:     
57:     
58:  void draw() {  
59:   background(0xFF444444);  //*color gris en el fondo *//  
60:     
61:     
62:   /*definir el color de relleno combinando los valores  
63:    de los colores de los 3 Knobs  
64:   */  
65:     
66:   fill(valR, valG, valB);   
67:     
68:   // dibujar el rectángulo con ese color//  
69:     
70:   rect(20, 300, 750, 120);  
71:  }  
72:     
73:   // Cuando ocurra un evento, aquí lo procesamos//  
74:     
75:  void controlEvent(ControlEvent evento) {  
76:     
77:   // Obtenemos el nombre y el valor del evento//  
78:     
79:   String nombre = evento.getController().getName();  
80:   int valor = int(evento.getController().getValue());  
81:   println(nombre + valor);  
82:   serial.write(nombre+valor);  
83:     
84:   // guardar el valor en la variable para cada color  
85:     
86:   if (nombre == "R") {  
87:    valR = valor;  
88:   }  
89:   if (nombre == "G") {  
90:    valB = valor;  
91:   }  
92:   if (nombre == "B") {  
93:    valG = valor;  
94:   }  
95:     
96:  }  
97: