Práctica 5 – ADC

 

INTRODUCCIÓN

 

En esta práctica se implementa la lectura de un puerto ADC a través de una variación de voltaje con un potenciómetro y se despliega el valor analógico a través de LEDs. Esta práctica utiliza el módulo I/O’s ADC de Microside para facilitar componentes y conexiones.

 

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 implementa una lectura analógica, utilizando el potenciómetro incluido en el módulo I/O's ADC de Microside, el cual se conecta con los módulos X-TRAINER P8 o X-TRAINER P8 DIP40 o X-TRAINER P8 DIP28, con el PIC18F45K50 o el PIC18F25K50. El potenciómetro se conecta en el pin A3, el cual se configura como entrada y señal analógica. Para visualizar dicha lectura se utilizan 8 LEDs, conectados al puerto B, de tal manera que pueda observarse el incremento o decremento de voltaje del potenciómetro.

 

Materiales:

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

1 x Módulo I/O's ADC. 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 y realiza la compilación. 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

*/

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

Implementar una lectura analógica de un potenciómetro y desplegar el valor

en 8 LEDs

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

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

#DEVICE ADC=8                                            //Configura el ADC a 8 bits

#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

 

int ValorPot;                                                      //Variable para almacenar el valor leído del ADC

void SisInit(void)

{

set_tris_b (0X00);                                             //Configura todo el puerto B como salidas digitales

setup_adc_ports (sAN3);                                  //Configura solo el puerto A3 como entrada analógica

setup_adc (ADC_CLOCK_INTERNAL);     //Configura oscilador interno para la conversión

}

 

void main()

{

              SisInit () ;

 

              while (1)

                    {

                          set_adc_channel (3);                        //Selecciona el canal 3 para la conversión

                         ValorPot = read_adc ();                     //Lee el valor del ADC y lo guarda en la variable

                          if (ValorPot <= 28)                          //Compara el valor de el ADC con 28

                                {

                                    output_b (0b00000000);          // Leds activos
                                }

                           else if (ValorPot <= 56)                    //Compara el valor de el ADC con 56

                                {

                                    output_b (0b00000001);          // Leds activos
                                }

                            else if (ValorPot <= 84)                 //Compara el valor de el ADC con 84

                                {

                                    output_b (0b00000011);       // Leds activos

                                }

                           else if (ValorPot <= 112)                //Compara el valor de el ADC con 112

                                {

                                      output_b (0b00000111);      // Leds activos

                                }

                           else if (ValorPot <= 140)                //Compara el valor de el ADC con 140

                                {

                                      output_b (0b00001111);       // Leds activos

                                }

                            else if (ValorPot <= 168)               //Compara el valor de el ADC con 168

                                 {

                                        output_b (0b00011111);    // Leds activos

                                 }

                             else if (ValorPot <= 196)               //Compara el valor de el ADC con 196

                                 {

                                         output_b (0b00111111);    // Leds activos

                                 }

                             else if (ValorPot <= 252)               //Compara el valor de el ADC con 252

                                 {

                                       output_b (0b01111111);      // Leds activos

                                 }

                             else if (ValorPot <= 255)               //Compara el valor de el ADC con 255

                                   {

                                        output_b (0b11111111);    // Leds activos

                                    }

               }

}

 

Descargas

 

Software XIDE v1.0

Descarga el software XIDE v1.0 

 

Práctica 5 – PIC – Bootloader-PIC C Compiler

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

MikroC PRO
Bootloader PIC18FX5K50
Programador XCU
Bootloader PIC18FX5K50

Descripción

En esta práctica se implementa una lectura analógica, utilizando el potenciómetro incluido en el módulo I/O's ADC de Microside, el cual se conecta con los módulos X-TRAINER P8 o X-TRAINER P8 DIP40 o X-TRAINER P8 DIP28, con el PIC18F45K50 o el PIC18F25K50. El potenciómetro se conecta en el pin A3, el cual se configura como entrada y señal analógica. Para visualizar dicha lectura se utilizan 8 LEDs, conectados al puerto B, de tal manera que pueda observarse el incremento o decremento de voltaje del potenciómetro.

 

Materiales:

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

1 x Módulo I/O's ADC. 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

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

Implementar una lectura analógica de un potenciómetro y desplegar el valor

en 8 LEDs

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

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

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 el espacio para bootloader

