Práctica 9 – LED RGB

INTRODUCCIÓN

 

En esta práctica se regula la intensidad luminosa de cada color (Rojo-Verde-Azul) de un LED RGB de cátodo común, variando el ciclo de trabajo mediante un PWM (modulador de ancho de pulso).

 

Selecciona la plataforma y entorno de programación.

 

 

PIC
AVR
ARDUINO
PIC
PIC C Compiler
MikroC PRO
MPLAB X IDE
PIC C Compiler
Bootloader PIC18FX5K50
Bootloader PIC18FX5K50

Descripción

En esta práctica se realiza un control PWM para regular la intensidad luminosa de cada color de un LED RGB de cátodo común, por medio de un puerto PWM, usando los módulos X-TRAINER P8 o X-TRAINER P8 DIP40 o X-TRAINER P8 DIP28 con el PIC18F45K50 o PIC18F25K50.

 

Materiales:

1 x Módulo X-TRAINER P8 o X-TRAINER P8 DIP40 o X-TRAINER P8 DIP28Comprar

1 x LED RGB. Comprar

1 x Resistencia 330 Ohms. Comprar

1 x Protoboard de 830 puntos. Comprar

1 x Juego de cables Dupont. Comprar

1 x Cable micro USB.

 

Software:

Windows 7 o posterior.

PIC C Compiler v5.069 o posterior. Descarga

XIDE v1.0 Descarga

 

Procedimiento

1. En el apartado de "Diagrama esquemático", que se encuentra a continuación, selecciona tu módulo, realiza las conexiones que se muestran en la imagen y conéctalo a la computadora.

2. Al final de esta práctica, en el apartado de "Descargas", puedes encontrar los archivos del código fuente, o bien copiarlo del apartado de "Código" que se encuentra más abajo.

3. Si descargaste el archivo del paso 2, omite este paso. Si copiaste el código, abre el compilador, pega el código en un nuevo proyecto. En el siguiente link encontrarás un manual para compilar en PIC C Compiler.

4.Abre el Software XIDE v1.0 y programa el código que descargaste o compilaste en el módulo. En el siguiente link encontrarás el manual de usuario para el Software XIDE v1.0. 

5.Al terminar de programar, el módulo se reiniciará y el programa de esta práctica se ejecutará.

 

Diagrama esquemático

 

X-TRAINER P8
X-TRAINER P8 DIP 40
X-TRAINER P8 DIP 28
X-TRAINER P8

X-TRAINER P8 DIP 40

X-TRAINER P8 DIP 28

 

Código

Código


/* 

 AUTOR: MICROSIDE TECHNOLOGY S.A. DE C.V.

 FECHA: JUNIO 2019

*/

/**************************************************************************

Esta práctica consiste en realizar un control PWM

para el control de un LED RGB

**************************************************************************/

#include <18F45K50.h>                                                      //Incluye la librería para el PIC ( para X-TRAINERp8DIP28: #include <18F25K50.h> )

#use delay(internal=48MHz)                                               //Configura frecuencia del oscilador interno

#build(reset=0x02000,interrupt=0x02008)                          //Asigna los vectores de reset e interrupción para la versión con bootloader

#org 0x0000,0x1FFF {}                                                       //Reserva espacio en memoria para el bootloader

#define LEDR PIN_B0                                                        //Pin donde está conectado el LED de X-TRAINER

#define LEDV PIN_B1                                                         //Pin donde está conectado el LED de X-TRAINER

#define LEDA PIN_B2                                                          //Pin donde está conectado el LED de X-TRAINER

unsigned int16 Duty=0;                                                          //Variable para guardar el valor para PWMvoid SisInit(void)

{

   setup_timer_2 (T2_DIV_BY_16, 254, 1);                           //Configura Timer2, periodo ajustado a 342uS

   setup_ccp1 (CCP_PWM|CCP_SHUTDOWN_AC_L|CCP_SHUTDOWN_BD_L);    //Configura el módulo CCP para uso del PWM

}

void Set_PWM (void)

{

   int i;                                                                                       //Declaramos variable

   for (i = 255; i > 0; i–)                                                              // Ciclo para disminuir el valor de la variable

   {

    set_pwm1_duty (i);                                                              // Guarda la salida PWM en la variable

    delay_ms (5);                                                                       // Retardo de 5ms

    }

    for (i = 0; i < 255; i++)                                                          // Ciclo para aumentar el valor de la variable

    {

     set_pwm1_duty (i);                                                              // Guarda la salida PWM en la variable

     delay_ms (5);                                                                      // Retardo de 5ms

   }

}

void main()

{

   SisInit();

    while (1)                                                                                // Ciclo infinito

     {

       output_high (LEDR) ;

       output_low (LEDV) ;

       output_low (LEDA) ;

       Set_PWM ();                                                                   // Convocamos la función

       output_low (LEDR) ;

       output_high (LEDV) ;

       output_low (LEDA) ;

       Set_PWM ();                                                                    // Convocamos la función

       output_low (LEDR) ;

       output_low (LEDV) ;

       output_high (LEDA) ;

       Set_PWM ();                                                                     // Convocamos la función

     }

}

 

Descargas

Software XIDE v1.0

Descarga el software XIDE v1.0 

Práctica 9 – PIC – Bootloader – CCS

Descargar código en PIC C Compiler de la práctica 9.

MikroC PRO
Bootloader PIC18FX5K50
Programador XCU
Bootloader PIC18FX5K50

Descripción

En esta práctica se realiza un control PWM para regular la intensidad luminosa de cada color de un LED RGB de cátodo común, por medio de un puerto PWM, usando los módulos X-TRAINER P8 o X-TRAINER P8 DIP40 o X-TRAINER P8 DIP28 con el PIC18F45K50 o PIC18F25K50.

 

Materiales:

1 x Módulo X-TRAINER P8 o X-TRAINER P8 DIP40 o X-TRAINER P8 DIP28Comprar

1 x LED RGB. Comprar

1 x Resistencia 330 Ohms. Comprar

1 x Protoboard de 830 puntos. Comprar

1 x Juego de cables Dupont. Comprar

1 x Cable micro USB.

 

Software:

Windows 7 o posterior.

MikroC PRO for PIC. Descarga

XIDE v1.0 Descarga

 

Procedimiento

1. En el apartado de "Diagrama esquemático", que se encuentra a continuación, selecciona tu módulo, realiza las conexiones que se muestran en la imagen y conéctalo a la computadora.

2. Al final de esta práctica, en el apartado de "Descargas", puedes encontrar los archivos del código fuente, o bien copiarlo del apartado de "Código" que se encuentra más abajo.

3. Si descargaste el archivo del paso 2, omite este paso. Si copiaste el código, abre el compilador, pega el código en un nuevo proyecto, selecciona en el apartado de librerías la necesaria para esta práctica como se muestra en la siguiente imagen y realiza la compilación. En el siguiente link encontrarás un manual para compilar en MikroC PRO for PIC.

