Problema con implementación en PIC16F684

Hola gente que tal, quiería preguntarles si hay algo que no estoy viendo que esté haciendo mal.
He realizado un programa en CCS para el PIC16F684, el cual simulo en PROTEUS V7.4 y funciona a la perfección. Pero ahora cuando lo paso al PIC en cuestion y lo monto sobre una protoboard no funciona adecuadamente. Lo que he detectado hasta el momento es que los pines de salida que van a los registros de desplazamiento estan transmitiendo información, no he montado la parte de los display ya que no era lo que queria probar ahora, pero bueno con el osciloscopio veo cambios en esos pines (C0,C1 y C2). Cuando presiono el pulsador para cambiar entre un tipo de secuencia y otra, las salidas antes mencionadas dejan de variar, como si el programa se quedara colgado y no hace mas nada. Tampoco cambia del led rojo al led verde. Y los más importante de todo, en el pin 13 (A0) tengo una salida de una secuencia de pulsos que nunca aparece y no se porque. A ver si estoy cometiendo algun error que no estoy viendo y alguien de afuera quizas lo pueda ver. Adjunto todos los datos que tengo para que puedan ver mejor.
Código:
#include <16F684.H> // Directivas del PIC 16F684

// Declaro la palabra de configuración del microcontrolador //

#fuses INTRC_IO,NoWdt,NoBrownout,Protect     // INTRC_IO, NoWatchDog, NoBrownOut, Protect 
#fuses NoMclr,NoCpd,Put,NoFcmen,NoIeso // NoMasterClear, NoEEProtection, Put, NoFcmen, NoIeso

// Configuro el cristal que voy a utilizar //

#use delay(clock=4000000) // Frecuencia de 4MHz interna

// Modo de configurar los pines de entrada/salida

#use fast_io(A) // Asignación rápida de los pines del puerto A
#use fast_io(C) // Asignación rápida de los pines del puerto C

#locate Puerto_A = 0x05 // Defino el puerto A con una etiqueta
// Registro de PORTA ==> BITS: 5 4 3 2 1 0
//                             | | | | | |_ RPM : Salida del sensor de RPM
//                             | | | | |___ Pot_RPM : Entrada para bajar/subir las RPM
//                             | | | |_____ Led_36_60 : Salida para indicar rueda de 36/60 dientes
//                             | | |_______ Pulsador : Entrada para cambiar entre rueda de 36 y 60 dientes
//                             | |_________ Xt : Oscilador a cristal
//                             |___________ Xt : Oscilador a cristal

#bit RPM       = Puerto_A.0 // GP0 como salida
#bit Pot_RPM   = Puerto_A.1 // GP1 como entrada
#bit Led_36_60 = Puerto_A.2 // GP2 como salida
#bit Pulsador  = Puerto_A.3 // GP3 como entrada

// Configuración de los pines del registro de desplazamiento 74HC595 //

#DEFINE OUTPUT_DATA  PIN_C0   // C0 a DS
#DEFINE SHIFT_LOAD   PIN_C1   // C1 a STCP
#DEFINE SHIFT_CLOCK  PIN_C2   // C2 a SHCP

// Definición de variables

int Valor_timer,Bandera_rueda,contador_36,contador_60,i;
int Unidad_Mil,Centena,Decena,Unidad;
int Numeros[10] = {0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F};
unsigned int Multiplicador;
long Tiempo,RPMs;
float p1=0.7254;
float p2=0.8784;

// Declaro las funciones utilizadas

void Inicializacion_dispositivo (); // Rutina de inicialicación del dispositivo
void Visualizar_RPM (); // Rutina para visualizar las RPM en display 7 segmentos
void Enviar_Numero (); // Rutina que manda en forma serie el numero

