Introduccion a la programacion de PICS en lenguaje C (CCS)

[Tokes]

vetealdemonio:

La verdad me da flojera revisar la librería del teclado de CCS. Mejor te pongo una que me elaboré para no tener problemas a la hora de modificar.

Código [Seleccionar] Expandir

/***************** teclado.h ******************/
#byte    PORTA    =  getenv("sfr:PORTA")
#byte    TRISA    =  getenv("sfr:TRISA")

#byte    PORTB    =  getenv("sfr:PORTB")
#byte    TRISB    =  getenv("sfr:TRISB")

#byte    PORTC    =  getenv("sfr:PORTC")
#byte    TRISC    =  getenv("sfr:TRISC")

#byte    PORTD    =  getenv("sfr:PORTD")
#byte    TRISD    =  getenv("sfr:TRISD")

#byte    PORTE    =  getenv("sfr:PORTE")
#byte    TRISE    =  getenv("sfr:TRISE")

/***************************************/
#define  PORT_fila0     PORTC
#define  TRIS_fila0     TRISC
#define  fila0          0

#define  PORT_fila1     PORTC
#define  TRIS_fila1     TRISC
#define  fila1          1

#define  PORT_fila2     PORTC
#define  TRIS_fila2     TRISC
#define  fila2          2

#define  PORT_fila3     PORTC
#define  TRIS_fila3     TRISC
#define  fila3          3

#define  PORT_columna0  PORTC
#define  TRIS_columna0  TRISC
#define  columna0       4

#define  PORT_columna1  PORTC
#define  TRIS_columna1  TRISC
#define  columna1       5

#define  PORT_columna2  PORTC
#define  TRIS_columna2  TRISC
#define  columna2       6

#define  PORT_columna3  PORTC
#define  TRIS_columna3  TRISC
#define  columna3       7

/*************************************************/
#ifdef teclado_activoalto
  #define  es_activo(r,b)    bit_test(r,b)
  #define  activar(r,b)      bit_set(r,b)
  #define  desactivar(r,b)   bit_clear(r,b)
#else
#ifdef teclado_activobajo
  #define  es_activo(r,b)    !bit_test(r,b)
  #define  activar(r,b)      bit_clear(r,b)
  #define  desactivar(r,b)   bit_set(r,b)
#else
  #error "Debe declarar la lógica del teclado: activo alto o activo bajo"
#endif
#endif

/***************************************************/
void teclado_inicializa(void)
{
  // Inicializa los latches de salida para las filas.
  activar(PORT_fila0,fila0);
  activar(PORT_fila1,fila1);
  activar(PORT_fila2,fila2);
  activar(PORT_fila3,fila3);
 
  // Configura las filas como salidas.
  bit_clear(TRIS_fila0,fila0);
  bit_clear(TRIS_fila1,fila1);
  bit_clear(TRIS_fila2,fila2);
  bit_clear(TRIS_fila3,fila3);
 
  // Configura las columnas como entradas
  bit_set(TRIS_columna0,columna0);
  bit_set(TRIS_columna1,columna1);
  bit_set(TRIS_columna2,columna2);
  bit_set(TRIS_columna3,columna3);
}

void teclado_activafilas(void)
{
  activar(PORT_fila0,fila0);
  activar(PORT_fila1,fila1);
  activar(PORT_fila2,fila2);
  activar(PORT_fila3,fila3);
}

int8 teclado_examinacolumnas(void)
{
  if(es_activo(PORT_columna0,columna0)) return 0;
  if(es_activo(PORT_columna1,columna1)) return 1;
  if(es_activo(PORT_columna2,columna2)) return 2;
  if(es_activo(PORT_columna3,columna3)) return 3;
  return 4;
}

