Instalación de MPLAB X 5.3 y XC8 en Manjaro Linux

[Video] Uso de Atom en Manjaro y uso para trabajar con ensamblador para AVR como editor

En el siguiente video, muestro la forma en que se usa el editor Atom para trabajar con ensamblador de AVR, aclaro que no es usado Atom para el ensamble, solo como editor.

GHDL, UMHDL y Quartus en Fedora 25 y 26

Una serie de videos en relación a GHDL

Compilando en GCC una funcion creada en XFuzzy en Manjaro Linux

XFuzzy es un programa de Open Source desarrollado por el centro Nacional de microelectronica de Sevilla, España. este software permite el desarrollo de sistemas difusos, para su implementación, monitoreo, y simulación con planta, además permite la implementación de código fuente a partir del sistema propuesto

En la imagen se muestra como esta implementado un sistema difuso y su monitorización.

Para generar un fuente a partir del sistema, dar clic en Synthesis -> To C, ahora elige la carpeta donde se van a almacenar los archivos generados que tendrán el mismo nombre del sistema, por ejemplo, para este caso el sistema se denomina example.xfl y los archivos generados se llaman example.c y example.h

Dentro del archivo example.h se encuentra la función que se puede llamar desde lenguaje , esta funcion incluye el nombre del sistema difuso diseñado en XFuzzy seguido de las palabras "Inference Engine", en este caso:

exampleInferenceEngine

Esta función tiene igual número de parámetros que entradas y salidas tiene el sistema

El código fuente se muestra en la imagen anterior, revise que la salida del sistema se almacena en la variable sal, la cual inicialmente se le asigna un valor de 0.0 por ser una variable de tipo double. notese que se usa paso por referencia.