4.Abre el Software XIDE v1.0 y programa el código que descargaste o compilaste en el módulo. En el siguiente link encontrarás el manual de usuario para el Software XIDE v1.0. 

5.Al terminar de programar, el módulo se reiniciará y el programa de esta práctica se ejecutará.

 

Diagrama esquemático

 

X-TRAINER P8
X-TRAINER P8 DIP40
X-TRAINER P8 DIP28
X-TRAINER P8

X-TRAINER P8 DIP40

X-TRAINER P8 DIP28

 

Código

Código

/*

AUTOR: MICROSIDE TECHNOLOGY S.A. DE C.V.

FECHA: JUNIO 2019

*/

/**************************************************************************

Esta práctica consiste en realizar un control PWM

para el control de un LED RGB

**************************************************************************/

/**************************************************************************

Para usar el código con bootloader MICROSIDE:

1) Tools>Options>Output>Output Settings>Marcar "long HEX format"

2) Project>Edit Project>Insertar 48000000 en "MCU Clock Frequency [MHz]" box

**************************************************************************/

#pragma orgall 0x1FFF                                                                               //Se reserva espacio para bootloader

#define LEDR LATB0_bit                                                                          //Se define la salida en para LED rojo

#define LEDV LATB1_bit                                                                           //Se define la salida para LED verde

#define LEDA LATB2_bit                                                                          //Se define la salida para LED azul

void SisInit(void)                                                                                          //Se inicializa el PIC

{                                                                                                                        //Se configura el oscilador interno

           OSCTUNE = 0x80;                                                                            //Se activa el multiplicador de frecuencia 3X PLL

           OSCCON = 0x70;                                                                               //Se cambia de HFINTOSC a 16MHz

           OSCCON2 = 0x10;                                                                             //Se habilita PLL, oscilador primario deshabilitado

           while (PLLRDY_bit == 0);                                                              //Se crea bucle para estabilizar frecuencia

           ACTCON = 0x90;                                                                               //Mantiene la frecuencia una vez estable

                                                                                                                          //Se configuran las entradas y salidas del PIC

           LATB = 0;                                                                                            //Puerto B escribe a su salida ceros

           TRISB = 0;                                                                                          //Puerto B declarado como salida

           PWM1_Init (500000);                                                                     //Se inicializa el PWM a 500000 Hz

           PWM1_Start ();                                                                                  //Inicia el ciclo PWM

}

void Set_PWM(void)                                                                                   //Se crea función para PWM

{

           int i;                                                                                                      //Se declara la variable de inicio

           for (i = 255; i > 0; i--)                                                                        //Se crea un ciclo para disminuir el valor de la variable

                          {

                             PWM1_Set_Duty (i);                                                      //Se guarda la salida PWM en la variable

                             delay_ms (5);                                                                    //Retardo

                          }

           for (i = 0; i < 255; i++)                                                                     //Se crea un ciclo para aumentar el valor de la variable

                          {

                             PWM1_Set_Duty (i);                                                      //Se guarda la salida PWM en la variable

                             delay_ms (5);                                                                   //Retardo

                          }

}

void main() org 0x2000                                                                              //Se instancia el vector del bootloader de MICROSIDE

{

           SisInit ();                                                                                             //Se instancia la configuración del PIC

           while (1)                                                                                               //Se crea un ciclo infinito mientras seas verdadero

                         {

                            LEDR = 1;                                                                           //Led rojo en alto

                            LEDA = 0;                                                                          //Led azul en bajo

                            LEDV = 0;                                                                          //Led verde en bajo

                            Set_PWM();                                                                       //Se  instancia la función creada para PWM

                       LEDR = 0;                                                                          //Led rojo en bajo

                            LEDA = 0;                                                                           //Led azul en bajo

                            LEDV = 1;                                                                           //Led verde en alto

                            Set_PWM();                                                                       //Se instancia la función creada para PWM

                            LEDA = 1;                                                                           //Led azul en alto

                            LEDR = 0;                                                                          //Led rojo en bajo

                            LEDV = 0;                                                                          //Led verde en bajo

                            Set_PWM();                                                                      //Se instancia la función creada para PWM

                         }

}

 

Descargas

Software XIDE v1.0

Descarga el software XIDE v1.0 

Práctica 9 – PIC – Bootloader

Descargar código en MikroC PRO for PIC de la práctica 9.

Programador XCU
PIC10F
PIC12F
PIC16F
PIC18F
PIC10F

Descripción

En esta práctica se realiza un control PWM para regular la intensidad luminosa de cada color de un LED RGB de cátodo común, por medio de un puerto PWM, usando los módulos X-TRAINER P8 con el PIC10F322.


Materiales:

1 x Módulo X-TRAINER P8. Comprar

1 x Módulo Programador XCU. Comprar

1 x Microcontrolador PIC10F322. Comprar

1 x LED RGB. Comprar

1 x Resistencia de 330 Ohms. Comprar

1 x Juego de cable Dupont. Comprar

1 x Protoboard de 830 puntos. Comprar

1 x Cable micro USB.

 

Software:

Windows 7 o posterior.

MikroC PRO for PIC. Descarga

XIDE v1.0 Descarga

 

Procedimiento

1. En el apartado de "Diagrama esquemático", que se encuentra a continuación, selecciona tu módulo, realiza las conexiones que se muestran en la imagen y conéctalo a la computadora.

2. Al final de esta práctica, en el apartado de "Descargas", puedes encontrar los archivos del código fuente, o bien copiarlo del apartado de "Código" que se encuentra más abajo.

3. Si descargaste el archivo del paso 2, omite este paso. Si copiaste el código, abre el compilador, pega el código en un nuevo proyecto, selecciona en el apartado de librerías la necesaria para esta práctica como se muestra en la siguiente imagen y realiza la compilación. En el siguiente link encontrarás un manual para compilar en MikroC PRO for PIC.

4. Abre el Software XIDE v1.0 y programa el código que descargaste o compilaste, en el módulo. En el siguiente link encontrarás el manual de usuario para el Software XIDE v1.0. 

5.Al terminar de programar, el módulo se reiniciará y el programa de esta práctica se ejecutará.

 

 

Diagrama esquemático

 

X-TRAINER P8
X-TRAINER P8

 

Código 

Código

/*

AUTOR: MICROSIDE TECHNOLOGY S.A. DE C.V.

FECHA: JUNIO 2019

*/

/**************************************************************************

/**************************************************************************

Esta práctica consiste en realizar un control PWM para el control de un LED RGB

**************************************************************************/

/**************************************************************************

Para configurar el oscilador:

1) Project> Edit Project>Oscillator Selection Bits>seleccionar "INTOSC oscillator: CLKIN function disabled"

2) Project>Edit Project, insertar 32000000 en "MCU clock frecuency (MHz)" box

**************************************************************************/

#define LEDR LATA1_bit                                                      // Puerto como salida

#define LEDV LATA2_bit                                                     // Puerto como salida

