SEP DIRECCIN GENERAL DE EDUCACIN SUPERIOR TECNOLGICA

INSTITUTO TECNOLGICO DE SAN LUIS POTOS

CARRERA MATERIA PROFESOR ESTUDIANTE

Ingeniera Mecatrnica Interfaces M.C. Ramn Daz de Len Zapata Segura Lpez Marco Antonio Torres Bez Edgar Armando Montes Alonso Aldo Antonio

CALIFICACIN

Compilador CCS CCS te ofrece un conjunto de herramientas completas e integrada para la produccion de aplicaciones embebidas corriendo en microcontroladores PIC y dsPIC de Microchip. La salida en HEX y los archivos de depuracin son seleccionables y compatibles con emuladores y programadores populares incluyendo MPLAB IDE para depuracin a nivel de fuente. PCWHD incluye un poderoso IDE bajo Windows. El compilador requiere Windows 95, 98, ME, NT4, 2000, XP, o Linux. # Bibliotecas incorporadas que funcionan con todos los chips para Entrada/Salida por puerto serie RS-232, Entradas/Salidas discretas y pausas de precisin. # Se integra al IDE de MPLAB y otros simuladores y editores para depuracin a nivel de fuente. Los archivos HEX estndar y archivos de depuracin aseguran compatibilidad con todos los programadores. # El "printf" formateado permite un formateo y muestra simple en HEX o decimal. # La implementacin eficiente de funciones permite rboles de llamada ms profundos que la pila del hardware. # Se incluyen drivers de cdigo fuente para mdulos LCD, teclados, EEPROMs serie 24xx y 94xx, relojes en tiempo real X10, DS1302 y NJU6355, dispositivos de memoria de toque de Dallas, RAM serie DS2223 y PCF8570, conversores A/D LTV1298 yPCF8591, sensores de temperatura, potencimetros digitales, expansores de Entrada/Salida y ms. # Acceso a las caractersticas del hardware desde funciones en C fciles de usar, temporizadores, conversin A/D, SSP, PSP, USB, I2C, y ms. # Tipos enteros de 1, 8, 16 y 32 bits y punto flotante de 32 bits. # Se puede insertar cdigo ensamblador en el cdigo fuente y puede referenciar variables de C. # El enlazamiento automtico puede manejar mltiples pginas de cdigo. # Soportadas funciones inline para ahorrar espacio de pila; el enlazador determinar automticamente la mejor arquitectura o se puede especificar manualmente. # Las directivas del compilador determinan si los registro tri-estado se refrescan en cada E/S o si la E/S es lo ms rpida posible. # Las constantes (incluyendo cadenas y vectores) se almacenan en la memoria de programa. # El tipo de dato bit estndar (short int) permite que el compilador genere cdigo muy eficiente orientado a Bit. # #BIT y #BYTE permite que las variables de C sean puestas en direcciones absolutas para mapear registros a variables de C. # Los parmetros de referencia se pueden usar para mejorar la lectura del cdigo y la eficiencia de las funciones inline. # PCW tiene un compilador de lnea de comando y un editor/compilador integrado. # Ventanas especiales muestran el mapa de memoria de la RAM, listados C/ensamblador, y el rbol de llamadas. # Funciones de interrupcin soportadas en PCM/PCH. El compilador genera todo el cdigo de inicio y limpieza as como identifica la funcin de interrupcin correcta a ser llamada. # Ms de 100 programas de ejemplo listos para ser ejecutados.

Se incluye: CD con el Software original v4.099 y ejemplosLicenciaTabla de caracteres ASCIITabla con la sintaxis CLibro Manual de Referencia PIC MCU C Compiler (para PIC10,/PIC12/PIC16/PIC18)Libro Manual de Referencia PCD C Compilre (para PIC24/dsPIC DSC) |Unidades | Dlares | ---------------------| 1 | 710 | | 2 | 1350 | | 2+ | (consulte) | ---------------------// // ACONDICIONAMIENTO DE SEAL // //

///////////////////////CONFIGURACION DEL PIC//////////////////////////////////// #include <18F4550.h> //Seleccion del pic a utilizar

/******************************************************************************/ #device adc=10; //Conversor ADC de 10 bits de resolucion

//////////////////////////////FUSES///////////////////////////////////////////// #fuses HSPLL,NOWDT,NOLVP,USBDIV,PLL5,CPUDIV1,VREGEN /******************************************************************************/ #use delay(clock=48000000) //Frecuencia del cristal oscilador

