Haz una pregunta
  Foros de Electrónica » Diseño digital » Microcontroladores y sistemas embebidos
Foros Registrarse ¿Olvidaste tu contraseña?

Temas similares

22/04/2013 #41


en este tutorial dan un ejemplo para controlar un teclado matricial en c18
28/06/2013 #42


Hola Gente !!! Alguien tiene idea de como hacer que en un pic 18Fxxxx que en un puerto x tenga un pulsador y en otro puerto x tenga por ejemplo un led y al apretar el pulsador este led prenda por 1 o mas minutos? Yo aprendi a hacer funcionar este mini proyecto usando "delays" pero la idea es usar los TIMER.
Tambien me gustaria usar el C18 Compiler, si alguien tiene una idea por fabor que me la diga estare eternamente agradecido ya que es un proyecto que quiero hacer para presentar en el instituto en el que empece a estudiar C18 hace unos meses.
Desde ya muy agradecido a todos y todas.
Saludos
28/06/2013 #43
Moderador

Avatar de D@rkbytes

Te muestro una opción, quizás este programa te sirva Timer1 1 segundo Base

En ese programa se usa un cristal para el TMR1, pero también se puede hacer el conteo internamente.

Saludos.
28/06/2013 #44


Gracias por tu rapida respuesta pero como soy nuevo en esto de la programacion C te hago una consulta sobre el codigo que me pasaste, dicho codigo esta formulado en CCS ahora tengo entendido que no es tan simple pasarlo a C18 en el que pretendo usar un pic 18Fxxx.
Si estoy equivocado te pido disculpas de antemano.
En la ciudad donde vivo no encontre otro curso mas que el de C18 Compiler y por lo que veo en la web no hay mucha data como asi para CCS, pero es lo unico que encontre para poder estudiar algo.
Muchas gracias por tu atencion y espero tu ayuda si no es mucha molestia.
Un abrazo.
28/06/2013 #45
Moderador

Avatar de D@rkbytes

Marquitos RR dijo: Ver Mensaje
Gracias por tu rapida respuesta pero como soy nuevo en esto de la programacion C te hago una consulta sobre el codigo que me pasaste, dicho codigo esta formulado en CCS ahora tengo entendido que no es tan simple pasarlo a C18 en el que pretendo usar un pic 18Fxxx.
Si estoy equivocado te pido disculpas de antemano.
En la ciudad donde vivo no encontre otro curso mas que el de C18 Compiler y por lo que veo en la web no hay mucha data como asi para CCS, pero es lo unico que encontre para poder estudiar algo.
Muchas gracias por tu atencion y espero tu ayuda si no es mucha molestia.
Un abrazo.
He ahí el detalle, me imagine que tenías algo de conocimientos ya.
Cómo quiera si te fijas bien en el código, se puede hacer uso de los registros unicamente.

Ese programa lo he realizado en Ensamblador, en PICC de CCS, en PICBasic Pro, y en PICBasic de Proton.
Así que, si le echas un poco de cabeza lo podrás migrar a C18 fácilmente.

Suerte.
11/08/2013 #46

Avatar de george.manson.69

Hi tech Function 'Compare'
Este codigo es simple, solo trata de realizar comparaciones entre lo que escribes y lo que debe de ser, usando el compilador HiTech.

Saludos!

