Programacion en Lenguaje C Orientado a Sistemas Embedidos

 Hola a todos, Le muestro el nuevo curso que esta disponible en Udemy.

Link del Curso_Lenguaje_C

Link del Curso_Lenguaje_C

Unity 3D with Arduino Uno

Buenas tardes compañeros.

En esta ocasion vamos a mover un  cubo que esta en Unity 3D por medio del Arduino Uno.

Procedimiento:

1.-Hacemos el programa del Arduino Uno,que consiste en leer el estado de un pulso externo(Button).

y enviarlo por medio de la comunicacion serial RS232 a la PC.

codigo del Arduino:

/***************************************************************/
const int buttonPin = 2;     // the number of the pushbutton pin
const int ledPin =  13;      // the number of the LED pin

// variables will change:
int buttonState = 0;         // variable for reading the pushbutton status

void setup() {
  Serial.begin(9600);

  // initialize the LED pin as an output:
  pinMode(ledPin, OUTPUT);
  // initialize the pushbutton pin as an input:
  pinMode(buttonPin, INPUT);
}

void loop() {
  // read the state of the pushbutton value:
  buttonState = digitalRead(buttonPin);

  // check if the pushbutton is pressed. If it is, the buttonState is HIGH:
  if (buttonState == HIGH) {
    // turn LED on:
    digitalWrite(ledPin, HIGH);
    Serial.println(buttonState);//Send '1'
  } else {
    // turn LED off:
    digitalWrite(ledPin, LOW);
    Serial.println(buttonState);//Send '0'
  }
  delay(150);
}
/**********************************************************/
Link-->Download_Arduino_Button
/**********************************************************/

2.-Creamos el cubo en Unity 3D y activamos su comunicacion RS232 para poder leer los datos que son enviados desde el Arduino. Seleccionamos el COMx correspodiente al Arduino Uno.

Luego le damos al boton Start y nos saldra el mensaje de comenzar.

Programa del Unity 3D.

/**********************************************************/
link-->Download_Cubo_Arduino
/**********************************************************/

3.-Con cada pulso('1') que le realizamos al arduino(Button) el cubo se eleva.

OHMETRO_DSPIC33FJ

Óhmetro

La resistencia eléctrica es parte fundamental en la creación de circuitos, todas las resistencias pueden ser medidas y para esto se emplea un óhmetro o también conocido como ohmímetro.

¿Como funciona un Óhmetro?

Este dispositivo de medición emplea una batería en su interior con la cual se induce un voltaje a través de la resistencia que se desea medir, este proceso se hace para que posteriormente el galvanometro pueda medir la corriente que circula a través de la resistencia.

Despues de realizar el proceso anterior el Óhmetro puede calcular rápidamente la resistencia utilizando la ley de ohm, para ser más precisos se utiliza esta formula:

En donde:

• R = Resistencia
• V = Voltaje
• I = Corriente

Recordemos que el Óhmetro posee una batería interna cuyo valor esta definido, con esto ya tenemos uno de los valores (V), posteriormente al inducir el voltaje sobre la resistencia a medir el instrumento calcula la corriente (I), al ya tener estos 2 valores el instrumento aplica la formula mostrada arriba y con esta puede determinar de que valor es la resistencia que se esta midiendo.

Para medir resistencia con el PIC utilizaremos la fórmula de un divisor de voltaje. 

como observamos en la figura tenemos dos resistencias R1 y R2,entonces fijamos un valor de resistencia en este caso R2,le damos un valor fijo de 1K.luego tenemos q reemplazar y despejar.

Vin=5V;

R2=1Kohm;

Vout=5*(1K/(R1+1K));

Vout*(R1+1K)=5K;

R1=(5K/Vout) - 1K;

R1=((5/Vout)-1)Kohm;-------------------------------(1)

La tensión Vout se leerá con el ADC del dsPIC, si lo configuramos a 10 bits se debe utilizar la formula, 

Radc=5Vout/1024;--------------------------------(2)