Para compilar el programa (http://stackoverflow.com/questions/8999975/strange-behaviour-of-gcc-and-math-h) se usan algunos parámetros como son Wall y lm pque sirven para imprimir todas las advertencias que se generan (-Wall) durante la compilación del programa y -lm para el uso de la libreria math.h

En la imagen se aprecian las líneas para compilar el programa mostrado y la forma en que se ejecuta, es importante el orden de los archivos a compilar.

Para este caso se podrá notar la salida del sistema cuando las variables val1=val2 = 50.0 y val3 = 0.4 da el compilador de C un resultado de salida de 0.15 y en la imagen siguiente se muestra la salida del sistema difuso definido en XFuzzy cuando las entradas son 50.0, 50.0, 0.4

Esta portabilidad hace interesante a la herramienta, ya que es posible en cierta medida, colocar este código generado en un sistema embebido como lo es un microcontrolador.

hasta el momento les puedo comentar que en avr-gcc funciona muy bien pero con Pinguino PIC no se puede compilar a causa de que SDCC no permite el paso de estructuras como argumentos de funciones. Esto tambien lo probé al tratar de compilar en SDCC puro con el IDE PIKLAB

A fin de confirmarles el uso de la libreria generada por Xfuzzy en AVR-GCC se usa como IDE el code-blocks en su versión 12.11

y programando un ATmega32u4 (vea los siguientes links http://iemontiel.blogspot.mx/2013/05/mexican-arduino-usb-en-fedora-18.html y http://iemontiel.blogspot.mx/2013/12/teensyduino-en-manjaro.html) con cristal de 16MHz integrado en la tarjeta, es posible su compilación y el empleo de EASYDFU (como supervaca) para enviar la información al microcontrolador.

Vea que es interesante el hecho de que solamente se ocupó el 17.30% del total de la memoria del microcontrolador en cuestión.

Configurar Codeblocks en Manjaro para programar AVR

Code Blocks es un IDE multiplataforma para lenguaje C, en esta entrada describiré brevemente como configurar el Code Blocks para que en Manajro se pueda programar un AVR, en este caso tenemos el ATmega32U4

La primera parte es muy sencilla ya que solo hay que seguir un asistente, el problema es que cuando se pretende compilar el nuevo codigo, envia un error


/usr/lib/libm.so: file not recognized: File format not recognized
Process terminated with status 1 (0 minutes, 0 seconds)
0 errors, 0 warnings

Esto es a causa de que el IDE no está correctamente configurado para funcionar con el AVR GCC, por lo tanto solo hay que redireccionarlo, tal y como se indica en esta entrada de AVR Freaks

 http://www.avrfreaks.net/index.php?name=PNphpBB2&file=viewtopic&t=99954&view=next

De acuerdo a lo que ahi se indica debemos ir al menu settings, luego al menu Compiler..

Seleccionar el compilador "GNU AVR GCC Compiler"

Ir a la pestaña "Search directories" y en la sub-pestaña "Linker"
cambia la ruta por
/usr/lib/avr/lib/
 que actualmente dice /usr/lib

ahora ir a la sub-pestaña "Compiler" y editar la entrada para que diga lo siguiente:

/usr/lib/avr/include/avr

Entonces, ahora si al compilar tendremos el siguiente resultado :)

Pinguino PIC18F2550 USBBulk y SCILAB con USB - bulk error en Manjaro

Probando Pinguino PIC con Scilab, en la modalidad USB Bulk Transfer, me encontré con el atomo de JOSE PABLO CASTRO VALVERDE, en http://forge.scilab.org.

El scilab si reconoce al Pinguino en modalidad Bulk Transfer pero indica el siguiente error al tratar de enumerar al dispositivo

 

 -->;exec('/home/miguel/Documentos/scilab/usbTst.sce', -1)
 
 Libusb-1.0 Library initialized  
 
 device open  
endP_success=bulk_set_endpoint(enpIn,enpOut);
                               !--error 999
bulk_set_endpoint: Wrong size for input argument #1: A scalar expected ????.
at line      29 of exec file called by :   
scilab/usbTst.sce', -1

el código que se le carga al Pinguino es el que viene de ejemplo en la version SVN. Espero tener mas avances proximamente.

Qucs 0.01.17 en Manjaro

Bien pues sigo probando el uso de Manjaro y pues de momento va muy bien, el desktop es ligero en la PC que tengo, ya es un poco viejita (Gateway con procesador Core 2 con 2GB de RAM y disco de 500GB ) Pues como les comento, estoy probando Qucs y de momento va muy bien y lo mejor es que a diferencia de Fedora 19, esta distro si me está generando el VHDL a partir del diagrama lógico sin problemas, de igual forma Scilab despueś del detalle de ayer, he instalado los atoms de Fuzzy Logic, el complemento Coselica y SIMM para simulación física, y pues las simulaciones han corrido, el problema que tengo es con el IDE de Pinguino X.4 que no me abre, pero ya veré como funciona, aun no he probado la grabación de archivos .hex con AVR y PIC, pero ya está en la pc SDCC y AVR-GCC con el codeblocks.

Impresion a doble cara con bookbinder

Bueno, casualmente me encuentro haciendo unos manuales, pero como se requiere de engrapar, pues bookbinder es una solucion de software libre para elaborar folletos. este software a partir de un pdf te crea dos archivos, pues la cosa de imprimirlos es facil, (bueno despues de varios intentos lo es) 1. imprime el documento 1 2. asi como sale la hoja, la giras 180º y la introduces así como salió de la impresora 3. imprime el documento 2 pero con la opcion de imprimir de forma inversa. y eso es todo!

Para configurar piklab con pickit2

consultado de aquí:

http://www.electronica.robotsperu.org/index.php/microcontroladores/pic-linux-win/5-instalacion-configuracion-pickit-2-piklab

Máquinas de estados finitas en C

La siguiente herramienta les permitirá construir una máquina de estados finitos

http://qfsm.sourceforge.net/download.html

Las dependencias son
Graphviz  ()
cmake
make

para instalar desde las fuentes usa la version 0.52 ya que la actual en Fedora 18 indica un error

/usr/include/string.h:66:77: error: declaration of ‘int memcmp(const void*, const void*, size_t) throw ()’ has a different exception specifier
/usr/include/graphviz/cdt.h:242:12: error: from previous declaration ‘int memcmp(const void*, const void*, size_t)’

El cual en el sourceForge, el autor indica lo siguiente:

Date: 2012-11-20 08:18:18 PST
Sender: sttodu

I cannot reproduce the problem with Linux 3.2.0 / Ubuntu 12.04 / Qt 4.8.1 /
graphviz 2.26.3.
You seem to have graphviz 2.28 installed, and it seems that the problem
comes from an incompatibility between graphviz 2.28 and Qt.
I will do some further investigation.

Stefan

Y en mi caso, tengo Fedora 18, con graphviz 2.28 , que de acuerdo al autor, causa el problema indicado.

error semántico en eclipse AVR

Cuando se tiene una instalación fresca de eclipse con el plug-in de avr, es posible compilar un programa aunque en la ventana de problemas coloca un error al no identificar los defines de los puertos

Descripción    Información    Ruta    Ubicación    Type
Symbol 'PB3' could not be resolved    main.c    /mo    línea 27    Semantic Error

aunque el programa incluya al archivo io.h

#include 
//#include 
#define F_CPU 1000000UL
#include 

#define clearbit(sfr,bit) _SFR_BYTE(sfr)&=~_BV(bit)
#define setbit(sfr,bit) _SFR_BYTE(sfr)|=_BV(bit)

#define start    PINB0
#define pstart    PINB
#define stop    PINB1
#define pstop    PINB



#include "help.h"



int main(void) {
    //unsigned char flag = hola;
    config();
    while(1)
        {
            if(bit_is_set(pstart,start) && bit_is_set(pstop,stop))
            {
                clearbit(PORTB, PB3);
            }
            else
            {
                setbit(PORTB,PB3);
            }
        }
    return 0;
}

Una forma de resolver este problema es medinte la inclusión del  archivo .h del correspondiente microcontrolador (en este caso el

#include  

que se encuentra comentado).

Otra opción que se lee en el foro http://www.avrfreaks.net/index.php?name=PNphpBB2&file=viewtopic&p=902018 es entrar a las propiedades del proyecto y en la opción Target Hardware del menú AVR
seleccionar de nuevo el microcontrolador a utilizar  y posteriormente dar clic derecho sobre el nombre del proyecto.
Una vez ahí seleccionar índices y luego la opción rebuild.

Participación en WEEF2012

Aquí puede acceder al recurso: http://www.weef2012.edu.ar/papersFinal/information.php?doc=186

Libro de Abstracts: http://www.weef2012.edu.ar/archivos/papers/WEEF2012.pdf

Tuve a bien participar en el World Engineering Education Forum (WEFF) 2012 “Educación de ingeniería para el desarrollo sostenible y la inclusión social”, con la publicación del trabajo “Kit de prácticas OSH para la programación básica del microcontrolador PIC18F2550 con SDCC y PIKLAB en GNU/Linux” en Co-autoría con la M.S.C. Mariana Lobato Baéz y el M.C. Jorge Rivera Flores, en el cual se propone el uso de las herramientas libres para la enseñanza de microcontroladores.

Agradezco los comentarios de los revisiones, quienes comentaron:

"En este trabajo se recupera el valor de la “guía didáctica”. Los autores la proponen como material didáctico integrado a la realización de prácticas experimentales con elementos físicos (circuito pre-ensamblado o Kit de prueba) y a la aplicación del concepto de Open Source Hardware en un curso de Microcontroladores. Como resultado los autores exponen que esta estrategia integradora aparece cómo más favorable que el empleo de clases y simulación para el desarrollo de competencias específicas.

Esta experiencia concreta puede resultar de interés para los docentes en carreras de ingeniería ya que estaría mostrando que la simulación por sí sola no garantiza el aprendizaje de ciertas habilidades. Resalta la aplicación de Software Libre y sus beneficios en caso de no disponer de los recursos económicos necesarios para adquirir un software comercial."

Del mismo modo, agradezco el apoyo del Instituto Tecnológico Superior de Teziutlán, que es donde actualmente laboro.

Winavr- display 7 segmentos multiplexados - libreria alfa

Esta es una libreria en alfa, ya es funcional y admite cierta flexibilidad en el uso de pines, pero requiere de mucho manoseo por parte del usuario, espero comentarios, en el post se encuentra el diagrama con las indicaciones pertinentes.

Winavr- display 7 segmentos multiplexados - libreria alfa

Libreria LCD 20 x 4 Flexible 4 bits SDCC PIC18F2550

Este enlace lleva al codigo fuente de como hacer la interfaz entre una LCD y un micro PIC18f2550 mediante 4 bits definidos por el usuario, no importa el orden de conexion, esto es muy util cuando
se requiere de hacer ajustes en la placa donde se montaría el circuito.

Libreria LCD 20 x 4 Flexible 4 bits SDCC PIC18F2550

Libreria LCD 20x 4 Flexible 3 bits SDCC PIC18F2550

Esta es una libreria que se utiliza para comunicar un micro pic18f2550 con una pantalla LCD
alfanumerica de 2 caracteres por 4 lineas:

Libreria LCD 20x 4 Flexible 3 bits SDCC PIC18F2550

Tercer Rally Mecatrónico -- Sumobots

competencia que se desarrollo en el marco de la semana académica 2011 en el ITST por los chavos de Ing. en Mecatrónica.

Tercer Rally Mecatrónico -- Mecanismos Móviles

Este video resume el evento del tercer rally mecatrónico en la categoría Mecanismos Móviles.

PIC18F2250 y timer 1 una propuesta para configurarlo.

bueno aquí está parte del trabajo que realicé en el año. Se esperan comentarios.

http://www.itsteziutlan.edu.mx/index.php?option=com_content&view=article&id=715:propuesta-para-la-programacion-basica-del-temporizador-1-del-microcontrolador-pic18f2550-con-el-compilador-sdcc&catid=27:artlos&Itemid=288

http://www.itsteziutlan.edu.mx/index.php?option=com_content&view=article&id=714:propuesta-para-la-configuracion-basica-del-temporizador-1-del-microcontrolador-pic18f2550&catid=27:artlos&Itemid=288

etapa Regional de Innovación Tecnológica Tehuacan Puebla

Pues hace un buen rato que no escribo nada, y creo que tenia suficiente tiempo para hacerlo antes.

Ahora ya hay mas trabajo que antes, aunque esto, por el momento, no veo remuneración alguna, mas que la entera satisfacción, de hacer bien mi chamba.

Pues como uno de los resultados, el proyecto Gramatical, sigue adelante y ahora con un nuevo integrante, gramabot (aun está en condiciones de prototipo, pero ya está funcional)

el codigo fuente de control, está en lenguaje C, con el compiladr SDCC, programdo usando IDE beta MPLABX y libero el codigo con licencia GPL que anexo a continuación.





/**
*
Copyright (C) <2011>

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
#include

#define FOSC 48000000
#include "simple_delay.h"

__code char __at __CONFIG1L CONFIG1L = _PLLDIV_DIVIDE_BY_5__20MHZ_INPUT__1L & _CPUDIV__OSC1_OSC2_SRC___1__96MHZ_PLL_SRC___2__1L & _USBPLL_CLOCK_SRC_FROM_96MHZ_PLL_2_1L;
//code char at __CONFIG1H CONFIG1H = _OSC_HS__USB_HS_1H & _FCMEN_OFF_1H & _IESO_OFF_1H;
__code char __at __CONFIG1H CONFIG1H = _OSC_HS__HS_PLL__USB_HS_1H & _FCMEN_ON_1H & _IESO_ON_1H;
//_FOSC_HS_1H _FOSC_HS_1H
//_OSC_HS__HS_PLL__USB_HS_1H
__code char __at __CONFIG2L CONFIG2L = _PUT_ON_2L & _BODEN_ON_2L & _BODENV_4_2V_2L & _VREGEN_ON_2L;
__code char __at __CONFIG2H CONFIG2H = _WDT_DISABLED_CONTROLLED_2H & _WDTPS_1_32768_2H;
__code char __at __CONFIG3H CONFIG3H = _CCP2MUX_RC1_3H & _PBADEN_PORTB_4_0__CONFIGURED_AS_DIGITAL_I_O_ON_RESET_3H & _LPT1OSC_ON_3H & _MCLRE_MCLR_ON_RE3_OFF_3H;
__code char __at __CONFIG4L CONFIG4L = _STVR_ON_4L & _LVP_OFF_4L & _ENHCPU_OFF_4L & _BACKBUG_OFF_4L;
__code char __at __CONFIG5L CONFIG5L = _CP_0_OFF_5L & _CP_1_OFF_5L & _CP_2_OFF_5L & _CP_3_OFF_5L;
__code char __at __CONFIG5H CONFIG5H = _CPB_OFF_5H;
__code char __at __CONFIG6L CONFIG6L = _WRT_0_OFF_6L & _WRT_1_OFF_6L & _WRT_2_OFF_6L & _WRT_3_OFF_6L;
__code char __at __CONFIG6H CONFIG6H = _WRTC_OFF_6H & _WRTB_OFF_6H;
__code char __at __CONFIG7L CONFIG7L = _EBTR_0_OFF_7L & _EBTR_1_OFF_7L & _EBTR_2_OFF_7L & _EBTR_3_OFF_7L;
__code char __at __CONFIG7H CONFIG7H = _EBTRB_OFF_7H;

//Definiciones de servos
#define SERVO1 LATBbits.LATB0
#define SERVO2 LATBbits.LATB1
#define SERVO3 LATBbits.LATB2
#define SERVO4 LATBbits.LATB3
#define SERVO5 LATBbits.LATB4
#define SERVO6 LATBbits.LATB5
#define SERVO7 LATBbits.LATB6
#define SERVO8 LATBbits.LATB7

#define CSERVO1 TRISBbits.TRISB0
#define CSERVO2 TRISBbits.TRISB1
#define CSERVO3 TRISBbits.TRISB2
#define CSERVO4 TRISBbits.TRISB3
#define CSERVO5 TRISBbits.TRISB4
#define CSERVO6 TRISBbits.TRISB5
#define CSERVO7 TRISBbits.TRISB6
#define CSERVO8 TRISBbits.TRISB7

typedef enum{false = 0, true = 1} boolean; //para definir variables booleanas

//Constantes para la definición de ventanas
const unsigned Ticks4WindowH = 0x75;
const unsigned Ticks4WindowL = 0x2F;
const unsigned Ticks4CenterH = 0x46;
const unsigned Ticks4CenterL = 0x4F;
const unsigned Ticks4MinimumH = 0x17;
const unsigned Ticks4MinimumL = 0x6F;
const unsigned Ticks4MaximumH = 0x6B;
const unsigned Ticks4MaximumL = 0xCF;
static unsigned int Ticks4NextInterruptH = 0xCF;
static unsigned int Ticks4NextInterruptL = 0x2C;


const unsigned Ticks4Window = 0x752F;
const unsigned Ticks4Minimum = 0x176F;
const unsigned Ticks4Center = 0x464F;
const unsigned Ticks4Maximum = 0x6BCF;
static unsigned int Ticks4NextInterrupt = 0xCF2C;
static unsigned int Servo_PWM[8];
static unsigned int tempom=0x0000;
static unsigned int tempo=0x0000;
static unsigned int tempol;
static unsigned int tempoh;

static unsigned int Servo_PWMH[8];
static unsigned int Servo_PWML[8];
static unsigned short Servo_Idx = 0;

boolean SERVO1_ON = false;
boolean SERVO2_ON = false;
boolean SERVO3_ON = false;
boolean SERVO4_ON = false;
boolean SERVO5_ON = false;
boolean SERVO6_ON = false;
boolean SERVO7_ON = true;
boolean SERVO8_ON = true;


boolean flag_Phase;
unsigned short j=0xFF;
unsigned int posI;

//Prototipos
void init_board(void);
void EnableTimer1Interrupt(void);
void DiSi(void);
void DiNo(void);
void Tmr1Carga(unsigned char tempoH,unsigned char tempoL);
unsigned int SelectServo(unsigned char Servo);
void turnPlus(int vueltas, unsigned char vel, unsigned char Servo);
void turnMinus(int vueltas, unsigned char vel, unsigned char Servo);


//Sección de interrupciones
static void isr_Tmr1() __interrupt 1 //Esta es una interrupcion de alta prioridad
{
PIE1bits.RCIE=0; //deshabilitamos la interrupcion del puerto serie
if(flag_Phase == 1)
{
if(Servo_Idx == 0 && SERVO1_ON) {SERVO1 = 1;}
if(Servo_Idx == 1 && SERVO2_ON) {SERVO2 = 1;}
if(Servo_Idx == 2 && SERVO3_ON) {SERVO3 = 1;}
if(Servo_Idx == 3 && SERVO4_ON) {SERVO4 = 1;}
if(Servo_Idx == 4 && SERVO5_ON) {SERVO5 = 1;}
if(Servo_Idx == 5 && SERVO6_ON) {SERVO6 = 1;}
if(Servo_Idx == 6 && SERVO7_ON) {SERVO7 = 1;}
if(Servo_Idx == 7 && SERVO8_ON) {SERVO8 = 1;}
Ticks4NextInterruptH = 0xFF - Servo_PWMH[Servo_Idx];
Ticks4NextInterruptL = 0xFF - Servo_PWML[Servo_Idx];
Tmr1Carga(Ticks4NextInterruptH,Ticks4NextInterruptL);
}

if(flag_Phase == 0)
{
if(Servo_Idx == 0 && SERVO1_ON) {SERVO1 = 0;}
if(Servo_Idx == 1 && SERVO2_ON) {SERVO2 = 0;}
if(Servo_Idx == 2 && SERVO3_ON) {SERVO3 = 0;}
if(Servo_Idx == 3 && SERVO4_ON) {SERVO4 = 0;}
if(Servo_Idx == 4 && SERVO5_ON) {SERVO5 = 0;}
if(Servo_Idx == 5 && SERVO6_ON) {SERVO6 = 0;}
if(Servo_Idx == 6 && SERVO7_ON) {SERVO7 = 0;}
if(Servo_Idx == 7 && SERVO8_ON) {SERVO8 = 0;}
Ticks4NextInterruptH = 0xFF - Ticks4WindowH;
Ticks4NextInterruptL = 0xFF - Ticks4WindowL;

if(Ticks4NextInterruptL + Servo_PWML[Servo_Idx] > 0xFF)
{
Ticks4NextInterruptL = Ticks4NextInterruptL + Servo_PWML[Servo_Idx];
Ticks4NextInterruptH = Ticks4NextInterruptH + Servo_PWMH[Servo_Idx] + 1;
}
else
{
Ticks4NextInterruptL = Ticks4NextInterruptL + Servo_PWML[Servo_Idx];
Ticks4NextInterruptH = Ticks4NextInterruptH + Servo_PWMH[Servo_Idx];
}
Tmr1Carga(Ticks4NextInterruptH, Ticks4NextInterruptL);
if(++Servo_Idx > 7 ) Servo_Idx = 0;
}
if(++flag_Phase > 1) flag_Phase = 0;

//Esta instruccion se esta ejecutando cada 13ms con un xtal de 20MHz
//LATBbits.LATB7^=1; //complementamos el valor del bit RB7
PIR1bits.TMR1IF=0; //limpiamos la bandera de interrupcion
PIE1bits.RCIE=1; //habilitamos la interrupcion del puerto serie
}



//Funcion Principal
int main(void)
{
//declaracion de variables
int i=0;
int button_down=1;
int valTimer=0;

RCONbits.IPEN=1; //interrupciones por prioridad habilitadas

init_board();


//Centrar los servos
for (i=0;i<9;i++)
{
Servo_PWMH[i] = Ticks4CenterH;
Servo_PWML[i] = Ticks4CenterL;
}

EnableTimer1Interrupt();
tempo = Ticks4Center;
tempoh = tempo & 0xFF00;
tempol = tempo & 0x00FF;
Tmr1Carga(tempoh, tempol);
posI = Ticks4Center;




while (true)
{
//Aquí va el código para si y no
if(!PORTBbits.RB0) //Termino exitosamente la actividad
{
PORTAbits.RA4 = 0;
DiSi();
// PORTAbits.RA4 = 1;
// delay_ms(20);
// PORTAbits.RA4 = 0;
// delay_ms(20);
}
if(!PORTBbits.RB1) //esta prendido el led amarillo del semaforo
{
PORTAbits.RA4 = 0;
DiNo();
}
else
{
PORTAbits.RA4 = 1; //Mientras no pase nada prende el testigo
delay_ms(20);
PORTAbits.RA4 = 0;
delay_ms(20);
}
}
return 0;
}


void init_board(void)
{
ADCON1=0x7; // PORTA used for digital I/O
TRISAbits.TRISA4=false; // configure PORTA4 como salida TESTIGO
/*Falta configurar RA0 y RA1 como entradas*/
/* Configuramos las salidas de los servomotores*/
CSERVO1 = true;
CSERVO2 = true;
CSERVO3 = true;
CSERVO4 = true;
CSERVO5 = true;
CSERVO6 = true;
CSERVO7 = false;
CSERVO8 = false;
//configurar Entradas para GRAMAKIT
TRISBbits.TRISB0 = true;
TRISBbits.TRISB1 = true;

}