#include <lcd.c>

//Libreria LCD //Libreria bootloader se comenta para poder

//#include "usb_bootloader.h"

//simularse, al probar el circuito fisico //quitar comentario /******************************************************************************/ /////////////////////////////FUNCIONES////////////////////////////////////////// /******************************************************************************/

////////////////////////////////BIENVENIDA////////////////////////////////////// void bienvenida (void)

{ printf(lcd_putc,"\f Bienvenido \n"); //Mje de bienvenida delay_ms(500); printf(lcd_putc,"\f Selecciona la\n" ); //Instrucciones delay_ms(500); printf(lcd_putc,"\n funcion"); //imprime el valor del voltaje de vsal delay_ms(500); printf(lcd_putc,"\n que desees"); //imprime el valor del voltaje de vsal delay_ms(500); printf(lcd_putc,"\f Solo precionala"); //imprime el valor del voltaje de vsal delay_ms(500); }

///////////////////////////SEGUIDOR DE VOLTAJE////////////////////////////////// void seguidor (void) { int16 valor=0; float sal=0; float vent=0.0; float vres=0.0; float vres2=0.0; //Variable para almacenar lectura del adc0 //Variable para mostrar el voltaje de salida en lcd //Variable para realizar calculos en zero y span //Variable para resultado del zero y span de entrada //Variable de resultado del zero y span de salida

unsigned char vsal=0;//Variable para sacar por el puerto

set_adc_channel(0); delay_us(20); valor=read_adc(); vent=valor;

//habilita el canal analogico 0

//Delay para estabilizar conversion //variable para almacenara lectura del adc //Cambio de variable int16 a float

vres=((vent-(1023.0/2.0))*(20.0/1023.0));//entrada 1023 y 0 salida de 10v a -10v

vres2=(1.0*vres);

//Operacion a efectuar

if (vres2>10.0) { vres2=10.0; } else { vres2=(1.0*vres); }

//Proteccion para limitar la salida del operacional a 10v

vres2=((vres2+10)*(255.0/20.0));//entrada de 10v a -10v y salida de 0 a 255 vsal=vres2; //Cambio de variable float a unsigned char es la variable //que puede escribirse por un puerto output_B(vsal); sal=vres; //Sacamos por el puerto b el resultado //Variable para mostrar en lcd el resultado de la salida

printf(lcd_putc,"\f Seguidor \n"); delay_ms(500);

//imprime mensaje en lcd

printf(lcd_putc,"\n Vent= %f V",vres); //imprime el valor del Vent delay_ms(500); printf(lcd_putc,"\n Vsal= %f V",sal); //imprime el valor del voltaje de vsal delay_ms(500); }

////////////////////////Amplificador no inversor//////////////////////////////// void amp_no_inv (void) { int16 valor=0; //Variable para almacenar lectura del adc0

signed char ganancia=2; //Variable que da la ganancia modificar el numero //Para dar otra ganancia deseada float sal=0; float vent=0.0; float vres=0.0; float vres2=0.0; //Variable para mostrar el voltaje de salida en lcd //Variable para realizar calculos en zero y span //Variable para resultado del zero y span de entrada //Variable de resultado del zero y span de salida //Variable para sacar por el puerto

unsigned char vsal=0;

set_adc_channel(0); delay_us(20); valor=read_adc(); vent=valor;

//habilita el canal analogico 0 //Delay para estabilizar conversion //variable para almacenara lectura del adc //Cambio de variable int16 a float

vres=((vent-(1023.0/2.0))*(20.0/1023.0));//entrada 1023 y 0 salida de 10 a -10 vres2=(ganancia*vres); sal=vres2; vres2=((vres2+10)*(255.0/20.0));//entrada de 10 a -10 y salida de 0 a 255 vsal=vres2; output_B(vsal); //Operacion a efectuar

printf(lcd_putc,"\f AMPLIFICADOR \n"); delay_ms(500); printf(lcd_putc,"\fNO INVERSOR \n"); delay_ms(500);

//imprime mensaje en lcd

printf(lcd_putc,"\f GANANCIA= %d \n",ganancia); delay_ms(500);

//imprime valor de la ganancia

printf(lcd_putc,"\n Vent= %f V",vres); //imprime el valor del Vent delay_ms(500); printf(lcd_putc,"\n Vsal= %f V",sal); //imprime el valor del voltaje de vsal

delay_ms(500); }

