Autor Tema: Microcursillo en C (Leído 178962 veces)

vszener

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

cchhaa

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

tartourusparda

la verdad no estaria mal yo tambien le entro a esto del cursito

RaDoN

Estupendo, ya tengo algo que hacer cuando a auna le da por no ir xD

andresitovv

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.

MGLSOFT

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

omibaya

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);
}

juan-jubilado

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.

juan-jubilado

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.

Nocturno

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...

Diego_arrow

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

micro_pepe

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.

omibaya

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

hhpp

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.

hhpp

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.

TODOPIC

Autor Tema: Microcursillo en C (Leído 178962 veces)

vszener

RE: Microcursillo en C

cchhaa

RE: Microcursillo en C

tartourusparda

RE: Microcursillo en C

RaDoN

RE: Microcursillo en C

andresitovv

RE: Microcursillo en C

MGLSOFT

RE: Microcursillo en C

omibaya

RE: Microcursillo en C

juan-jubilado

RE: Microcursillo en C

juan-jubilado

RE: Microcursillo en C

Nocturno

RE: Microcursillo en C

Diego_arrow

RE: Microcursillo en C

micro_pepe

RE: Microcursillo en C

omibaya

RE: Microcursillo en C

hhpp

RE: Microcursillo en C

hhpp

RE: Microcursillo en C