unsigned int ValorPOT;                                                                             //Se declara una variable global para la lectura de la señal analógica

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 un bucle para estabilizar la frecuencia

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

                                                                                                                            //Se configuran las entradas y salidas del PIC

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

          TRISA3_bit = 1;                                                                                   //Se declara el pin A3 como entrada

          ANSA3_bit = 1;                                                                                    //Se declara el pin A3 como señal analógica
}


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

{

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

          ADC_Init_Advanced(_ADC_INTERNAL_REF);                         //Se instancia la librería y el voltaje de referencia a VDD y GND

          while (1)                                                                                                  //Se crea un bucle donde se ejecuta el código

                         {

                            ValorPOT=ADC_Get_Sample(3);                                  //Se lee el valor del potenciómetro a tráves del pin A3

                       if(ValorPot <=114)                                                              //Compara el valor de el ADC con 114
                                                            {

                                                               LATB=0b00000000;                     // Leds activos

                                                            }

                            else if(ValorPot <=228)                                                    //Compara el valor de el ADC con 228

                                                            {

                                                                LATB=0b00000001;                     // Leds activos

                                                            }

                             else if(ValorPot <=342)                                                   //Compara el valor de el ADC con 342

                                                            {

                                                                LATB=0b00000011;                     // Leds activos

                                                            }

                             else if(ValorPot <=456)                                                   //Compara el valor de el ADC con 456

                                                            {

                                                                LATB=0b00000111;                      // Leds activos

                                                            }

                             else if(ValorPot <=570)                                                    //Compara el valor de el ADC con 570

                                                            {

                                                                LATB=0b00001111;                       // Leds activos

                                                            }

                             else if(ValorPot <=684)                                                   //Compara el valor de el ADC con 684

                                                            {

                                                                 LATB=0b00011111;                       // Leds activos

                                                            }

                             else if(ValorPot <=798)                                                   //Compara el valor de el ADC con 798

                                                            {

                                                                LATB=0b00111111;                        // Leds activos

                                                            }

                             else if(ValorPot <=912)                                                    //Compara el valor de el ADC con 912

                                                            {

                                                                 LATB=0b01111111;                        // Leds activos

                                                            }

                             else if(ValorPot <=1024)                                                 //Compara el valor de el ADC con 1024

                                                            {

                                                               LATB=0b11111111;                           // Leds activos

                                                            }

                        }

}

 

Descargas

Software XIDE v1.0

Descarga el software XIDE v1.0 

Práctica 5 – PIC – Bootloader

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

Programador XCU
PIC10F
PIC12F
PIC16F
PIC18F
PIC10F

Descripción

En esta práctica se implementa una lectura analógica, utilizando el potenciómetro incluido en el módulo I/O's ADC de Microside, el cual se conecta con los módulos X-TRAINER P8 con el PIC10F322. El potenciómetro se conecta en el pin A0, el cual se configura como entrada y señal analógica. Para visualizar dicha lectura se utilizan 2 LEDs, conectados al puerto A, de tal manera que pueda observarse el incremento o decremento de voltaje del potenciómetro.


Materiales:

1 x Módulo X-TRAINER P8. Comprar

1 x Módulo Programador XCU. Comprar

1 x Microcontrolador PIC10F322. Comprar

1 x Módulo I/O's ADC. 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.

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 hacer una lectura de un puerto analogico y desplegar el valor en 2 leds

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

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

Para ocnfigurar el osilador interno:

1) Project>Edit Project, insertar 16000000 en "MCU Clock Frequency [MHz]" box

2) Project>Edit Project>Oscillator>Seleccion bit>Seleccionar "INTOSC oscillator: CLKIN function disabled"

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

char Bool_Var= 0x00;

unsigned int ValorPOT;

void SisInit(void) {                               //Inicializa el PIC

               OSCCON = 0X7B;                 // 0111 1011 16MHz

               TRISA = 0X09;

              //Configurar entradas y salidas

               LATA1_bit = 0;                     //Salida
             

              ANSA0_bit = 1;                     //PIN como analógico
}

void main()