///////////////////////////Amplificador inversor//////////////////////////////// void amp_inv (void) { int16 valor=0; //Variable para almacenar lectura del adc0

signed char ganancia=-2; //Variable que da la ganancia modificar el numero //Para dar otra ganancia deseada float sal=0; float vent=0.0; float vres=0.0; float vres2=0.0; //Variable para mostrar el voltaje de salida en lcd //Variable para realizar calculos en zero y span //Variable para resultado del zero y span de entrada //Variable de resultado del zero y span de salida //Variable para sacar por el puerto

unsigned char vsal=0;

set_adc_channel(0); delay_us(20); valor=read_adc(); vent=valor;

//habilita el canal analogico 0 //Delay para estabilizar conversion //variable para almacenara lectura del adc //Cambio de variable int16 a float

vres=((vent-(1023.0/2.0))*(20.0/1023.0));//entrada 1023 y 0 salida de 10 a -10 vres2=(ganancia*vres); sal=vres2; vres2=((vres2+10)*(255.0/20.0));//entrada de 10 a -10 y salida de 0 a 255 vsal=vres2; output_B(vsal); //Operacion a efectuar

printf(lcd_putc,"\f AMPLIFICADOR \n"); delay_ms(500);

//imprime mensaje en lcd

printf(lcd_putc,"\f INVERSOR \n"); delay_ms(500); printf(lcd_putc,"\f GANANCIA= %d \n",ganancia); delay_ms(500); printf(lcd_putc,"\n Vent= %f V",vres); //imprime el valor del Vent delay_ms(500); printf(lcd_putc,"\n Vsal= %f V",sal); //imprime el valor del voltaje de vsal delay_ms(500); } //imprime valor de la ganancia

////////////////////////////SUMADOR INVERSOR//////////////////////////////////// void sumador_inversor (void) { int16 valor=0; float sal=0; float vent=0.0; float vent2=0.0; float vres=0.0; float vres2=0.0; float vres3=0.0; unsigned char vsal=0; //Variable para almacenar lectura del adc0 y adc1 //Variable para mostrar el voltaje de salida en lcd //Variable para realizar calculos en zero y span //Variable para realizar calculos en zero y span 2 //Variable para resultado del zero y span de entrada //Variable para resultado del zero y span 2 //Variable de resultado del zero y span de salida //Variable para sacar por el puerto

set_adc_channel(0); delay_us(20); valor=read_adc(); vent=valor;

//habilita el canal analogico 0 //Delay para estabilizar conversion //variable para almacenara lectura del adc //Cambio de variable int16 a float

vres=((vent-(1023.0/2.0))*(20.0/1023.0));//entrada 1023 y 0 salida de 10 a -10

set_adc_channel(1); delay_us(20); valor=read_adc(); vent=(valor);

//habilita el canal analogico 1 //Delay para estabilizar conversion //variable para almacenara lectura del adc //Cambio de variable int16 a float

vres2=((vent)*(5.0/1023.0));//entrada 1023 y 0 salida de 5 a 0 vres3=(vres+vres2)*(-1.0); //Operacion a efectuar sal=vres3; vres3=((vres3+10)*(255.0/20.0));//entrada de 10 a -10 y salida de 0 a 255 vsal=vres3; output_B(vsal);

printf(lcd_putc,"\f SUMADOR \n"); delay_ms(500); printf(lcd_putc,"\f INVERSOR \n"); delay_ms(500);

//imprime mensaje en lcd

printf(lcd_putc,"\n Vent1= %f V",vres); //imprime el valor del Vent1 delay_ms(500); printf(lcd_putc,"\n Vent2= %f V",vres2); //imprime el valor del Vent2 delay_ms(500); printf(lcd_putc,"\n Vsal= %f V",sal); //imprime el valor del voltaje de vsal delay_ms(500); }

//////////////////////////SUMADOR NO INVERSOR/////////////////////////////////// void sumador_no_inversor (void) { int16 valor=0; //Variable para almacenar lectura del adc0 y adc1

float sal=0; float vent=0.0; float vent2=0.0; float vres=0.0; float vres2=0.0; float vres3=0.0;

//Variable para mostrar el voltaje de salida en lcd //Variable para realizar calculos en zero y span //Variable para realizar calculos en zero y span 2 //Variable para resultado del zero y span de entrada //Variable para resultado del zero y span 2 //Variable de resultado del zero y span de salida //Variable para sacar por el puerto

