Paso 2: El bosquejo del temporizador
Volviendo la atención el dibujo de PinewoodTimer, en primer lugar algunos parámetros claves se definen...
#define IR_THRESHOLD 200 / / auto detectar el umbral
#define STARTER_PIN / / a partir de interruptor de puerta = pin 2
#define QTI_PIN_OFFSET 5 / / carriles 0-2 = pernos de 5-7
#define NUM_LANES 3 / / número de carriles
#define TRACK_LENGTH 50 / / pies
#define escala 25 / / escala 1:25
#define espera 6000 / / ms para el tiempo de espera/reinicio de carrera
El IR_THRESHOLD debe establecerse dentro de la ventana definida por las condiciones ambientales de IR y QTI respuesta determinada con el bosquejo de PinewoodCalibrate. STARTER_PIN especifica el pin utilizado para el interruptor de la puerta de salida (al otro lado del interruptor está conectado a tierra) mientras que QTI_PIN_OFFSET determina las conexiones de pines de los sensores QTI. Varios seguimiento de configuraciones y tamaños de coche son compatibles con NUM_LANES, TRACK_LENGTH y escala. Finalmente, un tiempo de espera termina la carrera si, por ejemplo, un coche no termina o sólo dos coches carreras, etc..
La rutina de instalación sólo permite la terminal serie y establece el modo de pin para la puerta de arranqu.
void setup() {}
Serial.Begin(9600);
pinMode(STARTER_PIN,INPUT_PULLUP);
}
El bucle principal se comienza definiendo las variables utilizadas. El start_time es la base para el funcionamiento et (tiempo transcurrido) con la matriz finish_et [] guardar el tiempo de cada carril. La variable race_over cuenta cuántos coches han cruzado la línea de meta.
Después de borrar el finish_et [] para cada carril, "Listos..." aparece en el terminal y el bosquejo espera la carrera empezar. Cuando se abre el interruptor de arranque el bosquejo imprime "Go" y luego entrar en el bucle de tiempo principal. Dentro del bucle cada carril se comprueba la presencia de un rematador comparando su sensor QTI leyendo con el umbral. Una vez que se detecta un coche el tiempo transcurrido para lane se almacena. El bucle de temporización se ejecuta hasta que termine la carrera (es decir, coches de NUM_LANEs cruzan la línea de meta o se excede el tiempo de espera).
Incluir una declaración (comentada aquí) para mostrar el tiempo necesario para verificar todos los carriles, que a su vez determina cuántos carriles puede manejar el bosquejo. Observé el tiempo de lazo para una configuración de 3 carriles 9 y 10 milisegundos, o aproximadamente 3 milisegundos por carril. Si, por ejemplo, el tiempo por el carril es de 3 MS y un coche lleva 30 milisegundos para cruzar la línea de meta, el bosquejo puede apoyar teóricamente hasta 10 carriles. Sin embargo, un margen se deberá acomodar, por ejemplo, un coche especialmente rápido (o corto). Para realmente probar la capacidad del carril puede aumentar NUM_LANES y ejecutar ensayos repetidos para determinar en qué momento comenzará a 'perder' un coche rápido, cruzando la línea de meta. Tenga en cuenta que usted puede hacer esto para cualquier NUM_LANES utilizando sólo un único coche/carril.
void loop() {}
largo start_time, et = 0, finish_et [NUM_LANES];
int race_over = 0;
int i;
para (i = 0; i < NUM_LANES; i ++) {}
finish_et [i] = 0;
}
Serial.println("Ready...");
mientras (digitalRead(STARTER_PIN)==0) {}
}
Serial.println("Go!");
start_time = millis();
mientras que ((race_over < NUM_LANES) & & (et < TIMEOUT)) {}
et = millis ()-start_time;
para (i = 0; i
Si (RCTime (+ QTI_PIN_OFFSET) < IR_THRESHOLD) {}
Si (finish_et [i] == 0) {}
finish_et [i] = y;
race_over ++;
}
}
}
Serial.println(Millis()-(et+start_time));
}
Una vez terminada la carrera se muestra el tiempo de finalización para cada carril. Usando el TRACK_LENGTH y escala también muestra la velocidad media en la escala de millas por hora (gente se excitan cuando su coche va 250 MPH: =). Después se muestran los resultados de la carrera el bosquejo espera a la puerta de salida cerrar en preparación para la próxima carrera. La instrucción delay asegura la puerta de salida interruptor rebote no activen un reinicio inmediato.
Serial.println();
para (i = 0; i
Serial.Print ("carril");
Serial.println(i+1);
Serial.Print ("tiempo");
Serial.println(float(finish_et[i]/1000.0));
Serial.Print ("velocidad");
flotador de fps = TRACK_LENGTH/(finish_et[i]/1000.0);
flotador mph = ((fps * 3600.0) / 5280.0) * escala;
Serial.Print(int(mph));
Serial.println ("MPH");
Serial.println();
}
mientras que (digitalRead(STARTER_PIN)! = 0) {}
Delay(50);
}
Todo lo que queda es la rutina de RCTime cortesía de paralaje (http://learn.parallax.com/KickStart/555-27401), que adquiere la lectura del sensor QTI. Funciona midiendo el tiempo de descarga de un condensador a través de un resistor variable (dependiendo de la cantidad de IR reflejada).
{} (int sensorIn) de largo RCTime
duración = 0;
pinMode (sensorIn, salida); Hacer pin salida
digitalWrite (sensorIn, HIGH); Perno de alta (descarga de condensador)
Delay(1); Esperar 1ms
pinMode (sensorIn, entrada); Hacer pin entrada
digitalWrite (sensorIn, bajo); Apagar pullups interno
while(digitalRead(sensorIn)) {/ / espere pin ir bajo
duración ++;
}
vuelta duración;
}
