Microcursillo en C

[papauleti]

Hola!!

Soy principiante en esto de los PIC. Estoy empezando con las comunicaciones serie y consigo que imprima cadenas, pero no logro que las lea. Parece que no reconoce el retorno de carro porque se queda leyendo por mucho q le de al ENTER. No se si utilizo incorrectamente la función gets(). Este es el programa de prueba q estoy utilizando, a ver si es que estoy cometiendo metedura de pata tamaño camión y mis despistes no me dejan verlo

#include <16F876.h>
#include <stdio.h>
#use delay(clock=20000000)
#fuses NOWDT,HS, NOPROTECT, BROWNOUT, LVP

#use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7)

void main()
{

   int i=0;
   char cadena[]={"s", "e", "g", "u", "n", "d", "o", ""};


   setup_adc_ports(NO_ANALOGS);
   setup_adc(ADC_OFF);
   setup_spi(FALSE);
   setup_counters(RTCC_INTERNAL,RTCC_DIV_1);
   setup_timer_1(T1_DISABLED);
   setup_timer_2(T2_DISABLED,0,1);

  //PRimero compruebo la función puts() con constante y despues con array de char

   puts("
PRimer mensaje";
   puts(cadena);
   //Luego trato de probar la función gets() pero no llega a imprimir el
//segudno mensaje

   gets(cadena);
   puts("
Segundo mensaje";
   puts(cadena);

}

Seguire probando.

Gracias!!

[mariosaul]

Te recomiendo mejor usar la funcion fgets, aca te pongo su descripcion, es parecida a fgets, pero mas completa, tu le das un numero maximo de caracteres, para que asi finalice su ejecucion y continue tu programa, que asi como esta se queda esperando a que le llegue el carracter que marca el final del string

tengo un archivo con todas las funciones estandares de c, pero no se subirlo, si alguien lo quiere que de su mail.


suerte, avisanos como te anda el programa cuando resuelvas esto

--------------------------------------------------------------------------------------------------------
---------------------------------------Funcion fgets();---------------------------------------------
--------------------------------------------------------------------------------------------------------

fgets();
char *fgets (char *s, int n, FILE *flujo);
Lee caracteres por "flujo" y los almacena en elementos sucesivos del "array" que comienza en "s", continuando hasta que almacene "n-1" caracteres, almacene un carácter "NL" o ponga a 1 los indicadores de error o fin de fichero. Si almacena un carácter, concluye almacenando un carácter nulo en el siguiente elemento del "array". Devuelve "s" si almacena algún carácter y no ha puesto a 1 el indicador de error; en caso contrario, devuelve un puntero nulo.

[Ric555]

Hola a todos/as,

Prodíais poner algún ejemplo de como se usa el Timer del 16f84, es decir, como se activa, como se ve por donde va y como saber que ha parado.


Muchas gracias

[Nocturno]

Pues para no tener que hacerlo, pego a continuación el ejemplo que viene con CCS:

Codigo://///////////////////////////////////////////////////////////////////////
////                           EX_STWT.C                             ////
////                                                                 ////
////  This program uses the RTCC (timer0) and interrupts to keep a   ////
////  real time seconds counter.  A simple stop watch function is    ////
////  then implemented.                                              ////
////                                                                 ////
////  Configure the CCS prototype card as described below.           ////
////                                                                 ////
////  This example will work with the PCM and PCH compilers.  The    ////
////  following conditional compilation lines are used to include a  ////
////  valid device for each compiler.  Change the device, clock and  ////
////  RS232 pins for your hardware if needed.                        ////
/////////////////////////////////////////////////////////////////////////
////        (C) Copyright 1996,2003 Custom Computer Services         ////
//// This source code may only be used by licensed users of the CCS  ////
//// C compiler.  This source code may only be distributed to other  ////
//// licensed users of the CCS C compiler.  No other use,            ////
//// reproduction or distribution is permitted without written       ////
//// permission.  Derivative programs created using this software    ////
//// in object code form are not restricted in any way.              ////
/////////////////////////////////////////////////////////////////////////


#if defined(__PCM__)
#include <16F877.h>
#fuses HS,NOWDT,NOPROTECT,NOLVP
#use delay(clock=20000000)
#use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7)  // Jumpers: 8 to 11, 7 to 12

#elif defined(__PCH__)
#include <18F452.h>
#fuses HS,NOWDT,NOPROTECT,NOLVP
#use delay(clock=20000000)
#use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7)  // Jumpers: 8 to 11, 7 to 12
#endif

#define INTS_PER_SECOND 76     // (20000000/(4*256*256))

BYTE seconds;      // A running seconds counter
BYTE int_count;    // Number of interrupts left before a second has elapsed


#int_rtcc                          // This function is called every time
void clock_isr() {                 // the RTCC (timer0) overflows (255->0).
                                   // For this program this is apx 76 times
    if(--int_count==0) {           // per second.
      ++seconds;
      int_count=INTS_PER_SECOND;
    }

}


void main() {

   BYTE start;

   int_count=INTS_PER_SECOND;
   set_timer0(0);
   setup_counters( RTCC_INTERNAL, RTCC_DIV_256 | RTCC_8_BIT);
   enable_interrupts(INT_RTCC);
   enable_interrupts(GLOBAL);

   do {

      printf("Press any key to begin.
";
      getc();
      start=seconds;
      printf("Press any key to stop.
";
      getc();
      printf("%u seconds.
",seconds-start);

   } while (TRUE);

}

En un 16F84 tendría que funcionar igual.
En el programa, ves cómo se activa (Setup_counters y set_timer).
Para ver por donde va en cualquier momento, tendrías que usar get_timer.
Y pararse, no para nunca. En realidad lo que hace es que al llegar a 256 desborda y lanza la interrupción #int_rtcc.

[Amarice_BA]

A ver qué os parece.
He puesto ??? en las partes que no sé muy bien cómo funcionan o para qué sirven. Si me podeis decir...
Lo he compilado y no da errores.
Soy novato en esto por eso quisiera que me dijerais dónde he metido la pata.
Gracias.

Codigo:
///  Descripcion

///  1. Comunica con DAC, saca un valor (400) y enciende led correspondiente
///  2. Espera dos minutos
///  3. Comunica con DAC, saca un valor (340) y enciende led correspondiente
///  4. Espera a las entradas: conmutador de tres posiciones (arriba, inicial, abajo)
///  5. Arriba: Comunica con DAC, saca un valor superior y enciende led correspondiente
///     Abajo: Comunica con DAC, saca un valor inferior y enciende led correspondiente



/// Configuracion ///


#include <16F87.h>  // Libreria del pic

#fuses HS,NOPUT,NOWDT,NOWRT,NOPROTECT,NOLVP,NOBROWNOUT  // Fusibles ???

#use delay(clock=20000000)                               // Velocidad reloj
#use I2C(MASTER,SDA=PIN_B1,SCL=PIN_B4,SLOW,RESTART_WDT)  // Comunicacion serie ???

#use fast_io(B)  // Da por buena la configuaracion del puerto B
#use fast_io(A)  // Da por buena la configuaracion del puerto A

#byte port_a=5  // ???
#byte port_b=6  // ???

port_a_pullups(FALSE);  // Desactiva pull-ups del puerto A
port_b_pullups(FALSE);  // Desactiva pull-ups del puerto B



/// Programa Principal ///


void main()

    {


    // Declaracion de Variables

    int nivel;
    int const dac_alta[6]={0x38,0x39,0x39,0x3A,0x3B,0x3C};
    int const dac_baja[6]={0x00,0x6A,0xFD,0xAB,0x6E,0x4F};


    // Configura puertos

    set_tris_b(0x00);       // Puerto B configurado como salida

    output_b(0x00);         // Limpia B

    set_tris_a(0x02);       // Puerto A configurado RA6 y RA7 como entrada y el resto como salida

    output_a(0x00);         // Limpia A


    // Inicio

    nivel=0x00;
  
    output_low(PIN_B0);  // Comunica con DAC

    i2c_start();
    i2c_write(dac_baja[nivel]);
    i2c_write(dac_alta[nivel]);  // Saca el valor para 400V
    i2c_stop();

    port_a=nivel;  // Enciende el led rojo de RA0

    nivel++;


    delay_ms(120000);  // Espera 2 minutos


    output_low(PIN_B0);  // Comunica con DAC

    i2c_start();
    i2c_write(dac_baja[nivel]);
    i2c_write(dac_alta[nivel]);  // Saca el valor para 340V
    i2c_stop();

    port_a=nivel;  // Enciende el led amarillo de RB1


    while(input(PIN_A6) || input(PIN_A7));  // Espera si el conmutador no está en posición inicial


    while(TRUE)  // Bucle infinito

        {

        if((nivel>1) && (input(PIN_A6))) // Si no esta dando el máximo y el conmutador arriba

            {

            nivel++;

            output_low(PIN_B0);  // Comunica con DAC

            i2c_start();
            i2c_write(dac_baja[nivel]);
            i2c_write(dac_alta[nivel]);
            i2c_stop();

            port_a=nivel;  // Enciende el led amarillo del nivel correspondiente

            while(input(PIN_A6));  // Espera a que el conmutador pase a posición inicial

            }



        if((nivel<5) && (input(PIN_A7))) // Si no esta dando el minimo y el conmutador abajo

            {

            nivel--;

            output_low(PIN_B0);  // Comunica con DAC

            i2c_start();
            i2c_write(dac_baja[nivel]);
            i2c_write(dac_alta[nivel]);
            i2c_stop();

            port_a=nivel;  // Enciende el led amarillo del nivel correspondiente

            while(input(PIN_A7));  // Espera a que el conmutador pase a posición inicial

            }


        }


    }

[Amarice_BA]

Creo que lo he mejorado. ¿Cómo lo veis?

Codigo:
///  Descripcion del programa
///  1. Comunica con DAC, saca un valor (400) y enciende led correspondiente
///  2. Espera dos minutos
///  3. Comunica con DAC, saca un valor (340) y enciende led correspondiente
///  4. Espera a las entradas: conmutador de tres posiciones (arriba, inicial, abajo)
///  5. Arriba: Comunica con DAC, saca un valor superior y enciende led correspondiente
///     Abajo: Comunica con DAC, saca un valor inferior y enciende led correspondiente
/// Configuracion ///
#include <16F87.h>  // Libreria del pic
#fuses HS,NOPUT,NOWRT,NOPROTECT,NOLVP,NOBROWNOUT  // Fusibles
#use delay(clock=20000000)              // Velocidad reloj
#use I2C(MASTER,SDA=PIN_B1,SCL=PIN_B4)  // Comunicacion serie
#use fast_io(B)  // Da por buena la configuaracion del puerto B
#use fast_io(A)  // Da por buena la configuaracion del puerto A
/// Programa Principal ///
void main()
    {
    // Declaracion de Variables
    int nivel;
    int const tension[6]={0x1800,0x196A,0x19FD,0x1AAB,0x1B6E,0x1C4F};
    // Configura puertos
    set_tris_b(0x00);       // Puerto B configurado como salida
    output_b(0x00);         // Limpia B
    set_tris_a(0x02);       // Puerto A configurado RA6 y RA7 como entrada y el resto como salida
    output_a(0x00);         // Limpia A
    // Inicio
    nivel=0x00;
    output_low(PIN_B0);  // Comunica con DAC
    i2c_start();
    i2c_write(tension[nivel]>>;  // Escribe la parte alta del dato (400)
    i2c_write(tension[nivel]);     // Escribe la parte baja del dato (400)
    i2c_stop();
    output_a(nivel);  // Enciende el led rojo de RA0
    nivel++;
    delay_ms(120000);  // Espera 2 minutos
    output_low(PIN_B0);  // Comunica con DAC
    i2c_start();
    i2c_write(tension[nivel]>>;  // Escribe la parte alta del dato (340)
    i2c_write(tension[nivel]);     // Escribe la parte baja del dato (340)
    i2c_stop();
    output_a(nivel);  // Enciende el led amarillo de RB1
    while(input(PIN_A6) || input(PIN_A7));  // Espera si el conmutador no está en posición inicial
    while(TRUE)  // Bucle infinito
        {
        if((nivel>1) && (input(PIN_A6))) // Si no esta dando el máximo y el conmutador arriba
            {
            nivel++;
            output_low(PIN_B0);  // Comunica con DAC
            i2c_start();
            i2c_write(tension[nivel]>>;  // Escribe la parte alta del dato
            i2c_write(tension[nivel]);     // Escribe la parte baja del dato
            i2c_stop();
            output_a(nivel);  // Enciende el led amarillo del nivel correspondiente
            while(input(PIN_A6));  // Espera a que el conmutador pase a posición inicial
            }
        if((nivel<5) && (input(PIN_A7))) // Si no esta dando el minimo y el conmutador abajo
            {
            nivel--;
            output_low(PIN_B0);  // Comunica con DAC
            i2c_start();
            i2c_write(tension[nivel]>>;  // Escribe la parte alta del dato
            i2c_write(tension[nivel]);     // Escribe la parte baja del dato
            i2c_stop();
            output_a(nivel);  // Enciende el led amarillo del nivel correspondiente
            while(input(PIN_A7));  // Espera a que el conmutador pase a posición inicial
            }
        }
    }

[albert.fabregat]

Buenas Hace poco que he empezado con esto de la programación de PIC"s  y he programado una cosilla que alomejor os parece interesante, es mi primer aplicación realizada para un PIC y alomejor hay gente que le parece interesante. Os pego aquí el codigo. Es un pequeño ejemplo de utilización de EEPROM externas y cadenas de caracteres, el circuito esta probado con PROTEUS y funciona a la perfección.

Codigo:
//*******************************************************************//
// Nombre      : Strings.c
// Autor       : Albert Fabregat Hernando (|RooT|)
// Descripción : Manejo de cadenas de caracteres (Strings) y
//               su almacenamiento en EEPROM
//
//*******************************************************************//

#include <16F876.h>   // Utilizaremos en PIC16F76

#fuses HS,NOWDT,NOPROTECT,NOLVP,NOBROWNOUT  // Fusibles

#use delay(clock=10000000)  // Velocidad del cristal

#define use_portb_lcd TRUE // Para usar el puerto B en este PIC ya que no tiene D

#include "lcd.c"  // Librería para el manejo del lcd.

#include <2416.c> // Librería para el manejo de la EEPROM 24LC16B
                  // Se ha cambiado por
                  // #define EEPROM_SDA  PIN_C4
                  // #define EEPROM_SCL  PIN_C3

#use fast_io(B)   //Para hacerlo FAST el port B


#define MAX_CADENA 32 //Una cadena de 32bytes como MAXIMO

//Rutinas para el LCD


void borra_lcd()

   {

   lcd_putc("f";  // Con esta instrucción borramos el lcd

   }


// Esto nos muestra en forma de LETRERO una cadena de caracteres (STRING)
void letrero(char *s)
{
      delay_ms(100);  // Retardo de un 100 ms

      do{
       printf(lcd_putc,"%c",*s);
       delay_ms(50);  // Retardo de un 50 ms para las letras

      }
      while(*s++);

}


// Rutinas para el manejo de la EEPROM

//Esto nos guarda una cadenad de caracteres empezando por una posición de memoria

void guarda_string_en_rom(char *s,int d)
{

      borra_lcd();
      printf(lcd_putc,"Guardando en %u",d);

      do{
       write_ext_eeprom(d++,(byte)*s);
      }
      while(*s++);

      write_ext_eeprom(d,0);    //OJO!! Ponemos un 0 al final de la cadena para
                               //que sepa cuando acaba la cadena.
      borra_lcd();
}

//Esto nos devuelve la cadena que hay en la posición que pongamos
//OJO!! Las cadenas tienen que acabar en  si no la reconocera y podria morir

char *lee_string_de_rom(int d)
{
char tmp[MAX_CADENA];
int i=0;

      borra_lcd();
      printf(lcd_putc,"Leyendo en %u",d);

      do{
         if(i==MAX_CADENA)break; //BUG_FIX: Solucionado para que no muera si
                                 //no encuentra un  antes de MAX_CADENA
         tmp[ i ]=read_ext_eeprom(d++);
      }while(tmp[i++]);

      borra_lcd();
      
return tmp;
}


// El programa principal

void main()

   {

   char str[MAX_CADENA];  //Cadena que queremos GUARDAR
   char rstr[MAX_CADENA]; //Cadena que vamos a LEER


   set_tris_B(0b00000000); // Configuramos PORT_B como salida
   port_b_pullups(FALSE);  // Desactivamos pull-ups del puerto B

   init_ext_eeprom();      //Iniciamos la EEPROM
   lcd_init();             //Iniciamos el LCD


   strcpy(str,"*** Fabre ***"; //Copiamos la cadena a STR

   guarda_string_en_rom(str,0); //Guarda la cadena en la EEPROM
   
   strcpy(rstr,lee_string_de_rom(0));  //Leemos la CADENA de la EEPROM
                                       //y la guardamos en RSTR

   letrero(rstr);


   for( ; ; )  // Esto se ejecuta de forma indefinida.

     {
     }

   }

[Modulay]

Albert,si te parece bien,podemos colgar tu programa junto con su archivito Proteus en un espacio que tenemos reservado para ejemplos C para pic:

http://personal.auna.com/asencio5/Ejemplos%20C/

Hay ejemplos diversos,pero para uso de eeprom externa no tenemos ninguno ¿qué te parece?

[albert.fabregat]

EDITADO:  Pues si, no me importa, todo lo contrario. Ahora ZIPEO el proyecto en PROTEUS y lo subo. Es posible subir ficheros al FORO? Es decir funciona la opción UPLOAD? O lo envio a algun mail en particular?


Gracias

La verdad es que es toda una gozada poder usar punteros sobre todo a la hora del manejo de caracteres. Estoy haciendo otras cosillas que cuando las tenga y funcionen las pongo aquí, por si a alguién le sirve de algo. Por ejemplo para poder manejar varias memorias EEPROM a la vez.

[hhpp]

hola a todos, soy nuevo quisiera que me ayuden ya que el compilador que manejo es un tanto diferente y me he esta costando bastante aprenderlo, quiero utilizar un lcd con 8 bit de datos, la visualizacion sera  "HOLA" y ya le di vueltas y vueltas y no encuentro que esta mal opor favor si me ayufdarian.
#include  <pic.h>
#include  "delay.h"
void DelayMs(unsigned char cnt);
void lcd_escribeme(unsigned  char pos,unsigned char linea,unsigned char b);
void lcd_write(unsigned char c);
void lcd_init(void);

static bit LCD_RS @ ((unsigned)& PORTA*0);
static bit LCD_EN @ ((unsigned)& PORTA*2);
#define LCD_STROBE   ((LCD_EN=1),(LCD_EN=0))
void main()
{ TRISA=0;
  TRISB=0;
  ADCON1=7;
  lcd_init();
  lcd_escribeme(1,0,"H");
  lcd_escribeme(2,0,"O");
  lcd_escribeme(3,0,"L");
  lcd_escribeme(4,0,"A");
}
void lcd_init(void)
{ LCD_RS=0;
  DelayMs(15);
  PORTB=0x3;
  LCD_STROBE;
  DelayMs(5);
  LCD_STROBE;
  DelayUs(100);
  LCD_STROBE;
  DelayMs(5);
  lcd_write(0x38);
  lcd_write(0x08);
  lcd_write(0x0C);
  lcd_write(0x06);
}
 
void lcd_write(unsigned char c)
{
 PORTB=((PORTB & 0xF0)|c);
 LCD_STROBE;
 PORTB=((PORTB & 0xF0)|c);
 LCD_STROBE;
 DelayUs(40);
}
void lcd_escribeme(unsigned char pos,unsigned char linea,unsigned char c)
{
 LCD_RS=0;
 PORTB=128 + (linea*0x40) +pos;
 LCD_STROBE;
  DelayUs(40);
 LCD_RS=1;
 PORTB=c;
 LCD_STROBE;
 DelayUs(120);
}
 
void DelayMs(unsigned char cnt)
{
 #if   XTAL_FREQ<=2MHZ
       do {
            DelayUs(996);
          } while(--cnt);
 #endif
 #if XTAL_FREQ > 2MHZ
    unsigned char i;
    do { i=4;
        do{
            DelayUs(250);
          } while(--i);
       } while(--cnt);
#endif
}    
 
Aproposito manejo pic C de hitech

Grcias de antemano.

[tocaja]

Hola amigos:
Me he empapado de todo el curso en un tiempecito, y reconozco que esta super currado , y es muy didactico. Soy novato en el manejo de micros, aunque ya habia tenido algun contacto con el lenguaje C. Aqui van mis dudas:

1. Estoy empleando el CCS versión ID 3.40, y en todos los programas que habeis puesto en el curso obtengo el mismo error "MISSING #ENDIF", y por más que lo miro no se que es lo que falla.

2. Empleando alguno de vuestros programas he hecho este, cuya mision es leer un valor analógico y visualizarlo en un LCD. Esta bien??? Debido a que tengo el problema con el compilador no e podido ver si tiene mas errores.

//Convierte señal analógica en RA0
//La saca por un LCD

#include <16F876.h>   // Dispositivo a utilizar
#device adc=8         // Resolución de 8 bits para el conversor ADC
#fuses HS,NOWDT,NOPROTECT,NOLVP,NOBROWNOUT  // Fusibles
#use delay(clock=10000000)  // Velocidad del cristal
#define use_portb_lcd TRUE
#include "lcd.c"  // Librería para el manejo del lcd
#use fast_io(B)  //optimiza código

const float ganancia=0.2045;

void main(void)
 {
 float entrada; // entrada es el valor analogico que entra al A/D
 float salida;  // salida es el valor que quiero se vea en el LCD
 set_tris_A (0xFF); // Puerto A configurado como entrada
 set_tris_B(0x00); //Puerto B configurado como salida
 port_b_pullups(FALSE);  // Desactivamos pull-ups del puerto B
 setup_adc(adc_clock_div_32); //Enciende ADC
 setup_adc_ports(RA0_ANALOG); //Configura A0 como entrada analógica
 set_adc_channel(0); // Seleccionamos el canal 0 (RA0)
 delay_us(20);
 lcd_init(); //Inicia LCD
 lcd_putc("    MEDIDOR
"; //Saca texto
 lcd_putc("     DE CAMPO"; //Saca texto
 delay_ms(3000);
 lcd_putc("f"; //Limpia pantalla
 lcd_putc(" CAMPO ACTUAL"; //Saca texto
 delay_ms(1000);
 lcd_gotoxy(9,2); //Acomoda cursor LCD
 lcd_putc("OERSTED";
 while (1)
      {
      lcd_gotoxy(0,2);   //Acomoda cursor LCD
      lcd_putc("         ";   //Limpia ese sector de pantalla
      lcd_gotoxy(0,2);   //Acomoda cursor LCD
      entrada=read_adc(); //Capturamos señal analógica que entra por el canal previamente seleccionado (RA0)
      salida=entrada*ganacia;
      printf(lcd_putc,"%2.2f",salida)   // Mostramos en el lcd el contenido de la variable "salida"
      delay_ms (1000000);  // Medidas cada 10 segundos
      }
 }

3. Ahora haber si me podais contestar a estas dudas que tengo sobre los micros, pues como ya mencioné es mi primera experiencia con ellos:

         3.1. Que ventajas tiene el pic16F876 que veo que es muy utilizado????
         3.2. Que son las resistencias pull-ups?
         3.3. Que son los fusibles?
         3.4. Es necesario para utilizar un micro emplear el citado cristal???

(quiza estas preguntas prefirais que las comente en el general, es asi??)

Muchas gracias, seguid así cracks

[tocaja]

Vale, he solucionado el primer punto bajandome una version posterior del compilador CCS. Ahora intento simular con proteus, pero no consigo que funcione, veis algun fallo grave en el programa?? gracias

[gallegol13]

Una pregunta muy tonta es que acabo de empezar y no se que es exactamente eso de los fusible cuando se pone

#fuses HS,NOWDT,NOPROTECT,NOLVP


gracias chic@s

[Nocturno]

Los fuses son bits de configuración del micro y vienen explicados en la data de cada micro.
Los que tú has puesto en tu ejemplo son:
-HS: High Speed Crystal. Se suele usar con cristales de más de 4MHz
-NOWDT: No WatchDog. Desactiva el perro guardián.
-NOPROTECT: No proteger el código. Permite que pueda leerse el programa
-NOLVP: No Low Voltage Program. Impide que el micro pueda grabarse en modo de bajo voltage.

[hhpp]

Hola a  Todos, queria preguntales si me podrian ayudar a resolver algunos problemillas, lamentablemente no manejo el compilador del curso, pero si pueden denme una mano, estoy con PIC C de hitech, por favor si alguien podria ayudarme o decirme donde ir a buscar le agradeceria mucho.

Gracias por todo.