void EnableTimer1Interrupt(void)
{
T1CON=1; //Timer1 preescaler 1 interno, carga de 8 bits
PIE1bits.TMR1IE=1;
INTCONbits.PEIE=1;
INTCONbits.GIE=1;
}

void DiSi(void)
{
unsigned char posicion[] = {60,90,60,90,60,90}; //posiciones en grados a mover la cabeza para decir SI
unsigned char i, DerIzq = 1;
unsigned char vel=1; //AQUI SE DEFINE LA VELOCIDAD DEL SERVO
//si quieres ver como se puede modificar este valor por medio
//de rs232, ve el archivo timer1.c


unsigned int posF;
unsigned int vueltas;

for(i = 0;i<4;i++)
{
posI = SelectServo(6); //El servo conectado a RB6
posF = 106.66 * posicion[i] + 8399;

if(posF>posI){
vueltas = posF - posI;
vueltas = vueltas / vel;
DerIzq = 1;
}
else
{
vueltas = posI - posF;
vueltas = vueltas/ vel;
DerIzq = 0;
}

if(DerIzq)
{
turnPlus(vueltas,vel,6);
}
else
{
turnMinus(vueltas,vel,6);
}
delay_ms(10);
}
}

void DiNo(void)
{
unsigned char posicion[] = {60,120,60,90}; //posiciones en grados a mover la cabeza para decir NO
unsigned char i, DerIzq = 1;
unsigned char vel=1; //AQUI SE DEFINE LA VELOCIDAD DEL SERVO
//si quieres ver como se puede modificar este valor por medio
//de rs232, ve el archivo timer1.c


unsigned int posF;
unsigned int vueltas;

for(i = 0;i<4;i++)
{
posI = SelectServo(7); //El servo conectado a RB7
posF = 106.66 * posicion[i] + 8399;

if(posF>posI){
vueltas = posF - posI;
vueltas = vueltas / vel;
DerIzq = 1;
}
else
{
vueltas = posI - posF;
vueltas = vueltas/ vel;
DerIzq = 0;
}

if(DerIzq)
{
turnPlus(vueltas,vel,7);
}
else
{
turnMinus(vueltas,vel,7);
}
delay_ms(10);
}

}