{
             SisInit();
             ADC_Init();                               //Voltaje de referencia a VDD

              while (1)
              {
             

             ValorPOT=ADC_Get_Sample(0);                //Leer el valor del potenciometro de A0

                          if (ValorPOT<=85) {                                       //Pregunta el estado del boton

                                 LATA= 0b00000000;                              //Leds apagados

                          } else if (ValorPOT<=170) {                            //Pregunta el estado del boton

                                LATA= 0b00000010;                                //Enciende el LED del puerto A1

                           } else if (ValorPOT<=255) {                          //Pregunta el estado del boton

                                LATA= 0b00000110;                                 //Enciende el LED del puerto A2

                           }
                  }
}

 

Descargas

Software XIDE v1.0

Descarga el software XIDE v1.0 

Práctica 5-XCU-PIC10F322

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

PIC12F

Descripción

En esta práctica se implementa una lectura analógica, utilizando el potenciómetro incluido en el módulo I/O's ADC de Microside, el cual se conecta con los módulos X-TRAINER P8 con el PIC12F1572. El potenciómetro se conecta en el pin A0, el cual se configura como entrada y señal analógica. Para visualizar dicha lectura se utilizan 4 LEDs, conectados al puerto A, de tal manera que pueda observarse el incremento o decremento de voltaje del potenciómetro.

 

Materiales

1 x MóduloX-TRAINER P8. Comprar

1 x Módulo programador XCU. Comprar

1 x Microcontrolador PIC12F1572. Comprar

1 x Módulo I/O´s ADC. 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.

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 hacer una lectura de un puerto analogico y desplegar el valor en 4 leds

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

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

Para configurar el osilador interno:

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

2) Project>Edit Project>Oscillator>Seleccion bit>Seleccionar "INTOSC oscillator: I/O funtion on CLKIN pin "

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

 char Bool_Var= 0x00;

 unsigned int ValorPOT;

 void SisInit(void)                                                                                                       //Inicializa el PIC

   {
          OSCCON = 0X0F;                                                                                               // 32MHz
         TRISA = 0x09;                                                                                                     //Puerto A como salida // 00001001

            //Configurar entradas y salidas

           ANSA0_bit = 1;                                                                                                  //PIN como analógico
     }


 void main()
 {

         SisInit();

         ADC_Init();                                                                                                       //Voltaje de referencia a VDD

     while (1)

    {

                 ValorPOT=ADC_Get_Sample(0);                                                     //Leer el valor del potenciómetro de A0

        if (valorPot<=255) 

         {

                    LATA= 0b00000000;                                                                //Leds apagados

        }

        else if (ValorPOT<=510)                                                                          //Pregunta el estado del botón

         {           

            LATA= 0b00000010;

          }

          else if (ValorPOT<=765)                                                              //Pregunta el estado del botón

          { 
                        LATA= 0b00000110;
           }

           else if (ValorPOT<=920)                                                //Pregunta el estado del botón

        {
                      LATA= 0b00010110;
           }

          else if (ValorPOT<=1023)                                  //Pregunta el estado del botón

        {
                      LATA= 0b00110110;
           

}
       }
}

 


Descargas

Software XIDE v1.0

Descarga el software XIDE v1.0 

Práctica 5-PIC-XCU-12F1572

Descarga el código en mikroC PRO for PIC de la práctica 5.

PIC16F

Descripción

En esta práctica se implementa una lectura analógica, utilizando el potenciómetro incluido en el módulo I/O's ADC de Microside, el cual se conecta con los módulos X-TRAINER P8 con el PIC16F1827. El potenciómetro se conecta en el pin A0, el cual se configura como entrada y señal analógica. Para visualizar dicha lectura se utilizan 8 LEDs, conectados al puerto B, de tal manera que pueda observarse el incremento o decremento de voltaje del potenciómetro.


Materiales:

1 x Módulo X-TRAINER P8. Comprar

1 x Módulo Programador XCU. Comprar

1 x Microcontrolador PIC16F1827. Comprar

1 x Módulo I/O's ADC. 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.

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

*/

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

La practica consiste en hacer una lectura de un pin analogico y desplegar el valor en el puerto B.

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

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

l) Project> Edit Project>Oscillator Selection Bits>seleccionae "INTOSC oscillator: I/O function on CLKIN pin"

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

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

unsigned int ValorPOT;

void SisInit(void) {                                                                                              //Inicializa el PIC

                                                                                                                            //Configura el oscilador interno

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

                                                                                                                            //Configurar entradas y salidas

   TRISB = 0x00;                                                                                                //Puerto B como salida

   TRISA3_bit = 1;                                                                                               //PIN como entrada

   ANSA3_bit = 1;                                                                                                //PIN como analógico

}

