La variable coje el valor que le da la gana

[Churi]

Hola a todos,

  Ando frito con un programa que estoy haciendo para leer una señal de IR de un mando a distancia. He probado con los ejemplos que he ido encontrando y nada, no consigo leer señales correctas.
Para la lectura, uso un TSOP1738, un PIC 16F628 y un cristal a 20Mhz.
Os pongo el programa y el resultado que obtengo.
Lo curioso es que en este resultado me da valores para la variable AltoBajo distintos a 0 y a 1, que son los únicos que yo asigno a la variable. Por otro lado esta el tema de los ticks, que no consigo con  ningún mando de los que tengo en casa que sea mas o menos estable.

Código: [Seleccionar]

////////////////////////////////////////////////////////////////////////////////////
// Churi
// 08/Noviembre/06
//
// Programa: Mando universal
// Version: 0.0
//
// Dispositivo: PIC 16F628A Compilador: CCS vs3.430
//
// Notas: Captura la señal del receptor de IR y la reenvia por el puerto A2
//
// B5(11) -> Reproducir pulso aprendido
// B4(10) -> Aprender un pulso
// B3(09) -> CCPM Pulso de 38 Khz
// B2(08) -> T1IN MAX232
// B1(07) -> R1OUT MAX232
// B0(06) -> Señal de entrada de IR (del TSOP 1738)
// A2(01) -> Señal de salida de IR
//
// Datos Leidos
//  Pulso 242 de 508
//  Pulso 9 de 3034
// L Pulso 0 de 915
// H Pulso 1 de 13394
// L Pulso 0 de 825
// H Pulso 1 de 16595
// L Pulso 0 de 2367
// H Pulso 1 de 9340
// L Pulso 0 de 1842
//  Pulso 3 de 4041
//  Pulso 29 de 505
//  Pulso 21 de 3252
//  Pulso 46 de 2035
//  Pulso 3 de 2860
//  Pulso 143 de 5596
//  Pulso 18 de 5159
//  Pulso 2 de 861
//  Pulso 21 de 4133
// L Pulso 0 de 6091
// H Pulso 1 de 11730
//  Pulso 50 de 2546
//////////////////////////////////////////////////////////////////////////////////

#include <16f628a.h> //pic a utilizar
#fuses HS,NOCPD,NOWDT,NOPUT,NOLVP,NOBROWNOUT //ordenes programador
#use delay (clock=20000000) //Fosc=4Mhz
#use rs232(baud=19200, xmit=PIN_B2, rcv=PIN_B1) //manejo del RS232
#use standard_io(a)
#use standard_io(b)

const int TotalPulsos = 20;
long Pulsos[TotalPulsos];
int AltoBajo[TotalPulsos];
long tt, t, vtt = 0;
int flancoHTOL = 1, v_a, v_PulsoNum;
int1 Aprendiendo = 0, HayDatos = 0;
const long tvuelta = 65536; // ticks por vuelta

// INTERRUPCION OVERFLOW TIMER 1 ---------------------------------------------
#int_rtcc
void int_r(){
vtt++;
}

// INTERRUPCION EXT por RB0 --------------------------------------------------
#int_ext
void ext_isr() {
// Obtengo datos de Timer0
tt = get_timer1();
Pulsos[v_PulsoNum] = tt + vtt * tvuelta;
//AltoBajo[v_PulsoNum] = FlancoHTOL;
if (FlancoHTOL == 1) {
   ext_int_edge(L_TO_H);
   FlancoHTOL = 0;
AltoBajo[v_PulsoNum] = 1;
   }
else
   {
   ext_int_edge(H_TO_L);
   FlancoHTOL = 1;
AltoBajo[v_PulsoNum] = 0;
   }
set_timer1(0);
vtt = 0;
v_PulsoNum++;
}
//-----------------------------------------------------------------------------

///PROGRAMA
void main(void)
{
long duty;

set_tris_a(0b11100011); //porta
set_tris_b(0b00000011); //portb
disable_interrupts(global);
setup_counters(RTCC_INTERNAL,RTCC_DIV_2);

setup_ccp1(CCP_PWM); // Configurar CCP como Modulador de pulsos.
setup_timer_2(T2_DIV_BY_16,7,1);

setup_comparator(NC_NC_NC_NC); // Configura los comparadores analógicos como desconectados.
setup_vref(FALSE); // Desactiva la tension de referencia para los comparadores.

// Para 38Khz y Cristal 20Mhz -> Preescaler = 16; PR2 = 7; Duty = 16
duty = 16;
set_pwm1_duty(duty);

port_b_pullups(FALSE);
setup_timer_1(T1_INTERNAL | T1_DIV_BY_1);
set_tris_b(0b00000001);
printf("\r\n");
printf("Prueba para leer dato enviado por IR\r\n");
ext_int_edge(H_TO_L);
FlancoHTOL = 1;
//enable_interrupts(int_ext);
enable_interrupts(int_rtcc);
enable_interrupts(global);
{
do{
if (!input(PIN_B4)&&(Aprendiendo==0)) { // Comienza a aprender.
   delay_ms(151);
   printf("Esperando lectura\r\n");
   FlancoHTOL = 1;
   Aprendiendo = 1;
   set_timer1(0);   
   vtt = 0;
   v_PulsoNum = 0;
   for(v_a=0; v_a <= TotalPulsos; v_a++){
      Pulsos[v_a] = 0;
      AltoBajo[v_a] = 0;
      }
   ext_int_edge(H_TO_L);
   enable_interrupts(int_ext);
   }
if (!input(PIN_B4)&&(Aprendiendo==1)) { // Deja de aprender
   delay_ms(151);
   disable_interrupts(int_ext);
   printf("Lectura acabada\r\n");
   Aprendiendo = 0;
   HayDatos = 1;
   }
if (HayDatos == 1) {
   printf("Datos Leidos\r\n");
   for(v_a=0;v_a <= TotalPulsos; v_a++) {
      if (AltoBajo[v_a] == 1) printf("H");
      else if (AltoBajo[v_a] == 0) printf("L");
      printf(" Pulso %U de %lu \r\n", AltoBajo[v_a], Pulsos[v_a]);
      }
   printf("\r\n");
   HayDatos = 0;
}

}while(TRUE); //bucle infinito
}
}