donde Radc es el valor del buffer ADC1BUF0 del ADC del dspic.

Reemplazando (2) en (1): R1=((1024/Radc)-1)Kohm;--------------(3)

la formula (3) lo utilizaremos para calcular el valor de nuestra resistencia R1,lo cual llevado al codigo del dspic quedara asi:

    while (1) {

        _LATA8 = ~_LATA8;

        AD1CON1bits.SAMP = 1; // Start sampling

        delay_us(10); // Wait for sampling time (10us)

        AD1CON1bits.SAMP = 0; // Start the conversion

        while (!AD1CON1bits.DONE); // Wait for the conversion to complete

        Radc = ADC1BUF0;

        Ohm = (float)1024/Radc -1;

        printf("Valor Resistor: %.3f Kohm\r",(double)Ohm);

        delay_ms(75);

    }

Download_Ohmeter

SENSOR DE DISTANCIA GP2D12_DSPIC33FJ

Los sensores de distancia permiten medir una longitud desde el punto de ubicación del sensor hasta un obstáculo puesto en un punto dentro del rango de trabajo del sensor. La implementación de este tipo de dispositivos es de utilidad en sistemas de control, y en proyectos de robótica. Para el caso puntual de este capítulo se trabajará con el sensor GP2D12, este dispositivo usa como estrategia de medida un rayo de luz infrarroja y su reflejo para determinar la longitud.La apariencia física la distribución de pines y la vista en el simulador ISIS del sensor son los siguientes: 

Este tipo de sensores cuentan con un comportamiento no lineal, esto quiere decir que la salida no obedece a una función de transferencia lineal. Para comprender de forma clara este concepto se puede observar y analizar la siguiente gráfica que muestra el comportamiento de la salida en función de la distancia:

Este comportamiento en un sensor es de difícil aplicación, dado que en algunos casos los fabricantes no entregan una función de transferencia útil de tal forma que pueda ser usada en una sola ecuación. Sin embargo no es un obstáculo para el uso del sensor. Como se puede apreciar en la hoja técnica el rango de acción es de 10 a 80 centímetros tal como se puede apreciar en la gráfica. La gráfica mostrada está contenida en la hoja técnica del dispositivo y está es realizada experimentalmente. Para poder caracterizar el comportamiento del sensor y realizar una función de transferencia es indispensable realizar un proceso matemático conocido como linealización. Para este fin se hace una interpolación con una cantidad finita de puntos conocidos de la función, estos puntos se toman de las medidas experimentales. Cuantos más puntos se evalúen más precisa será la función de transferencia. Para iniciar este proceso se escogen 2 puntos, que estén equitativamente distribuidos. Por ejemplo el punto a 10cm, y 80cm. Para cada uno de los puntos se realiza una ecuación de orden igual al número de puntos menos uno, en este caso serán ecuaciones de primer orden. Se asume como variable independiente x los datos de entrada que en este caso son el voltaje de salida del sensor, como variable dependiente y, la distancia en centímetros. Para comprender este concepto observe la siguiente ecuación que representa el comportamiento exponencial del sensor:

y=A/x+B ; ecuacion12.11

Recordando que y, representa la distancia y que x, el voltaje de salida del sensor, se usan los datos de dos puntos y se remplazan en las ecuaciones de la siguiente forma:

                                        Tabla 12-3

Sistema de ecuaciones:

10=A/2.35 +B ;

80=A/0.41+B;

Sistema de ecuaciones con dos incógnitas.

Solucionando el sistema de ecuaciones se puede determinar que las constantes son:

A=34,76546392

B=-4,793814433

De está forma se puede formalizar la función de transferencia del sensor con la ecuación:

y=34,76546392/x  + 4,793814433; Ecuación 12-14

Como la variable x representa el voltaje de salida del sensor y teniendo presente que el valor del sensor no supera 2,5 voltios, la referencia del convertidor AD, se puede ajustar a 2,5 voltios. Para estáblecer la conversión se puede usar la ecuación: (12.15)