// Interrupcion Timer 0
#int_timer0
void Generador_de_pulsos_de_rueda (void)
{
   switch (Bandera_rueda)                 // Salto al caso que corresponda
   {
   case 0:                                // Rueda de 36 dientes
      {
         if (contador_36 < 70)            // Ingreso hasta formar los primeros 35 dientes
         {
            output_toggle (PIN_A0);       // Alterno la salida para formar los 35 dientes
            contador_36++;                // Incremento el contador para determinar el diente 35
         }
         else
            if (contador_36++ == 72)      // Incremento el contador pero solo ingreso cuando completo el diente 36 para resetear el contador
            {
               contador_36 = 0;           // Borro el contador
               Tiempo = get_timer1();     // Leo el valor del timer para calcular las RPM
               set_timer1(0);             // Pongo a cero el timer para calcular las RPM para la próxima
            }
      }break;
   case 1:                                // Rueda de 60 dientes
      {
         if (contador_60 < 116)           // Ingreso hasta formar los primeros 58 dientes
         {
            output_toggle (PIN_A0);       // Alterno la salida para formar los 58 dientes
            contador_60++;                // Incremento el contador para determinar el diente 58
         }
         else
            if (contador_60 < 118)        // El diente 59 va todo en alto
            {  
               RPM = 1;                   // Pongo la salida en alto
               contador_60++;             // Incremento el contador para determinar el diente 59
            }
            else
            {
               RPM = 0;                   // Hago baja la salida para el diente 60
               if (contador_60++ == 120)  // Incremento el contador pero solo ingreso cuando completo el diente 60 para resetear el contador
               {
                  contador_60 = 0;        // Borro el contador
                  Tiempo = get_timer1();  // Leo el valor del timer para calcular las RPM
                  set_timer1(0);          // Pongo a cero el timer para calcular las RPM para la próxima
               }
            }  
      }break;
   }
   set_timer0(Valor_timer);               // Seteo el valor del timer en función del valor del potenciometro
}

// Comienzo del programa principal

void main (void)
{
   Inicializacion_dispositivo();          // Inicializo el dispositivo
   Enable_interrupts (Int_timer0);        // Habilito la interrupción del timer1
   Enable_interrupts (global);            // Habilito las interrupciones globales
   for(;;)
   {
      if (Pulsador == 1)                  // Si apreto el pulsador ingreso al menú para cambiar de rueda
      {
         delay_ms (20);                   // Espero 20 mseg para evitar rebotes
         while(Pulsador == 1);            // Me quedo esperando hasta soltar el pulsador
         if (Bandera_Rueda == 1)          // Si la bandera de rueda es 1 entonces cambio a la rueda de 36 dientes
         {
            while(Contador_60 != 0);      // Espero para cambiar de tipo de rueda hasta que termine la que está en curso para comenzar con la nueva 
            setup_timer_0 (RTCC_DIV_8);   // Seteo el prescaler del timer0 a 8 para la rueda de 36 dientes
            Led_36_60 = 0;                // Prendo el led de la rueda de 36 dientes
            Bandera_Rueda = 0;            // Pongo en 0 la bandera de rueda para indicar que estamos en la rueda de 36 dientes
         }
         else                             // Si la bandera de rueda es 0 entonces cambio a la rueda de 60 dientes
         {
            while(Contador_36 != 0);      // Espero para cambiar de tipo de rueda hasta que termine la que está en curso para comenzar con la nueva
            setup_timer_0 (RTCC_DIV_4);   // Seteo el prescaler del timer0 a 4 para la rueda de 60 dientes
            Led_36_60 = 1;                // Prendo el led de la rueda de 60 dientes
            Bandera_Rueda = 1;            // Pongo en 1 la bandera de rueda para indicar que estamos en la rueda de 60 dientes
         }
      }
      if (Bandera_Rueda == 1)
         Valor_timer = p2*Read_adc()+21;  // Ecuación de la rueda de 60 dientes
      else
         Valor_timer = p1*Read_adc()+57;  // Ecuación de la rueda de 36 dientes
      Visualizar_RPM();                   // Rutina para visualizar las RPM
   }
}