//Funcion para cargar el timer1 con valor dado por el usuario
void Tmr1Carga(unsigned char tempoH,unsigned char tempoL)
{
TMR1H=tempoH;
TMR1L=tempoL;
}


//Función para elegir el valor de tiempo que tiene un servo

unsigned int SelectServo(unsigned char Servo)
{
tempoh = Servo_PWMH[Servo];
tempo = tempoh << 8;
return (tempo | Servo_PWML[Servo]);
}


//Funcion para dar un valor incremental a la posición de un servo determinado
void turnPlus(int vueltas, unsigned char vel, unsigned char Servo)
{
int i=0;

for(i=0;i> 8;
Servo_PWMH[Servo] = tempoh;
delay_us(100);
}
}

//Funcion para dar un valor decremental a la posicion de un servo determinado
void turnMinus(int vueltas, unsigned char vel, unsigned char Servo)
{
int i=0;

for(i=0;i> 8;
Servo_PWMH[Servo] = tempoh;
delay_us(100);
}
}

Algo que escribí

Bueno aquí dejo algo que escribí en la escuela, no esta muy bien redactado, pero la idea fundamental es dar a conocer la existencia de las herramientas libres para la programación de microcontroladores PIC.

Echenle un ojito y espero sus comentarios
LINK
http://www.itsteziutlan.edu.mx/index.php?option=com_content&view=article&id=597:herramientas-libres-para-la-programacion-de-microcontroladores-pic&catid=27:artlos&Itemid=288