void SisInit(void){                                                                       //inicializa el PIC

               OSCCON = 0X7B;                                                      // 0111 1011 16MHz

                                                                                                      //Configurar entradas y salidas

                TRISA = 0x0C;                                                           //puerto A como salida

                                                                                                    // 00001100, encendera colo el pin 2 y 3

                PWM1_Init(500000);                                                  //Inicializa el módulo a 500KHz

                PWM1_Start();                                                           //Inicializa el módulo PWM

}

void Set_PWM(void)

{

               int i;                                                                           // Definición de variables

                for(i=255;i>0;i--)                                                      // Ciclo para disminuir el valor de la variable

             {

              PWM1_Set_Duty(i);                                                  // Guarda la salida pwm en la variable

              delay_ms(5);                                                              // Retardo de 5ms

              }

             for(i=0;i<255;++)                                                         // Ciclo para aumentar el valor de la variable

             {

              PWM1_Set_Duty(i);                                                  // Guarda la salida pwm en la variable

              delay_ms(5);                                                              // Retardo de 5ms

              }

     }

    void main (){

           SisInit();

            while(1)

            {

                    LEDV=0;

                    LEDR=1;

                    Set_PWM();                                      //Se convoca función

                    LEDV=1;

                   LEDR=0;

                   Set_PWM();                                        //Se convoca función

                }

        }

 

Descargas

Software XIDE v1.0

Descarga el software XIDE v1.0 

Práctica 9-XCU-PIC10F322

Descargar código en mikroC PRO for PIC de la práctica 9.

PIC12F

Descripción

En esta práctica se realiza un control PWM para regular la intensidad luminosa de cada color de un LED RGB de cátodo común, por medio de un puerto PWM, usando los módulos X-TRAINER P8 con el PIC12F1572.

 

Materiales:

1 x Módulo X-TRAINER P8. Comprar

1 x Módulo programador XCU. Comprar

1 x Microcontrolador PIC12F1572. Comprar

1 x LED RGB. Comprar

1 x Resistencia de 330 Ohms. Comprar

1 x Juego de cable Dupont . Comprar

1 x Protoboard de 830 puntos. Comprar

1 x Cable micro USB.

 

Software:

Sistema operativo Windows 7 o posterior.

MikroC PRO for PIC. Descarga

XIDE v1.0 Descarga

 

Procedimiento

1. En el apartado de "Diagrama esquemático", que se encuentra a continuación, selecciona tu módulo, realiza las conexiones que se muestran en la imagen y conéctalo a la computadora.

2. Al final de esta práctica, en el apartado de "Descargas", puedes encontrar los archivos del código fuente, o bien copiarlo del apartado de "Código" que se encuentra más abajo.

3. Si descargaste el archivo del paso 2, omite este paso. Si copiaste el código, abre el compilador, pega el código en un nuevo proyecto, selecciona en el apartado de librerías la necesaria para esta práctica como se muestra en la siguiente imagen y realiza la compilación. En el siguiente link encontrarás un manual para compilar en MikroC PRO for PIC.

4. Abre el Software XIDE v1.0 y programa el código que descargaste o compilaste, en el módulo. En el siguiente link encontrarás el manual de usuario para el Software XIDE v1.0. 

5. Al terminar de programar, el módulo se reiniciará y el programa de esta práctica se ejecutará.

 

Diagrama esquemático

X-TRAINER P8
X-TRAINER P8

 

Código

Código

/*

AUTOR: MICROSIDE TECHNOLOGY S.A. DE C.V.

FECHA: JUNIO 2019

*/

/**************************************************************************

Esta práctica consiste en realizar un control PWM

para el control de un LED RGB

**************************************************************************/

/**************************************************************************

Para configurar el oscilador:

1) Project> Edit Project>Oscillator Selection Bits>seleccionar "INTOSC oscillator: CLKIN function disabled"

2) Project>Edit Project, insertar 32000000 en "MCU clock frecuency (MHz)" box

**************************************************************************/

#define LEDR LATA0_bit                  // Puerto como salida

#define LEDV LATA5_bit                  // Puerto como salida

#define LEDA LATA4_bit                  // Puerto como salida

void SisInit(void) {                              //inicializa el PIC

OSCCON = 0xF0;                              //11110000 32 MHz

LATA = 0;                                           //Puerto como salidas digitales

TRISA = 0;                                         //Puerto como salida

PWM3_Init(1000,4);                           //Inicializa el modulo a 1KHz

PWM3_Start();                                   // Inicializa el módulo PWM1

}

void Set_PWM(void)

{

int i;                                                      // Definición de variables

      for(i=255;i>0;i--)                            // Ciclo para disminuir el valor de la variable

     {

           PWM3_Set_Duty(i<<8);          // Guarda la salida pwm en la variable

          delay_ms(5);                              // Retardo de 5ms

     }

     for(i=0;i<255;i++)                          // Ciclo para aumentar el valor de la variable

    {

         PWM3_Set_Duty(i<<8);            // Guarda la salida pwm en la variable

          delay_ms(5);                              // Retardo de 5ms

     }

}

void main()

{

       SisInit();

       while(1)

   {

          LEDA=0;

         LEDV=0;

         LEDR=1;

        Set_PWM();                          // Se convoca función

         LEDA=0;

         LEDV=1;

         LEDR=0;

        Set_PWM();                         // Se convoca función

         LEDA=1;

         LEDV=0;

         LEDR=0;

         Set_PWM();                     // Se convoca función

      }

}

 

Descargas

Software XIDE v1.0

Descarga el software XIDE v1.0 

Práctica 9- XCU-12F1572

Descargar código en mikroC PRO for PIC de la práctica 9.

PIC16F

Descripción

En esta práctica se realiza un control PWM para regular la intensidad luminosa de cada color de un LED RGB de cátodo común, por medio de un puerto PWM, usando el módulo X-TRAINER P8 con el PIC16F1827.

 

Materiales:

1 x Módulo X-TRAINER P8. Comprar

1 x Módulo Programador XCU. Comprar

1 x Microcontrolador PIC16F1827. Comprar

1 x LED RGB. Comprar

1 x Resistencia de 330 Ohms. Comprar

1 x Juego de cable Dupont. Comprar

1 x Protoboard de 830 puntos. Comprar

1 x Cable micro USB.

 

Software:

Sistema Operativo Windows 7 o posterior.

MikroC PRO for PIC. Descarga

XIDE v1.0 Descarga

 

Procedimiento

1. En el apartado de "Diagrama esquemático", que se encuentra a continuación, selecciona tu módulo, realiza las conexiones que se muestran en la imagen y conéctalo a la computadora.

2. Al final de esta práctica, en el apartado de "Descargas", puedes encontrar los archivos del código fuente, o bien copiarlo del apartado de "Código" que se encuentra más abajo.