void main()

{
     SisInit();
     

ADC_Init_Advanced(_ADC_INTERNAL_REF);                                              //Voltaje de referencia a VDD

     while (1)
     {

            ValorPOT=ADC_Get_Sample(3);                                                         //Leer el valor del potenciómetro

            if(ValorPOT <=114)                                                                                // el valor del potenciómetro es menor o igual

            {

                 LATB=0b00000000;

            }

            else if(ValorPOT <=228)                                                                       // el valor del potenciómetro es menor o igual

            {

                 LATB=0b00000001;

            }

            else if(ValorPOT <=342)                                                                       // el valor del potenciómetro es menor o igual

            {

                LATB=0b00000011;

            }

            else if(ValorPOT <=456)                                                                       // el valor del potenciómetro es menor o igual

           {

                LATB=0b00000111;

           }

           else if(ValorPOT <=570)                                                                       //el valor del potenciómetro es menor o igual

           {

                LATB=0b00001111;

            }

           else if(ValorPOT <=684)                                                                       // el valor del potenciómetro es menor o igual

            {

                LATB=0b00011111;

            }

           else if(ValorPOT <=798)                                                                        //el valor del potenciómetro es menor o igual

            {

                LATB=0b00111111;

            }

            else if(ValorPOT <=912)                                                                        // el valor del potenciómetro es menor o igual

            {

                LATB=0b01111111;

            }

            else if(ValorPOT <=1023)                                                                      // el valor del potenciómetro es menor o igual

            {

                LATB=0b11111111;

             }

      }

}

 

Descargas

Software XIDE v1.0

Descarga el software XIDE v1.0 

Práctica 5-PIC-XCU-16F

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

PIC18F

Descripción

En esta práctica se implementa una lectura analógica, utilizando el potenciómetro incluido en el módulo I/O's ADC de Microside, el cual se conecta con los módulos X-TRAINER P8 o X-TRAINER P8 DIP28, con el PIC18F25K22. El potenciómetro se conecta en el pin A3, el cual se configura como entrada y señal analógica. Para visualizar dicha lectura se utilizan 8 LEDs, conectados al puerto B, de tal manera que pueda observarse el incremento o decremento de voltaje del potenciómetro.

 

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 Módulo I/O's ADC. 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

*/

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

Implementar una lectura analógica de un potenciómetro y desplegar el valor

en 8 LEDs

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

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

Para usar el código con este PIC:

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

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

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

unsigned int ValorPOT;                                                                               //Se crea una variable global para la lectura analógica

void SisInit(void)                                                                                          //Se inicializa el PIC

{                                                                                                                        //Se configura el oscilador intern

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

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

         while (PLLRDY_bit==0);                                                                  //Se pregunta la frecuencia hasta que sea estable

                                                                                                                    //Se configuran las entradas y salidas del PIC

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

           TRISA3_bit = 1;                                                                                   //Se declara el pin A3 como entrada

          ANSA3_bit = 1;                                                                                    //Se declara el pin A3 como señal analógica
}

void main()                                                                                                     //Se instancia el main principal

{

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

          ADC_Init_Advanced(_ADC_INTERNAL_REF);                         //Se instancia la librería y el voltaje de referencia a VDD y GND

          while (1)                                                                                                  //Se crea un bucle donde se ejecuta el código

                         {

                            ValorPOT=ADC_Get_Sample(3);                                  //Se lee el valor del potenciómetro a tráves del pin A3

                            if(ValorPot <=114)                                                              //Compara el valor de el ADC con 114

                                                            {

                                                               LATB=0b00000000;                     // Leds activos

                                                            }

                            else if(ValorPot <=228)                                                    //Compara el valor de el ADC con 228

                                                            {

                                                                LATB=0b00000001;                     // Leds activos

                                                            }

                             else if(ValorPot <=342)                                                   //Compara el valor de el ADC con 342

                                                            {

                                                                LATB=0b00000011;                     // Leds activos

                                                            }

                             else if(ValorPot <=456)                                                   //Compara el valor de el ADC con 456

                                                            {

                                                                LATB=0b00000111;                      // Leds activos

                                                            }

                             else if(ValorPot <=570)                                                    //Compara el valor de el ADC con 570

                                                            {

                                                                LATB=0b00001111;                       // Leds activos

                                                            }

                             else if(ValorPot <=684)                                                   //Compara el valor de el ADC con 684

                                                            {

                                                                 LATB=0b00011111;                       // Leds activos

                                                            }

                             else if(ValorPot <=798)                                                   //Compara el valor de el ADC con 798

                                                            {

                                                                LATB=0b00111111;                        // Leds activos

                                                            }

                             else if(ValorPot <=912)                                                    //Compara el valor de el ADC con 912

                                                            {

                                                                 LATB=0b01111111;                        // Leds activos

                                                            }

                             else if(ValorPot <=1024)                                                 //Compara el valor de el ADC con 1024

                                                            {

                                                               LATB=0b11111111;                           // Leds activos

                                                            }

                        }

}

 