unsigned char vsal=0;

set_adc_channel(0); delay_us(20); valor=read_adc(); vent=valor;

//habilita el canal analogico 0 //Delay para estabilizar conversion //variable para almacenara lectura del adc //Cambio de variable int16 a float

vres=((vent-(1023.0/2.0))*(20.0/1023.0));//entrada 1023 y 0 salida de 10 a -10

set_adc_channel(1); delay_us(20); valor=read_adc(); vent=(valor);

//habilita el canal analogico 1 //Delay para estabilizar conversion //variable para almacenara lectura del adc //Cambio de variable int16 a float

vres2=((vent)*(5.0/1023.0));//entrada 1023 y 0 salida de 5 a 0 vres3=(vres+vres2); sal=vres3; vres3=((vres3+10)*(255.0/20.0));//entrada de 10 a -10 y salida de 0 a 255 vsal=vres3; output_B(vsal); //Operacion a efectuar

printf(lcd_putc,"\f SUMADOR \n"); delay_ms(500);

//imprime mensaje en lcd

printf(lcd_putc,"\f NO INVERSOR \n"); delay_ms(500); printf(lcd_putc,"\n Vent1= %f V",vres); //imprime el valor del Vent1 delay_ms(500); printf(lcd_putc,"\n Vent2= %f V",vres2); //imprime el valor del Vent2 delay_ms(500); printf(lcd_putc,"\n Vsal= %f V",sal); //imprime el valor del voltaje de vsal delay_ms(500); }

/////////////////////////////ZERO y SPAN//////////////////////////////////////// void zero_span (void) { int16 valor=0; float sal=0; float vent=0.0; float vres=0.0; float vres2=0.0; //Variable para almacenar lectura del adc0 //Variable para mostrar el voltaje de salida en lcd //Variable para realizar calculos en zero y span //Variable para resultado del zero y span de entrada //Variable de resultado del zero y span de salida //Variable para sacar por el puerto //Referencia en el zero y span

unsigned char vsal=0; signed char vref=-1;

set_adc_channel(0); delay_us(20); valor=read_adc(); vent=valor;

//habilita el canal analogico 0 //Delay para estabilizar conversion //variable para almacenara lectura del adc //Cambio de variable int16 a float

vres=((vent-(10230.0/20.0))*(20.0/1023.0));//entrada 1023 y 0 salida de 10 a -10 vres2=((vres+(vref))*(5.0)); //Operacion a efectuar

sal=vres2; vres2=((vres2+10)*(255.0/20.0));//entrada de 10 a -10 y salida de 0 a 255 vsal=vres2; output_B(vsal);

printf(lcd_putc,"\fZERO Y SPAN \n"); delay_ms(500);

//imprime mensaje en lcd

printf(lcd_putc,"\f Vent1= %fV\n",vres); //imprime el valor del Vent1 delay_ms(500); printf(lcd_putc,"\f Vref= %dV\n",vref); //imprime el valor del Vref delay_ms(500); printf(lcd_putc,"\f Vsal= %fV\n",sal); //imprime el valor del voltaje de vsal delay_ms(500); }

void main() {

int entradas;

//Variable para leer entradas en el case

setup_adc_ports(AN0_TO_AN1);

//ACTIVACION DE CANAL ANALOGICO 0 y 1 //CONVERSION CON RELOJ INTERNO

setup_adc(ADC_CLOCK_INTERNAL );

lcd_init(); bienvenida();

//Inicializa el LCD //Funcion de bienvenida

while(TRUE) {

entradas=input_c(); switch (entradas) { case 0x00: bienvenida(); delay_ms(50); break;

//Entrada tomara el valor del puerto c

//Si todo esta apagado //Llama la funcion bienvenida

case 0x01: seguidor(); delay_ms(50); break;

//Si RC0=1 //Llama la funcion seguidor

case 0x02: amp_no_inv(); delay_ms(50); break;

//Si RC1=1 //Llama la funcion amp_no_inv

case 0x04: amp_inv(); delay_ms(50); break;

//Si RC2=1 //Llama la funcion amp_inv

case 0x10: sumador_inversor(); delay_ms(50); break;

//Si RC4=1 //Llama la funcion sumador_inversor

case 0x20: sumador_no_inversor(); delay_ms(50); break;

//Si RC5=1 //Llama la funcion sumador_inversor

case 0x40: zero_span(); delay_ms(50); break; } } }

//Si RC6=1 //Llama la funcion zero_span