char teclado_lee(void)
{
  const char teclas[16]={'0', '1', '2', '3',
                         '4', '5', '6', '7',
                         '8', '9', 'A', 'B',
                         'C', 'D', 'E', 'F'};
  int8 i;
 
  teclado_activafilas();
  for(i=0; i<20; i++)
  {
     if(teclado_examinacolumnas()>3) return 0;
     delay_ms(1);
  }
 
  desactivar(PORT_fila3,fila3);
  desactivar(PORT_fila2,fila2);
  desactivar(PORT_fila1,fila1);
 
  if((i=teclado_examinacolumnas())<4) return(teclas[i]);
 
  desactivar(PORT_fila0,fila0);
  activar(PORT_fila1,fila1);
  if((i=teclado_examinacolumnas())<4) return(teclas[i+4]);
 
  desactivar(PORT_fila1,fila1);
  activar(PORT_fila2,fila2);
  if((i=teclado_examinacolumnas())<4) return(teclas[i+8]);
 
  desactivar(PORT_fila2,fila2);
  activar(PORT_fila3,fila3);
  if((i=teclado_examinacolumnas())<4) return(teclas[i+12]);
 
  desactivar(PORT_fila3,fila3);
  return 0;
}

void teclado_esperalibere(void)
{
  teclado_activafilas();
  while(teclado_examinacolumnas()<4);
}

Antes de incluir la librería debes declarar:

Código [Seleccionar] Expandir

#use delay(clock=xxxx)

También debes declarar previamente la lógica del teclado, por ejemplo:

Código [Seleccionar] Expandir

#define   teclado_activoalto

o el otro caso:

Código [Seleccionar] Expandir

#define   teclado_activobajo

Si en las columnas colocas resistencias de pullup (hacia Vcc) la lógica debe ser activo bajo. Si en las columnas colocas resistencias de pulldown (hacia GND) la lógica debe ser activo alto.

Todas y cada una de las filas y columnas son colocables en cualquier terminal de cualquier puerto.

Así, si colocas la fila 0 del teclado en la terminal RA5, la declaración debe quedar así:

Código [Seleccionar] Expandir

#define   PORT_fila0    PORTA
#define   TRIS_fila0   TRISA
#define   fila0      5

Para leer una tecla debes invocar a la función teclado_lee(). Esta función retornará un 0 binario (caracter nulo) si no hay tecla pulsada. En caso contrario retornará el código ASCII de la tecla pulsada.

Debes invocar la función teclado_esperalibere() para esperar que se libere la tecla y evitar leer varias veces la misma tecla.

Te dejo el siguiente programa de ejemplo:

Código [Seleccionar] Expandir

#include "16f877a.h"
#use     delay(clock=20M)
#define  teclado_activobajo
#include "teclado.h"
#define  use_portb_lcd
#include "lcd.c"

int main(void)
{
   char tecla;
   
   teclado_inicializa();
   lcd_init();
   
   while(1)
   {
      if(tecla=teclado_lee())
      {
         lcd_putc(tecla);
         teclado_esperalibere();
      }
   }
}
Nos vemos...

[krader]

Creo que me he equivocado y he puesto este mensage en el general de este for, cuando el sitio bueno sería este ya que trata de programación PIC C en CCS, si es así pido disculpas y si los moderadores creen conveniente que lo eliminen. Les propongo mi problema:

Hola a todos, soy nuevo en el foro pero os he leido mucho y he sacado buenas ideas de aquí. Ahora estoy haciendo un proyecto y me surge una duda:
Consiste en un medidor de velocidad, para ello tengo un sensor que manda un '1' cada vez que la rueda da una vuelta completa. Para saber la velocidad de la rueda necesito saber el tiempo que para entre dos '1' (es decir, una vuelta) pero no se cómo hacerlo. Mi primera idea es que cuande me de un '1' salte una interrupción y un contador se incremente. Al haber otro '1' volverá a saltar la interrupción y ese contador tendrña valor 2. Ahora necesito saber el tiempo que ha pasado entre ambas interrupciones para hacer los calculos de velocidad.
Espero que me puedan ayudar, Ah! es con una PIC 16F88 y en CCS!

Muchas gracias.

[skapunky]

Mira, tiene facil solución, espero que entienda el planteamiento.