Descargas

Software XIDE v1.0

Descarga el software XIDE v1.0 

Práctica 5 – XCU – PIC18F25K22

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

MPLAB X IDE
Bootloader PIC18FX5K50
Programador PK3 LITE
Bootloader PIC18FX5K50

Descripción

En esta práctica se implementa una lectura analógica, utilizando el potenciómetro incluido en el módulo I/O's ADC de Microside, el cual se conecta con los módulos X-TRAINER P8 X-TRAINER P8 DIP40 o X-TRAINER P8 DIP28, con el PIC18F45K50 o el PIC18F25K50. El potenciómetro se conecta en el pin A3, el cual se configura como entrada y señal analógica. Para visualizar dicha lectura se utilizan 8 LEDs, conectados al puerto B, de tal manera que pueda observarse el incremento o decremento de voltaje del potenciómetro.

 

Materiales:

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

1 x Módulo I/O's ADC. 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

*/

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

Implementar una lectura analógica de un potenciómetro, si el valor del ADC supera

un Set Point, el LED encenderá.

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

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

Para configurar el Bootloader:

1) File>Project properties> XC8 Linker>Options categories>Memory models>ROM ranges> Esribir: 2000-7F00

2) File>Project properties> XC8 Linker>Options categories>Additional options>Codeoffset> Esribir: 2000

3) File>Project properties> Building>Marcar:Insert unprotected checksum in user ID memory

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

#include <xc.h>

#include <stdint.h>

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

#define LED_High() LATAbits.LA1 = 1;                     //DEFINE LA FUNCIÓN CUANDO EL LED ESTA ENCENDIDO

#define LED_Low() LATAbits.LA1 = 0;                      //DEFINE LA FUNCIÓN CUANDO EL LED ESTA APAGADO

#define POT_CH 0x03 ;                                          //DEFINE EL CANAL

uint16_t ValorPOT = 0;                                            //DECLARA UNA FUNCIÓN

void SisInit(void) {                                                   //INICIALIZA EL PIC

//CONFIGURA EL OSCILADOR INTERNO

OSCTUNE = 0x80;                                                 //3X PLL

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

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

while (OSCCON2bits.PLLRDY == 0);

ACTCON = 0x90;

//CONFIGURAR ENTRADAS Y SALIDAS

TRISAbits.TRISA3 = 1;                                            //PIN como entrada

ANSELAbits.ANSA3 = 1;                                         //PIN como analógico

TRISAbits.TRISA1 = 0;                                            //PIN como salida

ANSELAbits.ANSA1 = 0;                                          //PIN como digital

//CONFIGURA ADC

ADCON0 = 0x01;                                                     // GO_nDONE stop; ADC habilitado;

ADCON1 = 0x00;                                                     // TRIGSEL CCP2; NVCFG VSS; PVCFG VDD;

ADCON2 = 0x0E;                                                    // ADFM derecha; ACQT 2; ADCS FOSC/64;

}

 

uint16_t ADC_Muestra(char canal) {                          //Lectura del canal ADC

ADCON0bits.CHS = canal;                                      //delecciona el canal

ADCON0bits.ADON = 1;                                         //Habilita ADC

ADCON0bits.GO_nDONE = 1;                                 //Inicia conversión

while (ADCON0bits.GO_nDONE);

return ((uint16_t) (ADRESH << 2) + (ADRESL>>6));

}

 