Compilador Arduino Caractersticas generales de la placa Se trata de una placa open hardware por lo que su diseo es de libre distribucin y utilizacin, que incluso podemos construirnos nosotros mismos. El programa se implementar haciendo uso del entorno de programacin propio de arduino y se transferir empleando un cable USB. Si bien en el caso de la placa USB no es preciso utilizar una fuente de alimentacin externa, ya que el propio cable USB la proporciona, para la realizacin de algunos de los experimentos prcticos s que ser necesario disponer de una fuente de alimentacin externa ya que la alimentacin proporcionada por el USB puede no ser suficiente. El voltaje de la fuente puede estar entre 6 y 25 Voltios. Entorno de desarrollo Para programar la placa es necesario descargarse de la pgina web de Arduino el entorno de desarrollo (IDE). Se dispone de versiones para Windows y para MAC, as como las fuentes para compilarlas en LINUX. Lo primero que tenemos que hacer para comenzar a trabajar con el entorno de desarrollo de arduino es configurar las comunicaciones entre la placa Arduino y el PC. Para ello deberemos abrir en el men "Tools" la opcin "Serial Port". En esta opcin deberemos seleccionar el puerto serie al que est conectada nuestra placa. En Windows, si desconocemos el puerto al que est conectado

nuestra placa podemos descubrirlo a travs del Administrador de dispositivos (Puertos COM & LPT/ USB Serial Port). El uso de arduino y labview es muy intuitivo, ya que al ser labview un lenguaje de programacin grafico es relativamente sencillo poder utilizar la placa arduino con labview. A continuacin se muestra un cdigo de ejemplo para conectar la tarjeta de arduino con Ethernet shield y poder crear un servidor. #include<SPI.h> #includeEthernet.h> // network configuration. gateway and subnet are optional. // the media access control (ethernet hardware) address for the shield: byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; IPAddress ip(192,168,1,50); //CREAMOS LA VARIABLE PARA EL SERVIDOR ETHERNET, EN EL PUERTO 23 EthernetServer server = EthernetServer(23);

void setup() { Serial.begin(9600); Serial.println("Serial inicializado"); // INICIALIZAMOS EL SERVIDOR ETHERNET Ethernet.begin(mac, ip); .. // EMPEZAMOS A ESCUCHAR A LA ESPERA DE CLIENTES server.begin(); }

void loop() {

EthernetClient client = server.available(); //-> Devuelve un cliente en caso de que exista if (client == true) { //mientras el cliente siga conectado while(client.connected()) { .. //si hay datos disponibles para leer if (client.available()){ //aqu leeramos el comando y devolveramos la respuesta // para leer: char c = client.read(); //para escribir: client.println(cadena);

} } Compilador MikroC Estructura bsica de un programa en mikroC PRO (sin funciones) Todos los programas (cdigo fuente) de microcontroladores PIC y AVR en C tienen una estructura bsica, a partir de la cual se desarrolla cualquier aplicacin del usuario: //Nombre_de_programa.c //Descripcin del programa. //Autor: Ing. Penagos R. //Declaracin de variables ... //Funcin principal void main( ){ //Instrucciones del programa. ... } Los 7 elementos bsicos de la programacin de PIC y AVR en C La programacin de PIC en C se puede comprender mejor si se estudian sus elementos bsicos; una vez que se dominen estos elementos se podr dar solucin a la gran mayora de problemas de programacin. El propsito de la mayora de los programas es resolver un problema. Los programas resuelven los problemas por medio de la manipulacin de informacin o datos. Normalmente los programas se caracterizan por permitir el ingreso de informacin, tener uno o varios lugares de almacenamiento de dicha informacin, contar con las instrucciones para manipular estos datos y obtener algn resultado del programa que sea til para el usuario. Tambin, las instrucciones se pueden organizar de tal forma que algunas de ellas se ejecuten slo cuando una condicin especfica (o conjunto de condiciones) sea verdadera, otras instrucciones se repitan un cierto nmero de veces y otras pueden ser agrupadas en bloques que se ejecutan en diferentes partes de un programa. Lo anterior constituye una breve descripcin de los siete elementos bsicos de la programacin: entrada de datos, tipos de datos, operaciones, salida, ejecucin condicional, lazos y funciones. Una vez que se dominan estos elementos se puede afirmar que se conocen los fundamentos de la programacin, con lo cual ya es posible desarrollar una gran cantidad de aplicaciones de diversa ndole. Instrucciones bsicas de PIC y AVR en C 1.- Instruccin de asignacin (=)

