Tabla de contenido
concepto
La función principal del módulo Guardian es monitorear el estado del sistema de conducción automática. Cuando el módulo falla, cortará activamente la salida del comando de control y frenará.
Es un poco como un fusible, con un mecanismo de respaldo.
Hay dos condiciones de activación principales para el módulo guardián.
- El intervalo de mensajes para informar sobre el estado del módulo supera los kSecondsTillTimeout (2,5 segundos)
- Si hay un campo safety_mode_trigger_time en el mensaje de estado informado, la adquisición se activará en este momento.
Los pasos del modo de seguridad se dividen en 2 pasos. El primer paso requiere frenado de emergencia o detección ultrasónica de obstáculos en el mensaje de estado. Si se detecta un obstáculo, significa que el automóvil está muy cerca del obstáculo. Esta detección se llama una detección activada por hardware.Debido a que se ha encontrado la falla del módulo y el obstáculo está muy cerca, los frenos se acelerarán. El segundo paso es el frenado normal, el frenado no es tan urgente.
Guardian es un módulo de cronometraje, por lo que se enviarán mensajes en el proceso hasta que el vehículo se detenga.
El código de la versión actual protege la detección ultrasónica anterior.
La frecuencia del módulo guardián es de 10 ms, por lo que el retardo máximo del comando de control se incrementará en 10 ms.
el código
class GuardianComponent : public apollo::cyber::TimerComponent {
public:
bool Init() override;
bool Proc() override;
private:
void PassThroughControlCommand();
void TriggerSafetyMode();
apollo::guardian::GuardianConf guardian_conf_;
apollo::canbus::Chassis chassis_;
apollo::monitor::SystemStatus system_status_;
apollo::control::ControlCommand control_cmd_;
apollo::guardian::GuardianCommand guardian_cmd_;
double last_status_received_s_{};
std::shared_ptr<apollo::cyber::Reader<apollo::canbus::Chassis>>
chassis_reader_;
std::shared_ptr<apollo::cyber::Reader<apollo::control::ControlCommand>>
control_cmd_reader_;
std::shared_ptr<apollo::cyber::Reader<apollo::monitor::SystemStatus>>
system_status_reader_;
std::shared_ptr<apollo::cyber::Writer<apollo::guardian::GuardianCommand>>
guardian_writer_;
std::mutex mutex_;
};
bool GuardianComponent::Proc() {
constexpr double kSecondsTillTimeout(2.5);
bool safety_mode_triggered = false;
if (guardian_conf_.guardian_enable()) {
std::lock_guard<std::mutex> lock(mutex_);
if (Time::Now().ToSecond() - last_status_received_s_ >
kSecondsTillTimeout) {
safety_mode_triggered = true;
}
safety_mode_triggered =
safety_mode_triggered || system_status_.has_safety_mode_trigger_time();
}
if (safety_mode_triggered) {
ADEBUG << "Safety mode triggered, enable safety mode";
TriggerSafetyMode();
} else {
ADEBUG << "Safety mode not triggered, bypass control command";
PassThroughControlCommand();
}
common::util::FillHeader(node_->Name(), &guardian_cmd_);
guardian_writer_->Write(guardian_cmd_);
return true;
}analizar
La función principal es Proc.
puede ser visto
if (Time::Now().ToSecond() - last_status_received_s_ >
kSecondsTillTimeout) {
safety_mode_triggered = true;
}Determinará si el monitor ha superado el tiempo de espera, y si el monitor ha superado el tiempo de espera, frenará directamente.
La otra es juzgar si hay un campo safety_mode_trigger_time en system_state informado por summary_monitor en el monitor.Si hay safety_mode_triggered, configúrelo en True y llame al modo de seguridad para que se haga cargo.
El modo seguro aquí es llamado por la función TriggerSafetyMode.
Finalmente, se llamará a set_brake para ejecutar guardian_cmd_emergency_stop_percentage mode parking o guardian_cmd_soft_stop_percentage parking.
La diferencia entre los dos modos de estacionamiento es que la fuerza de estacionamiento configurada es diferente, por lo que reciben el nombre de comodidad.