void Inicializacion_dispositivo(void)  // Rutina de inicialicación del dispositivo
{  
   set_tris_a (0b00001010);                     // Pines como entrada: A1,A3 - Pines como salida: A0,A2,A4,A5
   output_a (0);                                // Borro las salidas del puerto A
   set_tris_c (0b00000000);                     // Pines como entrada:  - Pines como salida: C0,C1,C2,C3,C4,C5
   output_c (0);                                // Borro las salidas del puerto C
   setup_timer_0 (RTCC_Internal | RTCC_DIV_8);  // Seteo el prescaler del timer0 a 8 para la rueda de 36 dientes
   setup_timer_1 (T1_INTERNAL | T1_DIV_BY_2);   // Seteo el timer 1 para funcionar a 2 useg
   Setup_adc_ports (SAN1 | VSS_VDD);            // Indico que la entrada AN1 es analógica y con referencia entre Vss y Vdd
   Setup_adc (adc_clock_div_8);                 // Divido por 8 la frecuencia de reloj para un correcto funcionamiento del ADC
   Set_adc_channel(1);                          // Selecciono el canal 1 para realizar conversiones con el ADC
}

void Enviar_Numero (unsigned int8 Valor)
{
   Multiplicador = 128;
   for (i=0;i<=7;i++)                                    // inicio el bucle de 8 pasos
   {
      output_bit(Output_Data,!!(Valor&Multiplicador));   // Envio el bit n al IC
      output_low(Shift_Clock);                           // Pongo el clock interno del Shift Register en low 
      output_high(Shift_Clock);                          // Genero la señal de reloj para hacer shift register en el IC
      Multiplicador>>=1;                                 // y divido la mascara (128,64,32,16,8,4,2,1)
   }
}

void Visualizar_RPM (void)
{
   if (Tiempo != 0)
   {
      RPMs = 30000000/Tiempo;
      Unidad_Mil = 0;
      Centena = 0;
      Decena = 0;
      Unidad = 0;
      while (RPMs > 1000)
      {
         RPMs-=1000;
         Unidad_Mil++;
      }
      while (RPMs > 100)
      {
         RPMs-=100;
         Centena++;
      }
      while (RPMs > 10 )
      {
         RPMs-=10;
         Decena++;
      }
      while (RPMs > 1)
      {
         RPMs-=1;
         Unidad++;
      }
      Enviar_Numero(Numeros[Unidad_Mil]);
      Enviar_Numero(Numeros[Centena]);
      Enviar_Numero(Numeros[Decena]);
      Enviar_Numero(Numeros[Unidad]);
      output_low(Shift_Load);             // Cuando envió el byte completo pongo a low el clock externo del IC
      output_high(Shift_Load);            // y genero la señal de reloj para pasar el contenido del
      output_low(Shift_Load);             // registro a las salidas del IC
   }
}
 

Adjuntos

  • Emulador.part1.rar
    5 MB · Visitas: 16
  • Emulador.part2.rar
    5 MB · Visitas: 13
  • Emulador.part3.rar
    5 MB · Visitas: 12
  • Emulador.part4.rar
    5 MB · Visitas: 11
  • Emulador.part5.rar
    210.7 KB · Visitas: 10

D@rkbytes

Moderador
Saludos.
No sé si ya resolviste el problema, pero me quedé intrigado, así que realicé una prueba en físico y efectivamente el PIC no hacía nada.
Los puertos en 0 y no respondía a la función de cambio.

Revisé el programa y no encontré nada extraño, sólo algunas instrucciones que se podían cambiar por las nativas del compilador, así que las cambié y el programa empezó a funcionar en físico.

Oscilograma en físico CKP 60
DSC01951.jpg

Oscilograma en físico CKP 36
DSC01952.jpg

Adjunto el programa con los cambios realizados.​
 

