TODOPIC

Microcontroladores PIC => Lenguaje C para microcontroladores PIC => Mensaje iniciado por: Nocturno en 04 de Agosto de 2004, 10:42:00

Título: Microcursillo en C
Publicado por: Nocturno en 04 de Agosto de 2004, 10:42:00

Escrito originalmente por pocher
El que lo desee que habrá un Microcursillo en C.

Bueno, pues yo lo deseo. ¿Por dónde empezamos Oh Gran Pocher?

Título: RE: Microcursillo en C
Publicado por: Modulay en 04 de Agosto de 2004, 10:44:00

Yo me apunto!!!

Título: RE: Microcursillo en C
Publicado por: pocher en 04 de Agosto de 2004, 11:01:00

Eh, eh que si no lo abrí yo fué precisamente por esto, para no hacerme responsable je, je.

Yo iré ayudando en lo que pueda pero la dirección y escritura de los programas tendran que ser otros.

¿Quién escribe un programa que haga parpadear un LED?

Título: RE: Microcursillo en C
Publicado por: Nocturno en 04 de Agosto de 2004, 11:04:00

Claro, no te vamos a pedir que también escribas tú los programas. Venga, me pongo con lo del LED y a ver qué sale. Hasta pronto.

Título: RE: Microcursillo en C
Publicado por: Nocturno en 04 de Agosto de 2004, 16:12:00

Bueno, hoy estoy trabajador

. Aquí está mi ejemplo de parpadeo de leds en C.

Curiosamente es mi primer programa en C y no dice aquello de "Hello world", pero bueno, espero que sirva.

Lo he probado en Proteus y funciona, aunque supongo que se podrá depurar tanto el algoritmo como la apariencia; no sé qué estilo de sangrados se utiliza más cómodamente en C. La verdad es que es un lío tanto corchete y puntos y comas.

Codigo:
/////////////////////////////////////////////////////////////////////////
////                           PARPADEO                              ////
////                                                                 ////
////  Ejemplo de parpadeo de todos los leds colocados en el PORTB    ////
////                                                                 ////
////  Realizado por Manuel Jiménez (nocturno) para el foro TODOPIC   ////
////                                                                 ////
////                                                        4/8/2004 ////
////                                                                 ////
/////////////////////////////////////////////////////////////////////////

#include <16F84.h>
#fuses HS,NOWDT,NOPROTECT
#use delay(clock=4000000)

#byte port_b=6


void main() {

  int contador; 
  
  set_tris_b(0);           //// declaramos el puerto B como salidas
  port_b=0;

         
  while (true) {           //// bucle infinito
     contador=200;         //// retraso, 200 ciclos de 1000 microsegundos, o sea, 2 milisengundos
     while(--contador!=0)
       delay_us(1000);
     port_b=0xff;          //// activa todos los pins del puerto B
     contador=200;
     while(--contador!=0)  //// retraso, 200 ciclos de 1000 microsegundos, o sea, 2 milisengundos
       delay_us(1000);
     port_b=0x00;};        //// apaga todos los pins del puerto B

}

Título: RE: Microcursillo en C
Publicado por: Modulay en 04 de Agosto de 2004, 16:38:00

Empezamos algo bueno!!
Otro ejemplillo con leds,esta vez las lucecitas del coche fantástico en el puerto b

Codigo:
 
////////////////////////////////////// PREPROCESADO ///////////////////////////////////

#include <16F84.h>
#use delay(clock=4000000)
#fuses XT,NOWDT,NOPUT,NOPROTECT

#use fast_io(B)
#byte PORTB = 0x06

/////////////////////////////////////// PRINCIPAL /////////////////////////////////////

void main()
   {
   set_tris_b(0b00000000);    // Puerto B al completo configurado como salida
   PORTB = 1; // Encendemos el primer led  
   for(;;)    // Bucle infinito
     {
     while(PORTB != 128)  // Avanzamos en una dirección 
       {
       PORTB = PORTB * 2; // Apagamos el led que esté encendido y encendemos el siguiente
       delay_ms(200);     // Retardo de 200 ms
       }
     while(PORTB != 1)    // Avanzamos en la otra dirección
       {
       PORTB = PORTB / 2; // Apagamos el led encendido y encendemos el anterior
       delay_ms(200);
       }
     }
   }

Título: RE: Microcursillo en C
Publicado por: pocher en 05 de Agosto de 2004, 00:33:00

Lo del parpadeo un poco más corto:

Codigo:
#include <16F84.h>
#fuses XT,NOWDT,NOPROTECT
#use delay(clock=4000000)
#use fast_io(B)

void main()
{
        set_tris_b(0x00);
   while (1)
   {          
        output_b(0xff);
          delay_ms(200);
        output_b(0x00);
          delay_ms(200);
   }
}

NOTA:

El programa se puede hacer también así:

- Sin el fast_io(B) y sin el set_tris_b(0x00) y todo lo demás como está.

- O se deja el fast_io(B) y se añade en el main el set_tris_b(0x00)

Personalmente soy partidario de la segunda opción. En todos los programas se definan entradas y salidas con los correspondientes set_tris, así vamos a lo seguro. Además usando el fast_io se consiguen al compilar, menos instrucciones de programación en asembler ya que cada vez que en el programa se encuentre con un input o un output no se reprograma el puerto, solo se programa una vez con el primer input o output, cosa que no ocurre sin el fast.

Un saludo

Título: RE: Microcursillo en C
Publicado por: Nocturno en 05 de Agosto de 2004, 00:38:00

Eres un fenómeno, Pocher. Bueno ahora que he aprendido a usar los delay_ms os envío otro ejemplo de parpadeo, en esta ocasión con encendido y apagado suave de los leds. Lo he probado en la placa entrenadora y queda un efecto muy simpático:

Codigo:
/////////////////////////////////////////////////////////////////////////
////                           PARPADEO v.2                          ////
////                                                                 ////
////  Ejemplo de parpadeo de todos los leds colocados en el PORTB    ////
////                                                                 ////
////  Realizado por Manuel Jiménez (nocturno) para el foro TODOPIC   ////
////                                                                 ////
////                                                        4/8/2004 ////
////                                                                 ////
/////////////////////////////////////////////////////////////////////////

#include <16F84.h>
#fuses XT,NOWDT,NOPROTECT
#use delay(clock=4000000)
#use fast_io(B)

void main() {

  int i;

  while (true) {           //// bucle infinito
  
            //// en esta primera parte va encendiendo la mitad alta del puerto B y apagando la mitad baja
      for (i=1;i<=24;++i) {      //// va cambiando el retraso, de 1 a 24 ms
            output_b(0xF0);         //// encendemos la mitad del puerto B
            delay_ms (i);        //// hacemos una parte de la espera
            output_b(0x0F);         //// encendemos la otra mitad del puerto B
            delay_ms ((25-i));   //// realizamos la espera complementaria
      };
      
            //// en esta segunda parte va encendiendo la mitad baja del puerto B y apagando la mitad alta
      for (i=1;i<=24;++i) {      //// va cambiando el retraso, de 1 a 24 ms
            output_b(0x0F);         //// encendemos la mitad del puerto B
            delay_ms (i);        //// hacemos una parte de la espera
            output_b(0xF0);         //// encendemos la otra mitad del puerto B
            delay_ms ((25-i));   //// realizamos la espera complementaria
      };
   };
}

Pocher, alguna pregunta. Veo que no has declarado el Puerto B como salidas ni como entradas, ¿el compilador lo declara automáticamente cuando pones output_b?

Título: RE: Microcursillo en C
Publicado por: pocher en 05 de Agosto de 2004, 00:46:00

Así es nocturno, además usando la directiva #use fast_io(B) el código generado en ensamblador cada vez que se encuentra con un input o un output es más corto.

Conviene que uses en fuses XT (4MHz) aunque con HS también debe funcionar.

Título: RE: Microcursillo en C
Publicado por: Sispic en 05 de Agosto de 2004, 00:48:00

Una pregunta .

Codigo:

while (1)
   {          
        
          delay_ms(200);
         PORTB= ~ PORTB;

   }

Así quedaria mas corto ?

Título: RE: Microcursillo en C
Publicado por: pocher en 05 de Agosto de 2004, 00:51:00

Pués va a ser que sí ... sin embargo lo acabo de probar en PROTEUS y no funciona bien ... habrá que probarlo físicamente.

Título: RE: Microcursillo en C
Publicado por: Nocturno en 05 de Agosto de 2004, 00:54:00

Esto me recuerda a las competiciones de demos en 4 Kb

Otra pregunta, aprovechando que os pillo a los dos. ¿Cómo puedo enlazar el PCW con el Winpic para no tener que ir cambiando de programa cuando quiera grabar el pic?

Graciaaaaaaaaaaas

Título: RE: Microcursillo en C
Publicado por: oshow en 05 de Agosto de 2004, 03:47:00

Me meto yo si no os importa. Yo tengo la epicwin y la lanzo desde el IDE del compilador, supongo que con cualquier otra programadora se puede hacer lo mismo. Para esto en el menú Options-->Debugger/programmer cambio el campo name de WARP13 a la programadora que tengo (EPIC) y en el campo de la ruta, le doy la direccion del epicwin.exe. Recuerda que tienes que darle la direccion como si fuese msdos, los nombres largos los omite, por ejemplo si lo tienes en C:mis documentosepicwin.exe la direccion sería C:misdoc~1epicwin.exe.

Luego en el menú TOOLS, te sale el nombre que has puesto en el campo name y desde ahí lanzas el software para programar.

Título: RE: Microcursillo en C
Publicado por: Nocturno en 05 de Agosto de 2004, 04:10:00

Gracias, oShow, lo probaré en cuanto llegue a casa.

(No me he dado cuenta de que había otro post en que alguien lo preguntaba ya y por eso lo he vuelto a preguntar aquí

Título: RE: Microcursillo en C
Publicado por: Sispic en 05 de Agosto de 2004, 04:34:00

Aquí lo encontraras para varios compiladores :

http://miarroba.com/foros/ver.php?pag=4&temaid=1381119&foroid=59905

recuerda ponerle la ruta como explica oshow.

Título: RE: Microcursillo en C
Publicado por: RGL en 05 de Agosto de 2004, 08:55:00

He instalado el Cde CCS visto que se puede tabajar con algunos diferentes programadores.

1,- El Pic Star Plus se puede integrar en el entorno IDE de CCS. He leido el Link, pero despues de las 9 páginas ya no se qué es lo que se puede hacer.

2.- Con el ICD2 de Microchip se puede usar este entorno de CCS, para depurar y grabar?

----------------
Cuál es el hardware mejor para programar micros y depurar una aplicación en C?

Saludos y Gracias

Ricky
Madrid-España

Título: RE: Microcursillo en C
Publicado por: Duende_Azul en 07 de Agosto de 2004, 10:45:00

Escrito originalmente por pocher
Así es nocturno, además usando la directiva #use fast_io(B) el código generado en ensamblador cada vez que se encuentra con un input o un output es más corto.

Conviene que uses en fuses XT (4MHz) aunque con HS también debe funcionar.

Pregunta: Esa directiva configura el puerto como entrada o salida dependiendo de si de usa Input o Ouput?, es decir, automaticamente configura y escribe el registro TRISX??

Título: RE: Microcursillo en C
Publicado por: pocher en 07 de Agosto de 2004, 11:42:00

Si no usa la directiva cada vez que se encuentra con un input o un output lo reprograma como Entrada o Salida.

Si se usa solo lo hace una vez a lo largo del programa, con lo que este resulta más corto.

Puedes ponerte un ejemplo y mirar los resultados en el fichero .LST

Un saludo

Título: RE: Microcursillo en C
Publicado por: Nocturno en 07 de Agosto de 2004, 11:55:00

Estoy leyendo el manual de C de la página de Luis Frino y está superinteresante.

De todas formas, me gustaría que nos pusieras otro ejercicio para ir cogiendo nivel, ¿qué hacemos?

Título: RE: Microcursillo en C
Publicado por: litris en 07 de Agosto de 2004, 16:15:00

He!!! que yo tambien me apunto (llego de vacaciones y zas dos cursos ASM y C)

A la escucha me quedo.

Saludos.

Título: RE: Microcursillo en C
Publicado por: Micom en 07 de Agosto de 2004, 23:29:00

Bueno lo poco que se de "C" creo que solo sirve para hacer programitas sencillos para la pc y quiero aprender a hacer programas para pics ya tengo instalado el PCHW compiler ide vercion 3.43 y quisiera saber si con este compilador puedo compilar los primeros ejemplo que pusieron en la primera pagina de este post. hasta pronto

Título: RE: Microcursillo en C
Publicado por: pocher en 07 de Agosto de 2004, 23:56:00

Sí es ese, esa es la versión del IDE, la versión del compilador será otra.

Un saludo

Título: RE: Microcursillo en C
Publicado por: Micom en 08 de Agosto de 2004, 00:55:00

El compilador es el 3.190. Compilo los ejemplos y les cuento como me va . Hasta pronto

Título: RE: Microcursillo en C
Publicado por: Nocturno en 08 de Agosto de 2004, 02:23:00

Los ejemplos que yo he enviado están compilados con la versión 3.204 de compilador, pero no creo que haya ninguna diferencia que impida que te funcionen.

Título: RE: Microcursillo en C
Publicado por: Modulay en 08 de Agosto de 2004, 06:53:00

Como va la versión 3.204?
Funciona bien?

Título: RE: Microcursillo en C
Publicado por: Nocturno en 08 de Agosto de 2004, 07:59:00

Bueno, no le he dado caña como para poder hacer una evaluación, lo único que he compilado son los dos ejemplos que publiqué antes y no me ha dado problemas.

Título: RE: Microcursillo en C
Publicado por: pocher en 08 de Agosto de 2004, 09:55:00

Si os fijais en el IDE de CCS, hay muchas más funciones respecto a las que aparecían en el manual en castellano que rula por ahí. Os recomiendo que tengais tanto la traducción antigua del manual como la última actualización de este que aparece en la WEB de CCS.

Ah y si alguién conoce de una traducción para una versión superior que dé un silbido!

Un saludo.

Título: RE: Microcursillo en C
Publicado por: litris en 09 de Agosto de 2004, 02:04:00

No quiero ser un estorbo pero a mi lo que me lia, es de donde sacais estos comandos, que se supone que son direcciones del pic pero siempre me he liado para usarlos.

Codigo:
  set_tris_b(0);

o esto

Codigo:
port_b=0xff;

este

Codigo:
set_tris_b(0b00000000);

vaya en general como se usan.

Codigo:
output_b(0xF0);

Saludos.

Título: RE: Microcursillo en C
Publicado por: Nocturno en 09 de Agosto de 2004, 05:08:00

¿Has visto el manual de CCS que ha traducido Luis Frino?

http://www.frino.com.ar/zip/Ccs_c_sp.ace

Título: RE: Microcursillo en C
Publicado por: litris en 09 de Agosto de 2004, 11:55:00

Ya me lo he bajado!
No lo tenia, le dare un vistazo.

Saludos.

Título: RE: Microcursillo en C
Publicado por: nordestenica en 10 de Agosto de 2004, 03:23:00

me estoy volviendo loco con el c e intentado acer varias experiencias cojiendo trocos de codigo de otras personas e juntando algo de mi cabeca ay vezes que consigo acer algo que funcione pero la verdade es que nunca e conseguido entender lo que significan muchos comandos

les pondre un exenplo esto lo e cojido por ay

#include <lcd.c> // con esto incluimos en nuestro codigo una driver para controlar una lcd

set_adc_channel( 0 );// aqui le decimos al micro que usaremos como entrada adc el pin A0 del micro (si fura el pin A1 pondriamos set_adc_channel( 1 );

lcd_init();// esto lo usamos para iniciar el driver lcd e se coloca despues del inicio del programa por exemplo

void main()
{
int16 i;

//float const resoluc=5.0/256.0;
float const resoluc=5.0/1024.0;
float valor;

// Inicializacion del micro
setup_port_a( ALL_ANALOG );
setup_adc( ADC_CLOCK_INTERNAL );
set_adc_channel( 0 );
setup_psp(PSP_DISABLED);
setup_spi(FALSE);
setup_counters(RTCC_INTERNAL,RTCC_DIV_1);
setup_timer_1(T1_DISABLED);
setup_timer_2(T2_DISABLED,0,1);

lcd_init(); //Inicializacion del display LCD

aver esto creo que es correcto no

bueno e yo creo que antes de enpecar a programar micros devemos aprender lo que significan todas estas cosas porque sino me passa como a mi que escrivo un pequenho codigo e no se lo que significan todos estes comandos

aver qual va a ser el prof que nos ensenhe que significan todas estas cosas

Título: RE: Microcursillo en C
Publicado por: Modulay en 10 de Agosto de 2004, 10:27:00

Hombre,es que te estás lanzando ya a por el manejo de periféricos y cuestiones más avanzadas.Para entender la misión de cada función lo mejor es echarle un ojo al manual de CCS,que está en castellano y es magnífico.
Para ayudarte un poco con tu duda,voy a poner un programa completo e iré explicando un poco la estructura y lo que y para qué es cada cosa:

Codigo:
 
///////////////////////////// DIRECTIVAS DE PREPROCESADO /////////////////////////////

#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
#include "lcd.c"  // Librería para el manejo del lcd.En mi caso está configurada para
                  // manejar el lcd desde el puerto B
// Con la siguiente directiva,se optimiza código,ya que el compilador asume que en cada momento que accedemos al puerto B,
// este está configurado adecuadamente(como entrada ó como salida) para la acción que vamos a ejercer sobre él
// Si no añadimos esta directiva,cada vez que accedamos al puerto,el compilador generará código para
// asegurar que el puerto esté configurado como salida si lo que vamos a hacer es escribir en él y viceversa
#use fast_io(B)

////////////////////////////////////// GLOBALES //////////////////////////////////////

// Estos parámetros son visibles desde todo el código,por eso se les llama globales.
// Al ser constantes,lo más práctico es declararlas aquí.
const int escala = 255;       // Escala del conversor ADC (8 bits)
const float v_max = 25.2;     // Voltaje máximo que entrega mi fuente

////////////////////////////////////// RUTINAS ////////////////////////////////////////

void borra_lcd()
   {
   lcd_putc("f");  // Con esta instrucción borramos el lcd
   }

// Como se observa en la cabecera,los nombres de los parámetros no tienen por qué ser iguales
// que los de la llamada ( calcula_voltaje(valor,voltaje) ),pero sí deben estar en el mismo
// orden.
// "voltaje",al ser de entrada-salida,debe llevar el símbolo "&" delante
void calcula_voltaje(int val,float &voltaje)
   {
   // "escala" y "v_max" son parámetros globales,por eso son visibles dentro
   // de esta rutina(y en todo el código).Si no lo fueran,al no estar declarados dentro de ella ni 
   // ser parámetros de entrada ó entrada-salida como los de la cabecera,se produciría
   // error al compilar
   voltaje = (val*v_max)/escala;
   }

/////////////////////////////////////// PRINCIPAL //////////////////////////////////////

void main()
   {
   int valor,;    // La declaración de variables SIEMPRE debe ir lo primero
   float voltaje; //
   set_tris_B(0b00000000); // Puerto B configurado como salida
   port_b_pullups(FALSE);  // Desactivamos pull-ups del puerto B
   setup_adc_ports(RA0_RA1_RA3_ANALOG); //Configura A0,A1 y A3 como entradas analógicas y Vdd como voltaje de referencia
   setup_adc(ADC_CLOCK_INTERNAL); // Reloj para el conversor
   set_adc_channel(0); // Seleccionamos el canal 0 (RA0)
   lcd_init();  // Antes de usar el lcd,hay que inicializarlo
   for(;;)  // Bucle infinito,que se ejecuta de forma indefinida
     {
     valor = read_adc(); // Capturamos señal analógica que entra por el canal previamente seleccionado (RA0)
     // Esta rutina tiene a "valor" como parámetro de entrada y a "voltaje" como parámetro de entrada-salida.
     // "valor",al ser de entrada,podrá ser utilizado por la rutina pero NO podrá ser modificado.
     // "voltaje",al ser de entrada-salida,si puede ser modificado dentro de la rutina
     calcula_voltaje(valor,voltaje); // Le mandamos el parámetro "valor" y nos devuelve "voltaje"
     borra_lcd();  // Llamada a rutina que borra el lcd
     printf(lcd_putc,"%f",voltaje)   // Mostramos en el lcd el contenido de la variable "voltaje"
     delay_ms(10);  // Retardo de un 10 ms
     }
   }

Título: RE: Microcursillo en C
Publicado por: Nocturno en 10 de Agosto de 2004, 11:06:00

Ha quedado muy ilustrativo, Modulay.

¿Lo has escrito tú o lo has sacado de algún sitio donde haya más ejemplos como este?. Si la respuesta correcta es la segunda, dinos dónde está por favor. He aprendido muchísimo con este ejemplo.

Gracias

Título: RE: Microcursillo en C
Publicado por: Modulay en 10 de Agosto de 2004, 11:38:00

Es de cosecha propia,Nocturno.
He adaptado un poco el código del voltímetro de mi fuente de alimentación destacando las cosillas que me parecían interesantes.
Un saludo

Título: RE: Microcursillo en C
Publicado por: Duende_Azul en 10 de Agosto de 2004, 13:40:00

Que diferencia hay entre:

valor==(valor && 0x80) y
valor &= 0x80

la primera no me funciona, la segunda si.

Título: RE: Microcursillo en C
Publicado por: Modulay en 10 de Agosto de 2004, 14:47:00

La segunda lo que hace es asignar a valor la operación AND,a nivel de bits,de su contenido con el literal 0x80.
La primera no vale para asignar al ser un doble igual (==).
Al ser una comparación,supongo que lo tendrás como condición de control en una estructura de control (while,for,if...).Tal y como está escrita,no puede desempeñar ninguna otra función.
Saludos

Título: RE: Microcursillo en C
Publicado por: Duende_Azul en 10 de Agosto de 2004, 14:53:00

Gracias Modulay por responder, lo que quiero hacer es una mascara para saber el estado del bit mas significativo de un puerto... leo el puerto y lo guardo en valor, luego con un "and logico" pongo todo a cero menos el ultimo bit para saber si esta a 1 o a cero.

Título: RE: Microcursillo en C
Publicado por: Modulay en 10 de Agosto de 2004, 15:00:00

Pues el segundo método es el que te va al pelo.
El operador && trabaja a nivel lógico,pero no a nivel de bits.Un uso correcto seria...
BOOLEAN condicion;
int numero;
if (condicion1 && numero == 15)
{
bla bla bla...
}

Aunque si quieres saber el estado de un bit de cualquiera de los puertos basta con hacer :
if ( input(PIN_B7) )
{
// Esto se ejecuta si RB7 está a 1
}

Espero que te ayude
Saludos

Título: RE: Microcursillo en C
Publicado por: Modulay en 10 de Agosto de 2004, 15:17:00

Bueno,lo importante es dar ideas y que cada uno aporte dentro de sus posibilidades.Qué mas da quien esté al frente mientras sigamos aprendiendo unos de otros.
Aún así...gracias!!!!
Un saludote

Título: RE: Microcursillo en C
Publicado por: YF-21 en 10 de Agosto de 2004, 18:11:00

Compañeros muchas gracias por abrir el cursillo de "C", ya que es mas sencillo ke el asm ... No cabe duda que se van a ir al cielo

Título: RE: Microcursillo en C
Publicado por: Nocturno en 12 de Agosto de 2004, 00:58:00

Estoy probando las comunicaciones serie en C y hay algo que me tiene comido el coco pero no consigo.

Se trata de que cuando ejecuto el programa que aparece a continuación no me aparece nada en Hyperterminal, a veces me aparece un carácter extraño si reseteo el PIC y otras veces nada, pero ni mucho menos lo que tendría que salir.

La conexión es correcta porque, de hecho, grabo el PIC con el PICDownloader a través del COM1 a 19200.

He revisado la configuración de Hyperterminal y parece que está bien, puesto que también está seleccionado Com1 y 19200.

No entiendo lo que pasa.

Codigo:
#include <16F877A.h>
#fuses XT,NOWDT,NOPROTECT,NOLVP
#use delay(clock=4000000)
#use rs232(baud=19200, xmit=PIN_C6, rcv=PIN_C7)  // Jumpers: 8 to 11, 7 to 1

void main() {

   printf("Press any key to begin
";
   getc();
   printf("1 khz signal activated
";

   while (TRUE) {
     output_high(PIN_B0);
     delay_us(500);
     output_low(PIN_B0);
     delay_us(500);
   }
}

Título: RE: Microcursillo en C
Publicado por: Modulay en 12 de Agosto de 2004, 04:46:00

Lo he probado,pero con un cristal de 20 MHz y me va perfectamente.
Aunque a mí me funciona bien tu programa,en la directiva #use rs232 vendría bien que especificaras si la comunicación es a 8 bits o no,más que nada,para ahorrarte posibles complicaciones o despistes:

// 19200 baudios,8 bits sin paridad
#use rs232(baud=19200, xmit=PIN_C6, rcv=PIN_C7,bits=8)

A lo mejor es por la velocidad del cristal,ponle otro mas potente

Título: RE: Microcursillo en C
Publicado por: Nocturno en 12 de Agosto de 2004, 04:50:00

Probaré con el cristal de 20MHz, y añadiendo lo de los 8 bits.
Es extraño, porque la comunicación aguanta perfectamente a 19200 bps cuando grabo el PIC desde el PicDownloader.

Título: RE: Microcursillo en C
Publicado por: T0ni0 en 12 de Agosto de 2004, 09:26:00

Yo toy empezando con el C PIC, pero creo que se tendría que parar cuenta con poner XT si se utiliza un cristal de 20MHz

Voy a probar cosillas, que tal el CCS para empezar?

De momento no lo he podido provar bien, me pide un registro y luego me me da un error al compilar, supongo que no funciona si no estas registrado, seguiré buscando para hacerme con el

Título: RE: Microcursillo en C
Publicado por: Modulay en 12 de Agosto de 2004, 15:50:00

Un pequeño inciso para comentar una serie de cosas que pueden resultar útiles para familiarizarnos un poco más con el uso de variables y procedimientos(rutinas).
AMBITO DE LAS VARIABLES:
Dependiendo del lugar donde sea declarada,una variable podrá ser visible o no desde una parte concreta de nuestro código.
Si la declaramos como variable global,su ámbito(alcance) será todo el programa,por lo que podremos consultar o modificar su valor desde el main o desde cualquiera de los procedimientos de nuestro código.La pega es que hacer uso de variables globales no es lo más recomendado,no por una cuestión formal,sino porque estarán ocupando memoria durante toda la ejecución aunque no las usemos,y eso no interesa.
Así,si lo que queremos es optimizar los recursos del micro,lo bueno es reducir al máximo el ámbito de las variables y que éstas estén localizadas en segmentos concretos del código.
Un ejemplo:

Codigo:
 
#include <16F877A.h>
#fuses HS,NOWDT,NOPROTECT,NOLVP
#use delay(clock=20000000)
#include "lcd.c"

int numero1;  // Esta variable es global,por lo que ocupará 1 byte durante
              // toda la ejecución

void suma()
   {
   // numero2 está localizada en este procedimiento,por lo que su ámbito es
   // exclusivamente este procedimiento y no será visible desde ningún otro sitio.
   // ¿Qué ganamos con ello? Pues es sencillo,cuando suma() es llamado desde el main,
   // lo primero que ocurre es que se crea la variable numero2,que ocupará 1 byte
   // en algún lugar de la memoria.Cuando suma() termina de ejecutarse,ese byte 
   // quedará liberado para que otro dato pueda usarlo si fuera necesario.
   // Conclusión: se optimiza memoria
   int numero2;
   numero2 = 15;
   numero1 = numero1 + numero2;  // Modificamos el valor de nuestra variable global
   }

void main()
   {
   lcd_init();
   numero1 = 10;  // La vemos porque es global
   suma();       // Llamada al procedimiento suma() 
   printf(lcd_putc,"%u",numero1); // La mostramos en el lcd
   for(;;) {}
   }

Ya no es sólo cuestión de optimizar memoria,así se consigue también un código más estructurado y modularizado.
A otra cosa,mariposa.
PARAMETROS POR VALOR O POR REFERENCIA:
Como se ve en un ejemplo que hay un poco más arriba,también se puede conseguir que una variable sea visible,para que podamos usarla,dentro de una rutina en la que no está declarada.La forma de hacerlo es enviar dicha variable como parámetro cuando se efectúa la llamada al procedimiento...¡¡Ponme un ejemplo!!:-/

Codigo:
 
#include <16F877A.h>
#fuses HS,NOWDT,NOPROTECT,NOLVP
#use delay(clock=20000000)
#include "lcd.c"


void suma(int num1,int num2,long int &res) 
   {
   // "num1" y "num2" son parámetros de entrada.
   // "res" es de entrada-salida.
   // "num1" es un parámetro de entrada por valor.Al ser un parámetro de entrada,cuando se produce
   // la llamada al procedimiento,se crea una copia de dicho valor y el procedimiento
   // trabaja con dicha copia,y no con el original como cabe pensar.
   // "num2" es otro parámetro pasado por valor.Al ser sólo de entrada,también se crea una copia en 
   // memoria con la que trabajaremos y que será destruída,al igual que "num1",cuando
   // acabe la ejecución de la rutina.
   // Por último nuestro parámetro de entrada-salida.Ni que decir tiene que un parámetro
   // de entrada-salida JAMAS DE LOS JAMASES es pasado por valor,siempre lo es por referencia y
   // deberá tener SIEMPRE como origen una variable.
   // Esta vez,al ser un parámetro de entrada-salida,susceptible de ser modificado,el
   // el procedimiento no hace copia ninguna y trabaja con el original de forma dinámica
   // ¿qué quiere decir eso? Pues que se crea un puntero que apuntará al dato de origen y la 
   // rutina trabajará con ese puntero en vez de hacerlo directamente con el dato.
   res = num1 + num2;  // Asiganmos a "res" la suma de los otros 2 parámetros
   }


void main()
   {
   // Declarar variables en el programa principal es casi como declararlas globales,
   // por lo que tampoco es lo más óptimo.
   int numero;
   long int resultado;
   lcd_init();
   resultado = 0;  // Esta acción es superflua ya que vamos a modificar su valor en breve.
   // suma() lleva 3 parámetros: uno por valor y dos por referencia.
   suma(numero,23,resultado);    // Llamada al procedimiento suma() 
   // "resultado" ha sido modificado y devuelto por el procedimiento suma()
   printf(lcd_putc,"%lu",resultado);   // La mostramos en el lcd
   for(;;) {}
   }

Para ver más claro esto de las copias de los parámetros y tal,una vez compilado el programa,se puede ver la distribución de los datos en la memoria del pic en el menú de CCS:
View -> Symbol map

Saludos

Título: RE: Microcursillo en C
Publicado por: Nocturno en 12 de Agosto de 2004, 17:58:00

Muy didáctico Modulay. Practicaré con ello en los próximos ejemplos.

Con respecto al problema que tenía con mis comunicaciones serie, ya lo he resuelto. Y no era problema del cristal.

Resulta que tenía conectado al MAX232 la salida DTS del puerto serie para que, una vez adaptada a niveles TTL, me hiciera Reset en el micro a través de la patilla MCLR. De esta manera, cuando lo grababa con el PICDownloader, no tenía que tocar nada; el software hacía reset automáticamente y enviaba el programa.

Pues bien, esta conexión impedía el funcionamiento correcto del puerto serie. Ahora bien, me pregunto porqué. ¿Cuál es el funcionamiento de la señal DTS en una comunicación serie?, ¿porque impide que funcione?

Gracias

Título: RE: Microcursillo en C
Publicado por: oshow en 12 de Agosto de 2004, 18:08:00

Hola Modulay, tengo dos preguntas sobre el 2º codigo que has puesto, bueno, mejor un apunte y una pregunta.

El apunte, bueno según lo poco que sé de esto, num1 no es un parámetro de entrada por referencia, sino por valor ( o al menos así me explicaron), si fuese por referencia (como el tercer argumento de la función) si se podría modificar, sin embargo es una "copia del valor" de la variable, por eso lo de "paso por valor".

Bueno, ahora la pregunta, me puedes explicar como funciona realmente el paso del tercer argumento de la función?. Yo personalmente, para modificar una variable dentro de una función, la paso por referencia usando punteros, pero es la primera vez que veo tu forma de hacerlo, pasando la dirección de la variable en la definición de la función, te pongo aquí lo que hago yo habitualmente...

Codigo:

#include <16F877A.h>
#fuses HS,NOWDT,NOPROTECT,NOLVP
#use delay(clock=20000000)
#include "lcd.c"


void suma(int num1,int num2,long int *res) 
   {
   // "num1" y "num2" son parámetros de entrada.
   // "res" es de entrada-salida.
   // "num1" es un parámetro de entrada por referencia,ya tiene como referencia
   // a una variable ("numero" del main).Al ser un parámetro de entrada,cuando se produce
   // la llamada al procedimiento,se crea una copia de dicho parámetro y el procedimiento
   // trabaja con dicha copia,y no con el original como cabe pensar.
   // "num2" es un parámetro pasado por valor,ya que tiene como origen un valor
   // constante(23),y no una variable.Al ser sólo de entrada,también se crea una copia en 
   // memoria con la que trabajaremos y que será destruída,al igual que "num1",cuando
   // acabe la ejecución de la rutina.
   // Por último nuestro parámetro de entrada-salida.Ni que decir tiene que un parámetro
   // de entrada-salida JAMAS DE LOS JAMASES puede ser pasado por valor.
   // Deberá tener SIEMPRE como origen una variable.
   // Esta vez,al ser un parámetro de entrada-salida,susceptible de ser modificado,el
   // el procedimiento no hace copia ninguna y trabaja con el original.
   *res = num1 + num2;  // Asiganmos a "res" la suma de los otros 2 parámetros
   }


void main()
   {
   // Declarar variables en el programa principal es casi como declararlas globales,
   // por lo que tampoco es lo más óptimo.
   int numero;
   long int resultado;
   lcd_init();
   resultado = 0;  // Esta acción es superflua ya que vamos a modificar su valor en breve.
   // suma() lleva 3 parámetros: uno por valor y dos por referencia.
   suma(numero,23,&resultado);    // Llamada al procedimiento suma() 
   // "resultado" ha sido modificado y devuelto por el procedimiento suma()
   printf(lcd_putc,"%lu",resultado);   // La mostramos en el lcd
   for(;
     {}
  }

Saludos.

Título: RE: Microcursillo en C
Publicado por: Modulay en 12 de Agosto de 2004, 18:16:00

Cuando te refieres a DTS,supongo que lo harás a RTS(yo lo conozco con ese nombre,no se si será el correcto).En definitiva,el pin 6 del puerto.
Bien,este terminal del puerto serie es de salida y es usado por el pc para avisar al dispositivo que tenga conectado que tiene datos para enviar,y funciona conjuntamente con el terminal de entrada DSR(pin 7),por el que le entrará la respuesta que proporcione el pic o dispositivo conectado a la solicitud-aviso enviada mediante DTS:

pc tiene datos para enviar y pone DTS a 1 -> pic responde poniendo un 1 en DSR -> pc recibe respuesta y envía los datos.

Es por esto que se suelen puentear los pines 6 y 7 cuando se implementa una puerto para comunicación serie en un circuito,de esa forma,la solicitud de envío de datos formulada por el pc es contestada a sí misma.
De la misma forma tb se puentean los pines 8(CTS) y 4(DTR) para el mismo objetivo,pero esta vez cuando el flujo de datos va en sentido contrario.
En cuanto a que fuera la causa de tu problema,si dices que lo tenías conectado al MCLR del pic,posiblemente te lo estuviera reseteando.
Un saludo

Título: RE: Microcursillo en C
Publicado por: Modulay en 12 de Agosto de 2004, 18:35:00

Haciéndolo así consigues lo mismo pero con una pequeña diferencia,oshow.
Yo,al poner "&" delante del parámetro en la cabecera del procedimiento,lo que hago es que dicho procedimiento tome como dato la dirección de memoria del parámetro de origen para trabajar directamente con él,es decir estoy usando sin darme cuenta un puntero.
Al hacerlo como describes,el parámetro en la llamada es una dirección de memoria :
&dato = dirección en memoria de dato
En la cabecera del procedimiento,al poner el * delante del parámetro lo que consigues esta vez es deshacer el cambio y proporcionarle a la rutina el dato en sí mismo,pero con una pega,que se crea una copia en memoria.
De ahí la importancia de poner el dichoso & delante de los parámetros de entrada-salida (PERO SOLO EN LA CABECERA DE LA RUTINA!,NO EN LA LLAMADA!).Ese pequeño detalle te ahorra memoria por cada vez que lo uses,al indicarle al compilador que debe trabajar de forma dinámica con los datos.
En cuanto a lo por valor o por referencia,puede que tengas razón y que me haya embalado un poco con los conceptos.
Lo miraré a ver.Gracias.
Saludotess!!

Título: RE: Microcursillo en C
Publicado por: oshow en 12 de Agosto de 2004, 18:42:00

Gracias a tí por la explicación , máquina...

La verdad nunca había trabajado dinámicamente con los datos, me pondré al día y lo intentaré usar más a menudo.

Gracias.

Saludos

Título: RE: Microcursillo en C
Publicado por: Modulay en 12 de Agosto de 2004, 18:45:00

Definitivamente sí,tienes razón.
Por valor significa de entrada,se copia el valor del parámetro de origen(sea constante o variable) y se trabaja con dicha copia.
Por referencia implica entrada-salida,uso de un puntero asociado al parámetro y manejo dinámico de dicho parámetro.
Ya está corregido.
Echale un vistazo a lo del Symbol map,probando a tu forma,a la que expuse yo,a la que se te ocurra,observando qué datos se crean en memoria.
Un saludo

Título: RE: Microcursillo en C
Publicado por: Nocturno en 13 de Agosto de 2004, 00:40:00

Sí, era RTS, Modulay.

Pienso que efectivamente me resetea el PIC a la vez que intenta la comunicación, pero hay dos cosas extrañas:
- tengo al principio del programa unas instrucciones para que se encienda un led durante una décima de segundo cuando arranca. Si hago reset a mano veo como efectivamente se enciende. Sin embargo, cuando sospechamos que está reseteándose, no veo encenderse al led en ningún momento.
- ¿porqué funciona perfectamente la comunicación serie cuando grabo el micro con el PicDownloader?

Seguiré investigando

Título: RE: Microcursillo en C
Publicado por: Modulay en 13 de Agosto de 2004, 01:12:00

No veo por que ha de encenderse ese led si el micro se mantiene reseteado.Si RTS está a 0 porque el pc no tiene nada para enviar,el reset será permanente ¿no?
¿A qué te refieres con la última pregunta? No termino de entenderla

Título: RE: Microcursillo en C
Publicado por: Nocturno en 13 de Agosto de 2004, 02:25:00

Bien, puede ser que esté siempre reseteado. Pensé que la señal RTS oscilaba; si es continua puede ser una explicación.

Con respecto al segundo tema, me refiero a que cuando grabo el PIC con el Bootloader y el PICDownloader utilizo una comunicación serie con el PC y ahí no falla, aunque tenga conectado el RTS.

Título: RE: Microcursillo en C
Publicado por: T0ni0 en 13 de Agosto de 2004, 10:59:00

Vamo a ver, en principio instaldo el CCS 3.155 y funcionando, he probado las rutinas anteriores NP pero con el el LCD ... es otro asunto, no he sabido ver en que puerto esta ( yo uso un PICDEM 2 PLUS con un PIC16F876) y al compilar me da error en los set_tris_ me faltará alguna rutina? o inicializar algun parámetro?

Mi siguiente paso va a ser dos entradas analógicas. Por cierto que se pondria en la atención de la interupción de la UART?

Vale vale poco a poco

Título: RE: Microcursillo en C
Publicado por: Modulay en 13 de Agosto de 2004, 15:23:00

Holas,Tonio.
CCS y su librería "lcd.c" asumen por defecto que tienes el lcd conectado al puerto D.
Ya que un 16F876 carece de puerto D vale con añadir esta línea a tu código en la parte de preprocesado:
#define use_portb_lcd TRUE
Con ello le dices al compilador que tienes conectado el lcd al puerto B y dejará de darte ese error al compilar.
Para saber como tienes que tener el conexionado de las líneas de datos y las de control,abre el archivo "lcd.c" (está en PICC-> drivers) y fíjate en las primeras líneas de código.Deberías tener algo así,posiblemente en diferente orden.Dicho orden dependerá de como conectes los pines del lcd al pic:

Codigo:
 
struct lcd_pin_map {
           BOOLEAN unused;    // RB0  (sin conectar a nada)
           BOOLEAN rs;        // RB1
           BOOLEAN rw;        // RB2
           BOOLEAN enable;    // RB3
           int     data : 4;  // RB4 a RB7
        } lcd;

Así,si en vez de "unused",en la primera línea tienes "rs",dicho pin del lcd irá conectado a RB0.De la misma forma todo lo demás
Ya nos cuentas como te fue.
Saludos

Título: RE: Microcursillo en C
Publicado por: T0ni0 en 14 de Agosto de 2004, 04:30:00

Haber sobre la LCD, a quien le intertese:

En la PICDEM2 PLUS hay una LCD de 4 bits que solo está conectada al zocalo de 40 pines, está como sigue: E=RA1, R/W=RA2, RS=RA3, RD0:RD3 son los datos.

Como yo utilizo un 16F876 ( si tengo el de 40 pines pero digamos que no me gusta mucho) de momento voy ha esperar con la LCD y lo voy a printar por la UART.

Más adelante ya lo probare con el grande haber como adapto las rutinas para 4 bits ok gracias por todo.

PD: alguien sabe como puedo depurar con un ICD2?

Título: RE: Microcursillo en C
Publicado por: gfp en 14 de Agosto de 2004, 10:16:00

Mira este recorte de código, a mi me funcionó a las mil maravillas. recibe una trama de caracteres hasta el enter.

Espero te ayude.

GFP

#include <16F877.h>
#include <stdlib.h>
#fuses XT, NOPROTECT, PUT, NOWDT, NOBROWNOUT, NOLVP, NOCPD, NOWRT
#use delay (clock=4000000)
#use RS232(BAUD=19200, XMIT=PIN_C6, RCV=PIN_C7)
#zero_ram
void main( void )
{
   char string[4];    //Define la cantidad de caracteres a recibir. Ejemplo 125 y el "enter".
   long int x;       //Se define x cono entero
   while(1)         //Loop infinito
   {
   gets(string);      //Guarda caracteres hasta que recibe enter.
   x = atoi32(string);   //Convierte los 3 caracteres ascii recibidos a un numero entero. Ejemplo 1,2,3 quedaría x=123
//Bla-bla-bla
   }
}

Título: RE: Microcursillo en C
Publicado por: Modulay en 14 de Agosto de 2004, 14:37:00

Otro buen ejemplo para seguir ampliando este cursillo,gracias gfp.
Se me ocurre tocar otro tema interesante.
Hasta ahora hemos visto que nuestros programas,además del programa principal,también pueden contar con una serie de rutinas para hacerlo mas modular.Estos subprogramas,hasta el momento han sido todos del tipo "void".Pero podemos usar otro tipo de procedimientos llamados funciones.Las funciones tienen como cometido hacer una serie de operaciones para finalmente DEVOLVER un valor,ya sea de tipo entero,caracter,real,booleano...
Una vez está implementada,el manejo de una función es casi el mismo que el que se le da a una variable del mismo tipo,a excepción de que mientras a una variable le podemos asignar un valor con "=",a una función no le podemos asignar nada.Sólo podemos usarla como fuente,no como destino.
Un ejemplo de una función de tipo entero:

Codigo:
 
////////////////////////////////////// PREPROCESADO ///////////////////////////////////

#include <16F876.h>
#use delay(clock=20000000)
#fuses HS,NOWDT,NOPUT,NOLVP,NOBROWNOUT,NOWRT
#include "lcd.c"

#use fast_io(B)
#use fast_io(C)

////////////////////////////////////// RUTINAS ///////////////////////////////////////

int entrada_activa()
  {
  if(input(PIN_C0))
    {
    // Esto se ejecuta si RC0 está a 1
    return(0);  // Devolvemos un 0
    }else if(input(PIN_C1)) {
    // Esto se ejecuta si RC1 está a 1
    return(1);  // Devolvemos un 1
    }else if(input(PIN_C2)) {
    // RC2 está a 1
    return(2);  // Devolvemos un 2
    }else if(input(PIN_C3)) {
    // RC3 está a 1
    return(3);
    }else if(input(PIN_C4)) {
    // RC4 está a 1
    return(4);
    }else if(input(PIN_C5)) {
    // RC5 está a 1
    return(5);
    }else if(input(PIN_C6)) {
    // RC6 está a 1
    return(6);
    }else if(input(PIN_C7)){
    // RC7 está a uno
    return(7);
    }else {
    // Si entramos aquí es que no se dió ninguno de los casos anteriores (todas a 0)
    return(8);
    }
  }
  
  
////////////////////////////////////// PRINCIPAL //////////////////////////////////////
  

void main()
   {
   int pin_activo;
   set_tris_c(0xff);  // Puerto C configurado como entrada
   lcd_init();
   pin_activo = entrada_activa();  // Asiganmos a "pin" el valor que devuelve entrada_activa()
   while(TRUE) // Bucle infinito
     {
     if(entrada_activa() > 7)  // Usamos directamente el valor que nos retorne la función
       {
       // entrada_activa() devolvió el valor 8
       printf(lcd_putc,"No hay entradas activas");  
       }else {
       // En otro caso...
       printf(lcd_putc,"El pin %u está a 1",entrada_activa());  // Mostramos qué pin está a 1
       }
     }
   }

Como se ve,la clave de una función es la sentencia "return".
No hay que olvidar que el elemento que acompañe a "return" debe ser del mismo tipo que la función.
Otra forma de hacerlo es declarando una variable dentro de la función,modificarla dentro de la función según nos interese,y finalmente devolver dicha variable.Ocupa más memoria,pero nos libra de escribir tantos returns:

Codigo:
 
////////////////////////////////////// PREPROCESADO ///////////////////////////////////

#include <16F876.h>
#use delay(clock=20000000)
#fuses HS,NOWDT,NOPUT,NOLVP,NOBROWNOUT,NOWRT
#include "lcd.c"

#use fast_io(B)

////////////////////////////////////// RUTINAS ///////////////////////////////////////

BOOLEAN a_mayor_que_b(int a,int b)
  {
  BOOLEAN mayor; // Esta es la variable que vamos a devolver
  mayor = FALSE; // Las variables booleanas es bueno inicializarlas con algún valor
  if(a >= b)
    {
    // "a" es mayor o igual que "b"
    mayor = TRUE;
    }else {
    // "a" es menor que "b"
    // Aquí no necesitamos hacer mayor=FALSE ya que hemos inicializado "mayor" a FALSE
    }
  return(mayor);
  }
  
////////////////////////////////////// PRINCIPAL //////////////////////////////////////
  

void main()
   {
   int a,b;
   a = 50;
   b = 30;
   if(a_mayor_que_b(a,b))
     {
     // La función ha devuelto TRUE
     output_high(PIN_B1);  // Por ejemplo :)
     }else if(!a_mayor_que_b(a,b)) {
     // La función ha devuelto FALSE
     output_high(PIN_B2);
     }
   }

Igual que los subprogramas,las funciones también pueden llevar parámetros,pero únicamente de entrada,nunca de entrada-salida.
Ah,se me olvidaba...Una vez que nos encontramos con un "return",acaba la ejecución de la función y volvemos al punto desde donde fué llamada.
Saludos

Título: RE: Microcursillo en C
Publicado por: Duende_Azul en 14 de Agosto de 2004, 17:26:00

Una impecable exposición, gracias por este conocimiento, por cierto ¿eres profesor de C?

Título: RE: Microcursillo en C
Publicado por: Modulay en 14 de Agosto de 2004, 19:31:00

¿Me tomas el pelo?

Título: RE: Microcursillo en C
Publicado por: Duende_Azul en 14 de Agosto de 2004, 21:38:00

Como crees, en serio, tu explicación es muy buena.

Título: RE: Microcursillo en C
Publicado por: Modulay en 14 de Agosto de 2004, 21:41:00

Gracias,Duende,pero no,no soy profe.
Soy alumno!!
La verdad es que me tomo mi tiempo para construir estos ejemplos,no salen de corrido.Y en eso consiste la cosa...que mejor forma de asimilar una idea que con un ejemplo ¿no?
Saludotes

Título: RE: Microcursillo en C
Publicado por: Nocturno en 15 de Agosto de 2004, 01:28:00

Modulay, admiro tu dedicación y entrega.

Cada día me está gustando más el C.

Título: RE: Microcursillo en C
Publicado por: T0ni0 en 16 de Agosto de 2004, 05:12:00

Gracias GFP por tu aportación, por lo visto no definia bien el string,

He podido captar un string, y compararlo con otro, realizo un switch de esta comparación, espero que sea ilustrativo .

Problemas que me he encontrado:

---- NO puedo utilizar las funciones dentro de la Interrupción, se pueden definir punteros a función? he intentado utilizar la función suma() ( anteriormente modificada por mi, con los dos valores como entrada y entero como salida)

---- Los string NO pueden ser más grandes de 80 bytes (creo que 80 es el numero máximo de variables que puedo utilizar) esto en el caso del F876 Alguna solución? en teoría tendría que haber 2x80 + 2x96 bytes disponibles.

---- Como puedo inicializar un string ? el switch lo quería hacer entre el valor que llega y la frase SUMAR

Aquí hos dejo el código

http://www.goto10.net/probac/probc.c

http://www.goto10.net/probac/probc.h

haber como salimos de esta, de momento voy a provar el A/D y enviar los resultados.

Título: RE: Microcursillo en C
Publicado por: T0ni0 en 16 de Agosto de 2004, 06:33:00

Haber que os parece la adquisición de las dos AD

http://www.goto10.net/probad/probc.c

Por cierto, solo pueda adquirir 8 bits? como cojo los otros 2 ? yo ya he puesto que sean 10 pero en la variable solo me coge esos como la defino?

Título: RE: Microcursillo en C
Publicado por: Modulay en 16 de Agosto de 2004, 07:16:00

Creo que te faltó añadir #device adc=10 en la parte de preprocesado,sin esta línea el ADC trabaja a 8 bits.
En cuanto al tema de los punteros a funciones,se puede hacer sin ningun problema,pero(siemre hay un pero) he estado haciendo pruebas y CCS no se traga un puntero a una función ni por asomo,da error de compilación te pongas como te pongas,aún siendo el código correcto.He probado a compilar el código con visual C++ y no hay problema.No sé si será cuestión de que a CCS hay que dárselo de otra forma(cosa que dudo) ó es que simplemente no se lo traga.Es una pena.De todas formas,aquí va un ejemplo para que prueben suerte a ver si alguien consigue hacerlo funcionar

Codigo:
 
///////////////////////////////////// PREPROCESADO ////////////////////////////////////

#include <16F876.h>
#use delay(clock=20000000)
#fuses HS,NOWDT,NOPUT,NOLVP,NOBROWNOUT,NOWRT
#include "lcd.c"

#use fast_io(B)

////////////////////////////////////// GLOBALES ///////////////////////////////////////

int (*funcion) (int,int);  // Puntero a una función que lleva dos parámetros enteros
                          // y que devuelve un entero

////////////////////////////////////// RUTINAS ///////////////////////////////////////

int suma(int a,int b)
  {
  return(a+b);
  }


int resta(int a,int b)
  {
  return(a-b);
  }

//////////////////////////////////// PRINCIPAL //////////////////////////////////////

void main()
   {
   int resultado;
   lcd_init();
   funcion = suma;      // Hacemos que el puntero apunte a la función "suma"
   resultado = funcion(10,2);  // Asignamos a "resultado" el valor que devuelve la función
                               // apuntada por el puntero "funcion"
   printf(lcd_putc,"La suma es: %u",resultado);  // Al lcd
   funcion = resta;    // Ahora el puntero apunta a "resta"
   resultado = funcion(10,2);  // Asignamos
   lcd_gotoxy(1,2);  // Segunda línea del lcd
   printf(lcd_putc,"La resta es: %u",resultado);  // Al lcd
   for(;;) {}
   }

La solución que yo veo para poder definir arrays de mayor tamaño es usar un pic 18.Estoy usando un 18F258 en un proyecto y tengo definido en el código un array de 500 posiciones.Claro que este micro tiene 1 K y medio de memoria RAM :)

Título: RE: Microcursillo en C
Publicado por: oshow en 16 de Agosto de 2004, 07:50:00

Aunque el codigo esté bien, el compilador no lo acepta, lo he buscado en la ayuda y efectivamente este compilador no acepta punteros a funciones, además pone un ejemplo de como podría hacerse sin punteros. Mediante una variable enum y luego un switch ejecutar la función correspondiente. Pego el texto directamente.

////////////////////////////////////////////////////////////////////////////////
How do I make a pointer to a function?

The compiler does not permit pointers to functions so that the compiler can know at compile time the complete call tree. This is used to allocate memory for full RAM re-use. Functions that could not be in execution at the same time will use the same RAM locations. In addition since there is no data stack in the PIC®, function parameters are passed in a special way that requires knowledge at compile time of what function is being called. Calling a function via a pointer will prevent knowing both of these things at compile time. Users sometimes will want function pointers to create a state machine. The following is an example of how to do this without pointers:

Codigo:

enum tasks {taskA, taskB, taskC};

 

run_task(tasks task_to_run) {

 

    switch(task_to_run) {

    case taskA : taskA_main();  break;

    case taskB : taskB_main();  break;

    case taskC : taskC_main();  break;

    }

 

}

Saludos.

Título: RE: Microcursillo en C
Publicado por: T0ni0 en 16 de Agosto de 2004, 09:21:00

bueno ha decir verdad falta ver un archivo, aqui están los dos archivos:

http://www.goto10.net/probad/probc.c

http://www.goto10.net/probad/probc.h

veras como si esta definido adc=10

De la interupción creo que será mejor levantar un flag en una variable global y ya está, luego en el main actuar.

Ah!!

para inicializar un string, ya lo se al mismo tiempo que se define

ej. char car[10]="hola";

Título: RE: Microcursillo en C
Publicado por: Modulay en 16 de Agosto de 2004, 10:16:00

Tonio creo que tu problema con la función se debe al hecho de que cualquier procedimiento debe estar declarado (ó al menos implementado) antes que el algoritmo llamante.
"Undefined identifier suma"...Si este es el error que te da corta la función "suma" y la pegas antes de la rutina de interrupción(si es dicha rutina quien quieres que llame a "suma").
Esto es una cuestión básica de C,se me ha escapado comentarla.
La forma mas correcta de solucionar esta cuestión es declarando siempre en nuestros programas todos y cada uno de los procedimientos..¿dónde y cómo se hace eso?...pues podemos hacerlo justo antes de la parte de variables globales,en la parte alta del código.La forma de declarar un procedimiento es copiar su cabecera tal cual está en la implementación del mismo.Sería de esta forma:

Codigo:

///////////////////////////////////// PREPROCESADO ////////////////////////////////////

#include <16F876.h>
#use delay(clock=10000000)
#fuses HS,NOWDT,NOPUT,NOLVP,NOBROWNOUT,NOWRT
#include "lcd.c"

#use fast_io(B)

////////////////////////////////////// CABECERAS ////////////////////////////////////

// Aquí declaramos todos los procedimientos a excepción del "main"
// Cuando el código comienza a adquirir unas dimensiones considerables,una ventaja
// que esto tiene es poder ordenar las rutinas por orden alfabético para poder 
// localizarlas con facilidad.
// Las cabeceras también las ordenamos por orden alfabético

void fulanito(int var);
float manolito(int a,int b);
void pepito();  // OJO! No olvidar el ";"

////////////////////////////////////// GLOBALES ///////////////////////////////////////

int var_global;

////////////////////////////////////// RUTINAS ///////////////////////////////////////

void fulanito(int var)
  {
  // "pepito()" está implementada después del algoritmo llamante,pero
  // al estar ya declarado,será visible aunque esté después.
  pepito();
  }


float manolito(int a,int b)
  {
  return(a/b);
  }


void pepito()
  {
  printf(lcd_putc,"bla bla bla");
  }

//////////////////////////////////// PRINCIPAL //////////////////////////////////////

void main()
   {
   // ¿Cual puede ser el motivo por el cúal el "main" está siempre lo último? :)
   }

He probado tu programa(quitando alguna cosas,ya que no tengo ICD,ni tengo el micro con su max232 para el puerto serie) y he mostrado los valores capturados por el adc en mi lcd y funciona bien,los valores son de 10 bits.No se que puede estar mal.Prueba a hacerlo más sencillo y que el programa en sí únicamente consista en la captura del adc a ver q tal va.
Saludos

Título: RE: Microcursillo en C
Publicado por: pocher en 16 de Agosto de 2004, 11:58:00

Te felicito Modulay por tan valiosa dedicación, este minicursillo está pero que muy interesante.

Como vereis ultimamente entro poco al FORO ... vacaciones.

Título: RE: Microcursillo en C
Publicado por: Modulay en 16 de Agosto de 2004, 12:17:00

Gracias,pocher
Disfruta de la vacaciones
Saludos

Título: RE: Microcursillo en C
Publicado por: T0ni0 en 18 de Agosto de 2004, 10:18:00

Pues ya llevas razón se me había escapado, cuando hago C pongo todas las funciones en un include y las cabeceras en un archivo .h , al hacerlo todo en un mismo archivo se me escapó.

Gracias por estar atento

Aki está el resultado:

//******************************************************+

//
// Adquisición de dos entradas analógicas
//
// Parpadeo de LED en RB1
//
// AD0:
// AD1: termómetro con LM35
//
// Polling entrada digital RB0 ( 0 si activada)
//
// Entrada string por Interrupción UART
// Si es "SUMAR" entrar dos numeros y se suman
//
// Visualización de los resultados por UART
//
//
// Autor: T0ni0
//
//******************************************************+
#include <16F876.h>
#device ICD=TRUE
#device adc=10
#use delay(clock=20000000)
#fuses NOWDT,HS, NOPUT, NOPROTECT, NOBROWNOUT, NOLVP, NOCPD, NOWRT, DEBUG
#use rs232(baud=9600,parity=N,xmit=PIN_C6,rcv=PIN_C7,bits=8)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ZERO_RAM

//******************************************************+
// Cabezeras
//******************************************************+
long int suma(long int num1, long int num2);

//******************************************************+
// Variables globals
//******************************************************+
int glob;

//******************************************************+
// INTERRUPCIÓN DE LA UART
//******************************************************+
#int_RDA
RDA_isr()
{

char caract[30];
long int x,y;
char sumes[6]="SUMAR";

gets(caract); //Guarda caracteres hasta que recibe enter.

switch (strcmp(sumes,caract)) {

// SI SON LOS DOS STRINGS IGUALES

case 0: printf("
ENTRA EL PRIMER NUMERO
" );
gets(caract); //Guarda caracteres hasta que recibe enter.
x= atoi32(caract);
printf( " EL PRIMER NUMERO ES %lu
",x);

printf(" ENTRA EL SEGUNDO NUMERO
" );
gets(caract); //Guarda caracteres hasta que recibe enter.
y= atoi32(caract);
printf( " EL SEGUNDO NUMERO ES %lu
", y);

x= suma(x,y);
// x=x + y;

printf(__DATE__);
printf(" LA SUMA ES = %lu
",x); // La mostramos
break;

// SI EL PRIMERO ES MAYOR
case 1: printf("PRIMERO MAS GRANDE
" );
printf("
ENTRAR "SUMAR" PARA EMPEZAR
" );
break;

// SI EL PRIMERO ES MENOR
case -1:printf("PRIMERO MENOR
" );
printf("
ENTRAR "SUMAR" PARA EMPEZAR
" );
break;

// PARA ESTA EVALUACIÓN TIENE QUE SER UN VALOR DE LOS ANTERIORES
default:printf("NO ENCONTRADO
" );

break; } //FINAL DEL SWITCH

} //FINAL DE LA INTERRUPCIÓN

//******************************************************+
// Funciones
//******************************************************+

long int suma(long int num1, long int num2)
{
return(num1 + num2); // Valor a retornar
}

//******************************************************+
// MAIN
//******************************************************+
void main()
{
//******************************************************+
// Variables
//******************************************************+

long int val1,val2;

//******************************************************+
// INICIO
//******************************************************+
setup_adc_ports(RA0_RA1_RA3_ANALOG);
setup_adc(ADC_CLOCK_INTERNAL);
setup_spi(FALSE);
setup_counters(RTCC_INTERNAL,RTCC_DIV_1);
setup_timer_1(T1_DISABLED);
setup_timer_2(T2_DISABLED,0,1);
enable_interrupts(INT_RDA);
enable_interrupts(GLOBAL);

//******************************************************+
// BUCLE PRINCIPAL
//******************************************************+
while (TRUE)
{

printf("
$AD0: EL VALOR MESURADO EN A/D 0 ES=%4lu
",val1);

delay_ms(2000);

printf("
$TEMPERATURA EXTERIOR:%2luC
",val2);

if (!input(PIN_B0))
{
printf("
$ENTRADA1: SE HA ACTIVADO" );
}

output_high(PIN_B1);

set_adc_channel(0); //observamos el canal 0
delay_ms(1000);
val1 = read_adc(); //Realizamos la adquisición

output_low(PIN_B1);

set_adc_channel(1); //observamos el canal 1
delay_ms(1000);
val2 = read_adc(); //Realizamos la adquisición
val2= val2/25.3; //Relación del (LM35 * 10)

} // FINAL DEL BUCLE PRINCIPAL
} // FINAL DEL MAIN

Título: RE: Microcursillo en C
Publicado por: Modulay en 18 de Agosto de 2004, 10:27:00

Olvidaste la cabecera de la rutina de interrupción.No se trata de declarar sólo las funciones,sino todas las rutinas a excepción del main.Aunque viéndolo en cierto modo,no sería necesario puesto que no va a ser llamada por ninguna rutina del programa.
¿Resolviste lo de los 10 bits en el ADC?

Título: RE: Microcursillo en C
Publicado por: T0ni0 en 18 de Agosto de 2004, 10:38:00

Pues si, asunto resuelto, mi fallo era declarar las variables como int, luego solo cogían 8 bits ahora están declaradas como long int.

Título: RE: Microcursillo en C
Publicado por: Modulay en 18 de Agosto de 2004, 11:18:00

Juer pues yo diría que las había visto declaradas como tipo long,ya te digo que cogí tu codígo,lo probé y funcionó bien.

Título: RE: Microcursillo en C
Publicado por: Modulay en 19 de Agosto de 2004, 08:25:00

Mas cuestiones para echarle un ojo (o los dos 0_o).
Lo mas típico es basar nuestros programas en el uso de los tipos de datos básicos que
trae implementados el compilador.Son los tipos simples: int,char,short,long,float,enum,etc...
Lo bueno es que a partir de estos tipos predefinidos,el usuario puede crear sus propias
estructuras de datos (tipos definidos por el usuario) para hacer más ordenado y sencillo
el manejo de datos a escalas mayores.
Imaginemos que tenemos 5 sensores de temperatura conectados al micro,cada uno a una entrada
analógica.Para procesar la información recogida por estos sensores tendríamos que usar una
variable para cada uno de ellos y trabajar con estas variables de manera individual.
Sin embargo,es posible definir un tipo creado por nosotros,del cual podremos crear
una única variable en cualquier parte del código que pueda contener los 5 datos de los 5
sensores en cada momento.Podría ser una cosa así:

Codigo:

///////////////////////////////////// PREPROCESADO ////////////////////////////////////

#include <16F876.h>
#use delay(clock=10000000)
#fuses HS,NOWDT,NOPUT,NOLVP,NOBROWNOUT,NOWRT
#define use_portb_lcd TRUE
#include "lcd.c"

////////////////////////////////////// CONSTANTES /////////////////////////////////////

const unsigned int NUM_SENSORES = 5;

//////////////////////////////////////// TIPOS ////////////////////////////////////////

typedef int Tsensores[NUM_SENSORES];
// Esto es un array de 5 enteros(int es el tipo base).Puede albergar,pues eso,5 valores
// individuales comprendidos entre 0-255.
// Tsensores es el nombre que le hemos puesto al tipo,la T se suele poner para
// tener constancia,por si lo vemos en alguna parte del código,de que se trata de un
// tipo definido de usuario.

///////////////////////////////////// CABECERAS ///////////////////////////////////////

int temperatura(int canal);

/////////////////////////////////////// RUTINAS ///////////////////////////////////////

int temperatura(int canal)
  {
  // Esta rutina se supone que captura un valor en el canal adc que indique el 
  // parámetro canal (0,1,2,3 ó 4),lo procesa y devuelve un valor de temperatura.
  int valor;
  // blablabla...
  return(valor);
  }

////////////////////////////////////// PRINCIPAL //////////////////////////////////////

void main()
   {
   int j;
   Tsensores sensores; // Array de 5 posiciones,cada posición es un entero.
   // La forma de acceder a cada uno de los elementos del array es usando su número de
   // orden (índice) dentro de él.
   // No olvidar que el primer elemento de un array tiene SIEMPRE índice 0.
   // Si el array tiene dimensión 5 -> primer elemento,índice 0
   //                               -> último elemento,índice 4
   
   for(j = 0; j <= 4; j++)  // Vamos a poner todos los valores a 0
     {
     sensores[j] = 0; // Así se accede al elemento de un array,mediante su índice.     
     }
   j = 0;  // Después del for,el valor de j es indeterminado,así que 
           // la ponemos a 0 para afrontar el siguiente bucle.
   while(j < 5)  // Bucle infinito
     {
     // Capturamos la temperatura de todos los sensores continuamente,con un intervalo
     // de tiempo de un segundo entre sensor y sensor.
     // Se ve la correspondencia entre el número del canal y la posición dentro del array.
     sensores[j] = temperatura(j); 
     delay_ms(1000);
     j++;
     if(j==5)  // Cuando j=5,la ponemos otra vez a 0 para no salir del bucle y empezar de nuevo
       {
       j = 0;
       }
     }
   }

El tipo base de un array puede ser cualquier tipo(int,char,boolean,array...).
Los arrays pueden ser multidimensionales,como por ejemplo...

typedef BOOLEAN Tmatriz[4][4]

...que es un tipo array bidimensional que contendrá 16 variables booleanas,y que puede servir por ejemplo para manejar una matriz de leds de 4x4.
Como comentario,hacer alusión al tipo "string",el cual no es más que un tipo array cuyo
tipo base es char.

Título: RE: Microcursillo en C
Publicado por: Nocturno en 19 de Agosto de 2004, 11:09:00

Claro como el agua. Muchas gracias Modulay

Título: RE: Microcursillo en C
Publicado por: Modulay en 20 de Agosto de 2004, 05:24:00

Un array puede ser de cualquier tipo,de caracteres,de enteros,de flotantes...
Pero sólo podrá contener un único tipo base,por lo que todos sus elementos,
da igual cuantos sean,serán del mismo tipo.
Otra estructura muy útil que nos permite implementar un conjunto con diferentes
tipos de datos es el registro.Para definir un tipo registro se usa la palabra
reservada "struct" (Las palabras reservadas son aquellas que UNICAMENTE pueden
ser utilizadas con el propósito para el que han sido concebidas: int,char,struct,
while,typedef,return,if,void,etc..).

Codigo:

///////////////////////////////////// PREPROCESADO ////////////////////////////////////

#include <16F876.h>
#use delay(clock=10000000)
#fuses HS,NOWDT,NOPUT,NOLVP,NOBROWNOUT,NOWRT
#define use_portb_lcd TRUE
#include "lcd.c"

//////////////////////////////////////// TIPOS ////////////////////////////////////////

struct Tregistro {   
         int edad;         
         float estatura;
         boolean casado;
         };
// Nuestro registro contiene tres campos,una variable booleana llamada "casado",
// una entera llamada "edad" y una real llamada "estatura".

////////////////////////////////////// PRINCIPAL //////////////////////////////////////

void main()
   {
   struct Tregistro juan,antonio; // Creamos 2 variables tipo registro.
   // Para acceder a un campo de un registro,se pone el nombre de la variable
   // registro seguido de un punto y el nombre del campo.
   juan.edad = 28;            // Llenamos los registros con datos
   juan.estatura = 1.75;      //
   juan.casado = TRUE;        //
   antonio.edad = juan.edad;  //
   antonio.estatura = 1.81;   //
   antonio.casado = FALSE;    //
   for(;;)  {}
   }

CCS no permite el paso de registros como parámetros a un procedimiento,pero es algo que
sí se puede hacer en C.La alternativa a esta limitación es el uso de punteros.

Título: RE: Microcursillo en C
Publicado por: Nocturno en 20 de Agosto de 2004, 05:36:00

Intuyo que sí, pero ¿puede una matriz formar parte de un registro?, ¿y viceversa?

Título: RE: Microcursillo en C
Publicado por: Modulay en 20 de Agosto de 2004, 06:09:00

Sip!!

Codigo:

///////////////////////////////////// PREPROCESADO ////////////////////////////////////

#include <18F258.h>
#use delay(clock=10000000)
#fuses HS,NOWDT,NOPUT,NOLVP,NOBROWNOUT,NOWRT
#define use_portb_lcd TRUE
#include "lcd.c"

//////////////////////////////////////// TIPOS ////////////////////////////////////////

struct Tregistro {        // Este es el más pequeño
         int edad;
         float estatura;
         boolean casado;
         };
         

typedef struct Tregistro TmatrizRegistros[5][5];  // Matriz de 25 registros
                                                  // Este es el mediano

                                            
struct TregistroMatrices {          // Este es el que los contiene a todos
         TmatrizRegistros hombres;  
         TmatrizRegistros mujeres;
         };

////////////////////////////////////// PRINCIPAL //////////////////////////////////////

void main()
   {
   struct TregistroMatrices poblacion; 
   poblacion.mujeres[1][3].edad = 18;  
   for(;;)  {}
   }

Otra cosa,se me olvidó decir que CCS tampoco admite arrays ni matrices de booleanas

Título: RE: Microcursillo en C
Publicado por: Nocturno en 20 de Agosto de 2004, 06:20:00

CRACK

(no me he roto, es sencillamente lo que eres)

Título: RE: Microcursillo en C
Publicado por: Nocturno en 24 de Agosto de 2004, 04:13:00

Ahora que por fin me funcionan mis malditas pantallitas LCD, puedo seguir aprendiendo C.

Como ejercicio me he planteado jugar con los bucles y aprender a dominarlos, sobre todo en cuanto a sintaxis. Para ello, y aprovechando que ya funcionan mis LCD, he diseñado una rutina que saca por la pantalla dos cadenas de caracteres usando un efecto parecido a Matrix, una cadena en la línea superior y la otra en la inferior.

Aunque funciona, el código no está depurado y tampoco está muy legible, pero todavía no estoy muy ducho en estas lides.

Bueno, lo pego aquí y lo comentamos, ¿no?

Codigo:
#include <16F877A.h>
#use delay(clock=20000000)
#fuses HS,NOWDT,NOPUT,NOLVP,NOBROWNOUT,NOWRT
#define use_portb_lcd TRUE
#include "lcd.c"
#include "string.h"

// Esta función la he tenido que incluir aquí porque si hacía un include de su librería y la llamaba me fallaba. Pegándola aquí funciona bien.

unsigned int32 _Randseed = 1;

long rand(void)
{
   _Randseed = _Randseed * 1103515245 + 12345;
   return ((unsigned long)(_Randseed >> 16) % 93);
}

// Esta función recibe dos cadenas de caracteres y sus longitudes, y las representa en un LCD 2x16 con un efecto parecido a Matrix

void matrix (char *cadena1, char *cadena2, int largo1, int largo2)
{
   int i,j;
   
   // durante 15 ciclos mostramos caracteres aleatorios
   for (i=0;i<=15;i++) {
      for (j=1;j<=16;j++) {          // va pasando por cada columna del LCD
         lcd_gotoxy (j,1);         // pone el cursor en la primera fila y la columna j
         printf (lcd_putc,"%C",rand()+161);   // escribe un caracter aleatorio comprendido entre el 161 y el 253
         lcd_gotoxy (j,2);         // pone el cursor en la segunda fila y la columna j
         printf (lcd_putc,"%C",rand()+161);   // escribe un caracter aleatorio comprendido entre el 161 y el 253
      };
      delay_ms (100);            // y esperamos una décima de segundo para que dé tiempo a verlo
   };

   // en los siguientes 16 ciclos vamos desvelando los caracteres correctos en posición par
   for (i=1;i<=16;++i) {          // repetimos 16 veces para acompañar el efecto Matrix
      for (j=0;j<=15;++j) {         // pero ya vamos cumplimentando los 16 caracteres, del 0 al 15
         if (j<=i & bit_test (j,0)) {      // sólo escribiremos el carácter si el bucle principal ha pasado por aquí y está en posición par
            lcd_gotoxy (j+1,1);         // vamos allí, en la primera fila
            if (j<largo1)         // si no hemos sobrepasado el tamaño de la cadena
               printf (lcd_putc,"%C",cadena1[j]); // escribimos la letra que corresponda
              else            // y si no
               printf (lcd_putc," ";      // un espacio en blanco
            lcd_gotoxy (j+1,2);         // vamos allí, en la segunda fila
            if (j<largo2)         // si no hemos sobrepasado el tamaño de la cadena
               printf (lcd_putc,"%C",cadena2[j]); // escribimos la letra que corresponda
              else            // y si no
               printf (lcd_putc," ";      // un espacio en blanco
         } else {            // si aún no hemos llegado o se trata de una posición impar
            lcd_gotoxy (j+1,1);         // en la primera fila
            printf (lcd_putc,"%C",rand()+161);   // escribimos carácter matrix aleatorio
            lcd_gotoxy (j+1,2);         // y en la segunda fila
            printf (lcd_putc,"%C",rand()+161);  // escribimos carácter matrix aleatorio
         };
      };
      delay_ms(100);            // y esperamos una décima de segundo para que dé tiempo a verlo
   };

      // y en los siguientes 16 ciclos vamos desvelando los caracteres correctos en cualquier posición
   // aunque para el espectador sólo son nuevos los impares
   // no comento esta rutina porque es igual que la anterior, exceptuando la condición de la paridad

   for (i=1;i<=16;++i) {
      for (j=0;j<=15;++j) {
         if (j<=i) {
            lcd_gotoxy (j+1,1);
            if (j<largo1)
               printf (lcd_putc,"%C",cadena1[j]);
              else
               printf (lcd_putc," ";
            lcd_gotoxy (j+1,2);
            if (j<largo2)
               printf (lcd_putc,"%C",cadena2[j]);
              else
               printf (lcd_putc," ";
         } else {
            lcd_gotoxy (j+1,1);
            printf (lcd_putc,"%C",rand()+161);
            lcd_gotoxy (j+1,2);
            printf (lcd_putc,"%C",rand()+161);
         };
      };

      delay_ms (100); 

   };
}

void main()
   {
   char cad1[16],cad2[16];

   output_high (PIN_B0);      // es un led que se enciende al arrancar, y me sirve para señalar si ha habido un reset
   delay_ms (300);         // lo mantengo encendido 3 décimas de segundo
   output_low (PIN_B0);         // y lo apago
   lcd_init();            // inicializamos la pantalla
   strcpy (cad1,"EFECTO MATRIX";   // preparamos las strings a mostrar
   strcpy (cad2,"(por Nocturno)";   
   
   matrix (cad1,cad2,strlen(cad1),strlen(cad2));   // e invocamos a la función
   // no he conseguido calcular las longitudes de las strings en la función, por eso hago el cálculo en la llamada

   sleep();            // ponemos el bichito a dormir la siesta

   }

Ya me diréis.

Editado:
No sé porqué cojones saca los caretos si está en formato código, pero si queréis probar el código, donde aparezca un careto va un paréntesis cerrado.

Título: RE: Microcursillo en C
Publicado por: Modulay en 24 de Agosto de 2004, 07:37:00

Aunque esté en formato código,tienes que desactivar la opción "usa caretos".
He probado a incluir la librería stdlib.h para no tener que implementar la función rand() en el código y no me da error.
La función rand() realiza una serie de pasos matemáticos para llegar a un resultado considerado "aleatorio".Estos pasos parten del valor de una variable "semilla"(_Randseed).Si esta semilla tiene siempre el mismo valor,obtendrás una secuencia de aleatorios que se repetirá de forma consecutiva.Para variar el valor de esta semilla se usa la función srand(semilla),también incluída en la librería,por lo que se me ocurre que cambies el valor de la semilla antes de cada llamada a rand().Podrías conseguirlo por ejemplo asignándole a la semilla el valor de alguna de las dos variables de control que usasen los bucles "for",que en cada iteración tendrían un valor diferente.Puede que tampoco fuese del todo aleatorio,pero la repetición de secuencias sería en menor grado.
Podrías intentar que los caracteres de las dos cadenas se fueran descubriendo tb de forma aleatoria,así quedaría más chulo.
Podría servir crear un array de enteros(ya que de booleanas no se puede) de igual longitud a tus cadenas que te indicase que carácter está descubierto y que carácter no lo está.Así en cada una de las iteraciones que descubren caracteres de la cadena,llamas a rand() para que te devuelva una posición de la cadena,compruebas si ya está destapada,y si no lo está la descubres.

La implementación de rand() y srand() podría ser algo asi:

Codigo:

#define RAND_MAX 255
#define LONG_CADENA 14

unsigned int32 semilla = 1;


long rand(unsigned int maximo)
{
   semilla = semilla * 1103515245 + 12345;
   return ((unsigned long)(semilla >> 16) % maximo);
}


void srand(unsigned int32 seed)
{
   semilla = seed;
}

De esta forma,si quieres que el aleatorio esté comprendido entre 0 y 14,haces rand(LONG_CADENA),y si es para generar el carácter aleatorio,usas RAND_MAX como parámetro.

Título: RE: Microcursillo en C
Publicado por: Nocturno en 24 de Agosto de 2004, 07:47:00

Bien, gracias por tus consejos.

Depuraré el programa e intentaré lo del destape aleatorio, aunque en vez de buscar la posición a destapar de forma aleatoria, lo mejor va a ser desordenar la serie 1 a 16 de manera que me garantice que siempre se va a destapar todo. Aunque es improbable, con el método que me propones podría darse la casualidad de una posición que nunca sale, y entonces tardaría mucho en mostrarse el mensaje completo.

Gracias de nuevo

Título: RE: Microcursillo en C
Publicado por: Modulay en 24 de Agosto de 2004, 08:18:00

En eso tienes razón,aunque todo se haría a la velocidad de la ostia,se apreciaría cierta tardanza en los últimos caracteres.
La solución podría ser esto:

int posiciones[14] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13};
// Generamos un aleatorio entre 0 y la longitud de la cadena(14).
// Accedemos a "posiciones" y vemos que elemento toca descubrir.
// Descubrimos el carácter.
// Despues "eliminamos" del array "posiciones" dicho elemento,y todos los que están después
// los reubicamos desplazándolos hacia atrás una posición...
// ...(en el caso de que no fuera el último).
// Ahora solo tenemos que generar el aleatorio con el parámetro "maximo" decrementado
// en una unidad.
// Así conseguimos que con cada aleatorio generado,descubrimos un carácter que aún
// sigue oculto.

O más fácil todavía,en vez de mover tantos elementos hacia atrás,coges el último y lo colocas en la posición que ha quedado "vacía".Eso si,cada vez que hagas esto, debes tener en cuenta en qué posicion de las 14 está el último elemento.

Título: RE: Microcursillo en C
Publicado por: Nocturno en 25 de Agosto de 2004, 03:26:00

Pues ya he hecho los cambios que comentábamos ayer.
Finalmente he optado por desordenar una matriz de posiciones que contiene los números 1 al 16 y luego ir destapandolos siguiendo el desorden que haya quedado.

Está aquí y la verdad es que el resultado que ha quedado está chulísimo.

Aún así, tengo dos dudas que me gustaría lanzar al foro porque no acabo de entenderlas:

1.- ¿cómo puedo calcular en una función la longitud de un string que es recibido como parámetro?. No he conseguido que me funcione.

2.- ¿Cómo puedo hacer operaciones entre int y float y que el resultado sea un int?. En realidad, el problema lo tengo porque no domino las conversiones entre tipos de datos, pero no he encontrado documentación clara al respecto.

Título: RE: Microcursillo en C
Publicado por: oshow en 25 de Agosto de 2004, 04:01:00

Hola Nocturno.

En cuanto a lo primera pregunta, existen dos tipos de conversiones de tipos de datos implicitas y explicitas Cuando el compilador realiza la conversion de forma automatica como es el caso que planteas (sumar int + float , resultado float) es conversión implicita. La explicita es la que realiza el programador (casting de variables), se indican precediendo a la constante o variable que se desea convertir por el tipo a convertir rodeado entre parentesis.

Por ejemplo en tu caso sería una conversion explícita:

int a=2,c;
float b=2.5;

c=(int) (a+b);

Con esto conviertes la suma de a y b (float, porque el compilador realiza una conversion implicita) y tu lo conviertes a int para almacenarla en la variable c (tipo entero).

Esto en cuanto a ansi C ahora no lo he probado con el CSS, no se si lo soporta, en caso de que no lo soporte,otra forma de hacerlo (un poco mas cutre) seria usando una varible temporal por ejemplo:

int a=2,c,temp;
float b=2.5;

temp=b;
c=a+temp;

Esto estoy casi seguro que lo aceptará el CCS (aunque no veo porque debería aceptar lo de arriba).

En cuanto a la segunda pregunta, para calcular la longitud de una cadena tienes la funcion strlen() que devuelve un entero con la cantidad de elementos de la cadena. También puedes hacerlo sin usar la funcion, mediante un for y esperando al caracter nulo "" que es el del final de la cadena.

Saludos.

PD: Vaya, he visto que he contestado las preguntas en orden inverso....

Título: RE: Microcursillo en C
Publicado por: Nocturno en 25 de Agosto de 2004, 04:10:00

Respecto a las conversiones de datos, la explicación que has hecho es como yo creía que el compilador lo hacía, pero he tenido problemas para implementarlo en mi programa y finalmente he tenido que decantarme por otra solución. No puedo garantizar que el CCS no lo admita porque puede ser que me haya confundido, pero me da la impresión de que no se comporta como el Ansy C.

Con respecto al segundo tema, al del cálculo de la longitud del array, lo he intentado con el strlen, pero sólo me funciona en el main(), no en la función a la que llamo. Si miras el ejemplo que he subido, verás a qué me refiero.

Muchas gracias por responder Oshow.

Título: RE: Microcursillo en C
Publicado por: MGLSOFT en 27 de Agosto de 2004, 13:29:00

Escrito originalmente por pocher
Muy sencillo, cogeros un libro con ejercicios en ensamblador (el de Angulo podría servir) y empezais por los primeros pasándolos a C.

Podeis plantear aquí el enunciado y su resolución.

En la pagina de Angulo encontraran los ejemplos en C, los mismos que hay en assembler...

Título: RE: Microcursillo en C
Publicado por: Modulay en 28 de Agosto de 2004, 08:02:00

Nocturno ¿cómo es eso que no puedes calcular la longitud de la cadena desde la función?
¿te da error al compilar?
¿te la calcula mal?

Título: RE: Microcursillo en C
Publicado por: Nocturno en 28 de Agosto de 2004, 09:53:00

Pues no me funcionaba, no sé si era porque estaba pasando mal los parámetros string a la función, o si la razón radicaba en otro sitio. El caso es que el amigo Oshow me pasó por privado un ejemplo que sí funciona, y ya lo he arreglado, con el strlen dentro de la función.

Título: RE: Microcursillo en C
Publicado por: Nocturno en 28 de Agosto de 2004, 09:55:00

Escrito originalmente por MGLSOFT
En la pagina de Angulo encontraran los ejemplos en C, los mismos que hay en assembler...

Marcos, ¿cuál es la página de Angulo?

Título: RE: Microcursillo en C
Publicado por: Nocturno en 29 de Agosto de 2004, 02:34:00

He estado desarrollando una miniaplicación para leer los valores PWM de un acelerómetro, es un ADXL210E.
Ya consigo leerlos, y además veo cómo varían según la inclinación que le dé, pero hay una pijotada que no me sale y me gustaría.

Se trata de formatear el resultado de salida, que es un float, de manera que me muestre un determinado nº de decimales.

En el código que adjunto ya consigo que calcule sólo los decimales que yo quiero, pero sin embargo, al representarlos en el LCD me sigue mostrando ceros a partir del último decimal, con lo que no me deja acabar con el símbolo del %.

Echadle un vistazo, masters del universo, y decidme algo, please:

Codigo:
#include <16F877A.h>
#use delay(clock=20000000)
#fuses HS,NOWDT,NOPUT,NOLVP,NOBROWNOUT,NOWRT
#define use_portb_lcd TRUE
#include "lcd.c"
#include "math.h"


float lee_acelerometro (int Eje, int Decimales) { // Según Eje sea 0 o 1 se lee el pin D0 o D1
                                                   // Decimales indica la resolución del resultado
                                                   // El resultado siempre será un porcentaje
   int32 alto=0, bajo=0, j;
   float Resultado;
   int i;
   for (i=0;i<10;++i) {                            // se lee 10 veces, para evitar márgenes de error (se puede modificar)
                                                   // si es necesaria mayor frecuencia
      if (Eje) {
            while( input(PIN_D0));                 // esperamos a que baje la señal de entrada
            while( !input(PIN_D0));                // esperamos a que suba la señal de entrada
            while( input(PIN_D0)) {                // mientras esté arriba vamos contando en alto
                        alto++;
               } ;
            while( !input(PIN_D0)) {               // y mientras esté abajo vamos contando en bajo
                        bajo++;
               };
      } else {
            while( input(PIN_D1) );   
            while( !input(PIN_D1) );  
            while( input(PIN_D1)  ) { 
                        alto++;
               } ;
            while( !input(PIN_D1) ) { 
                        bajo++;
               };
      };
      
   };

   Resultado = (((float)alto/((float)alto+(float)bajo))-0.43)*10000/9;   // el resultado es alto/(alto+bajo),
                                       // las constantes son ajustes de escala y calibración del acelerómetro
   Resultado = floor(Resultado*pow(10,Decimales))/pow(10,Decimales); // Formateamos el resultado con nº decimales                                 
   return (Resultado); // no he podido hacer toda la operación aquí porque me decía "Expression too complex"
}

void main()
   {

   lcd_init();
   output_high (PIN_B0);      // es un led que se enciende al arrancar, y me sirve para señalar si ha habido un reset
   delay_ms (300);         // lo mantengo encendido 3 décimas de segundo
   output_low (PIN_B0);         // y lo apago

   while (TRUE) {
         printf (lcd_putc,"fLectura: %f%%",lee_acelerometro(0,2)); // muestra el resultado de la lectura del eje 0
         lcd_gotoxy (1,2);
         printf (lcd_putc,"Lectura: %f%%",lee_acelerometro(1,2));   // muestra el resultado de la lectura del eje 1
         output_high (PIN_B0);
         delay_ms (100);                                            // parpadea para saber que ha pasado por el bucle
         output_low (PIN_B0);
         };
   }

Título: RE: Microcursillo en C
Publicado por: Modulay en 29 de Agosto de 2004, 03:57:00

Para concretar el número de decimales a mostrar de un flotante creo que sería una cosa así:
printf(lcd_putc,"%m.nf",variable)
...siendo m el número de dígitos enteros a mostrar y n el número de decimales.
Si quieres representar tb el carácter "%" tendrás que hacerlo aparte usando
lcd_putc("%")

Título: RE: Microcursillo en C
Publicado por: Modulay en 29 de Agosto de 2004, 05:57:00

ups...
Tomo nota

Título: RE: Microcursillo en C
Publicado por: Nocturno en 29 de Agosto de 2004, 10:48:00

Ahondando en mi proyecto con el acelerómetro, he leído en la ayuda de CCS algo sobre la implementación de PWM en CCS. He visto que el módulo CCP se puede configurar para PWM.

Mi pregunta es: ¿sólo puede utilizarse para generar un pulso PWM saliente o también es posible usarlo para interpretar uno entrante?

Título: RE: Microcursillo en C
Publicado por: oshow en 31 de Agosto de 2004, 10:11:00

Ni idea sobre lo del pwm nocturno, lo siento...

Volviendo al tema anterior de especificadores de formato, sabéis si existe alguno para ajustar a la derecha, es decir para que los numeros menores de 10 se representen como 01, 02,03,04 en lugar de 0,1,2,3

No se si cogeis la idea....

Saludos.

Título: RE: Microcursillo en C
Publicado por: Modulay en 31 de Agosto de 2004, 10:23:00

%0n coloca n ceros a la izquierda,eso si,no hace distinción entre números mayores o menores que 10

Título: RE: Microcursillo en C
Publicado por: oshow en 31 de Agosto de 2004, 10:27:00

Gracias Modulay, creo que con eso ya me arreglo, el detectar que sea menor de 10 esta tirao....

Gracias.

Saludos.

Título: RE: Microcursillo en C
Publicado por: Modulay en 31 de Agosto de 2004, 10:33:00

He probado en proteus y no hace falta ni eso:
-> %02
Colocando esa coletilla ya te discierne el solito y te lo representa como estás buscando,con el 0 delante si el numerito es menor que 10.
Saludos

Título: RE: Microcursillo en C
Publicado por: oshow en 31 de Agosto de 2004, 10:38:00

Vaya, mas fácil incluso....

Gracias.

Saludos.

Título: RE: Microcursillo en C
Publicado por: MGLSOFT en 01 de Septiembre de 2004, 06:37:00

Escrito originalmente por nocturno66
Escrito originalmente por MGLSOFT
En la pagina de Angulo encontraran los ejemplos en C, los mismos que hay en assembler...

Marcos, ¿cuál es la página de Angulo?

Perdon:
Confundi estos ejemplos que tengo en C y assembler con los de Angulo, crei que era lo mismo.
Estos estan hechos para la Micropic Trainer, pero son facilmente adaptables para otro entrenador...
Si quieres los pongo, pero estan en http://www.microcontroladores.com

Título: RE: Microcursillo en C
Publicado por: Nocturno en 02 de Septiembre de 2004, 02:12:00

No te preocupes Marcos, ya los descargo de esa página. No la conocía y tiene buena pinta.

Título: RE: Microcursillo en C
Publicado por: T0ni0 en 09 de Septiembre de 2004, 04:09:00

Por que motivo me llevo tan mal con los strings? que les he hecho?

Yo defino :

char st[MAXB];

luego en el codigo quiero cargar una frase en esa variable:

*st="HOLA";

i nada, ya he probado varias posibilidades, como puedo cargar a st strings dentro del programa?

Título: RE: Microcursillo en C
Publicado por: oshow en 09 de Septiembre de 2004, 05:37:00

No estoy sseguro y no te lo puedo confirmar ahora porque no lo tengo delante, pero creo que es otra limitación del compilador. No permite punteros a constantes en rom.

Yo lo que haría sería una matriz al inicio del programa:

const char matr[5][3]={ "hola1", "hola2", "hola3"};

y luego dentro de tu programa llamar al elemento que quieras.

Saludos.

Título: RE: Microcursillo en C
Publicado por: T0ni0 en 09 de Septiembre de 2004, 05:57:00

De momento es lo que estoy haciendo, pero necesito tantas variables como estrigs quiero comprar

Título: RE: Microcursillo en C
Publicado por: lovando en 10 de Septiembre de 2004, 08:42:00

Una consultilla

La libreria LCD trabaja en modo 8 o 4 bits??...Se puede usar CCS para configurar un PIC en modo 3 bits para manejar un LCD copn esta libreria??

Osea, 3 lineas del PIC conectados a un registro desplazamiento 74HC164 (serial a paralelo) el cual esta conectado en modo 8 lineas al LCD???

3 lineas: data,clock y latch

Gracias

Título: RE: Microcursillo en C
Publicado por: pocher en 10 de Septiembre de 2004, 11:43:00

Supongo que estarás hablando sobre un programa y circuito que alguién puso (¿fuiste tú?) hace algún tiempo donde había un PIC16C54, un registro 4094 y este conectado a la LCD.

Como el PROTEUS no simula 16C54 y yo no lo tengo, no pude comprobar si funcionaba ese circuito y me interesaba. Lograste tú comprobar si funcionaba?

Ahora a tu pregunta. La librería lcd.c de CCS trabaja en modo 4 bits de datos (D4..D7), también las hay para trabajar en modo 8 bits de datos aunque ninguna de las dos te van a servir para este circuito ya que ambas librerías se usan para controlar el PIC directamente, no haciendo de intermediario un registro de desplazamiento.

Un saludo

Título: RE: Microcursillo en C
Publicado por: pacalaconcurso en 10 de Septiembre de 2004, 13:18:00

para copiar string puedes usar la libreria de funciones para string:

char aux[10];
strcpy(aux,"HOLA"

;

Título: RE: Microcursillo en C
Publicado por: YF-21 en 26 de Septiembre de 2004, 17:09:00

Disculpen ... para seguir con el curso podrian poner un ejemplo de comunicacion mediante I2C con 2 16F877 ? Aunque ya estudié la teoria necesito un empujoncito más ...

Lo unico que requiero es ... el master busca la lectura del Primer registro libre del 877 esclavo

Lo que tiene el registro no es de mucha importancia ... solo lo lee, y despues el master escribe en la segunda direccion libre del esclavo el valor 0Fh

POR FAVOR, se los agradeceré mucho

Título: RE: Microcursillo en C
Publicado por: YF-21 en 26 de Septiembre de 2004, 22:48:00

OK, para no abusar de su confianza, solo quisiera que me respondieran una preguntota ...

Cuando el master dice la direccion, se refiere a la direccion que intenta accesar del integrado esclavo ??

Lo que pasa es que ví que se puede realizar una conexion entre varios esclavos y varios maestros, pero como saben los esclavos a cual master se deben dirigir y viceversa y que registro leer/escribir si solo manda el master una direccion?

Título: RE: Microcursillo en C
Publicado por: YF-21 en 27 de Septiembre de 2004, 18:06:00

Con respecto al Timer es sustituido por los delay ??? o alguien lo ha configurado en C??

Título: RE: Microcursillo en C
Publicado por: oshow en 28 de Septiembre de 2004, 16:30:00

Hola, bueno antes de nada, decir, que yo tampoco soy un experto en el tema, estoy experimentando un poquillo con el i2c, he puesto algunos rtc en funcionamiento, pero nada más.

Tengo un ejemplo entre dos 877 con i2c (es muy básico!!!!) que hice para "trastear" un poco, te lo envío al privado porque no puedo subirlo aquí y en el almacén tampoco puedo subirlo.

En cuanto a tu última pregunta, si que no entiendo nada, a que te refieres con si se puede sustituir el timer por delays?, no entiendo....si lo aclaras un poco más a lo mejor te podemos echar un cable.

Un saludo.

PD: El ejemplo esta hecho con una versión de proteus reciente (6.5), mira a ver si puedes simularla sin problemas.

Título: RE: Microcursillo en C
Publicado por: migsantiago en 22 de Noviembre de 2004, 19:10:00

Hola,

quiero revivir este microcursillo de C. Sólo agrego un programita que YF-21 me ayudó a hacer. Sirve para mandar el abecedario en minúsculas a la PC en protocolo RS-232. Sólo hay que abrir la hyperterminal y configurarla en el COM con 2400baudios.

También hay que usar el MAX232 para pasar las patas TTL a RS232.

Codigo:

#include <16f84a.h>
#fuses XT, NOWDT, NOPROTECT
#use delay(clock=4000000)

#use rs232(baud=2400, xmit=PIN_A1, rcv=PIN_A0)

#use fast_io (a)
#use fast_io (b)

SET_TRIS_A(0b00000001);
SET_TRIS_B(0x00);

int dato,conteo;

void main(void)
{
output_b(0x00);
output_a(0x00);
while(1)
   {
   for(conteo=0x61;conteo<=0x7a;conteo++)
      {
      dato=conteo;
      putc(dato);
      delay_ms(1000);
      }
   }
}

Hay que hacer la interface del pin A1 del PIC a RD del puerto serial.

El 61 es la a en ASCII y el 72 es la z.

Título: RE: Microcursillo en C
Publicado por: Modulay en 23 de Noviembre de 2004, 01:44:00

Una buena idea darle un poco de vidilla a este cursillo.
Probado el programa de migsantiago en proteus y funcionando a la perfección.
Saludos

Título: RE: Microcursillo en C
Publicado por: Nocturno en 23 de Noviembre de 2004, 11:53:00

Con el ánimo constructivo de seguir aprendiendo, creo que hay unas instrucciones en el código que no aportan nada, al menos yo no lo veo claro.
Se trata de los SET_TRIS y los OUTPUT.

Título: RE: Microcursillo en C
Publicado por: rferrero en 24 de Noviembre de 2004, 10:02:00

Pues ... s¡, tienes gran parte de raz¢n. SET_TRIS_B(0xFF), pone como entradas todas las l¡neas del puerto B. Pero usando ciertos dispositivos o instrucciones, no hace falta poner ‚sto. A m¡ me ha ocurrido con unos sensores que he tenido que usar hace poco. De hecho, he dado la lata en el foro ... Sonrisa Gigante

Pero queda bien ponerlo y es un buen h bito de programaci¢n. Las maneras, el protocolo, el procedimiento, ... ya sabes.

Output es para sacar un valor por donde quieras (m s o menos). S¡, tambi‚n se puede poner de otras formas.

Esto lo que indica es que, como el castellano o espa¤ol, tenemos una gran variedad de recursos, lo cual hace al C un lengua muy interesante para programar.

Muchas risas

Título: RE: Microcursillo en C
Publicado por: migsantiago en 26 de Noviembre de 2004, 09:25:00

Ah, es que las puse para limpiar puertos jejeje, outport a y b.

Una pregunta...¿cuáles son todas las formas posibles de agregar comentarios a los programas de C? Sólo me acuerdo de /*blah*/

Gracias

Título: RE: Microcursillo en C
Publicado por: pocher en 26 de Noviembre de 2004, 09:58:00

La otra forma es: //Comentario

Título: RE: Microcursillo en C
Publicado por: Modulay en 26 de Noviembre de 2004, 09:58:00

// Esa que has puesto y esta son las que yo conozco
// Saludos Sonrisa Gigante

Título: RE: Microcursillo en C
Publicado por: David_TGN en 27 de Noviembre de 2004, 11:23:00

Hola buenas a todos, gracias por ste post me está ayudando mucho, pero ya que tengo una dudilla a ver si podeis ayudarme (soy un iniciado y me ido directamente al pic 18 y con programación en C de MPLAB):

Tengo un programa (PIC 18F252 a 32 MHz) y utilizo 3 interrupciones externas (Puerto B),así como tres timers para cada vez que acontece una de estas interrupciones.

Cada vez que acontece una INT, realiza una operación y inicializa un timer (4,8 microseg.) asociado a esa int

INT0 --> timer0
INT1 --> timer2
INT2 --> timer3

lo he hecho demil frmas diferentes pero na de ná, alguna idea para que continue probando.

Cuando llega una int, inhabilita las otras, ejecuta código interno, y sale..
Cuando acontece el final de un timerX , ejecutá código y sale..

Bueno, a ver si alguien me hecha un cable. (El programa en si controla tres convertidores, mediante la corriente de entrada a cada uno de ellos).. Con puertas logicas funciona de cine, pero con e PIC de momento no chuta.

no se si era el lugar mas adecuado para postear, pero bueno, en tal caso me lo decis y lo posteo donde deba...

Gracias..

David
Castellón - Barcelona

Título: RE: Microcursillo en C
Publicado por: Modulay en 28 de Noviembre de 2004, 10:56:00

Podrías crear un hilo en el subforo de C y plantear tu problema.Si pasteas el código ó al menos la parte que te da problemas será más fácil dar con el fallo.
Un saludo

Título: RE: Microcursillo en C
Publicado por: Modulay en 28 de Noviembre de 2004, 11:22:00

Que os parece si vamos construyendo ejemplos de código para el uso de todos y cada uno de los recursos y periféricos del pic,desde el simple uso de los puertos hasta I2C,PWM,AD,etc...
Tenía pensado en poner cada ejemplo de código con un esquema en proteus,alojados de forma individual en un pequeño espacio web de 30Mb que tengo,ó en el mismo foro,eso como vean ustedes.Así se puede orientar rápidamente a alguien que no tiene conocimiento o manejo con estas cosas.Yo de momento estoy haciendo uno para el uso del lcd,el conversor y el timero 0 todo en uno,aunque creo que sería mas didáctico hacerlos totalmente por separado y de forma específica y bien desarrollada.
¿Cómo lo ven?
¿Quien se pide el PWM?
¿Y la USART?

Título: RE: Microcursillo en C
Publicado por: gfp en 28 de Noviembre de 2004, 11:30:00

Modulay, me parece magnifico, esa idea es brillante, asi la persona que no tenga experiencia alguna en el asunto de los micros puede guiarse de la manera mas práctica. Y la idea de almacenarlos separadamente en ese espacio es mgnífico. De ser así me pido el capitulo de la USART.

gfp Sonrisa

Título: RE: Microcursillo en C
Publicado por: Modulay en 28 de Noviembre de 2004, 11:43:00

Uno menos para elegir,amigos!!
Gracias gfp.Cuando lo tengas me avisas y lo cuelgo.
Lo suyo es comentar los programas al máximo y destacar todo lo que uno crea q es digno de destacar.
Si no hay nadie que lo quiera para sí,yo voy a hacer un ejemplo para el uso de los puertos.
Saludos

Título: RE: Microcursillo en C
Publicado por: pocher en 28 de Noviembre de 2004, 11:46:00

Venga yo dejaré algunos ejemplillos en la carpeta de PWM.

Podemos dejar ejemplos en las carpetas que queramos, eso sí fundamental que sean ejemplos que sepamos que funcionan correctamente, a ser posible acompañados de la correspondiente simulación en PROTEUS.

Un saludo

Título: RE: Microcursillo en C
Publicado por: Modulay en 28 de Noviembre de 2004, 12:49:00

Ya tenemos algo más
¿Qué carpeta es esa,Pocher?

Título: RE: Microcursillo en C
Publicado por: pocher en 28 de Noviembre de 2004, 13:22:00

Me refería al espacio WEB del que dispones pues dividirlo en carpetas, E/S, A/D, RS232 , PWM etc, donde el que lo desee pueda meter ejemplos en cada una de ellas. A su vez dentro de cada carpeta incluir nuevas carpetas con el nombre del que deja los ejemplos:

Carpeta PWMPocherEjemplo1, Ejemplo2 ....
Carpeta PWMModulayEjemplo1, Ejemplo2 ....
Carpeta PWMgfpEjemplo1, Ejemplo2 ....

Incluso se podrían recopilar algunos de los ejemplos-proyectos que se han ido resolviendo a lo largo de la historia del FORO y tenerlos allí perfectamente ordenados.

Título: RE: Microcursillo en C
Publicado por: Modulay en 28 de Noviembre de 2004, 13:59:00

Me parece bien.
Conforme vayan saliendo cosas que añadir,se le puede ir dando estructura y forma.
De momento el espacio está vacío,en espera de ir añadiendo ejemplos.Ya hay una carpeta PWM en la que se pueden poner esos ejemplos.Aún tengo que hacer el diseño html para poder visualizar y navegar por los directorios,de momento solo se puede acceder a descargas directas de los archivos a través de la url

Título: RE: Microcursillo en C
Publicado por: Modulay en 28 de Noviembre de 2004, 16:13:00

Bueno,ya se puede navegar por los directorios.He creado varias carpetas para ir distribuyendo las cosillas que se vayan poniendo,pwm,adc,puertos E/S....

La dire es

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

He colocado un ejemplo de uso de memoria ram externa,probado y funcionando gracias a la inestimable ayuda de manex_1987,está aqui
Saludos

Título: RE: Microcursillo en C
Publicado por: migsantiago en 28 de Noviembre de 2004, 19:19:00

Qué bien está la idea de publicar programas básicos para que todos les entendamos.

Tal vez sería más fácil publicarlos en un Maletín de Yahoo como en otros subforos le han hecho, así cualquiera puede agregar lo que quiera.

También sería bueno que hubiera una lista completa y actualizada de todos los códigos que suban para no tener que andar preguntando a medio mundo dónde está cada cosa. Esta lista sería bueno ponerla al principio de este tema.

Ya que estoy aquí... tengo una pregunta...

En C para computadora hay una función que genera números random: numero=randomize(100);

Esa saca un número del 0 al 100 y lo pone en numero.

¿Existe una función así en los PIC?

Giño

Título: RE: Microcursillo en C
Publicado por: pocher en 29 de Noviembre de 2004, 00:44:00

Son estas:

RAND()

Syntax:
re=rand()

Parameters:
None

Returns:
A pseudo-random integer.

Function:
The rand function returns a sequence of pseudo-random integers in the range of 0 to RAND_MAX.

Availability:
All devices

Requires
#include <STDLIB.H>

Examples:
int I;

I=rand();

Example Files:
None

Also See:
srand()

-----------------------------------------------------------------------

SRAND()

Syntax:
srand(n)

Parameters:
n is the seed for a new sequence of pseudo-random numbers to be returned by subsequent calls to rand.

Returns:
No value.

Function:
The srand function uses the argument as a seed for a new sequence of pseudo-random numbers to be returned by subsequent calls to rand. If srand is then called with same seed value, the sequence of random numbers shall be repeated. If rand is called before any call to srand have been made, the same sequence shall be generated as when srand is first called with a seed value of 1.

Availability:
All devices.

Requires
#include <STDLIB.H>

Examples:
srand(10);

I=rand();

Example Files:
None

Also See:
rand()

Un saludo

Título: RE: Microcursillo en C
Publicado por: pocher en 29 de Noviembre de 2004, 04:05:00

Sí que convendría que las simulaciones en PROTEUS funcionasen 100% y si esto no es posible indicar que físicamente funciona pero que en PROTEUS no.

El ejemplo de la RAM para que os simule en PROTEUS se deben de hacer las siguientes correcciones (tonterías, pero si no las corriges no va):

- Comentar la línea de los FUSES (con los fuses no funciona)

- Comentar la línea del #define use_portb_lcd TRUE ya que está repetida en el lcd.c

- Corregir las conexiones a la LCD en el circuito.

Título: RE: Microcursillo en C
Publicado por: Modulay en 29 de Noviembre de 2004, 04:59:00

Son detalles q se me han escapado lo del orden de los pines del lcd,depende de como lo tengas configurado.A mi me simula perfectamente.Si añades la línea "define use_port_b_lcd TRUE" en el código no es necesario descomentarla del fichero "lcd.c" (ya depende de como lo quiera cada uno).Nocturno,en cuanto a los retardos,la mayoria de ellos no son necesarios.Unicamente los he usado para que se vea con claridad en la gráfica de simulación las transiciones y el orden cronológico de las señales.Como mejora,se pueden implementar las señales CS colocando un decoder entre el pic y los módulos.Así,por ejemplo,con tres pines del pic se pueden controlar hasta 8 pastillas de memoria.El tema de donde almacenar los códigos...planteé esta cuestión de almacenarlos en un espacio web porque es mas fácil y directo acceder a ellos con un simple enlace.Se puede colocar una lista con los contenidos e ir actualizándola.De momento se ve pobre pq falta relleno!!
Con idea de cambiar el orden de los pines del lcd del archivo proteus ¿cúal era el orden por defecto?

Título: RE: Microcursillo en C
Publicado por: pocher en 29 de Noviembre de 2004, 05:40:00

Este es el orden que viene por defecto en el fichero lcd.c de CCS:

B0(D0) ---> E
B1(D1) ---> RS
B2(D2) ---> R/W

B4(D4) ---> D4
B5(D5) ---> D5
B6(D6) ---> D6
B7(D7) ---> D7

Título: RE: Microcursillo en C
Publicado por: Modulay en 30 de Noviembre de 2004, 08:05:00

Ya hay colgado un ejemplo para el uso de la usart realizado por gfp:

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

Gracias gfp
Saludos

Título: RE: Microcursillo en C
Publicado por: pocher en 30 de Noviembre de 2004, 10:40:00

Modulay ¿como hacemos para enviar los ejemplos?

Título: RE: Microcursillo en C
Publicado por: Modulay en 30 de Noviembre de 2004, 10:57:00

Pocher,mandamelos por privado y los cuelgo en un plis

Título: RE: Microcursillo en C
Publicado por: pocher en 30 de Noviembre de 2004, 13:34:00

Te envio 2 sencillos, a ver si la gente se va animando y crecen las carpetas de participantes.

PD. Recorcho, ahora que recuerdo el tema de enviar ficheros adjuntos no funcionaba. Ya me dices si te ha llegado el .rar

Título: RE: Microcursillo en C
Publicado por: Modulay en 30 de Noviembre de 2004, 13:56:00

Pues no,miarroba lleva unos dias mosqueada con los adjuntos.
Animense,llenemos las carpetas de programitas ejemplo

Título: RE: Microcursillo en C
Publicado por: migsantiago en 30 de Noviembre de 2004, 17:11:00

Gracias Pocher por la info, realmente no pensé que el CCS pudiera generar randoms.

Me pregunto cómo le hará para generar un número random, porque en esamblador es imposible generarlo sin la intervención de algún factor externo al PIC, ejemplo... presión de un botón por un usuario.

Voy a modificar un programa que tengo en AVR que hace la salida de un dado, lo haré en C para PIC. Giño

Título: RE: Microcursillo en C
Publicado por: Nocturno en 30 de Noviembre de 2004, 17:29:00

MigSantiago, si en ensamblador fuera imposible generar un número aleatorio, también lo sería en C, puesto que los comandos de C cuando se compilan se traducen a ASM.

Y sí, estoy contigo en que sin una intervención externa, no se puede tener aleatoriedad pura, pero se puede aproximar bastante.

Mira el ejemplo que TodoPic publicó hace poco para generar randoms en ASM:
http://miarroba.com/foros/ver.php?foroid=6510&temaid=2950691

Título: RE: Microcursillo en C
Publicado por: electronando en 30 de Noviembre de 2004, 19:43:00

la verdad felicito a ustedes por hacer posibl este microcursillo y que pronto se convierta en un señor curso la verdad yo uso el pic basic pero creo que vi que la tendncia por ejemplo a los dspics es hacerlo en lenguaje c esa es la tendencia y ustedes estan sembrando amigos Sonrisa Gigante

Título: RE: Microcursillo en C
Publicado por: Modulay en 01 de Diciembre de 2004, 07:37:00

Amigos,ya tenemos dos ejemplos de uso del PWM,obra de pocher:

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

Pocher,no sé si estaré haciendo algo mal,pero el segundo ejemplo no consigo simularlo,me da error.

También contamos con un ejemplo de comunicaciones serie,gracias al amigo migsantiago:

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

...lo he colocado en la carpeta "USART" aunque no sé si será el lugar indicado,ya que no hace exactamente uso de la usart del pic ¿no? ¿diferenciamos entre usart y comunicación serie pura y dura?

Saludos

Título: RE: Microcursillo en C
Publicado por: pocher en 01 de Diciembre de 2004, 10:44:00

Lo he bajado para probar y sí que va. Que alguién más lo pruebe y lo comente. Si eso lo vuelvo a subir.

PD. Yo pondría una carpeta RS232 (con o sin USART) y otra RS485

Título: RE: Microcursillo en C
Publicado por: Nocturno en 01 de Diciembre de 2004, 11:54:00

A mí también me falla, Pocher. Este es el mensaje de error:

N.B. 3rd party assemblers such as MPASM, ASEM51, ASM11 and AVRASM can be installed using the Proteus SETUP program.

Build FAILED with 1 error(s).

Título: RE: Microcursillo en C
Publicado por: Elecman en 01 de Diciembre de 2004, 12:07:00

Hola!! soy novato en el foro y este minicursillo me parece muy interesante.
Debido a que debo realizar un proyecto tengo que aprender como programar PIC"s en C, ya que lo había hecho ya en MPLAB, pero las necesidades requieren el C, Bueno se podria decir que me obligan.

Más adelante os contare de que va el proyecto, pero aún tengo que recopilar un poco de información.De momento, si me pudierais pasar el compilador que usais, os estaría muy agradecido. Merçis Giño

Título: RE: Microcursillo en C
Publicado por: Elecman en 01 de Diciembre de 2004, 12:07:00

Título: RE: Microcursillo en C
Publicado por: Modulay en 01 de Diciembre de 2004, 13:06:00

Dicho y hecho.Carpetas RS232 y RS485 disponibles.Una vacía y otra que cuenta con un par de ejemplos.
Elecman,la mayoría usamos el compilador PCWH.Lo encontrarás en la red,hay multitud de versiones.
Saludos

Título: RE: Microcursillo en C
Publicado por: Elecman en 01 de Diciembre de 2004, 17:04:00

Gracias Modulay, voy a hacerme con el programa y aprenderlo un poco, seguramente que tendreis noticias mias.

saludos, elecman...... Giño

Título: RE: Microcursillo en C
Publicado por: migsantiago en 01 de Diciembre de 2004, 18:56:00

Gracias por publicar el archivo Modulay, estuvo bien que le agregaras el DSN de Proteus. Giño

Lo malo es que no he bajado la última versión de Proteus y no me lo corre Enfurruñado

Una recomendación, no hagas tantas carpetas en tu servidor, veo que hiciste una para mí, pero al momento de andar buscando información, uno se va a cansar de buscar con tanta carpeta que va a haber, ¿no crees? Giño

Título: RE: Microcursillo en C
Publicado por: Nocturno en 02 de Diciembre de 2004, 00:17:00

Yo lo he recompilado y no me ha dado errores. Pero no lo puedo simular.

Título: RE: Microcursillo en C
Publicado por: Sergio_Pic en 02 de Diciembre de 2004, 06:30:00

Hola, soy nuevo aquí.
Antes que nada quiero daros un saludo a todos. Giño

Mi duda es muy profana a estas alturas de topic, pero agradeceria mucho vuestro consejo.

La razón de mi duda es que me gustaria conocer el software que debo utilizar para programar un pic con C. Me he instalado el PWC de CCS pero durante la instalacion me pide el mplab.ini, ¿tengo q instalar el MPLAB.exe?.
Tengo entendido que para realizar simulaciones lo mas apropiado es el PROTEUS (que es lo que gastaré ya que todavia no tengo tarjeta entrenadora...).
¿PROTEUS de limita tan solo a la simulación o podria suplantar en algún caso a un editor/compilador?

Espero que mi duda no resulte muy ofensiva Angelito

Muchas gracias.
Espero poder ayudar en el foro en un futuro cercano.

Título: RE: Microcursillo en C
Publicado por: pocher en 02 de Diciembre de 2004, 06:51:00

No para usar el compilador de CCS no hace falta el MPLAB.

Para "disparar" el CCS desde el MPLAB sí que hace falta que instales un programita llamado plug-in que está en la pg. de CCS.

El PROTEUS por defecto lleva un editor, que es bastante pobre. Te recomiendo un editor en colores, el del PCW de CCS lo lleva, el de MPLAB también es bueno y yo uso el ULTRAEDIT.

Un saludo

Título: RE: Microcursillo en C
Publicado por: Sergio_Pic en 02 de Diciembre de 2004, 07:28:00

Muchas gracias por las aclaraciones.
Hasta pronto.

Título: RE: Microcursillo en C
Publicado por: lovando en 02 de Diciembre de 2004, 12:27:00

Hola

la funcion main() puede llevar main(void) o void main(), pues asi lo he visto

Kien me puede aclarar esto, por qué se usa void, para que sirve, y por qué a veces simplemente no se usa??

Gracias

Título: RE: Microcursillo en C
Publicado por: migsantiago en 02 de Diciembre de 2004, 12:37:00

Según tengo entendido, todas las funciones de C tienen un tipo de dato y regresan un valor cuando terminan.

En este caso main es la función principal, así que no importa que no regrese algún valor al terminar de ejecutarse, por eso se le pone:

void main(void); el tipo de función es void y el tipo de dato que regresa es void, es decir, no importan.

Si no mal recuerdo se puede hacer algo así:

suma(dato_x)
{
dato_x=10;
return dato_x;
}

y en el programa se le pone

dato_a=suma();

Si ando medio perdido por favor corríjanme Sonrisa

Título: RE: Microcursillo en C
Publicado por: Khronos_Nieto en 02 de Diciembre de 2004, 16:54:00

Hola migsantiago:

Yo creo que el comando "return" es exclusivo para las funciones. La forma de definir una función (la función "Suma") sería la siguiente:

int Suma(int aux)
{
return (aux+10);
}

Esta función devuelve un valor de tipo "int", y tiene como parametro de entrada otro "int". Por lo que los tipos de datos deben de coincidir tanto en la cabecera como en la llamada a la función.

Esta función podría ser llamada de la siguiente forma

resultado=Suma(num);

Espero que sirva de ayuda...
Saludos..

Título: RE: Microcursillo en C
Publicado por: Elecman en 02 de Diciembre de 2004, 18:00:00

Hola pichi yo soy nuevo aqui pero creo que una función VOID es una función vacia.
¿que quiere decir?

Quiere decir que no necesita ninguna variable de entrada.
ej:
...
int a;
int x;

FUNCIÓN(VOID)
{
return a + x;
}
otra forma:
FUNCIÓN(int x,int a)
{
return a + x;
}

La diferencia de estas dos funciones radica en la forma de llamarlas:

En la primera llamariamos solo a la función y las variables X y A ya estarian definidas en otra parte del programa.(Variables globales).

En la segunda las variables X y A solo estan definidas dentro de esa función
con lo que X y A son variables difenrentes de cualquier otra variable X y A definidas fuera de esa función.(variables locales).

Espero que te sirva de ayuda Pichi, aunque yo también soy un poco novato en C.
Saludos de Eleman.

Título: RE: Microcursillo en C
Publicado por: Modulay en 02 de Diciembre de 2004, 18:08:00

Estoy con el amigo Khronos.
migsantiago,no estoy muy seguro de que eso se pueda hacer,al menos tal y como lo has escrito.Es posible que un procedimiento devuelva un tipo "void",pero no creo que esto se pueda usar alegremente para mezclarlo con variables numericas.
Lo que si te apuedo asegurar,tal y como apunta Khronos,es quelos parámetros de la llamada deben coincidir con los de la cabecera del procedimiento.
En cuanto a lo que comentaste sobre las carpteas de los ejemplos C,no creo que sea demasiado lío tal y como está distribuído.Si conforme vaya creciendo en contenido (y espero que crezca mucho!!!) vemos que se puede hacer de forma mas ordenada pues se cambia y ya está.
Por cierto,pocher me volvió a enviar el ejemplo de pwm que no funcionaba,lo he probado y ya simula a la perfección.Ya está disponible para bajar.
Saludos

Título: RE: Microcursillo en C
Publicado por: MGLSOFT en 03 de Diciembre de 2004, 05:21:00

Escrito originalmente por pic-chi
Hola

la funcion main() puede llevar main(void) o void main(), pues asi lo he visto

Kien me puede aclarar esto, por qué se usa void, para que sirve, y por qué a veces simplemente no se usa??

Gracias

Hasta donde da mi corto entendimiento del C, cuando declaras una funcion el modificador colocado antes del nombre indica que tipo de datos devuelve esa funcion, para VOID le indicas que la funcion no devuelve nada.
En el caso del modificador puesto dentro de los parentesis, indicara el tipo de datos que puede recibir como parametros esta funcion, para VOID nuevamente indica que no necesita estos parametros.

Segun creo si declaras VOID Funcion (VOID) o Funcion () es exactamente lo mismo, en apariencia el modificador VOID es el tomado por default cuando no existe otro modificador declarado.

Espero haya dejado algo claro... Sonrisa Gigante

Título: RE: Microcursillo en C
Publicado por: Modulay en 04 de Diciembre de 2004, 02:24:00

Tras darle unas pocas vueltas al asunto,termino por darte la razón,migsantiago,con respecto a la distribución de los archivos en el servidor.A poco que ha crecido el contenido,ya se estaba haciendo algo enredado,así que he procurado hacerlo más simple para que sea más fácil encontrar las cosas.
Más ejemplos:
Uso del timer1,obra de manex_1987:

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

Ejemplo de uso del acelerómetro ADXL213,por el amigo Nocturno66:

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

Saludos

Título: RE: Microcursillo en C
Publicado por: oshow en 04 de Diciembre de 2004, 06:47:00

Escrito originalmente por MGLSOFT

Segun creo si declaras VOID Funcion (VOID) o Funcion () es exactamente lo mismo, en apariencia el modificador VOID es el tomado por default cuando no existe otro modificador declarado.

Creo que eso es en C++, pero en C el tipo de retorno y los parametros de las funciones por defecto son enteros (int), lo que no se ahora es como lo toma el compilador ccs, llevo una temporada larga sin tocarlo y estoy dudando Avergonzado

.

Un saludo.

Título: RE: Microcursillo en C
Publicado por: David_TGN en 04 de Diciembre de 2004, 11:10:00

Buenas, a ver si alguien me puede explicar como programar los timers (0, 1 y 3) del pic 18f252 para generar interrupciones cada 4.8 microseg. y cada 0.8 microseg.

¿Es posible?¿se tiene que configurar el pic para 32 MHz no?

Si se puede hacer, una vez dentro del timerX hay que borrar por software el registro de habilitación por interrupción.

Seria interesante verlo para compiler c18

yo estoy en ello, cuando más o menos funcione os lo pongo, ..pero mientras alguien puede sugerirme algo?

hasta luego cracks

Título: RE: Microcursillo en C
Publicado por: gfp en 04 de Diciembre de 2004, 13:38:00

La verdad lo veo un poco complicado en C, aunque no es el mejor código pero se intentó. Cristal de 40 Mhz

#include <16f876.h>
#fuses XT, NOPROTECT, PUT, NOWDT, NOBROWNOUT, NOLVP, NOCPD, NOWRT
#use delay (clock=40000000)
#use fast_io(A)
#use fast_io(B)

#int_TIMER0
void TIMER0_isr()
{
      output_bit(pin_b2,1);
}
void main()
{
   set_tris_b(0x00);
   setup_timer_0(RTCC_INTERNAL | RTCC_DIV_1 | RTCC_8_BIT);

   enable_interrupts(INT_TIMER0);
   enable_interrupts(GLOBAL);
   set_timer0(212);
   for(; Giño

{}
}

Intenté realizarlo en asm y los resultados sdon mejores. Al parecer para el control de tiempos específico es mejor utilizar asembler.

   LIST P=PIC16F876
#INCLUDE <P16F876.INC>
      ORG   00
      GOTO   INICIO
      ORG   04
      BTFSS INTCON, T0IF      ; Timer has overflowed
      RETFIE               ;NO
      NOP                  ;YES
      NOP
      RETFIE
INICIO   BCF   STATUS,RP1
      BSF   STATUS,RP0
      CLRF   TRISA
      CLRF   TRISB
      CLRF   TRISC
      MOVLW   0XC4
      MOVWF   OPTION_REG
      MOVLW   0X07
      MOVWF   ADCON1      ;RA, PINES DIGITALES
      BCF   STATUS,6
      BCF   STATUS,5
      CLRF   PORTA
      CLRF   PORTB
      CLRF   TMR0
      CLRF   INTCON
      BSF      STATUS,RP0   ; Bank1
      MOVLW 0xC0
      MOVWF OPTION_REG      ; Timer0 increment from internal clock with a prescaler of 1:16.
      BCF STATUS, RP0 ; Bank0
      BSF INTCON, T0IE ; Enable TMR0 interrupt
      BSF INTCON, GIE ; Enable all interrupts
      MOVLW   .233
      MOVWF   TMR0
      GOTO   $
      END

gfp Sonrisa

Título: RE: Microcursillo en C
Publicado por: migsantiago en 07 de Diciembre de 2004, 09:48:00

Hola a todos

Pues ya le di uso a la función rand() que me recomendó Pocher.

Hice el programa del dado electrónico que está en el foro de AVRs pero ahora con PIC y en C. :]

Hay que hacer un cambio a la librería stdlib.h. Al valor RANDOM_MAX hay que ponerle el número máximo (más uno) que uno espera entregue la función rand();.

Les agrego el programa. Luego le mando el DSN de proteus a Modulay. Ah y en el programa pueden ahorrarse líneas de programación.

Ah y la idea de hacer un dado electrónico se la copié a Carlete. :c)

//Programa que genera la salida de un dado electrónico con PIC
//migsantiago@tutopia.com
//dado electrónico
//B0   B1   B2   B3   B4   B5   B6   B7
//1   2   3   4   5   6   7   NC

// _______
//   1|O 4 O|5
//   2|O O O|6
//   3|O O|7
//    -------

#include <16F84.h>

/*Para random de 6 modifique stdlib.h*/
//RANDOM_MAX=6
#include <D:santiagoPICsprogramasc_dadoSTDLIB-dado.H>

#use delay(clock=4000000)
#fuses XT,NOWDT,NOPROTECT

#use fast_io(B)
#byte portb = 0x06
#byte porta =0x05

void main()
{
int x_numero;
set_tris_b(0b00000000); /*PtoB salida*/
set_tris_a(0xff); /*PtoA entrada*/

output_b(0x00); /*Limpio puerto*/

while(1){
if (input(PIN_A0)==1)
{
x_numero=rand(); /*Saca un random 0 a 5 en x*/
if(x_numero==0) /*Cayó 1*/
{
portb=0x08; /*Prende 4*/
delay_ms(1000);
}
if(x_numero==1) /*Cayó 2*/
{
portb=0x41; /*Prende 1 7*/
delay_ms(1000);
}
if(x_numero==2) /*Cayó 3*/
{
portb=0x49; /*Prende 1 4 7*/
delay_ms(1000);
}
if(x_numero==3) /*Cayó 4*/
{
portb=0x55; /*Prende 1 3 5 7*/
delay_ms(1000);
}
if(x_numero==4) /*Cayó 5*/
{
portb=0x5d; /*Prende 1 3 4 5 7*/
delay_ms(1000);
}
if(x_numero==5) /*Cayó 6*/
{
portb=0x77; /*Prenden todos menos el 4*/
delay_ms(1000);
}
}
}
}

Título: RE: Microcursillo en C
Publicado por: Modulay en 07 de Diciembre de 2004, 10:39:00

migsantiago,no es necesario modificar el fichero stdlib.h.
Basta con definir el valor de RAND_MAX antes del include correspondiente:

#define RAND_MAX 6
#include "stdlib.h"

Pos eso,un curioso ejemplo de generación de números completamente aleatorios.
Gracias migsantiago Sonrisa

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

SALUDOS

Título: RE: Microcursillo en C
Publicado por: migsantiago en 07 de Diciembre de 2004, 11:30:00

Ohhhh, ahora entiendo. Lo que hice fue definirlo después del include, me regañaba que porque ya lo había declarado dos veces.

Gracias Muchas risas

Título: RE: Microcursillo en C
Publicado por: migsantiago en 08 de Diciembre de 2004, 08:29:00

Estoy con un problemita... no logro echar a andar este programa:

#include "16f877.h"
#use delay(clock=4000000)
#fuses xt,nowdt,noput,nobrownout,nolvp,noprotect

#use fast_io(a)
#use fast_io(b)
#use fast_io(c)
#use fast_io(d)
#use fast_io(e)

#byte porta = 0x05
#byte portb = 0x06
#byte portc = 0x07
#byte portd = 0x08
#byte porte = 0x09

//Este programa sólo checa si las terminales del
//PIC16F877A están funcionando correctamente

void main(void)
{
int unos,ceros;
unos=0xff;
ceros=0x00;

while(true){
output_a(unos);
output_b(unos);
output_c(unos);
output_d(unos);
output_e(unos);
delay_ms(1000);

output_a(ceros);
output_b(ceros);
output_c(ceros);
output_d(ceros);
output_e(ceros);
delay_ms(1000);
}
}

Se supone que enciende y apaga todos los puertos del 877a, pero ya que lo conecto, no prende ninguno. No tiene ningún fusible activado (WDT, LVP no se qué... etc.)

Sé que hay que ponerle unas instrucciones que indiquen que los puertos son digitales, por ejemplo el A, que no sea análogo... pero no me las sé... Sonrisa Gigante

Podría alguien explicarme que le falta a mi programa... tal vez sólo sea un error mínimo. Vacilando

Bueno, y hablando de otra cosa, hace tiempo programé mi 877a con un programa en ensamblador que prendía y apagaba el puertoB, pero extrañamente el Puerto B PB3 no hacía nada. Yo pensaba que estaba quemado, pero ya que lo programé ayer, ya funcionó... ¿a qué se debe? Recuerdo que activaba el fusible LVP y ayer no lo activé.

Título: RE: Microcursillo en C
Publicado por: oshow en 08 de Diciembre de 2004, 11:49:00

Si usas las directivas fast_io(), tienes que definir como quieres que sean los puertos (con la sentencia set_tris_X), si de entrada o salida, si no usas las directivas, el compilador realiza esta operacion automaticamente (con lo cual el programa también funcionará).

Prueba a realizarlo de ambas formas ya verás como va.

En cuanto a la pregunta sobre lo del LVP, no sabria responderte, ese fuse se activa para la programacion en bajo voltaje, ahora bien no se en que puede haber influido ese fuse para el funcionamiento de ese pin.

Un saludo.

Título: RE: Microcursillo en C
Publicado por: CharlyM en 08 de Diciembre de 2004, 22:13:00

Hola, mi problema es q nesecito conectar 2 pics 16f84, y hacer una especia de chat conectandoles tambien un teclado y un lcd, pero no se ni configurar y sacar los datos por el lcd, ademas todo es simulado en el proteus y uso un lcd de 16x2, si alguien puede ayudarme

Título: RE: Microcursillo en C
Publicado por: migsantiago en 09 de Diciembre de 2004, 13:27:00

Gracias por la respuesta. Checaré sus sugerencias. Luego subo el programa funcionando.

Por otro lado, CharlyM, te dejo este programa en C para el control de la LCD. Sólo define como el puerto de salida de la LCD el puerto B del 16f84a:

#define use_portb_lcd TRUE

En el que yo escribí está el puerto D como salida predeterminada.

Al escribir tu programa checa el archivo lcd.c que trae tu compilador para que hagas los cambios necesarios.

#include "16f877.h"
#use delay(clock=4000000)
#fuses nowdt,noput,nobrownout,nolvp,noprotect
#include "lcd.c"

#use standard_io (D)

//migsantiago
// As defined in the following structure the pin connection is as follows:
// D0 enable
// D1 rs
// D2 rw
// D4 D4
// D5 D5
// D6 D6
// D7 D7
//
// LCD pins D0-D3 are not used and PIC D3 is not used.
void main(void)
{
lcd_init(); //Inicia LCD
while(1){

lcd_putc(" Santiago
"); //Saca texto
delay_ms(1000);

lcd_putc(" PIC16F877A");
delay_ms(1000);

lcd_putc("f"); //Limpia pantalla
delay_ms(1000);

lcd_putc(" :) :(
");
delay_ms(1000);

lcd_putc(" XD :-P");
delay_ms(1000);

lcd_putc("f");
delay_ms(1000);

}
}

Título: RE: Microcursillo en C
Publicado por: CharlyM en 10 de Diciembre de 2004, 00:07:00

Hola, de nuevo
Gracias por la repuesta pero ya intente implementarlo y me salen los siguientes errores

Error[000] C:Documents and SettingsCarlosEscritorioPICS2.c 2 : Illegal # command "use"
Error[000] C:Documents and SettingsCarlosEscritorioPICS2.c 3 : Illegal # command "fuses"
Error[000] C:HT-PICINCLUDElcd.c 17 : Cannot open include file "ztimer/include/debug.h"

estoy usando el picc de Ht con mplab, ademas de q no tenia el lcd.c aun q bueno ya lo baje pero no se si sea una buena version, bueno por fa si me pueden volver a ayudar, la verdad es q estoy verde en esto de pics y lcds loco

Título: RE: Microcursillo en C
Publicado por: pocher en 10 de Diciembre de 2004, 03:02:00

Eso es porque el programa de migsantiago está hecho para el compilador de CCS no para el de Ht (que dicho sea de paso desconozco).

Un saludo

Título: RE: Microcursillo en C
Publicado por: migsantiago en 10 de Diciembre de 2004, 08:30:00

Pues sólo te puedo recomendar que leas el manual de usuario que tu compilador trae incluido, es decir, la ayuda. Checa los comandos que puedes usar.

También puedes checar el archivo lcd.c que usaste y modificarlo para que corra tu programa.

Por ahora subo el programa del dado, pero ahora sale en la LCD el número que cae.

#include "16f877.h"
#use delay(clock=4000000)
#fuses nowdt,noput,nobrownout,nolvp,noprotect
#include "lcd.c"

#define RAND_MAX 6 //Número aleatorio máximo
#include "stdlib.h" //rand();

#use standard_io (D)

#use fast_io(B)
#byte portb = 0x06

//migsantiago
// As defined in the following structure the pin connection is as follows:
// D0 enable
// D1 rs
// D2 rw
// D4 D4
// D5 D5
// D6 D6
// D7 D7
//
// LCD pins D0-D3 are not used and PIC D3 is not used.

void main(void)
{
int x_numero; //random

lcd_init(); //Inicia LCD

set_tris_b(0xff); /*PtoB entrada*/

lcd_putc(" Bienvenido
"); //Saca texto
lcd_putc(" Dado Virtual"); //Saca texto
delay_ms(3000);

lcd_putc("f"); //Limpia pantalla
lcd_putc("Aprieta Switch
"); //Saca texto
delay_ms(1000);

while(1){

if(input(PIN_B0)==1)
{
delay_ms(500);
x_numero=rand(); /*Saca un random 0 a 5 en x*/
x_numero++; /*anula cero*/
printf(lcd_putc,"El dado cae en %u",x_numero);
lcd_gotoxy(1,2); /*Regresa a segunda línea*/
}
}
}

Ya me di cuenta que no conviene usar el rand(), porque genera números random, pero en la misma secuencia... siempre prende en 3 la primera caída del dado, luego 1, luego 4, etc. Lo mejor será usar el contador timer para generar los randoms.

Título: RE: Microcursillo en C
Publicado por: Modulay en 10 de Diciembre de 2004, 13:36:00

Tienes razón,migsantiago.La forma de solucionarlo es tener al timer siempre corriendo y capturar su valor en el momento de la pulsación,para coger ese valor y mandárselo a la rutina srand(unsigned int32 seed) como parámetro.De esta forma se consigue cambiar el valor de la semilla de la que la función rand() parte para generar el número aleatorio.He puesto el nuevo ejemplo del dado en la carpeta de ejemplos LCD:

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

Saludos

Título: RE: Microcursillo en C
Publicado por: migsantiago en 11 de Diciembre de 2004, 09:57:00

Gracias Modulay

Pues como veo tu servidor muy vacío todavía, te mando en un ratito un convertidor AD de temperatura con el LM35 y saca el dato al LCD.

En Proteus simulé el LM35 con un potenciómetro lineal, porque cuando conectaba el LM35 me regañaba y decía que algo estaba mal declarado o algo así. En la vida real el circuito sí funciona.

//Convierte señal analógica en RA0
//Usa LM35 para medir temperatura en °C
//La saca por un LCD

//LM35
//Vout=(°C)/100

//Vref=+2.5V en 16f877a (RA3)

// migsantiago
// Conexiones de la LCD:
// D0 enable
// D1 rs
// D2 rw
// D4 D4
// D5 D5
// D6 D6
// D7 D7
//
// LCD pins D0-D3 are not used and PIC D3 is not used.

#include "16f877.h"

#device adc=8 //Usa resolución de 8 bits
#use delay(clock=4000000)
#fuses xt,nowdt,noput,nobrownout,nolvp,noprotect

#include "lcd.c"
#use standard_io (D)
//#use fast_io (B)

//Puerto B sólo indica lectura digital

void main (void)
{
int medicion;
float temper;
// set_tris_b (0x00);

lcd_init(); //Inicia LCD
lcd_putc(" Digital
"); //Saca texto
lcd_putc(" Termometer"); //Saca texto
delay_ms(3000);
lcd_putc("f"); //Limpia pantalla
lcd_putc("Temperatura
"); //Saca texto
lcd_putc("actual"); //Saca texto
delay_ms(1000);
lcd_gotoxy(14,2); //Acomoda cursor LCD
lcd_putc("oC");

while (1)
{

lcd_gotoxy(8,2); //Acomoda cursor LCD
lcd_putc(" "); //Limpia ese sector de pantalla
lcd_gotoxy(8,2); //Acomoda cursor LCD

setup_adc (adc_clock_div_32); //Enciende ADC

//Elige terminales análogicas
//RA0 y RA1 miden, RA3 es Vref (2.5V)
setup_adc_ports (RA0_RA1_ANALOG_RA3_REF);

set_adc_channel (0); //Elige canal a medir RA0
delay_us (20);
medicion=read_adc (); //Hace conversión AD
setup_adc (adc_off); //Apaga ADC

// output_b(medicion); //Saca valor a portB
// delay_ms(1000);

temper=medicion*(0.9803); //Pasa binario a °C

printf(lcd_putc,"%03.1f",temper); //xxx.x °C
delay_ms (1000);
}
}

Hay que mejorar la resolución de este programa, ya que sólo usa un quinto de los 8bits en total.

Título: RE: Microcursillo en C
Publicado por: Modulay en 11 de Diciembre de 2004, 11:07:00

Gracias migsantiago por tu dedicación.A ver si se anima más gente.
Ya tenemos un ejemplo de uso del conversor AD:

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

Saludos desde Málaga,España

Título: RE: Microcursillo en C
Publicado por: YF-21 en 14 de Diciembre de 2004, 20:50:00

Me uno a la coperacha

Pues asi es ... este es el codigo que usé es para presionar una tecla de un teclado 4x4 en el micro master y esta aparece en el esclavo en un lcd...

Para el master ...

#include "16f877.h"
#fuses noprotect,nobrownout,noput,nowdt,nolvp
#use delay(clock=4000000)
#use standard_io(A)
#use standard_io(b)
#use standard_io(d)

#use i2c(MASTER, SDA=PIN_C4, SCL=PIN_C3,FAST,FORCE_HW)

int tecla=0,conta=0,x,corrim=8;

int getkey (conta)
{
i2c_start ();

i2c_write (254);

i2c_write (conta);

i2c_stop ();

output_a (conta);
delay_ms (1000);
}

void main ()
{
conta=0;
while (1){
for (x=0;x<=3;x++)
{
output_b(corrim);
output_d (conta);

if (input(PIN_B4))
{
getkey(conta);
}
conta++;
output_d(conta);

if (input(PIN_B5))
{
getkey(conta);
}

conta++;
output_d(conta);

if (input(PIN_B6))
{
getkey(conta);
}

conta++;
output_d(conta);

if (input(PIN_B7))
{
getkey(conta);
}
conta++;
rotate_right(&corrim,1);
output_d(conta);

}
conta=0;
corrim=8;
}
}--------------------------------------------------------------------------------

y slave ...

Codigo:--------------------------------------------------------------------------------#include "16f877.h"
#use i2c (slave, ADDRESS=254, scl=pin_c3, sda=pin_c4, fast, force_hw)
#use delay(clock=4000000)
#fuses noprotect,nobrownout,noput,nowdt,nolvp
#include "lcd.c"
#use fast_io (C)
#use standard_io (A)

int data;

void main ()
{
set_tris_c (0xff);
lcd_init ();
lcd_putc ("Esperando" Giño

;

while (1)
{
if(~input(PIN_c4))
{
data=i2c_read ();
if (data==254)
{
data=i2c_read ();
lcd_putc ("f" Giño

;
printf (lcd_putc, "El dato es el %i", data);
}
}
}
}

Si funciona pero no uso el i2c_poll, te envio por privado los archivos compilados y en proteus, OK Modulay ??

Título: RE: Microcursillo en C
Publicado por: migsantiago en 15 de Diciembre de 2004, 11:25:00

Vientos YF-21. Mejor mándale el archivo y el DSN a Modulay a su mail de hotmail. El messenger de arroba no sirve.

Les pongo un programa que lee datos de la memoria 24LC65 y el PIC16F84A los va sacando por el puerto B.

Mi programa es el siguiente (ya corregido):

//Programa que usa protocolo I2C para leer datos de
//la EEPROM I2C 24LC65 de 64kb (8kx8)

//migsantiago

#include <16f84a.h>
#fuses XT, NOWDT, NOPROTECT
#use delay(clock=4000000)

#use fast_io (a)
#use fast_io (b)

#use i2c(MASTER, SDA=PIN_A1, SCL=PIN_A0,slow)

#define hi(x) (*(&x+1))

//A la EEPROM hay que conectarle:
//A0=0
//A1=0
//A2=0
//Su dirección de llamada I2C será según 24LC65.pdf
// 1 0 1 0 A2 A1 A0
// es decir: 1010000 = 0x50

void main(void)
{

int dato_leido;
int16 retardo;
int16 address_eeprom; //8k palabras

retardo=500; //ms a tardar entre lectura y lectura
address_eeprom=0;

set_tris_a(0x00);
set_tris_b(0x00); //B salida
output_b(0x00); //Limpia B

while(1){

i2c_start(); //Inicia I2C
i2c_write(0xa0); //Direcciona 24LC65 RW=0
i2c_write(hi(address_eeprom)); //Le dice que quiere leer dirección 0x00...
i2c_write(address_eeprom); //00
i2c_start();
i2c_write(0xa1); //RW=1

for(address_eeprom=0;address_eeprom<=8191;address_eeprom++)
{
dato_leido = i2c_read(); //Lee actual dirección EEPROM
output_b(dato_leido); //Saca dato leído en 24LC65
delay_ms(retardo);
}

i2c_stop();
}
}

Mi programa lee lo que está grabado en la 24LC65 y pasa dato por dato al puerto B del 16f84a, espera 500ms entre dato y dato. A la 24LC65 de Proteus le cargué la 24C64 porque no hay 65 y aparte le cargué un buffer de información en archivo BIN para que salgan datos.

La dirección con la que hay que llamar a la EEPROM es 1 0 1 0 A2 A1 A0. Para lo cual yo ya conecté A0, A1 y A2 a tierra, lo cual convierte a la dirección en 1010000, es decir, 0x50.

Configuré A0 como SCL y A1 como SDA n el 16f84a. En proteus conecté una PULL-UP a SDA y SCL para asegurar el 1 lógico.

Bueno, hablando de otras cosas... necesito su ayuda... ¿cómo le hago para que en la instrucción PUTS que se usa con RS232 uno pueda mandar RETROCESO?

Cada que PUTS termina de mandar una cadena, manda un ENTER. A mí no me sirve eso, quiero mandar un retroceso para que no baje de línea. También me gustaría que me explicaran porfas cómo le hago para mandar un caracter ASCII al RS232.

Y... otra duda... tengo el C++ para MS-DOS y antes lo corría en windows me y 98, pero he oído que ya no genera las salidas de puertos (outport e inport) en windows XP. ¿Cómo le hago para usar los puertos en XP?

Muchas gracias, espero ser claro en mis preguntas. :]

Título: RE: Microcursillo en C
Publicado por: Nocturno en 15 de Diciembre de 2004, 11:36:00

Escrito originalmente por pocher
Son estas:

RAND()

Syntax:
re=rand()

Parameters:
None

Returns:
A pseudo-random integer.

Function:
The rand function returns a sequence of pseudo-random integers in the range of 0 to RAND_MAX.

Supongo que para muchos de vosotros es un método conocido, pero a mí me ha sorprendido y me ha parecido conveniente publicarlo.

Se trata de un curioso método para generar números aleatorios que alguien ha posteado en la Piclist Latina. Sólo es válido para micros con conversor Analógico/Digital.

El método consiste en dejar la patilla del conversor al aire y hacer una lectura de su valor cuando sea necesario un número aleatorio. La verdad es que he tenido la oportunidad de ver en un osciloscopio la lectura de un A/D al aire y es de lo más aleatorio del mundo.

Bueno, ahí queda eso, por si alguien lo puede aprovechar.

Título: RE: Microcursillo en C
Publicado por: David_TGN en 15 de Diciembre de 2004, 15:45:00

Hola a todos,

una pregunta,

en PIC 18F252 como detectais mediante la interrupción que tiene el timer0 4,8 microseg? y 0,8 microseg?

es posible hacerlo en C?

bueno, gracias de antemano,

saludos,

David

Título: RE: Microcursillo en C
Publicado por: Modulay en 15 de Diciembre de 2004, 18:13:00

Nocturno,no conocía ese método.Probaremos a ver que tal va.
migsantiago,he simulado tu archivo y no se iluminan los led.
A ver si alguien más lo puede probar:

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

A propósito ¿como funciona eso del archivo bin? me interesa el tema

David,si no me equivoco,para calcular el tiempo de interrupción del timer 0 (8 bits),sería una cosa así:

Frecuencia interrupción timer 0 = Fosc / [4 x preescaler x (256 - valor de carga)]

Siendo:
Fosc = frecuencia del cristal
preescaler = valor del preescaler
valor de carga = valor con el que cargas el timer tras cada interrupción

He colgado un ejemplo en el enlace que te puede venir bien:

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

Título: RE: Microcursillo en C
Publicado por: Nocturno en 15 de Diciembre de 2004, 23:58:00

Pues yo también lo he probado y tampoco funciona.

Título: RE: Microcursillo en C
Publicado por: migsantiago en 16 de Diciembre de 2004, 10:07:00

Pues la verdad no sé porque luego el Proteus anda haciendo cosas raras con los leds, pero se pueden ver las salidas encender, los cuadritos rojos y azules.

El archivo BIN es el archivo que supuestamente uno le carga en la vida real a la 24LC65, uno lo usa para programarla.

Si quieres ábrelo en WinPic800 y selecciona la memoria 24C64.

Le cargué la siguiente información:

0000: 0000 0001 0002 0003 0004 0005 0006 0007 ........
0008: 0008 0009 000A 000B 000C 000D 000E 000F ........
0010: 0010 0011 0012 0013 0014 0015 0016 0017 ........
0018: 0018 0019 001A 001B 001C 001D 001E 001F ........

En realidad son palabras de 8 bits, pero ICProg las muestra como de 16bits... loco

Si no cargara el archivo BIN en Proteus, las salidas en el puerto B del f84 serían puros 00 o puros FF, ya que la memoria no tendría cargado ningún archivo.

Las salidas que tendrán en el puertoB con el BIN cargado son (cada 500ms):

00 01 02 03 04 05 0607 08 09 0A 0B 0C 0D 0E 0F 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F

Si alguien llega a saber porque Proteus hace eso con los leds, por favor díganos como corregirlo. Sonrisa Gigante

Y porfas, también ayúdenme con mis dudas en el mensaje anterior. Enfurruñado

Título: RE: Microcursillo en C
Publicado por: Modulay en 16 de Diciembre de 2004, 12:40:00

Ahora mismo estoy en un PC q no tiene proteus,pero imagino q para asociar el .bin a la memoria basta con hacer lo mismo q se hace para asociar un hex al pic ¿no?
Con respecto a lo de las cadenas,o bien puedes modificar la librería q contiene dichas funciones,o bien te fabricas tus propias funciones,o bien te dedicas a mandar tus cadenas carácter a carácter con "putc".No se me ocurre alguna otra opción

Título: RE: Microcursillo en C
Publicado por: David_TGN en 16 de Diciembre de 2004, 13:43:00

Escrito originalmente por Modulay
Nocturno,no conocía ese método.Probaremos a ver que tal va.
migsantiago,he simulado tu archivo y no se iluminan los led.
A ver si alguien más lo puede probar:

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

A propósito ¿como funciona eso del archivo bin? me interesa el tema

David,si no me equivoco,para calcular el tiempo de interrupción del timer 0 (8 bits),sería una cosa así:

Frecuencia interrupción timer 0 = Fosc / [4 x preescaler x (256 - valor de carga)]

Siendo:
Fosc = frecuencia del cristal
preescaler = valor del preescaler
valor de carga = valor con el que cargas el timer tras cada interrupción

He colgado un ejemplo en el enlace que te puede venir bien:

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

Este sistema funciona para familia 16 paero para pic 18 en c? para timer 1 y timer 3?

saludos

David

Título: RE: Microcursillo en C
Publicado por: Modulay en 16 de Diciembre de 2004, 14:36:00

David,si a lo que te refieres es a la diferencia entre timer de 8 bits y timer de 16 bits simplemente es cambiar en la fórmula el 256 por un 65536 (16 bits).Esto es válido tanto para los 16 como para los 18,independientemente del lenguaje que uses.Se trata de un cálculo matemático.La forma de aplicarlo al pic ya es cosa de cada lenguaje.En la misma carpeta del ejemplo que puse hay otro ejemplo en C para el timer1

Título: RE: Microcursillo en C
Publicado por: YF-21 en 16 de Diciembre de 2004, 15:48:00

Aunque este mensaje deberia ir en simuladores, quisiera preguntar

¿Como se emulan las terminales del PC en proteus? o no se puede

Título: RE: Microcursillo en C
Publicado por: migsantiago en 17 de Diciembre de 2004, 11:00:00

YF-21, Modulay me hizo el archivo Proteus del RS232, yo no sabía que existía la hyperterminal en Proteus, si quieres chécalo:

http://personal.auna.com/asencio5/Ejemplos%20C/RS232/RS232_2%20por%20migsantiago.zip

Sí Modulay, el .BIN sólo se asocia a la EEPROM justo como los HEX o los COF se asocian a los PICS. Y ya corregí el programa porque en protoboard no me quedaba.

Tendré que checar la combinación de caracteres ASCII para el retroceso, porque en la tabla ASCII no viene, es una combinación de teclas, pero no me la sé.

Sobre lo del C++ de MS-DOS, ¿no saben si se pueden usar los puertos paralelo y serial en Windows XP?

Título: RE: Microcursillo en C
Publicado por: Nocturno en 18 de Diciembre de 2004, 00:45:00

No sé si funcionará, pero en MS-DOS el ASCII del retroceso era el 8 decimal, o sea, el octavo carácter de la tabla ASCII: CHR(8)

Título: RE: Microcursillo en C
Publicado por: migsantiago en 19 de Diciembre de 2004, 13:01:00

OK, gracias Nocturno, lo voy a checar.

Sobre lo de Turbo C de MS-DOS, ya compilé un programa que lee el puerto serial (lo que manda un PIC16f877a) y ya me muestra la información en pantalla... no sé como... pero pude usar el puerto serial sin que XP se pusiera rudo.

Tal vez sólo sea en mi compu, porque he leído que en otras no se puede.

Título: RE: Microcursillo en C
Publicado por: tornar en 20 de Diciembre de 2004, 09:54:00

Aqui os dejo un programilla que hice anoche, se trata del tipico juego de hacer parejas, tu introduces por teclado un numero del 1 al 6, y te sale un nombre, que tienes que enlazar con otro igual, cuando te aburras de jugar, pulsa 0 y puedes ver el numero de aciertos obtenidos.

Este programa ha sido probado por mi con el micropic trainer y micropic trainer plus, con las librerias KBD.C y LCD.C modificadas, por lo que no se si para que os funcione debereis cambiar algo.

#include <16f84a.h>
#fuses NOWDT,NOPROTECT,Xt
#use delay (clock=4000000)

#include <KBD.C>
#include <LCD.C>
#include <string.h>

main()
{
char nombre[3][8];
char k;
int par[2]={8,9};
int last[2]={0,0};
int cont=0; //contador de aciertos

strcpy(nombre[0],"Neo");
strcpy(nombre[1],"Morpheo");
strcpy(nombre[2],"Trinity");

lcd_init();
lcd_gotoxy(0,1);
printf(lcd_putc,"--MATRIX LINKS--
");
printf(lcd_putc,"num(1-6):");
WHILE (1)
{
IF ((last[0]+last[1]>=2) && (par[0] != par[1])) //Condicion de derrota
{
par[0]=8;
par[1]=9;
last[0]=0;
last[1]=0;
}

IF (par[0]==par[1]) //Condicion de Victoria
{
cont+=1;
printf(lcd_putc,"GRATS");
delay_ms(1000);
par[0]=8;
par[1]=9;
last[0]=0;
last[1]=0;
lcd_putc("f");
lcd_gotoxy(0,1);
printf(lcd_putc,"--MATRIX LINKS--
");
printf(lcd_putc,"num(1-6):");
}

lcd_gotoxy(10,2);
k=kbd_getc();
IF (k)
{
switch (k)
{
case "0": lcd_putc("f"); printf(lcd_putc," Has obtenido
%d aciertos",cont);
delay_ms(2000);
sleep();
break;
case "1": printf(lcd_putc,"%s",nombre[0]); par[0]=1; last[0]+=1; delay_ms(1000); break;
case "2": printf(lcd_putc,"%s",nombre[1]); par[0]=2; last[0]+=1; delay_ms(1000); break;
case "3": printf(lcd_putc,"%s",nombre[2]); par[0]=3; last[0]+=1; delay_ms(1000); break;
case "4": printf(lcd_putc,"%s",nombre[0]); par[1]=1; last[1]+=1; delay_ms(1000); break;
case "5": printf(lcd_putc,"%s",nombre[1]); par[1]=2; last[1]+=1; delay_ms(1000); break;
case "6": printf(lcd_putc,"%s",nombre[2]); par[1]=3; last[1]+=1; delay_ms(1000); break;
}
lcd_putc("f");
lcd_gotoxy(0,1);
printf(lcd_putc,"--MATRIX LINKS--
");
printf(lcd_putc,"num(1-6):");
}
}
}

Título: RE: Microcursillo en C
Publicado por: YF-21 en 21 de Diciembre de 2004, 15:18:00

Regresando al tema de las preguntas ...

Ya me baje el datasheet del reloj, junto con subrutinas del picc que me encontre en el foro. He visto algunos diagramas de pic con el DS1307 y todos llevan una eeprom serial conectada al DS1307 pero yo no entiendo el motivo.

El ds1307 tiene memoria ram para el almacenaje de los datos, asi que no le veo el caso anexarle una eeprom serial (excepto cuando se pierda la energia se podria hacer el respaldo del tiempo en la eeprom,< pero grabarla cada segundo? (ademas creo que para eso esta la bateria (respaldo)).

Conclusion: Creo que es mejor usar el reloj sin eeprom externa, o no??

(Por cierto, aun no he conectado el reloj porque me falta el cristal Vacilando

)

Título: RE: Microcursillo en C
Publicado por: David_TGN en 21 de Diciembre de 2004, 16:29:00

OpenTimer0(TIMER_INT_ON & T0_8BIT & T0_SOURCE_EXT & T0_EDGE_RISE);
WriteTimer0();

Exactamente el contaje del timer0 cuando empieza?, cuando se ejecuta writeTimer0?, o tenemos que activarlo de alguna manera..

La configuración del timer1 y del timer3 para que se ejecuten de la misma manera que el timer0 se podría de la siguiente manera?:
OpenTimer1(TIMER_INT_ON & T1_8BIT_RW & T1_SOURCE_EXT & T1_SYNC_EXT_OFF);

OpenTimer3(TIMER_INT_ON & T3_8BIT_RW & T3_SOURCE_EXT & T1_SYNC_EXT_OFF);

saludos y gracias,

david

Título: RE: Microcursillo en C
Publicado por: oshow en 22 de Diciembre de 2004, 04:08:00

Hola YF-21, así es, ese reloj (y el pcf8583 por ejemplo) traen una memoria incorporada, no es necesario usar una memoria externa, a no ser que necesites trabajar con muchos datos. Pero asegurate de usar la batería si le quitas alimentación que es una RAM!!

Hola David, en cuanto a la duda del timer, el timer0 empieza contar en cuanto le escribes un numero al tmr0, si la función Writetimer0() realiza eso (que por el nombre parece que sí) pues empezará a contar desde el momento que llames a esa función.

Por otra parte no te puedo ayudar más, dado que el codigo que has puesto no permite hacer más y uno no es adivino, además de que parece que trabajas con otro compilador distinto al ccs...

Te recomendaría que posteases todo el código para saber el pic con el que trabajas e indicar el compilador que usas, y si el post es muy largo no sería descartable que abrieses un nuevo tema para que los demás participantes puedan ayudarte.

Un saludo.

-----------------------
FELICES FIESTAS.

Título: RE: Microcursillo en C
Publicado por: carlyvalente en 23 de Diciembre de 2004, 02:01:00

Alguno me puede recomendar un buen link online para aprender C de micros?
Si es en ingles da igual.
Gracias.

Título: RE: Microcursillo en C
Publicado por: Nocturno en 23 de Diciembre de 2004, 02:48:00

Yo creo que uno de los mejores que hay es precísamente este subforo, y concretamente este hilo del foro, si lo lees desde el principio.
Yo estoy aprendiendo aquí.

Título: RE: Microcursillo en C
Publicado por: migsantiago en 23 de Diciembre de 2004, 13:28:00

Oye YF-21... ¿qué hace el DS1307?

Título: RE: Microcursillo en C
Publicado por: YF-21 en 26 de Diciembre de 2004, 14:21:00

El ds107 es un reloj de tiempo real con comunicacion i2c (solo 2 cables !!!)

Título: RE: Microcursillo en C
Publicado por: gustav03 en 04 de Enero de 2005, 21:01:00

Hola !
FELIZ AÑO NUEVO Rebotado

Bueno estoy leyendo el desde el comienzo de este curcillo de c y me gusta la idea Fumador

cuando estaba contento que entendia algo de asm encontre la posibilidad de hacerlo con c .De programacion c c++ se alguito nomas Payaso

me baje el HI-TECH DEMO y el PCW (PIC C compiler DEMO) y encontre que es mas completo el primero en cuanto a librerias para cosas como calculos y manejo de strings pero poco para cosas como LCD .en cambio el segundo tiene lo contrario .se podria encontrar librerias para el primero ?
Les deseo un buen año !! Fumador

Pd.: en cuanto me ponga en campaña aporto con ideas por ahora estoy leyendo y aprendiendo Payaso

Título: RE: Microcursillo en C
Publicado por: Lager. en 04 de Enero de 2005, 22:32:00

Escrito originalmente por carlyvalente
Alguno me puede recomendar un buen link online para aprender C de micros?
Si es en ingles da igual.
Gracias.

Que onda carlyvalente,
Pues este link es el mejor y en tu idioma, ahora que si buscas bibliografias basica para entender todo lo aqui expresado(en especifico c para microscon ccs), te recomiendo el libro
PICmicro MCU C®
An introduction to programming
The Microchip PIC in CCS C
By Nigel Gardner
, de ahi te estudias TODO el manual y te revizas todos los ejemplos que trae(abarca todo lo que necesitarias para aprender), si hubiese duda, posteala y te la responderemos efectiva y rapidamente. Creo que seria la forma mas optima y rapida(ya que tu llevarias tu ritmo de aprendizaje) para aprender, sin olvidar lo mas importante, ponerlo en practica y haciendo los ejmplos de todas las formas posibles.

Pana gustav03, no seria mas facil si hicieras la libreria? Sonrisa

, aunque por ahi hay bastantes ejemplos con HiTech usando dispositivos poco usados(de ahi obtendrias la libreria)

Salu2

Título: RE: Microcursillo en C
Publicado por: doppel en 06 de Enero de 2005, 08:20:00

Hola Lager! estoy siguiendo el cursillo es por demas interesante ! y muy explicativo!!! asi da gusto... felicitaciones a todos..

con respecto al link !! no me aparece loco

saludos.-

Título: RE: Microcursillo en C
Publicado por: Lager. en 06 de Enero de 2005, 11:37:00

Hola pana doppel,
Asi es, es el mejor este curso en c aplicado a micros, aunque no se a que link te refieres pana??? loco

, por favor dime cual es el que te falla.
Un salu2 pana

Título: RE: Microcursillo en C
Publicado por: Modulay en 09 de Enero de 2005, 17:39:00

Magnífico ejemplo con i2c elaborado por Lager.

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

A seguir así !!

Gracias Lager.

Título: RE: Microcursillo en C
Publicado por: Lager. en 09 de Enero de 2005, 19:38:00

Gracias pana , Perfecto el Microcursillo que llevas a cabo. :-]

Un abrazo :-]

Título: RE: Microcursillo en C
Publicado por: Xelene en 10 de Enero de 2005, 14:30:00

No se mu bien donde poner este mensajillo... el caso es q estoy con el primer programa creado x mi misma en c. Se trata del mitico de encender un led al presionar un pulsador... compila bien, pero no me hase nada. Alguna sugerencia?

Ahi os dejo el programita:

#include <16F876.h>
#fuses XT,NOWDT,NOPROTECT,NOPUT,NOBROWNOUT,NOLVP
#use delay(clock=4000000)
#use fast_io(A)
#use fast_io(B)

#byte port_a=0X05
#byte port_b=0X06

void main()
{
set_tris_a(0xFF); //Puerto A como entrada
set_tris_b(0x00); //Puerto B como salida
port_b=0;
for(; Giño

      //Bucle infinito
{
if(input(PIN_A4))   //Si no has pulsado haces...
output_low(PIN_B0);   //apagas led
else      //Si no
   {
   delay_us(50);      //metes un tiempo para los rebotes
   output_high(PIN_B0);   //enciendes el led
   }
}
}

Salu2 y Gracias!!! Sonrisa Gigante

Título: RE: Microcursillo en C
Publicado por: Lager. en 10 de Enero de 2005, 21:15:00

Hola Xelene,
Si anda tu programa, de hecho cada ves que tocas el pushbutton se enciende tu led , si no lo tocas permanece apagado....

Acuerdate que no estas activando las pullups que tiene el pic, por tanto tienes que poner una resitencia depullup o una que jale corriente en donde va el led esto es poniendo del pin B0 al led una resistencia de 330 Ohms(no mas grande ya que si no consume de mas y no te enviende el led!!, jeje
Ademas usas el porta.4 (donde va el boton)este pin es de colector abierto, tambien necesitas una resistencia de pullup que valla del pin a VCC(una resitencia de 10k) .
Con esto ya te debe de funcionar.
Saludos Giño

Título: RE: Microcursillo en C
Publicado por: Lager. en 11 de Enero de 2005, 11:08:00

No tienes nada que agradecer Xelene, ;-)
Tu problema debe ser en hardware y habria que revizar como viene el conexionado esa placa, ya que lo e probado(de la forma que te comento) y funciona bien ;-)
Aqui esta el codigo que pusiste:

#include <16F876.h>
#fuses XT,NOWDT,NOPROTECT,NOPUT,NOBROWNOUT,NOLVP
#use delay(clock=4000000)
#use fast_io(A)
#use fast_io(B)

#byte port_a=0X05
#byte port_b=0X06

void main()
{
set_tris_a(0xFF); //Puerto A como entrada
set_tris_b(0x00); //Puerto B como salida
port_b=0;
for(;;) //Bucle infinito
{
if(input(PIN_A4)) //Si no has pulsado haces...
output_low(PIN_B0); //apagas led
else //Si no
{
delay_us(50); //metes un tiempo para los rebotes
output_high(PIN_B0); //enciendes el led
}
}
}

Salu2

Título: RE: Microcursillo en C
Publicado por: mariosaul en 11 de Enero de 2005, 14:07:00

Esta debe ser una pregunta muy basica pero da igual,

output_b(0xff);
esa instruccion me pone en 1 todos los pines del portb,
como hago para elegir exactamente que pin quiero poner en uno?

lo mismo con
output_b(0x00);

Lo de adentro del parentesis me permite elejis si lo pongo en uno o en cero, y he visto ejemplos (0x0f), que pone la mitad del puerto en cero y la mitad en uno, ojala puedan explicarme con mas detalle.

Los que sepan bien esto podrian hacer un diccionario de funciones de C, no todo lo de c, sino la parte que tiene relacion con los pics, el resto esta muy bien documentado en internet

saludos,
juaco

Título: RE: Microcursillo en C
Publicado por: Lager. en 11 de Enero de 2005, 14:24:00

Que onda mariosaul,
De hecho la infomacion viene en el manual del compilador que junto con un libro clasico para aprender uniones ,estructuras , punteros,variables,etc (PICmicro MCU C® An introduction to programming The Microchip PIC in CCS C By Nigel Gardner) deja muy en claro muchas de estas dudas.
hablando en especifico de este output_b(0x00) , que como tu bien dices saca un cero logico en todo el puerto b , asi mismo esta funcion establece al registro del puerto como salidas(cero logico) o como entradas(en el caso de poner 255) DEPENDIENDO de la definicion que uses de puertos: #Use XXX_IO(X) . Asi mismo la forma mas VISUAL de saber que pin pones como salida o cual como entrada seri usando binario:
output_b(0b00000000) , donde 0b es indicador que continua un binario, y 00000000 son los 8 bits del puerto b, de MSB a LSB(bit7,6,5..0) asi si solo quieres setear solo el bit 7 del puerto b seria output_b(0b10000000) , usando esta funcion. Aunque hay funciones que especifican esto de otra forma como bit_clear(var, bit) asi: bit_set(6,1) ;seteamos el bit 7 del portb(direcionado en la posicion 6) . bit_set(11,7) ;seteamos el bit 7 de INTCON y asi sucesivamente...

Salu2 pana

Título: RE: Microcursillo en C
Publicado por: mariosaul en 11 de Enero de 2005, 14:52:00

disculpa que te haya preguntado eso, justo despues de postiar me meti al comilador a hacer pruebas, hic eun pequenio programa que me lee el estado de los pulsadores y me prende un led por cada pulsador que este presionado, o despresionado, dependiendo de el tipo de pulsador,

ojala alguien me pueda decir si esto funciona:

#include <16F628.h>
#fuses XT,NOWDT,NOPROTECT
#use delay(clock=4000000)
#use fast_io(B)

void main()
{

set_tris_b(0x00);

while (1)
{
output_b(0b00000000);

if (input(PIN_B0)){
output_high(PIN_A0);
}

if(input(PIN_B1)){
output_high(PIN_A1);
}

if(input(PIN_B2)){
output_high(PIN_A2);
}

}
}

si tengo un entero, una variable int con el numero parecido a 0001011, que son los pines a poner en 1, se puede hacer algo asi como output_b(0b<nombre de variable> Giño

gracias laguer por responder tan rapido

juaco

Título: RE: Microcursillo en C
Publicado por: Lager. en 11 de Enero de 2005, 16:06:00

No tienes que agradecer nada pana, para eso estamos.
Aqui tu ejemplo corregido y con la respuesta a tu duda:

#include <16F628.h>
#fuses XT,NOWDT,NOPROTECT
#use delay(clock=4000000)
#byte CMCON = 0x19
#use fast_io(B) /*Ya que usamos el formato RAPIDO, debemos especificar entradas
y salidas antes de usarlas, si quitamos este formato, lo hace por defaul como
#use standard_io(x) generando CADA ves que se use el comando que este determinado por este
como el output_x() y generando mas espacio y menos rapides*/
int puerto;
void main(){CMCON=7;/*Deshabilitemos comparadores!!!*/
puerto=255; /La variable que comentabas*/
set_tris_b(0b00000111); /*b0,b1,b2 entradas, las demas salidas*/
output_a(puerto); /*limpiamos todo puerto Ay lo ponemos de salida,
aqui no es necesario poner tris ya que solo
definimos el portb como FAST!!!!!!!!!!!!!*/
Delay_ms(1000);
puerto=0;
output_a(puerto);
while (1){
if (!input(PIN_B0)){ /*como no usamos pullups internas usamos resitencias
externas, por tanto negamos la condicionante
asi si NO esta en 1 cada pin, enciende el led*/
output_high(PIN_A0);}
if(!input(PIN_B1)){
output_high(PIN_A1);}
if(!input(PIN_B2)){
output_high(PIN_A2);}
}
}

Salu2

Título: RE: Microcursillo en C
Publicado por: mariosaul en 11 de Enero de 2005, 16:42:00

no es necesario apagar los leds en cada loop?, queremos que se prendan solo mientras estan apretados, no apretarlos y que queden prendidos.

porque va ese delay?

Ahora en otro tema, el delay es preciso?, si quiero llevar una cuenta de segundos muy exacta, como lo hago?

saludos
juaco

(que es pana???)

Título: RE: Microcursillo en C
Publicado por: Lager. en 11 de Enero de 2005, 18:48:00

jejejeje, bueno eso ya lo decides tu pana, solo corregi unas cosas y adicione lo del delay para que encendiera todo el puerto 1 segundo(de pretexto para que vieras el uso de variables con funciones, lo que preguntabas....) . Sonrisa

Pana es un muy buen amigo Fumador

.
Como puedes ver es muy sencillo y leyendo bien el manual no debes de tener grandes problemas, es importante el orden de cada linea ya que esto refleja la sintaxis del programa, y que sea mejor o peor optimizado por el compilador.
El delay es preciso hasta cierto punto..... si quieres precision, usa interrupciones siin carga en el timer y sin ir a la interrupcion(estar pendiente de que se desborde con el flag de activacion).. y por consiguiente usar otro cristal, por ahi esta posteado por el pana pocher como se hace con precision.... pero usar un micro para hacer un temporizador???? ......
Aqui hay un post referente a lo de la precision y muy bien explicado :
http://miarroba.com/foros/ver.php?foroid=6510&temaid=3132687 reviza el post del pana pocher

Salu2 !!

Título: RE: Microcursillo en C
Publicado por: mariosaul en 11 de Enero de 2005, 19:15:00

saludos pana!
otra pregunta mas:
¿Solo con cambiar el nombre de la libreria al comienzo del codigo se adapta mi programa de un pic a otro?,
¿que diferencias hay que considerar al programar para uno u otro pic? (ademas del numero de pines, y frecuencia del cuarzo)

juaco

Título: RE: Microcursillo en C
Publicado por: Lager. en 12 de Enero de 2005, 12:10:00

Que onda mariosaul,
Eso seria lo mas importante, aparte de el leer el DS del pic a usar, para ver que cuente con los modulos hardware(ccp,a/d,mssp{spi,i2c},usart,psp,etc..) que se han usado en el codigo que piensas adaptar a tu otro proyecto, si es asi en que pines y funcionamiento,....
Recuerda que mientras mas sepas del pic, mas puedes personalizar ,optimizandolo, tu proyecto.

Salu2 pana

Título: RE: Microcursillo en C
Publicado por: migsantiago en 17 de Enero de 2005, 13:14:00

Hola a todos, les dejo un programita que lee y escribe muy básicamente la fecha y hora del ds1307. ;-)

//Programa que usa protocolo I2C para
//escribir y leer tiempo del DS1307
//saca tiempo en LCD

//migsantiago

// Conexiones de la LCD:
// D0 enable
// D1 rs
// D2 rw
// D4 D4
// D5 D5
// D6 D6
// D7 D7
//
// LCD pins D0-D3 are not used and PIC D3 is not used.

#include <16f877a.h>
#fuses xt,nowdt,noput,nobrownout,nolvp,noprotect
#use delay(clock=4000000)

#include "lcd.c"
#use standard_io (D)

#use fast_io (b)

#use i2c(MASTER, SDA=PIN_b1, SCL=PIN_b0,slow)

//Registros DS1307
#define ds_seconds 0x00
#define ds_minutes 0x01
#define ds_hours 0x02
#define ds_day 0x03
#define ds_date 0x04
#define ds_month 0x05
#define ds_year 0x06
#define ds_control 0x07

//DS1307
//Vbat a tierra

void main(void)
{

int16 retardo; //Cada cuando actualiza lectura en LCD

//Dato en registro ds, a mandar o leer
int seconds,minutes,hours,day,date,month,year,control;

retardo=250; //ms a tardar entre lectura y lectura

//Justo cuando prende circuito, la fecha que establece es la siguiente
seconds= 0x00;
minutes= 0x38;
hours = 0x15; //modo 24 hrs
day = 0x05; //1 es domingo
date = 0x13;
month = 0x01;
year = 0x05;
control= 0x00; //OUT=0 SQWE=0 RS0-1=0 no hay onda cuadrada

//Establece fecha y hora
i2c_start(); //Inicia I2C
i2c_write(0xd0); //Direcciona DS1307 write
i2c_write(ds_seconds); //Indica que empiece en registro ds_seconds
//Aquí establece fecha y hora respecto a la puesta arriba
i2c_write(seconds);
i2c_write(minutes);
i2c_write(hours);
i2c_write(day);
i2c_write(date);
i2c_write(month);
i2c_write(year);
i2c_write(control);
i2c_stop(); //Ya puso la hora y fecha
//El RTC ya está marcando el tiempo y fecha

//Rutina LCD
lcd_init(); //Inicia LCD
lcd_putc("f"); //Limpia LCD
lcd_putc("Real Time Clock
"); //rtc
lcd_putc(" DS1307");
delay_ms(3000);

while(1)
{

delay_ms(retardo); //Usuario lee

//Obtiene datos de DS1307
i2c_start(); //Inicia I2C
i2c_write(0xd0); //Direcciona DS1307 write
i2c_write(ds_seconds); //Indica que ponga registro en ds_seconds
i2c_stop();

i2c_start();
i2c_write(0xd1); //Lee DS1307
seconds = i2c_read();
minutes = i2c_read();
hours = i2c_read();
day = i2c_read();
date = i2c_read();
month = i2c_read();
year = i2c_read(0); //no ack
i2c_stop();

//Representa datos en la LCD
printf(lcd_putc,"f%2x-%2x-20%2x
",date,month,year); //dd-mm-year
printf(lcd_putc,"%2x:%2x:%2x",hours,minutes,seconds); //23:59:59
}
}

Título: RE: Microcursillo en C
Publicado por: Lager. en 21 de Enero de 2005, 14:22:00

Muy buen programa pana Rebotado

Salu2

Título: RE: Microcursillo en C
Publicado por: Modulay en 21 de Enero de 2005, 16:15:00

El amigo Lager nos sorprende ahora con un buenisimo trabajo para trastear con un HD en modo LBA.

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

Gracias mil Lager

migsantiago,en cuanto me instale un compilador y pueda compilar tu código subo el tuyo.
Saludos

Título: RE: Microcursillo en C
Publicado por: migsantiago en 23 de Enero de 2005, 18:53:00

ups... ahora que lo dices se me olvidó mandarte el hex Vacilando

Pero no sé si se pueda emular en Proteus, porque cuando lo intenté me marcaba que no tenía el modelo del DS1307.

Oye Modulay, supongo que un HD es un Hard Disk y ¿LBA qué es?

Título: RE: Microcursillo en C
Publicado por: Modulay en 23 de Enero de 2005, 19:23:00

Creo que es el modo de acceso al disco (Large block access o address o algo así Giño

,migsantiago,aunque creo q te lo podrán explicar mejor Lager o manex.
A ver si me puedes mandar el código compilado y ya veremos como hacemos para simular en proteus

Título: RE: Microcursillo en C
Publicado por: Lager. en 24 de Enero de 2005, 00:17:00

Que onda panas, LBA(linear Block Addreessing), CHS( Cylinder-Head-Sector), los dos modos son utilizables, pero el mas sencillo es el LBA, con AMBOS se puede accesar al disco en FAT,FAT16 o FAT32, lo unico que cambia son las comprobaciones. El codigo para FAT32 ya esta listo, de hecho se hace el mismo acceso via LBA. Nada mas les hago una imagen de prueba(formato fat32) para simularlo con proteus para que vean como es su funcionamiento.. y que me desocupe un poco del trabajo y se lo envio a el pana Modulay. Pero con el ejemplo de lba pueden hacer la rutina, para fat, es muy sencilla, sobre todo que solo la usaremos(por ahora,...jajaja) para escribir y leer de ahi.

Salu2 panas

Título: RE: Microcursillo en C
Publicado por: Afprog en 03 de Febrero de 2005, 15:42:00

hola a todos.

soy nuevo en esto de programar micros en c pero me gusta y me interesa mucho ya he mirado varias veses y concegui un compilador diferente al css porque este no me funciono y queria averiguar sobre una libreria que ustedes usan para visualizar en lcd y me gustaria conseguirla y aprender a usarla.

les agradesco si me ayudan mi mail es aalzate86@tutopia.com.

gracias

att: andres (colombia);

Título: RE: Microcursillo en C
Publicado por: tornar en 04 de Febrero de 2005, 05:14:00

Hola andresito86, no se que compilador de C, estaras usando, pero practicamente todos los compiladores de C, traen una libreria para control de perifericos basicos como LCD, teclado, etc. Simplemente busca en la carpeta donde tienes instalado el compilador algun archivo fuente que empiece por LCD, y ves buscando, hasta que encuentres la libreria adecuada. Pq seguramente la libreria que usamos nosotros en CCS no te valga en un compilador distinto.

Saludos.

Título: RE: Microcursillo en C
Publicado por: Xelene en 09 de Febrero de 2005, 04:10:00

Quiero hacer un programa q encienda el led o leds correspondientes en numero binario (hasta 16) según las veces q le des al pulsador... se me ocurre esto, pero no hace lo q quiero, alguna idea??

#include <16F876.h>
#fuses XT,NOWDT,NOPROTECT,NOPUT,NOBROWNOUT,NOLVP
#use delay(clock=4000000)
#use fast_io(A)
#use fast_io(B)

#byte PORTB=6

void main()
{
SET_TRIS_A(0b00001000); //RA4 como entrada
SET_TRIS_B(0b00000000); //Puerto B como salida

for(; Giño

         //Bucle infinito
{
PORTB=0;
while (PORTB <= 16) //mientras sea menor que 16
{
if(input(PIN_A4))   //Si no has pulsado no haces nada
{
}
else         //Si pulsas
{
delay_us(50);   //tiempo para los rebotes
PORTB= ++PORTB;   //incrementas valor de portb=led
}
}
}
}

Gracias de antemano

Título: RE: Microcursillo en C
Publicado por: Nocturno en 09 de Febrero de 2005, 05:14:00

Me temo que eso de PORTB=0; o PORTB++; no funciona en CCS.
Por el contrario, para leer el valor del puerto B tienes que ejecutar:
valor = input_b();

y para escribir esto otro:
output_b(valor);

Si quieres hacerlo a nivel de bit, tendrás que usar:
a=input (PIN_Bx);
o
output_high (PIN_Bx);
o
output_low (PIN_Bx);

Título: RE: Microcursillo en C
Publicado por: Lager. en 09 de Febrero de 2005, 10:32:00

Que onda panas deberian chekar su conexionado panas(pusieron la pullup ?? ), ya que tanto el portb=0 o 1 sirve y portb++ o portb-- tambien, (este se tiene que manejar con la sintaxis correcta)
Ejemplo:

#include <18F452.h>
#fuses H4,NOOSCSEN,NOBROWNOUT,NOPROTECT,NOWDT,NOPUT,NOLVP,NODEBUG,NOSTVREN,NOEBTRB,NOEBTR,NOCPB,NOCPD,NOWRTC,NOWRTB,NOWRTD,NOWRT /*PLL*/
#use delay(clock=32000000)
#USE FAST_IO(B)
#BYTE PORTB= 0xF81

MAIN(){SETUP_ADC_PORTS(NO_ANALOGS);/*SIN ANALOGOS.....POR AHORA > Sonrisa

*/
PORTB=0;
SET_TRIS_B(0);
portb++;
PORTB=PORTB; //EN SU DEFECTO USAR PORTB=PORTB+1 Y PORTB=PORTB-1
DELAY_MS(1000);
portb--;
PORTB=PORTB;
DELAY_MS(1000);
portb++;
PORTB=PORTB;
DELAY_MS(1000);
portb--;
PORTB=PORTB;
DELAY_MS(1000);
PORTB=1;
DELAY_MS(1000);
PORTB=0;
DELAY_MS(1000);
PORTB=1;
DELAY_MS(1000);
PORTB=0;
DELAY_MS(1000);
}
Probado en simulacion y montaje Real.

Aun mas facil:

#include <18F452.h>
#fuses H4,NOOSCSEN,NOBROWNOUT,NOPROTECT,NOWDT,NOPUT,NOLVP,NODEBUG,NOSTVREN,NOEBTRB,NOEBTR,NOCPB,NOCPD,NOWRTC,NOWRTB,NOWRTD,NOWRT /*PLL*/
#use delay(clock=32000000)
#USE FAST_IO(B)
#BYTE PORTB= 0xF81

MAIN(){SETUP_ADC_PORTS(NO_ANALOGS);/*SIN ANALOGOS.....POR AHORA > Sonrisa

*/
PORTB=0;
SET_TRIS_B(0);
PORTB== PORTB++;
DELAY_MS(1000);
PORTB== PORTB--;
DELAY_MS(1000);
PORTB==PORTB++;
DELAY_MS(1000);
PORTB==PORTB--;
DELAY_MS(1000);
PORTB=1;
DELAY_MS(1000);
PORTB=0;
DELAY_MS(1000);
PORTB=1;
DELAY_MS(1000);
PORTB=0;
DELAY_MS(1000);
}

Salu2 panas

Título: RE: Microcursillo en C
Publicado por: Nocturno en 09 de Febrero de 2005, 13:18:00

Pues entonces retiro lo dicho; tenía entendido que eso no funcionaba en CCS.
Y digo yo, ¿para qué sirven entonces las sentencias INPUT y OUTPUT?. Dejan de tener sentido...

Título: RE: Microcursillo en C
Publicado por: Lager. en 09 de Febrero de 2005, 15:02:00

Hola pana Nocturno66,
De hecho la forma OPTIMA de hacerlo es usando los comandos que mensionas, pero eso no es limitante para el compilador para que lo puedas hacer de muchas formas mas.
EN si la diferencia es notable:
.................... PORTB== PORTB++;
0048: MOVF F81,W /*11 ciclos*/
004A: INCF F81,F
004C: SUBWF F81,W
004E: BZ 0054
0050: MOVLW 00
0052: BRA 0054

.................... output_b(0); /*cuando mucho 3 ciclos*/
0062: CLRF F8A

.................... output_b(3);
0064: MOVLW 03
0066: MOVWF F8A

Como puedes ver la forma mas OPTIMA es usando output_X, ya que directamente mueve el valor(diferente de 1 o cero) directamente al puerto, y en caso de solo ser 1 o cero lo limpia(bcf) o lo setea (bsf)....... PERO ambas sirven.

SAlu2 pana Sonrisa

Título: RE: Microcursillo en C
Publicado por: Lager. en 09 de Febrero de 2005, 17:02:00

Xelene en el caso de tu codigo, quedaria mas o menos asi:

#include <18F452.h>
#fuses H4,NOOSCSEN,NOBROWNOUT,NOPROTECT,NOWDT,NOPUT,NOLVP,NODEBUG,NOSTVREN,NOEBTRB,NOEBTR,NOCPB,NOCPD,NOWRTC,NOWRTB,NOWRTD,NOWRT /*PLL*/
#use delay(clock=32000000)
#use fast_io(A)
#use fast_io(B)
#BYTE PORTA= 0xF80
#BYTE PORTB= 0xF81

void main()
{PORTA=0;
SET_TRIS_A(8);
PORTB=0;
SET_TRIS_B(0);
while (PORTB<=15){PORTB==PORTB++;delay_ms(500);}
}

Recalcando en el mismo que el bucle while se va a detener cuando llegue a 16, ya que la variable que estas chekando(portb) es incrmentada dentro del mismo y sensada DESPUES..... esto es,.. cuando portb vale 15,, el bucle while todavia lo acepta vajo la condicionante <=15, por tanto dentro del bucle este es incrementadoportb=(15+1) dando como resultado el binario final que requieres, (16) y solo DESPUEs de haberlo incrementado (dentro del bucle) se detendra.
Caso contrario si pones 16, se detendra en 17 y asi sucesivamente....(0,1,2..15 =16 numeros)

Salu2 Sonrisa

Título: RE: Microcursillo en C
Publicado por: Nocturno en 09 de Febrero de 2005, 23:04:00

Pues discrepo, querido pana.

He compilado este minicódigo y mira lo que sale:

Codigo:
....................    output_b(150);
001F:  MOVLW  96
0020:  MOVWF  06
....................
....................    PORTB=120;
0021:  MOVLW  78
0022:  MOVWF  06

La razón por la que en tu ejemplo el asm sale más grande con la instrucción PORTB==PORTB++ es doble: en primer lugar porque estás comparando en vez de asignando (==) y en segundo lugar porque además haces una operación matemática al incrementar el valor de PORTB en 1.

Lo que sí me queda claro entonces, es que los dos métodos son igualmente válidos, aunque uno de ellos simplifica mucho más la legibilidad de los programas.

Título: RE: Microcursillo en C
Publicado por: Lager. en 09 de Febrero de 2005, 23:27:00

Pana es correcto lo que mencionas en cuanto a esa comparacion, pero no fue eso lo que dije ni lo que compare ,te lo pongo una ves mas:
.................... PORTB== PORTB++;
0048: MOVF F81,W /*11 ciclos*/
004A: INCF F81,F
004C: SUBWF F81,W
004E: BZ 0054
0050: MOVLW 00
0052: BRA 0054

.................... output_b(0); /*cuando mucho 3 ciclos*/
0062: CLRF F8A

.................... output_b(3);
0064: MOVLW 03
0066: MOVWF F8A

Con respecto al incremento y asignacion, AÑADI anteriormente a esta informacion:
portb++; PORTB=PORTB; //EN SU DEFECTO USAR PORTB=PORTB+1 .........!!!!
Mas facil:
PORTB==PORTB++
"La comparacion es entre PORTB==PORTB++ y output_b(X)"
Por cierto pana, en que discrepas? en que la opcion con PORTB==PORTB++ es menos optima que la opcion Output_b(0) o en que ambos funcionan...?? por que esa es la informacion que puse en ambos posts .no entendi a que te refieres loco

Un salu2 pana

Título: RE: Microcursillo en C
Publicado por: Nocturno en 10 de Febrero de 2005, 00:47:00

Creo que no estamos hablando de lo mismo, entonces.
Lo que decía en mi último post es que ocupan el mismo número de ciclos tanto si haces PORTB=120 como si haces output_b(120).
Y te decía que discrepo porque entendí en tu post que estabas argumentando alguna diferencia entre ambos comandos, cuando en el fondo son exactamente iguales.

Título: RE: Microcursillo en C
Publicado por: Lager. en 10 de Febrero de 2005, 10:33:00

Pues si pana, creo que entendiste mal, por que nunca compare esos comandos, ....... y por lo mismo, por que actuan igual no fueron incluidos en el desensamblado del codigo.

Un abrazo pana

Título: RE: Microcursillo en C
Publicado por: Xelene en 12 de Febrero de 2005, 03:31:00

Hola xicos, ya siento no haber contestado antes... el problema era de codigo... conexion y toda configuración estaba bien, pero eso... no hacía lo q yo quería por motivos de temporizacion, eso era too. Asias!!!!

Rebotado

Título: RE: Microcursillo en C
Publicado por: damago en 12 de Febrero de 2005, 05:04:00

Hola k tal lager, no he utilizado el compilador CCS nunca. Suponiendo que es un compilador de C estandar....comento:

1º Giño

Porque haceis??:

portb++; // incrementas registro
PORTB=PORTB; // no se que utilidad tiene esta instruccion???

No bastaria con poner?....

PORTB++; // Incrementa el registo

No se si es algo particular de los puertos del PIC o del uso de ese compilador..por eso no se porque haceis eso.

2º Giño

PORTB==PORTB++,

no es lo mismo que

PORTB++;

lo que haces en el primer caso es incrementar el registro, y despues se realiza una comparacion que no sirve para nada. La comparacion siempre sera falsa, aunque eso es lo de menos, ya que no tiene utilidad.
Si observas el codigo generado en ensamblaor que poneis, observaras que con la instruccion:

004A: INCF F81,F

ya incrementamos el registro PORTB. El resto es para hacer una comparacion con el anterior valor de PORTB que no tiene ninguna utilidad.

Uff k no kiero kedar de listillo eh amigo lager... loco

solo queria participar. Es que me expreso de una manera que releida da la sensacion Muchas risas

Si es algo particular del PIC o compilador comentame okis?

Un saludo.

Título: RE: Microcursillo en C
Publicado por: Lager. en 12 de Febrero de 2005, 15:25:00

Tienes razon pana, de hecho de la forma que tu expones trabaja PERFECTO!! Rebotado

.
ASi que la usare asi de ahora en adelante Sonrisa

.
Gracias por la informacion pana

Un gran abrazo

Título: RE: Microcursillo en C
Publicado por: Amarice_BA en 21 de Febrero de 2005, 09:57:00

Este minicursillo me está viniendo fenomenal.

Voy a hacer una cosilla con un convertidos digital analógico. ¿Teneis apuntes o algún ejemplo sobre esto?

Quiero utilizar un pic barato como el 16F87 y un DAC sencillo como el MCP4921. El tema está en como configurar el pic y como hacer la comunicación entre ambos.

Gracias. Cuando lo tenga más avanzado os preguntaré a ver. Sonrisa

Título: RE: Microcursillo en C
Publicado por: papauleti en 24 de Febrero de 2005, 04:44:00

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 loco

#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" Giño

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

gets(cadena);
puts("
Segundo mensaje" Giño

;
puts(cadena);

}

Seguire probando.

Gracias!!

Título: RE: Microcursillo en C
Publicado por: mariosaul en 24 de Febrero de 2005, 12:09:00

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.

Título: RE: Microcursillo en C
Publicado por: Ric555 en 25 de Febrero de 2005, 02:51:00

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

Título: RE: Microcursillo en C
Publicado por: Nocturno en 25 de Febrero de 2005, 03:43:00

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.

Título: RE: Microcursillo en C
Publicado por: Amarice_BA en 01 de Marzo de 2005, 05:04:00

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

            }


        }


    }

Título: RE: Microcursillo en C
Publicado por: Amarice_BA en 03 de Marzo de 2005, 10:47:00

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]>>8);  // 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]>>8);  // 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]>>8);  // 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]>>8);  // 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
            }
        }
    }

Título: RE: Microcursillo en C
Publicado por: albert.fabregat en 07 de Marzo de 2005, 21:00:00

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.

     {
     }

   }

Título: RE: Microcursillo en C
Publicado por: Modulay en 08 de Marzo de 2005, 07:05:00

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?

Título: RE: Microcursillo en C
Publicado por: albert.fabregat en 08 de Marzo de 2005, 07:09:00

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 Muchas risas

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.

Título: RE: Microcursillo en C
Publicado por: hhpp en 11 de Marzo de 2005, 13:31:00

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.

Título: RE: Microcursillo en C
Publicado por: tocaja en 13 de Marzo de 2005, 22:11:00

Hola amigos:
Me he empapado de todo el curso en un tiempecito, y reconozco que esta super currado Muchas risas

, 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
" Giño

; //Saca texto
lcd_putc(" DE CAMPO" Giño

; //Saca texto
delay_ms(3000);
lcd_putc("f" Giño

; //Limpia pantalla
lcd_putc(" CAMPO ACTUAL" Giño

; //Saca texto
delay_ms(1000);
lcd_gotoxy(9,2); //Acomoda cursor LCD
lcd_putc("OERSTED" Giño

;
while (1)
{
lcd_gotoxy(0,2); //Acomoda cursor LCD
lcd_putc(" " Giño

; //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 Muchas risas

Título: RE: Microcursillo en C
Publicado por: tocaja en 14 de Marzo de 2005, 08:05:00

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

Título: RE: Microcursillo en C
Publicado por: gallegol13 en 21 de Marzo de 2005, 17:33:00

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

Título: RE: Microcursillo en C
Publicado por: Nocturno en 22 de Marzo de 2005, 02:35:00

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.

Título: RE: Microcursillo en C
Publicado por: hhpp en 28 de Marzo de 2005, 19:28:00

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.

Título: RE: Microcursillo en C
Publicado por: Modulay en 28 de Marzo de 2005, 21:20:00

Al fin y al cabo sigue siendo C.
Dispara a ver que se puede hacer,aunque veo más apropiado que abras un nuevo hilo y lo plantees allí.
Saludos

Título: RE: Microcursillo en C
Publicado por: pocher en 29 de Marzo de 2005, 01:52:00

Modulay ¿te pasó usuario_registrado los ficheros para subirlos a la ftp?

Título: RE: Microcursillo en C
Publicado por: Modulay en 29 de Marzo de 2005, 15:13:00

Pos no,no se nada de ningún fichero ¿De qué va la cosa?

Título: RE: Microcursillo en C
Publicado por: pocher en 29 de Marzo de 2005, 23:37:00

Es el ejemplo del primer mensaje de esta página.

Acabo de entrar y ya veo que no estan los ficheros.

Título: RE: Microcursillo en C
Publicado por: hhpp en 30 de Marzo de 2005, 19:26:00

Bien aqui va miren primero bueno tengo un programita que realiza la conversion A/D de los 3 primeros canales de A, ahora lo que yo quisiera es pues que los resultados de esta conversion se manden a la PC sia serie y al lcd tambien, pero en un formato entendible, osea si la entrada analogiica es 2.5 v en el LCD tb se vea 2.4v al igual que en la PC.

Es posible?

Saludos.

Título: RE: Microcursillo en C
Publicado por: hhpp en 31 de Marzo de 2005, 15:42:00

Aqui va el programilla espero me ayuden a completarlo:
#include <pic.h>
main()
{
CLRWDT();
PORTC=0x00;
ADCON1=128; // AN0-AN3 ANALOGICAS, POR DERECHA
TRISA=0xFF; //PA. ENTRADAS
TRISC=0xBF; //Rx ENTRADA, Tx SALIDA;
OPTION= 0b11001111;
AQUI DEBERIA IR
serie_ini();? CON ESTO INICIALIZO LA COMUNICACIÓN Tx EN oN, ASINCRONO,8 BITS, ALTA VELOCIDAD,9600 BAUDIOS,USARTE EN on,
// LUUEGO TEDRIA QUE CONFIGURAR EL ADC
ADCON0=0b01000001;
// AQUI PODRIA MANDAR LOS MENSAJES
SERIA
LCD_INI();?
LUEGO
ESCRIBIRIA EL MENSAJE
CONVERSION0 CONVERSION1 COPNVERSION2...........
---------------- ------------------ ----------------........
COMO PODRIA HACER ESO?
OSEA TENDRIA QUE MANDAR ESO A LA PC Y AL LCD.
LUEGO VENDRIA EL CICLO:

for(; Giño

{
CLRWDT();
ADIF=1; //PARA EL CONVERSOR
ADCON0=0b01000001;
ADG0=1 //INICIA LA CONVERSION
while(ADGO)
continue;
DATO1+=(AQUI VIENEN LOS adres )

AHORA UNA VES QUE EL RESLUTADO DE LA CONVERSION ESTE EN DATO1, TENDRIA QUE CONVERTIRLOS BCD? COMO?
UNA VEZ CONVERTIDO O ES EN ASCII?
SE MANDA LOS VALORES A LA PC Y AL LCD

I BUENO ASI
ADIF=0;
LUEGO SERIA
ADCON0=x49;
ADGO=1 Y ...YA SABEN LO MISMO 3 VECES MÁS PARA LOS CANALES, HABRIA UNA FORMA DE HACER TODO A LA VEZ Y NO LEER CANAL POR CANAL?
..
}

AQUI TERMINARIA EL CICLO
YO TENGO MIS RUTINAS PARA lcd_ini(); iicializa en modo 4 bits
lcd_mueve(); da la posicion
lcd_escribe(); escribe unc aracter en el LCD
lcd_puts(); varios caracteres;
tb serie_ini();
serie_escribe();
serei_lee();
putst(); para varios cacteres, pero no se como usarlos o talves si pero los valores me confunden

por favor una ayudita.

Título: RE: Microcursillo en C
Publicado por: migsantiago en 31 de Marzo de 2005, 21:22:00

Hola a todos

He regresado a mis estudios de C.

Me preguntaba si alguien tiene una librería para usar un teclado 4x4 en el PIC16F877A, usando CCS.

Necesito una fácil de usar como la LCD.C que nadamás se llama y ya.

Gracias invasor

Título: RE: Microcursillo en C
Publicado por: Nocturno en 01 de Abril de 2005, 02:47:00

Hay una como la que pides ya en CCS pero para teclados de 3 columnas y 4 filas.
Se llama KBD.C y funciona muy bien.
Si miras cómo está hecha verás que es fácil modificar para un teclado de 4 columnas.

Título: RE: Microcursillo en C
Publicado por: Gabo65 en 01 de Abril de 2005, 17:35:00

checa esto, tal vez te sirva.
http://www.blitzlogic.com/kbd_C.HTM

Título: RE: Microcursillo en C
Publicado por: migsantiago en 03 de Abril de 2005, 14:09:00

OK, los voy a checar. Gracias.

Título: RE: Microcursillo en C
Publicado por: Nocturno en 14 de Abril de 2005, 05:36:00

Venga, vamos a animar un poco el cotarro.

Propongo hacer un programa en C que maneje algún dispositivo I2C sin usar las funciones de I2C que ya trae CCS.

Yo voy a intentarlo.

Título: RE: Microcursillo en C
Publicado por: Modulay en 14 de Abril de 2005, 12:23:00

¿Usas CCS?
Si es así,un par de cosillas:
La librería lcd.c está diseñada para trabajar en modo 4 bits,por lo que las conexiones D0-D3 sobran,únicamente hay q conectar D4-D7.
Además de esto,ó conectas todo al puerto D,ó lo conectas al puerto B (tanto control como datos)
Por defecto,la librería asume que conectas las tres señales de control y las 4 de dato al puerto D,pudiendo cambiar al puerto B añadiendo al código #define lcd_portb TRUE (esa línea está como comentario en la librería,la descomentas y ya está Giño

.
Asegúrate de que el orden de conexionado de E,RS y RW en el puerto del pic coincide con el de la librería.
Otra cosilla.Ultimamente se está usando este microcursillo para plantear todo tipo de cuestiones que nada tienen que ver con lo que es el lenguaje C en sí mismo,su gramática,sintaxis y tal...y es una lástima que los que llegan buscando lo que precisamente este microcursillo trata de albergar tengan que leer posts y mas posts que nada tienen que ver con la temática que aquí se trata.
Si se tiene un problema concreto,es muy sencillo crear un hilo nuevo ó ubicarlo en algún hilo existente que esté relacionado con nuestro problema.
Por cierto Manolo,es buena idea eso de seguir ampliando un poco el tema,que yo ando también algo pez en eso del I2C Sonrisa Gigante

A ver si saco un ratito y cuelgo el juego del simón en las carpetas de ejemplos
Saludos desde Málaga,España

Título: RE: Microcursillo en C
Publicado por: campeon1982 en 14 de Abril de 2005, 15:55:00

Muchas gracias modulay, no quería abrir un nuevo hilo para no poner más cosas de los lcd.
Lo que pasa es que el buscado no acepta lcd ( que yo sepa jeje) y por eso lo puse aquí.
Muchas gracias de nuevo
pd: si uso ccs, y voy a probar jeje
saludos from Murcia => Spain

Título: RE: Microcursillo en C
Publicado por: j_fernandez en 15 de Abril de 2005, 06:04:00

Hola compañeros del mundo del microcontrolador!!!!!

Os escribo para proponeros hablar del tema del sincronismo de reloj mediante la señal DCF de Alemania. He estado mirando en la red y revistas y se puede obtener el modulo por un precio comprendido entre los 12 y 15 Euros. Si alguien tiene informacion de como se conecta o algun programilla o algo le agradeceria que lo mencionara para entre todos aprender mas del tema. Un saludo

Título: RE: Microcursillo en C
Publicado por: JorgitoFRyOle en 19 de Abril de 2005, 10:55:00

Buenas:

Tengo una duda. Tengo que construir una funcion para leer un dato de 64bits y necesito despues poder acceder a dicho dato. Alguien me puede ayudar con la cabecera?

Seria asi?
void leer_dato(BYTE *dato)

considerandolo como un array de 8bytes

y a la hora de llamar a la funcion, seria asi?
leer_dato(&dato);

Otra duda, tendria que reservar memoria con malloc dentro de la funcion para la variable dato, como seria entonces esto?

Gracias de ante mano.1saludo a tos.

Título: RE: Microcursillo en C
Publicado por: Xelene en 20 de Abril de 2005, 03:09:00

Holas! Os dejo aqui un programita que he hecho q os puede resultar interesante en el uso del pwm y señales analógicas. El programa en cuestión trabaja a una frecuencia fija de 500 Hz, el duty se varía mediante un potenciometro y el resultado lo podemos ver en un led y además en la pantalla lcd.

Nota: Para q funcione fisicamente tendreis q cortocircuitar RC2 con RB1 o algun apaño parecido

Codigo:
#include <16F877.H>
#fuses HS,NOWDT,NOPROTECT,NOPUT,NOBROWNOUT,NOLVP
#use Delay(Clock=4000000)
#include <lcd-picdem.c>

#use fast_io(B)
#byte PORTB=6

const float escala = 255;
const float d_max = 2000;

void calcula_duty (int val, float &duty)
 {
 duty=(val*d_max)/escala;
 }


main()
{

    int valor;
    float duty;

    PORTB=0b00000010;

    lcd_init();
    lcd_gotoxy(1,1);
    lcd_putc(" f=500Hz->T=2ms ");
    lcd_gotoxy(1,2);
    lcd_putc("duty =        us");


    setup_ccp1(CCP_PWM);                          // Configura CCP1 como PWM
    setup_timer_2(T2_DIV_BY_16,124,1);            // f=500Hz (T=2ms)
    
    setup_adc(adc_clock_div_32);                  // Selecciona Reloj
    setup_adc_ports(AN0);                         // RA0 analogico
    set_adc_channel(0);

    while(1)
    {
        valor=read_adc();                                // Lee valor RA0
        set_pwm1_duty(valor);                     // Establece duty como valor
        calcula_duty(valor,duty);                 // Escala el duty
        lcd_gotoxy(8,2);
        printf(lcd_putc,"%3.2f",duty);            // Muestra el resultado
    }
}

Espero q os sirva de ayuda. Saludos y gracias a este foro xq todo lo q he aprendido lo he aprendido aqui!!

Título: RE: Microcursillo en C
Publicado por: squallmx en 18 de Mayo de 2005, 15:58:00

Hola a todos, muchas gracias por este microcursillo que ya es todo un curso para los que apenas estamos en esto de C, la verdad no habia querido cambiar de ensamblador porque es mucho mas fino y preciso para las aplicaciones que hago pero al ser mas complejas cada ves pues no queda de mas.

Una pregunta en CCS de PCW se puede simular el programa como en el MPLAB con el sim que trae el mplab o solo se puede con el proteus???? y si se puede usar el CCS para programar directo los pics con el picstar plus???

de antemano mil gracias y de verdad que se van a ir al cielo con este curso, espero poder pronto aportar en los proyectos.

Saludos

Título: RE: Microcursillo en C
Publicado por: hhpp en 18 de Mayo de 2005, 17:52:00

Hola ahora por favor alghuien me podria dar una pista o idea , algo de como convertir RS-232 a RS-485 full-duplex?

hp

Título: RE: Microcursillo en C
Publicado por: Nocturno en 19 de Mayo de 2005, 00:17:00

Hola Squallmx, la verdad es que con ganas y los ejemplos que aparecen en el microcursillo, uno puede iniciarse en C, sí Sonrisa Gigante

Con respecto a tu pregunta, que yo sepa PCW no simula. Cuando lo he necesitado lo he hecho en Proteus.
¿Cómo grabas con PicStart Plus? supongo que tendrás un software de grabación: ICProg, Winpic,... Si es así, podrás enlazarlo en PCW y asignarlo a una tecla de función con el menú Options -> Debugger / Programer.

Hola hhpp, creo que tu pregunta tendría una más rápida respuesta si la pones en un hilo nuevo.

Título: RE: Microcursillo en C
Publicado por: oriolba0007 en 20 de Mayo de 2005, 06:48:00

Hola a todos !

He llegao al final del subtema !!!

Felicidades por este manual que me ha enseñado a programar un PIC en C ( casi no tenia idea de programar un PIC, y menos con C ).

Dejo aqui una pregunta que no he encontrado solucionada en el manual :

Hay alguna manera de que una rutina devuelva como resultado 3 variables a la vez ( 2 o mas )? Me explico :

Algo asi como :

int hola () {

a=3;
b=2;
c=4;
return(a,b,c);}

De esta manera podriamos llenar una tabla o una matriz ...etc

He encontrado solucion pero pasa por hacer 3 rutinas, una por resultado.

Seguir asi fieras Giño

Título: RE: Microcursillo en C
Publicado por: Nocturno en 20 de Mayo de 2005, 06:55:00

Que yo sepa sólo se puede devolver un valor, aunque siempre podrás utilizar variables globales que sean modificadas en tu función y visibles desde el programa principal.

Título: RE: Microcursillo en C
Publicado por: squallmx en 20 de Mayo de 2005, 17:01:00

Hola muchas gracias nocturno exactamente era lo que buscaba para no estar pasandome con el mplab, lo programa directo con el mplab y el picstar es mucho mas rapido y tiene mucho mas funciones por mplab que por icprog, y pues aqui estamos aprendiendo gracias a uds.

Saludos

Título: RE: Microcursillo en C
Publicado por: albert.fabregat en 20 de Mayo de 2005, 20:26:00

Si que hay varias maneras para poder "retornar 2 o mas variables a la vez".
Una de ellas es pasandole el offset de la variable por referencia, es decir.

void hola(int *a,int *b, int *c)
{

*a=4;
*b=3
*c=2;

}

y luego llamandolo por ejemplo desde el main

void main()

{
int d,e,f;

hola(&d,&e,&f);

}

En este caso esto haria que:

d=4;
e=3;
f=2;

Otra de las maneras es hacer que retorne un array o un puntero a un array. Pero la forma mas comoda es la que te he dicho al principio. Espero que te ayude.

Saludos.

Título: RE: Microcursillo en C
Publicado por: oriolba0007 en 22 de Mayo de 2005, 16:04:00

Pues si, Gracias por la respuesta albert !!

Ahora me meto a llenar una matriz de 4x3 de esta manera

Título: RE: Microcursillo en C
Publicado por: antspa en 27 de Mayo de 2005, 08:37:00

Hola a todo/as
Necesito programar un PIC en en lenguaje C para que me de una salida de -25 a 75 grados. Utilizando un sensor de temperatura LM35 me da unos valores de salidas de 0 a 5 v (0=-25 grados y 5= a+75 g). Estos Valores han de entrar en el adc.
Mi pregunta es : como programar el PIC para que me de los resultados que pido e introducirlos en el PC via RS485?. Lo del Pc lo tengo controlado con el programa Labwindows.
Muchisimas gracias espero
un alma caritativa.

Título: RE: Microcursillo en C
Publicado por: gustav03 en 14 de Junio de 2005, 11:55:00

hola alguien sabe que es esto ?

#define OUR_ID 1
byte checksum,len,to;

checksum=len^OUR_ID^to; /// <----que es esto ??????????????

y esto ?
if(kbhit())

Título: RE: Microcursillo en C
Publicado por: migsantiago en 14 de Junio de 2005, 18:47:00

Salu2 fans del lenguaje C

Ahora les comparto un programa que trabaja las 2 terminales PWM del PIC16F877A.

Lo utilicé para controlar 2 servos PWM que dependiendo el ancho del pulso, toman una posición en grados con un rango de 0° a 180°.

Este programa empieza enviando un ancho de pulso (ambos canales) y mediante Push buttons uno incremente o decrementa ese ancho de pulso.

Me sirvió mucho para checar los rangos de trabajo de los servos y saber con que cantidad de milisegundos a qué posición se iba el servo.

Usa LCD y 4 push buttons, 2 para cada servo, uno incremente el ancho de pulso y el otro lo decrementa.

La desventaja de mi programa es que usa cristal de 1.25MHz... algo difícil de conseguir :)

//Este programa da un periodo PWM de 13.1ms
//Santiago Villafuerte
//migsantiago

//Sirve para encontrar el rango de trabajo del DUTY time
//inicia en 2.5ms y el usuario sube o baja bit a bit ese rango

//Puede operar 2 señales PWM al mismo tiempo CCP1 y CCP2

//El DUTY actual saldrá en la LCD en hexadecimal

// Conexiones de la LCD:
// D0 enable
// D1 rs
// D2 rw
// D4 D4
// D5 D5
// D6 D6
// D7 D7
//
// LCD pins D0-D3 are not used and PIC D3 is not used.

//Los resultados que obtuve son:

//Servo KRAFT KPS-21K
//Periodo=13.1ms
//DUTY para 0° = 0.6784ms (0x35)
//DUTY para 90° = 1.408ms (0x6e)
//DUTY para 180° = 2.112ms (0xa5)
//Resolución
//0xa5-0x35=0x70=112
// 180°/112=1.6071°

#include "16f877.h"

#use delay(clock=1250000)
#fuses xt,nowdt,noput,nobrownout,nolvp,noprotect

#include "lcd.c"
#use standard_io (D)

#use fast_io (c)
#use fast_io (b) //PB para subir o bajar DUTY time

//B7 sube PWM1
//B6 baja PWM1

//B5 sube PWM2
//B4 baja PWM2

void main (void)
{
long duty_pwm1; //duty pwm1
long duty_pwm2; //duty pwm2
set_tris_c (0x00); //Todo salida
set_tris_b (0xff); //todo entrada

//Duty inicial
duty_pwm1=0xc8; //200d
duty_pwm2=0xc8; //200d
//D=(0xc8)(1/1.25MHz)(16)=2.5ms

//Rutina LCD
lcd_init(); //Inicia LCD
lcd_putc("f"); //Limpia LCD
lcd_putc("Presione PB
+ o -"); //rtc
delay_ms(3000);
lcd_putc("f");

setup_timer_2(T2_DIV_BY_16,255,1); //PR2 = 255
//T=(PR2+1)4.Tosc.PRStm2
//T=(255+1)4.(1/1.25MHz)(16)=13.1ms
setup_ccp1(CCP_PWM); //PWM
setup_ccp2(CCP_PWM); //PWM

while(1)
{
if( input(PIN_B7) )
{
duty_pwm1++; //incrementa duty time PWM1
delay_ms(100); //espera se suelte PB
}
if( input(PIN_B6) )
{
duty_pwm1--; //decrementa duty time PWM1
delay_ms(100); //espera se suelte PB
}
if( input(PIN_B5) )
{
duty_pwm2++; //incrementa duty time PWM2
delay_ms(100); //espera se suelte PB
}
if( input(PIN_B4) )
{
duty_pwm2--; //decrementa duty time PWM2
delay_ms(100); //espera se suelte PB
}

lcd_putc("f"); //Limpia LCD
lcd_putc("PWM1 = ");
printf(lcd_putc,"%x",duty_pwm1); //escribe DUTY1 en hexadecimal
lcd_putc("
");
lcd_putc("PWM2 = ");
printf(lcd_putc,"%x",duty_pwm2); //escribe DUTY2 en hexadecimal
delay_ms(200); //Usuario lee

set_pwm1_duty(duty_pwm1); //saca duty actual
set_pwm2_duty(duty_pwm2); //saca duty actual
}
}

Título: RE: Microcursillo en C
Publicado por: gustav03 en 15 de Junio de 2005, 23:14:00

tengo un problema en ccs las operaciones con variables float no da lo que deberia
float temp_vuelta=0,num_pasos=0,temp;

temp=temp_vuelta*num_pasos //me da cualquier cosa Llorando

temp=temp_vuelta/num_pasos //mi hablar !!!

como se trabaja con estas variables ?

Título: RE: Microcursillo en C
Publicado por: Modulay en 16 de Junio de 2005, 06:59:00

Al dividir por 0 me parece normal que obtengas un comportamiento inesperado,aunque la multiplicación debería marchar bien.
Prueba a declarar las variables y después de eso las inicializas.

float temp_vuelta,num_pasos,temp;
temp_vuelta = 0;
num_pasos = 0;
........

Título: RE: Microcursillo en C
Publicado por: electronando en 24 de Junio de 2005, 08:53:00

Bueno la verdad , yo solo e programado en basic y asembler pero queria aprender el lenguaje C que por lo que veo hay un cursillo que ya esta siendo cursote , antes de empezar en C no despejo la duda de para que vale eso de poner primero
main()
void main()
void (,..$%%&%$%$%)
y no se cuantas cosas mas no se si se pone por moneria por favor quiero empezar en C pero primero quisiera saber como se come lo anterior o que significado tiene le agradeceria a los que dominan el tema me resuelvan esta encrucijada pues quiero entrarle al C le agradecere bastante a toda la gente que hace grande el curso de C para pics

Título: RE: Microcursillo en C
Publicado por: electronando en 24 de Junio de 2005, 17:30:00

te agradesco mucho piriots eso del pulso esta interesante si lo entendi pero me queda la duda q querias decir con que "nodevuelve valor alli si no se como interperpretarlo por favor q significa creo haber escuchado lo mismo antes pero no lo llegue a entender te aradeceria bastante me despejes esta duda

Título: RE: Microcursillo en C
Publicado por: RaDoN en 24 de Junio de 2005, 18:38:00

Pues en C, hay dos clases de funciones, tienen un nombre raro que por cierto nunca recuerdo jeje, pero basicamente esque algunas retornan un valor y otras no.

La del ejemplo anterios hace los pulsos pero no devuelve nada a la funcion principal. Ahora imaginate que una funcion acaba con la orden;

return x;

Que x puede ser un numero, una constante o mejor aun, una variable, entonces esa funcion se completara cuando devuelva ese valor a la funcion main. Y podremos hacer algo con el, por ejemplo imagina ke la funcion se llama prueba() y el valor retornado lo queremos guardar en valor_prueba:

valor_prueba = prueba();

Me intentado explicar lo mejor que podido, espero haberlo hecho medianamente bien y que te ayude.

Título: RE: Microcursillo en C
Publicado por: Fer_TACA en 09 de Agosto de 2005, 10:59:00

Hola amigos:

Recien acabo de obtener el programa CCs, despues de llevar 9 dias leyendo el manual de CCs y algun que otro libro de C, repasando gran parte de este microcursillo, voy a familiarizarme un poco con el entorno de CCs y a partir de hay empezaré a migrar de "Ensamblador" a "C".

Ya veremos como me va, no obtante creo recordar que en algun lugar del foro habia indicaciones para integrar y/o relacionar CCs con Proteus. Os agradeceria donde o como para ir probando(simulando los programitas que vaya realizando.)

Espero no tener que molestaros con muchas preguntas. pero tener seguro que agradeceré bastante los consejos que me deis en su caso
UN saludo Carmelo.

Título: RE: Microcursillo en C
Publicado por: Fer_TACA en 17 de Agosto de 2005, 11:37:00

Hola amigos:
Recien acabo de realizar mi primer programa en C, espero dejar asm pronto, despues de seguir el hilo de este cursillo, asi de como los ejemplos que ha colocado otro compañero con otro tema.
Lo he simulado con proteus y parece que funciona. Os dejo el código para ver si alguien me puede decir si me sobra/falta algo.
De entrada se que me falta la linea con los fuses para el programdor. ¿Pero a parte de esto hay algo más?

#include <16F876.h>
#byte port_b = 6 // Identificador asociado al registro de dirección 6
#byte port_c = 7 // Identificador asociado al registro de dirección 7
#use standard_io(B)
#use standard_io(C)

void main()
{
set_tris_b(0xFF); //portb como entrada
set_tris_c(0x00); //portc como salida
port_c=0; //inicio el puerto C
do {
input(PIN_B0);
output_bit(PIN_C0,input(PIN_B0));
}
while(1);
}

Con esto leo un pin del puerto B y pongo su valor en el puerto C. Pero si quiero leer todo el puerto B y pasarlo al puerto C como lo haria?
Gracias
Carmelo

Título: RE: Microcursillo en C
Publicado por: RaDoN en 17 de Agosto de 2005, 12:40:00

No entiendo la utilidad de esta linea, si luego lees el mismo pin en la funcion del output ...

Para la otra consulta creo que con esto vale:

#byte port_b = 6
#byte port_c = 7

port_b = port_c;

Corrijanme si me equiboco please!! muñeco de nieve

Título: RE: Microcursillo en C
Publicado por: Fer_TACA en 17 de Agosto de 2005, 16:31:00

Hoña amigo radon:
No te comprendo com lo que me indicas de la utilidad de la linea? RollEyes

Me creo que es la primera linea del input. Pienso que tienes razón, acabo de probarlo y funciona sin ella; pero...... Rebotado

Si coloco la sentencia como indicas, dentro del bucle do---while, entoces,el puerto c no responde al estado que pongo en el puerto B.
Me puedes aclarar algo más?
Carmelo

Título: RE: Microcursillo en C
Publicado por: RaDoN en 17 de Agosto de 2005, 16:51:00

No acabo de estar seguro si se puede usar como una "variable" los estados de un puerto como entrada, como salida sí ... haber si alguien que conozca mas CCS que yo (cualquiera ...) nos ilumina Muchas risas

Título: RE: Microcursillo en C
Publicado por: Nocturno en 17 de Agosto de 2005, 21:47:00

Escrito originalmente por Fer_TACA

Con esto leo un pin del puerto B y pongo su valor en el puerto C. Pero si quiero leer todo el puerto B y pasarlo al puerto C como lo haria?
Gracias
Carmelo

Carmelo, creo que con esto debería ser suficiente dentro de tu bucle:
port_c=port_b;

Ánimo, es una acertada decisión aprender C.

pd: Disculpa, pero la primera vez en vez de darle a "Citar" sobre tu mensaje le di a "Editar" por error. Por eso aparece editado por mí. No he cambiado nada.

Título: RE: Microcursillo en C
Publicado por: Fer_TACA en 18 de Agosto de 2005, 09:42:00

Gracias amigo nocturno:
Ya lo probé y funciona. La sentencia era la que habia pensado al primer momento, pero error de principiante que la puse al revés y de esta forma siempre ponia en el puerto b lo que tenia en el C( es decir un 0).
Pero no desespero y voy a continuar con esto. Al final lo que pretendo, aparte de aprender es pasar un programa que tengo funcionando enensamblador a C.
Un saludo Carmelo.

Título: RE: Microcursillo en C
Publicado por: RaDoN en 18 de Agosto de 2005, 10:35:00

Sorry, culpa mia ... supongo que me lie entre tus entradas y salidas y lo puse al reves jeje, pero bueno, siempre esta ahi el paisano nocturno para correjirme Sonrisa Gigante

Título: RE: Microcursillo en C
Publicado por: todopic en 26 de Agosto de 2005, 19:53:00

Hola Amig@s!!!, HOY me meti con todo en "C"... Sonrisa Gigante

Realmente empece a leer este fabuloso cursillo a las 4 de la tarde... y ya son casi las 10... loco

ademas, recomiendo este manual (gracias Julian de Xior)
http://www.fi.uba.ar/materias/7542/herramientas/libro/taller.pdf.

y entre las dos herramientas... voy entendiendo!!! Giño

asi que gracias por tantos ejemplos y consejos!!!

Norberto

Título: RE: Microcursillo en C
Publicado por: Nocturno en 27 de Agosto de 2005, 00:30:00

Ánimo Norberto, es todo un evento que un dinosaurio del ASM como tú se acerque por estos lares.
Y lo mejor de todo es que cuando le pilles el rollo a esto, me temo que no volverás por AquelSitiopriMitivo.

Título: RE: Microcursillo en C
Publicado por: todopic en 27 de Agosto de 2005, 09:19:00

ja ja ja

Gracias Nocturno! je je je.... realmente estoy sorprendido!, y realmente hay que ir migrando al C .. Sonrisa Gigante

Veo que muchas cosas son "similares" al basic..., y alli está mi problema....
por eso recomiendo el librito.. explica la parte de sintaxis... luego con los magnificos ejemplos del cursillo del foro, todo cierra bien!!!
El problema es como empezar... , y mas si estaba con ASM... yo quiero saber que es lo que pasa Giño

y por que esta lleve?, por que este FOR (y el next?)... je je je... y alli mis dudas... pero ya estan siendo aclaradas.... Payaso

Gracias Amig@s!....mmmm pero sera dificil olvidar Aquel Sitio priMitivo je je

Norberto

Título: RE: Microcursillo en C
Publicado por: RaDoN en 27 de Agosto de 2005, 10:51:00

Y que cuesta tela!!! migrar desde ASM, el mejor consejo es que olvides como trabaja el micro internamente Sonrisa Gigante

(de eso se trata un lenguaje de alto nivel no?)

Título: RE: Microcursillo en C
Publicado por: piriots en 27 de Agosto de 2005, 11:35:00

Pues a mi no me costo mucho migrar de asm a c, con el asm conseguia poco mas que romperme las neuronas y desde que pase a c que la cosa ba muuuuuuuucho mejor. Ahunque supongo que para alguien que lleva años programando en asm tendra que cambiar mucho la forma de plantear el programa.

Salu2

Título: RE: Microcursillo en C
Publicado por: todopic en 29 de Agosto de 2005, 11:47:00

Hola Amig@s!, estoy tratando de empezar....
pero luego de proyect>new>pic wizar etc etc...
cuando quiero compilar, sale este error
ACCESS VIOLATION AT ADRESS 00405807 IN MODULE "PCW.EXE" READ OF ADRESS FFFFFFFF
Creo que en algun lugar del foro, lo leí.... pero no lo encuentro.....

Gracias!

Norberto

Título: RE: Microcursillo en C
Publicado por: vszener en 29 de Agosto de 2005, 12:05:00

Ke tal todopic!!!ummm ese error suena haber seleccionado mal el compilador c, es decir, cuando estas en el paso 2 del project wizard: select a languaje toolsuite pones como active toolsuite CCS C COMPILER....y abajito en el recuadrito blanco pondra CCS C COMPILER....y aqui viene lo importante en location...si tu has introducido el plug-in de CCS para que se integre dentro del MPlab no deberas escoger el ccsc.exe sino que deberas escoger el pcw.exe...aunque decirte que en la nueva version der mplab 7.21 ya esta incluido el CCS como compilador externo y si ya tenias instalado el CCS de antes no deberia darte problemas! Giño

Título: RE: Microcursillo en C
Publicado por: todopic en 29 de Agosto de 2005, 15:52:00

Hola Vszener, yo estoy trabajando directamente con el CCS (no con el mplab)
y solo comence con los seteos del micro, es desir esto

#include "C:Archivos de programaPICCExamplesejemplo1.h"

void main()
{

port_b_pullups(TRUE);
setup_adc_ports(NO_ANALOGS);
setup_adc(ADC_OFF);
setup_psp(PSP_DISABLED);
setup_spi(FALSE);
setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
setup_timer_1(T1_DISABLED);
setup_timer_2(T2_DISABLED,0,1);

}

y al tratar de compilar con el propio CCS da el error mensionado ok? Enfurruñado

y ademas, al instalarlo, solo me reconocio el MPLAB, que ahora puedo ingresar desde el CCS como herramientas ->MPLAB..

Norberto

Título: RE: Microcursillo en C
Publicado por: J1M en 29 de Agosto de 2005, 16:00:00

Norberto, vuelve a instalar el CCS, los archivos de registro (aunq te de la advertencia de q son antiguos...) deben estar junto con el ejecutable de instalación, veras como entonces no te da ese fallo.

Saludos!

Título: RE: Microcursillo en C
Publicado por: todopic en 29 de Agosto de 2005, 19:32:00

Hola Amig@s!... no hay forma, reinstale una version mas vieja... pero igual Llorando

El problema es mi maquina, ya que recien lo instale en otra PC y anda perfecto

asi que esta se esta por ganar un C:/format ....

Norberto

Título: RE: Microcursillo en C
Publicado por: andresitovv en 09 de Septiembre de 2005, 11:29:00

Me pueden ayudar con esta pregunta fácil? No he mirado las 18 páginas del microcursillo, la verdad, pero en el pequeño manual no viene nada y no encuentro como hacerlo. Que debo escribir en C para cambiar un registro determinado del pic? Por ejemplo, quiero poner en el pic 18f452 el bit T08BIT del registro T0CON a 1. Como hago eso? En el archivo .h viene la dirección del registro, pero no sé como ponerlo para luego usarlo. Muchas gracias.

Título: RE: Microcursillo en C
Publicado por: vszener en 09 de Septiembre de 2005, 12:12:00

Ke tal!!para definir bit en el compilador CCS se hace de la siguiente manera:
#bit T08BIT=0xFD5.6
Haber, primero como tu deseo es manejar un bit solamente se usa la instruccion #bit despues hay que localizar donde esta nuestro bit, en este caso esta dentro del registro T0CON, y su posicion es la 6(es decir dentro del registro ocupa el bit 6), por lo tanto definimos la instruccion(#bit) le damos nombre a nuestro bit(T08BIT) declaramos en el registro que se encuentra(T0CON) y ponemos su direccion con un punto(6), en total: #bit T08BIT=0xFD5.6
Para poner el bit a 1:
T08BIT=1;
Para ponerlo a cero:
T08BIT=0;
Espero que sea lo que pedias.....sino dimelo!suerte!!! Giño

Título: RE: Microcursillo en C
Publicado por: andresitovv en 09 de Septiembre de 2005, 12:27:00

Exacatamente lo que quería, muchisimas gracias. Ya puedo controlar el bit que me de la gana de cualquier registro, lo cual es importante, verdad? Gracias.

Título: RE: Microcursillo en C
Publicado por: vszener en 10 de Septiembre de 2005, 05:52:00

Hombre importante es....ya que asi podras manejar declarando previamente cualquier bit, eso si , ya muchos de ellos estan declarados en la libreria correspondiente al dispositivo, asi que antes de definir algun bit mirate la libreria haber si ya esta definido(cuestion de no repetir las cosas dos veces), y para declarar bit"s ten siempre a mano el data sheet del dispositivo para ver sus posiciones en memoria!!!jeje suerte!!!! Giño

Título: RE: Microcursillo en C
Publicado por: vitervi en 26 de Septiembre de 2005, 11:50:00

Hola a todos,

Me gustaria poder mirarme tranquilament este foro pero no puedo, porque no se como va el CCS,

¿alguien me podria hecharme una mano? ¿Alguien sabe de alguna mini manual donde expliquen las teclas mas importantes?

Me encantaria poder aprenderme de memoria este foro como el de arriba.

Muchas gracias

Título: RE: Microcursillo en C
Publicado por: vszener en 26 de Septiembre de 2005, 11:59:00

Ke tal vitervi!!!veo que por fin te has decantado pro el CCS y el c jeje ya era hora!!!jeje es broma...bueno el manual mejor creo que e ssu propia ayuda que tiene integrada el CCS o por lo menos esa fue mi fuente de inspiracion jeje....aqui un enlace donde se habla del tema
http://miarroba.com/foros/ver.php?foroid=46840&temaid=4023657
Despues pasate por el post de ejemplitos en c de CCS y ves como es la construccion y realizacion de programas
http://miarroba.com/foros/ver.php?foroid=46840&temaid=4061462

Y sobre todo mucha suerte y buena eleccion haber elegido el c! Giño

Título: RE: Microcursillo en C
Publicado por: vitervi en 26 de Septiembre de 2005, 13:18:00

Hola a todos,

Ese manual ya lo tengo , esta muy bien,. solo quiero uno en que me diga como van las teclas o algo asi.

Pero te are caso y mirare el HELP que lleba el programa.

Pero si sabes algo mas te daria las gracias de nuevo.

Gracias por todo

Título: RE: Microcursillo en C
Publicado por: vszener en 26 de Septiembre de 2005, 14:18:00

No se a lo que te refieres cuando dices:

Codigo:

             solo quiero uno en que me diga como van las teclas o algo asi...

Pero vamos si ya tienes el manual en castellano simplemente con los ejemplos del post de ejemplitos que ya te he dado puedes programar e inicializarte, los ejemplos empiezan siendo muy basicos...de todas formas por el foro dieron una pagina de un integrante del mismo aqui el enlace a la pagina donde hablan de programacion en c con el CCS:
http://www.tecnopic.tk/
Le das a cursos->microcontroladores->programacion->c
Suerte!!! Giño

Título: RE: Microcursillo en C
Publicado por: vitervi en 27 de Septiembre de 2005, 06:38:00

Hola a todos,

SI, es lo queestaba buscando.

Gracias ahora o cuando pueda

Muchas gracias

Título: RE: Microcursillo en C
Publicado por: SISTEK en 01 de Octubre de 2005, 14:39:00

Hola a todos. me pueden enviar un esquema para las conexiones de un PIC16F877A y un MAX232, es un programa sencillo en C, envia por serie un valor el cual se utilizara para hacer ciclos, en un simulador me funciona pero en el pic, no espera a que le envie el dato, esto lo hago conectando el pic directamente al PC, algo vi en un post de rs232 invert , pero no lo encuentro , si tienen un codigo de ejemplo de trasnmision serial en C, que me envien, consegui este pero no se que esta mal. este comentario(// Jumpers: 8 to 11, 7 to 1) este jumpeo en el pic para que sirve
#include <16F877A.h>
#fuses XT,NOWDT,NOPROTECT,NOLVP
#use delay(clock=4000000)
#use rs232(baud=9600,BITS=8, xmit=PIN_C6, rcv=PIN_C7)

enable_interrupts(GLOBAL); // Ahora sí se pueden producir las interrupciones
#int_rda //recive
//#INT_TBE //transmite

void main() {

printf("P
" Giño

;
getc();
printf("1
" Giño

;

while (TRUE) {
output_high(PIN_B1);
delay_ms(100);
output_low(PIN_B1);
delay_ms(100);
}
}

Gracias por su ayuda

Saludos desde Colombia

Título: RE: Microcursillo en C
Publicado por: vszener en 02 de Octubre de 2005, 16:29:00

Buenas!!!aqui tienes un ejemplo de conexion MAX232 y un PIC...incluso el programa y la simulacion en PROTEUS....en el ejemplito Comunicacion PC via RS232...aqui el enlace
http://miarroba.com/foros/ver.php?foroid=46840&temaid=4061462&pag=6

suerte!!! Giño

Título: RE: Microcursillo en C
Publicado por: cchhaa en 03 de Octubre de 2005, 11:38:00

hola amigos, como mi intencion es programar los pics con c me he descargado todas las paginas de este post para poder seguirlo en casa ya que alli no tengo internet (ni quiero loco

) tambien lo he comprimido a rar y lo he colgado por si alguien mas esta interesado en poder repasarlo sin tener conexion, aqui lo dejo : minicursillo de C

un saludo
cchhaa

Título: RE: Microcursillo en C
Publicado por: tartourusparda en 01 de Noviembre de 2005, 00:27:00

la verdad no estaria mal yo tambien le entro a esto del cursito

Título: RE: Microcursillo en C
Publicado por: RaDoN en 01 de Noviembre de 2005, 02:52:00

Estupendo, ya tengo algo que hacer cuando a auna le da por no ir xD

Título: RE: Microcursillo en C
Publicado por: andresitovv en 03 de Noviembre de 2005, 05:33:00

Hola, a ver si alguien me puede ayudar. Estoy intentando crear un proyecto de forma manual con el CCS, ya que tengo demasiado código para ponerlo todo en un sólo fichero. Para hacerlo, las funciones que quiero poner en otro fichero las declaro primero en un .h. Luego tanto en el main como en el fichero con las funciones meto: #include <archivo.h>. Pero al compilar no me encuentra la función que está en otro archivo. Algunos pasos básicos para crear un proyecto a partir de archivos ya creados? Gracias.

Título: RE: Microcursillo en C
Publicado por: MGLSOFT en 03 de Noviembre de 2005, 08:43:00

Debes preparar al compilador para que encuentre los archivos que debe buscar y en que carpetas los encontrara.
Eso lo haces incluyendo las carpetas donde buscar con Include Dirs del menu de opciones.
A veces alcanza con incluir el directorio de tu proyecto, y en las nuevas versiones eso queda configurado para cada proyecto, por lo tanto ya no debes tocarlo al cambiar de un proyecto a otro.
Sonrisa Gigante

Título: RE: Microcursillo en C
Publicado por: omibaya en 26 de Noviembre de 2005, 19:44:00

Hola amigos, aqui les pongo un programita de un pic maestro, que trabaja con 4 esclavos en forma serial, asi que hay 4 puertos virtuales y uno que va con la PC con rs485, es parte de miproyecto de tesis, y me ayudo a hacerlo un Ingeriero amigo, pero me gustaria saber como se le puede mejorar, o que den consejos, y para que vean todo lo que se puede hacer con CCS, hasta tiene como les he escrito para separar un pin y conectarlo con el 485, el protocolo implementado es con codigos ascii, es usado en algunos dispositivos, bueno se los dejo y que el foro siga creciendo
/*--------------------------------------------------------------------------------------
           Funciones para recepcionar o enviar tramas
--------------------------------------------------------------------------------------
----------------------------
TRAMAS MAESTRO / ESCLAVOS:
----------------------------

Trama de transmision a los canales RS232-A a RS232-C:

*------------------------------------*
|SOH|STX|ENQ|RS|D1|D0|ETX|CHECKSUM|CR|
*------------------------------------*

Trama de recepcion de los RS232-A a RS232-C. Es la misma para la PC. La diferencia es
que los PIC D1 y D0 van de 00 a 16. En el caso de PC es de 00 a 47.

*--------------------------------------*
|SOH|STX|D1|D0|RS|C|D|U|ETX|CHECKSUM|CR|
*--------------------------------------*

Trama de comando que envia la el maestro a un esclavo indicando un PUERTO, una LINEA y
el valor que puede tener la misma (0 ó 1)
*-----------------------------------------------------*
|SOH|STX|DC1|RS|PORT|RS|LINEA|RS|VALOR|ETX|CHECKSUM|CR|
*-----------------------------------------------------*

----------------------
TRAMAS PC / MAESTRO:
----------------------

Trama que envia la PC para solicitar algun dato del buffer de los esclavos. Similar
al comando que se emplea para solicitar los datos a los esclavos desde el maestro.

*------------------------------------*
|SOH|STX|ENQ|RS|D1|D0|ETX|CHECKSUM|CR|
*------------------------------------*

Trama de comando que envia la PC al maestro indicando en el campo CANAL el destinatario
*--------------------------------------------------------*
|SOH|STX|DC1|CANAL|PORT|RS|LINEA|RS|VALOR|ETX|CHECKSUM|CR|
*--------------------------------------------------------*

Caracteres de control. Tabla de codigos ASCII

SOH - Comienzo de encabezamiento
STX - Comienzo de texto
D1 - Indicador de decenas del buffer
D0 - Indicador de unnidades del buffer
ETX - Final de texto
ENQ - Pregunta
Checksum - Suma en 8 bits de los valores anteriores
CR - Retorno de carro
RS - Separador de registros
C - Centenas
D - Decenas
U - Unidades
CANAL- Canal al cual se envia un comando desde la PC

/*------------------------------------------------------------------------------------
            Definiciones y declaraciones
-----------------------------------------------------------------------------------*/

#define SOH 0x01    // Definicion de los caracteres. Tabla de codigo ASCII
#define STX 0x02
#define ETX 0x03
#define CR 0x0D
#define LF 0x0A
#define RS 0x1E
#define EOT 0x04
#define ACK 0x06
#define NAK 0x15
#define ENQ 0x05
#define DC1 0x11

//-------------------------------------------------------------------------------------

#define MAX_BUFFER     10      // Buffer para los datos de los esclavos
static char buffer[MAX_BUFFER*3];

//-------------------------------------------------------------------------------------

#define MAX_RX    11      // Buffer de recepcion. 11 posiciones
static char buffer_rx[MAX_RX];
static int ptro_buffer_rx=0;      // Ptro a la sgte posicion que esta vacia

//-------------------------------------------------------------------------------------

#define MAX_PREGUNTA 9       // Nro caracteres de la pregunta de la PC
#define MAX_CONTROL1 12       // Nro caracteres del comando a un esclavo
#define MAX_USART 12         // Buffer para Rx del Usart
static char buffer_usart[MAX_USART];
static int ptro_buffer_usart=0;   // Ptro a la sgte posicion que esta vacia

//-------------------------------------------------------------------------------------

char truefalse;
#bit flag      =truefalse.0    // Bandera de tx/rx en canales
#bit tx_comando   =truefalse.1    // Indica si hay comando disponible en un canal
#bit timeout_error   =truefalse.2   // timeout en la lectura de un canal

char canal_comando; // Indica a que canal se va a eniar un comando

//-------------------------------------------------------------------------------------

#bit BIT_RS232A=PORTD.7   // Led indicador de actividad en el canal: RS232-A
#bit BIT_RS232B=PORTD.6   // RS232-B
#bit BIT_RS232C=PORTD.5   // RS232-C
#bit BIT_RS232D=PORTD.4    // RS232-D, canal para transmitir los valores a la PC

/*-------------------------------------------------------------------------------------
             INTERRUPCION SERIAL
-------------------------------------------------------------------------------------*/

#byte   SPBRG_C=SPBRG      // Definicion de los registros que controlan el USART
#byte   TXREG_C=TXREG
#byte   RCREG_C=RCREG
#bit   BRGH_C =TXSTA.BRGH   // Definicion de los bits. Registros Tx/Rx
#bit   SYNC_C =TXSTA.SYNC
#bit   TXEN_C =TXSTA.TXEN
#bit   TX9_C =TXSTA.TX9
#bit   RX9_C =RCSTA.RX9
#bit   CREN_C =RCSTA.CREN
#bit   SPEN_C =RCSTA.SPEN
#bit   TXIF_C =PIR1.TXIF   // Definicion de flag de Tx/Rx
#bit   RCIF_C =PIR1.RCIF
#bit   OERR_C =RCSTA.OERR   // Definicion de los bits de estado del USART en Rx
#bit   FERR_C =RCSTA.FERR

/*-------------------------------------------------------------------------------------
                FUNCIONES
-------------------------------------------------------------------------------------*/

// Rutina para la recepcion serial por interrupcion

static int dir_int;      // Convierte de ASCII a Nro. Dir de buffer a enviar
static char centenas_int;   // Centenas, decenas y unidades del dato a Tx
static char decenas_int;
static char unidades_int;

#int_rda
rda_isr()
{
   // Recepcion de valores via interrupcion que son almacenados en buffer_usart

   if(ptro_buffer_usart < MAX_USART){
      if(!OERR_C && !FERR_C ){   // Revisa los bits de errores
            if( RCREG_C == EOT) ptro_buffer_usart=0;
            else
               buffer_usart[ptro_buffer_usart++]=RCREG_C;
      }
      else{            // Control de errores en USART
         CREN_C = 0;      // Reset OERR
         CREN_C = 1;
         dir_int = RCREG_C;   // Reset del FERR
         ptro_buffer_usart=0;   // Reset del buffer del usart
      }
   }
   else
      ptro_buffer_usart=0;

   // Verifica si tiene un mensaje de la PC tipo pregunta

   if(buffer_usart[2] == ENQ && ptro_buffer_usart == MAX_PREGUNTA){

      // Verifica checksum de la trama
      if(buffer_usart[0]+buffer_usart[1]+buffer_usart[2]+buffer_usart[3]+
       buffer_usart[4]+buffer_usart[5]+buffer_usart[6]==buffer_usart[7]){

         dir_int=( buffer_usart[4]-"0" ) * 10 + ( buffer_usart[5]-"0" );

         // Pasa a texto el contenido de buffer[dir]
         centenas_int = (buffer[dir_int] / 100)+"0";
         decenas_int = buffer[dir_int] % 100;
         unidades_int = (decenas_int % 10) +"0";
         decenas_int = (decenas_int / 10) +"0";

         // Envio del mensaje a la PC
         #use rs232(baud=9600,xmit=PIN_C6,rcv=PIN_C7,ENABLE=PIN_C5)
         putc(SOH)         ;delay_ms(2);
         putc(STX)         ;delay_ms(2);
         printf("%02u",dir_int)      ;delay_ms(2);
         putc(RS)          ;delay_ms(2);
         printf("%03u",buffer[dir_int])   ;delay_ms(2);
         putc(ETX)         ;delay_ms(2);
         putc(SOH+STX+buffer_usart[4]+
          buffer_usart[5]+
          RS+centenas_int+decenas_int+
          unidades_int+ETX)
                     ;delay_ms(2);
         putc(CR);         ;delay_ms(2);

         // Hace cambio en el led indicador
         BIT_RS232D=0;delay_ms(100);BIT_RS232D=1;delay_ms(100);BIT_RS232D=0;
      }

      ptro_buffer_usart=0;   // Reset del buffer del USART
   }

   // Verifica si tiene un mensaje de la PC tipo pregunta

   if(buffer_usart[2] == DC1 && ptro_buffer_usart == MAX_CONTROL1){

      // Verifica checksum de llegada
      if(buffer_usart[0]+buffer_usart[1]+buffer_usart[2]+buffer_usart[3]+
       buffer_usart[4]+buffer_usart[5]+buffer_usart[6]+buffer_usart[7]+
       buffer_usart[8]+buffer_usart[9]==buffer_usart[10]){

         if(buffer_usart[3]=="A") canal_comando=1;   // Elije el canal
         if(buffer_usart[3]=="B") canal_comando=2;
         if(buffer_usart[3]=="C") canal_comando=3;

         buffer_usart[3]=RS;   // Prepara trama que va a enviar al canal

         buffer_usart[10]=buffer_usart[0]+buffer_usart[1]+buffer_usart[2]+
                buffer_usart[3]+buffer_usart[4]+buffer_usart[5]+
                buffer_usart[6]+buffer_usart[7]+buffer_usart[8]+
                buffer_usart[9];

         tx_comando=TRUE;   // Indica en el bucle principal que hay
                  // mensaje. Esto para evitar colisiones
                  // en los accesos concurrentes

         // Hace cambio en el led indicador
         BIT_RS232D=0;delay_ms(100);BIT_RS232D=1;delay_ms(100);BIT_RS232D=0;
      }
      ptro_buffer_usart=0;   // Reset del buffer del USART
   }
}

void configurar_usart()
{
   BRGH_C   = 1;   // 9600 para un XTAL de 4MHz
   SPBRG_C = 25;
   SYNC_C   = 0;   // Configuracion del TXSTA y RCSTA
   SPEN_C   = 1;   // Habilita pines de salida del USART
   TX9_C   = 0;   // 8 bits de datos en Tx
   TXEN_C   = 1;   // Habilita la transmision
   RX9_C   = 0;   // 8 bits de datos en Rx
   CREN_C   = 1;   // Recepcion continua
}

/*-------------------------------------------------------------------------------------
                FUNCIONES
-------------------------------------------------------------------------------------*/
static int canal=0,posicion=0;

void valida_rs232()
{
   if(ptro_buffer_rx >= MAX_RX){   // Si hay mensaje completo
      // Calculamos el checksum de los datos que han llegado
      if(buffer_rx[0]+buffer_rx[1]+buffer_rx[2]+
       buffer_rx[3]+buffer_rx[4]+buffer_rx[5]+
       buffer_rx[6]+buffer_rx[7]+buffer_rx[8]==buffer_rx[9])
          buffer[canal*MAX_BUFFER+posicion]=(buffer_rx[5]-"0")*100+
                (buffer_rx[6]-"0")*10+buffer_rx[7]-"0";
   }
}

static unsigned long timeout;      // Varibles para generar el timeout de un mensaje

int solicita_dato()
{
   ptro_buffer_rx=0;      // Inicializa valores y calcula checksum
   timeout_error=FALSE;
   timeout=0;

   if(canal==0){
      #use rs232(baud=9600,xmit=PIN_B3,rcv=PIN_B2)   // RS232-A
      BIT_RS232A=0;      // Led que indica Tx
      putc(EOT);      delay_ms(2);
      putc(SOH);      delay_ms(2);
      putc(STX);      delay_ms(2);
      putc(ENQ);      delay_ms(2);
      putc(RS);      delay_ms(2);
      putc(posicion / 10+"0");delay_ms(2);
      putc(posicion % 10+"0");delay_ms(2);
      putc(ETX);      delay_ms(2);
      putc(SOH+STX+ENQ+RS+ (posicion / 10+"0") + (posicion % 10+"0") +ETX);
               delay_ms(2);
      putc(CR);
      do{
         while(!kbhit()&&(++timeout<50000)) delay_us(10);// Espera rpta con timeout
         if(kbhit()) buffer_rx[ptro_buffer_rx++]=getc();
            else timeout_error=TRUE;
         if(ptro_buffer_rx >= MAX_RX || timeout_error == TRUE)break;
      }while(1);
      if(timeout_error == FALSE) BIT_RS232A=1;   // Led que indica Tx
   }

   if(canal==1){
      #use rs232(baud=9600,xmit=PIN_B4,rcv=PIN_B5)   // RS232-B
      BIT_RS232B=0;
      putc(EOT);      delay_ms(2);
      putc(SOH);      delay_ms(2);
      putc(STX);      delay_ms(2);
      putc(ENQ);      delay_ms(2);
      putc(RS);      delay_ms(2);
      putc(posicion / 10+"0");delay_ms(2);
      putc(posicion % 10+"0");delay_ms(2);
      putc(ETX);      delay_ms(2);
      putc(SOH+STX+ENQ+RS+ (posicion / 10+"0") + (posicion % 10+"0") +ETX);
               delay_ms(2);
      putc(CR);
      do{
         while(!kbhit()&&(++timeout<50000))delay_us(10);   // Espera rpta con timeout
         if(kbhit()) buffer_rx[ptro_buffer_rx++]=getc();
            else timeout_error=TRUE;
         if(ptro_buffer_rx >= MAX_RX || timeout_error == TRUE)break;
      }while(1);
      if(timeout_error == FALSE) BIT_RS232B=1;
   }

   if(canal==2){
      #use rs232(baud=9600,xmit=PIN_D3,rcv=PIN_D2)   // RS323-C
      BIT_RS232C=0;
      putc(EOT);      delay_ms(2);
      putc(SOH);      delay_ms(2);
      putc(STX);      delay_ms(2);
      putc(ENQ);      delay_ms(2);
      putc(RS);      delay_ms(2);
      putc(posicion / 10+"0");delay_ms(2);
      putc(posicion % 10+"0");delay_ms(2);
      putc(ETX);      delay_ms(2);
      putc(SOH+STX+ENQ+RS+ (posicion / 10+"0") + (posicion % 10+"0") +ETX);
               delay_ms(2);
      putc(CR);
      do{
         while(!kbhit()&&(++timeout<50000))delay_us(10);   // Espera rpta con timeout
         if(kbhit()) buffer_rx[ptro_buffer_rx++]=getc();
            else timeout_error=TRUE;
         if(ptro_buffer_rx >= MAX_RX || timeout_error == TRUE)break;
      }while(1);
      if(timeout_error == FALSE) BIT_RS232C=1;
   }

   if(timeout_error == TRUE || ptro_buffer_rx < MAX_RX) return 1;
   delay_ms(10);
   return 0;
}

/*--------------------------------------------------------------------------------------
             Fin de la libreria
--------------------------------------------------------------------------------------*/

/*--------------------------------------------------------------------------------------
             Funcion principal
--------------------------------------------------------------------------------------*/

#zero_ram
void main()
{
set_tris_a(0x00);    // Configura los puertos
set_tris_b(0x24);
set_tris_c(0x80);
set_tris_d(0x04);
set_tris_e(0x00);

#use rs232(baud=9600,xmit=PIN_C6,rcv=PIN_C7,ENABLE=PIN_C5)
putc(SOH);
delay_ms(2);    // Envia un caracter para indicar que el equipo esta operativo

configurar_usart();    // Configura el usart
enable_interrupts(INT_RDA); // Habilita la interrupcion del Rx Serial
enable_interrupts(global);    // Habilita el GIE
tx_comando=FALSE;

do{

   // Lectura de los valores que estan en los esclavos
   flag=FALSE;
   for(posicion=0;posicion<MAX_BUFFER;posicion++){
      flag = solicita_dato();
      if(flag==FALSE) valida_rs232();
       else
         for(posicion=0;posicion<MAX_BUFFER;posicion++)
            buffer[canal*MAX_BUFFER+posicion]=0x00;
   }

   canal++;       // Representa el cambio de canal que leemos (0,1,2)
   if(canal==3) canal=0;

   if(tx_comando==TRUE){      // Si hay comando para transmitir
      if(canal_comando==1){
         #use rs232(baud=9600,xmit=PIN_B3,rcv=PIN_B2)   // RS232-A
         putc(EOT);
         delay_ms(2);
         for(posicion=0;posicion<MAX_CONTROL1;posicion++){
            putc(buffer_usart[posicion]);
            delay_ms(2);
         }
         putc(EOT);
         delay_ms(2);
      }
      if(canal_comando==2){
         #use rs232(baud=9600,xmit=PIN_B4,rcv=PIN_B5)   // RS232-B
         putc(EOT);
         delay_ms(2);
         for(posicion=0;posicion<MAX_CONTROL1;posicion++){
            putc(buffer_usart[posicion]);
            delay_ms(2);
         }
         putc(EOT);
         delay_ms(2);
      }
      if(canal_comando==3){
         #use rs232(baud=9600,xmit=PIN_D3,rcv=PIN_D2)   // RS323-C
         putc(EOT);
         delay_ms(2);
         for(posicion=0;posicion<MAX_CONTROL1;posicion++){
            putc(buffer_usart[posicion]);
            delay_ms(2);
         }
         putc(EOT);
         delay_ms(2);
      }
      tx_comando=FALSE;   // Resetea bandera de transmision de comando
   }
}while(TRUE);
}

Título: RE: Microcursillo en C
Publicado por: juan-jubilado en 30 de Noviembre de 2005, 10:34:00

Hola compañeros:
Aunque normalmente he estado haciendo preguntas en otro hilo, me decido a dirigirme a este porque creo que será mas interesante.
El asunto que quiero plantearos es el siguiente:
En un programa para un PIC16F84a, el cuál genéricamente funciona, en las siguientes lineas:

if (((input(PIN_A0)==0)||(input(PIN_A1)==0)||(V2==1))&&(V1==1)) output_low(PIN_B7);
else output_high(PIN_B7);

que forman parte de dicho programa, como puedo retardar la sentencia output_high(PIN_B7); por ejemplo un segundo.

Gracias.

Título: RE: Microcursillo en C
Publicado por: juan-jubilado en 01 de Diciembre de 2005, 10:22:00

Hola nocturno:

Veo que sigues en la brecha, y haces verdadero el lema "come y duerme en el foro". Bueno a lo que voy es, en primer lugar gracias por la rapidez de la respuesta, he probado lo que me indicas pero observo que dicha interrupción afecta tambien a las demas sentencias del tipo if-else, que hay en el programa, y esta anomalia hace que el conjunto requiera unos impulsos de entrada mas largos, y lo que pretendo es que el retardo se produzca sólo en la patilla de salida RB7, en el nivel alto.

Saludos.

Título: RE: Microcursillo en C
Publicado por: Nocturno en 01 de Diciembre de 2005, 15:05:00

Hola Juan, pues sí, este foro es un vicio.

Con respecto a tu duda, no sé si la he entendido bien.
Sospecho que lo que tú deseas es que mientras se espera ese segundo para activar la salida, tu programa siga corriendo y ejecutando el resto de comprobaciones.
Si efectivamente es así, el Delay_Ms no sirve porque absorbe el proceso para él solito.

Una posible solución a tu problema sería mantener una variable contadora que se incremente en cada ciclo de tu programa una cantidad X:

Codigo:
 Contador = Contador + incremento_variable;

Por defecto, la variable incremento_variable estaría a 0, por lo que el contador no se movería. Pero tras la comprobación de la condición de tu programa establecerías:

Codigo:
 if (((input(PIN_A0)==0)||(input(PIN_A1)==0)||(V2==1))&&(V1==1))
    output_low(PIN_B7); 
 else 
     {
   incremento_variable=1;
  }

Así, el contador empezaría a crecer con cada ciclo.

Sólo faltan dos cosas. Primero averiguar el tiempo que tarda en producirse un ciclo completo, y por tanto, cuántos ciclos se dan en un segundo. Si por ejemplo se dieran 20000 ciclos por segundo, establecerías la condición:

Codigo:
 if (Contador==20000)
  {
   incremento_variable=0;  // paramos los incrementos
   output_high (PIN_B7);
  }

Uff, menudo ladrillo te acabo de soltar...

Título: RE: Microcursillo en C
Publicado por: Diego_arrow en 05 de Diciembre de 2005, 06:51:00

Hola a todos, siguiendo el consejo de Nocturno, decidí aprender a programar C con el minicursillo

Ahora empeze como todos haciendo parpadear un led,

#include <16f84a.h> //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT //ordenes para el programador
#use delay (clock=4000000) //Fosc=4Mhz
#use fast_io(b)

///PROGRAMA
void main(void)
{
set_tris_b(0x00); //portb como salida
disable_interrupts(GLOBAL);

do{ //esto seria para una luz estroboscopica//
output_high(PIN_B3); //salida 1//
delay_ms(75); //espera 75ms//
output_low(PIN_B3); //salida 0//
delay_ms(75); //espera 75ms//
output_high(PIN_B3); //salida 1//
delay_ms(75); //espera 75ms//
output_low(PIN_B3); //salida 0//
delay_ms(1500); //espera 1500ms//

}
while(TRUE); //bucle infinito

}

Pero ahora quisiera hacer una sirena, y no se como emplear los retardos.(parece que me afecta a todo el delay)

Yo querria hacer un retardo de una onda cuadrada durante, por ejemplo, 1000ms y luego que comienze otra onda cuadrada de distinta frecuencia y haga otro retardo de 1000ms y asi indefinidamente,

si quereis pongo lo que tengo pensado, pero no lo pongo ahora para no hacer esto muy voluminoso

Un saludo

Título: RE: Microcursillo en C
Publicado por: micro_pepe en 06 de Diciembre de 2005, 06:40:00

Hola, me gustaria que alguien me esplicase con un poco mas de detalles que en el manual, las directivas:

#rom

#use rs232

#printf

En la rom, no se que direcciones se deben poner entre parentesis, supongo que una por posicion de la EEPROM de datos usada, y que direccion se debe poner antes del parentesis.

Y en la rs232, no se para que sirve en programas que no se conectan por este protocolo a un PC.

Saludos y gracias.

Título: RE: Microcursillo en C
Publicado por: omibaya en 08 de Diciembre de 2005, 21:02:00

bueno en lo que conozco de teoria, #rom lo puedes usar para guardar datos en la EEPROM, pero sinceramente jamas lo use, el #rs232 no sirve de nada si no usas transmision serial, ya sea con pc o con cualquier dispositivo serial, y el #printf no existe, al menos no en mi version de CCS, lo que si existe es el printf y se usa para mandar texto o caracteres a traves de una conexion serial, tambien puede ser usada para imprimir caracteres en un LCD

Título: RE: Microcursillo en C
Publicado por: hhpp en 10 de Diciembre de 2005, 08:45:00

Hola amigos perdon que interumpa sus laboires, pero necesito su ayuda
miren estoy usando el 16f873 pero tengo problemas con la
inicialmente leo los valores de entraas y salidas luego habo una convewrsin en los canales analogicos, pero si por ejemplo una entrada se pone a 1 su salida correspondiente se pone a 1 hasta ahi bien pero cuando la entrada se pone a cero su salida ya no (la entrda mantien un voltaje pequeño que no deja a la salida apagarse)
Colaborenme en esto cumpas.
hp.

Título: RE: Microcursillo en C
Publicado por: hhpp en 12 de Diciembre de 2005, 20:07:00

Hola amigos aquii va una parte de mi codigo

void main()
{
float diff_i;
unsigned char adcchan;
char x,y;
PORTA=0;
PORTB=0;
PORTC=0;
ADCON1=0x84; //an0-an3 analog,rigth j,vref=vcc
TRISA=0xFF; //input
TRISC=0xBB; //rx in, tx out, PWM out.
TRISB=0x00;
OPTION=0xCF;//pull ups(PORTB) //disabled,clkout,prescaler 1 :128 WDT
ini_232(); //tx on,asin,8,9600,usart on
for(; Giño

//loop
{ //Here I test the inputs
CLRWDT();
if(RC1==1)
{ RB1=1;}
else
{ RB1=0;}
if(RC0==1)
{ RB2=1;}
else
{ RB2=0;}
if(RA4==1)
{ RB3=1;}
else
{ RB3=0;}
if(RA5==1)
{ RB4=1;}
else
{ RB4=0;}

//{ Solo leo AN0,AN1 y AN3, AN2 es una entrada digital(trisA)
for(adcchan=0;adcchan<4;adcchan++)
{
if(adcchan==2) adcchan+=1;
diff_i=get_adc_value(adcchan);
print_result(adcchan,diff_i);
DelayMs(100);
}
//}
}
}
Elproblema como les comente antes
a.) Si RA4(5 volts in RA4) esta en uno logicoentonces RB3=1(% volts), pero cuando se quitan los 5 voltios de RA4, es como si retendria un voltaje
(2V) y esto hace que TB3 nunca llegue a cero voltios.( RB3!=0).
No entiendo por que sera un problema del micro?denme una mano si,(con las demas entradsa es casi lo mismo)
Hp.

Título: RE: Microcursillo en C
Publicado por: micro_pepe en 16 de Diciembre de 2005, 13:30:00

Gracias por tu respuesta omibaya.

Por otro lado, ¿Sabiais que esto:

delay_ms(500);
delay_ms(500);
delay_ms(500);
delay_ms(500);
delay_ms(500);

ocupa mas espacio de memoria, que esto:

delay_ms(2500); ??

Yo pensaba que el ccs, al ver que se escribe el mismo retardo varias veces, lo trataba como una rutina, y solo lo escribia una vez, pero no es así. Quizas vosotros ya lo sabiais, pero yo estoy empezando con el C, y me ha sorprendido.

Saludos.

Título: RE: Microcursillo en C
Publicado por: vszener en 16 de Diciembre de 2005, 16:06:00

Bueno que ocupe mas espacio de memoria es logico, ya que cada vez que se llama a una funcion, el compilador lo que hace es pegar todas las instrucciones de dicha funcion en el sitio donde se ha llamado, en este caso tu has puesto 5 llamadas de una funcion(delay), eso hara que al compilarlo esten 5 rutinas de delay unas detras, en cambio en la otra rutina aunque sea de mas tiempo solamente se llamada una vez, aparte los tiempos de retardo tambien vienen delimitados por los tipos de las variables definidas en dichas funciones....

Giño

Título: RE: Microcursillo en C
Publicado por: micro_pepe en 18 de Diciembre de 2005, 16:28:00

Hola a todos:

Alguien sabe como se puede usar un "long" , definido en ccs, con instrucciones en ensamblador, con un "int" no hay problema, pues se usa como si fuese un registro normal definido en ensamblador.

Saludos y gracias.

Título: RE: Microcursillo en C
Publicado por: FixxxerMetal en 31 de Enero de 2006, 19:01:00

De que me sirve usar la libreria #include <lcd.c>??? no sabia que esta existia y tuve que hacer mi propio programa para inicializar y mostrar palabas en el lcd.

Título: RE: Microcursillo en C
Publicado por: Nocturno en 01 de Febrero de 2006, 00:08:00

Es una librería que aporta CCS para precísamente ahorrarte tener que diseñar tú todas las funciones de gestión de un LCD.
Si miras en la carpeta "Drivers" del directorio donde hayas instalado el compilador, verás una lista de dispositivos para los que CCS ya tiene librerías.

Título: RE: Microcursillo en C
Publicado por: pocher en 01 de Febrero de 2006, 00:26:00

microfalo si a lo que te refieres es que si a partir un registro (variable int), unirlo con otro registro (variable int) para conseguir una variable long se hace con make16(), mirate también el make(8), y el make(32).

Un saludo

Título: RE: Microcursillo en C
Publicado por: FixxxerMetal en 01 de Febrero de 2006, 18:41:00

Que hacen estas librerias?
la fuses no conozco: NOBROWNOUT, NOCPD, NOWRT
las otras dos librerias ni idea.
#include <stdlib.h>
#fuses XT, NOPROTECT, PUT, NOWDT, NOBROWNOUT, NOLVP, NOCPD, NOWRT
#zero_ram

Título: RE: Microcursillo en C
Publicado por: Nocturno en 02 de Febrero de 2006, 00:58:00

Si utilizas el Asistente de CCS para crear un proyecto nuevo, y seleccionas el modelo de PIC con que vas a trabajar, no tendrás que preocuparte del significado de los FUSES, porque contestando a los parámetros de configuración de un formulario, él se encargará de generar el código correcto.
De todas formas, te pego aquí lo que genera al crear el código para un 18F4550 de manera automática, porque seguro que te sacará de muchas dudas:

Codigo:
#device adc=8

#FUSES NOWDT                    //No Watch Dog Timer
#FUSES WDT128                   //Watch Dog Timer uses 1:128 Postscale
#FUSES XT                       //Crystal osc <= 4mhz
#FUSES NOPROTECT                //Code not protected from reading
#FUSES BROWNOUT_SW              //Brownout controlled by configuration bit in special file register
#FUSES BROWNOUT                 //Reset when brownout detected
#FUSES BORV20                   //Brownout reset at 2.0V
#FUSES NOPUT                    //No Power Up Timer
#FUSES NOCPD                    //No EE protection
#FUSES STVREN                   //Stack full/underflow will cause reset
#FUSES NODEBUG                  //No Debug mode for ICD
#FUSES LVP                      //Low Voltage Programming on B3(PIC16) or B5(PIC18)
#FUSES NOWRT                    //Program memory not write protected
#FUSES NOWRTD                   //Data EEPROM not write protected
#FUSES IESO                     //Internal External Switch Over mode enabled
#FUSES FCMEN                    //Fail-safe clock monitor enabled
#FUSES PBADEN                   //PORTB pins are configured as analog input channels on RESET
#FUSES NOWRTC                   //configuration not registers write protected
#FUSES NOWRTB                   //Boot block not write protected
#FUSES NOEBTR                   //Memory not protected from table reads
#FUSES NOEBTRB                  //Boot block not protected from table reads
#FUSES NOCPB                    //No Boot Block code protection
#FUSES MCLR                     //Master Clear pin enabled
#FUSES LPT1OSC                  //Timer1 configured for low-power operation
#FUSES NOXINST                  //Extended set extension and Indexed Addressing mode disabled (Legacy mode)
#FUSES PLL1                     //No PLL PreScaler

Título: RE: Microcursillo en C
Publicado por: lovando en 14 de Febrero de 2006, 21:12:00

Hola

Alguien le ha dado una vuelta a esto???

http://sdcc.sourceforge.net/

Saludos

Título: RE: Microcursillo en C
Publicado por: Nocturno en 15 de Febrero de 2006, 00:57:00

Parece que aún no soporta los PIC...

Título: RE: Microcursillo en C
Publicado por: vszener en 15 de Febrero de 2006, 05:10:00

Bueno.....la competencia hace que se mejoren unos a otros.... Giño

Título: RE: Microcursillo en C
Publicado por: gONzAO en 16 de Marzo de 2006, 05:22:00

Escrito originalmente por nocturno66
Parece que aún no soporta los PIC...

Sí, sí que vale para los pic

Un saludo

gONzAO

Título: Re: Microcursillo en C
Publicado por: Bigdogo en 18 de Abril de 2006, 20:04:34

Hola a todos,

Como puedo hacer para leer, por ejemplo, lo que hay en la puerta A de un 16F628 y guardar los datos en la memoria del PIC? Como puedo verificar que los datos han sido guardados correctamente?

Saludos,

Jose

Título: Re: Microcursillo en C
Publicado por: Nocturno en 19 de Abril de 2006, 02:30:13

Imagino que te refieres a almacenarlas en la memoria eeprom del pic.
Si es así, te convendría echar un vistazo al ejemplo EX_INTEE.C del CCS donde aparecen las funciones para manejar la eeprom.
Te recomiendo que luego hagas tu código y si tienes dudas las postees adjuntándolo, así será más fácil ayudarte.

Título: Re: Microcursillo en C
Publicado por: Bigdogo en 19 de Abril de 2006, 14:43:10

Gracias Nocturo, hechare un vistazo

Título: Re: Microcursillo en C
Publicado por: Duende_Azul en 20 de Abril de 2006, 17:59:30

Pregunta:

El siguiente código fué hecho en ccs:

Código: C#

byte limite;
 
void copia_vector(byte*vect1[4], *vect2[4], tamano){
For (i=0;i<tamano;++i)
   vect2[i]=vect1[i];
}
 
while (true){
leer_teclas();
 
switch (tecla){
   case 1: Menu_config(1);
           limite = 3;
           copia_vector(vector_slope,cantidad,limite);
           Cambia_numero();
           copia_vector(cantidad,vector_slope,limite);
   break;
 
   case 2: Menu_config(2);
           limite = 3;
           copia_vector(vector_T1,cantidad,3);
           Cambia_numero();
           copia_vector(cantidad,vector_T1,3);
   break;
 
   case 3: Menu_config(3);
           limite = 4;
           copia_vector(vector_T2,cantidad,4);
           Cambia_numero();
           copia_vector(cantidad,vector_T2,4);
   break;
 
   case 4: Menu_config(4);
           limite = 4;
           copia_vector(vector_Time,cantidad,4);
           Cambia_numero();
           copia_vector(cantidad,vector_Time,4);
   break;
}

si el resultado de leer teclas es 1, vamos a copiar vector_slope en otro llamado cantidad la variable limite indica cuantos elementos van a copiarse y en este caso se inicializa con el valor 3; asi pues si tecla es 1, se muestra un menu de configuracion, limite se establece con valor 3, se hace la primera copia y he aqui el problema: ¿porque limite retorna con valor 0? segun entiendo, el pase de parametros es por valor por lo que una copia de limite es lo que deberia utilizarse en la subrutina (amen de que en la subrutina no se modifica dicha variable...)

¿que está mal?

Título: Re: Microcursillo en C
Publicado por: Modulay en 20 de Abril de 2006, 18:18:54

No veo por qué te hace eso,aunque si deberías poner la cabecera completa,especificando los tipos de todos los parámetros...de hecho,no debería ni compilar si no se ponen...este ccs...

Código: C++

void copia_vector(byte*vect1[4],byte *vect2[4],byte tamano)

Título: Re: Microcursillo en C
Publicado por: Duende_Azul en 20 de Abril de 2006, 18:37:45

Modulay, gracias por responder, pero te cuento que asi como lo puse fue como quedó (a eso de las 4:30am), antes lo tenia tal cual como lo pones y siempre limite retorna como 0, pero la rutina hace su funcion perfectamente, el detalle es que limite cambia de valor; la solucion fue poner el valor de limite como un numero como puedes ver en las demas opciones.

Estoy a punto de declararlo como un bug :?

Título: Re: Microcursillo en C
Publicado por: Modulay en 20 de Abril de 2006, 19:06:09

ajajaj pues no sería muy descabellado.
Supongo que se te habrá escapado al pastear el código,pero no veo la llave de cierre del while.A ver si se te va a estar colando código que no debiera dentro del bucle

Título: Re: Microcursillo en C
Publicado por: Duende_Azul en 20 de Abril de 2006, 21:11:37

:shock:
esto es de locos...

asi, no funciona:

Código: C#

#include "C:\Archivos de programa\PICC\Proyectos\Horno_16f877\Horno_877.h"
//#include <LCD_modif.C>
#include <flex_lcd.c>
#include <math.h>
#define muestras 10
#define slope_dir 0
#define T1_dir    3
#define T2_dir    6
#define Time     10
 
//Coeficientes inversos - Termocupla K -
//    de 0 a 500ºC
float const c[20]={0,                 // a0
                   2.508355E1  ,      // a1
                   7.860106E-2 ,      // a2
                  -2.503131E-1 ,      // a3
                   8.315270E-2 ,      // a4
                  -1.228034E-2 ,      // a5
                   9.804036E-4 ,      // a6
                  -4.413030E-5 ,      // a7
                   1.057734E-6 ,      // a8
                  -1.052755E-8 ,      // a9
 
//  de 500ºC a  1300ºC
                  -1.318058E2  ,      // b0
                   4.830222E1  ,      // b1
                  -1.646031E0  ,      // b2
                   5.464731E-2 ,      // b3
                  -9.650715E-4 ,      // b4
                   8.802193E-6 ,      // b5
                  -3.110810E-8 ,      // b6
                   0           ,      // b7
                   0           ,      // b8
                   0           ,   }; // b9
 
float temperatura;
float voltaje,voltaje_t;
float valor;
float T_amb,T_rampa,T_max,T1,T2;
float t_act;
int16 Tiempo;
boolean sw=True;
byte base,i,etapa;
byte Tecla=0;
byte contador=0;
byte cuenta=0;
byte cursor_pos=0;
byte vector_t1[4]={0,0,0,0};
byte vector_t2[4];
byte vector_slope[4]={9,8,7,0};
byte vector_time[4];
byte raw[4];
byte cantidad[4];
byte limite;   //<----- Variable implicada en mi trasnocho...

Asi si funciona:

Código: C#

#include "C:\Archivos de programa\PICC\Proyectos\Horno_16f877\Horno_877.h"
//#include <LCD_modif.C>
#include <flex_lcd.c>
#include <math.h>
#define muestras 10
#define slope_dir 0
#define T1_dir    3
#define T2_dir    6
#define Time     10
 
//Coeficientes inversos - Termocupla K -
//    de 0 a 500ºC
float const c[20]={0,                 // a0
                   2.508355E1  ,      // a1
                   7.860106E-2 ,      // a2
                  -2.503131E-1 ,      // a3
                   8.315270E-2 ,      // a4
                  -1.228034E-2 ,      // a5
                   9.804036E-4 ,      // a6
                  -4.413030E-5 ,      // a7
                   1.057734E-6 ,      // a8
                  -1.052755E-8 ,      // a9
 
//  de 500ºC a  1300ºC
                  -1.318058E2  ,      // b0
                   4.830222E1  ,      // b1
                  -1.646031E0  ,      // b2
                   5.464731E-2 ,      // b3
                  -9.650715E-4 ,      // b4
                   8.802193E-6 ,      // b5
                  -3.110810E-8 ,      // b6
                   0           ,      // b7
                   0           ,      // b8
                   0           ,   }; // b9
 
float temperatura;
float voltaje,voltaje_t;
float valor;
float T_amb,T_rampa,T_max,T1,T2;
float t_act;
int16 Tiempo;
byte limite;         //<------- Misma variable pero en otra direccion de memoria
boolean sw=True;
byte base,i,etapa;
byte Tecla=0;
byte contador=0;
byte cuenta=0;
byte cursor_pos=0;
byte vector_t1[4]={0,0,0,0};
byte vector_t2[4];
byte vector_slope[4]={9,8,7,0};
byte vector_time[4];
byte raw[4];
byte cantidad[4];

se podria pensar que podria ser la memoria del micro pero no! en proteus tambien pasa.. ve tu a sabé :x

Título: Re: Microcursillo en C
Publicado por: vszener en 21 de Abril de 2006, 05:48:05

¿que version de ccs usas? :shock:

Suerte!!! :wink:

Título: Re: Microcursillo en C
Publicado por: Modulay en 21 de Abril de 2006, 10:06:24

Dentro de lo que cabe me parece normal,las declaraciones de variables deben ir antes que nada,incluídas posibles inicializaciones:

Código: C (Mac)

byte a,b,c;
int d,f;
a=0;
b=0;
c=1;
.......

Título: Re: Microcursillo en C
Publicado por: Duende_Azul en 21 de Abril de 2006, 14:02:08

wueno... ya he probado de todo, inicializando, no inicializando, ahora resulta que a uno de los vectores (vector_t1[4]) se le escribe un numero cuando se esta copiando cantidad a vector_slope y esto justo en la direccion 0x73 de la memoria de datos
declaro la direccion 0x73 como la direccion maldita (http://img126.imageshack.us/img126/2072/smiley116lq.gif) (http://imageshack.us)

en ccs hay uuna manera de definir la posicion de memoria que ocupara una variable? algo asi como DB en assembler?

PD: elmasvital, si puedes agrega este careto a la lista pues me parece que es la cara que ponemos cuando el compilador hace lo que se le da la gana....
(http://img126.imageshack.us/img126/2072/smiley116lq.gif) (http://imageshack.us) (http://img126.imageshack.us/img126/2072/smiley116lq.gif) (http://imageshack.us)

Título: Re: Microcursillo en C
Publicado por: Bigdogo en 21 de Abril de 2006, 15:03:21

Hola,

En el maula del C cpmpiler de Andrés Cánovas dice:

WRITE_EEPROM(address, value)
Esta función escribe un byte de datos en la dirección de memoria EEPROM
especificada. address puede valer 0-63; value es el byte de datos a escribir;
Esta función puede tardar varios milisegundos para ejecutarse.
Ejemplo:
#define LAST_VOLUME 10
volume++;
write_eeprom(LAST_VOLUME,volume);

Quantos milisegundos de delay devemos poner despues de "write_eeprom(LAST_VOLUME,volume);" para asegurar que todo se grabo bien y grabar otro dato?

Título: Re: Microcursillo en C
Publicado por: Modulay en 21 de Abril de 2006, 15:10:11

No hace falta que pongas retardos.
El algoritmo de escritura de la eeprom no termina de ejecutarse hasta que el dato queda grabado,de ahí que haya ese retardo,ya que ese tipo de memoria es algo lenta

Título: Re: Microcursillo en C
Publicado por: Bigdogo en 21 de Abril de 2006, 15:38:58

Muchas Gracias Modulay,

Título: Re: Microcursillo en C
Publicado por: Bigdogo en 22 de Abril de 2006, 16:04:51

Hola a todos,

Perdonar por las preguntas basicas, pero no encuentro las respustas por ningun lado.

Si hago:
set_tris_B(0b10001111); // Puerto B configurado, 1 entrada 0 salida
output_b(0x00); // Limpia B
set_tris_a(0b00010000); // Puerto A configurado, 1 entrada 0 salida
output_a(0x00); // Limpia A

Primera pregunta: como estoy configurando el puerto B como entradas y salidas, y despues le envio un output_b(0b00000000); esto pone 0 en todas las salidas y entradas? que passa cunado pongo 0 en una entrada?

Segunda pregunta: el puerto A tiene apenas 5 bits (RA0 hasta RA4), porque es necesario poner (0b00010000)(8 bits)? Si guardo en la memoria "write_eeprom(dir,port_a);", que datos voy a tener en los ultimos bits?

Título: Re: Microcursillo en C
Publicado por: Nocturno en 23 de Abril de 2006, 02:15:48

Cita de: Bigdogo en 22 de Abril de 2006, 16:04:51

Primera pregunta: como estoy configurando el puerto B como entradas y salidas, y despues le envio un output_b(0b00000000); esto pone 0 en todas las salidas y entradas? que passa cunado pongo 0 en una entrada?

En CCS hay básicamente dos formas de trabajar con los puertos, y dependerá de cómo lo tengas configurado.
Si no le indicas nada, estarás trabajando en el modo STANDARD_IO, en el que el compilador se encargará de activar los TRIS adecuados antes de cada operación de escritura o lectura, facilitando la vida al programador en ese sentido.
Si le indicas #USE FAST_IO(puerto) esa responsabilidad recaerá sobre el programador, porque el compilador no añadirá nada adicional.
En el modo STANDARD_IO, si haces un OUTPUT_B(0), el compilador internamente colocará delante un SET_TRIS_B(0), configurando TODO EL PUERTO como salida.
Sin embargo, si haces un OUTPUT_BIT (PIN_B3), sólo configurará como salida ese pin.

En el modo FAST_IO, si envías un 0 a un puerto entero, en el que hay configurados pines como entrada y pines como salida, sólo se colocarán a nivel bajo los pines de salida, quedando en alta impedancia los de entrada.

Cita de: Bigdogo en 22 de Abril de 2006, 16:04:51

Segunda pregunta: el puerto A tiene apenas 5 bits (RA0 hasta RA4), porque es necesario poner (0b00010000)(8 bits)? Si guardo en la memoria "write_eeprom(dir,port_a);", que datos voy a tener en los ultimos bits?

Aunque el puerto A en el micro que estás usando no esté publicado al completo por falta de pines, internamente se gestiona como un puerto completo, ocupando un byte entero en la memoria del micro. No sé qué aparecerá en los bits RA5,RA6 y RA7 si los configuras como entrada; habría que probarlo.

Título: Re: Microcursillo en C
Publicado por: Bigdogo en 23 de Abril de 2006, 10:51:05

Gracias Nocturno,

Todavia no me aclaro mucho pero echa una ojeada a parte de mi programa:

#include <16F84A.h>
#fuses NOWDT,XT, NOPUT, NOPROTECT //fusibles
#use delay(clock=4000000) // Velocidad del cristal
#use fast_io(B) //Para hacerlo FAST el port B
#use fast_io(A) //Para hacerlo FAST el port A
#byte INTCON = 0x0B
set_tris_B(0b10001111); // Puerto B configurado, 1 entrada 0 salida
output_b(0x00); // Limpia B
set_tris_a(0b00010000); // Puerto A configurado, 1 entrada 0 salida
output_a(0x00); // Limpia A

Como pudes ver utilizo el #use fast_io(B) y set_tris para configurar el puerto B. Rb0,1,2,3 y 7 son entradas y Rb 4,5, y 6 son salidas.

Quiero que tolos los pines que sean salidas esten en 0 cuando empiece la ejecucion del programa.

Entonces utilizo output_b(0x00), mi pregunta es que si cuando hago output_b(0x00) el micro sabe que SOLAMENTE deve poner 0 en RB4,5 y 6, ya que son las SALIDAS, o pone 0 en todo el puerto B.

Si pone 0 en todo el puerto B, que passa con mis entradas RB0,1,2,3 y 7 ?

Cuanto a la pregunta 2, he encontrado un metodo para utilizar solamente el dato que me interesa y asy lo hecho:

valor_recebido= valor_memoria & 0b00001111; //mascara para utilizar solamente los datos contenidos en Ra0, 1, 2 y 3

Título: Re: Microcursillo en C
Publicado por: Nocturno en 23 de Abril de 2006, 11:58:32

Sí, si haces output_b(0) sólo se ponen a 0 tus pines de salida; los de entrada se quedan en alta impedancia.

Título: Re: Microcursillo en C
Publicado por: Bigdogo en 23 de Abril de 2006, 15:34:51

Perfecto, muchas gracias

Título: Re: Microcursillo en C
Publicado por: Bigdogo en 23 de Abril de 2006, 16:46:50

Hola a todos,

Ya estoy outra vez con mas dudas...pero quiero aprender el C para los PICs.

Hecho el siguiente programa, y lo que deberia hacer seria encender y apagar un led con el mismo pulsador, nada de mas...
Hecho la simulacion en PROTEUS y el led solamente se enciende, no se apaga, por que?

Es posible hacer que el proteus te muestre una pantalla con el codigo C en ejecucion? He puesto en ON a todas las ventanas del Debug en proteus, pero no veo la ejecucion del codigo en C.

Gracias de antemano por el cable...

#include <16F84A.h>
#use delay(clock=4000000)
#int_EEPROM
#use fast_io(B)
#fuses XT,NOWDT,NOPUT

//globales
int ap=1;

//Rutinas

void enciende()
{
while(PIN_B7) // Hasta que pulsemos RB7
{
if(input(PIN_B7)) // Se ha pulsado RB7
{
delay_ms(100); //rebote
output_low(PIN_B4); //zero en la salida, led encendido
}
}
ap=0; // la proxima pulsacion se va a apaga
}

void apaga()
{
while(PIN_B7) // Hasta que pulsemos RB7
{
if(input(PIN_B7)) // Se ha pulsado RB7
{
delay_ms(100); // rebote
output_high(PIN_B4); //Uno en la salida, led apagado
}
}
ap=1; //la proxima pulsacion se va a enciende
}

//Principal, deveria encender y apagar un led en RB4, con un pulsador en RB7
//Elpulsador cuando entra envia +5V al pin 13 (RB7)
//el LED esta con el anodo al + y el catodo al pin 10 (RB4) del 16F84A

void main()
{
set_tris_B(0b10001111); // RB0,1,2,3 y 7 entradas RB4,5 y 6 salidas
output_high(PIN_B4); // zero la salida, led apagado

if(ap=1)
{
enciende();
}
else
{
apaga();
}
}

Título: Re: Microcursillo en C
Publicado por: Mario_2004 en 23 de Abril de 2006, 17:46:56

Hola Bigdogo, tienes un error en esta línea:

Código: [Seleccionar]

if(ap=1)
le estás asignando siempre el valor 1 a la variable ap, cambialo por lo siguiente:

Código: [Seleccionar]

if(ap==1)
saludos

Mario

Título: Re: Microcursillo en C
Publicado por: Bigdogo en 23 de Abril de 2006, 18:30:36

Hoal Mario,

Gracias por la ayuda, hecho la modificacion y infelizmente sigue igual, o sea, se enciende y no se apaga.

Título: Re: Microcursillo en C
Publicado por: Bigdogo en 23 de Abril de 2006, 18:35:10

Mofificaciom, pero sigue igual, se enciende y no se apaga.

#include <16F84A.h>
#use delay(clock=4000000)
#int_EEPROM
#use fast_io(B)
#fuses XT,NOWDT,NOPUT

//globales
int ap=1;

//Rutinas

void enciende()
{
while(PIN_B7) // Hasta que pulsemos RB7
{
if(input(PIN_B7)) // Se ha pulsado RB7
{
delay_ms(100); //rebote
output_low(PIN_B4); //zero en la salida, led encendido
}
}
ap=0; // la proxima pulsacion se va a apaga
}

void apaga()
{
while(PIN_B7) // Hasta que pulsemos RB7
{
if(input(PIN_B7)) // Se ha pulsado RB7
{
delay_ms(100); // rebote
output_high(PIN_B4); //Uno en la salida, led apagado
}
}
ap=1; //la proxima pulsacion se va a enciende
}

//Principal, deveria encender y apagar un led en RB4, con un pulsador en RB7
//Elpulsador cuando entra envia +5V al pin 13 (RB7)
//el LED esta con el anodo al + y el catodo al pin 10 (RB4) del 16F84A

void main()
{
set_tris_B(0b10001111); // RB0,1,2,3 y 7 entradas RB4,5 y 6 salidas
output_high(PIN_B4); // zero la salida, led apagado

if(ap==1)
{
enciende();
}
else
{
apaga();
}
}

Título: Re: Microcursillo en C
Publicado por: Mario_2004 en 23 de Abril de 2006, 20:20:07

Hola Jose, prueba con este código:

Código: [Seleccionar]

#include <16F84A.h>
#use delay(clock=4000000)
#use fast_io(B)
#fuses HS,NOWDT,NOPUT

//globales
int ap=1;

//Rutinas

void enciende(){
	do{  // Hasta que pulsemos RB7
		delay_ms(100); //rebote
		output_low(PIN_B4);    //zero en la salida, led encendido
	}while(input(PIN_B7));
	ap=0;  // la proxima pulsacion se va a apaga
}

void apaga(){
	do{  // Hasta que pulsemos RB7
		delay_ms(100); // rebote
		output_high(PIN_B4);    //Uno en la salida, led apagado
	}while(input(PIN_B7));
	ap=1;  //la proxima pulsacion se va a enciende
}

//Principal, deveria encender y apagar un led en RB4, con un pulsador en RB7
//Elpulsador cuando entra envia +5V al pin 13 (RB7)
//el LED esta con el anodo al + y el catodo al pin 10 (RB4) del 16F84A

void main(){
	set_tris_B(0b10001111);    // RB0,1,2,3 y 7 entradas RB4,5 y 6 salidas
	output_high(PIN_B4);       // zero la salida, led apagado

	while(true){
		if(input(PIN_B7)){
			if(ap==1)
				enciende();
			else
				apaga();
		}
	}
}

saludos,

Mario

Título: Re: Microcursillo en C
Publicado por: Bigdogo en 28 de Abril de 2006, 19:55:07

Muchisimas gracias Mario y perdona por no haver contestado anteriormente, pero estava fuera de mi ciudad.

Tu código funciona perfectamente, y si me permites una pregunta, en el código:

void enciende(){
   do{ // Hasta que pulsemos RB7
      delay_ms(100); //rebote
      output_low(PIN_B4); //zero en la salida, led encendido
   }while(input(PIN_B7));
   ap=0; // la proxima pulsacion se va a apaga
}

la linea while(input(PIN_B7)); significa "1 enquanto la entrada B7 sea igual a 1 ( boton sin pulsar)" ?

muchas gracias mas una vez,

Título: Re: Microcursillo en C
Publicado por: zimanka en 30 de Abril de 2006, 11:56:54

mi inquietud es acerca de como comunicar varios pic entre si siendo uno maestro y 3 esclavos y el maestro comunicarse serial con el pc si alguien me puede ayudar porfavor gracias

Título: Re: Microcursillo en C
Publicado por: Bigdogo en 03 de Mayo de 2006, 19:42:11

Hola a todos

Vuelvo con mas dudas...
Suponer que la funcion beep, emite un pitido en un altavoz.
Suponer que tengo un pulsador en RB7.
porque cuando ejecuto el siguinte codigo solo escucho un beep despues de pulsar el pulsador? Yo creia que durante la ejecucion del programa, siempre escucharia un beep, independiente si pulso o no el pulsador!

void main()
{
set_tris_B(0b10001111); // RB0,1,2,3 y 7 entradas RB4,5 y 6 salidas

while(true)
{
beep();
if(input(PIN_B7)){ //si pulsamos switch en RB7
hace_algo();
}
}

esto nó es un loop infinito?

Título: Re: Microcursillo en C
Publicado por: LabPIC en 03 de Mayo de 2006, 19:50:25

Hola :mrgreen:

He programado en builder C++, pero tiene algo de tiempo que no lo hago y me gustaría retomarlo, quisiera que me recomendaran algun soft para programar en C que pueda bajar de la red, pero para principiantes .

Saludos :-)

Título: Re: Microcursillo en C
Publicado por: Nocturno en 04 de Mayo de 2006, 02:14:05

Cita de: Bigdogo en 03 de Mayo de 2006, 19:42:11

Hola a todos

Vuelvo con mas dudas...
Suponer que la funcion beep, emite un pitido en un altavoz.
Suponer que tengo un pulsador en RB7.
porque cuando ejecuto el siguinte codigo solo escucho un beep despues de pulsar el pulsador? Yo creia que durante la ejecucion del programa, siempre escucharia un beep, independiente si pulso o no el pulsador!

void main()
{
set_tris_B(0b10001111); // RB0,1,2,3 y 7 entradas RB4,5 y 6 salidas

while(true)
{
beep();
if(input(PIN_B7)){ //si pulsamos switch en RB7
hace_algo();
}
}

esto nó es un loop infinito?

Teóricamente sí es un bucle infinito, y debería estar haciendo beep continuamente, salvo por dos circunstancias:
- no sabemos qué pasa en hace_algo(). Puede que el control del programa nunca retorne desde esa función.
- falta una llave de cierre, ¿seguro que te ha compilado bien ese programa?

LabPIC, si te refieres a un C para PC, deberías preguntarlo en el subforo de C++, seguro que allí encuentras respuesta rápida. Si te refieres a un C para microcontroladores PIC, la mayoría usamos CCS. Puedes descargar una demo de 30 días desde aquí:
http://www.ccsinfo.com/content.php?page=compdemo

Título: Re: Microcursillo en C
Publicado por: erkys en 04 de Mayo de 2006, 02:38:24

:shock: Por favor me podrias explicar para que son cada uno de los siguientes programas; cuales son sus limitaciones y uso; etc
PCM
PCWH
PCW
Demo Pic C Compiler-PCW

Existe una versiones demo de los anteriores y cuales son sus limitaciones de estos demos;

:-) Para una persona que esta comenzando a programar los PIC desde cero; cual demo de los cuatro programas listados ; me recomienda (tengo PIC: 112f683; 16f628A; 16f873A,16f877A); veo muy buenos los ejemplos del Microcursillo en C. y quisiera comenzar a constuir algunos y practicar los publicados aca en el Microcursillo en C

Título: Re: Microcursillo en C
Publicado por: LabPIC en 04 de Mayo de 2006, 11:59:24

Hola a todos :mrgreen:

Gracias Nocturno por el comentario, me refería a un C para PICs, descargare el CCS versión Demo e informare mis avances :D

Saludos

Título: Re: Microcursillo en C
Publicado por: Bigdogo en 04 de Mayo de 2006, 19:03:32

Gracias Nocturno, aqui te pongo el codigo para que eches una ojeada:

#include <16F84A.h>
#use delay(clock=4000000)
#use fast_io(B)
#fuses HS,NOWDT,NOPUT

//globales
int tono,vel,dado1,dado2,dado3,dado4,a=0,direccion=0;

//Rutinas

void beep(int tono,vel) // Para generar un sonido
{
int i,j;
for(i=0; i<=vel; i++) // vel = duracion del tono
{
for(j=0; j<=4; j++)
{
output_high(PIN_A0); // La distancia entre pulso y pulso viene determinada
delay_us(200*(6-tono)); // por el parámetro tono
output_low(PIN_A0);
delay_us(200*(6-tono));
}
}
}

void grava_default(){
   while(input(PIN_B7));
   {

      delay_ms(50); //rebote
      output_low(PIN_B4); //zero en la salida, led encendido
write_eeprom(direccion,1); //grava valores default
write_eeprom(direccion+1,2); //en la memoria
write_eeprom(direccion+2,3); //1,2,3,4
write_eeprom(direccion+3,4); //
}
}

void main()
{
   set_tris_B(0b10001111); // RB0,1,2,3 y 7 entradas RB4,5 y 6 salidas
   output_high(PIN_B4); // zero la salida, led apagado

   while(true){

beep(3,50);

      if(input(PIN_B7)){ //si pulsamos switch en RB7

grava_default(); //grava valores default en memoria

}
}
}

compilado perfectamente.

Título: Re: Microcursillo en C
Publicado por: Nocturno en 05 de Mayo de 2006, 01:46:48

No entiendo el objetivo del programa, aunque me parece entender que debería estar pitando continuamente y grabar unos valores (1,2,3 y 4) en la eeprom cuando se pulse una tecla.

En teoría debería hacerlo así, aunque veo que has definido el fuse HS para un oscilador de 4MHz.

Para ese clock el fuse correcto es XT.

No sé si será ese el error, pero podrías probar cambiándolo.

Título: Re: Microcursillo en C
Publicado por: Bigdogo en 05 de Mayo de 2006, 19:30:04

Gracias Nocturno por la observacion,

El objetivo del programa es apenas el aprendizaje del C para los PICS. Con este programa queria saber si los datos se gravavan en la memoria y el beep era para estar seguro que el programa seguiria en un loop constante independiente si pulso el boton o no, lo que parece que el programa no lo hace, pues lo he simulado en proteus y solo hace beep despues que pulso el boton, y no descubro el porque!
Cuanto a la parte de memoria, funciona bien.

Esto podria utilizar para, por ejemplo, parte de un proyeto para una cerradura electronica que no utilize un teclado y si pulsadores (botones).

He cambiado para XT y sigue lo mismo.

Como puedo hacer un loop infinito con la instruccion "FOR"

Título: Re: Microcursillo en C
Publicado por: Nocturno en 06 de Mayo de 2006, 03:48:19

Pues no tienes el problema en el bucle infinito, porque el while(TRUE) es perfectamente válido, pero si quieres probar con FOR podrías hacer:
for (i=0; i>=0; i++) { ... }

Título: Re: Microcursillo en C
Publicado por: vszener en 06 de Mayo de 2006, 07:41:10

Para usar el bucle for como infinito tambien vale de esta forma

Código: [Seleccionar]

               for( ; ; ){....}

Suerte!!! :wink:

Título: Re: Microcursillo en C
Publicado por: Bigdogo en 06 de Mayo de 2006, 09:43:47

Gracias Nocturno,
Gracias vszener,

Título: Re: Microcursillo en C
Publicado por: Bigdogo en 07 de Mayo de 2006, 15:04:45

Hola a todos,

Porque elsiguinte codigo solamente me grava el valor del puerto B en la posicion 0 de la memoria, y no en las posiciones 0,1,2 y 3 ? (en el puerto A (A4) tengo una confirmacion que los datos en el puerto B estan listos y correctos)

void lee_datos(){
int i,valor=0;

for(i=0;i<4 && input(pin_A4);i++) //solo ejecuta si pin A4=1
{

valor=port_b &0b00001111; //mascara para leer el valor deseado
write_eeprom(i,valor);
while (input(pin_A4)){ //espera que A4 cambie de estado (vuelva a 0)
}
}

}

Título: Re: Microcursillo en C
Publicado por: Bigdogo en 08 de Mayo de 2006, 14:28:16

Hola,
Ya he conseguido que funcione:

void grava_pass(){ //grava 4 digitos en la memoria
int valor=0,v=0;

while(v<4){

if(input(pin_A4) && v<4)
{

valor=port_b &0b00001111;
write_eeprom(v,valor);

while(input(pin_A4))
{
}
V++;
}

}
}

No lo se si existe una manera mas practica, pero esta funciona.

Título: Re: Microcursillo en C
Publicado por: JCAK en 11 de Junio de 2006, 01:29:43

HOLA ...

Soy novato en esto del lenguaje C he visto códigos donde la instrucción es como la siguiente:

TCCR0B = (1 << WGM02) | (0 << CS02) | (0 << CS01) | (1 << CS00);

Yo interpreto esto como lo siguiente:

TCCR0B.WGM02 = 1
TCCR0B.CS02 = 0
TCCR0B.CS01 = 0
TCCR0B.CS00 = 1

Pero mi duda se presenta porque "<<" por lo que leí significa un desplazamiento a la izquierda y "|" significa OR (no me refiero al OR logico)

Entonces me gustaría si alguien con más experiencia me puede aclarar un poquito.

gracias

Título: Re: Microcursillo en C
Publicado por: dayan en 11 de Junio de 2006, 02:22:59

hey querido amigo quiero saber como hago para poder ver los cursos de programacion que ofreces en esta web, no se donde le tengo que dar click para poder leer el documento...te agradezco si me dices como hacerlo...ok?
tks

Título: Re: Microcursillo en C
Publicado por: ChOrChE en 19 de Junio de 2006, 11:44:44

hola, yo si que soy un novato en comparacion con todos vosotros!!!
Estoy intentando hacer cosillas con el 12c508a, por empezar con algo facil.
Veo que declarais los puertos a o b como entradas y salidas.... pero en el 12c508 solo existe un puerto y se configuran sus entradas y salidas.
Si quisiera que se ejecutara el codigo dependiendo del estado de un solo pin, seria algo asi?

if ( input(PIN_A0) )
{
// Esto se ejecuta si A0 está a 1
}
Espero aprender de vosotros, me esta gustando.

Título: Re: Microcursillo en C
Publicado por: Nocturno en 19 de Junio de 2006, 14:48:57

Sí, eso que has escrito es correcto.
Es más, por defecto en CCS no tienes porqué definir los TRIS y, si utilizas la función "input()" el pin seleccionado se configurará automáticamente como entrada.
Esto es así salvo que declares #use fast_io, en cuyo caso el compilador te deja a ti la gestión de los TRIS.

Título: Re: Microcursillo en C
Publicado por: ChOrChE en 19 de Junio de 2006, 15:01:27

Hola a todos. Siempre he programado en ensamblador y de c tengo poca idea.
me gustaria hacer pruebas con el 12c508a y variar las salidas dependiendo de las entradas. Y que ademas que el codigo se ejecute dependiendo del estado de GP0.

BIT ENABLE SALIDAS ENTRADAS
GP0(IN) GP1(OUT) GP2(OUT) GP3(IN) GP4(IN) GP5(IN)
0 NO SE EJECUTACODIGO HASTA QUE GP0=1
1 0 0 0 0 0
1 0 1 0 0 1
1 1 1 0 1 0
1 0 1 0 1 1
1 1 0 1 0 0
1 0 0 1 0 1
1 1 0 1 1 0
1 0 0 1 1 1

He estado haciendo algo y no se si es una aberracion.

#LIST p=12c508, r=HEX;
#INCLUDE <p12C508.inc>;
#define __CONFIG _MCLRE_OFF & _CP_OFF & _WDT_OFF & _IntRC_OSC;
#define GP0 pin_a0 ;

void main()
{

// Descripcion de variables
boolean GP0;
GP0= input(GP0);// de otra manera input_pin_port_a( 0 )
GP1= output_pin_port_a( 1 );
GP2= output_pin_port_a( 2 );
GP3= input_pin_port_a( 3 );
GP4= input_pin_port_a( 4 );
GP5= input_pin_port_a( 5 );

// Se ejecuta si pin_a0=GP0 esta a 1

while( GP0 ){ //podria ser como while( input(PIN_A0) )

if (GP3=0 &GP4=0 & GP5=0) {
GP1=0;
GP2=0;

}else if (GP3=0 & GP4=0 & GP5=1){
GP1=0;
GP2=1;

}else if (GP3=0 & GP4=1 & GP5=0){
GP1=1;
GP2=1;

}else if (GP3=0 & GP4=1 & GP5=1){
GP1=0;
GP2=1;

}else if (GP3=1 & GP4=0 & GP5=0){
GP1=1;
GP2=0;

}else if (GP3=1 & GP4=0 & GP5=1){
GP1=0;
GP2=0;

}else if (GP3=1 & GP4=1 & GP5=0){
GP1=1;
GP2=0;

}else if (GP3=1 & GP4=1 & GP5=1){
GP1=1;
GP2=1;

}
}

Creo que se corresponde a la tabla pero si alguien me corrigiera no me vendria mal. GRACIAS!!

Título: Re: Microcursillo en C
Publicado por: Nocturno en 19 de Junio de 2006, 15:12:16

Un comentario sin entrar en revisar a fondo. En C si pones "=" estás asignando un valor, aunque lo hagas dentro de un "if". Por tanto, para comprobación de condiciones lógicas, lo que debes usar es "=="

Por otra parte, el símbolo "&" es una operación a nivel de bits. Igualmente, para hacer AND dentro de un "if", tendrás que usar el operador "&&".

Título: Re: Microcursillo en C
Publicado por: ChOrChE en 19 de Junio de 2006, 16:14:51

Gracias. No habia caido en eso. Lo que mas me preocupaba era si habia definido bien las variables,ya que lo que quiero es que sean pin configurados, no configurar un puerto entero como entrada -salida.
Supongo que seran de tipo booleano aunque no esten definidos como tal en GP1= output_pin_port_a( 1 );
o hay que definirlos como
#define GP0 pin_a0 ;
void main()
{

// Descripcion de variables
boolean GP0;
GP0= input(GP0);//

Título: Re: Microcursillo en C
Publicado por: Helena en 01 de Julio de 2006, 11:13:06

Hola Mario 2004,

Tu codigo funciona muy bien, quiero hacer lo mismo pero con 4 pulsadores desde rb0 hasta rb3 y 4 salidas desde rb4 hasta rb7 como harìa para hacerlo funcionar?.

Muchas gracias

Besos

Helena :g)

Cita de: Mario_2004 en 23 de Abril de 2006, 20:20:07

Hola Jose, prueba con este código:

Código: [Seleccionar]
#include <16F84A.h> #use delay(clock=4000000) #use fast_io(B) #fuses HS,NOWDT,NOPUT //globales int ap=1; //Rutinas void enciende(){ do{ // Hasta que pulsemos RB7 delay_ms(100); //rebote output_low(PIN_B4); //zero en la salida, led encendido }while(input(PIN_B7)); ap=0; // la proxima pulsacion se va a apaga } void apaga(){ do{ // Hasta que pulsemos RB7 delay_ms(100); // rebote output_high(PIN_B4); //Uno en la salida, led apagado }while(input(PIN_B7)); ap=1; //la proxima pulsacion se va a enciende } //Principal, deveria encender y apagar un led en RB4, con un pulsador en RB7 //Elpulsador cuando entra envia +5V al pin 13 (RB7) //el LED esta con el anodo al + y el catodo al pin 10 (RB4) del 16F84A void main(){ set_tris_B(0b10001111); // RB0,1,2,3 y 7 entradas RB4,5 y 6 salidas output_high(PIN_B4); // zero la salida, led apagado while(true){ if(input(PIN_B7)){ if(ap==1) enciende(); else apaga(); } } }saludos,

Mario

Título: Re: Microcursillo en C
Publicado por: Helena en 01 de Julio de 2006, 11:15:34

Cita de: Mario_2004 en 23 de Abril de 2006, 20:20:07

Hola Jose, prueba con este código:

Código: [Seleccionar]
#include <16F84A.h> #use delay(clock=4000000) #use fast_io(B) #fuses HS,NOWDT,NOPUT //globales int ap=1; //Rutinas void enciende(){ do{ // Hasta que pulsemos RB7 delay_ms(100); //rebote output_low(PIN_B4); //zero en la salida, led encendido }while(input(PIN_B7)); ap=0; // la proxima pulsacion se va a apaga } void apaga(){ do{ // Hasta que pulsemos RB7 delay_ms(100); // rebote output_high(PIN_B4); //Uno en la salida, led apagado }while(input(PIN_B7)); ap=1; //la proxima pulsacion se va a enciende } //Principal, deveria encender y apagar un led en RB4, con un pulsador en RB7 //Elpulsador cuando entra envia +5V al pin 13 (RB7) //el LED esta con el anodo al + y el catodo al pin 10 (RB4) del 16F84A void main(){ set_tris_B(0b10001111); // RB0,1,2,3 y 7 entradas RB4,5 y 6 salidas output_high(PIN_B4); // zero la salida, led apagado while(true){ if(input(PIN_B7)){ if(ap==1) enciende(); else apaga(); } } }saludos,

Mario

Título: Re: Microcursillo en C
Publicado por: tsu_daniel en 05 de Julio de 2006, 17:40:07

hola a todos y saludos fde venezuela. yo quisiera pedirles el favor de que me ayuden a aprender a programar pic en c, se programar en ensamblador pero ya quiero aprender en c, ya que dicen que ya el ensanblador paso de moda y en c es mas facil. nose nada de lenguaje asi que sera un poco dificil aprender, hasta luego y espero la ayuda de ustedes

Título: Re: Microcursillo en C
Publicado por: vszener en 06 de Julio de 2006, 08:59:54

Buenas!!!! y bienbenido al maravilloso mundo del C!!!jeje, una matizacion el ensamblador nunca pasara de moda, siempre debe estar presente para ciertas aplicaciones(y es una buena herramienta para conocer en profundidad al microcontrolador), eso si, el C te dara mayor flexibidad al escribir codigos, poco codigo y tal, ¿para empezar? pues este mismo hilo, el cual trata del microcursillo conjuntamente con los ejemplitos en C y muchas ganas de aprender!

Animo y suerte!!! :wink:

Título: Re: Microcursillo en C
Publicado por: FJPPitta en 19 de Julio de 2006, 04:39:29

Saludos, estoy comenzando con esto de los PICs y estoy tratando de usar el 18F2550 para realizar mi proyecto, mi duda es:

existe alguna manera de hacer en C un temporizador que corra mientras el micro realiza otra funcion?

Lo que intento es hacer es una especie de frecuencimetro, tengo una señal de onda cuadrada de frecuencia variable y un ciclo de trabajo del 50% la cual entrara a un pin de micro y deseo conocer la frecuencia cuando lo solicite.

La frecuencia varia entre 10 KHz y 600 KHz.

Aprovechando, que es mas sencillo y eficaz para medir esa frecuencia, hacer un conteo de pulsos en cierta unidad de tiempo o contar el tiempo que tarda en presentarse cierto numero de pulsos.

EDIT: ya localize un hilo acerca de como medir la frecuencia y ya lo estoy leyendo, solo me gustará saber si es posible medir esa frecuencia de 10 KHz y 600 KHz y lo ultimo acerca de que metodo es mas recomendable para medir frecuencia.

Título: Re: Microcursillo en C
Publicado por: microfull en 16 de Agosto de 2006, 23:26:42

Bueno soy nuevo en esto del C quiero aprender se un poco de pic basic pro quiero saber cual es mejor cual genera codigo mas puro porque ya he tenido problemas con pic basic pro

quiero aprender me apunto en el minicurso de c

Título: Re: Microcursillo en C
Publicado por: Nocturno en 17 de Agosto de 2006, 01:41:21

Bienvenido, Maser.

Creo que podría ser un buen ejercicio para empezar ese que propones; hacer el programa con Basic y con C y comparar qué código está más optimizado. Podrías empezar por encender un led, por ejemplo.

Título: Re: Microcursillo en C
Publicado por: BrunoF en 17 de Agosto de 2006, 04:28:28

Hola.
Como me interesa esto de la optimización, he realizado el análisis de hacer parpadear un led en ambos compiladores.Y en assembler, por supuesto.
En PBP: Usando el ejemplo de LordLafebre(Ejemplos en PBP y PROTEUS (http://www.todopic.com.ar/foros/index.php?topic=3613.msg30302#msg30302)) : 56 instrucciones asm
En CCS: Usando el ejemplo de vszener(Ejemplitos en C para 16F648A (http://www.todopic.com.ar/foros/index.php?topic=4530.msg38848#msg38848)): 51 instrucciones asm.
El mísmo programa hecho por mi en assembler: 24 instrucciones.

Aclaraciones:
1)Elegí entre las 4 opciones que puso LordLafebre la que menor cantidad de lineas generó.
2)Convertí el programa de vszener para el pic 16F84A y a los delay los cambié a 1 segundo.

Programas desensambladores utilizados:
PIC-Disasm
IC-PROG.
.

Saludos.

Título: Re: Microcursillo en C
Publicado por: RedPic en 17 de Agosto de 2006, 05:17:20

Bruno:

Pásame el ejemplo en C de vszener tal como tu lo has compilado para darle un vistazo ... y después te digo algo.

Título: Re: Microcursillo en C
Publicado por: BrunoF en 17 de Agosto de 2006, 14:49:56

Hola RedPic.

Código: C

////////////////////////////////////////////////////////////////////////////////////
//   VsZeNeR"05      
//             6/Agosto/05
//
//Programa:   Parpadeo de un led cada 0.5s 
//Version:   0.0
//
//Dispositivo: PIC 16F648A      Compilador:    CCS vs3.227
//Entorno IDE: MPLAB IDE v7.20   Simulador:    Proteus 6.7sp3
//
//Notas: Parpadeo de un led cada 0.5s por el pin RB0 del puerto B
//////////////////////////////////////////////////////////////////////////////////
 
#include <16f84a.h>         //pic a utilizar          
#fuses XT,NOWDT,NOPROTECT,PUT      //ordenes para el programador 
#use delay (clock=4000000)         //Fosc=4Mhz
#use fast_io(b)
 
///PROGRAMA
void main(void)
{
   set_tris_b(0xFE);   //portb como salida(RB0,las demas desactivadas)
   disable_interrupts(GLOBAL);   //todas las interrupciones desactivadas
   
   do{   
      output_low(PIN_B0);          //led off
      delay_ms(1000);            
      output_high(PIN_B0);        //led on
      delay_ms(1000);
   }while(TRUE);                //bucle infinito
}

Probablemente sin el fast_io y sin el disable_interrupts(global) se ahorren unas lineas.

Saludos.

Título: Re: Microcursillo en C
Publicado por: RedPic en 17 de Agosto de 2006, 15:05:36

Ya está Bruno. Ya he visto lo que quería ver.

Precisamente el fast_io es lo que ya ahorra algunas líneas. Si le quitas el fast_io debe subir el numero de líneas generadas por el CCS ya que en ausencia de fast_io el compilador pone automáticamente un tris delente de cada instrucción de entrada o salida por un pin.

Es una forma de asegurarse de que el tris es el que debe ante una salida o una entrada. Al usar el fast_io todo el asunto de los tris queda en manos del programador y el CCS se desentiende, por eso genera menos lineas en asm.

Título: Re: Microcursillo en C
Publicado por: microfull en 18 de Agosto de 2006, 00:21:41

Bueno yo creia que podiamos empezar la verdad tengo el manual de ccs de frino y ya lo he leido un poco pero quiero empezar a programar la idea es que cuando escriban un codigo las personas que saben mas de esto traten de explicar y no hacer otras cosas ya que los novatos se confunden cuando tratan de seguir un proseso y luego saltan a discutir otra cosa.
Bueno voy a empezar por hacer un programa por dia veamos cuanto demoro en aprender ccs hagamos un ejemplo por dia pero bien explicado.

Título: Re: Microcursillo en C
Publicado por: Nocturno en 18 de Agosto de 2006, 01:17:28

Si te quieres subir al tren tendrás que empezar a correr porque está en marcha. Sacaremos la mano por la ventanilla para ayudarte, pero no puedes pedir que el tren pare para que te subas, y mucho menos exigirlo.

Además, lo tuyo es curioso. Si miras en el foro, no sólo encontrarás el tren parado y esperándote, sino encima con alfombra roja, sombrilla para el sol y cubata para el camino. No tienes más que empezar el Microcursillo por el post nº 1, o echar un vistazo a los Ejemplitos para 16F648A de vszener o los Ejemplitos para 16F876 de RedPic, que son la punta de lanza de miles de posts con ayuda a principiantes.

¿Que no están bien explicados?, entonces es que no sabes leer.

Título: Re: Microcursillo en C
Publicado por: vszener en 18 de Agosto de 2006, 16:51:18

Muchas lineas de codigo se consumen al configurar los fuses.....es cuestion de compilarlo con la nueva versión (o la más actual) haber si se mejora.

Suerte!!! :wink:

Título: Re: Microcursillo en C
Publicado por: microfull en 19 de Agosto de 2006, 18:00:19

Amigo nocturno yo no desia de empezar de nuevo sino que cuando detallaramos los dos codigos el PBP y CCS no saltaramos a otros temas sino observar bien y explicar la diferencias en codigo y en esto de la optimizacion al igual de que cosas no se pueden hacer en PBP o que salen demacido largas y que poden problemas, que con CCS si se pueden hacer y mas faciles, es como dar una opcion de porque pasarse a CCS esto le sirve tanto al que esta empezando como al que va montado en el tren como dice usted de todos modos recuerde que ese es el titulo del foro microcursillo en c, disculpe las molestias. Creo que las persanas que saben un poco mas estan para ayudar ese es el objetivo recuerde que hay personas que quieren entrar a este medio. Gracias

Título: Re: Microcursillo en C
Publicado por: microfull en 19 de Agosto de 2006, 18:01:54

Pero eso no importa ya lo importante es montarme en el tren asi que les pido que todos saquen las manos a ver de cual me agarro hare como james Bond en sus esenas de trenes.
Gracias
Pilas manos a la obra

Título: Re: Microcursillo en C
Publicado por: vszener en 20 de Agosto de 2006, 08:12:10

Para 'montarte en el tren' es fácil, ¿quieres encender y apagar un led? ¿quieres manejar perifericos internos del pic? ¿quieres comunicarte via serial con el PC? ¿quieres.....?

Aquí lo encontrarás:
Ejemplitos en C para 16F648A (http://www.todopic.com.ar/foros/index.php?topic=4530.0)
Ejemplitos 16F876A: Indice de contenidos. (http://www.todopic.com.ar/foros/index.php?topic=4531.0)
Microcursillo en C (http://www.todopic.com.ar/foros/index.php?topic=4533.0)

Y si entras en los respectivos post, verás que hay manuales y utilidades para programar.

Suerte!!! :wink:

Título: Re: Microcursillo en C
Publicado por: javier_b en 12 de Septiembre de 2006, 15:17:31

Hola a todos, alguien podria mostrar un ejemplo con las interrupciones por favor, la verdad he visto ejemplos de todo, pero no he visto como manejar las interrupciones, gracias a quien pueda mostrar algun ejemplo

Título: Re: Microcursillo en C
Publicado por: Nocturno en 13 de Septiembre de 2006, 02:51:01

Pues si miras en el hilo Ejemplitos de vszener, encontrarás un montón de ejemplos.

Por ejemplo aquí:
http://www.todopic.com.ar/foros/index.php?topic=4530.30

Título: Re: Microcursillo en C
Publicado por: marco_recargado en 03 de Octubre de 2006, 21:14:05

HOLA EL MICROCURSILLO ESTA EXCELENTE, UN PAR DE HORAS LEYENDOLO Y APLICANDOLO Y BUENO AL MENOS YA ENTENDI COMO HACER PARPADEAR UNOS LEDS.
EL MOTIVO DE MI MENSAJE ES QUE HE LEIDO QUE EN ALGUNOS PROGRAMAS EL PROTEUS NO FUNCIONA MUY BIEN, EN ESE CASO YO LES ACONSEJARIA EL PIC SIMULATOR EL CUAL NUNCA ME HA FALLADO EN ESE SENTIDO ES MAS FIDEDIGNO QUE EL PROTEUS.
DISCULPARAN MI NOVATES PUES TENGO POCO SIMULANDO CON EL PROTEUS (Y CREO QUE SI LLEGO A ENCONTRAR MUCHAS FALLAS AL PROTEUS ES POR IGNORANCIA MUCHAS VECESO TAL VEZ TODAS).
BUENO DE TODOS MODOS YO ACONSEJO EN ESTOS MOMENTOS EL PIC SIMULATOR.
Y GRACIAS A TODOS POR SUS APORTACIONES REALMENTE ESTOY APRENDIENDO (Y VEAN QUE SOY UN CABEZA DURA) :D :shock:

Título: Re: Microcursillo en C
Publicado por: Nocturno en 04 de Octubre de 2006, 01:41:22

Hola Marco. Efectivamente yo soy crítico con el Proteus, pero hay que reconocer que supera con creces al PIC Simultator porque no sólo simula al PIC, sino a toda la electrónica que le acompañe en el circuito.
De hecho, el Proteus no suele fallar cuando simula PICs, sino con la electrónica analógica.

Título: Re: Microcursillo en C
Publicado por: lord-neo en 19 de Octubre de 2006, 18:55:29

pocher ..hola mira me llamo christofer soy un afisionado de la electronica y me a apacionado el tema de los pic,
,si puedes dar el mismo ejemplo por favor para un 16f628 y si me lo puedes explicar para comensar a practicar gracias
:-/ :-/ :-/

Título: Re: Microcursillo en C
Publicado por: vszener en 20 de Octubre de 2006, 11:57:13

¿Qué ejemplo necesitas?

Suerte!!! ;)

Título: Re: Microcursillo en C
Publicado por: Fer_TACA en 24 de Diciembre de 2006, 15:52:08

Hola amigos:
Después de haber superado el ASM, empece con C. Así que me decidi por leer todo este hilo, libro del CCS y cuanta informacion caia en mis manos, pase a realizar algunos ejemplos: los tipicos encender un led, leer y escribir un puerto....
Ahora estoy inmerso en practicar con las sentencias switch y case y la verdad estoy empanado.
Lo que hago es pretender leer un puerto continuamente, para despues teestear unos determinados bits de ese puerto y en funcion de su estado hacer cosas distintas, pero no me funciona.
Abajo les dejo la funcion main que seguro que los sabios podran echarme una manita. No pongo todo el codigo, pues la inicializacion del micro (877) y la funcion parpadear funcionan (las probé con otors ejemplos), tambien tengo declarada la variable estado como "unsigned int estado", pero no consigo que funcione el main.

void main()
{
disable_interrupts(GLOBAL); // Desactivamos todas las interrupc
setup_adc_ports(NO_ANALOGS); // Puerto A configurado como digital
set_tris_A(0xFF); // Puerto_A como salida
set_tris_b(0xFF); // Puerto_B como entrada
set_tris_d(0x00); // Puerto_D como salida
set_tris_e(0x00); // Puerto_E como salida
output_d(0x00); // Se borra el puerto d
output_e(0x00); // Se borra el puerto e

while(input_b())
estado = portb;
switch (input_b())

{
case (0):

if (bit_test(estado,1))
portd=0xFF;
else
Parpadeo();
break;

case (1):

if (bit_test(estado,2))

{
portd=0xAA;
break;
}
}
}

Seguro que me echan una manita.
De todas maneras aprovecho para felicitar las fiestas a todos los amigos del Foro y desearles un feliz año.

Fermin

Título: Re: Microcursillo en C
Publicado por: vszener en 25 de Diciembre de 2006, 10:53:15

En el case quitale los paréntesis, déjalo así:

Código: C

void main()
{
   disable_interrupts(GLOBAL);                                             // Desactivamos todas las interrupc
   setup_adc_ports(NO_ANALOGS);                                            // Puerto A configurado como digital
   set_tris_A(0xFF);                                                       // Puerto_A como salida
   set_tris_b(0xFF);                                                         // Puerto_B como entrada
   set_tris_d(0x00);                                                       // Puerto_D como salida
   set_tris_e(0x00);                                                       // Puerto_E como salida
   output_d(0x00);                                                         // Se borra el puerto d
   output_e(0x00);                                                       // Se borra el puerto e                                                             
 
      while(input_b())
               estado = portb;
               switch (input_b())
 
                     {
                      case 0:
                       
                        if (bit_test(estado,1))
                          portd=0xFF;
                       else
                          Parpadeo();
                          break;
 
                      case 1:
 
                        if (bit_test(estado,2))
 
                        {
                           portd=0xAA;
                           break;
                        }
                     }
}

Suerte!!! ;)

Título: Re: Microcursillo en C
Publicado por: Fer_TACA en 25 de Diciembre de 2006, 14:51:36

Gracias por responder vszener, la verdad que ya habia probado de esa forma asi como cambaindo el nombre de la variable "estado" por otra como entrada por ejemplo.
Cuando lo simulo con proteus paso a paso la verdad esque se queda siempre en estado=portb y de ahí no pasa. :x
Por otra parte he revisado ejemplos que hay posteados en el foro y pienso que deberia funcionar pero :(
La variable está definida como = unsigned int estado.
¿que puede estar pasando'
Gracias?

Título: Re: Microcursillo en C
Publicado por: vszener en 26 de Diciembre de 2006, 09:48:44

Supongo que la instrucción portb está bien definida, pero vamos, puedes usar la que CCS trae implementada (y aparte usas):

Código: C

void main()
{
   byte estado;                                            
 
   disable_interrupts(GLOBAL);                                             // Desactivamos todas las interrupc
   setup_adc_ports(NO_ANALOGS);                                            // Puerto A configurado como digital
   set_tris_A(0xFF);                                                       // Puerto_A como salida
   set_tris_b(0xFF);                                                         // Puerto_B como entrada
   set_tris_d(0x00);                                                       // Puerto_D como salida
   set_tris_e(0x00);                                                       // Puerto_E como salida
   output_d(0x00);                                                         // Se borra el puerto d
   output_e(0x00);                                                       // Se borra el puerto e                                                             
 
      while(input_b())
               estado = input_b();
               switch (input_b())
 
                     {
                      case 0:
                       
                        if (bit_test(estado,1))
                          portd=0xFF;
                       else
                          Parpadeo();
                          break;
 
                      case 1:
 
                        if (bit_test(estado,2))
 
                        {
                           portd=0xAA;
                           break;
                        }
                     }
}

Título: Re: Microcursillo en C
Publicado por: Fer_TACA en 26 de Diciembre de 2006, 16:22:24

Gracias por reponder nuevamente vszener, pero todavia no me funciona, lo que me indicas tambien lo probe y nada. Adjunto el programa completo por si hay algo mal que se me haya escapado. He eliminado la funcion de parpadeo dentro del main. En fin :x :x

#include <16F877.h> // Tipo de microcontrolador utilizado
#fuses XT,NOWDT,NOPUT,NOLVP,NOBROWNOUT,NOWRT // Cofiguración de fusibles
#use delay(clock=4000000) // Frecuencia Fosc=4Mhz

#byte porta = 0x05 // Direccion del puerto A
#byte portb = 0x06 // Direccion del puerto B
#byte portc = 0x07 // Direccion del puerto C
#byte portd = 0x08 // Direccion del puerto D
#byte porte = 0x09 // Direccion del puerto E

#use fast_io(a)
#use fast_io(b)
#use fast_io(c)
#use fast_io(d)
#use fast_io(e)

VOID Parpadeo(void); // Rutina de parpadeo de puerta E
VOID Parpadeo(void)
{
output_high (PIN_E0); // Pin E0 = 1
delay_ms (1000); // delay 1 segundo.
output_low (PIN_E0); // Pin E0 = 0
delay_ms (1000); // delay 1 segundo.
output_high (PIN_E1); // Pin E1 = 1
delay_ms (1000); // delay 1 segundo.
output_low (PIN_E1); // Pin E1 = 0
delay_ms (1000); // delay 1 segundo.
output_high (PIN_E2); // Pin E2 = 1
delay_ms (1000); // delay 1 segundo.
output_low (PIN_E2); // Pin E2 = 0
}

VOID main()
{
byte estado;
disable_INTERRUPTS (GLOBAL); // Desactivamos todas las interrupciones
setup_adc_ports (NO_ANALOGS); // Puerto A configurado como digital
set_tris_a (0xFF); // Puerto_A como entrada
set_tris_b (0xFF); // Puerto_B como entrada
set_tris_d (0x00); // Puerto_D como salida
set_tris_e (0x00); // Puerto_E como salida
output_d (0x00); // Se borra el puerto d
output_e (0x00); // Se borra el puerto e

WHILE (input_b ())
estado = input_b();

SWITCH (input_b())
{
CASE 0:
IF (bit_test (estado, 1))

portd = 0xFF;

BREAK;

CASE 1:
IF (bit_test (estado, 2))

portd = 0xAA;

BREAK;

}
}
Adjunto una imagen de la simulacion en proteus, paso a paso. Cuando llega a la sentencia: estado=input_b(), se queda parado hasta el fin de los siglos y nada. Entiendo que una vez leido el puerto B como esta a 1 el pin b1, dberia entrar en el primer case pero :x :x
seguiré estrujandome los sexos.
Un saludo fermin

Título: Re: Microcursillo en C
Publicado por: vszener en 26 de Diciembre de 2006, 16:35:42

¿La entencia 'switch' está dentro del while? te lo digo porque según está escrito en tú programa no está dentro del while, otra cosa que puedes hacer,es especificar dentro de la sentencia while porner la condición.

Suerte!!! ;)

Título: Re: Microcursillo en C
Publicado por: Fer_TACA en 26 de Diciembre de 2006, 16:40:51

La sentencia Switch esta dentro del While es mas he copia la funcion como la has escrito y tampoco.

Título: Re: Microcursillo en C
Publicado por: vszener en 26 de Diciembre de 2006, 16:54:03

Y yome copie de la tuya, es lo que pasa cuando se hace copy & paste, mira a ver este:

Código: C

#include <16F877.h>                                                           // Tipo de microcontrolador utilizado
#fuses XT,NOWDT,NOPUT,NOLVP,NOBROWNOUT,NOWRT                                  // Cofiguración de fusibles
#use delay(clock=4000000)                                                     // Frecuencia  Fosc=4Mhz
 
#byte porta = 0x05                                                           // Direccion del puerto A
#byte portb = 0x06                                                           // Direccion del puerto B
#byte portc = 0x07                                                           // Direccion del puerto C
#byte portd = 0x08                                                           // Direccion del puerto D
#byte porte = 0x09                                                           // Direccion del puerto E
 
#use fast_io(a)
#use fast_io(b)
#use fast_io(c)
#use fast_io(d)
#use fast_io(e)
 
 
VOID Parpadeo(void);                                                          // Rutina de parpadeo de puerta E
VOID Parpadeo(void)
      {
   output_high (PIN_E0);                                                      // Pin E0 = 1
   delay_ms (1000);                                                           // delay 1 segundo.
   output_low (PIN_E0);                                                       // Pin E0 = 0
   delay_ms (1000);                                                           // delay 1 segundo.
   output_high (PIN_E1);                                                      // Pin E1 = 1
   delay_ms (1000);                                                           // delay 1 segundo.
   output_low (PIN_E1);                                                       // Pin E1 = 0
   delay_ms (1000);                                                           // delay 1 segundo.
   output_high (PIN_E2);                                                      // Pin E2 = 1
   delay_ms (1000);                                                           // delay 1 segundo.
   output_low (PIN_E2);                                                       // Pin E2 = 0
      }
 
VOID main()
{
   byte estado;
 
   set_tris_a (0xFF);                                                         // Puerto_A como entrada
   set_tris_b (0xFF);                                                         // Puerto_B como entrada
   set_tris_d (0x00);                                                         // Puerto_D como salida
   set_tris_e (0x00);                                                         // Puerto_E como salida
 
   setup_adc_ports (NO_ANALOGS);                                              // Puerto A configurado como digital
   disable_INTERRUPTS (GLOBAL);                                               // Desactivamos todas las interrupciones
 
   output_d (0x00);                                                           // Se borra el puerto d
   output_e (0x00);                                                           // Se borra el puerto e
 
   WHILE (TRUE)
{
      estado = portb;
 
   SWITCH (estado)
   {
      CASE 0b00000000:
           IF (bit_test (estado, 1))
           
               portd = 0xFF;
            
      BREAK;
 
      CASE 0b00000001:
           IF (bit_test (estado, 2))
             
               portd = 0xAA;
            
         BREAK;
 
   }
}
}

Prueba así, a ver que tal.

Suerte!!! ;)

Título: Re: Microcursillo en C
Publicado por: Fer_TACA en 26 de Diciembre de 2006, 17:06:58

Hola de nuevo algo parece que funciona, pero no del todo. Una pregunta:la sentencia Bit_test(estado,1) lo que realiza es que comprueba elbit uno de la variable estado y si es 1 entoces ejecuta portd=0xFF. ¿Es cierto? es que para que me haga portd=0xFF tengo que poner !bit_test(estado,1)
Sigo probando

Título: Re: Microcursillo en C
Publicado por: vszener en 26 de Diciembre de 2006, 17:11:19

Míralo en la help del compilador, de todas formas, ponlo todo directamente:

Código: C

if(bit_test (estado, 1)==1)
       portd = 0xFF;

Suerte!!! ;)

Título: Re: Microcursillo en C
Publicado por: Fer_TACA en 26 de Diciembre de 2006, 17:58:33

Hola Vszener: :-/ :-/ :-/ FUNCIONA :-/ :-/
Pongo el código y una pequeña explicacion de las conclusiones que he sacado y ya me direis si son correctas:

VOID main()
{
byte estado;

set_tris_a (0xFF); // Puerto_A como entrada
set_tris_b (0xFF); // Puerto_B como entrada
set_tris_d (0x00); // Puerto_D como salida
set_tris_e (0x00); // Puerto_E como salida

setup_adc_ports (NO_ANALOGS); // Puerto A configurado como digital
disable_INTERRUPTS (GLOBAL); // Desactivamos todas las interrupciones

output_d (0x00); // Se borra el puerto d
output_e (0x00); // Se borra el puerto e

WHILE (TRUE)
{
estado = portb;

SWITCH (estado)
{
CASE 0b00000001:
IF (!bit_test (estado, 1))
portd = 0xFF;
Parpadeo();
portd = 0x00;
delay_ms (1000);

BREAK;

CASE 0b00000010:
IF (!bit_test (estado, 2))
portd = 0xAA;
Parpadeo();
portd = 0x00;
delay_ms (1000);

BREAK;

}
}
}

Seguro que estoy equivocado con lo siguiente, ya me contareis:
1º No funcionaba por que faltaba "{" entre el while y el case. Se opuede ver al principio del primer código.
2º Al poner case 0, case 1..... al ser un byte no se ejecutaban los case por que el valor 0 es decimal y no se correspondia con su valor en binario del puerto b.
3º El puerto de entrada lo tengo de lconectado con cada pin una resistancia a masa y el correpondiente interruptor a +5V, pero para que funcionara tengo que poner if(!bit_test(estado,1).De esta forma al accioar el interruptor seria=como es distinto de 0 entonces pongo el puerto d=0xFF. Lo que no entiendo es como con if (bit_test(estado,1) al actuar el interruptor no ejecuta portd=0xFF pues la explicacion seria si el pin es 1 entonces portd=0xFF.

Bueno seguiré profundizando en esto del C.

Título: Re: Microcursillo en C
Publicado por: vszener en 26 de Diciembre de 2006, 18:43:53

Me alegro que funcione jeje a tus preguntas:
1. Al no estar todo el bucle cerrado entre corchetes, el pic hacia un reset continuo, no creo que fuese esa la razón, quizás es la declaración que tenias dentro del bucle while.

2. Te dejo como ejercicio que lo realices con el 0 y el 1, da igual cual pongas, ya que lo que especificamos es la base del número, pero no su cantidad 1 en base decimal, equivale a 00000001 en base binario. Aparte, como ejercicio también, sería bueno que hicieras tú programa con las funciones que trae consigo el compilador, no hace falta declarar ningún puerto para leerlo ni escribirlo, para leerlo usa la instrucción input_x(); donde la x indica la letra del puerto a leer.

3. Mira en la help del compilador, que resultado te dá la función bit_test.

Suerte!!! ;)

Título: Re: Microcursillo en C
Publicado por: Fer_TACA en 26 de Diciembre de 2006, 19:32:17

Pues eso es lo grave que si miro en el help del compilador la instruccion bit_test no me funciona como he descrito en el post anterior punto 3 y eso es lo que me confude.
Bueno mañana y com mas tiempo, reducire al maximo el programa y es esquema de proteus para probar solo la funcion bit_test.

Gracias por las indicaciones , aunque más adelante me saldran otras pegas.
Fermín

Título: Re: Microcursillo en C
Publicado por: vszener en 26 de Diciembre de 2006, 20:12:54

Mira a ver el pin de entrada, a ver como está definido, si activo en bajo o en alto.

Suerte!!! ;)

Título: Re: Microcursillo en C
Publicado por: Fer_TACA en 27 de Diciembre de 2006, 13:06:17

esto es lo que aparece en el Help de CCs para la funcion bit_test.

if( bit_test(x,3) || !bit_test (x,1) ){

//either bit 3 is 1 or bit 1 is 0

}

Entiendo que si tengo puesto en mi programa:IF (bit_test (estado,1)) y tengo unido a +5v el pin entonces se ejecutará la sentencia siguiente=portd = 0xFF;
Y si dejo a masa el pin entonces se sale del case dado que existe el break
Y es que me está funcionando justo al reves.
pero si doy la vuelta a la conexion del pin y de la sentencia, entonces es que ni me funciona. :x :x :x

Título: Re: Microcursillo en C
Publicado por: Fer_TACA en 27 de Diciembre de 2006, 13:27:17

Me respondo a mi mismo:
Resr un capu.....
Estaba testeando el bit 1 cuando en realidad tenia conectado el interruptor al bit 0 del puerto. Esto me pasa por ser un yogurin en esto de C. En fin vale la pena haber perdido 2 dias.
Gracias por ayudarme.
fermin

Título: Re: Microcursillo en C
Publicado por: vszener en 27 de Diciembre de 2006, 16:27:35

Jeje me alegro que te funcione!!! ahora solo falta que pruebes hacer el código con las instrucciones propias del CCS (no es difícil)

Suerte!!! ;)

Título: Re: Microcursillo en C
Publicado por: Fer_TACA en 27 de Diciembre de 2006, 16:58:38

VSZENER:
Solo por curiosidad a que funciones del CCs te refieres?
fermin

Título: Re: Microcursillo en C
Publicado por: vszener en 28 de Diciembre de 2006, 08:58:09

Me refiero a que no hace falta definir los puertos del pic, ya que para leer los puertos est´ña la instrucción input_x(); y para escribir en los mismos está la instrucción output_x(); donde x es la letra del puerto donde actuaremos. Aparte te puedes ahorrar la declaración de la variable estado.

Prueba este código, a ver si funciona:

Código: C

#include <16F877.h>                                                           // Tipo de microcontrolador utilizado
#fuses XT,NOWDT,NOPUT,NOLVP,NOBROWNOUT,NOWRT                                  // Cofiguración de fusibles
#use delay(clock=4000000)                                                     // Frecuencia  Fosc=4Mhz
 
#use fast_io(a)
#use fast_io(b)
#use fast_io(c)
#use fast_io(d)
#use fast_io(e)
 
 
VOID Parpadeo(void);                                                          // Rutina de parpadeo de puerta E
VOID Parpadeo(void)
      {
   output_high (PIN_E0);                                                      // Pin E0 = 1
   delay_ms (1000);                                                           // delay 1 segundo.
   output_low (PIN_E0);                                                       // Pin E0 = 0
   delay_ms (1000);                                                           // delay 1 segundo.
   output_high (PIN_E1);                                                      // Pin E1 = 1
   delay_ms (1000);                                                           // delay 1 segundo.
   output_low (PIN_E1);                                                       // Pin E1 = 0
   delay_ms (1000);                                                           // delay 1 segundo.
   output_high (PIN_E2);                                                      // Pin E2 = 1
   delay_ms (1000);                                                           // delay 1 segundo.
   output_low (PIN_E2);                                                       // Pin E2 = 0
      }
 
VOID main()
{
   set_tris_a (0xFF);                                                         // Puerto_A como entrada
   set_tris_b (0xFF);                                                         // Puerto_B como entrada
   set_tris_d (0x00);                                                         // Puerto_D como salida
   set_tris_e (0x00);                                                         // Puerto_E como salida
 
   setup_adc_ports (NO_ANALOGS);                                              // Puerto A configurado como digital
   disable_INTERRUPTS (GLOBAL);                                               // Desactivamos todas las interrupciones
 
   output_d (0x00);                                                           // Se borra el puerto d
   output_e (0x00);                                                           // Se borra el puerto e
 
   WHILE (TRUE)
{
 
   SWITCH (input_b())
   {
      CASE 1:
           IF (!bit_test (estado, 1))
               output_d(0xFF);
               Parpadeo();
               output_d(0x00);
               delay_ms (1000); 
 
                
      BREAK;
 
      case 2:
           if (!bit_test (estado, 2))
               output_d(0xAA);
               Parpadeo();
               output_d(0x00);
               delay_ms (1000); 
            
           break;
 
   }
}
}

El tema de definir regisros, pines e incluso puertos, es a gusto de cada programador (cada uno tenemos nuestro librillo), pero a veces es bueno conocer las funcionalidades del propio compilador, ya que en muchos códigos donde hay bastantes definiciones se hace tedioso leer para otros programadores.

Suerte!!! ;)

Título: Re: Microcursillo en C
Publicado por: Fer_TACA en 28 de Diciembre de 2006, 12:51:12

Hola vszener:
gracias por la ayuda que estás prestando. Creí que te referias a instrucciones especificas de CCS que no venian en su manual. Esas ya las conocia. El caso es que procedo del ASm y en su dia realizé un programa para el control de un grupo motocompresor y ahora que empezé con C pretendo hacerlo de nuevo en este lenguaje y aunque en principio estoy practicando con el 877, pretendo despues utilizar uno de la serie 18F y poder colocarle todo el tratamiento de averias y ordenes de marcha-paro, por comunicaciones ( a ser posible por RS485). pero voy despacito con el C.
El no haber utilizado al principio del post las instrucciones de CCS era por que el funcionamiento del programa pense que fuera "una maquina de estados". Asi segun el bit del puerto de entrada, así seria la accion a realizar, pero seguro que los maestros de C se les ocurre alguna otra forma de realizarlo. En fin es lo que tiene ser principiante.
El codigo último que pusiste si funciona, pero como vers mi código ya avanzó un poco más. Ahora trataré de reducir la rutina de parpadeo asi como manejar los temporizadores dado que los necesitaré para los casos siguientes. Ahí va el codigo qu elo adjunto para no hacer el post muy grande y si tienes ganas y tiempo me dices com lo ves.
Un saludo
Fermín

Título: Re: Microcursillo en C
Publicado por: Renatox_ en 02 de Enero de 2007, 21:05:37

Hola a todos los del grupo, yo programaba en full asembler hasta hace una semana, pero me comentaron que programar en C era mejor hasta que di en este microcursillo y decidí aprendérmelo, asi que me grabé las 28 páginas y en mi casa me puse a leer y prácticar, y en solo una semana aprendí lo que en asembler me tomó 6 meses. ´

El CCS hace maravillas con los pics y de ahora en adelante voy a programar en C, y aportar aquí lo que he aprendido y mis dudas también, nos vemos.

Título: Re: Microcursillo en C
Publicado por: Renatox_ en 02 de Enero de 2007, 21:27:03

Hola otra ves, por la página 5 de ese microcursillo TONIo publicó su código de ADC pero lo he reducido y me funciona pero tengo un problema en la parte final, cuando lo implementé en protoboard el pin B0 no basculaba solo se mantenía prendido, será porque no se puede chequear si un pin del puerto es uno o cero si se mantiene como salida..?

El programita, es este.

Título: Re: Microcursillo en C
Publicado por: Renatox_ en 02 de Enero de 2007, 21:32:39

Mejor lo pongo aquí:

#include <16F876.h>
#fuses XT,NOWDT,NOPROTECT,NOLVP
#use delay(clock=4000000)
#use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7,bits=8)
#use fast_io(B)
#device adc=10

const int escala = 1023; // Escala del conversor ADC (10 bits)
const float v_max = 4.9; // Voltaje máximo que entrega mi fuente

// Como se observa en la cabecera, los nombres de los parámetros no tienen por qué
//ser iguales que los de la llamada ( calcula_voltaje(valor,voltaje) ),pero sí deben
//estar en el mismo orden. "voltaje",al ser de entrada-salida,debe llevar el símbolo
//"&" delante
void calcula_voltaje(int val,float &voltaje)
{
// "escala" y "v_max" son parámetros globales,por eso son visibles dentro
// de esta rutina(y en todo el código).Si no lo fueran,al no estar declarados dentro
//de ella ni y al no ser parámetros de entrada ó entrada-salida como los de la cabecera,
//se produciría error al compilar
voltaje = (val*v_max)/escala;
}

void main()
{ int valor; //declaración de variables
float voltaje; //valor=(0 a 1023), voltaje=(0 a 4.9)volt.

set_tris_b(0x00); // Aquí declaro al PORTB como salida
setup_adc_ports(AN0);
setup_adc(ADC_CLOCK_INTERNAL);
setup_spi(FALSE);
setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
setup_timer_1(T1_DISABLED);
setup_timer_2(T2_DISABLED,0,1);

output_low(PIN_B0);
printf("Presione cualquier tecla para empezar la conversión ADC");
getc();

while (1)
{
set_adc_channel(0); // Seleccionamos el canal 0 (RA0)
valor = read_adc(); // Capturamos señal analógica que entra por el canal AN0
// Le mandamos el parámetro "valor" y nos devuelve "voltaje"
calcula_voltaje(valor,voltaje);
putc(voltaje);

//prende y apaga el pin B0

if ((PIN_B0)==1) //puedo hacer esto..? B0 está como salida
output_low(PIN_B0);
else
output_high(PIN_B0);

delay_ms(400);
}
}

Título: Re: Microcursillo en C
Publicado por: johnnybravo en 03 de Enero de 2007, 14:06:35

Saludos amigos de este microcursillo de c
bueno la verdad que yo soy nuevo en esto de la programacion en c, pero bueno estoy tratando de aprender de sus ejemplos y empesando a programar mis propias aplicasiones

tengo una duda... estuve leyendo las primeras notas d este curso.. hay unas notas de Nuestro amigo modulay.. que por cierto son muy explicativas.. pero algo que no entinedo ... por ejemplo en sus notas sobre las variables globales y localizadas .. mas especificamente en su codigo en la ultima linea
for(; :wink: {}
que significa esa linea... es acaso algun tipo bucle infinito como
while(true) {
puedo remplasarlo por este... esque saben.. cuando trato de compilar el codigo original, me bota un error en esa linea de codigo....

ojala puedan resolver mi duda... la verdad ya estoy un poco cabezon .. con esto.... gracias de antemano por su antencion..

Título: Re: Microcursillo en C
Publicado por: MGLSOFT en 03 de Enero de 2007, 18:45:47

Cita de: johnnybravo en 03 de Enero de 2007, 14:06:35

Saludos amigos de este microcursillo de c
bueno la verdad que yo soy nuevo en esto de la programacion en c, pero bueno estoy tratando de aprender de sus ejemplos y empesando a programar mis propias aplicasiones

tengo una duda... estuve leyendo las primeras notas d este curso.. hay unas notas de Nuestro amigo modulay.. que por cierto son muy explicativas.. pero algo que no entinedo ... por ejemplo en sus notas sobre las variables globales y localizadas .. mas especificamente en su codigo en la ultima linea
for(; :wink: {}
que significa esa linea... es acaso algun tipo bucle infinito como
while(true) {
puedo remplasarlo por este... esque saben.. cuando trato de compilar el codigo original, me bota un error en esa linea de codigo....

ojala puedan resolver mi duda... la verdad ya estoy un poco cabezon .. con esto.... gracias de antemano por su antencion..

Por un problema de no estar escrito dentro de un segmento CODE aparecen los smiles (carita guiño es un punto y coma y cierre de parentesis).
El codigo es este:

Código: [Seleccionar]

for(; ; ) {}

Y realmente es un bucle infinito similar al While(true){}

Suerte!!! :mrgreen: :mrgreen:

Título: Re: Microcursillo en C
Publicado por: Renatox_ en 03 de Enero de 2007, 19:18:12

Hola johnnybravo, las variables globales pueden ser vistas y utilizadas en todo el proprama, tanto para la función principal como las funciones auxiliares.

Por ejm si declaras la variable valor dentro del void main(), será vista y utilizada solo por la función principal, pero si la declaras fuera es vista por todas las funciones principales, auxiliares y subprogramas.

void main()
{ int32 data;

Y la otra forma:

int32 data; // variable global
void main()
{ //programa principal
}

Modulay utuliza el for de esa forma y funciona pero pienso que de esa forma no se debe usar, ya que para eso no ha sido hecho el for sino para bucles finitos, para un bucle infinito sería while (1) o while (true).

Alguién podría responderme mi pregunta, nos vemos.

Título: Re: Microcursillo en C
Publicado por: johnnybravo en 03 de Enero de 2007, 20:09:58

:shock: Si que es verdad :-/ gracias por responder amigos .. muchisimas gracias :D
me han quitado un peso de encima.. ya me estaba haciendo bolas con esa linea de comando..jajaja.. gracias..tansimple como eso...
pero a la vez muchas gacias por confirmar lo que yo estaba pensando tambien...

Título: Re: Microcursillo en C
Publicado por: Modulay en 03 de Enero de 2007, 20:42:02

Quizá no sea elegante pero no veo por qué no se debe usar.

Título: Re: Microcursillo en C
Publicado por: Nocturno en 04 de Enero de 2007, 00:37:15

Cita de: renatox_ en 03 de Enero de 2007, 19:18:12

Modulay utuliza el for de esa forma y funciona pero pienso que de esa forma no se debe usar, ya que para eso no ha sido hecho el for sino para bucles finitos, para un bucle infinito sería while (1) o while (true).

Alguién podría responderme mi pregunta, nos vemos.

La elegancia es muy relativa. Particularmente en los micros habría que buscar con mucho mas ahinco la eficacia, vista tanto en tamaño de código cuando sea crítico, como en ciclos de instrucción.
Para ello habría que compilar ambas opciones y examinar cuál "chupa" más. Lo he hecho y ambas se compilan exactamente igual: un BRA a si mismas, o lo que es igual, un salto incondicional permanente.
A partir de ahí, que cada cual utilice la fórmula que más "elegante" le parezca.

Con respecto a la duda que preguntabas, si no has colocado la sentencia #FAST_IO, el compilador se encargará de colocar los TRIS adecuados antes de cada sentencia de lectura/escritura. No obstante, para leer un pin en CCS hay un comando específico. Yo cambiaría tu línea por esta:
if (input(PIN_B0)==1)

Título: Re: Microcursillo en C
Publicado por: Renatox_ en 04 de Enero de 2007, 19:00:59

hola Nocturno, voy a hacer lo que me dices poner if (input(PIN_B0)==1) para chequear el estado del pin B0, este pin lo he configurado como salida y al inicio del programa he puesto #FAST_IO B. Te comento que en todos los ejemplos que he visto en el Microcursillo cuando chequean el estado de un PIN este siempre esta configurado como entrada, pero en mi caso el B0 está como salida, da igual...?

Para tener más resumido el microcursillo me he hecho una recopilación de las explicaciones y codigos más importantes, hasta la pág. 28 asi puedo tener a la mano y encontrar más rápido lo que han explicado, lo pongo aquí, nos vemos.

Título: Re: Microcursillo en C
Publicado por: vszener en 05 de Enero de 2007, 15:10:39

Hombre, si un pin está declarado como salida, de poco vale leer su estado, ya que por soft, el programador le indica el estado que debe estar, en cambio, si el pin está configurado como entrada, si es interesante, en un determinado tiempo, ver que estado tiene dicho pin.

Suerte!!! ;)

Título: Re: Microcursillo en C
Publicado por: MGLSOFT en 05 de Enero de 2007, 15:27:20

Cita de: vszener en 05 de Enero de 2007, 15:10:39

Hombre, si un pin está declarado como salida, de poco vale leer su estado, ya que por soft, el programador le indica el estado que debe estar, en cambio, si el pin está configurado como entrada, si es interesante, en un determinado tiempo, ver que estado tiene dicho pin.

Suerte!!! ;)

Una de las cosas que permite la instruccion Input (pin) es de multiplexar una entrada utilizandola como salida y en un momento especifico tembien usarla como entrada.
Cuando tienes pocas patillas disponibles es muy comun hacerlo... :? :?

Título: Re: Microcursillo en C
Publicado por: Nocturno en 06 de Enero de 2007, 02:48:42

Para que te funcione como entrada / salida tienes dos opciones:
- modo standard_io para dejar que el compilador establezca si un pin estará como entrada o salida según convenga
- poner modo fast_io y asegurarse del estado de cada pin con set_trix_x() antes de utilizarlo

Para tu objetivo, y hasta que domines bien el tema, te recomiendo el standard_io.

Título: Re: Microcursillo en C
Publicado por: vszener en 06 de Enero de 2007, 05:26:58

Amí me gusta ser rudimentario :mrgreen: si un pin está configurado como salida, no creo que sea de interés la lectura de dicho pin (ya que por soft la sabemos), y si un pin está declarado como entrada, pues sí, ahí es su misión el leer que estado tiene.

A parte, me reitero en lo de rudimentario jeje, si tenemos un pin definido como entrada y en un momento determinado queremos usarlo de salida, pues a la fórmula de siempre, ponemos un set_tris_x y lo declaramos como salida y al finalizar la operacion pues el correspondiente set_tris_x y definido como entrada.

Suerte!!! ;)

Título: Re: Microcursillo en C
Publicado por: Renatox_ en 08 de Enero de 2007, 18:22:54

hola, con respecto a mi duda ya la pude solucionar me estaba haciendo bolas por las puras, debo haber tipeado mal, si se puede chequear si un pin està en alto o en bajo cuando es declarado como salida, esto es ùtil por ejm para hacer bascular un led.

Hace un tiempo estaba leyendo un subforo donde estaban hablando de la nueva versiòn del CCS, pero ahora no la puedo encontrar, alguièn sabe donde se ha metido.

saludos desde lima.

Título: Re: Microcursillo en C
Publicado por: vszener en 10 de Enero de 2007, 12:51:37

Desde la página web del fabricante (http://www.ccsinfo.com/content.php?page=compilers) podrás encontrar la información más acutalizada.

Suerte!!! ;)

Título: Re: Microcursillo en C
Publicado por: PalitroqueZ en 10 de Enero de 2007, 13:09:31

Cita de: Nocturno en 04 de Enero de 2007, 00:37:15

...
Yo cambiaría tu línea por esta:
if (input(PIN_B0)==1)

Nocturno ¿no se podría simplicar mas esa línea?

Código: [Seleccionar]

    if (input(PIN_B0))    // pregunta si RB0 está a uno

el caso contrario sería así

Código: [Seleccionar]

    if (!input(PIN_B0))    // pregunta si RB0 está a cero

Salu2
Pedro

Título: Re: Microcursillo en C
Publicado por: Nocturno en 10 de Enero de 2007, 16:55:59

Sí, se puede cambiar por la que tú dices. Creo que es cuestión de gustos.

Mira cómo compila CCS las cuatro opciones siguientes:

Código: [Seleccionar]

.................... if (input(PIN_B0)==1); 
0048:  BSF    F93.0
004A:  BTFSS  F81.0
004C:  BRA    004E
....................  
.................... if (input(PIN_B0)); 
004E:  BSF    F93.0
0050:  BTFSS  F81.0
0052:  BRA    0054
....................  
.................... if (input(PIN_B0)==1); 
0054:  BSF    F93.0
0056:  BTFSS  F81.0
0058:  BRA    005A
....................  
.................... if (!input(PIN_B0)); 
005A:  BSF    F93.0
005C:  BTFSC  F81.0
005E:  BRA    0060

En definitiva, aunque lo pongamos como nos de la gana, siempre se compila en tres ciclos, así que no hay más simplificación posible.

Título: Re: Microcursillo en C
Publicado por: PalitroqueZ en 11 de Enero de 2007, 11:41:32

cierto, cierto. ya está comprobado por ensamblador. :mrgreen:

Salu2
Pedro

Título: Re: Microcursillo en C
Publicado por: johnnybravo en 21 de Enero de 2007, 19:18:01

Saludos amigos del microcursillo
bueno la verdad es que no soy un capo en este lenguaje ... recien lo estoy aprendiendo y esque la verdad esta muy bueno este microcursillo y e aprendido un monto aqui...

revisando un poco el programa CCS encontre algo muy chido que me gusto mucho.... un ejemplo de como subirrle musiquita al pic el ejemplo se llama EX_tones... y tiene por supuesto un driver para esto que tambien viene con le programa.. bueno lo quise probar pero grande fue mi sorpresa cuando me arrojo un error :shock: .... que paso ??? :( el mensaje decia "A #DEVICE required before this line" alguien tubo el mismo problema? .. ¿ a que se debe.... que significa ?
como lo puedo solucionar... para poder compilarlo....

Título: Re: Microcursillo en C
Publicado por: johnnybravo en 21 de Enero de 2007, 19:52:09

hola amigos otra ves
Alguien se anima a ayudarme a decifrar un poco el ejemplito EX_Tones.c :-/ del copilador CCS.
bueno la verdad es que soy un novato en este lenguaje
pero aqui va el primer intento.

/////////////////////////////////////////////////////////////////////////
//// EX_TONES.C ////
//// ////
//// This example plays the song "Happy Birthday." ////
//// ////
//// Configure the CCS prototype card as follows: ////
//// Connect the positive wire of the speaker to pin 47 (B0) ////
//// Connect the negative wire of the speaker to pin 27 (Gnd) ////
//// ////
//// 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 and clock ////
//// pins for your hardware if needed. ////
/////////////////////////////////////////////////////////////////////////

#if defined(__PCM__) // ????
#include <16F877.h> // esta liena indica el pic que usaremos
#fuses HS,NOWDT,NOPROTECT,NOLVP // esto es la configuracion de los fusibles del pic
#use delay(clock=20000000) // esto indica el pic corre con un cristal de 20MHz

#elif defined(__PCH__) // ?????
#include <18F452.h> // ????? porque se define otro pic ???? aclaren me esto ????
#fuses HS,NOWDT,NOPROTECT,NOLVP /?????
#use delay(clock=20000000)
#endif

#include <tones.c> //incluimos el driver Tones.c, este produce las frec y duracion de las notas musicales

#define SIZE 25 // define de cuantas notas tiene nuestra estructura musical

const struct note // esto es la subrutina estructura de notas
{
long tone; // la frecuencia de la nota, la frecuenci esta incluida en la tabla del driver tones.c
long length; // la duracion de la nota, tambien incluida en la misma tabla del driver tones.c
} happy_bday[SIZE] = { // aquiesta si cuentas mas abajo tiene 25 notas musicales con su frecuencia y duracion
C_note[0],350, C_note[0],100, D_note[0],500, C_note[0],500, F_note[0],500, E_note[0],900,
C_note[0],350, C_note[0],100, D_note[0],500, C_note[0],500, G_note[0],500, F_note[0],900,
C_note[0],350, C_note[0],100, C_note[1],500, A_note[0],500, F_note[0],500, E_note[0],500, D_note[0],900,
Bb_note[0],350, Bb_note[0],100, A_note[0],500, F_note[0],500, G_note[0],500, F_note[0],1200};

void main(void) { // esto es el programa principal
int i; // declaramos la variable i

while(TRUE) // esto es un bucle infinito
{
for(i=0; i<SIZE; ++i) // esta condicion nos dice que ejecutara la siguiente instruccion mientras la variable i<25
{
generate_tone(happy_bday.tone,happy_bday.length); // esto llama al driver Tones.c
delay_ms(75); // un delay de 75ms
}
}
}

bueno todo lo explicado es a mi modesto entender, como ven hay cosas que no llego a entender. y las he remarcado como: //???????? aqui les quiero pedir que me ayuden a decifrar el resto del ejemplo

a por cierto para los que no tienen el CCS el driver tones.c lo pongo por aqui abajo tal y como biene.

////////////////// Driver to generate musical tones /////////////////////
//// ////
//// generate_tone(frequency, duration) Generates wave at set ////
//// frequency (Hz) for set ////
//// duration (ms) ////
//// ////
/////////////////////////////////////////////////////////////////////////

#ifndef MUSIC_NOTES
#define MUSIC_NOTES

// NOTE FREQUENCY
// Octave0 Octave1 Octave2 Octave3
const long C_NOTE[4] ={ 262, 523, 1047, 2093};
const long Db_NOTE[4] ={ 277, 554, 1109, 2217};
const long D_NOTE[4] ={ 294, 587, 1175, 2349};
const long Eb_NOTE[4] ={ 311, 622, 1245, 2489};
const long E_NOTE[4] ={ 330, 659, 1329, 2637};
const long F_NOTE[4] ={ 349, 698, 1397, 2794};
const long Gb_NOTE[4] ={ 370, 740, 1480, 2960};
const long G_NOTE[4] ={ 392, 784, 1568, 3136};
const long Ab_NOTE[4] ={ 415, 831, 1661, 3322};
const long A_NOTE[4] ={ 440, 880, 1760, 3520};
const long Bb_NOTE[4] ={ 466, 923, 1865, 3729};
const long B_NOTE[4] ={ 494, 988, 1976, 3951};
#endif

#define TONE_PIN PIN_B0

void do_delay(int ms_delay, int num_ms, int us_delay, int num_us) {
int i;

for(i=0;i<num_ms;i++)
delay_ms(250);
delay_ms(ms_delay);
for(i=0;i<num_us;i++)
delay_us(250);
delay_us(us_delay);
}

void generate_tone(long frequency, long duration)
{
int32 total_delay_time; // in microseconds
long total_ms_delay_time, total_us_delay_time;
int num_us_delays, num_ms_delays, ms_delay_time, us_delay_time;
long num_periods;

total_delay_time = (1000000/frequency)/2-10; // calculate total delay time (10 for error)

total_ms_delay_time = total_delay_time/1000; // total delay time of ms
num_ms_delays = total_ms_delay_time/250; // number of 250ms delays needed
ms_delay_time = total_ms_delay_time%250; // left over ms delay time needed

total_us_delay_time = total_delay_time%1000; // total delay time of us (ms already acounted for)
num_us_delays = total_us_delay_time/250; // number of 250us delays needed
us_delay_time = total_us_delay_time%250; // left over us delay time needed

num_periods = ((int32)duration*1000)/(1000000/frequency);

while((num_periods--) != 0)
{
do_delay(ms_delay_time, num_ms_delays, us_delay_time, num_us_delays);
output_high(TONE_PIN);
do_delay(ms_delay_time, num_ms_delays, us_delay_time, num_us_delays);
output_low(TONE_PIN);
}

return;
}

Título: Re: Microcursillo en C
Publicado por: vszener en 23 de Enero de 2007, 08:35:05

Pues esta parte del código:

Código: C

#if defined(__PCM__)  // ????
#include <16F877.h>  // esta liena indica el pic que usaremos
#fuses HS,NOWDT,NOPROTECT,NOLVP    // esto es la configuracion de los fusibles del pic
#use delay(clock=20000000)  // esto indica el pic corre con un cristal de 20MHz
 
#elif defined(__PCH__)  // ?????
#include <18F452.h>  // ????? porque  se define otro pic ???? aclaren me esto ????

Son órdenes para el compilador, para definir el pic a usar y su correspondinte libreria de definiciones, y quiere decir algo como esto: Si se define el pic 16F877 pues utiliza la configuración que está a continuación, en caso contrario, pues la definición es paa el pic 18F452.

Suerte!!! ;)

Título: Re: Microcursillo en C
Publicado por: johnnybravo en 25 de Enero de 2007, 15:27:24

ha yaaaaaaa.. muchas gracias por eso amigo :-/

Título: Re: Microcursillo en C
Publicado por: perry en 06 de Febrero de 2007, 07:41:11

Hola!!!!

La verdad es que este micro cursillo está muy bien para empezar a familiarizarte con la programacion de pics, este es mi caso que estoy empezando a manejar el ccs pero tengo un problema. A la hora de compilar me da el error de que no encuentra el dispositivo utilizado(18f4550) y la verdad es que en la carpeta devices no tengo más que la configuración de 4 pics. ¿alguien sabe como puedo conseguir el fichero .h del 18f4550?

muchas gracias por vuestra ayuda y seguid así. :P :P :P

Título: Re: Microcursillo en C
Publicado por: maunix en 06 de Febrero de 2007, 09:52:05

Cita de: Nocturno en 10 de Enero de 2007, 16:55:59

Sí, se puede cambiar por la que tú dices. Creo que es cuestión de gustos.

Mira cómo compila CCS las cuatro opciones siguientes:

Código: [Seleccionar]
.................... if (input(PIN_B0)==1); 0048: BSF F93.0 004A: BTFSS F81.0 004C: BRA 004E .................... .................... if (input(PIN_B0)); 004E: BSF F93.0 0050: BTFSS F81.0 0052: BRA 0054 .................... .................... if (input(PIN_B0)==1); 0054: BSF F93.0 0056: BTFSS F81.0 0058: BRA 005A .................... .................... if (!input(PIN_B0)); 005A: BSF F93.0 005C: BTFSC F81.0 005E: BRA 0060
En definitiva, aunque lo pongamos como nos de la gana, siempre se compila en tres ciclos, así que no hay más simplificación posible.

Manolo, he visto este código y creo que una pequeña simplificación más, sería la de activar los seteos rápidos de los puertos para evitar ésta linea (bsf F93.0) que lo que haces es poner el TRISB<0> como entrada

De esa forma, solo ocuparía 2 líneas.

Título: Re: Microcursillo en C
Publicado por: Sispic en 06 de Febrero de 2007, 13:19:18

Si maumix , hace cosa rara esto -> if (input(PIN_B0)==1);

Código: [Seleccionar]

.................... if (  bit_test( PORTB ,  0 )){a=0;}
002C:  BTFSC  F81.0
002E:  CLRF   05

Título: Re: Microcursillo en C
Publicado por: maunix en 06 de Febrero de 2007, 13:27:39

Cita de: Sispic en 06 de Febrero de 2007, 13:19:18

Si maumix , hace cosa rara esto -> if (input(PIN_B0)==1);

Código: [Seleccionar]
.................... if ( bit_test( PORTB , 0 )){a=0;} 002C: BTFSC F81.0 002E: CLRF 05

Si, una vez ví leyendo velozmente el manual del CCS (el cual no uso) que usa un modo automático que acomoda el tris de un pin como entrada si es que se lee el registro o como salida si es que se lo escribe.

Y que si uno usa algo así como FAST_IO o similar, se evitaba eso.

tal vez justo en el ejemplo de manolo estaban activados. :)

Título: Re: Microcursillo en C
Publicado por: vszener en 07 de Febrero de 2007, 06:53:39

perry tú lo que tienes es la versión demo , parece ser, y por eso tienes un número limitado de pic's

Suerte!!! ;)

Título: Re: Microcursillo en C
Publicado por: perry en 09 de Febrero de 2007, 08:26:13

Muchas gracias vszener. Tenias razón, ya me he hecho con una version completa. :wink:

He tenido un problema con un ejemplo de modulay (en la pagina tres de este tema) que sumaba 2 numeros y los sacaba por la lcd. A la hora de compilar me da un error que dice: can not change device type this far into the code. ¿por que pasa esto? no he hecho más que copiar el código en ccs.

Cuesta bastante empezar con esto, vaya lío. :-/
muchas gracias

Título: Re: Microcursillo en C
Publicado por: PalitroqueZ en 09 de Febrero de 2007, 11:59:57

Cita de: maunix en 06 de Febrero de 2007, 13:27:39

Cita de: Sispic en 06 de Febrero de 2007, 13:19:18
Si maumix , hace cosa rara esto -> if (input(PIN_B0)==1);

Código: [Seleccionar]
.................... if ( bit_test( PORTB , 0 )){a=0;} 002C: BTFSC F81.0 002E: CLRF 05

Si, una vez ví leyendo velozmente el manual del CCS (el cual no uso) que usa un modo automático que acomoda el tris de un pin como entrada si es que se lee el registro o como salida si es que se lo escribe.

Y que si uno usa algo así como FAST_IO o similar, se evitaba eso.

tal vez justo en el ejemplo de manolo estaban activados. :)

Aclarenme una duda que tengo, la idea de simplificar un código en C ¿se trata de optimizar el ensamblador que genera ó de reducir las lineas de programacion?

Salu2
Pedro

Título: Re: Microcursillo en C
Publicado por: Nocturno en 09 de Febrero de 2007, 13:22:18

Según cuál sea tu objetivo. Puede que se trate de optimizar la velocidad o de optimizar el tamaño.
Te pongo un ejemplo: vamos a generar una onda cuadrada muy rápida por un pin llamado "led".

En caso de optimizar en tamaño podríamos optimizarlo así:

Código: C

....................    for (i=0;i<10;i++) { 
0104:  CLRF   15
0106:  MOVF   15,W
0108:  SUBLW  09
010A:  BNC   0114
....................       led=0; 
010C:  BCF    F81.2
....................       led=1; 
010E:  BSF    F81.2
.................... 
0110:  INCF   15,F
0112:  BRA    0106   }

y si queremos optimizar el programa en velocidad, sin importarnos lo que ocupe, nada mejor que esto:

Código: C

....................       led=0; 
0114:  BCF    F81.2
....................       led=1; 
0116:  BSF    F81.2
....................       led=0; 
0118:  BCF    F81.2
....................       led=1; 
011A:  BSF    F81.2
....................       led=0; 
011C:  BCF    F81.2
....................       led=1; 
011E:  BSF    F81.2
....................       led=0; 
0120:  BCF    F81.2
....................       led=1;       
0122:  BSF    F81.2
....................       led=0; 
0124:  BCF    F81.2
....................       led=1; 
0126:  BSF    F81.2
....................       led=0; 
0128:  BCF    F81.2
....................       led=1; 
012A:  BSF    F81.2
....................       led=0; 
012C:  BCF    F81.2
....................       led=1; 
012E:  BSF    F81.2
....................       led=0; 
0130:  BCF    F81.2
....................       led=1; 
0132:  BSF    F81.2
....................       led=0; 
0134:  BCF    F81.2
....................       led=1; 
0136:  BSF    F81.2
....................       led=0; 
0138:  BCF    F81.2
....................       led=1; 
013A:  BSF    F81.2

Código: ASM

Título: Re: Microcursillo en C
Publicado por: mistergato en 12 de Julio de 2007, 04:04:41

eyy yo me apunto.!!! necesito eso si o siiiii

Título: Re: Microcursillo en C
Publicado por: handpic en 28 de Agosto de 2007, 16:04:13

Hola a todos,

Llevo algún tiempo intentando aprender esto del "C", pero resulta que me encuentro con algunos escaloncillos...

He intentado simular estos primeros ejercicios que indicais, pero no puedo compilarlos, el MPLAB, con el compilador de microchip, me dice que no es posible para el 16F84.

Es posible que sea por que no encuentra el archivo 16f84.h.

Aunque los programas los voy entendiendo, creo que se me quedan cosas en el tintero.

Por cierto, está claro que llevo algo de retraso..... vuestros mensajes son del 2004.

Título: Re: Microcursillo en C
Publicado por: Nocturno en 28 de Agosto de 2007, 19:12:43

La mayoría de los ejemplos que encontrarás aquí (por no decir todos) están hechos con el compilador CCS, y por eso seguramente te fallarán en el compilador de Microchip.
Te recomiendo te hagas con un CCS y lo pruebes.

Título: Re: Microcursillo en C
Publicado por: vszener en 29 de Agosto de 2007, 06:08:02

Como ya te han menciondao, el C está realizado, prácticamente todo, en CCS, el MPlab, en sus nuevas versiones, trae consigo una demo limitada, para el PIC que deseas, el PIC16F84A, la demo es válida.

Simplemente cuando creas el proyecto, el lenguaje que deberás poner es el del CCS.

Suerte!!! ;)

Título: Re: Microcursillo en C
Publicado por: microKings en 06 de Septiembre de 2007, 09:24:26

Buenas disculpen, que modificaciones tendría que hacer en la libreria lcd de CCS para el manejo de una pantalla de 16x4?

de antemanos muchisimas gracias.

Título: Re: Microcursillo en C
Publicado por: vszener en 07 de Septiembre de 2007, 14:37:02

Tendrías que bajarte el datasheet de tú lcd, y realizar las librerias de manejo para la misma. La libreria lcd que trae el CCS es para lcd's compatibles Hitachi.

Suerte!!! ;)

Título: Re: Microcursillo en C
Publicado por: johnnybravo en 28 de Septiembre de 2007, 14:56:34

Hola amigos
despues de mucho tiempo... que paso con el foro... tiene alguna fallas creo.. no pude ingresar a l principio pero ya estoy aqui...
bueno ahora estoy tras un proyectito pa mi arbol de navidad jejeje... quiero ponerle led en las bolitas transparentes de colores de mi arbolito... pero quiero lograr el efecto tipo dimer con los Leds que le ponga dentro de las bolitas....
haber les explico como estoy pensando.. cuando empiesa va aumentando el brillo del led hasta lograr la maxima iluminacion despues de eso se mantiene ahi por un rato y luego comienza el proceso inverso se va desvaneciendo hasta apagarse.. todo ello un proceso repetitivo que empiese cuado yo enchufe el aparato.. no se si lo logre pero empesare de inmediato....
la idea es hacerlo atravez del pwm.. y voy a tratar de usar un 16f628 espero que me alcance quiero usar como salidas el puertoB, 8 led aumentando y disminuyendo su brillo al mismo tiempo.....ya el comentare los resutados.
me parece que esta facil ... bueno parece... asi que :-/ manos la obra... :-/ vamos a la guerra :mrgreen:

Título: Re: Microcursillo en C
Publicado por: vszener en 03 de Octubre de 2007, 08:57:47

También podrías hacerlo con un módulo de Digital a Analógico (D/A).

Suerte!!! ;)

Título: Re: Microcursillo en C
Publicado por: Leon Pic en 03 de Octubre de 2007, 09:18:43

Cita de: handpic en 28 de Agosto de 2007, 16:04:13

Hola a todos,

Llevo algún tiempo intentando aprender esto del "C", pero resulta que me encuentro con algunos escaloncillos...

He intentado simular estos primeros ejercicios que indicais, pero no puedo compilarlos, el MPLAB, con el compilador de microchip, me dice que no es posible para el 16F84.

Es posible que sea por que no encuentra el archivo 16f84.h.

Aunque los programas los voy entendiendo, creo que se me quedan cosas en el tintero.

Por cierto, está claro que llevo algo de retraso..... vuestros mensajes son del 2004.

Hola handpic. Pasate por este link que yo tuve el mismo problema, en él verás como renegué con esto pero lo tengo andando.

http://www.todopic.com.ar/foros/index.php?topic=18743.0

Saludos. :-/ :-/

Título: Re: Microcursillo en C
Publicado por: rodrigodedomingo en 13 de Octubre de 2007, 21:36:26

Buenas,
me podria explicar alguien para que sirve la instruccion setup_oscilator(osc_8MHz) y cuando se usa??
tiene algo que ver con #use delay (clock=8000000)??

Título: Re: Microcursillo en C
Publicado por: Nocturno en 14 de Octubre de 2007, 01:58:30

La instrucción setup_oscillator se utiliza cuando el micro incopora un oscilador interno ajustable a distintas frecuencias. Cuando esto es así, con esta instrucción lo configuras para que corra a la frecuencia que tú desees.

La instrucción #use delay prepara determinadas opciones del programa para adaptarse a una frecuencia de trabajo determinada: delay_ms(), #use rs232, ... En definitiva, todos los procesos "síncronos" mirarán lo que hay en "delay" para calcular sus retardos.

Título: Re: Microcursillo en C
Publicado por: rodrigodedomingo en 16 de Octubre de 2007, 12:32:35

clarito,clarito...muchas gracias nocturno!!

Todavia me queda una preguntilla.¿que diferencia hay entre usar un oscilador interno y un crystal?¿que es mejor?¿tienen todos los pics osciladores internos?

muchas gracias!

Título: Re: Microcursillo en C
Publicado por: RedPic en 16 de Octubre de 2007, 12:59:08

Le tomo el relevo a Nocturno.

Entre un oscilador interno y un cristal externo del mismo valor está la diferencia de la exactitud de la oscilación. Cosa que será solo apreciable si el PIC debe ejecutar funciones a alta velocidad en el que los tiempos deban ser muy precisos: por ejemplo comunicaciones síncronas (RS232) a altos baudajes, de 115200 baudios o más.

La gran diferencia, ademas de la precisión, va a estar en la selección de velocidades de oscilación: Podrás poner un cristal de 4 Mhz, o 8 Mhz, o 10 Mhz o 20 Mhz ... seleccionando el que mas te convenga para tu aplicación, siempre dentro de los márgenes que soporte cada PIC en cuestión, ya que los hay que pueden oscilar hasta 10 Mhz o hasta 20 Mhz ...

Los PIC los hay con un oscilador interno fijo, a 4 Mhz, a 8 MHz ... los hay que con un mismo oscilador puede seleccionarse varias velocidades de oscilación ... y los hay sin oscilador interno alguno.

Un saludo.

Título: Re: Microcursillo en C
Publicado por: zurdo en 26 de Noviembre de 2007, 14:08:23

hola apenas estoy empezando con lo de los pic y me han ayudado bastante los ejemplos de este foro... quisiera empezar a manejar el puerto serie del pic simplemente haciendo en proteus una conversion paralelo serie de un dato con el 74165 e ingresarlo al pic por el puerto serie y para verificarlo, mostrarlo en la pantalla LCD, es muy simple pero creo que me ayudaria bastante para empezar con otros proyectos de mayor envergadura.... gracias y saludos

:mrgreen:

Título: Re: Microcursillo en C
Publicado por: Nocturno en 26 de Noviembre de 2007, 16:13:34

Seguro que te ayuda. Por aquí estaremos esperando a ver tus progresos y cómo queda definitivamente tu reto. Suerte.

Título: Re: Microcursillo en C
Publicado por: zurdo en 26 de Noviembre de 2007, 18:52:33

ya empezaron los problemas este es el codigo que tengo para leer el dato y mostrarlo por pantalla:

void main()
{

char num;

setup_adc_ports(NO_ANALOGS);
setup_adc(ADC_OFF);
setup_psp(PSP_DISABLED);
setup_spi(FALSE);
setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
setup_timer_1(T1_DISABLED);
setup_timer_2(T2_DISABLED,0,1);
setup_comparator(NC_NC_NC_NC);
setup_vref(FALSE);
lcd_init();

while(TRUE)
{
if (kbhit())
{
num=getc();
delay_ms(20);
lcd_putc(" ");
lcd_gotoxy(1,1);
delay_ms(10);
printf(lcd_putc,"%C",num); //si en la entrada coloco distintos datos
} //aparecen simbolos extraños en la pantalla
}
}

la principal duda es como saber si el pic leyo correctamente el dato?
y como mostrarlo en binario en la pantalla para asi poder chequearlo bit a bit con la entrada

gracias.... :mrgreen:

Título: Re: Microcursillo en C
Publicado por: pocher en 27 de Noviembre de 2007, 03:18:23

¿Para leer un teclado matricial? ¿Como lo sabes? La instrucción kbhit() ¿no está esperando un caracter del RS232?

Yo de zurdo pondría todo el programa entero.

Título: Re: Microcursillo en C
Publicado por: Nocturno en 27 de Noviembre de 2007, 03:34:08

Pocher, después de escribir semejante tontería me di cuenta del error y eliminé el mensaje. Pero ya era tarde y habías respondido tú.

Título: Re: Microcursillo en C
Publicado por: zurdo en 27 de Noviembre de 2007, 23:25:06

ok disculpen, la instruccion kbhit() la coloque para probar si asi la solucionaba pero no estoy seguro que sea la correcta.

el dato lo estoy recibiendo por el RS-232 y el circuito que lo genera es un registro de desplazamiento 74165 y una circuiteria extra para generar el bit de start y de stop con unas compuertas, el dato creo que lo estoy generando bien y le coloco la misma frecuencia que la del RS-232 del pic.
por ejemplo si le introduzco la secuencia 11000110 entonces al mandar a escribir en la pantalla obtengo el caracter EC y asi con otros con y sin la instruccion kbhit()
y si declaro a num como integer pues escribo un numero en la pantalla que tampoco corresponde al introducido.

Título: Re: Microcursillo en C
Publicado por: zurdo en 27 de Noviembre de 2007, 23:30:03

adjunto la simulacion en proteus porque me parece que una imagen habla mas que mil palabras. gracias por su ayuda... :mrgreen:

Título: Re: Microcursillo en C
Publicado por: pocher en 28 de Noviembre de 2007, 03:56:25

Ten en cuenta que al PIC le estan llegando 0 y 1 individuales que tendrás que ir guardando y luego unir para formar un caracter y poder representarlo en la LCD.

Pon el programa completo para poder simularlo.

PD. Acabo de ver que lo único que quieres es representarlos en la LCD bit a bit.

Título: Re: Microcursillo en C
Publicado por: pocher en 28 de Noviembre de 2007, 13:50:22

Esta tarde que tenía mas tiempo me lo he estado mirando más detenidamente.

Hay varias cosas que no entiendo. Los valores que le llegan al pin C7 son valores de tensiones (0V y 5V) no son bits, ni bytes. Entonces, ¿para qué quieres emplear la comunicación RS232? Lo estás enfocando mal, si lo único que quieres es que cuando hagas la carga en paralelo del registro 74165 leer la entrada RC7 y después mandarsela a la LCD, pués haces num=input(pin_C7) ... y olvídate de toda la comunicación RS232.

Otra cosa, esas puertas que tienes por ahí no sé para qué sirven, para generar el bit de Start y Stop creo que no. Ya me dirás algo.

Un saludo

Título: Re: Microcursillo en C
Publicado por: pocher en 28 de Noviembre de 2007, 13:55:19

Otra cosa, si quieres ver en la LCD el contenido del 74165, poco a poco, no le metas en el reloj la frecuencia que tienes de 9,6KHz, métele 1Hz por ejemplo.

Título: Re: Microcursillo en C
Publicado por: Tho0oR en 24 de Enero de 2008, 20:23:13

Muy Buenas!!!

Este cursillo sige en pie??

Es fantastico!! yo soy un principiante, pero me lo agrego a favoritos y lo que pueda participar, participo.

Me esta ayudando mucho en mi aprendizaje, sois unos fenomenos!!!

Unos saludos a todos!!

Título: Re: Microcursillo en C
Publicado por: Leon Pic en 28 de Enero de 2008, 15:15:56

Por supuesto que sigue en pie. Solo tenés que hacer preguntas sobre algunas dudas o problemas que tengaas y alguién te las va a responder.

Título: Re: Microcursillo en C
Publicado por: Tho0oR en 29 de Enero de 2008, 08:52:23

Hola!!

Estoy muy interesado en un programa que hizo Nocturno sobre un teclado matricial 4x3 creo recordar!

Era brillante la forma de pensar, de como leer un teclado con una sola entrada! Para ello empleaba 12 pulsadores distribuidos a forma de teclado, y en cada linea y columna una resistencia de distinto valor, de forma que la tension en la entrada del pia, dependia de que tecla hubieras pulsado. El convertidor AD hacie el resto.

Como me parece brillante esa forma de pensar, me gustaria ver el ejemplo, porque me lo enseñaron pero no lo consigo en ningun sitio.

por cierto Nocturno, tienes pagina web?

Un saludo a todos!!

Título: Re: Microcursillo en C
Publicado por: Nocturno en 29 de Enero de 2008, 09:00:43

http://www.todopic.com.ar/foros/index.php?topic=18911.40

Título: Re: Microcursillo en C
Publicado por: Tho0oR en 29 de Enero de 2008, 20:27:42

gracias nocturno, eres un crack! :-)

Título: Re: Microcursillo en C
Publicado por: RedPic en 29 de Enero de 2008, 21:50:12

:mrgreen:

Título: Re: Microcursillo en C
Publicado por: pocher en 30 de Enero de 2008, 10:10:01

Nocturno alias RedPic :mrgreen:

Título: Re: Microcursillo en C
Publicado por: dawaherjesus en 10 de Febrero de 2008, 01:17:44

amigos como hago para seleccionar un pin en especifico del PIC y dale una configuración distinta a los demás por decirles quiero que el pin 3 de portb como salida y los demas como entrada o algo por el estilo

Título: Re: Microcursillo en C
Publicado por: Nocturno en 10 de Febrero de 2008, 02:31:21

Para establecer la dirección de un pin (entrada o salida) se utiliza el registro TRIS del micro. En este registro hay una equivalencia de cada bit con cada pin del puerto. Cuando en el TRIS un bit vale 0, el pin correspondiente estará configurado como salida; por el contrario, si hay un 1, el pin será entrada.

Así, si haces lo siguiente, el pin3 de portb será salida y los demás entradas:
set_tris_b(0b11110111);

Además, en CCS hay una forma más rápida de hacerlo, puesto que si no cambias la configuración por defecto, cada vez que hagas una escritura o lectura en el puerto, el compilador establecerá automáticamente el TRIS que corresponda.

De esta manera, si haces esto, también conseguirás el resultado que buscas:

x=input_b(); // leemos el puerto entero, y se autoconfigura como entradas
output_low(PIN_B3); // escribimos en el pin 3, y se autoconfigura como salida

Título: Re: Microcursillo en C
Publicado por: poseidon20 en 10 de Febrero de 2008, 02:33:36

Hola, que tal a todos. Algunos que me conocen en el foro, saben que programo en ASM, peor depsues de ver todo lo qeu se podia hacer con la seri 18f, y despue de ver todo lo que se necesitaba en ASM para hacer funcionar esos pics, tome la desicion de comenzar a tocar el lenguaje C para pics, el compilador con el cual estoy comenzando mi sprimeros pasos es el CCS 3.249. Y como no podia ser de otra manera habia que comenza con algo facil, simple y ameno. El parpadeo de un led, al cual le agregue una condicion con el PIN RA0 del PORTA, y bueno aca esta el resultado de eso, claro con la ayuda de el_guitre que me asesoro "on-line". Ahora me tendra a MI dandoles lata por que ahora tendre que pensar en C y dejar el ASM por un momento

Código: C

#include <16f877A.h>
#fuses   XT,NOWDT,PUT,NODEBUG,NOPROTECT,NOBROWNOUT,NOLVP,NOCPD,NOWRT
#use  delay(clock=4000000)    
#use  fast_io(b)
#use  fast_io(a)
#zero_ram         //pone a "0" todos los registros internos que son usados como
                  //variables
 
 
void main()
   {
 
   set_tris_b(0x00);                //configuro el puerto B como salida
   set_tris_a(0b00001);             //configura el RA0=in, RA1-RA5=out
   output_b(0x00);                  //pongo en cero las salidas del portb
 
      
      while(true)            
         {                          
         while(!input(PIN_A0))      //pregunto si presione RA0=0?      
            {                       //si, entonces enciendo RB1   
            output_high(PIN_B1);       
            }
         output_low(PIN_B1);        //no, apago RB1, y RB0 esta
         delay_ms(1000);            //encendido y apagado cada 1s
         output_toggle(PIN_B0);
         }         
   }

P.D: Si la memoria no me falla, CCS tiene librerias para manejar LCD y teclado matricial, mi duda es si se pueden usar el LCD y el teclado en el mismo portB, ya que en asm yo lo hago asi, el lcd lo tengo conectado en la parte alta del puerto y el detecto las pulsadas en el teclado por interrupcion (cambio de -estado en RB7-RB4) asi me permite usar los dos dispositivos en un solo puerto. No se si la librerias que hizo aitopes puede hacer eso o tendre que hacer mi adaptaciones del asm de esas librerias al C :D

P.D2: la version que estoy usando es la mas estable? ya que no quiero romperme el cerebro por problema de compilador :mrgreen:

P.D3: Manolo, paras en linea? ya que solo una vez charle por el MSN con tigo :mrgreen:.

Título: Re: Microcursillo en C
Publicado por: MGLSOFT en 10 de Febrero de 2008, 10:35:57

La primera compara valor con el resultado de la operacion matematica, la segunda opcion le asigna a valor el resultado de la misma... :mrgreen:

Título: Re: Microcursillo en C
Publicado por: Tho0oR en 12 de Febrero de 2008, 16:56:39

Hola amigos!

Necesito ayuda con un programa de un servo motor.

El problema parece sencillo, se trata de que el programa te de la opcion de elegir los grados, y luego al pulsar un boton ( RB0 por ejemplo ) gire esos grados.

Parece sencillo pero nose ni como empezar.

Cualquier tipo de ayuda sera muy bienvenida!

Muchas gracias de antemano

Título: Re: Microcursillo en C
Publicado por: vszener en 16 de Febrero de 2008, 08:17:08

Un Encoder angular podría serte útil.

Suerte!!! ;)

Título: Re: Microcursillo en C
Publicado por: Trino en 14 de Julio de 2008, 08:35:06

Hola a todos, en primer lugar deciros que este foro es de lo mejor que he encontrado en internet en cuanto a programacion de pics. Soys geniales ;)
bien a lo que iva, yo empece con esto de los pics en lenguaje ensamblador (asm) y en esto de C aun estoy un poco verde, una cosa que queria saber es si se pueden realizar saltos en C con alguna instruccion, ya que tengo que testear 2 entradas y segun la combinacion que tengan (00,01,10,11) he de dar un salto a un lugar o a otro.
Voy a concretar un poco mas....
tengo 2 entradas en las que siempre van a seguir la secuencia ascendente (00,01,10,11,00,01,10,11,00.....) o descendente (00,11,10,01,00,11,....) y cada vez que cambia ascendentemente he de incrementar en 1 un contador y por el contrario cada vez que desciende he de decrementar en 1 dicho contador pero para ello he de testear en que posicion está al iniciar el programa y dar un salto asta dicha posicion y de ahi seguir con el programa.
Y claro no se como dar ese salto en C, si alguien me pudiera orientar lo agradeceria mucho.

Gracias a todos de antemano.

Un Saludo.

Título: Re: Microcursillo en C
Publicado por: firepic en 14 de Julio de 2008, 11:14:02

Qué tal trino!
Para programar en C tienes que quitarte un poquito las mañas que trae uno de assembler... eso de saltos y demás...
En C no se hacen saltos, sino condicionales (if-else) o ciclos (while, for, switch).
Bueno habría que ver el código completo para saber qué se podría hacer. Pero te repito, tienes que cambiar un poco la lógica de programación.
Un cordial saludo, nos leemos! :mrgreen:

Título: Re: Microcursillo en C
Publicado por: Trompimania en 15 de Julio de 2008, 23:08:11

Estimados
¿Quisiera saber si alguen conoce alguna aplicacion para comunicar un pic a travez de un servidor OPC, si no es OPC puede ser un DDE?, de esta manera la informacion de un PIC podria ser levantada por una planilla exel, una base de datos,...... Este tema me pareceria muy interesante
Gracias

Título: Re: Microcursillo en C
Publicado por: victorga74 en 13 de Agosto de 2009, 13:43:51

ya se que hace casi 4 años pero en que quedo el microcursillo, le siguieron porque esta bien interesante

Saludos :) :)

Título: Re: Microcursillo en C
Publicado por: myesid en 14 de Agosto de 2009, 13:44:04

hola a todos soy nuevo en esto del ccs miren este mi programa de parpadeo de un led

/////Programa para parpadeo de led en CCS
// elaborador por Miller Yesid Galeano Santana

#include <16f877A.h> // llama el tipo de dispositivo en este caso el pic
#fuses XT // define el tipo de reloj y protecciones para el programa
#use delay(clock=4000000)// define la frecuencia de reloj ademas de el tiempo base del watchdog y valor del reset del mismo
// definicion de puertos
#byte portb=6 // se define el puerto a usar y su direccion en hexadecimal
// programa principal
void main ()
{

set_tris_b(0); //configura el puerto b de salida y ademas lo resetea
portb=0;

while(1)
{
delay_us(1000); // retardo de 1000uS para iniciar parpadeo
portb=1;
delay_us(2000);
portb=0;

}

}

mas sencillo sin la necesidad de crear contadores

Título: Re: Microcursillo en C
Publicado por: Suky en 14 de Agosto de 2009, 13:51:17

Hola myesid! Para ir mejorando, no es necesario definir el puerto, sino que puedes utilizar output_high(PIN_Bx) y output_low(PIN_Bx) para el control de un pin.
Después output_b(0xAA) por ejemplo para control de todo el puerto, etc.

Saludos!

Título: Re: Microcursillo en C
Publicado por: Miquel_S en 25 de Octubre de 2009, 18:55:07

Hola a todos, estoy empezando a programar en C y la verdad no parece tan dificil como el asm. Aqui os dejo otro programita de led's usando funciones.

#include <16F84.h>
#use delay(clock=4000000)
#fuses XT,NOWDT,NOPROTECT
#use standard_io(B)

//////////////////////// FUNCIONES //////////////////////

void Parpadea_0(int Repeticiones)
{
int i;
for(i=1;i<=Repeticiones;++i)
{
output_high(pin_B0);
delay_ms(500);
output_low(pin_B0);
delay_ms(500);
}
}

void Parpadea_1(int Repeticiones)
{
int i;
for(i=1;i<=Repeticiones;++i)
{
output_high(pin_B1);
delay_ms(500);
output_low(pin_B1);
delay_ms(500);
}
}

void Parpadea_2(int Repeticiones)
{
int i;
for(i=1;i<=Repeticiones;++i)
{
output_high(pin_B2);
delay_ms(500);
output_low(pin_B2);
delay_ms(500);
}
}

void Parpadea_3(int Repeticiones)
{
int i;
for(i=1;i<=Repeticiones;++i)
{
output_b(0x07);
delay_ms(500);
output_b(0x00);
delay_ms(500);
}
}

///////////////////////////// PROGRAMA PRINCIPAL /////////////////////////
void main()
{
set_tris_b(0x00);
output_b(0x00);

Parpadea_0(5);
Parpadea_1(5);
Parpadea_2(5);
Parpadea_3(5);

while(true);
}

PD: Ya se que es una tonteria de programa pero para uno que empieza como yo cuesta lo suyo escribir el codigo y que ademas que funcione.

Miquel_S

Título: Re: Microcursillo en C
Publicado por: Suky en 25 de Octubre de 2009, 23:38:51

Muy bien Miguel! Una cosita, cuando definís que el compilador trate los puertos como estándar no es necesario definir los tris, porque cada vez que se actué sobre el puerto el compilador modificará el tris según corresponda ;-) Esto podes verlo en C/ASM List

Saludos!

Título: Re: Microcursillo en C
Publicado por: Miquel_S en 26 de Octubre de 2009, 11:44:31

Gracias suky por la observacion, lo tendre en cuenta. :shock:

Miquel_S