void main(void) {

    SisInit();                                                                  //INICIALIZA EL PIC

    while (1) {

          __delay_ms(50);

          ValorPOT = ADC_Muestra(POT_CH);

          if (ValorPOT <= 512) {

          LED_Low(); //EL LED ENCIENDE

            } else {
                   LED_High(); //EL LED SE APAGA

           }

     }

}

 


Descargas

Software XIDE v1.0

Descarga el software XIDE v1.0 

Práctica 5-PIC-BOOTLOADER/MPLAB

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

Programador PK3 LITE

Descripción

En esta práctica se implementa una lectura analógica, utilizando el potenciómetro incluido en el módulo I/O's ADC de Microside, el cual se conecta con los módulos X-TRAINER P8 X-TRAINER P8 DIP40, con el PIC18F47K42. El potenciómetro se conecta en el pin A3, el cual se configura como entrada y señal analógica. Para visualizar dicha lectura se utilizan 8 LEDs, conectados al puerto B, de tal manera que pueda observarse el incremento o decremento de voltaje del potenciómetro.

 

Materiales:

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

1 x Módulo Programador PK3 LITE. Comprar

1 x Microcontrolador PIC18F47K42. Comprar

1 x Módulo I/O's ADC. 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

 

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

*/

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

Implementar una lectura analógica de un potenciómetro y desplegar el valor en 8 LEDs

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


                                                                                       //Fusibles

#pragma config FEXTOSC = OFF                                    //Oscilador externo deshailitado

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

#pragma config CLKOUTEN = OFF                               //Función CLOKOUTEN deshabilitada

#pragma config WDTE = OFF                                           //Deshabilitada WDT

 

#include <xc.h>

#include <stdint.h>

#define _XTAL_FREQ 64000000                                    //Define frecuencia de 64MHz

#define POT_CH 0x03                                                        //Define canal

uint16_t ValorPOT = 0;                                                      //Declara función

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;


  TRISB = 0x00;                                                                   //Puerto B como salida

  TRISAbits.TRISA3 = 1;                                                   //PIN como entrada

  ANSELAbits.ANSELA3 = 1;                                         //PIN como analógico


                                                                                //Configura ADC
  ADCAP = 0x00;

  ADCON1 = 0x00;

  ADCON2 = 0x00;

  ADCON3 = 0x00;

  ADSTAT = 0X00;

  ADREF = 0X00;

  ADACT = 0X00;

  ADCLK = 0X3F;

  ADCON0 = 0x84;

}

uint16_t ADC_Muestra(char canal) {                            //Lectura del canal ADC
   ADPCH = canal;
   ADCON0bits.ADON = 1;                                               //Habilita ADC|
   ADCON0bits.ADCONT = 0;
   ADCON0bits.ADGO = 1;                                               //Inicia conversión
   while (ADCON0bits.ADGO);
   return ((uint16_t) (ADRESH << 8) + ADRESL);
}

  void main(void) {
                    SisInit();                                                           //INICIALIZA EL PIC
                    LATB = 0X00;                                              //VALOR INICIAL
while (1) {                                                               
              __delay_ms(50);
              ValorPOT = ADC_Muestra(POT_CH);
              if (ValorPOT <= 455){
                  PORTB=0B00000000;
              } else if (ValorPOT <= 910){
                  PORTB=0B00000001;
              } else if (ValorPOT <= 1365){
                   PORTB=0B00000011;
              } else if (ValorPOT <= 1820){
                   PORTB=0B00000111;
              } else if (ValorPOT <= 2275){
                    PORTB=0B00001111;
              } else if (ValorPOT <= 2730){
                    PORTB=0B00011111;
              } else if (ValorPOT <= 3185){
                    PORTB=0B00111111;
              } else if (ValorPOT <= 3640){
                    PORTB=0B01111111;
             } else if (ValorPOT <= 4095){
                    PORTB=0B11111111;
           }
      }
}

 


Descargas

Práctica 5 – PIC – PK3

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

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

Descripción

En esta práctica se implementa una lectura analógica, utilizando el potenciómetro incluido en el módulo I/O's ADC de Microside, el cual se conecta con los módulos X-UNO o X-NANO. El potenciómetro se conecta en el pin C0, el cual se configura como entrada y señal analógica. Para visualizar dicha lectura se utilizan 8 LEDs, conectados al puerto D, de tal manera que pueda observarse el incremento o decremento de voltaje del potenciómetro.

 

Materiales:

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

1 x Módulo programador XCU. Comprar