Primero de todo, utiliza la libreria delay.h o create tu propia rutina de retardo con un tiempo que conozcas, por ejemplo de 1 segundo. Entonces mete la rutina del tiempo que cada segundo incremente una variable, dentro de un while que verifique que una variable no sea uno. Cuando sea uno haz que salga del while y cuenta cuanto a sumado el contador que se incrementa con el delay, sabras que cada incremento es de 1 segundo.

Te pongo aquí codigo para que te hagas una idea, lo programo aquí directamente:

int cont;
int sensor;

Void Interrupt_XX()
{
// Rutina de interrupción, para saber que salta interrupción
sensor = 1;
}

Void delay (void)
{
// Rutina de retardo, por ej 2 o 3 bucles anidados que sumen tiempo
}

Void main{
   while sensor=0 {
   delay();
   cont ++;
   }
sensor = 0;
}

Fijate que cont  se va incrementando (+1 segundo si delay es de 1 segundo) hasta que la variable sensor es 1, para ello ya tendras el tiempo contado en cont que es lo que necesitas. Espero que te aclares con el codigo y cojas la idea.

Por otro lado, porías utilizar los TMRx del pic, pero bueno, con que te crees tu propia funcion Delay() o utilizes delay.h ya bastará.

[krader]

Mira, tiene facil solución, espero que entienda el planteamiento.

Primero de todo, utiliza la libreria delay.h o create tu propia rutina de retardo con un tiempo que conozcas, por ejemplo de 1 segundo. Entonces mete la rutina del tiempo que cada segundo incremente una variable, dentro de un while que verifique que una variable no sea uno. Cuando sea uno haz que salga del while y cuenta cuanto a sumado el contador que se incrementa con el delay, sabras que cada incremento es de 1 segundo.

Te pongo aquí codigo para que te hagas una idea, lo programo aquí directamente:

int cont;
int sensor;

Void Interrupt_XX()
{
// Rutina de interrupción, para saber que salta interrupción
sensor = 1;
}

Void delay (void)
{
// Rutina de retardo, por ej 2 o 3 bucles anidados que sumen tiempo
}

Void main{
  while sensor=0 {
  delay();
  cont ++;
  }
sensor = 0;
}

Fijate que cont  se va incrementando (+1 segundo si delay es de 1 segundo) hasta que la variable sensor es 1, para ello ya tendras el tiempo contado en cont que es lo que necesitas. Espero que te aclares con el codigo y cojas la idea.

Por otro lado, porías utilizar los TMRx del pic, pero bueno, con que te crees tu propia funcion Delay() o utilizes delay.h ya bastará.

Gracias, es algo en que no había pensado. No me sirve del todo porque el programa hace más cosas a parte de calcular la velocidad y no puede estar el micro pillado esperando la salida del while en el caso de que la rueda no se mueva, pero me ha dado una idea que creo que me servirá. Llevo bastante tiempo usando pic para cosas sencillas, pero nunca nadie me ha enseñado y los TMR es algo que no comprendo, pero poco a poco.

de todas formas como me lié y repeti el post, pongo aqui el enlace al otro para dejar este libre y que no sea un lio. http://foro.elhacker.net/electronica/saber_el_tiempo_transcurrido_entre_interrupciones-t317969.0.html
Gracias amigo!

[ezquerra_makina]

Hola, tengo que pasar varias practicas de ensamblador a C y estoy lleno de dudas. el codigo en ensamblador si que lo tengo pero no sé muy bien como pasarlo...si me pudieseis ayudar, os dejo aquí el programa...

;*************************************************************************
;      TEMA_2.ASM
; Lector de datos digitales. El sistema visualizar  en el PORTD los datos
; digitales que se presenten mediante 8 interruptores en el PORTB. Estos
; datos se visualizar n si el bit menos significativo del PortA
; se encuentra activado, en caso contrario se apagar n todos los LEDs. 
;*************************************************************************

   LIST   P=16F877A   ; PIC16F877A microcontrolador utilizado

   INCLUDE   "P16F877A.INC"   


; Registros particulares del programa
TMP1   equ   0x20

; Constantes
W   equ      0
F   equ      1

