He ahí el detalle, me imagine que tenías algo de conocimientos ya.
/*
* File: MAIN.c
* Author: george
*
* Created on 4 de agosto de 2013, 07:06 PM
*/
#include<htc.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<plib/usart.h>
/////////////////////////////////////////////////////////////
//Configuracion para trabajar Con oscilador interno de 8Mhz
#pragma config OSCS = OFF, OSC = HSPLL
#pragma config BOR = OFF, BORV = 42, PWRT = ON
#pragma config WDTPS = 128, WDT = ON
#pragma config DEBUG = OFF, LVP = OFF, STVR = OFF
#pragma config CP0 = OFF, CP1 = OFF, CP2 = OFF, CP3 = OFF
#pragma config CPD = OFF, CPB = OFF
#pragma config WRT0 = OFF, WRT1 = OFF, WRT2 = OFF, WRT3 = OFF
#pragma config WRTB = OFF, WRTC = OFF, WRTD = OFF
#pragma config EBTR0 = OFF, EBTR1= OFF, EBTR2= OFF, EBTR3 = OFF
#pragma config EBTRB = OFF
//////////////////////////////
//Frecuencia FOSC 4Mhz x 4 PLL = 16 Mhz/4 = 4Mhz
//////////////////////////////
#define _XTAL_FREQ 4000000
struct{
unsigned flag_rx:1;
unsigned dumy:7;
}flags={0};
char data[25],i;
const char strings[6][20]={"COMANDO1\r",
"COMANDO2\r",
"COMANDO3\r",
"COMANDO4\r",
"COMANDO5\r",
"COMANDO6\r"};
void clear_string(){
for(char index=0;index<=sizeof(data);index++){
data[index]=0;
}
}
void get_string_rx(char *s){
do{
while(!DataRdyUSART());
*s=getcUSART();
}while(*s++!='\r');
}
void interrupts_enables(void){
INTCONbits.GIE=1;
INTCONbits.PEIE=1;
}
static void interrupt isr(void){
if(DataRdyUSART()){
flags.flag_rx=1;
get_string_rx(&data);
}
}
void periphericals_configuration(void){
TRISC=0X80;
//------------------------------------------------------------------
// Configuracion del USART
//------------------------------------------------------------------
OpenUSART(USART_TX_INT_OFF &//Interrupcion por Transmision apagado
USART_RX_INT_ON &//Interrupcion por Recepcion Apagado
USART_ASYNCH_MODE &//Modo Asincronico
USART_EIGHT_BIT &//8-bit de transmision
USART_CONT_RX &//Recepcion Continua
USART_BRGH_HIGH, //Alta velocidad de baudios
51); //para alta Velocidad:
//FOSC (16 x (spbrg + 1))
//spbrg=(FOS/baud*16)-1
//Para baja Velocidad:
//FOSC (64 x (spbrg + 1))
/*---------------------Fin de Conf. USART----------------------------*/
INTCONbits.GIE=1;
INTCONbits.PEIE=1;
}
void putch(char c){
/*Empty buffer?
*/
while(!TXSTAbits.TRMT) continue;
//load data into register to send
TXREG=c;
}
void main(void){
periphericals_configuration();
interrupts_enables();
while(1){
if(flags.flag_rx){
flags.flag_rx=0;
printf("%s",data);
for(unsigned char i=0;i<6;i++){
if(strcmp(data,&strings[i])==0){
printf("%s es igual que %s\n",data,&strings[i]);
break;
}
}
clear_string();
}
CLRWDT();
}
}
#pragma udata gpr1
char Cos[180];
#pragma udata
#pragma udata gpr2
char Sen[180];
#pragma udata#pragma udata MISECCION
char Cos[180];
char Sen[180];
#pragma udata
, con respecto a las secciones??
¿Y por que no lo haces por I2C? Es más fácil.
#ifndef MAIN_C
#define MAIN_C
#include <p18F4550.h>
#include <delays.h>
#include <usart.h>
#include <stdio.h>
#include <stdlib.h>
#include "xlcd1.h"
#pragma config PLLDIV = 5 // (20 MHz crystal on PICDEM FS USB board)
#pragma config CPUDIV = OSC1_PLL2
#pragma config USBDIV = 2 // Clock source from 96MHz PLL/2
#pragma config FOSC = HSPLL_HS //INTOSC_HS //INTOSCIO_EC //
#pragma config FCMEN = OFF
#pragma config IESO = OFF
#pragma config PWRT = OFF
#pragma config BOR = ON
#pragma config BORV = 3
#pragma config VREGEN = ON //USB Voltage Regulator
#pragma config WDT = OFF
#pragma config WDTPS = 32768
#pragma config MCLRE = ON
#pragma config LPT1OSC = OFF
#pragma config PBADEN = OFF
// #pragma config CCP2MX = ON
#pragma config STVREN = ON
#pragma config LVP = OFF
// #pragma config ICPRT = OFF // Dedicated In-Circuit Debug/Programming
#pragma config XINST = OFF // Extended Instruction Set
#pragma config CP0 = OFF
#pragma config CP1 = OFF
// #pragma config CP2 = OFF
// #pragma config CP3 = OFF
#pragma config CPB = OFF
// #pragma config CPD = OFF
#pragma config WRT0 = OFF
#pragma config WRT1 = OFF
// #pragma config WRT2 = OFF
// #pragma config WRT3 = OFF
#pragma config WRTB = OFF // Boot Block Write Protection
#pragma config WRTC = OFF
// #pragma config WRTD = OFF
#pragma config EBTR0 = OFF
#pragma config EBTR1 = OFF
// #pragma config EBTR2 = OFF
// #pragma config EBTR3 = OFF
#pragma config EBTRB = OFF
#pragma udata
void ISRRecepcion(void);
volatile char Kbhit;
volatile char Data;
#define REMAPPED_RESET_VECTOR_ADDRESS 0x1000
#define REMAPPED_HIGH_INTERRUPT_VECTOR_ADDRESS 0x1008
#define REMAPPED_LOW_INTERRUPT_VECTOR_ADDRESS 0x1018
//void YourHighPriorityISRCode();
void YourLowPriorityISRCode();
extern void _startup (void); // See c018i.c in your C18 compiler dir
#pragma code REMAPPED_RESET_VECTOR = REMAPPED_RESET_VECTOR_ADDRESS
void _reset (void){
_asm goto _startup _endasm
}
#pragma code REMAPPED_HIGH_INTERRUPT_VECTOR = REMAPPED_HIGH_INTERRUPT_VECTOR_ADDRESS
void Remapped_High_ISR (void) {
_asm goto ISRRecepcion _endasm //_asm goto YourHighPriorityISRCode _endasm
}
#pragma code REMAPPED_LOW_INTERRUPT_VECTOR = REMAPPED_LOW_INTERRUPT_VECTOR_ADDRESS
void Remapped_Low_ISR (void){
_asm goto YourLowPriorityISRCode _endasm
}
#pragma code HIGH_INTERRUPT_VECTOR = 0x08
void High_ISR (void) {
_asm goto REMAPPED_HIGH_INTERRUPT_VECTOR_ADDRESS _endasm
}
#pragma code LOW_INTERRUPT_VECTOR = 0x18
void Low_ISR (void){
_asm goto REMAPPED_LOW_INTERRUPT_VECTOR_ADDRESS _endasm
}
#pragma code
//#pragma interrupt YourHighPriorityISRCode
//void YourHighPriorityISRCode() {
//} //This return will be a "retfie fast", since this is in a #pragma interrupt section
// Rutina de Interrupcion.-
#pragma interrupt ISRRecepcion
void ISRRecepcion(void){
if(PIR1bits.RCIF==1){
Data=getcUSART(); // Leemos Dato recibido
Kbhit=1; // Indicamos que se ha recibido un dato.-
PIR1bits.RCIF=0; // Borramos bandera.-
}
}
#pragma interruptlow YourLowPriorityISRCode
void YourLowPriorityISRCode() {
} //This return will be a "retfie", since this is in a #pragma interruptlow section
#pragma code
void DelayFor18TCY(void){
Delay10TCYx(8);//8
}
void DelayPORXLCD(void){
Delay1KTCYx(49);//49
}
void DelayXLCD(void){
Delay1KTCYx(20);//20
}
/** DECLARATIONS ***************************************************/
/* UART Global variables */
char message;//men2; // Used for receiving commands from the computer
//unsigned char men[],i,len;
unsigned char Rxdata[11];
unsigned char Txdata[] = " PROBANDO_USART\n\r";
void main(void)
{
ADCON1 |= 0x0F;
//OSCCON=0x72; //EMPIEZA A CORRER A FOSC=8Mhz
// Set all of PORTC as outputs. TX and RX must be set as outputs first
TRISCbits.TRISC6=0; TRISCbits.TRISC7=1; //
//TRISC=0x00;
TRISD=0x00;
LATD=0;
// Configure UART //51 a 8mhz
OpenUSART(USART_TX_INT_OFF & USART_RX_INT_ON & USART_ASYNCH_MODE &USART_EIGHT_BIT & USART_CONT_RX & USART_BRGH_HIGH,311 ); //311 baud = 48000000/(16 x 312) = 9615
Kbhit=0; // 129 baud= 20mhz/(16x130) =9615
RCONbits.IPEN=0; // Deshabilitamos Prioridades
INTCONbits.PEIE=1; // Habilitamos interrupcion de perifericos.-
INTCONbits.GIE=1; // Habilitamos interrupcion Global.
PIE1bits.RCIE=1;
putrsUSART("Prueba Comunicacion Serial \n\r");
Delay1KTCYx(4);
while(1)
{
// while(Kbhit==0){}; // esperamos a recibir dato.-
// Kbhit=0;
LATDbits.LATD3=~PORTDbits.RD3;
//------USART Transmission ----
while(BusyUSART()); //Check if Usart is busy or not
putsUSART((char *)Txdata); //transmit the string
//---USART Reception ---
// while(!DataRdyUSART()); //sin interrupciones
while(Kbhit==0){}; // esperamos a recibir dato.-
Kbhit=0;
// getsUSART((char *)Rxdata,10); //Recieve data upto 24 bytes
message=getcUSART();
Delay10KTCYx(250);
// Delay10KTCYx(250);
// Delay10KTCYx(250);
// putsUSART((char *)Rxdata ); //transmit the string
putcUSART(message);
}
}
#endif...
He invito a otras personas a colaborar en la programacion de este compilador tanto de uso de librerias hechas para este lenguaje ASCII, para que fuera una gran ayuda para llegar a programar correctamente estos pic18 y entender mas porque de las cosas...
Ya que tengo unas cuantas dudas en la programacion...como son
*Como importar librerias o hacer librerias para nuestros programas
*intruccion de lcd : putrsXLCD(const char*buffer), no funciona en proteus(no aparece nada escrito)
....
while(*buffer) // Write data to LCD up to null
{
while(BusyXLCD()); // Wait while LCD is busy
WriteDataXLCD(*buffer); // Write character to LCD
buffer++; // Increment buffer
}
return;