1 x Módulo X-AVR. Comprar

1 x Módulo I/O's ADC. 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.

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

*/

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

Implementar una lectura analógica de un potenciómetro

y desplegar el valor en 8 LEDs

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

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

Registros de configuración:

Project>Edit Project

        CKDIV8 = NO SPIEN = SI

       CKOUT = NO WDTON = NO

        RSTDISBL = NO EESAVE = SI

        DWEN = NO BOOTRST = NO

        Brown - out detection level al VCC = 2.7 V

        Boot Flash section size = 256 words...

        Start - up time PWRDWN / RESET: 16K CK / 14 CK + 65 ms

        Ext. Crystal Osc., Frequency > 8.0MHz, Show startup

        Insertar 16.000000 en "MCU Clock Frequency [MHz]" box

        En "Program Memory is used for": Application (Boot Flash Section is reserved)

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

unsigned int ValorPOT;

void SisInit(void)

{                                                                       

                DDRD = 0XFF;                                                //Puerto D como salida
}

void main()

{
            SisInit () 

           ADC_Init_Advanced (_ADC_INTERNAL_REF);       //Voltaje de referencia a VDD

            while (1)

           {

                 ValorPOT = ADC_Get_Sample (0);                   //Leer el valor del potenciometro

                  if (ValorPot <= 114)                                         //Compara el valor de el ADC con 114

                  {

                           PORTD = 0b00000000;                        // Leds activos

                   }

                    else if (ValorPot <= 228)                               //Compara el valor de el ADC con 228

                   {

                            PORTD = 0b00000001;                       // LEDs activos

                    }

                    else if (ValorPot <= 342)                              //Compara el valor de el ADC con 342

                   {

                               PORTD = 0b00000011;                     // LEDs activos

                   }

                   else if (ValorPot <= 456)                                //Compara el valor de el ADC con 456

                   {

                                 PORTD = 0b00000111;                     // LEDs activos

                     }

                     else if (ValorPot <= 570)                              //Compara el valor de el ADC con 570

                     {

                                  PORTD = 0b00001111;                 // LEDs activos

                     }

                      else if (ValorPot <= 684)                            //Compara el valor de el ADC con 684

                       {

                                  PORTD = 0b00011111;                  // LEDs activos

                      }

                       else if (ValorPot <= 798)                        //Compara el valor de el ADC con 798

                      {

                                   PORTD = 0b00111111;             // LEDs activos

                       }

                       else if (ValorPot <= 912)                       //Compara el valor de el ADC con 912

                       {

                                      PORTD = 0b011111111;          // LEDs activos

                         }

                         else if (ValorPot <= 1024)                   //Compara el valor de el ADC con 1024

                        {

                                       PORTD = 0b11111111;           // LEDs activos

                        }

          }

}

 

Descargas

Software XIDE v1.0

Descarga el software XIDE v1.0 

Práctica 5- XCU-AVR

Desacrgar el código en mikroC PRO for AVR de la práctica 5.

 

Atmel Studio 7
Programador MKII LITE
Programador MKII LITE

Descripción

En esta práctica se implementa una lectura analógica, utilizando el potenciómetro incluido en el módulo I/O's ADC de Microside, el cual se conecta con los módulos X-UNO o X-NANO. El potenciómetro se conecta en el pin C0, el cual se configura como entrada y señal analógica. Para visualizar dicha lectura se utilizan 8 LEDs, conectados al puerto D, de tal manera que pueda observarse el incremento o decremento de voltaje del potenciómetro.

 

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 Módulo I/O's ADC. 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.

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 practica consiste en hacer una lectura de un puerto analogico y desplegar el valor en 8 LEDs

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

#include <stdio.h>

#include <avr/io.h> 

#define F_CPU 16000000

#include <util/delay.h> 

int ValorPOT;

void SistIni()

{

     ADMUX| = (1<<REFS0);                                                                                       // Selecciona Vref

    ADCSRA| = (1<<ADPS2)| (1<<ADPS1)| (1<<ADPS0)| (1<<ADEN);       //Habilita ADC.

     DDRD = 0xFF;                                                                                                       //Inicializa el puerto D como salida.

}

uint16_t ReadADC(uint8_t ADCchannel)