Adjuntos

  • Emulador Modificado.rar
    1.8 MB · Visitas: 18
Hola D@rkbyte, perdón que me colgué, si lo pude descular, tuve una semana algo complicada por eso no tuve el suficiente tiempo para explicar como lo resolví. Al final de todo termino siendo las instrucciones while (contador_36); y while (contador_60); las que trababan todo. Por algún motivo era como que el timer0 no iniciaba su conteo con el primer seteo que le hacia en la rutina de inicialización y por lo tanto nunca entraba a la interrupción donde era que esas variables se podían modificar para que se saltara el while en un momento determinado. Asi que lo termine solucionando con unos if en ves de con while. Luego subo el programa modificado. Gracias por tu ayuda, luego lo veo con detenimiento. Saludos

 

D@rkbytes

Moderador
OK. Pero mira, hay algo que noto mal, yo no entiendo muy bien sobre esto de las revoluciones en un auto motor.
Pero si miras la frecuencia de la primer imagen, está en 491.197 Khz.
Lo cual multiplicado por 60, da; 29471.82 R.P.M
Ese rango se me hace bastante fuera de lo normal para emular la señal de CKP.
Si existiera el pulso de CMP con chispa perdida, supongo que obtendríamos ese pulso dividido entre 2
O sea; 14735.91 R.P.M, lo cual también se me hace excesivo.

Pero como mencioné, desconozco algo sobre éste tema.
 
aver deja pongo mi grano de arena.

ami el CCS me da problemas con sus directivas FAST IO y los output_high output_low.
asi que lo que hago es nombrar un PIN y usarlo como si fuera una variable.

ejemplo:

para nombrar el LAT en los pic 18f uso esto:

el pin D0 se llamara DATA

#bit DATA =GETENV("SFR:LATD").0

para los pic 16f es la directiva port

#bit DATA =GETENV("SFR:pORTD").0

en el caso de los PIC con GPIO es simple en este caso es pin 0:

#bit DATA =GETENV("SFR:GPIO").0

para declarar el TRIS en el caso de los pic 18f y 16f es el mismo:

#bit TRIS_DATA =GETENV("SFR:TRISD").0
en el caso de los GPIO cambia:

#bit TRIS_DATA =GETENV("SFR:TRISIO").0


ahora si un poco de ejemplo:


Código:
#include <16Fxxx.H>
#fuses INTRC_IO,NOBROWNOUT,NOMCLR
#use delay(bla bla bla) 

#bit LED =GETENV("SFR:LATD").0
#bit BOTON=GETENV("SFR:LATD").1
#bit TRIS_LED       =GETENV("SFR:TRISD").0
#bit TRIS_BOTON       =GETENV("SFR:TRISD").1

void main()
{
TRIS_LED=0; // es salida ;)
TRIS_BOTON=1; //es entrada       


while(1)
{
if(boton==1)
{
LED=1;
}
else=0;
}

}

en este caso ya no usamos directivas como input y output del CCS aver intentalo y cuenta que paso
 

D@rkbytes

Moderador
Sí, sí, sí. Ajá, o sea que no tiene sentido declarar cosas que se pueden hacer con instrucciones nativas.
Es decir, ¿Para qué declarar, un PORTA.0, cuando se puede definir con #define RA0 PIN_A0? (CCS C Compiler)

Bueno, eso pasa por venir de otros lenguajes y no conocer las directivas e instrucciones de un compilador de alto nivel.
Sin embargo, para un programador esos detalles nunca deben pasarse por alto y estar pendiente siempre en qué lenguaje estamos escribiendo un programa.
Yo manejo varios lenguajes de programación, no al 100% pero siempre veo sus respectivos cambios y trato de usar su sintaxis y sus optimizaciones.