3. Si descargaste el archivo del paso 2, omite este paso. Si copiaste el código, abre el compilador, pega el código en un nuevo proyecto, selecciona en el apartado de librerías la necesaria para esta práctica como se muestra en la siguiente imagen y realiza la compilación. En el siguiente link encontrarás un manual para compilar en MikroC PRO for PIC.

4. Abre el Software XIDE v1.0 y programa el código que descargaste o compilaste, en el módulo. En el siguiente link encontrarás el manual de usuario para el Software XIDE v1.0. 

5. Al terminar de programar, el módulo se reiniciará y el programa de esta práctica se ejecutará.

 

Diagrama esquemático

 

X-TRAINER P8
X-TRAINER P8

 

Código 

Código

/*

AUTOR: MICROSIDE TECHNOLOGY S.A. DE C.V.

FECHA: JUNIO 2019

*/

/**************************************************************************

Esta práctica consiste en realizar un control PWM

para el control de un LED RGB

**************************************************************************/

/**************************************************************************

1) Tools>Options>Output>Output Options, marcar "Long HEX format"

2) Project>Edit Project, insertar 32000000 en "MCU Clock Frequency [MHz]" box

**************************************************************************/

int i;                                                                                             //Declaramos la variable

#define LEDR LATB0_bit

#define LEDV LATB1_bit

#define LEDA LATB2_bit

void SisInit(void)
{

                                                                                                         //Inicializa el PIC

                                                                                                        //Configura el oscilador interno

       OSCCON = 0xF0;                                                                //Cambiar HFINTOSC a 32MHz

                                                                                                        //Configurar entradas y salida

      LATB = 0;                                                                               //puerto

      TRISB = 0;                                                                             //PIN como salida

     PWM1_Init (500000);                                                        // Inicializa PWM a 500000 Hz

     PWM1_Start ();                                                                     // Inicia PWM

}

       void Set_PWM(void)

        {

               int i;                                                                                //Declaramos la variable

               for (i= 255; I > 0; i--)                                                  // Ciclo para disminuir el valor de la variable

               {

                  PWM1_Set_Duty (i);                                              // Guarda la salida pwm en la variable

                  delay_ms (5);                                                             // Retardo de 5ms

                }

              for (i = 0; i < 255; i++)                                                // Ciclo para aumentar el valor de la variable

              {

                 PWM1_Set_Duty (i);                                                // Guarda la salida pwm en la variable

                 delay_ms (5);                                                             // Retardo de 5ms

              }

        }

void main ()

{

       SisInit () ;

       while (1)                                                                                 // Ciclo infinito

       {

           LEDR = 1;

           LEDA = 0;

           LEDV = 0;

  Set_PWM();

           LEDV = 1 ;

           LEDR = 0;

           LEDA = 0;

  Set_PWM ();

           LEDV = 0 ;

           LEDR = 0;

           LEDA = 1;

  Set_PWM ();

           }

}

 

Descargas

Software XIDE v1.0

Descarga el software XIDE v1.0 

Práctica 9-PIC-XCU-16F

Descargar código en mikroC PRO for PIC de la práctica 9.

PIC18F

Descripción

En esta práctica se realiza un control PWM para regular la intensidad luminosa de cada color de un LED RGB de cátodo común, por medio de un puerto PWM, usando los módulos X-TRAINER P8 o X-TRAINER P8 DIP28 con el PIC18F25K22.

 

Materiales:

1 x Módulo X-TRAINER P8 o X-TRAINER P8 DIP28. Comprar

1 x Módulo Programador XCU. Comprar

1 x Microcontrolador PIC18F25K22. Comprar

1 x LED RGB. Comprar

1 x Resistencia 330 Ohms. Comprar

1 x Protoboard de 830 puntos. Comprar

1 x Juego de cables Dupont. Comprar

1 x Cable micro USB.

 

Software:

Windows 7 o posterior.

MikroC PRO for PIC. Descarga

XIDE v1.0 Descarga

 

Procedimiento

1. En el apartado de "Diagrama esquemático", que se encuentra a continuación, selecciona tu módulo, realiza las conexiones que se muestran en la imagen y conéctalo a la computadora.

2. Al final de esta práctica, en el apartado de "Descargas", puedes encontrar los archivos del código fuente, o bien copiarlo del apartado de "Código" que se encuentra más abajo.

3. Si descargaste el archivo del paso 2, omite este paso. Si copiaste el código, abre el compilador, pega el código en un nuevo proyecto, selecciona en el apartado de librerías la necesaria para esta práctica como se muestra en la siguiente imagen y realiza la compilación. En el siguiente link encontrarás un manual para compilar en MikroC PRO for PIC.

4. Abre el Software XIDE v1.0 y programa el código que descargaste o compilaste, en el módulo. En el siguiente link encontrarás el manual de usuario para el Software XIDE v1.0. 

5.Al terminar de programar, el módulo se reiniciará y el programa de esta práctica se ejecutará.

 

Diagrama esquemático

 

X-TRAINER P8
X-TRAINER P8 DIP28
X-TRAINER P8

X-TRAINER P8 DIP28

 

Código

Código

/*

AUTOR: MICROSIDE TECHNOLOGY S.A. DE C.V.

FECHA: JUNIO 2019

*/

/**************************************************************************

Esta práctica consiste en realizar un control PWM

para el control de un LED RGB

**************************************************************************/

/**************************************************************************

1) Project> Edit Project> Oscillator Selection> Internal Oscillator"

2) Project> Edit Project> Insertar 64000000 en "MCU Clock Frequency [MHz]" box

**************************************************************************/

#define LEDR LATB0_bit                                                                          //Se define variable global para led rojo

#define LEDV LATB1_bit                                                                           //Se define variable global para led verde 

#define LEDA LATB2_bit                                                                          //Se define variable global para led azul

void SisInit(void)                                                                                          //Se inicializa el PIC

{                                                                                                                        //Se configura el oscilador interno

           OSCCON = 0x78;                                                                               //Se cambia la frecuencia a 16MHz

           PLLEN_bit=1 ;                                                                                   //Se habilita el multiplicador de frecuencia x4

                                                                                                                          //Se configuran las entradas y salidas del PIC

          LATB = 0;                                                                                             //Se escribe ceros a la salida del puerto B

          TRISB = 0;                                                                                            //Se declara el puerto B como salida

          PWM1_Init(500000);                                                                       //Se inicializa el PWM a 500000 Hz

          PWM1_Start();                                                                                    //Se inicia el ciclo PWM

}

void Set_PWM(void)                                                                                   //Se crea una función para el control PWM

{

          int i ;                                                                                                      //Se declara una variable de inicio

          for(i=255;i>0;i--)                                                                               //Se crea un ciclo para disminuir el valor de la variable

                         {

                            PWM1_Set_Duty(i);                                                       //Se guarda la salida PWM en la variable

                            delay_ms(5);                                                                     //Retardo

                         }

          for(i=0;i<255;i++)                                                                             //Se crea un ciclo para aumentar el valor de la variable

                         {

                             PWM1_Set_Duty(i);                                                       //Se guarda la salida PWM en la variable

                             delay_ms(5);                                                                    //Retardo

                         }

}