Vadc =2,5Radc/1023  ;  Ecuación 12-15

Remplazando la ecuación (12.15) en la ecuación (12.14), obtenemos la siguiente relación o función de transferencia:

y=14226,02784/Radc - 4,793814433 ; Ecuación 12-16

El paso siguiente es implementar un código fuente que use la función de transferencia y que posteriormente visualice el valor capturado.

Nota:Texto copiado del libro: Diseño y simulación de sistemas microcontrolados en lenguaje C -Capitulo:12.3 Sensores de distancia- Pagina 134 

Download

FACEBOOK:https://www.facebook.com/MasterProgramadorDsPic/

TIMER 32-DSPIC33FJ

Los estupendos microcontroladores dsPIC33F nos vuelven a sorprender con su módulo Timer, que incorpora hasta 9 Timer que pueden funcionar a 16 o 32 bits.

La serie de micros dsPIC33F dispone de 9 timers de 16 bits, de los cuales el Timer1 trabaja de manera individual, y el resto puede trabajar de forma individual o en parejas como Timer de 32 bits.

Timer1

El esquema del módulo Timer1 es el siguiente:

Como se puede observar en el gráfico, las características del Timer1 son:

• Timer de 16 bits
• Contador síncrono de 16 bits
• Contador asíncrono de 16 bits
• Acumulador de pulsos altos en TGate
• Prescaler seleccionable en ratios 1:1, 1:8, 1:64 y 1:256
• Ajuste fácil del Periodo con PR1

Además, nuestro Timer1 puede seguir funcionando incluso en el modo Idle o Sleep de la CPU.

El Timer1 puede acumular pulsos tanto externos (TCS=1) a través del pin T1CK como internos (TCS=0) al ritmo de la Frecuencia de instrucciones (Tcy). Además, en el modo de trabajo de acumulación de pulsos altos en TGate puede contar los pulsos internos (Tcy) sólo cuando el pin externo T1CK esté a nivel alto lo que permite contar la duración acumulada de una señal a nivel alto. Para seleccionar este modo hay que poner a 1 los bits TCS y TGATE.

El interruptor que nos permite encender y apagar el Timer1 es el bit TON.

A continuación nuestro tren de impulsos atraviesa el prescaler donde es dividido a razón de 1:1, 1:8, 1:64 y 1:256 en función de la combinación seleccionada en los bits TCKPS<1:0>.

A continuación se incrementa en una unidad el registro TMR1. En función del bit de configuración TSYNC, si su valor es 1 el incremento de dicho registro será sincronizado con una señal externa. Cada vez que se incrementa el registro TMR1, se compara con el registro PR1 y en caso de igualdad se pone a 0 el TMR1 y se señala el bit de interrupción T1IF. El registro PR1por defecto vale 0xFFFF con lo que el periodo del Timer1 será ese, pero podemos ajustarlo al valor que queramos, lo que nos permite seleccionar una frecuencia de interrupción programable muy útil.

Timer2/3, Timer 4/5, Timer 6/7 y Timer 8/9

Estos 8 timers pueden funcionar individualmente como timers de 16 bits o en parejas como timers de 32 bits. Su esquema es el siguiente:

Básicamente el funcionamiento de estos Timers a 16 bits es análogo al del Timer1, con excepciones que veremos más adelante0. Para hacerlos trabajar a 32 bits hay que poner a 1 el bit T32. En este caso, los bits de configuración del Timer de 32 bits serán los del Timer par; es decir, si queremos trabajar con la pareja Timer 4/5 hay que setear los bits del Timer4, incluyendo el bit T32=1.

Sin embargo, el bit de señalización de fin de periodo será el del Timer impar, en nuestro ejemplo se activará el bit T5IF.

En el modo de trabajo a 32 bits, la palabra alta la forma el registro TMR impar y la palabra baja el TMR par.

Las excepciones son las siguientes:

