BIKEDUINO::: Predictor de punto de parada para los ciclistas (3 / 6 paso)

Paso 3: Paso 2: proceso de la lectura de la dinamo y obtener la velocidad, aceleración y distancia

Necesita bastante precisos muy exacto en el conteo de los pulsos y luego calbulate la velocidad, la aceleración y la distancia.

Aquí Obtén el código.

Bikeduino versión 1
Deja su bicicleta punto de un láser en el lugar donde estará si la desaceleración es constante.

#include < Servo.h >

Servo servo;

pin analógico
#define DYNAMO_PIN 5
pin digital PWM
#define SERVO_PIN 10
pin digital
#define LASER_PIN 11

ventana de tiempo del promedio de la muestra
#define WINDOW_SIZE 32
ventana promedio aceleración
#define AWINDOW_SIZE 8

el ángulo en que servo apunta horizontalmente
#define SERVO_STRAIGHT_ANGLE 140
la cantidad de milímetros la moto se mueve en un impulso de la dinamo (medida)
#define mm_per_pulse 16
la cantidad de milímetros el láser está por encima del suelo (en la bicicleta)
#define bike_height 1030

void setup() {}
Serial.Begin(19200);
Serial.println ("Bikeduino versión 1.");
servo.Attach(SERVO_PIN);
servo.Write(SERVO_STRAIGHT_ANGLE);
pinMode (LASER_PIN, salida);
}

int q [WINDOW_SIZE];
q_p int = 0;

void queue(int x) {}
Si (++ q_p > = WINDOW_SIZE)
q_p = 0;
q [q_p] = x;
}

int average_pulsetime() {}
int i;
largo r = 0;
para (i = 0; i < WINDOW_SIZE; i ++) {}
r += q [i];
}
Return (int) (r/WINDOW_SIZE);
}

int aq [AWINDOW_SIZE];
int aq_p = 0;

void aqueue(int x) {}
Si (++ aq_p > = AWINDOW_SIZE)
aq_p = 0;
AQ [aq_p] = x;
}

int average_acceleration() {}
int i;
largo r = 0;
para (i = 0; i < AWINDOW_SIZE; i ++) {}
r += aq [i];
}
Return (int) (r/AWINDOW_SIZE);
}

void wait_for_pulse() {}
/*
mientras (digitalRead(DYNAMO_PIN)) {}
}
mientras (! {digitalRead(DYNAMO_PIN))}
}
*/
mientras (analogRead(DYNAMO_PIN) < 300) {}
}
mientras (analogRead(DYNAMO_PIN) > 300) {}
}
}

void laser_off() {}
digitalWrite (LASER_PIN, bajo);
}

void laser_on() {}
digitalWrite (LASER_PIN, alto);
}

int v_prev;
prev_t largo sin firmar;

void loop() {}
t largo sin firmar;
int dt;
wait_for_pulse();
t = millis();
DT = t - prev_t;
Queue(DT);
prev_t = t;

DT = average_pulsetime();
int v = (1000 * mm_per_pulse) /dt; [v] = mm/s

int dv = v - v_prev;
v_prev = v;

int a = (int) ((1000*(long)dv) / dt); aceleración en m/s ^ 2

Aqueue(a);
Serial.println();
Serial.Print ("a:");
Serial.println(a);
un = average_acceleration();

Serial.Print ("t");
Serial.println(t);
Serial.Print ("despegue ahora:");
Serial.println(q[q_p]);
Serial.Print ("despegue av:");
Serial.println(DT);
Serial.Print ("v:");
Serial.println(v);
Serial.Print ("a:");
Serial.println(a);
Si (a == 0) {}
no cambiar nada
}
else if (< 0) {}
nos estamos frenando, apunte el láser
laser_on();
int d = (int) (-sq((long) v) / a/2); distancia (mm) hasta que la desaceleración que parada permanece constante
ángulo doble = (180.0/3.1416) * atan (bike_height (doble) / d); ángulo entre el láser y horizontal hacia adelante
servo.Write(SERVO_STRAIGHT_ANGLE-Angle); Cambie el signo menos a un plus si su servo se da vuelta alrededor
Serial.println();
Serial.Print ("d:");

Serial.println(d);
Serial.Print ("ángulo:");
Serial.println(Angle);

}
Else {}
no frenar
laser_off();
servo.Write(SERVO_STRAIGHT_ANGLE); ahora en adelante
}

}