void main()                                                                                                    //Se instancia el main principal

{

          SisInit();                                                                                               //Se instancia la configuración del PIC

          while (1)                                                                                                //Se crea un ciclo infinito, mientras sea verdadero

                         {

                             LEDA=0;                                                                           //Led azul en bajo

                             LEDV=0;                                                                           //Led verde en bajo

                             LEDR=1;                                                                            //Led rojo en alto

                             Set_PWM();                                                                      //Se instancia la función del PWM

                             LEDA=0;                                                                           //Led azul en bajo

                             LEDV=1;                                                                            //Led en verde en alto

                             LEDR=0;                                                                           //Led rojo en bajo

                             Set_PWM();                                                                     //Se instancia la función del PWM

                             LEDA=1;                                                                           //Led azul en alto

                             LEDV=0;                                                                           //Led verde en bajo

                             LEDR=0;                                                                           //Led rojo en bajo

                             Set_PWM();                                                                      //Se instancia la función del PWM

                     }

}

 

Descargas

Software XIDE v1.0

Descarga el software XIDE v1.0 

Práctica 9 – XCU – PIC18F25K22

Descargar código en MikroC PRO for PIC de la práctica 9.

MPLAB X IDE
Bootloader PIC18FX5K50
Programador PK3 LITE
Bootloader PIC18FX5K50

Descripción

En esta práctica se realiza un control PWM para regular la intensidad luminosa de cada color de un LED RGB de cátodo común, por medio de un puerto PWM, usando los módulos X-TRAINER P8 o X-TRAINER P8 DIP40 o X-TRAINER P8 DIP28 con el PIC18F45K50 PIC18F25K50.

 

Materiales:

1 x Módulo X-TRAINER P8 o X-TRAINER P8 DIP40 o X-TRAINER P8 DIP28Comprar

1 x LED RGB. Comprar

1 x Resistencia 330 Ohms. Comprar

1 x Protoboard de 830 puntos. Comprar

1 x Juego de cables Dupont. Comprar

1 x Cable micro USB.

 

Software:

Windows 7 o posterior.

MPLAB X IDE. Descarga

XIDE v1.0 Descarga

 

Procedimiento

1. En el apartado de "Diagrama esquemático", que se encuentra a continuación, selecciona tu módulo, realiza las conexiones que se muestran en la imagen y conéctalo a la computadora.

2. Al final de esta práctica, en el apartado de "Descargas", puedes encontrar los archivos del código fuente, o bien copiarlo del apartado de "Código" que se encuentra más abajo.

3. Si descargaste el archivo del paso 2, omite este paso. Si copiaste el código, ejecuta MPLAB X IDE, pega el código en un nuevo proyecto y realiza la compilación. En el siguiente link encontrarás un manual para compilar tu proyecto en MPLAB X IDE.

4. Abre el Software XIDE v1.0 y programa el código que descargaste o compilaste en el módulo. En el siguiente  link encontrarás el manual de usuario para el Software XIDE v1.0. 

5. Al terminar de programar, el módulo se reiniciará y el programa de esta práctica se ejecutará.

 

Diagrama esquemático

 

X-TRAINER P8
X-TRAINER P8 DIP 40
X-TRAINER P8 DIP 28
X-TRAINER P8

X-TRAINER P8 DIP 40

X-TRAINER P8 DIP 28

 

Código

 

Código

/*

AUTOR: MICROSIDE TECHNOLOGY S.A. DE C.V.

FECHA: JUNIO 2019

*/

/**************************************************************************

Esta práctica consiste en realizar un control PWM

para el control de un LED RGB

**************************************************************************/

#include <xc.h>

#include <stdint.h>

#define _XTAL_FREQ 48000000                          //DEFINE LA FRECUENCIA DE 64MHz

#define LEDR LATBbits.LATB0                            // Definimos salida para LED

#define LEDV LATBbits.LATB1                            // Definimos salida para LED

#define LEDA LATBbits.LATB2                            // Definimos salida para LED

void SisInit(void) {                                               //INICIALIZA EL PIC

//CONFIGURA EL OSCILADOR INTERNO

OSCCON = 0x70;                                               //Cambiar HFINTOSC a 16MHz

OSCCON2 = 0x10;                                             //Habilita PLL, oscilador primario deshabilitado

OSCTUNE = 0x80;                                             //3X PLL

ACTCON = 0x90;

while (OSCCON2bits.PLLRDY == 0);

//CONFIGURAR ENTRADAS Y SALIDAS

TRISBbits.TRISB0 = 0;                                        //PIN como salida

ANSELBbits.ANSB0 = 0;                                      //PIN como digital

TRISBbits.TRISB1 = 0;                                         //PIN como salida

ANSELBbits.ANSB1 = 0;                                      //PIN como digital

TRISBbits.TRISB2 = 0;                                         //PIN como salida

ANSELBbits.ANSB2 = 0;                                       //PIN como digital

TRISCbits.TRISC2 = 0;                                          //PIN como salida

ANSELCbits.ANSC2 = 0;                                        //PIN como digital

//CONFIGURA TMR2

PR2 = 0xFF; // PR2 255

TMR2 = 0x00; // TMR2 0

T2CON = 0x16; // T2CKPS 1:16; T2OUTPS 1:3; TMR2ON on

//CONFIGURA PWM

CCP1CON = 0x3C;

ECCP1AS = 0x00;

PWM1CON = 0x80;

PSTR1CON = 0x01;

}

void PWM_Set_Duty(uint16_t dutyValue) {

CCPR1L = ((dutyValue & 0x03FC) >> 2);

CCP1CON = ((uint8_t) (CCP1CON & 0xCF) | ((dutyValue & 0x0003) << 4));

}

void Set_PWM(void)

{

    int i;                                                                //Declaramos variable

    for (i = 1023; i > 0; i--)                                      // Ciclo para disminuir el valor de la variable

     {

       PWM_Set_Duty(i);                                          // Guarda la salida PWM en la variable

       __delay_ms(1);                                               // Retardo de 1ms

   }

     for (i = 0; i < 1023; i++)                                    // Ciclo para aumentar el valor de la variable

     {

        PWM_Set_Duty(i);                                          // Guarda la salida PWM en la variable

        __delay_ms(1);                                               // Retardo de 1ms

    }

}

void main(void) {

     SisInit();

       while (1) {

            LEDR = 1;

            LEDA = 0;

            LEDV = 0;

            Set_PWM();                                                 // Convocamos la función

            LEDV = 1;

            LEDR = 0;

            LEDA = 0;

            Set_PWM();                                                 // Convocamos la función

            LEDA = 1;

            LEDR = 0;

            LEDV = 0;

            Set_PWM();                                                 // Convocamos la función

       }

}


Descargas

Software XIDE v1.0

Descarga el software XIDE v1.0 

Práctica 9-PIC-BOOTLOADER/MPLAB