• Sólo el Timer 2/3 puede servir como base de tiempos al módulo CCP (Capture and Output Compare)
• Sólo el Timer 2/3 puede activar una transferencia de datos al módulo DMA
• Sólo los Timer 2/3 y Timer 4/5 pueden activar el Trigger del ADC (1 y 2 respectivamente)

Registros

Los registros que utilizaremos para gestionar los Timer son los siguientes:

• TMRx
• PRx
• TxCON
  • TON: enciende (1) o apaga (0) el timer
  • TSIDL: el Timer puede seguir trabajando (1) en modo Idle o Sleep o puede quedar parado (0).
  • TGATE: selecciona el modo de acumulación de pulso a nivel alto (1)
  • TKCPS: Prescaler, según los ratios 1:1 (00), 1:8 (01), 1:64 (10) o 1:256 (11).
  • TSYNC: Sincroniza entrada de clock externa (1)
  • TCS: Selecciona una fuente de clock externa (1) o la frecuencia interna de instrucciones (0).
  • T32 (sólo en Timer2/4/6/8): activa el modo de 32 bits (1)
• IFS0
  • T1IF / T2IF / T3IF: se activan al finalizar el periodo del Timer.
• IFS1
  • T4IF / T5IF: idem
• IFS2
  • T6IF: idem
• IFS3
• T7IF / T8IF / T9IF: idem

Texto copiado de la pagina micropic. 

-->http://www.micropic.es/mpblog/2007/02/dspic33f-capitulo-2-el-timer/

Example Code Timer32-DsPIC33FJ

Freq -->Es la frecuencia de trabajo de su dspic en mi caso es de 40MIPS.


Configuracion de registros.


void config_TIMER32(void) {
    float time = 1000; //en milisegundos
    T3CONbits.TON = 0; //Stop any 16-bit Timer3 operation
    T2CONbits.TON = 0; //Stop any 16/32-bit Timer3 operation
    T2CONbits.T32 = 1; //Enable 32-bit Timer mode
    T2CONbits.TCS = 0; //Select internal instruction cycle clock
    T2CONbits.TGATE = 0; //Disable Gated Timer mode
    T2CONbits.TCKPS = 0b10; //Select 1:1 Prescaler Precontador (0 = 01:01, 1 = 01:08, 2 = 1:64, 3 = 1:256)
    long Time_Setup = (Freq / 64) * time;//Configuramos el tiempo deacuerdo al prescale.
    TMR3 = 0x00; //Clear 32-bit Timer (msw)
    TMR2 = 0x00; //Clear 32-bit Timer (lsw)
    PR3 = (Time_Setup / 1000) >> 16; //Load 32-bit period value (msw)
    PR2 = (Time_Setup / 1000) & 0xffff; //Load 32-bit period value (lsw)
    _T3IP = 0x01; //Set Timer Interrupt Priority Level - 7(highest) to 1(lowest)
    _T3IF = 0; //Clear Timer Interrupt Flag
    _T3IE = 1; //Enable Timer interrupt
    T2CONbits.TON = 1; //Start 32-bit Timer

}

Interrupcion del timer32.

void __attribute__((interrupt, auto_psv)) _T3Interrupt(void) {
    _LATA0 = ~_LATA0;
    _T3IF = 0; //Clear interrupt flag
}

Download

Sensor de presión MPX4115_DsPIC33FJ

Para los fines prácticos de este capítulo se trabajará con el sensor de presión MPX4115, este sensor está caracterizado en Kilo Pascal, y permite medir presiones entre 15 y 115 KPa, o entre 2,18 y 16,7 psi. La apariencia física, la distribución de pines y la vista en ISIS, de este dispositivo es la siguiente:

MPX4115 la función de transferencia especificada por el fabricante es: Vout =Vs(0.009P- 0.095)
donde:Vout :es la señal de salida del sensor.
P :es la presion
Vs: es el voltaje de alimentacion en este caso es de 5V.

