Señales Pwm, Hall 60-2

Hola compañeros que tal?
Soy nuevo en el tema de Arduino y estoy interesado en hacer un probador de Ecus ( computadoras Automotriz)
Alguno sabe como puedo generar RPM.
Es señal hall o pwm .
Son 60-2.

Hola.
No tengo ni idea de las señales que admite una Ecu, pero ese tema ya se planteo antiguamente en este foro, le lo que alli se dice y ya sigues comentando por este hilo.
Generador de RPM
Saludos.

1 Like

Hola, igual que tú soy nuevo en esto pero te comento un poco lo que se…

El Arduino puede generar señales pwm de 0-5volts con una definición de 255 puntos entre el 0 y 5. Si requieres trabajar a mayor rango o con valores distintos a estos en voltage requieres un amplificador. Pero lo puedes integrar en Arduino.

1 Like

Hola que tal, muchas gracias por su respuestas …
La verda en el otro hilo que hablan de las rpm no esta especificado que necesita el compañero.
Yo estaría necesitando señales pwm de 0 a 5v con una frecuencia de 500 HZ Y necesito 60 pulsos altos menos 2 bajos.
Y otra señal de 36 pulsos altos menos 2 bajos.

Puedes usar librerías como Timer1.h por ejemplo que te permite definir una salida con un período determinado. La inversa del período es la frecuencia asi que 2 mseg es tu período.
Ahora no comprendo eso de 60 pulsos altos y 2 bajos.
Quiere decir que requieres en un periodo de 2mseg 62 pulsos, 60 altos y 2 bajos?
Haz un dibujo de como debería ser, porque pulsos bajos no se que son.


Amigo esa es una de las señales que necesito generar

Si la señal es tal como la muestras, el período del "pulso" largo es de 3 períodos de pulso corto.
Entonces cada 60 pulsos necesitas poner en bajo 3 anchos de pulso y en alto otros 3 anchos de pulso en alto.
Voy a suponer que la representación no se ajuste a lo que necesitas y efectivamente sean 2 pulsos.
Sin dudarlo usaría una interrupción para generar los pulsos (sean 2, 3 ó n).
La interrupción se tiene que disparar al doble que la frecuencia buscada (si quiero obtener 500 Hz a la salida tendría que dispararse cada 1 ms, o sea, 1 kHz).
En la interrupción generar el cambio de estado del pin en cada llamada pero cada 120 cambios (60 alto y 60 bajos) saltear 1 para mantener el estado actual (que debería ser bajo (LOW)), luego cambiar (de bajo a alto) saltear 1, y volver el contador a 0 para volver a generar los pulsos cortos.
Es mucho más sencillo de lo que suena. :wink:

Hola:
Este es el codigo. La frecuencia ha sido medida por frecuencimetro, no tengo osciloscopio para verla, pero creo que sale bien.

//Frecuencia 500Hz  pulsos según dibujo
int t = 494;
int y;
void setup() {
  pinMode (7, OUTPUT);

INICIO:
  //  1--pulso
  digitalWrite (7, HIGH);
  delayMicroseconds (t);
  digitalWrite (7, HIGH);
  delayMicroseconds (t);

  //-----Descomentar el que queramos
  //  for (y == 2; y <= 29; y++) { //Para 30 pulsos
  //  for (y == 2; y <= 59; y++) { //para 60 pulsos
  digitalWrite (7, HIGH);
  delayMicroseconds (t);
  digitalWrite (7, LOW);
  delayMicroseconds (t);
}

//  ultimo--pulso
digitalWrite (7, LOW);
delayMicroseconds (t);
digitalWrite (7, LOW);
delayMicroseconds (t);

goto INICIO;
}
void loop () {}

Saludos.

Lo que yo pienso es algo así

const byte PIN_OUT_602 = 2;
const byte PIN_OUT_362 = 3;

volatile byte contador_602 = 0;
volatile byte contador_362 = 0;
volatile byte estado_602 = 1;
volatile byte estado_362 = 1;

// ... lo que haga falta definir

void setup(){
  pinMode(PIN_OUT_602, OUTPUT);
  pinMode(PIN_OUT_362, OUTPUT);

// ... setear timer y lo demás que haga falta inicializar
}

En la rutina de interrupción del timer

void timer_ISR() {

  contador_602++;
  estado_602 = (contador_602 & 0x01);
  if(contador_602 == 121) estado_602 = 0;
  if(contador_602 == 124) estado_602 = 1;
  digitalWrite(PIN_OUT_602, estado_602);
  if(contador_602 == 124) contador_602 = 0;

  contador_362++;
  estado_362 = (contador_362 & 0x01);
  if(contador_362 == 73) estado_362 = 0;
  if(contador_362 == 76) estado_362 = 1;
  digitalWrite(PIN_OUT_362, estado_362);
  if(contador_362 == 76) contador_362 = 0;

}

Lo explico para una señal, la otra es igual.
Tengamos en cuenta que cada pulso implica 2 estados (alto bajo), voy a contar cambios de estado por lo tanto multiplico la cantidad de pulsos por 2.

Cada vez que se dispara la interrupción, se incrementa el contador de estados.

El estado refleja el bit0 del contador, que cambia en cada incremento, excepto cuando se alcanza el pulso en que la señal se debe invertir. Por eso el cambio forzado en dos ocasiones.

Llegado a la cantidad total de cambios de estado se reinicia el contador.

Lo único que resta es setear un timer para que dispare una interrupción cada 1 ms para obtener pulsos a 500 Hz.

No estoy seguro si interpreté bien lo de "2 bajos" (que según la imagen van seguidos de 2 altos), si no es correcto se puede modificar fácilmente.

Consulta por curiosidad: ¿La polea a simular tiene 60 dientes, un diente faltante y luego relleno el valle entre los 2 siguientes?