[Modulay]

Donde tengas esto:

for(v_a=0;v_a <= TotalPulsos; v_a++)

pon esto:

for(v_a=0;v_a < TotalPulsos; v_a++)

a ver que tal

[Churi]

Probaré a ponerlo, pero tal cual entiendo que son los arrays:
Si defino un array a 10 entiendo que tiene posiciones de 0 (incluida) hasta 10 (también incluida), No?

De todas formas mañana os cuento.

gracias por la respuesta.

[vszener]

No, del 0 al 10 hay 11 posiciones de memoria:

Posiciones: 0  1  2  3  4  5  6  7  8  9   10
Contador:  1  2  3  4  5  6  7  8  9  10  11


Suerte!!!

[PalitroqueZ]

Hola Churi, si declaras un arrays con 10 variables debes usar int variable[10], pero cuando vayas a leer, será de 0 a 9. ej: variable[0] a variable[9]

Salu2

[Churi]

Ya os entiendo, estoy acostumbrado a Delphi en el que cuando defines una variable:

variable: array [0..10] of integer;

das por supuesto que va de cero al valor que le pongas, pequeño matiz, que espero sea la solución al programita y me deje continuar.

Un saludo y gracias

[Churi]

Ya lo he probado y era como deciais, de hecho daba valores todavía mas raros al sobrepasar las 2 variables el límite del array.

Por otro lado, al usar estas variables te comes enseguida la memoria RAM del chip de forma que puedes usar un rango muy pequeño en el array. ¿Sabeis de otra forma de almacenar una tirada de valores?

He intentado grabarlas en la EEprom del pic, pero es muy lento para lo que quiero, o sea, que primero las debo coger en RAM y luego ya las podría traspasar a la EEprom, ¿Hay alguna forma de asignar (por ejemplo) memoria de programa (que me sobra) a la RAM?.
El 16F628a cuenta con 224 Bytes de RAM, escaso si necesitas usar arrays.

Un saludo

[Modulay]

La memoria de programa es igual de lenta que la eeprom.
Se puede usar para almacenar variables pero lo normal es usarla para el almacenamiento de constantes,que no parece ser tu caso.
Saludo

[Churi]

Segun el manual del CSS, la EEprom lleva un tiempo de milisegundos su acceso, de ahí que pensara que es mas lenta.

De todas formas, en el programa he intentado leer la trama IR y almacenarla en la EEprom, al hacer esto se me saltan pulsos, sin embargo, si lo almaceno directamente sobre un array (RAM) me coge todos.

La idea final del programa es que lea cualquier pulso de un mando a distancia, almacenar esas tramas (en una EEProm) y mas tarde reproducirlas, según el pulsador.

Deshecho la idea de programar el PIC con las tramas correspondientes a los mandos de casa, porque lo que quiero es que una vez montado, el propio mando aprenda la trama que le meta.

Respecto a la velocidad de la EEprom, volvere a probar, tanto con la interna del PIC como con otra externa, a ver que pasa.

Un saludo

[Modulay]

Pues si que tarda unos milisegundos en almacenar un dato.
De todas formas creo que la RAM del micro que estás usando te da de sobra para capturar una trama y posteriormente pasarla a eeprom ¿no?,siempre que lo hagas capturando tramas de una en una

[PalitroqueZ]

Ya lo he probado y era como deciais, de hecho daba valores todavía mas raros al sobrepasar las 2 variables el límite del array.

Por otro lado, al usar estas variables te comes enseguida la memoria RAM del chip de forma que puedes usar un rango muy pequeño en el array. ¿Sabeis de otra forma de almacenar una tirada de valores?

He intentado grabarlas en la EEprom del pic, pero es muy lento para lo que quiero, o sea, que primero las debo coger en RAM y luego ya las podría traspasar a la EEprom, ¿Hay alguna forma de asignar (por ejemplo) memoria de programa (que me sobra) a la RAM?.
El 16F628a cuenta con 224 Bytes de RAM, escaso si necesitas usar arrays.

Un saludo

si ese es un detalle a tomar en cuenta, a menos que sea un arrays de constantes es la forma en que se puede guardar en la ROM, en este post también pregunté sobre eso.

Salu2