Para calcular la presion debemos de despejar P.

nos queda : P=(111.111111Vout/Vs) +10.555555

El ADC de nuestro microcontrolador esta configurado con 10 bits de resolución se puede concluir que: 

 Vout=5Radc/1024

Donde Radc es el el Buffer del ADC(ADC1BUF0).

Luego reemplazamos en P nos queda: 

  P=0.542535Radc/Vs +10.555555

pero Vs=5V

finalmente nos queda: P=0.108507Radc+10.555555

con esta ecuacion podemos hallar la presion en KiloPascal(KPa).

link -->Download_MPX4115

INTERPRETADOR DE CODIGO G

CODIGO G  .TXT CREADO POR EL PROGRAMA ARCAM

LUEGO LE DAMOS CLICK EN BOTON EXAMINAR Y BUSCAMOS EL ARCHIVO.

Y ESO ES TODO.

INTERPRETADOR DE CODIGO G A PASOS Y ENVIO DE DATOS POR COMUNICACION SERIAL

Obtenemos los datos de codigo G del programa ARCAM .

para poder controlar una CNC necesitamos extraer datos de X,Y,Z y F y enviarselos a un controlador como puede ser: PIC,DSPIC,AVR ARDUINO ETC mediante la comunicacion serial.

para ello hemos desarrollado una interfaz en C# que realize ese trabajo.

modo de uso:
En primer lugar buscamos el COM disponible para enviar datos,
luego le damos click  en el boton  examinar para cargar el codigo G en .txt,
despues se vera lleno los listbox con datos y tambien estara completado el dataGrid con todo la informacion del codigo G.
para finalizar le damos click en el boton send step para enviar los datos de pasos interpretados a un controlador.

PROYECTOS CON DSPIC

Programa:  MplabX
Compilador:  XC16

Simulador:  Proteus

CONTROL DE TEMPERATURA DE UNA CALDERA-CONTROL PID

TARJETA ENTRENADORA DE DSPIC-DSPIC33FJ32MC204

Uso de módulos a aprender: I/O,Timer,I2C,SPI,UART,QEI,PWM,INT,ADC,CCP.

SEMÁFORO MULTIPLEXADO CONTROLADO POR UN DSPIC

EXPANSOR PCF8574 CONTROLANDO LCD 16*2 POR MEDIO DE UN DSPIC.

El PCF8574 es un expansor de E/S compatible con la mayoría de microcontroladores, permite una comunicación bidireccional, necesitando para ello solo dos líneas a través del bus I2C.

MEDIDOR DE DISTANCIA CON SENSOR ULTRASONIDO                                 POR MEDIO DE UN DSPIC.

TECLADO MATRICIAL 4X4 UTILIZANDO UN PIN DEL                   DSPIC Y VISUALIZADO EN UN DISPLAY

CONTROL DE UN RTC DS1307 POR MEDIO DE UN DSPIC

LECTURA Y ESCRITURA DE DATOS EN UNA MEMORIA EEPROM

ENVIO DE DATOS POR MEDIO DE BLUETOOTH HC-06 Y DSPIC.

LECTURA DE DATOS DEL GPS MEDIANTE DSPIC

TARJETA ENTRENADORA DE DSPIC-KILLMU 1.

Se usa el modelo dspic33fj32mc204,este dspic se puede encontrar en proteus y simularlo,ademas cuenta con pines remapeables,tiene incorporada un DSP.

killmu 1 cuenta con todas las salidas de pines del dspic,con una alimenttacion de 5v con cable micro usb,con varias salidas de 5v y 3.3v.Tiene pines de ICSP para poder grabarlo con pickit3.

PROGRAMACIÓN DE DsPIC

Saludos a todos los que están leyendo mi blog,en esta oportunidad compartiré con uds un tema fundamental,lo que es programación en microcontroladores de gama alta como son los de 16 bits.

vamos a trabajar con el modelo dspic33fj32mc204 ¿por que?