Permite asignar a una variable un valor constante, el contenido de otra variable o el resultado de una expresin matemtica. La asignacin va de derecha a izquierda. Por ejemplo, suma=0; //El valor 0 se almacena en la variable suma. x0=x1; //El contenido de la variable x1 se almacena en la variable x0. dx=(b-a)/n; //El resultado de la expresin matemtica se almacena en la variable dx.

2.- Instruccin de entrada de datos (variable=PORTx) Permite el ingreso de uno o ms datos a travs de los pines del microcontrolador y almacenarlos en una o ms variables. Por ejemplo, variable=PORTA; //Los bits del puerto A se almacenan en la variable. El siguiente es un caso especial utilizado en la programacin de microcontroladores PIC en C: PORTB=PORTA; //Los bits del puerto A se envan hacia los pines del puerto B. Tambin se puede leer el estado individual de cada bit de un puerto: variable=RB3_bit; //Lee el estado del pin RB3 y lo guarda en la variable. 3.- Instruccin de salida de datos (PORTx=dato) Permite el envo de datos, el contenido de una variable o el resultado de una expresin matemtica hacia los pines de un puerto. Por ejemplo, PORTA=0x00; //Todos los pines del puerto A se ponen en 0. PORTB=variable; Los bits de la variable son enviados hacia los pines del puerto B. PORTB=PORTA+65; //El valor del puerto A ms 65 se enva hacia el puerto B. Como caso especial, se pueden enviar bits individuales a cada uno de los pines de un puerto: RB0_bit=0; //El pin RB0 se pone en 0. 4.- Instruccin de decisin (if...else) Permite la ejecucin de las instrucciones1 si la condicin es verdadera, de lo contrario se ejecutan las instrucciones2. Las llaves { } no son necesarias cuando hay una sola instruccin. if (condicin){ instrucciones1; } else{ instrucciones2; } 5.- Instruccin de ciclo controlado por una variable (for) Permite ejecutar un grupo de instrucciones de manera repetitiva, una determinada cantidad de veces. for (nmero de veces){ instrucciones; }

6.- Instruccin iterativa condicional (while) Permite ejecutar un grupo de instrucciones de manera repetitiva, mientras una condicin sea verdadera. Primero se revisa la condicin para determinar su valor de verdad (verdadero o falso) y luego se ejecutan las instrucciones. while (condicin){ instrucciones; } 7.- Instruccin hacer-mientras (do...while) Permite ejecutar un grupo de instrucciones de manera repetitiva, mientras una condicin sea verdadera. Es similar a la instruccin while, con la diferencia de que primero se ejecutan las instrucciones y luego se revisa la condicin. do{ instrucciones; } while (condicin); La informacion anterior es aplicable tanto para AVR como para PIC. El siguiente ejemplo es para un microcontrolador AVR. Ejemplo 1 //modulo pwm con avr char current_duty; char current_duty1; void main(){ DDC0_bit = 0; DDC1_bit = 0; DDC2_bit = 0; DDC3_bit = 0; current_duty = 255; current_duty1 = 255; DDRB.B1 = 1; DDRB.B2 = 1; // Set PORTC pin 0 as input // Set PORTC pin 1 as input // Set PORTC pin 2 as input // Set PORTC pin 3 as input // initial value for current_duty // initial value for current_duty // Set PORTB pin 1 as output pin for the PWM (according to datasheet) // Set PORTB pin 2 as output pin for the PWM (according to datasheet) _PWM16_PRESCALER_16bit_1,

PWM16bit_Init(_PWM16_FAST_MODE_9BIT, _PWM16_INVERTED, 255, 1);

