Nothing Special   »   [go: up one dir, main page]
Scribd Logo
Cargar

¡Te damos la bienvenida a Scribd!

  • 12 vistas

    Practicas Electrónica Tercer Parcial

    Cargado por

    david perez

    Copyright:

    © All Rights Reserved
    Descargue como PDF, TXT o lea en línea desde Scribd

    Practicas Electrónica Tercer Parcial

    Cargado por

    david perez
    12 vistas10 páginas

    Derechos de autor

    © © All Rights Reserved

    Formatos disponibles

    PDF, TXT o lea en línea desde Scribd

    ¿Le pareció útil este documento?

    ¿Este contenido es inapropiado?

    Copyright:

    © All Rights Reserved
    Descargue como PDF, TXT o lea en línea desde Scribd
    Descargar como pdf o txt
    12 vistas10 páginas

    Practicas Electrónica Tercer Parcial

    Cargado por

    david perez

    Copyright:

    © All Rights Reserved
    Descargue como PDF, TXT o lea en línea desde Scribd
    Descargar como pdf o txt
    de 10

    Práctica 1. Electrónica Programar una Matriz de Leds.

    Profesor: Dr. Francisco David Pérez Reynoso

    Objetivo: Diseñar un sistema que permita generar un mensaje al inicio con la leyenda “UVM”, y
    por cada ocasión que se presiona un botón se verá desplegado una imagen de un emoji diferente,
    con esto se pretende que el estudiante comprenda de mejor forma la polarización de los diodos
    mediante diodos emisores de luz (leds).

    Funcionamiento:

    Primero se deben ver cada letra de la palabra “UVM”.

    Después por cada vez que se presione el “push button” debe cambiar una expresión facial en la
    matriz de leds.

    Feliz.

    Triste.

    Sorprendido.
    Enojado.

    El siguiente código de Arduino solo tiene programadas las letras y la emoción “Feliz” y “Triste” toca
    turno al estudiante programar y modificar el código para que se visualicen las emociones
    “Sorprendido” y “Enojado”.
    Código 1.
    //Practica 1. Matriz de Leds.
    //Programa Dr. Francisco David Pérez Reynoso.

    //*********************ELECTRONICA DIODOS******************************************+

    #include "LedControl.h" //Librería que te permite controlar la matriz de leds.


    LedControl lc=LedControl(11,13,10,1); //Pines de control

    #define demora 100 //define el retardo para cada rostro

    int variable = 0; //variable que determina la opción a mostrar.

    //Arreglo de datos que muestra la letra U


    byte U[]= {
    B01000010,
    B01000010,
    B01000010,
    B01000010,
    B01000010,
    B01000010,
    B00111100,
    B00000000
    };

    //Arreglo de datos que muestra la letra V


    byte V[]= {
    B01000010,
    B01000010,
    B01000010,
    B01000010,
    B01000010,
    B01000010,
    B00100100,
    B00011000
    };

    //Arreglo de datos que muestra la letra M


    byte M[]= {
    B10000001,
    B11000011,
    B10100101,
    B10011001,
    B10000001,
    B10000001,
    B10000001,
    B10000001
    };

    //Arreglo de datos que muestra el emoji Feliz.


    byte feliz[]= {
    B00000000,
    B01100110,
    B01100110,
    B00000000,
    B01000010,
    B00111100,
    B00011000,
    B00000000
    };

    //Arreglo de datos que muestra el emoji Triste


    byte triste[]= {
    B00000000,
    B10011001,
    B01100110,
    B00000000,
    B00011000,
    B00100100,
    B00100100,
    B00000000
    };

    //Configuración de la tarjeta arduino


    void setup() {
    lc.shutdown(0,false); //Instrucción para establecer todos los pines de control como salida.
    lc.setIntensity(0,8); //Intensiddad de encendido de los leds 8 máximo.
    lc.clearDisplay(0); //Borrar la matriz
    attachInterrupt(digitalPinToInterrupt(2),cambio,LOW); //Función de interrupción que permite elevar el
    //numero de una variable dependiendo cuantas veces se presiona un boton conectado al pin 2.

    //función para mostrar el arreglo que contiene la letra U


    mostrarU();
    delay(1000);// Retardo de 1 segundo.
    //función para mostrar el arreglo que contiene la letra V
    mostrarV();
    delay(1000);//retardo de 1 segundo.
    //función para mostrar el arreglo que contiene la letra M
    mostrarM();
    delay(1000);//retardo de 1 segundo.
    }

    //Función que ejecuta el arduino de forma continua


    void loop(){

    //dependiente el valor de la variable = 0 ejecuta la emoción feliz.


    if(variable==0){
    mostrarFeliz();
    delay(demora);
    }

    //dependiente el valor de la variable = 1 ejecuta la emoción triste.


    else if(variable==1){
    mostrarTriste();
    delay(demora);
    }
    }

    //función que muestra el arreglo de la letra U


    void mostrarU(){
    for(int i=0; i<8; i++){
    lc.setRow(0,i,U[i]);
    }
    }

    //función que muestra el arreglo de la letra V


    void mostrarV(){
    for(int i=0; i<8; i++){
    lc.setRow(0,i,V[i]);
    }
    }

    //función que muestra el arreglo de la letra M


    void mostrarM(){
    for(int i=0; i<8; i++){
    lc.setRow(0,i,M[i]);
    }
    }

    //función que muestra el arreglo de la emoción Feliz


    void mostrarFeliz(){
    for(int i=0; i<8; i++){
    lc.setRow(0,i,feliz[i]);
    }
    }
    //función que muestra el arreglo de la emoción Triste
    void mostrarTriste(){
    for(int i=0; i<8; i++){
    lc.setRow(0,i,triste[i]);
    }
    }

    //función que ejecuta la interrupción se ejecuta cada vez que se presiona el boton conectado al pin 2
    //Aumenta en uno la variable pasando por 0, 1 y llegar hasta 2
    //cuando llega hasta 2 este se reinicia a 0.
    void cambio()
    {
    variable++;
    if(variable==2)
    {
    variable=0;
    }
    }

    Simulación en Proteus. (Diagrama Eléctrico de Conexiones).


    Práctica 2. Controlar un motor DC e implementar una matriz de leds para indicar el sentido de
    giro.

    Objetivo: Mediante esta práctica el estudiante comprenderá implementar mediante un puente H,


    el control de giro y velocidad de un motor de corriente directa, además se agrega el
    funcionamiento de la Matriz de Leds para indicar mediante una flecha el sentido de giro.

    El siguiente código en Arduino funciona correctamente cumpliendo los objetivos establecidos en


    esta práctica.

    Código 2.
    //Practica 2. Control Motor de DC
    //Programa Dr. Francisco David Pérez Reynoso.

    //*********************ELECTRONICA PUENTE H******************************************+

    #include "LedControl.h" //Librería que te permite controlar la matriz de leds.


    LedControl lc=LedControl(11,13,10,1); //Pines de control

    int pin2=8; //Entrada 2 del L293D


    int pin7=9; //Entrada 7 del L293D
    int pote=A0; //Potenciómetro

    int valorpote; //Variable que recoge el valor del potenciómetro


    int pwm1; //Variable del PWM 1
    int pwm2; //Variable del PWM 2

    //Arreglo de datos que muestra una flecha a la Derecha


    byte derecha[]= {
    B00000000,
    B00000000,
    B00001000,
    B11111110,
    B11111111,
    B11111110,
    B00001000,
    B00000000
    };

    //Arreglo de datos que muestra una flecha a la Izquierda


    byte izquierda[]= {
    B00000000,
    B00000000,
    B00010000,
    B01111111,
    B11111111,
    B01111111,
    B00010000,
    B00000000
    };

    void setup()
    {
    lc.shutdown(0,false); //Instrucción para establecer todos los pines de control como salida.
    lc.setIntensity(0,8); //Intensiddad de encendido de los leds 8 máximo.
    lc.clearDisplay(0); //Borrar la matriz
    //Inicializamos los pins de salida
    pinMode(pin2,OUTPUT);
    pinMode(pin7, OUTPUT);
    }

    void loop()
    {

    //Almacenamos el valor del potenciómetro en la variable


    valorpote=analogRead(pote);

    //Como la entrada analógica del Arduino es de 10 bits, el rango va de 0 a 1023.


    //En cambio, la salidas del Arduio son de 8 bits, quiere decir, rango entre 0 a 255.
    //Por esta razón tenemos que mapear el número de un rango a otro usando este código.
    pwm1 = map(valorpote, 0, 1023, 0, 255);
    pwm2 = map(valorpote, 0, 1023, 255, 0); //El PWM 2 esta invertido respecto al PWM 1

    //Sacamos el PWM de las dos salidas usando analogWrite(pin,valor)


    analogWrite(pin2,pwm1);
    analogWrite(pin7,pwm2);

    //Determina en que momento mostrar cada flecha indicando el sentido del motor
    if((pwm1>127)&&(pwm2<127))
    {
    mostrarDerecha();
    }

    if((pwm2>127)&&(pwm1<127))
    {
    mostrarIzquierda();
    }

    //función que muestra el arreglo de la flecha Derecha


    void mostrarDerecha(){
    for(int i=0; i<8; i++){
    lc.setRow(0,i,derecha[i]);
    }
    }

    //función que muestra el arreglo de la flecha Izquierda


    void mostrarIzquierda(){
    for(int i=0; i<8; i++){
    lc.setRow(0,i,izquierda[i]);
    }
    }
    Diagrama Eléctrico.

    Práctica 3. Controlar un motor a pasos de 4 hilos e implementar una matriz de leds para indicar
    el sentido de giro.

    Objetivo: Controlar un motor a pasos de 4 hilos mediante el driver puente H,

    Código 3.
    //Practica 3. Control Motor a pasos 4 Hilos
    //Programa Dr. Francisco David Pérez Reynoso.

    //*********************ELECTRONICA PUENTE H******************************************+

    #include <Stepper.h>
    double pasosPorRevolucion = 200;
    Stepper myStepper(pasosPorRevolucion, 5, 6, 7, 8); // Pin inversion to make the library work

    #include "LedControl.h" //Librería que te permite controlar la matriz de leds.


    LedControl lc=LedControl(11,13,10,1); //Pines de control

    #define STEPS 500 //Ponemos el número de pasos que necesita para dar una vuelta. 200 en nuestro caso
    int pote=A0; //Potenciómetro
    int pwm1; //Variable del PWM 1
    int valorpote; //Variable que recoge el valor del potenciómetro

    //Arreglo de datos que muestra una flecha a la Derecha


    byte derecha[]= {
    B00000000,
    B00000000,
    B00001000,
    B11111110,
    B11111111,
    B11111110,
    B00001000,
    B00000000
    };

    //Arreglo de datos que muestra una flecha a la Izquierda


    byte izquierda[]= {
    B00000000,
    B00000000,
    B00010000,
    B01111111,
    B11111111,
    B01111111,
    B00010000,
    B00000000
    };

    void setup() {
    lc.shutdown(0,false); //Instrucción para establecer todos los pines de control como salida.
    lc.setIntensity(0,8); //Intensiddad de encendido de los leds 8 máximo.
    lc.clearDisplay(0); //Borrar la matriz

    void loop()
    {

    //Almacenamos el valor del potenciómetro en la variable


    valorpote=analogRead(pote);
    //Como la entrada analógica del Arduino es de 10 bits, el rango va de 0 a 1023.
    //En cambio, la salidas del Arduio son de 8 bits, quiere decir, rango entre 0 a 255.
    //Por esta razón tenemos que mapear el número de un rango a otro usando este código.
    pwm1 = map(valorpote, 0, 1023, 0, 50);
    //Girar una vuelta entera en un sentido
    myStepper.setSpeed(pwm1);

    myStepper.step(STEPS);
    delay(500); //Pequeña pausa
    mostrarDerecha();

    //Girar una vuelta entera en sentido contrario


    myStepper.step(-STEPS);
    delay(500); //Pequeña pausa
    mostrarIzquierda();
    }

    //función que muestra el arreglo de la flecha Derecha


    void mostrarDerecha(){
    for(int i=0; i<8; i++){
    lc.setRow(0,i,derecha[i]);
    }
    }

    //función que muestra el arreglo de la flecha Izquierda


    void mostrarIzquierda(){
    for(int i=0; i<8; i++){
    lc.setRow(0,i,izquierda[i]);
    }
    }

    Diagrama Eléctrico Práctica 3.

    También podría gustarte