por que es el único modelo que se puede simular en proteus ,por esa razón lo estoy utilizando.

*En primer lugar vamos a leer un poco de teoría.

¿Qué es un dsPIC?

Los Un dsPIC es un [pequeño DSP + un PIC-MCU], entendiendo que su arquitectura es basada en la de un PIC®MCUs y que integra a la perfección las funciones del microcontrolador y las funciones DSP con un único conjunto de instrucciones y archivo de registros.

 "Cuenta con  (desde 30)  MIPS  que ofrece el rendimiento de un DSP con la simplicidad de un MCU"

Los Controladores Digitales de Señales (DSCs) de Microchip se comercializan en más de medio centenar de modelos diferentes de las familias dsPIC30F y dsPIC33F y consisten en la combinación de los microcontroladores de 16 bits con los recursos necesarios para soportar las funciones clásicas de los DSP.

dato: Los dsPIC nacen después de que los DSP hayan sido desarrollados durante años por otras empresas aprovechando la experiencia acumulada por otros fabricantes.

*En segundo lugar vamos a empezar con la estructura de programación que se utiliza. 

Toda  programación se va hacer en el IDE oficial  de Microchip  que esMPLABX3.0 y el compilar XC16(para microntroladores de 16 bits) http://www.microchip.com/mplab/mplab-x-ide , una vez abierto la pagina  darle click en la pestaña download (para descargar el mplabx3.0) y download archive(para descargar el compilador xc16),una vez descargado e instalado estamos listos para empezar a codear.

              Estructura de un programa para DsPic

/*

 * File:   main_PLed.c

 * Author: jhon ore

 * Created on 30 de junio de 2016, 16:56

 */

(*).....

#pragma config PWMPIN = ON               

#pragma config HPOL = ON      

#pragma config LPOL = ON               

#pragma config ALTI2C = OFF

#pragma config FPWRT = PWR128   

int main(void) {

   (**).....

    while (1) {

    (***).....

    }

    return 0;

}

Notas:
1.-Configuración de fuses.
(*).-Antes del programa principal,es fundamental saber configurar estos fuses para poder garantizar el buen funcionamiento del  dspic.

2.-Aquí solamente va a ocurrir una sola vez.
(**).-Aquí va todo las configuraciones y llamados de funciones configuración de I/O,módulos del dspic (UART,ADc,QEI,TIMER,INT etc.) llamado de funciones creados por nuestros propios medios para que se nos facilite la programación.

3.-Aquí va a ocurrir todo el tiempo.
(***).-Aquí va todo lo que siempre se va a querer repetir,por ejemplo un prende led o eventos que quieren que ocurran repetidamente.

Siempre se va a empezar con un comentario que es opcional-->luego se configura los fuses del dspic a usar-->luego se empieza con un funciónmain,ahí dentro se ejecutara todo el programa,después de pasar por el while,la función retorna a cero.

.-la plantilla anterior siempre se usa en los programa de microcontroladores de microchip.

*En tercer lugar empezaremos con los ejemplos.

          Ejemplos de programación en DsPic.

E-1:Prende led.

1.1.-Meta: hacer parpadear cada 500 ms.

1.2.-Herramientas:

      1.2.1.-Software:

               -Proteus.

               -MplabX

      1.2.2.-Hardware:

               -Resistencia 220 ohm.

               -Dspic33fj32mc204.

               -Led green.

1.3.-Resultado:

       código:

//1.-

/*******librerias******************/

#include "xc.h"

#include <libpic30.h>

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <math.h>

//2.-

/********Configuration Fuses************ */

//FPOR

#pragma config PWMPIN = ON               

#pragma config HPOL = ON      

#pragma config LPOL = ON               

#pragma config ALTI2C = OFF

#pragma config FPWRT = PWR128               

// FWDT

#pragma config WDTPOST = PS32768        // Watchdog Timer Postscaler bits (1:32,768)

#pragma config WDTPRE = PR128              // Watchdog Timer Prescaler bit (1:128)