¿Por qué? Porque un compilador es muy diferente de uno a otro, y por lo mismo uno debe estudiar bien a qué le tira, de forma de entender lo que uno pretende sobre lo que uno usa comúnmente.
No es lo mismo C que Ensamblador, ni lo mismo es C++, C# que Basic, Cobol, Delphi o Pascal y otras yerbas como Java o Phyton, que nada mas sirven para recordar lo que se te olvidó de C.

Yo digo... Realiza tu programa en el lenguaje que conozcas bien.
Con eso obtendrás buenos resultados. Al menos, predecibles.
 
Buenas....Primero que nada gracias por la ayuda, siempre viene bien una mirada objetiva desde alguien de afuera, y de la que no se enfrasca con el problema y mira lo que otro no ve. Mi forma de programar se que quizas no es la optimizada, pero bueno, aprendi sólo, a los ponchazos, sin nadie que me explique o diga como hacer tal y cual cosa, asi que siempre fue un prueba y error, pero estoy abierto a las sugerencias para mejorar como bien ustedes me lo marcan.
En cuanto a lo de la frecuencia, en eso te paso a explicar por que lo estas viendo mal. Los motores de los autos llevan en el eje del cigüeñal, una rueda fónica como la que muestro a continuación

Rueda fonica.jpg

Alli se puede apreciar que cuenta con una serie de dientes (los hay de 36, 60, 44, 40 y tantas variantes como fabricantes haya). Las más comunes acá en Argentina son las de 36 y 60 dientes. En la de 36 dientes como podrán ver en la siguente imagen le falta un diente, eso es lo que utiliza la computadora del auto (ECU) como referencia para ubicar los momentos de disparo de bujias (bobina) e inyectores.

Rueda 36 -1.jpg

Como bien dije tambien los hay de 60 dientes y 2 faltantes

Rueda 60 -2.jpg

Ahora bien, esto emula sólo la rueda fónica, para modelos de autos viejos, digo viejos en el sentido de aquellos que no traen el CMP (Sensor de posición del árbol de levas o Sensor de fase). Por lo tanto el periodo o frecuencia de la forma de onda arrnaca y termina con el diente faltante y no sólo como un tren de pulsos nada más, por eso es que se veia tan alta frecuencia, era porque analizabas los pulsos, pero en realidad la secuencia arranca con el primer diente y termina con el/los diente/s faltante/s

Señal sensor.png

Ahí se puede ver donde arranca y donde termina. Espero haberme hecho entender, ahora mirare el código que me adjuntaste, saludos

PD: Por aqui pueden ver un poco de los que les hable rápidamente
 
Última edición:

D@rkbytes

Moderador
En cuanto a lo de la frecuencia, en eso te paso a explicar por qué lo estás viendo mal.
Los motores de los autos llevan en el eje del cigüeñal, una rueda fónica como la que muestro a continuación.
OK. ¿Entonces de qué forma se determinan las revoluciones por minuto en este tipo de ruedas?
 
Para cuando el arbol de levas da 2 vueltas; cilindros 1 y 4 en la primer vuelta y 2 y 3 en la segunda vuelta; el cigueñal da solo 1 y es la que va a la caja de cambios. Por lo que cada vuelta del cigueñal esta determinada por una secuencia de pulsos, que pueden ser seudo-senoidal si el sensor es inductivo o digital si es de efecto hall. La vuelta se determina con la detección del diente faltante en la rueda, que se detecta como un estiramiento de la señal seudo-senoidal en el inductivo o como un nivel bajo mas largo que el resto de la secuencia si es de efecto hall.

 

D@rkbytes

Moderador
La vuelta se determina con la detección del diente faltante en la rueda, que se detecta como un estiramiento de la señal seudo-senoidal en el inductivo o como un nivel bajo mas largo que el resto de la secuencia si es de efecto hall.
Bien. Entonces supongo que la señal CMP es la que se genera en ese momento.
Y si cuento ese pulso podré obtener las revoluciones por minuto.
¿Es correcto?
 
