use callback

gripper/firmware/interfaces_z_motor.cpp

@@ -196,27 +196,24 @@ static motor_handler::MotorInterruptHandler motor_interrupt(
 static auto encoder_background_timer =
     motor_encoder::BackgroundTimer(motor_interrupt, motor_hardware_iface);
 
-extern "C" void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin) {
-    // disengage motor whenever estop is engaged
-    if (GPIO_Pin == ESTOP_IN_PIN) {
-        z_motor.motion_controller.disable_motor();
-    }
-}
-
 /**
  * Timer callback.
  */
 extern "C" void call_motor_handler(void) { motor_interrupt.run_interrupt(); }
 extern "C" void call_enc_handler(int32_t direction) {
     motor_hardware_iface.encoder_overflow(direction);
 }
+extern "C" void disengage_z_callback_glue(void) {
+    motor_hardware_iface.deactivate_motor();
+}
 
 void z_motor_iface::initialize() {
     if (initialize_spi() != HAL_OK) {
         Error_Handler();
     }
     initialize_hardware_z();
-    set_z_motor_timer_callback(call_motor_handler, call_enc_handler);
+    set_z_motor_timer_callback(call_motor_handler, call_enc_handler,
+                               disengage_z_callback_glue);
     encoder_background_timer.start();
 }
 

gripper/firmware/motor_hardware.h

@@ -32,14 +32,16 @@ extern TIM_HandleTypeDef htim8;
 
 typedef void (*motor_interrupt_callback)();
 typedef void (*z_encoder_overflow_callback)(int32_t);
+typedef void (*z_motor_disengage_callback)();
 
 
 HAL_StatusTypeDef initialize_spi();
 void initialize_hardware_z();
 
 void set_z_motor_timer_callback(
         motor_interrupt_callback callback,
-        z_encoder_overflow_callback enc_callback);
+        z_encoder_overflow_callback enc_callback,
+        z_motor_disengage_callback disengage_callback);
 
 
 // G motor specific

gripper/firmware/motor_hardware_shared.c

@@ -9,13 +9,16 @@ static encoder_overflow_callback gripper_enc_overflow_callback = NULL;
 static encoder_idle_state_callback gripper_enc_idle_state_overflow_callback =
     NULL;
 static stopwatch_overflow_callback gripper_force_stopwatch_overflow_callback = NULL;
+static z_motor_disengage_callback disengage_z_callback = NULL;
 
 
 void set_z_motor_timer_callback(
         motor_interrupt_callback callback,
-        z_encoder_overflow_callback enc_callback) {
+        z_encoder_overflow_callback enc_callback,
+        z_motor_disengage_callback disengage_callback) {
     timer_callback = callback;
     z_enc_overflow_callback = enc_callback;
+    disengage_z_callback = disengage_callback;
 }
 
 void set_brushed_motor_timer_callback(
@@ -214,3 +217,8 @@ void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef* htim) {
 }
 
 
+void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin) {
+    if (GPIO_Pin == Z_MOT_ENABLE_PIN && disengage_z_callback) {
+        disengage_z_callback();
+    }
+}

head/firmware/main_rev1.cpp

@@ -341,6 +341,10 @@ extern "C" void left_enc_overflow_callback_glue(int32_t direction) {
 extern "C" void right_enc_overflow_callback_glue(int32_t direction) {
     motor_hardware_right.encoder_overflow(direction);
 }
+extern "C" void motor_disengage_callback_glue() {
+    motor_hardware_left.deactivate_motor();
+    motor_hardware_right.deactivate_motor();
+}
 
 static auto psd = presence_sensing_driver::PresenceSensingHardware{
     gpio::PinConfig{// NOLINTNEXTLINE(cppcoreguidelines-pro-type-cstyle-cast)
@@ -411,22 +415,15 @@ class EEPromHardwareInterface
 };
 static auto eeprom_hw_iface = EEPromHardwareInterface();
 
-extern "C" void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin) {
-    // disengage motor whenever estop is engaged
-    if (GPIO_Pin == pin_configurations_left.estop_in.pin) {
-        motor_left.motion_controller.disable_motor();
-        motor_right.motion_controller.disable_motor();
-    }
-}
-
 auto main() -> int {
     HardwareInit();
     RCC_Peripheral_Clock_Select();
 
     app_update_clear_flags();
 
     initialize_timer(motor_callback_glue, left_enc_overflow_callback_glue,
-                     right_enc_overflow_callback_glue);
+                     right_enc_overflow_callback_glue,
+                     motor_disengage_callback_glue);
 
     i2c_setup(&i2c_handles);
     i2c_comms3.set_handle(i2c_handles.i2c3);

head/firmware/motor_hardware.h

@@ -14,10 +14,13 @@ extern TIM_HandleTypeDef htim3;
 
 typedef void (*motor_interrupt_callback)();
 typedef void (*encoder_overflow_callback)(int32_t);
+typedef void (*disable_motor_callback)();
+
 HAL_StatusTypeDef initialize_spi(SPI_HandleTypeDef* hspi);
 void initialize_timer(motor_interrupt_callback callback,
                       encoder_overflow_callback left_enc_overflow_callback,
-                      encoder_overflow_callback right_enc_overflow_callback);
+                      encoder_overflow_callback right_enc_overflow_callback,
+                      disable_motor_callback disengage_callback);
 void initialize_rev_specific_pins();
 
 #ifdef __cplusplus

head/firmware/motor_hardware_common.c

@@ -22,6 +22,8 @@ motor_interrupt_callback motor_callback = NULL;
 encoder_overflow_callback left_enc_overflow_callback = NULL;
 encoder_overflow_callback right_enc_overflow_callback = NULL;
 
+disable_motor_callback motor_disengage_callback = NULL;
+
 void HAL_SPI_MspInit(SPI_HandleTypeDef *hspi) {
     GPIO_InitTypeDef GPIO_InitStruct = {0};
     if (hspi->Instance == SPI2) {
@@ -334,12 +336,21 @@ void HAL_TIM_Encoder_MspInit(TIM_HandleTypeDef *htim) {
     }
 }
 
+void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin) {
+    // disengage motor whenever estop is engaged
+    if (GPIO_Pin == GPIO_PIN_4 && motor_disengage_callback) {
+        motor_disengage_callback();
+    }
+}
+
 void initialize_timer(motor_interrupt_callback callback,
                       encoder_overflow_callback l_f_callback,
-                      encoder_overflow_callback r_f_callback) {
+                      encoder_overflow_callback r_f_callback,
+                      disable_motor_callback disengage_callback) {
     motor_callback = callback;
     left_enc_overflow_callback = l_f_callback;
     right_enc_overflow_callback = r_f_callback;
+    motor_disengage_callback = disengage_callback;
     MX_GPIO_Init();
     Encoder_GPIO_Init();
     encoder_init(&htim2);