BIKEDUINO::: Arrêt Point Predictor pour cyclistes (3 / 6 étapes)

Étape 3: Étape 2: traiter la lecture du Dynamo et obtenir la vitesse, l’accélération et la DISTANCE

Vous devez acurate très précisément en comptant les impulsions, puis calbulate la vitesse, l’accélération et la DISTANCE.

Ici, vous obtenez le code.

Bikeduino, version 1
Permet à votre vélo de pointer un laser à l’endroit où elle défendra toujours si la décélération reste constante.

#include < Servo.h >

Servo servo ;

broche analogique
#define DYNAMO_PIN 5
broche numérique PWM
#define SERVO_PIN 10
broche numérique
#define LASER_PIN 11

fenêtre de temps moyenne de sample
#define WINDOW_SIZE 32
fenêtre de calcul de la moyenne d’accélération
#define AWINDOW_SIZE 8

l’angle à quel servo est orientée horizontalement
#define SERVO_STRAIGHT_ANGLE 140
le montant de milimeters le vélo se déplace dans une impulsion de la dynamo (mesurée)
#define mm_per_pulse 16
le montant de milimeters le laser est au-dessus du sol (sur le vélo)
#define bike_height 1030

void setup() {}
Serial.Begin(19200) ;
Serial.println ("Bikeduino version 1.") ;
servo.Attach(SERVO_PIN) ;
servo.Write(SERVO_STRAIGHT_ANGLE) ;
pinMode (LASER_PIN, sortie) ;
}

int q [WINDOW_SIZE] ;
int q_p = 0 ;

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

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

aq int [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 ;
long r = 0 ;
pour (i = 0; i < AWINDOW_SIZE; i ++) {}
r += aq [i] ;
}
Return (int) (r/AWINDOW_SIZE) ;
}

void wait_for_pulse() {}
/*
tandis que (digitalRead(DYNAMO_PIN)) {}
}
tandis que (! digitalRead(DYNAMO_PIN)) {}
}
*/
alors que {(analogRead(DYNAMO_PIN) < 300)
}
alors que {(analogRead(DYNAMO_PIN) > 300)
}
}

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

void laser_on() {}
digitalWrite (LASER_PIN, élevé) ;
}

int v_prev ;
unsigned long prev_t ;

void loop() {}
unsigned long t ;
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) ; accélération en mm/s ^ 2

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

Serial.Print ("t") ;
Serial.println(t) ;
Serial.Print ("dt maintenant:") ;
Serial.println(q[Q_p]) ;
Serial.Print ("av dt:") ;
Serial.println(DT) ;
Serial.Print (v ":") ;
Serial.println(v) ;
Serial.Print ("a:") ;
Serial.println(a) ;
Si (a == 0) {}
ne changez rien
}
ElseIf (un < 0) {}
Nous sommes ralentit, diriger le laser
laser_on() ;
int d = (int) (-sq((long) v) / a/2) ; longueur (mm) jusqu'à ce que la décélération en supposant statu quo demeure constante
double angle = (180.0/3.1416) * atan ((double) bike_height / d) ; angle entre laser et horizontale vers l’avant
servo.Write(SERVO_STRAIGHT_ANGLE-angle) ; changer le négatif pour un plus si votre servo tourne
Serial.println() ;
Serial.Print ("d:") ;

Serial.println(d) ;
Serial.Print ("angle:") ;
Serial.println(angle) ;

}
else {}
ne pas de ralentissement
laser_off() ;
servo.Write(SERVO_STRAIGHT_ANGLE) ; vers l’avant
}

}