D@rkbyte dijo:
Bien. Entonces supongo que la señal CMP es la que se genera en ese momento.
Y si cuento ese pulso podré obtener las revoluciones por minuto.
¿Es correcto?
Hay 2 sensores, el CKP y CMP, el que yo genero es el CKP y ya con ese basta para determinar las RPM, se mide el tiempo que tarda en dar una vuelta la rueda desde el diente 1 al 36/60 (que es donde ocurre la mueca de la rueda), determinandose el periodo, haciendo la inversa y multiplicando por 60 da las RPM. El sensor de fase o CMP no interviene en el calculo de las RPM, es más que nada para determinar el estado del arbol de leva y que asi la ECU pueda tener un mayor control en el avance (momento de disparo de los inyectores y bobina) del motor.
 
entonces las RPM se pueden medir por cigüeñal , cada X pulsos y el pulso sin diente es ahi la primer revolucion ,en el arbol de levas es cada 2 vuletas esperar 2 veces el diente chimuelo.

parece simple en realidad es generar los trenes de pulsos una vez generada la cantidad de pulsos hacer una espera del tiempo del engrane chimuelo.
 

D@rkbytes

Moderador
Entonces las RPM se pueden medir por cigüeñal, cada x pulsos y el pulso sin diente es ahí la primer revolucion.
En el árbol de levas es cada 2 vueltas, esperar 2 veces el diente chimuelo.
Así es cómo yo lo veo.
O sea que de alguna forma se deben obtener las R.P.M.
Ya sea contando el momento en donde faltan los dientes o generando otro pulso en ese momento.
Pero según he visto, ese pulso lleva un desface, lo cual no sería problema si se realiza por software.

Algo así...
Snap1.jpg
 
Última edición:
Resulta que no es tan facil hacer la señal del sensor de fase, ya que cada marca y cada modelo utilizan una señal de fase distinta, por ahi en una misma marca puede que 2 modelos distintos compartan la misma secuencia, pero entre marcas distintas no pasa, asi que hay que saber cada secuencia de cada marca para eso, en internet no están y la única forma de saberlas es tener el auto y medirla.

 

D@rkbytes

Moderador
Bueno, eso tampoco tendrá problema si se conecta un osciloscopio para ver las señales. ¿No?
Ya obtenidas, su emulación será sencilla y se hace una base de datos que pueda emular el microcontrolador.
 
pues yo he desarmado varios carros aveces el sensor de cigüeñal saca los pulsos de la polea del cigüeñal con un engrane dentado y su respectiva parte chimuela, tambien he visto que en lugar de un engrane usan un engrane que mueve la banda de distribucion y en entre el engrane y el damper llevan una lamina dentada con su engrane chumuelo.

otra y tambien comun es de la cremallera esta tambien dentada con su diente chumuelo.

lo que YO haria en ese caso si quiero emular los pulsos de CKP es simple.

genero los pulos digamos que el CKP deberia tener no se digamos 20 dientes en realidad 19 por el chimuelo.

entonces en el micro genero 1,2,3...,19 y un tiempo muerto de espera ¿no?

y si lo quiero para varias marcas de coche no se digamos que un toyota X tiene 40 dientes "39 " entonces le meto al micro el numero de dientes y le resto 1

entonces genero mis pulsos. no creo que sea lo mas exacto por que me han llegado al taller carros con sensores de cigüeñal pal perro, con la estrella del cigüeñal casi destruida y no se apagan.

entonces como emulador yo pondria un perido de señal cuadrada que fuera variable y numero de pulsos variables.

obviamente teniendo los parametros de CKP puedes generar los de CMP bien facil, pues es lo casi lo mismo solo dividido en 2
 