{

     ADMUX = (ADMUX&0xF0)| (ADCchannel&0x0F);                                      //Selecciona el canal del ADC.

     ADCSRA| = (1<<ADSC);                                                                                // Modo de coversión unica.

     while (ADCSRA& (1<<ADSC));                                                                        //Espera hasta que se complete la conversion de ADC.

     return ADC;

}

int main()

{

     SistIni ();                                                                                                          //Inicializa ADC

      while (1)

    {

      ValorPOT = ReadADC (0);                                                                         //Lectura del valor del potenciometro.

       if (ValorPOT <= 114)                                                                                 // Comparacion del valor ADC con el Set Poin

        {

               PORTD = 0b00000000;

         }

         else if (ValorPOT <= 228)                                                                          // Comparacion del valor ADC con el Set Poin

         {

              PORTD = 0b00000001;

         }

         else if (ValorPOT <= 342)                                                                         // Comparacion del valor ADC con el Set Poin

         {

             PORTD = 0b00000011;

         }

         else if (ValorPOT <= 456)                                                                         // Comparacion del valor ADC con el Set Poin

         {

             PORTD = 0b00000111;

         }

         else if (ValorPOT <= 570)                                                                         // Comparacion del valor ADC con el Set Poin

         {

             PORTD = 0b00001111;

         }

         else if (ValorPOT <= 684)                                                                         // Comparacion del valor ADC con el Set Poin

         {

              PORTD = 0b00011111;

         }

         else if (ValorPOT <= 798)                                                                         // Comparacion del valor ADC con el Set Poin

         {

            PORTD = 0b00111111;

         }

         else if (ValorPOT <= 912)                                                                         // Comparacion del valor ADC con el Set Poin

         {

             PORTD = 0b01111111;

         }

         else if (ValorPOT <= 1023)                                                                       // Comparacion del valor ADC con el Set Poin

         {

             PORTD = 0b11111111;

         }

     }

}

 

 

 

Descargas

Prácatica 5-AVR-MKII

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

ARDUINO

Descripción

En esta práctica se implementa una lectura analógica, utilizando el potenciómetro incluido en el módulo I/O's ADC de Microside, el cual se conecta con los módulos X-UNO o X-MEGA o X-NANO. El potenciómetro se conecta en el pin A0, el cual se configura como entrada y señal analógica. Para visualizar dicha lectura se utilizan 8 LEDs,  de tal manera que pueda observarse el incremento o decremento de voltaje del potenciómetro.

 

Materiales:

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

1 x Módulo Programador XCU. Comprar

1 x Módulo I/O's ADC. 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.

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

*/

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

Implementar una lectura analógica de un potenciómetro y desplegar el valor en 8 LEDs.

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

int POT = A0;                                                                                     // Entrada para el potenciómetro

int ValorPOT = 0;                                                                              // Variable donde se guardará el valor del potenciómetro

void setup()

{

DDRD = B11111111;                                                                           //Configura puerto D como salida

}

void loop()

{

              ValorPOT = analogRead (POT);                                    //Leer el valor del potenciómetro

        if (ValorPOT <= 114)                                                            //Compara el valor del potenciómetro

        {

                   PORTD = 0b00000000;

         }

         else if (ValorPOT <= 228)                                                 //Compara el valor del potenciómetro

         {

                    PORTD = 0b00000001;

          }

          else if (ValorPOT <= 342)                                                 // Compara el valor del potenciómetro

          {

                      PORTD = 0b00000011;

           }

          else if (ValorPOT <= 456)                                                 // Compara el valor del potenciómetro

           {

                      PORTD = 0b00000111;

           }

           else if (ValorPOT <= 570)                                                 // Compara el valor del potenciómetro

           {

                      PORTD = 0b00001111;

           }

           else if (ValorPOT <= 684)                                                 // Compara el valor del potenciómetro

           {

                      PORTD = 0b00011111;

           }

          else if (ValorPOT <= 798)                                                 // Compara el valor del potenciómetro

         {

                     PORTD = 0b00111111;

         }

          else if (ValorPOT <= 912)                                                 // Compara el valor del potenciómetro

           {

                     PORTD = 0b01111111;

            }

          else if (ValorPOT <= 1023)                                                 // Compara el valor del potenciómetro

          {

                    PORTD = 0b11111111;

           }

}

 

Descargas

 

Práctica 5 – Arduino

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

 

 

Fecha

julio 13, 2019

Categoría

Prácticas XIDE

× WhatsApp