;*************************************************************************
;      INICIO DEL PROGRAMA
;*************************************************************************
   org   00
   GOTO   START       ; Posición comienzo programa para                       simulador
   org      04
   GOTO   INT      ; Posici n comienzo interrupciones
   GOTO   START      ; Posici n comienzo programa para grabar

;*************************************************************************
;      INTERRUPCIONES
;*************************************************************************
INT:
   RETFIE            ; Fin de la interrupci n

;*************************************************************************
;      PROGRAMA PRINCIPAL
;*************************************************************************

START
   CLRF   INTCON      ; Eliminar posibles interrupciones
   BCF      STATUS,RP0   ; Banco 0 (asegurar)
   BCF      STATUS,RP1   ;
   
; Inicializaci n de puertos
   BSF      STATUS,RP0   ; Banco 1
   MOVLW   B'00111111'
   MOVWF   TRISA&7F   ; A5-A0 entrada
   MOVLW   B'00000111'
   MOVWF   ADCON1&7F   ; Puerto A digital
   MOVLW   B'11111111'
   MOVWF   TRISB&7F   ; B7-B0 entrada
   MOVLW   B'10111111'
   MOVWF   TRISC&7F   ; C5-C0 entrada, C7 y C6 reservados l nea serie
   MOVLW   B'00000000'
   MOVWF   TRISD&7F   ; D7-D0 salida
   MOVLW   B'00000000'
   MOVWF   TRISE&7F   ; E2-E0 salida
   BCF      STATUS,RP0   ; Banco 0

;*************************************************************************
;      BUCLE DEL PROGRAMA
;*************************************************************************

BUCLE

   MOVF   PORTA,W      ; Leer PORTA al acumulador
   MOVF   PORTC,W      ; Leer PORTB al acumulador
   MOVLW   B'10101100'

   BTFSS   PORTA,2      ; Test PORTA2
   GOTO    LEER_PORTC
   MOVLW   B'10101010'   ; Cargar dato inmediato al acumulador
   GOTO    ESCRIBIR_PORTC


LEER_PORTC:
   MOVF   PORTC,W      ; Leer PORTC al acumulador

ESCRIBIR_PORTC:
   MOVWF   PORTD      ; Escribir en PORTD

   GOTO   BUCLE
   
   NOP
   NOP
   NOP
   end

[tazmahv]

hola mi pregunta es la siguiente como y que tengo que usar para empezar com la programacion de pics  por que leo y leo y mas me lio

[andres_5]

Hola, encontre hace tiempo un blog de un hombre que explica bastante bien la forma de programar en C los pics, espero que te sirva de ayuda.
http://juan-ruiz-cespedes.over-blog.es/article-programacion-en-lenguaje-c-de-microcontroladores-65130649.html
Te adjunto tambien un video de un proyecto muy completo que vi hace 2 semanas y me gusto mucho:
[youtube=425,350]http://www.youtube.com/watch?v=tIKFdNMq9Cg[/youtube]

Saludos.

[tazmahv]

Hola, encontre hace tiempo un blog de un hombre que explica bastante bien la forma de programar en C los pics, espero que te sirva de ayuda.
http://juan-ruiz-cespedes.over-blog.es/article-programacion-en-lenguaje-c-de-microcontroladores-65130649.html
Te adjunto tambien un video de un proyecto muy completo que vi hace 2 semanas y me gusto mucho:
[youtube=425,350]http://www.youtube.com/watch?v=tIKFdNMq9Cg[/youtube]

Saludos.

gracias me pondre a estudirarlo

[tazmahv]

hola que es mas facil para uno que empieza en esta programar en c o en asm

[andres_5]

Ensamblador es mejor y vas a tener un control de 100% de tu pic, sin embargo en C creo que es mas facil de programar, Yo solo he programado en C, ASM no se programar, sin embargo Emsamblador orientado a MIPS es mas facil que el normal (Ese si he visto un poco) eso depende de las caracteristicas de tu microcontrolador (actualmente en esos campos estoy desinformado)

Saludos.