Si se puede hacer la base de datos como bien dices, llevara su tiempo ya que se necesita que vayan cayendo los coches que uno necesita, con tiempo y paciencia se logrará, pero por el momento para ir haciendo algo esto servirá. Para los modelos de coches viejos donde no traían el sensor de CMP esto anda bien.
En cuanto a lo de hacer variable lo de los dientes, no se si tiene mucho sentido, ya que tampoco es que hay tantas ruedas, con un switch case creo que alcanza. En cuanto a lo del sensor CMP para determinados modelos es como vos decís la señal, pero en otro no y cada cual tiene su forma, por lo que hacer la señal para un solo caso termina siendo muy particular. La pegada seria levantar la señal de muchos autos y ahí tiene otro color

 
Última edición:
bueno yo sigueria numero de dientes variables y de periodo variable, digo si quieres emular puedes enviar un comando por RS232 al emulador

ejemplo
que el micro pregunte
numero de dientes
numero de dientes faltantes
perido
¿comenzar?
si o no para corregir un parametro

digo ya que la cabeza tiene su CMP es la mitad de las revoluciones del cigüeñal podria hacerse togleando la señal una vez acabada la emulacion de CKP.

digo es un proyecto interesante que me estan dando ganas de fabricar uno :cool:
 
TRILO-BYTE dijo:
digo ya que la cabeza tiene su CMP es la mitad de las revoluciones del cigüeñal podria hacerse togleando la señal una vez acabada la emulacion de CKP.

Repito, no siempre son las mismas señales del sensor CMP, el que haya una relación de 1:2 entre el arbol de levas y el cigüeñal no significa que el sensor CMP entrege la mitad de pulsos que el CKP. Te adjunto algunas imagenes de estos sensores de distintos autos.

CPK vs CMP - 1.jpg

CPK vs CMP - 2.gif

CPK vs CMP - 3.jpg

CPK vs CMP - 4.jpg
CPK vs CMP - 5.jpg

CPK vs CMP - 6.jpg

CPK vs CMP - 7.jpg

CPK vs CMP - 8.jpg

CPK vs CMP - 9.jpg

CPK vs CMP - 10.gif

CPK vs CMP - 11.jpg

CPK vs CMP - 12.jpg

CPK vs CMP - 13.png

CPK vs CMP - 14.jpg

CPK vs CMP - 15.jpg

TRILO-BYTE dijo:
bueno yo sigueria numero de dientes variables y de periodo variable, digo si quieres emular puedes enviar un comando por RS232 al emulador

Pensa que este instrumento no solo lo utilizan en los talleres de inyección electrónica sino que también lo van a usar los mecanicos comunes que ni siquiera van a tener una computadora en el taller, creo que lo del RS232 al mecanico se la complicas, por los menos desde mi experiencia con los mecanicos de acá, no entienden la electrónica ni quiere enroscarse con ella. Por otro lado acá las ruedas más comunes y que abarcan el 90% o más de los casos son la de 60 - 2 y la de 36 - 1, por eso para mi caso no lo veo practico el ingresar cantidad de dientes y cuantos faltantes. El hecho de estableser un valor de periodo fijo no es los más recomendable ya que estableses un punto de trabajo en particular, realizando una prueba estática. Es mejor variar la frecuencia con un potenciometro, de esa forma obtienes un rango de trabajo dinámico y con variaciones suaves como pueden ocurrir en un motor al acelerar o desacelerar.
 
Última edición:
eso si es cierto en el taller tenemos un mecanico chambero, que por mas que uno le explica como usar el escaner no sabe solo sabe borrar codigos. :rolleyes:

y otro que es menos burro pero no sabe diagnosticar fallas en sensores de oxigeno, pero en fin estos instrumentos estan mas pensados en gente que tenga conocimientos tecnicos por que los radio tegnicos igual no rifan mucho.

respecto al arbol de levas si estaba viendo hoy uno y si tiene el encoder diferente ancho en sus dientes.

habria que hacer un banco de datos de varios coches y meterlos en el micro.

lo malo es que como mencione los mecanicos chamberos no piensan solo adivinan y con instrumentos mas tecnicos solo picarian botones hasta que de algo. :unsure:
 
Arriba