do { if (PINC.B0) { // Detect if PORTC pin 0 is pressed Delay_ms(40); // Small delay to avoid deboucing effect current_duty++; // Increment duty ratio PWM16bit_Change_Duty(current_duty, _TIMER1_CH_A); // Set incremented duty } else

if (PINC.B1) { // Detect if PORTC pin 1 is pressed Delay_ms(40); // Small delay to avoid deboucing effect current_duty--; // Decrement duty ratio PWM16bit_Change_Duty(current_duty, _TIMER1_CH_A); // Set decremented duty ratio } else if (PINC.B2) { // Detect if PORTC pin 2 is pressed Delay_ms(40); // Small delay to avoid deboucing effect current_duty1++; // Increment duty ratio PWM16bit_Change_Duty(current_duty1, _TIMER1_CH_B); // Set incremented duty } else if (PINC.B3) { // Detect if PORTC pin 3 is pressed Delay_ms(40); // Small delay to avoid deboucing effect current_duty1--; // Decrement duty ratio PWM16bit_Change_Duty(current_duty1, _TIMER1_CH_B); // Set decremented duty ratio } } while(1); } Ejemplo 2 //comunicacion serial char uart_rd; void main() { UART1_Init(9600); // Initialize UART module at 9600 bps Delay_ms(100); // Wait for UART module to stabilize UART1_Write_Text("Init"); UART1_Write(13); UART1_Write(10); while (1) { // Endless loop if (UART1_Data_Ready()) { // If data is received, uart_rd = UART1_Read(); // read the received data, UART1_Write(uart_rd); // and send data via UART } } } Ejemplo 3 //pwm controlado desde labview char dato; int current_duty; // Endless loop

void PWM_LABVIEW(void);//definimos una subrutina void Configure_Port(void);//definimos subrutina void Configure_Serial_Communication(void);//subrutina void main() { Configure_Port();//llamamos subrutina Configure_Serial_Communication();//llamamos subrutina PWM1_Init(_PWM1_FAST_MODE, current_duty); _PWM1_PRESCALER_8, _PWM1_NON_INVERTED,

//INICIA EL MODULO PWM EN MODO RAPIDO, CON UNA PRESCALA DE 8, CONFIGURADO EN MODO NO INVERTIDO Y EL CICLO DE TRABAJO ES //CURRENT DUTY while(1) { PWM_LABVIEW();//llamamos la subrutina para que se ejecute } } void Configure_Port(void) { DDB0_bit = 0; DDB1_bit = 0; DDC0_bit = 0; DDC1_bit = 0; current_duty = 127; DDB3_bit = 1; DDD7_bit = 1; // RB0 como entrada // RB1 como entrada // RC1 como entrada // RC1 como entrada // inicializamos la variable para el PWM inicie en 50% // Ponemos RB3 como SALIDA para el PWM // Ponemos RD7 como SALIDA para el PWM

//NOTA EL DATASHEET DEL MICRO NOS DECIA QUE TENIAMOS QUE PONER ESTOS PINES COMO SALIDA.... //EN EL PIC NO ES NECESARIO.............

} void Configure_Serial_Communication(void) { UART1_Init(9600); Delay_ms(100); //Inizializa el modulo UART a 9600 bps //Retardo para que se estabilice el modulo //Transmitimos una cadena de prueba

UART1_Write_Text("Prueba"); }

void PWM_LABVIEW(void) //codigo de la subrutina { if (UART1_Data_Ready()==1) recibio algo... { //si llego algo dato = UART1_Read(); UART1_Write(dato); // le el dato y lo guarda en dato.... // y envia lo que llego... //Data_Ready se pone en 1 si hay datos en el buffer, es decir si ya

current_duty=(int)dato;//CAST //con estas dos lineas tenemos una comunicacion full duplex... PWM1_Set_Duty(current_duty); // le asignamos el ciclo de trabajo al pwm } } Raspberry Pi La raspberry pi es una computadora del tamao de una tarjeta de crdito, cuenta con un procesador ARM a 700MHz el cual se le puede realizar overclock para aumentar la frecuencia hasta 1GHz, tambin cuenta con un procesador grfico GPU videocore capaz de reproducir video hasta 1900x1080p full hd, 512 de memoria RAM y un GPIO de 26 pines. Cuenta con dos modelos, el tipo A y B, las caractersticas de hardware que tiene el tipo B es que cuenta con 2 puertos USB, salida de video RCA y HDMI, Salida de audio por un Jack de 3.5mm y HDMI, memoria RAM de 512, un puerto de Ethernet, una entrada microUSB tipo B para la alimentacin a 5V, una ranura SD y cuenta con un Soc de 700MHz con arquitectura ARM. El pecio de la raspberry pi tipo B es alrededor de $35dls. Para su compra, sus distribuidores oficiales son Newark.com y rscomponents.com

Figura 2. Hardware de la Raspberry PI La diferencia entre el tipo A y B radica en que el tipo A contiene solo un puerto USB, cuenta con 256 de memoria RAM y no cuenta con el puerto Ethernet (RJ45), en la Figura 3 se muestra un cuadro entre las diferencias de ambas tarjetas tipo A y B.

Figura 3. Especificaciones tcnicas

El puerto GPIO (General Purpose Inpu/outpu) permite la comunicacin con el exterior tanto para activar actuadores como para leer el estado de los mismos. Se tiene que tener cuidado ya que no tiene proteccin el puerto, ya que est directamente ligada con el chip del procesador. En la Figura 4 se muestra la configuracin de los pines del puerto GPIO

Figura 4. Configuracion de los pines GPIO

El sistema operativo arranca desde la tarjeta SD, ya que no cuenta con un disco duro para el almacenamiento, los sistemas operativos soportados son: Raspbian wheezy, que es derivado de la distribucin de Debian. ArchLinux Fedora Raspbcm Para obtener el sistema operativo se descargan desde este link: http://www.raspberrypi.org/downloads

Estos sistemas operativos estn especialmente distribuidos para el funcionamiento en la raspberry pi por su arquitectura ARM. Para la instalacin del SO se utiliza el software Win32 Disk Imager para Windows. http://sourceforge.net/projects/win32diskimager/

Entre los usos que se le puede dar a la Raspberry PI, es la de montar un Media Center, ya que es capaz de reproducir pelculas en HD ya sea instalando XBMC o a travs de distribuciones Linux que ya lo integran como RaspBMC u OpenElec. Se puede usar para el uso de una estacin meteorolgica Uso como un servidor NAS, se puede acceder a archivos de cualquier computadora, telfono celular o Tablet que est conectado a la red con la posibilidad de establecer una red pblica o privada para compartir archivos. Crear un servidor VPN para la conexin a internet de forma ms segura, por ejemplo conectarse a la computadora del hogar a travs de una red pblica, pero navegar por internet utilizando la conexin de tu casa en lugar de la red pblica el cual puede ser insegura. Uso en la domtica, para automatizar determinados lugares del hogar, por ejemplo el control del aire acondicionado, iluminacin ya sea de una habitacin o de la casa entera, control de sensores y actuadores. Acceder remotamente desde otro ordenador a la raspberry pi, se puede acceder por el protocolo SSH para interactuar con la raspberry pi desde otra computadora, a base de esto, la raspberry pi se puede dejar conectado a internet por Ethernet y controlarlo desde otra PC va remotamente. Mediante este acceso solo se podr controlar la terminal, para un acceso remoto grafico se puede realizar mediante VNC que es un servicio gratuito para Windows y Mac. Para la programacin del puerto GPIO se puede realizar utilizando diferentes lenguajes de programacin, como son C, C#, Java, Basic, Python, Perl, Pascal, etc. En este link se encuentra informacin sobre el manejo del puerto GPIO as como ejemplos de cada lenguaje de programacin para realizar un blinking de un led http://elinux.org/RPi_Low-level_peripherals Existe una librera el cual se llama wiringPI, donde se puede programar en C y C++ muy similar a Arduino, para su instalacin es mediante este link: https://projects.drogon.net/raspberry-pi/wiringpi/download-and-install/ Tambin est un software el cual se puede tener control del puerto GPIO de la raspberry pi a travs de un entorno web de modo remoto. El software es WebIOpi, para su uso es importante instalar webiopi en la raspberry pi, y desde cualquier computadora o Smartphone se puede tener control del GPIO, para esto es necesario escribir en el navegador la IP de la raspberry pi y seguido del puerto como se muestra en la Figura 4. Para evitarse el uso de escribir siempre la IP, existe la posibilidad de instalar No-IP en la raspberry pi el cual nos permite poner el nombre del dominio y

seguido del puerto, por ejemplo ya no sera necesario escribir 192.172.1.99:8000 con No -IP seria de manera ejemplo:8000

Figura 5. WebIOpi Tambin cuenta con la posibilidad de modificar el entorno grafico al que se accede remotamente ya sea desde una PC o celular, ya que es open source con licencia Creative Commons, http://code.google.com/p/webiopi/wiki/INSTALL Un punto importante es establecer una IP estatica a la Raspberry PI para tener una conexin ms sencilla de manera por ejemplo remota, un mtodo fcil de realizar es desde la terminal realizando estos pasos: Sudo nano /etc/network/interfaces Se abrir un archivo, el cual hay que editar la parte address donde se aade la IP deseada, Gateway para la puerta de enlace y netmask para la mscara. Para guardar el archivo es mediante ctrl+o y para salir es mediante ctrl+x