Descargar código en MPLAB X IDE de la práctica 9.

Programador PK3 LITE

Descripción

En esta práctica se realiza un control PWM para regular la intensidad luminosa de cada color de un LED RGB de cátodo común, por medio de un puerto PWM, usando los módulos X-TRAINER P8  con el PIC18F47K42.

 

Materiales:

1 x Módulo X-TRAINER P8 o X-TRAINER P8 DIP40Comprar

1 x Módulo Programador PK3 LITE. Comprar

1 x Microcontrolador PIC18F47K42. Comprar

1 x LED RGB. Comprar

1 x Resistencia de 330 Ohms. Comprar

1 x Juego de cables Dupont. Comprar

1 x Protoboard de 830 puntos. Comprar

1 x Cable micro USB.

 

Software:

Windows 7 o posterior.

MPLAB X IDE. Descarga

 

Procedimiento

1. En el apartado de "Diagrama esquemático", que se encuentra a continuación, selecciona tu módulo, realiza las conexiones que se muestran en la imagen y conéctalo a la computadora.

2. Al final de esta práctica, en el apartado de "Descargas", puedes encontrar los archivos del código fuente, o bien copiarlo del apartado de "Código" que se encuentra más abajo.

3. Si descargaste el archivo del paso 2, omite este paso. Si copiaste el código, ejecuta MPLAB X IDE, pega el código en un nuevo proyecto y realiza la compilación. 

4. Programa el código en el microcontrolador. En el siguiente link encontrarás un manual para compilar y programar tu proyecto en MPLAB X IDE.

5. Al terminar de programar, el módulo se reiniciará y el programa de esta práctica se ejecutará.

 

Diagrama esquemático

 

X-TRAINER P8
X-TRAINER P8 DIP 40
X-TRAINER P8

X-TRAINER P8 DIP 40

 

Código

Código

/*

AUTOR: MICROSIDE TECHNOLOGY S.A. DE C.V.

FECHA: JUNIO 2019

*/

/**************************************************************************

Esta práctica consiste en realizar un control PWM para el control de un

LED RGB

**************************************************************************/

#pragma config FEXTOSC = OFF                               //Oscilador externo deshabilitado

#pragma config RSTOSC = HFINTOSC_64MHZ        //Frecuencia de 64MHz

#pragma config CLKOUTEN = OFF                           //Funcion CLOKOUTEN deshabilitada

#pragma config WDTE = OFF                                     //Deshabilita WDT

#include <xc.h>

#include <stdint.h>

#define _XTAL_FREQ 64000000                                 

#define LEDR LATBbits.LATB0                                 // Definimos salida para LED

#define LEDV LATBbits.LATB1                                 // Definimos salida para LED

#define LEDA LATBbits.LATB2                                 // Definimos salida para LED

void SisInit(void) {                                                      

 OSCCON1 = 0X60;                                                   //NOSC HFINTOSC; NDIV 1;

 OSCCON3 = 0X00;                                                   //CSWHOLD procede; oscilador secundario opera en Low power;

 OSCEN = 0X00;                                                        //Activación manual de osciladores

 OSCFRQ = 0X08;                                                      //HFFRQ 64_MHz;

 OSCTUNE = 0X00;                                                   //TUN 0;

 TRISBbits.TRISB0 = 0;                                               //PIN como salida

 ANSELBbits.ANSELB0 = 0;                                       //PIN como digital

 TRISBbits.TRISB1 = 0;                                               //PIN como salida

 ANSELBbits.ANSELB1 = 0;                                       //PIN como digital

 TRISBbits.TRISB2 = 0;                                               //PIN como salida

 ANSELBbits.ANSELB2 = 0;                                      //PIN como digital

 TRISCbits.TRISC2 = 0;                                              //PIN como salida

 ANSELCbits.ANSELC2 = 0;                                      //PIN como digital

 RC2PPS = 0x09;                                                         //RC2->CCP1:CCP1;

T4CLKCON = 0x01;

 T4HLT = 0x00;

 T4RST = 0x00;

 T4PR = 0xFF;

 T4TMR = 0x00;

 T4CON = 0xB0;

 CCP1CON = 0x8C;

 CCPR1H = 0x00;

 CCPR1L = 0x00;

 CCPTMRS0bits.C1TSEL = 0x2;

}

void PWM_Set_Duty(uint16_t dutyValue) {

   dutyValue &= 0x03FF;

   CCPR1H = dutyValue >> 8;

   CCPR1L = dutyValue;

}

void Set_PWM(void)

{

  int i; 

  for (i = 1023; i > 0; i--)                                    // Ciclo para disminuir el valor de la variable

  {

       PWM_Set_Duty(i);                                    // Guarda la salida PWM en la variable

      __delay_ms(1);                                           // Retardo de 1ms

   }

  for (i = 0; i < 1023; i++)                                 // Ciclo para aumentar el valor de la variable

  {

      PWM_Set_Duty(i);                                    // Guarda la salida PWM en la variable

      __delay_ms(1);                                          // Retardo de 1ms

}

}

void main(void) {

     SisInit();

    while (1) {

             LEDR = 1;

             LEDA = 0;

             LEDV = 0;

            Set_PWM();                                         // Convocamos la función

            LEDR = 0;

            LEDA = 0;

            LEDV = 1;

           Set_PWM();                                         // Convocamos la función

           LEDA = 1;

           LEDR = 0;

           LEDV = 0;

          Set_PWM();                                          // Convocamos la función

       }

}

 


Descargas

 

Práctica 9 – PIC – PK3

Descargar código en MPLAB X IDE de la práctica 9.

AVR
MikroC PRO
Atmel Studio 7
MikroC PRO
Programador XCU
Programador XCU

Descripción

En esta práctica se realiza un control PWM para regular la intensidad luminosa de cada color de un LED RGB de cátodo común, por medio de un puerto PWM, usando los módulos X-UNO o X-NANO .

 

Materiales:

1 x Módulo X-UNO o X-NANOComprar

1 x Módulo Programador XCU.  Comprar

1 x Módulo X-AVR. Comprar

1 x Juego de cables Dupont. Comprar

1 x Protoboard de 830 puntos. Comprar

1 x Resistencia de 330 Ohms. Comprar

1 x LED RGB. Comprar

1 x Cable micro USB.


Software:

Windows 7 o posterior.

MikroC PRO for AVR. Descarga

XIDE v1.0 Descarga

 

Procedimiento

1. En el apartado de "Diagrama esquemático", que se encuentra a continuación, selecciona tu módulo, realiza las conexiones que se muestran en la imagen y conéctalo a la computadora.

2. Al final de esta práctica, en el apartado de "Descargas", puedes encontrar los archivos del código fuente, o bien copiarlo del apartado de "Código" que se encuentra más abajo.

