[airborne] use math functions instead of macros

sed to the rescue:
find sw -path sw/airborne/math -prune -o -name "*.[ch]" -exec sed -i 's/\([ ]*[A-Z0-9_]*QUAT_OF[A-Z0-9_]*(\)\([a-zA-Z0-9_]*,[ ]*\)\([a-zA-Z0-9_]*)\)/\L\1\E\&\2\&\3/g' {} +
and so on...

sw/airborne/firmwares/fixedwing/guidance/energy_ctrl.c

@@ -347,7 +347,7 @@ void v_ctl_climb_loop( void )
 #ifndef SITL
   struct Int32Vect3 accel_meas_body;
   struct Int32RMat *body_to_imu_rmat = orientationGetRMat_i(&imu.body_to_imu);
-  INT32_RMAT_TRANSP_VMULT(accel_meas_body, *body_to_imu_rmat, imu.accel);
+  int32_rmat_transp_vmult(&accel_meas_body, body_to_imu_rmat, &imu.accel);
   float vdot = ACCEL_FLOAT_OF_BFP(accel_meas_body.x) / 9.81f - sinf(stateGetNedToBodyEulers_f()->theta);
 #else
   float vdot = 0;

sw/airborne/firmwares/rotorcraft/guidance/guidance_v.c

@@ -340,7 +340,7 @@ static int32_t get_vertical_thrust_coeff(void) {
 
   struct Int32RMat* att = stateGetNedToBodyRMat_i();
   /* thrust vector:
-   *  INT32_RMAT_VMULT(thrust_vect, att, zaxis)
+   *  int32_rmat_vmult(&thrust_vect, &att, &zaxis)
    * same as last colum of rmat with INT32_TRIG_FRAC
    * struct Int32Vect thrust_vect = {att.m[2], att.m[5], att.m[8]};
    *

sw/airborne/firmwares/rotorcraft/navigation.c

@@ -227,7 +227,7 @@ void nav_circle(struct EnuCoor_i * wp_center, int32_t radius) {
     // store last qdr
     int32_t last_qdr = nav_circle_qdr;
     // compute qdr
-    INT32_ATAN2(nav_circle_qdr, pos_diff.y, pos_diff.x);
+    nav_circle_qdr = int32_atan2(pos_diff.y, pos_diff.x);
     // increment circle radians
     if (nav_circle_radians != 0) {
       int32_t angle_diff = nav_circle_qdr - last_qdr;

sw/airborne/firmwares/rotorcraft/stabilization/stabilization_attitude_quat_float.c

@@ -293,9 +293,9 @@ void stabilization_attitude_run(bool_t enable_integrator) {
   /* attitude error                          */
   struct FloatQuat att_err;
   struct FloatQuat* att_quat = stateGetNedToBodyQuat_f();
-  FLOAT_QUAT_INV_COMP(att_err, *att_quat, stab_att_ref_quat);
+  float_quat_inv_comp(&att_err, att_quat, &stab_att_ref_quat);
   /* wrap it in the shortest direction       */
-  FLOAT_QUAT_WRAP_SHORTEST(att_err);
+  float_quat_wrap_shortest(&att_err);
 
   /*  rate error                */
   struct FloatRates rate_err;
@@ -313,10 +313,10 @@ void stabilization_attitude_run(bool_t enable_integrator) {
     scaled_att_err.qx = att_err.qx / IERROR_SCALE;
     scaled_att_err.qy = att_err.qy / IERROR_SCALE;
     scaled_att_err.qz = att_err.qz / IERROR_SCALE;
-    FLOAT_QUAT_COMP(new_sum_err, stabilization_att_sum_err_quat, scaled_att_err);
-    FLOAT_QUAT_NORMALIZE(new_sum_err);
+    float_quat_comp(&new_sum_err, &stabilization_att_sum_err_quat, &scaled_att_err);
+    float_quat_normalize(&new_sum_err);
     QUAT_COPY(stabilization_att_sum_err_quat, new_sum_err);
-    FLOAT_EULERS_OF_QUAT(stabilization_att_sum_err, stabilization_att_sum_err_quat);
+    float_eulers_of_quat(&stabilization_att_sum_err, &stabilization_att_sum_err_quat);
   } else {
     /* reset accumulator */
     float_quat_identity(&stabilization_att_sum_err_quat);
@@ -346,5 +346,5 @@ void stabilization_attitude_run(bool_t enable_integrator) {
 void stabilization_attitude_read_rc(bool_t in_flight, bool_t in_carefree, bool_t coordinated_turn) {
 
   stabilization_attitude_read_rc_setpoint_quat_f(&stab_att_sp_quat, in_flight, in_carefree, coordinated_turn);
-  //FLOAT_QUAT_WRAP_SHORTEST(stab_att_sp_quat);
+  //float_quat_wrap_shortest(&stab_att_sp_quat);
 }

sw/airborne/firmwares/rotorcraft/stabilization/stabilization_attitude_quat_int.c

@@ -230,8 +230,8 @@ void stabilization_attitude_run(bool_t enable_integrator) {
   struct Int32Quat* att_quat = stateGetNedToBodyQuat_i();
   INT32_QUAT_INV_COMP(att_err, *att_quat, stab_att_ref_quat);
   /* wrap it in the shortest direction       */
-  INT32_QUAT_WRAP_SHORTEST(att_err);
-  INT32_QUAT_NORMALIZE(att_err);
+  int32_quat_wrap_shortest(&att_err);
+  int32_quat_normalize(&att_err);
 
   /*  rate error                */
   const struct Int32Rates rate_ref_scaled = {
@@ -250,10 +250,10 @@ void stabilization_attitude_run(bool_t enable_integrator) {
     scaled_att_err.qx = att_err.qx / IERROR_SCALE;
     scaled_att_err.qy = att_err.qy / IERROR_SCALE;
     scaled_att_err.qz = att_err.qz / IERROR_SCALE;
-    INT32_QUAT_COMP(new_sum_err, stabilization_att_sum_err_quat, scaled_att_err);
-    INT32_QUAT_NORMALIZE(new_sum_err);
+    int32_quat_comp(&new_sum_err, &stabilization_att_sum_err_quat, &scaled_att_err);
+    int32_quat_normalize(&new_sum_err);
     QUAT_COPY(stabilization_att_sum_err_quat, new_sum_err);
-    INT32_EULERS_OF_QUAT(stabilization_att_sum_err, stabilization_att_sum_err_quat);
+    int32_eulers_of_quat(&stabilization_att_sum_err, &stabilization_att_sum_err_quat);
   } else {
     /* reset accumulator */
     int32_quat_identity(&stabilization_att_sum_err_quat);

sw/airborne/firmwares/rotorcraft/stabilization/stabilization_attitude_quat_transformations.c

@@ -39,7 +39,7 @@ void quat_from_rpy_cmd_f(struct FloatQuat *quat, struct FloatEulers *rpy) {
   /* orientation vector describing simultaneous rotation of roll/pitch/yaw */
   const struct FloatVect3 ov = {rpy->phi, rpy->theta, rpy->psi};
   /* quaternion from that orientation vector */
-  FLOAT_QUAT_OF_ORIENTATION_VECT(*quat, ov);
+  float_quat_of_orientation_vect(quat, &ov);
 
 }
 
@@ -67,11 +67,11 @@ void quat_from_earth_cmd_f(struct FloatQuat *quat, struct FloatVect2 *cmd, float
   const struct FloatVect3 ov = {cmd->y, -cmd->x, 0.0};
   /* quaternion from that orientation vector */
   struct FloatQuat q_rp;
-  FLOAT_QUAT_OF_ORIENTATION_VECT(q_rp, ov);
+  float_quat_of_orientation_vect(&q_rp, &ov);
 
   /* as rotation matrix */
   struct FloatRMat R_rp;
-  FLOAT_RMAT_OF_QUAT(R_rp, q_rp);
+  float_rmat_of_quat(&R_rp, &q_rp);
   /* body x-axis (before heading command) is first column */
   struct FloatVect3 b_x;
   VECT3_ASSIGN(b_x, R_rp.m[0], R_rp.m[3], R_rp.m[6]);
@@ -124,8 +124,8 @@ void quat_from_earth_cmd_f(struct FloatQuat *quat, struct FloatVect2 *cmd, float
   QUAT_ASSIGN(q_yaw, cosf(yaw2), 0.0, 0.0, sinf(yaw2));
 
   /* final setpoint: apply roll/pitch, then yaw around resulting body z-axis */
-  FLOAT_QUAT_COMP(*quat, q_rp, q_yaw);
-  FLOAT_QUAT_NORMALIZE(*quat);
-  FLOAT_QUAT_WRAP_SHORTEST(*quat);
+  float_quat_comp(quat, &q_rp, &q_yaw);
+  float_quat_normalize(quat);
+  float_quat_wrap_shortest(quat);
 
 }

sw/airborne/firmwares/rotorcraft/stabilization/stabilization_attitude_rc_setpoint.c

@@ -298,7 +298,7 @@ void stabilization_attitude_read_rc_roll_pitch_quat_f(struct FloatQuat* q) {
   ov.z = 0.0;
 
   /* quaternion from that orientation vector */
-  FLOAT_QUAT_OF_ORIENTATION_VECT(*q, ov);
+  float_quat_of_orientation_vect(q, &ov);
 }
 
 /** Read roll/pitch command from RC as quaternion.
@@ -317,7 +317,7 @@ void stabilization_attitude_read_rc_roll_pitch_earth_quat_f(struct FloatQuat* q)
   float qy_pitch = sinf(pitch2);
   float qi_pitch = cosf(pitch2);
 
-  /* only multiply non-zero entries of FLOAT_QUAT_COMP(*q, q_roll, q_pitch) */
+  /* only multiply non-zero entries of float_quat_comp(q, &q_roll, &q_pitch) */
   q->qi = qi_roll * qi_pitch;
   q->qx = qx_roll * qi_pitch;
   q->qy = qi_roll * qy_pitch;
@@ -351,33 +351,33 @@ void stabilization_attitude_read_rc_setpoint_quat_f(struct FloatQuat* q_sp, bool
   //Care Free mode
   if (in_carefree) {
     //care_free_heading has been set to current psi when entering care free mode.
-    FLOAT_QUAT_OF_AXIS_ANGLE(q_yaw, zaxis, care_free_heading);
+    float_quat_of_axis_angle(&q_yaw, &zaxis, care_free_heading);
   }
   else {
-    FLOAT_QUAT_OF_AXIS_ANGLE(q_yaw, zaxis, stateGetNedToBodyEulers_f()->psi);
+    float_quat_of_axis_angle(&q_yaw, &zaxis, stateGetNedToBodyEulers_f()->psi);
   }
 
   /* roll/pitch commands applied to to current heading */
   struct FloatQuat q_rp_sp;
-  FLOAT_QUAT_COMP(q_rp_sp, q_yaw, q_rp_cmd);
-  FLOAT_QUAT_NORMALIZE(q_rp_sp);
+  float_quat_comp(&q_rp_sp, &q_yaw, &q_rp_cmd);
+  float_quat_normalize(&q_rp_sp);
 
   if (in_flight)
   {
     /* get current heading setpoint */
     struct FloatQuat q_yaw_sp;
 #if defined STABILIZATION_ATTITUDE_TYPE_INT
-    FLOAT_QUAT_OF_AXIS_ANGLE(q_yaw_sp, zaxis, ANGLE_FLOAT_OF_BFP(stab_att_sp_euler.psi));
+    float_quat_of_axis_angle(&q_yaw_sp, &zaxis, ANGLE_FLOAT_OF_BFP(stab_att_sp_euler.psi));
 #else
-    FLOAT_QUAT_OF_AXIS_ANGLE(q_yaw_sp, zaxis, stab_att_sp_euler.psi);
+    float_quat_of_axis_angle(&q_yaw_sp, &zaxis, stab_att_sp_euler.psi);
 #endif
 
     /* rotation between current yaw and yaw setpoint */
     struct FloatQuat q_yaw_diff;
-    FLOAT_QUAT_COMP_INV(q_yaw_diff, q_yaw_sp, q_yaw);
+    float_quat_comp_inv(&q_yaw_diff, &q_yaw_sp, &q_yaw);
 
     /* compute final setpoint with yaw */
-    FLOAT_QUAT_COMP_NORM_SHORTEST(*q_sp, q_rp_sp, q_yaw_diff);
+    float_quat_comp_norm_shortest(q_sp, &q_rp_sp, &q_yaw_diff);
   } else {
     QUAT_COPY(*q_sp, q_rp_sp);
   }
@@ -403,21 +403,21 @@ void stabilization_attitude_read_rc_setpoint_quat_earth_bound_f(struct FloatQuat
     struct FloatQuat q_yaw_sp;
 
     #if defined STABILIZATION_ATTITUDE_TYPE_INT
-    FLOAT_QUAT_OF_AXIS_ANGLE(q_yaw_sp, zaxis, ANGLE_FLOAT_OF_BFP(stab_att_sp_euler.psi));
+    float_quat_of_axis_angle(&q_yaw_sp, &zaxis, ANGLE_FLOAT_OF_BFP(stab_att_sp_euler.psi));
     #else
-    FLOAT_QUAT_OF_AXIS_ANGLE(q_yaw_sp, zaxis, stab_att_sp_euler.psi);
+    float_quat_of_axis_angle(&q_yaw_sp, &zaxis, stab_att_sp_euler.psi);
     #endif
 
-    FLOAT_QUAT_COMP(*q_sp, q_yaw_sp, q_rp_cmd);
+    float_quat_comp(q_sp, &q_yaw_sp, &q_rp_cmd);
   }
   else {
     struct FloatQuat q_yaw;
-    FLOAT_QUAT_OF_AXIS_ANGLE(q_yaw, zaxis, stateGetNedToBodyEulers_f()->psi);
+    float_quat_of_axis_angle(&q_yaw, &zaxis, stateGetNedToBodyEulers_f()->psi);
 
     /* roll/pitch commands applied to to current heading */
     struct FloatQuat q_rp_sp;
-    FLOAT_QUAT_COMP(q_rp_sp, q_yaw, q_rp_cmd);
-    FLOAT_QUAT_NORMALIZE(q_rp_sp);
+    float_quat_comp(&q_rp_sp, &q_yaw, &q_rp_cmd);
+    float_quat_normalize(&q_rp_sp);
 
     QUAT_COPY(*q_sp, q_rp_sp);
   }

sw/airborne/firmwares/rotorcraft/stabilization/stabilization_attitude_ref_quat_float.c

@@ -69,9 +69,9 @@ static inline void reset_psi_ref_from_body(void) {
 
 static inline void update_ref_quat_from_eulers(void) {
   struct FloatRMat ref_rmat;
-  FLOAT_RMAT_OF_EULERS(ref_rmat, stab_att_ref_euler);
-  FLOAT_QUAT_OF_RMAT(stab_att_ref_quat, ref_rmat);
-  FLOAT_QUAT_WRAP_SHORTEST(stab_att_ref_quat);
+  float_rmat_of_eulers(&ref_rmat, &stab_att_ref_euler);
+  float_quat_of_rmat(&stab_att_ref_quat, &ref_rmat);
+  float_quat_wrap_shortest(&stab_att_ref_quat);
 }
 
 void stabilization_attitude_ref_idx_set_omega_p(uint8_t idx, float omega) {
@@ -143,18 +143,18 @@ void stabilization_attitude_ref_update(void) {
   /* integrate reference attitude            */
 #if STABILIZATION_ATTITUDE_REF_QUAT_INFINITESIMAL_STEP
   struct FloatQuat qdot;
-  FLOAT_QUAT_DERIVATIVE(qdot, stab_att_ref_rate, stab_att_ref_quat);
+  float_quat_derivative(&qdot, &stab_att_ref_rate, &stab_att_ref_quat);
   QUAT_SMUL(qdot, qdot, DT_UPDATE);
   QUAT_ADD(stab_att_ref_quat, qdot);
 #else // use finite step (involves trig)
   struct FloatQuat delta_q;
-  FLOAT_QUAT_DIFFERENTIAL(delta_q, stab_att_ref_rate, DT_UPDATE);
+  float_quat_differential(&delta_q, &stab_att_ref_rate, DT_UPDATE);
   /* compose new ref_quat by quaternion multiplication of delta rotation and current ref_quat */
   struct FloatQuat new_ref_quat;
-  FLOAT_QUAT_COMP(new_ref_quat, stab_att_ref_quat, delta_q);
+  float_quat_comp(&new_ref_quat, &stab_att_ref_quat, &delta_q);
   QUAT_COPY(stab_att_ref_quat, new_ref_quat);
 #endif
-  FLOAT_QUAT_NORMALIZE(stab_att_ref_quat);
+  float_quat_normalize(&stab_att_ref_quat);
 
   /* integrate reference rotational speeds   */
   struct FloatRates delta_rate;
@@ -164,9 +164,9 @@ void stabilization_attitude_ref_update(void) {
   /* compute reference angular accelerations */
   struct FloatQuat err;
   /* compute reference attitude error        */
-  FLOAT_QUAT_INV_COMP(err, stab_att_sp_quat, stab_att_ref_quat);
+  float_quat_inv_comp(&err, &stab_att_sp_quat, &stab_att_ref_quat);
   /* wrap it in the shortest direction       */
-  FLOAT_QUAT_WRAP_SHORTEST(err);
+  float_quat_wrap_shortest(&err);
   /* propagate the 2nd order linear model: xdotdot = -2*zeta*omega*xdot - omega^2*x  */
   /* since error quaternion contains the half-angles we get 2*omega^2*err */
   stab_att_ref_accel.p = -2.*stab_att_ref_model[ref_idx].zeta.p*stab_att_ref_model[ref_idx].omega.p*stab_att_ref_rate.p
@@ -185,5 +185,5 @@ void stabilization_attitude_ref_update(void) {
   SATURATE_SPEED_TRIM_ACCEL();
 
   /* compute ref_euler */
-  FLOAT_EULERS_OF_QUAT(stab_att_ref_euler, stab_att_ref_quat);
+  float_eulers_of_quat(&stab_att_ref_euler, &stab_att_ref_quat);
 }

sw/airborne/firmwares/rotorcraft/stabilization/stabilization_attitude_ref_quat_int.c

@@ -149,8 +149,8 @@ void stabilization_attitude_ref_enter(void)
   /* convert reference attitude with REF_ANGLE_FRAC to eulers with normal INT32_ANGLE_FRAC */
   struct Int32Eulers ref_eul;
   INT32_EULERS_RSHIFT(ref_eul, stab_att_ref_euler, (REF_ANGLE_FRAC - INT32_ANGLE_FRAC));
-  INT32_QUAT_OF_EULERS(stab_att_ref_quat, ref_eul);
-  INT32_QUAT_WRAP_SHORTEST(stab_att_ref_quat);
+  int32_quat_of_eulers(&stab_att_ref_quat, &ref_eul);
+  int32_quat_wrap_shortest(&stab_att_ref_quat);
 
   /* set reference rate and acceleration to zero */
   memset(&stab_att_ref_accel, 0, sizeof(struct Int32Rates));
@@ -176,14 +176,14 @@ void stabilization_attitude_ref_update(void) {
     OFFSET_AND_ROUND(stab_att_ref_rate.q, (REF_RATE_FRAC - INT32_RATE_FRAC)),
     OFFSET_AND_ROUND(stab_att_ref_rate.r, (REF_RATE_FRAC - INT32_RATE_FRAC)) };
   struct Int32Quat qdot;
-  INT32_QUAT_DERIVATIVE(qdot, rate_ref_scaled, stab_att_ref_quat);
+  int32_quat_derivative(&qdot, &rate_ref_scaled, &stab_att_ref_quat);
   //QUAT_SMUL(qdot, qdot, DT_UPDATE);
   qdot.qi = qdot.qi >> F_UPDATE_RES;
   qdot.qx = qdot.qx >> F_UPDATE_RES;
   qdot.qy = qdot.qy >> F_UPDATE_RES;
   qdot.qz = qdot.qz >> F_UPDATE_RES;
   QUAT_ADD(stab_att_ref_quat, qdot);
-  INT32_QUAT_NORMALIZE(stab_att_ref_quat);
+  int32_quat_normalize(&stab_att_ref_quat);
 
   /* integrate reference rotational speeds
    * delta rate = ref_accel * dt
@@ -198,9 +198,9 @@ void stabilization_attitude_ref_update(void) {
   /* compute reference angular accelerations */
   struct Int32Quat err;
   /* compute reference attitude error        */
-  INT32_QUAT_INV_COMP(err, stab_att_sp_quat, stab_att_ref_quat);
+  int32_quat_inv_comp(&err, &stab_att_sp_quat, &stab_att_ref_quat);
   /* wrap it in the shortest direction       */
-  INT32_QUAT_WRAP_SHORTEST(err);
+  int32_quat_wrap_shortest(&err);
 
   /* propagate the 2nd order linear model : accel = -2*zeta*omega * rate - omega^2 * angle  */
 
@@ -229,6 +229,6 @@ void stabilization_attitude_ref_update(void) {
 
   /* compute ref_euler for debugging and telemetry */
   struct Int32Eulers ref_eul;
-  INT32_EULERS_OF_QUAT(ref_eul, stab_att_ref_quat);
+  int32_eulers_of_quat(&ref_eul, &stab_att_ref_quat);
   INT32_EULERS_LSHIFT(stab_att_ref_euler, ref_eul, (REF_ANGLE_FRAC - INT32_ANGLE_FRAC));
 }

sw/airborne/modules/cam_control/rotorcraft_cam.c

@@ -152,13 +152,13 @@ void rotorcraft_cam_periodic(void) {
         struct Int32Vect2 diff;
         VECT2_DIFF(diff, waypoints[ROTORCRAFT_CAM_TRACK_WP], *stateGetPositionEnu_i());
         INT32_VECT2_RSHIFT(diff,diff,INT32_POS_FRAC);
-        INT32_ATAN2(rotorcraft_cam_pan,diff.x,diff.y);
+        rotorcraft_cam_pan = int32_atan2(diff.x, diff.y);
         nav_heading = rotorcraft_cam_pan;
 #if ROTORCRAFT_CAM_USE_TILT_ANGLES
         int32_t dist, height;
         INT32_VECT2_NORM(dist, diff);
         height = (waypoints[ROTORCRAFT_CAM_TRACK_WP].z - stateGetPositionEnu_i()->z) >> INT32_POS_FRAC;
-        INT32_ATAN2(rotorcraft_cam_tilt, height, dist);
+        rotorcraft_cam_tilt = int32_atan2(height, dist);
         Bound(rotorcraft_cam_tilt, CAM_TA_MIN, CAM_TA_MAX);
         rotorcraft_cam_tilt_pwm = ROTORCRAFT_CAM_TILT_MIN + D_TILT * (rotorcraft_cam_tilt - CAM_TA_MIN) / (CAM_TA_MAX - CAM_TA_MIN);
 #endif

sw/airborne/modules/ins/ins_vn100.c

@@ -205,14 +205,14 @@ static inline void parse_ins_msg( void ) {
       ins_quat.qx = last_received_packet.Data[1].Float;
       ins_quat.qy = last_received_packet.Data[2].Float;
       ins_quat.qz = last_received_packet.Data[3].Float;
-      FLOAT_EULERS_OF_QUAT(ins_eulers, ins_quat);
+      float_eulers_of_quat(&ins_eulers, &ins_quat);
       break;
     case VN100_REG_QTM :
       ins_quat.qi = last_received_packet.Data[0].Float;
       ins_quat.qx = last_received_packet.Data[1].Float;
       ins_quat.qy = last_received_packet.Data[2].Float;
       ins_quat.qz = last_received_packet.Data[3].Float;
-      FLOAT_EULERS_OF_QUAT(ins_eulers, ins_quat);
+      float_eulers_of_quat(&ins_eulers, &ins_quat);
       ins_mag.x = last_received_packet.Data[4].Float;
       ins_mag.y = last_received_packet.Data[5].Float;
       ins_mag.z = last_received_packet.Data[6].Float;
@@ -222,7 +222,7 @@ static inline void parse_ins_msg( void ) {
       ins_quat.qx = last_received_packet.Data[1].Float;
       ins_quat.qy = last_received_packet.Data[2].Float;
       ins_quat.qz = last_received_packet.Data[3].Float;
-      FLOAT_EULERS_OF_QUAT(ins_eulers, ins_quat);
+      float_eulers_of_quat(&ins_eulers, &ins_quat);
       ins_accel.x = last_received_packet.Data[4].Float;
       ins_accel.y = last_received_packet.Data[5].Float;
       ins_accel.z = last_received_packet.Data[6].Float;
@@ -232,7 +232,7 @@ static inline void parse_ins_msg( void ) {
       ins_quat.qx = last_received_packet.Data[1].Float;
       ins_quat.qy = last_received_packet.Data[2].Float;
       ins_quat.qz = last_received_packet.Data[3].Float;
-      FLOAT_EULERS_OF_QUAT(ins_eulers, ins_quat);
+      float_eulers_of_quat(&ins_eulers, &ins_quat);
       ins_rates.p = last_received_packet.Data[4].Float;
       ins_rates.q = last_received_packet.Data[5].Float;
       ins_rates.r = last_received_packet.Data[6].Float;
@@ -242,7 +242,7 @@ static inline void parse_ins_msg( void ) {
       ins_quat.qx = last_received_packet.Data[1].Float;
       ins_quat.qy = last_received_packet.Data[2].Float;
       ins_quat.qz = last_received_packet.Data[3].Float;
-      FLOAT_EULERS_OF_QUAT(ins_eulers, ins_quat);
+      float_eulers_of_quat(&ins_eulers, &ins_quat);
       ins_mag.x = last_received_packet.Data[4].Float;
       ins_mag.y = last_received_packet.Data[5].Float;
       ins_mag.z = last_received_packet.Data[6].Float;
@@ -255,7 +255,7 @@ static inline void parse_ins_msg( void ) {
       ins_quat.qx = last_received_packet.Data[1].Float;
       ins_quat.qy = last_received_packet.Data[2].Float;
       ins_quat.qz = last_received_packet.Data[3].Float;
-      FLOAT_EULERS_OF_QUAT(ins_eulers, ins_quat);
+      float_eulers_of_quat(&ins_eulers, &ins_quat);
       ins_accel.x = last_received_packet.Data[4].Float;
       ins_accel.y = last_received_packet.Data[5].Float;
       ins_accel.z = last_received_packet.Data[6].Float;
@@ -268,7 +268,7 @@ static inline void parse_ins_msg( void ) {
       ins_quat.qx = last_received_packet.Data[1].Float;
       ins_quat.qy = last_received_packet.Data[2].Float;
       ins_quat.qz = last_received_packet.Data[3].Float;
-      FLOAT_EULERS_OF_QUAT(ins_eulers, ins_quat);
+      float_eulers_of_quat(&ins_eulers, &ins_quat);
       ins_mag.x = last_received_packet.Data[4].Float;
       ins_mag.y = last_received_packet.Data[5].Float;
       ins_mag.z = last_received_packet.Data[6].Float;

sw/airborne/modules/nav/nav_catapult.c

@@ -110,7 +110,7 @@ void nav_catapult_highrate_module(void)
 #ifndef SITL
       struct Int32Vect3 accel_meas_body;
       struct Int32RMat *body_to_imu_rmat = orientationGetRMat_i(&imu.body_to_imu);
-      INT32_RMAT_TRANSP_VMULT(accel_meas_body, *body_to_imu_rmat, imu.accel);
+      int32_rmat_transp_vmult(&accel_meas_body, body_to_imu_rmat, &imu.accel);
       if (ACCEL_FLOAT_OF_BFP(accel_meas_body.x)  < (nav_catapult_acceleration_threshold * 9.81))
 #else
       if (launch != 1)