Código:
/* 
 * 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();
    }
    
    
}
Archivos Adjuntos
Tipo de Archivo: zip Sim.zip (13,8 KB (Kilobytes), 12 visitas)
15/09/2013 #47

Avatar de BKAR

Consulta!:
jugando con arreglos grandes,
solo declararlos..

compila sin errores...
Código:
#pragma udata gpr1
char Cos[180];
#pragma udata
#pragma udata gpr2
char Sen[180];
#pragma udata
pero seria mejor...,
Código:
#pragma udata MISECCION
char Cos[180];
char Sen[180];
#pragma udata
lo cual me tira error...

hay algo que pase por alto :( , con respecto a las secciones??
11/11/2013 #48


hago una consulta alguien tiene un ejemplo simple escribir y leer una eeprom 24lc256 por spi con pic 18f4550 o similar ya que uso el usb en C18.
Desde ya muy agradecido.
12/11/2013 #49
Moderador

Avatar de D@rkbytes

alberto0265 dijo: Ver Mensaje
hago una consulta alguien tiene un ejemplo simple escribir y leer una eeprom 24lc256 por spi con pic 18f4550 o similar ya que uso el usb en C18.
Desde ya muy agradecido.
¿Y por que no lo haces por I2C? Es más fácil.
En el Foro de Microchip existen algunos ejemplos para C18.
También puedes buscar las notas de aplicación y los ejemplos en Microchip Application Notes Home

Suerte.
12/11/2013 #50


Gracias por contestar D@rkbytes .
Buscare por donde dices.
19/11/2013 #51


hola nuevamente por aqui para hacer una nueva consulta,ya consegui unas librerias para leer y escribir una eeprom 24lc256.
si yo uso una configuracion de fuses para trabajar con cristal de 20 mhz y usando comunicacion usb el micro 18f4550 corre a 48 mhz declarando lo siguiente como esta en este post (//Fuses para trabajar con 8Mhz/////////
#pragma config FOSC = INTOSCIO_EC //usamos 8Mhz internos)
el micro correria a 8 mhz para tener el sspadd=4 y poder hacer la comunicacion i2c sin problemas.
un abrazo para todos.
28/11/2013 #52


Ya esta solucionado mi probleman aclaro que no es necesario configurar #pragma config FOSC=INTOSCIO_EC.Simplemente en el main se coloca OSCCON=0x72; //EMPIEZA A CORRER A FOSC=8Mhz
Por que el micro esta trabajando con dos clock el modulo USB a 48MHZ a patir del cristal (20mhz en mi caso) y la CPU a 8MHZ. Saludos
06/01/2014 #53


vuelvo a consultar sobre una comunicacion serie usart entre pc y un pic18f4550.
lo tengo funcionando tanto con interrupcion y sin ella tambien pero con el oscilador interno a 8mhz.
SPBRG=51
con SPBRG=311 calculado para 48mhz no funciona,como se puede lograr si alguien lo hiso.
Código:
#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
saludos

---------- Actualizado después de 3 horas ----------

Ya lo solucioné, pido disculpas pero hace días que estoy investigando después que publiqué el pedido seguí buscando y se solucionó en la búsqueda.
Aprovecho para desasnar; hay que calcular BGRH_LOW( USART_BRGH_LOW,77 );
Dicho 77 es para transmitir a 9600 baud.
Nuevamente saludos
15/06/2014 #54

Avatar de BKAR

george.manson.69 dijo: Ver Mensaje

...
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)
....
Yupi!!
la verdad no comprendi del todo como define los tipos de dato el C18, en especial los tipo
--> (const rom char *)
dentro de las funciones...

entonces justamente en la funcion putrsXLCD() comparandola con la funcion putsXLCD(),
las definicion de la funcion practicamente identicas para ambas funciones

Código:
        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;
copy paste del archivo .c
solo cambiaban las deficiones de entrada..
void putrsXLCD(const rom char *buffer)
void putsXLCD(char *buffer)

los misma declaracion en los prototipos de funciones en el archivo xlcd.h
nada del otro mundo.. todo entendible.. porque no aparece nada en proteus con la funcion putrs??

mi curiosidad me llevo a investigar otros putrsXXX... como en putrsUSART()
pero encontre una variante en el archivo USART.h
el prototipo estaba declarado como:
void putrsUSART ( const MEM_MODEL rom char *data);
mientras que en xlcd.h:
void putrsXLCD(const rom char *) ;

que hace la diferencia MEM_MODEL? ni idea...

tan solo cambie el archivo xlcd.h...
en el prototipo
void putrsXLCD(const MEM_MODEL rom char *) ;
y eso es todo.. funciona como deberia.

sera que las versiones del C18 modificaron algo y se olvidaron de corregir las librerias?
la fecha de mi arhcivo original usart.h es del 2013, pero xlcd.h es del 2009.

uso la version C18 3.47 que habra pasado jeje, no importa con ese cambio de soluciona.
modificar xlcd.h
void putrsXLCD(const rom char *) ; ---> void putrsXLCD(const MEM_MODEL rom char *) ;
Respuesta
¿Tienes una mejor respuesta a este tema? ¿Quieres hacerle una pregunta a nuestra comunidad y sus expertos? Registrate

Foros de Electrónica » Diseño digital » Microcontroladores y sistemas embebidos

Powered by vBulletin® Version 3.8.4
Copyright ©2000 - 2017, Jelsoft Enterprises Ltd.
Search Engine Optimization by vBSEO ©2011, Crawlability, Inc.