3. Si descargaste el archivo del paso 2, omite este paso. Si copiaste el código, abre el compilador, pega el código en un nuevo proyecto, verifica en el apartado de librerías que este seleccionada la necesaria para esta práctica como se muestra en la siguiente imagen y realiza la compilación. En el siguiente link encontrarás un manual para compilar en MikroC PRO for AVR.

4. Abre el Software XIDE v1.0 y programa el código que descargaste o compilaste en el módulo. En el siguiente link encontrarás el manual de usuario para el Software XIDE v1.0. 

5. Al terminar de programar, el módulo se reiniciará y el programa de esta práctica se ejecutará.

 

Diagrama esquemático

 

X-UNO
X-NANO
X-UNO

X-NANO

 

Código

Código

/*

AUTOR: MICROSIDE TECHNOLOGY S.A. DE C.V.

FECHA: JUNIO 2019

*/

/**************************************************************************

En esta práctica se variará el ciclo de trabajo del módulo PWM en el pin D6, para el control de un LED RGB de cátodo común regulando la

iluminación de cada color.

**************************************************************************/

#define LEDR_ON      PORTB |= (1<<PORTB0)

#define LEDR_OFF     PORTB &= ~(1<<PORTB0)

#define LEDV_ON     PORTB |= (1<<PORTB1)

#define LEDV_OFF     PORTB &= ~(1<<PORTB1)

#define LEDA_ON     PORTB |= (1<<PORTB2)

#define LEDA_OFF    PORTB &= ~(1<<PORTB2)

char Duty;

int VR=0,VA=0,VV=0,CONT=0;                                          //Declaramos las variables VR,VA,VV,CONT

SisInit(void)

{

   Duty = 0;                                                                          // Se inicializa el valor de current_duty

   DDD6_bit = 1;                                                                  // Se establese PORTD pin 6 como salida para el PWM

   PWM1_Init(_PWM1_FAST_MODE, _PWM1_PRESCALER_64, _PWM1_INVERTED, Duty);     //Inicializa el modo del PWM

   DDB0_bit=1;                                                                    //B1 como salida

   DDB1_bit=1;                                                                    //B2 como salida

   DDB2_bit=1;                                                                    //B3 como salida

}

void main(){

   SisInit();

while(1){

        for(VR=0;VR<255;VR++)                                               // Ciclo para aumentar el valor de la variable

        {

        LEDA_OFF;

        LEDV_OFF;

        Duty=VR;

        PWM1_Set_Duty(Duty);                                                   // Guarda la salida pwm en la variablE

        delay_ms(5);                                                                    // Retardo de 5ms

        LEDR_ON;

        }

        for(VR=255;VR>0;VR--)                                                   // Ciclo para disminuir el valor de la variable

        {

         LEDA_OFF;

         LEDV_OFF;

         Duty=VR;

         PWM1_Set_Duty(Duty);                                                    // Guarda la salida pwm en la variable

         delay_ms(5);                                                                      // Retardo de 5ms

         LEDR_ON;

         }

         for(VV=0;VV<255;VV++)                                                  // Ciclo para aumentar el valor de la variable

         {

         LEDR_OFF;

         LEDA_OFF;

         Duty=VV;

         PWM1_Set_Duty(Duty);                                                   // Guarda la salida pwm en la variablE

         delay_ms(5);                                                                     // Retardo de 5ms

         LEDV_ON;

         }

         for(VV=255;VV>0;VV--)                                                      // Ciclo para disminuir el valor de la variable

         {

         LEDR_OFF;

         LEDA_OFF;

         Duty=VV;

         PWM1_Set_Duty(Duty);                                                      // Guarda la salida pwm en la variable

         delay_ms(5);                                                                       // Retardo de 5ms

         LEDV_ON;

         }

         for(VA=0;VA<255;VA++)                                                       // Ciclo para aumentar el valor de la variable

          {

         LEDR_OFF;

         LEDV_OFF;

         Duty=VA;

         PWM1_Set_Duty(Duty);                                                        // Guarda la salida pwm en la variablE

         delay_ms(5);                                                                         // Retardo de 5ms

         LEDA_ON;

        }

        for(VA=255;VA>0;VA--)                                                          // Ciclo para disminuir el valor de la variable

       {

        LEDR_OFF;

        LEDV_OFF;

        Duty=VA;

        PWM1_Set_Duty(Duty);                                                       // Guarda la salida pwm en la variable

       delay_ms(5);                                                                          // Retardo de 5ms

       LEDA_ON;

       }

    }

}

 

Descargas

Software XIDE v1.0

Descarga el software XIDE v1.0 

 

Práctica 9-XCU-AVR

Descargar código en mikroC PRO for AVR de la práctica 9.

 

Atmel Studio 7
Programador MKII LITE
Programador MKII LITE

Descripción

En esta práctica se realiza un control PWM para regular la intensidad luminosa de cada color de un LED RGB de cátodo común, por medio de un puerto PWM, usando los módulos X-UNO o X-NANO .

 

Materiales:

1 x Módulo X-UNOX-NANO. Comprar

1 x Módulo Programador MKII LITE. Comprar

1 x Módulo X-AVR. Comprar

1 x Juego de cables Dupont. Comprar

1 x Protoboard de 830 puntos. Comprar

1 x Resistencia de 330 Ohms. Comprar

1 x LED RGB. Comprar

1 x Cable micro USB.

 

Software:

Windows 7 o posterior.

Atmel Studio 7. Descarga

 

Procedimiento

1. En el apartado de "Diagrama esquemático", que se encuentra a continuación, selecciona tu módulo, realiza las conexiones que se muestran en la imagen y conéctalo a la computadora.

2. Al final de esta práctica, en el apartado de "Descargas", puedes encontrar los archivos del código fuente, o bien copiarlo del apartado de "Código" que se encuentra más abajo.

3. Si descargaste el archivo del paso 2, omite este paso. Si copiaste el código, ejecuta Atmel Studio 7, pega el código en un nuevo proyecto y realiza la compilación.

4. Programa el código que descargaste o compilaste en el módulo. En el siguiente link encontrarás un manual para compilar y programar tu proyecto en Atmel Studio 7.

5. Al terminar de programar, el programa de esta práctica se ejecutará.

 

Diagrama esquemático

 

X-UNO
X-NANO
X-UNO

X-NANO

 

Código 

Código

/**

AUTOR: MICROSIDE TECHNOLOGY S.A. DE C.V.

FECHA: JUNIO 2019

*/

/**************************************************************************

Esta práctica consiste en realizar un control PWM para el control de un LED RGB

**************************************************************************/

#define F_CPU 16000000

#include <avr/io.h>

#include <util/delay.h>

#define LEDR_ON PORTB |= (1<<PORTB0)                                                                              //Enciende LED

#define LEDR_OFF PORTB &= ~(1<<PORTB0)                                                                           //Apaga LED

#define LEDV_ON PORTB |= (1<<PORTB1)                                                                              //Enciende LED

#define LEDV_OFF PORTB &= ~(1<<PORTB1)                                                                          //Apaga LED