#pragma config WINDIS = OFF                    // Watchdog Timer Window Enable bit 

#pragma config FWDTEN = OFF                 // Watchdog Timer Enable bit

// FOSC

#pragma config POSCMD = HS              // Primary Oscillator Mode Select bits (HS )

#pragma config OSCIOFNC = OFF        // OSC2 Pin Function bit (OSC2 is clock output)

#pragma config IOL1WAY = ON            // Peripheral pin select configuration 

#pragma config FCKSM = CSDCMD     // Clock Switching Mode bits

// FOSCSEL

#pragma config FNOSC = PRIPLL           // Oscillator Source Selection                                         

#pragma config IESO = OFF                // Two-speed Oscillator Start-up Enable bit
//3.-

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

#define MIPS 40      //MIPS deseados (máximo 40 para el dspic33fj32mc204)

#define crystal 16      //valor del cristal en MHZ       

#define FCY MIPS*1000000 //frecuencia de instrucción 40Mips

#define delay_ms(x) __delay32((FCY/1000)*x) //delay en milisegundos

#define delay_us(x) __delay32(MIPS*x) //delay en microsegundos

//4.-

void config_clk_HSPLL(void);//funcion para elevar a 40 mips

//5.-

int main(void) {

    AD1PCFGL = 0xFFFF;//configuración de todas las salidas digitales

    config_clk_HSPLL();//llamando a la función configuración

    _TRISA0 = 0; //Configurando A0 como salida 

    _LATA0 = 0; //se inicia en apagado

    while (1) {

        _LATA0 = ~_LATA0;//para  hacer el prendido y apagado del led.

        delay_ms(500);//tiempo de encendido y apagado.

    }

    return 0;

}

//6.-

void config_clk_HSPLL(void) {//funciona de configuración de velocidad del dspic

    int M = MIPS * 8 / crystal;                 //tranformacion ppara optener el valor M

    PLLFBD = M - 2;                                  // M = 28

    CLKDIVbits.PLLPRE = 0;                 // N1 = 2

    CLKDIVbits.PLLPOST = 0;              // N2 = 2

    while (_LOCK == 0);

}

   Diagrama esquemático-Proteus:

Explicación del código:

1.-incluimos librerías únicos del xc16 y de C.

2.-configuramos los fuses de acuerdo con el datasheet del dspic a usar.

3.-hacemos unos define para nuestra fácil programación:

  #define MIPS 40      //velocidad del dspic es de 40Mhz o 40MIPS

  #define crystal 16      //valor del cristal en MHz externo       

  #define FCY MIPS*1000000 //frecuencia de instrucción 40Mips

  #define delay_ms(x) __delay32((FCY/1000)*x) //delay en milisegundos

  #define delay_us(x) __delay32(MIPS*x) //delay en microsegundos

4.- se hace el nombramiento dela función (void config_clk_HSPLL(void)).

5.- entramos a la función main.

6.-creación de nuestra función.Esta función es la encargada de elevar la velocidad del dspic a 40Mips,es decir, si estamos usando como en este caso un cristal de 16Mhz,no dara una velocidad de 16/2=8Mhz,para nuestro uso es muy poco,por ese motivo lo elevamos,en vez de tener una velocidad de 8MHz ,elevando vamos a tener una velocidad de 40MHz.

Ahora la pregunta es ¿De donde salio los valores de M , N1 y N2?

Para nuestro caso salieron del datasheet del dspic en la sección OSCILLATOR CONFIGURATION.

Nota:si gustan siempre usen la funcion void config_clk_HSPLL(void),si quieren menos velocidad,solo tienes que cambiar el valor del #define MIPS 40 y el #define crystal 16  al  valor que quieran utilizar,por ejemplo.

Quiero una velocidad de 20 Mips y estoy utilizando un crystal de 8 MHz externo.

seria:

#define MIPS 20  //velocidad del dspic

#define crystal 8 //valor del cristal externo