#define LEDA_ON PORTB |= (1<<PORTB2)                                                                              //Enciende LED

#define LEDA_OFF PORTB &= ~(1<<PORTB2)                                                                          //Apaga LED

void Set_PWM(void)

{

     int i;                                                                                                                                         //Declaramos la variable

     for(i=255;i>0;i--)                                                                                                                     // Disminuye el valor de la variable

     {

             OCR0A=i;                                                                                                                       // Guarda la salida PWM en la variable

             _delay_ms(2);                                                                                                                // Retardo de 5ms

      }

     for(i=0;i<255;i++)                                                                                                                  // Aumenta el valor de la variable

     {

               OCR0A=i;                                                                                                                       // Guarda la salida PWM en la variable

 

              _delay_ms(2);                                                                                                                // Retardo de 5ms

       }

}

int main(void)

{

               DDRD|=(1<<6);                                                                                                             //PIN OC0A como salida obligatorio para PWM

               TCCR0A=0b10000011;                                                                                                 //PWM por el OC0A, no invertido,

               TCCR0B=0b00000001;

               OCR0A=0;

               DDRB |= (1<<DDB0);                                                                                                   // PIN como salida

               DDRB |= (1<<DDB1);                                                                                                    // PIN como salida

               DDRB |= (1<<DDB2);                                                                                                   // PIN como salida

               while(1)

               {

                             LEDA_OFF;

                             LEDV_OFF;

                             LEDR_ON;

                    Set_PWM();                                                                                                                // Se convoca a la función

                             LEDR_OFF;

                             LEDA_OFF;

                             LEDV_ON;

                     Set_PWM();                                                                                                               // Se convoca a la función

                             LEDR_OFF;

                             LEDV_OFF;

                             LEDA_ON;

                    Set_PWM();                                                                                                                // Se convoca a la función

               }

}

 

Descargas

Software XIDE v1.0

Descarga el software XIDE v1.0 

Práctica 9-AVR-MKII

Descargar código en Atmel Studio 7 de la práctica 9.

ARDUINO

Descripción

En esta práctica se realiza un control PWM para regular la intensidad luminosa de cada color de un LED RGB de cátodo común, por medio de un puerto PWM, usando los módulos  X-UNO o X-MEGA o X-NANO.

 

Materiales:

1 x Módulo X-UNO o X-MEGA o X-NANO.  Comprar

1 x Módulo Programador XCU. Comprar

1 x Juego de cables Dupont. Comprar

1 x Protoboard de 830 puntos. Comprar

1 x Resistencia de 330 Ohms. Comprar

1 x LED RGB. Comprar

1 x Cable micro USB.

 

Software:

Windows 7 o posterior.

Arduino IDE. Descarga

 

Procedimiento

1. En el apartado de "Diagrama esquemático", que se encuentra a continuación, selecciona tu módulo, realiza las conexiones que se muestran en la imagen y conéctalo a la computadora.

2. Al final de esta práctica, en el apartado de "Descargas", puedes encontrar los archivos del código fuente, o bien copiarlo del apartado de "Código" que se encuentra más abajo.

3. Si descargaste el archivo del paso 2, omite este paso. Si copiaste el código, abre el software Arduino IDE, pega el código en un nuevo proyecto, realiza la compilación. 

4. Programa el código que descargaste o compilaste, en el módulo. En el siguiente link encontrarás un manual para compilar y programar en Arduino IDE.

5. Al terminar de programar, el módulo se reiniciará y el programa de esta práctica se ejecutará.

 

Diagrama esquemático

 

X-UNO
X-MEGA
X-NANO
X-UNO

X-MEGA

X-NANO

 

Código

Código

/*

AUTOR: MICROSIDE TECHNOLOGY S.A. DE C.V.

FECHA: JUNIO 2019

*/

/**************************************************************************

Esta práctica consiste en realizar un control PWM para el control de un LED RGB.

**************************************************************************/

int pwm = 6;                                                                           //pin de salida PWM

int i = 0;                                                                                  //varible para que el ciclo de trabajo aumente

const int LEDR = 8;                                                             //Número del pin para LED

const int LEDV = 9;                                                             //Número del pin para LED

const int LEDA = 10;                                                             //Número del pin para LED

int VR=0,VA=0,VV=0;                                                         //Declaramos las variables

VR,VA,VV,CONT

void setup()

{

pinMode (pwm, OUTPUT) ;
pinMode (5, OUTPUT) ;
pinMode (LEDR, OUTPUT);                                                //Inicializa el PIN como una salida digital
pinMode (LEDV, OUTPUT);                                                //Inicializa el PIN como una salida digital
pinMode (LEDA, OUTPUT);                                               //Inicializa el PIN como una salida digital
}

void loop()
{
                digitalWrite (LEDA, LOW);
                digitalWrite (LEDV, LOW);
                digitalWrite (LEDR, HIGH);

       for (VR= 255; VR>= 0; VR--)                             //Ciclo para decrementar el brillo
        {
                analogWrite (pwm, VR);                             //Asigna contador al ciclo de trabajo
                analogWrite (5, 255 - VR);
                delay (5);                                                         //Retardo
         }
      for (VR = 0; VR <= 255; VR++)                             //Ciclo para incrementar el brillo
         {
                analogWrite (pwm, VR);                             //Asigna contador al ciclo de trabajo
                analogWrite (5, 255 - VR);
                delay (5);                                                         //Retardo
           }
                digitalWrite (LEDA, LOW);
                digitalWrite (LEDV, HIGH);
               digitalWrite (LEDR, LOW);

       for (VV= 255; VV>= 0; VV--)                             //Ciclo para decrementar el brillo
          {
                analogWrite (pwm, VV);                             //Asigna contador al ciclo de trabajo
                analogWrite (5, 255 - VV);
                delay (5);                                                         //Retardo
          }
        for (VV = 0; VV <= 255; VV++)                             //Ciclo para incrementar el brillo
          {
                analogWrite (pwm, VV);                               //Asigna contador al ciclo de trabajo
                analogWrite (5, 255 - VV);
                delay (5);                                                         //Retardo
          }
                digitalWrite (LEDA, HIGH);
                digitalWrite (LEDV, LOW);
                digitalWrite (LEDR, LOW);

       for (VA = 255; VA>= 0; VA--)                             //Ciclo para decrementar el brillo
          {
                analogWrite (pwm, VA);                             //Asigna contador al ciclo de trabajo
                analogWrite (5, 255 - VA);
                delay (5);                                                         //Retardo
            }
        for (VA = 0; VA <= 255; VA++)                             //Ciclo para incrementar el brillo
          {
                analogWrite (pwm, VA);                             //Asigna contador al ciclo de trabajo
                analogWrite (5, 255 - VA);
                delay (5);                                                         //Retardo
           }
}

 

Descargas

Práctica 9 – Arduino

Descarga código en Arduino de la práctica 9.

Fecha

julio 17, 2019

Categoría

Prácticas XIDE

× WhatsApp