From 5eed85c9540aec1609f9610fc0ce5df4fab4b045 Mon Sep 17 00:00:00 2001 From: Matt Date: Sat, 3 Feb 2024 23:38:39 -0500 Subject: [PATCH 1/2] Why is this a thing -sam 2024 --- .clang-format | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.clang-format b/.clang-format index 952bdd2f..c9ceeb0f 100644 --- a/.clang-format +++ b/.clang-format @@ -58,7 +58,7 @@ ConstructorInitializerIndentWidth: 4 ContinuationIndentWidth: 4 Cpp11BracedListStyle: true DeriveLineEnding: true -DerivePointerAlignment: true +DerivePointerAlignment: false DisableFormat: false ExperimentalAutoDetectBinPacking: false FixNamespaceComments: true From 8a3134bb90ce409460a0cbb9d26df9f6efdd3041 Mon Sep 17 00:00:00 2001 From: Matt M Date: Sun, 4 Feb 2024 19:36:04 -0500 Subject: [PATCH 2/2] Run lint --- common/groundstation/groundstation.cpp | 10 +- common/groundstation/groundstation.h | 2 +- .../expressions/binary_func_expression.cpp | 16 +-- .../expressions/binary_func_expression.h | 24 ++--- .../system/expressions/const_expression.cpp | 8 +- common/system/expressions/const_expression.h | 10 +- .../system/expressions/empty_expression.cpp | 8 +- common/system/expressions/empty_expression.h | 10 +- .../system/expressions/event_expression.cpp | 10 +- common/system/expressions/event_expression.h | 12 +-- common/system/expressions/expression.h | 12 +-- .../system/expressions/expression_builder.cpp | 26 ++--- .../system/expressions/expression_builder.h | 36 +++---- .../system/expressions/expression_store.cpp | 50 ++++----- common/system/expressions/expression_store.h | 10 +- .../expressions/unary_func_expression.cpp | 16 +-- .../expressions/unary_func_expression.h | 22 ++-- common/system/expressions/var_expression.cpp | 8 +- common/system/expressions/var_expression.h | 10 +- common/system/filtering/filterdata_types.cpp | 6 +- common/system/filtering/filterdata_types.h | 6 +- common/system/hardware_manager.cpp | 48 ++++----- .../system/states/cli/state_cli_offload.cpp | 4 +- common/system/tasks/cli/task_cli_sense.cpp | 4 +- common/system/tasks/data_log.cpp | 46 ++++---- common/system/tasks/data_log.h | 6 +- common/system/tasks/event_manager.cpp | 2 +- common/system/tasks/radio_manager.cpp | 12 +-- common/system/tasks/trigger_manager.h | 8 +- common/utils/circular_buffer.c | 18 ++-- common/utils/circular_buffer.h | 20 ++-- common/utils/fcb_matrix.h | 12 +-- common/utils/string_slice.cpp | 16 +-- common/utils/string_slice.h | 16 +-- desktop_projects/desktop_devices/arm_math.h | 2 +- .../desktop_devices/fake_internal_flash.cpp | 6 +- .../desktop_devices/file_backed_flash.cpp | 14 +-- .../desktop_devices/file_backed_flash.h | 4 +- .../desktop_devices/flight_replay.h | 4 +- .../desktop_devices/internal_flash.h | 4 +- .../desktop_devices/print_pyro.cpp | 10 +- desktop_projects/desktop_devices/print_pyro.h | 10 +- .../desktop_devices/tcp_socket.cpp | 24 ++--- desktop_projects/desktop_devices/tcp_socket.h | 6 +- .../desktop_sim/desktop_hardware_manager.cpp | 40 +++---- .../desktop_sim/tests/test_expressions.cpp | 12 +-- .../desktop_sim/tests/test_file_flash.cpp | 4 +- .../lib/device_drivers/gps/gps.cpp | 2 +- .../lib/device_drivers/gps/gps.h | 2 +- .../lib/device_drivers/gps/nmea_0183_gps.cpp | 2 +- .../lib/device_drivers/gps/nmea_0183_gps.h | 4 +- .../lib/device_drivers/imu/bno055_imu.cpp | 8 +- .../lib/device_drivers/imu/bno055_imu.h | 4 +- .../lib/device_drivers/radio/radio.cpp | 4 +- .../lib/device_drivers/radio/radio.h | 4 +- .../lib/device_drivers/radio/rfm_950.cpp | 6 +- .../lib/device_drivers/radio/rfm_950.h | 6 +- .../lib/new_hal/arduino_hardware_manager.cpp | 38 +++---- .../lib/new_hal/arduino_hardware_manager.h | 2 +- .../lib/new_hal/device_manager.cpp | 36 +++---- .../lib/new_hal/device_manager.h | 36 +++---- .../lib/new_hal/hal_callbacks.c | 100 +++++++++--------- .../lib/new_hal/hal_callbacks.h | 46 ++++---- .../lib/new_hal/internal_flash.c | 4 +- .../lib/new_hal/internal_flash.h | 4 +- platformio_projects/src/testing/pico_test.cpp | 6 +- .../src/testing/radio_test.cpp | 4 +- .../device_drivers/accel_h3lis331dl.cpp | 10 +- .../device_drivers/accel_h3lis331dl.h | 4 +- stm32_projects/device_drivers/adc_device.cpp | 10 +- stm32_projects/device_drivers/adc_device.h | 8 +- stm32_projects/device_drivers/adc_mcp3564.cpp | 22 ++-- stm32_projects/device_drivers/adc_mcp3564.h | 16 +-- .../device_drivers/barometer_ms5607.cpp | 6 +- .../device_drivers/barometer_ms5607.h | 10 +- stm32_projects/device_drivers/ble_chip.h | 10 +- .../device_drivers/ble_chip_nrf.cpp | 40 +++---- stm32_projects/device_drivers/ble_chip_nrf.h | 10 +- .../device_drivers/ble_client_std.cpp | 4 +- .../device_drivers/ble_client_std.h | 6 +- stm32_projects/device_drivers/buzzer_pwm.cpp | 8 +- stm32_projects/device_drivers/buzzer_pwm.h | 10 +- .../device_drivers/dc_motor_pwm.cpp | 4 +- stm32_projects/device_drivers/dc_motor_pwm.h | 6 +- .../device_drivers/flash_mb85rsx.cpp | 20 ++-- stm32_projects/device_drivers/flash_mb85rsx.h | 18 ++-- .../device_drivers/flash_s25flx.cpp | 38 +++---- stm32_projects/device_drivers/flash_s25flx.h | 26 ++--- stm32_projects/device_drivers/gps.cpp | 31 +++--- stm32_projects/device_drivers/gps.h | 18 ++-- .../device_drivers/hal_callbacks.cpp | 100 +++++++++--------- stm32_projects/device_drivers/hal_callbacks.h | 46 ++++---- .../device_drivers/imu_icm20600.cpp | 10 +- stm32_projects/device_drivers/imu_icm20600.h | 4 +- stm32_projects/device_drivers/imu_iis2mdc.cpp | 4 +- stm32_projects/device_drivers/imu_lsm9ds1.cpp | 12 +-- stm32_projects/device_drivers/imu_lsm9ds1.h | 4 +- .../device_drivers/internal_flash.cpp | 10 +- .../device_drivers/internal_flash.h | 4 +- stm32_projects/device_drivers/led.cpp | 6 +- stm32_projects/device_drivers/led.h | 8 +- .../device_drivers/line_cutter_ble.cpp | 34 +++--- .../device_drivers/line_cutter_ble.h | 28 ++--- stm32_projects/device_drivers/mag_iis2mdc.cpp | 10 +- stm32_projects/device_drivers/mag_iis2mdc.h | 6 +- stm32_projects/device_drivers/minmea.c | 50 ++++----- stm32_projects/device_drivers/minmea.h | 36 +++---- .../device_drivers/pyro_digital.cpp | 10 +- stm32_projects/device_drivers/pyro_digital.h | 14 +-- stm32_projects/device_drivers/servo_pwm.cpp | 4 +- stm32_projects/device_drivers/servo_pwm.h | 6 +- stm32_projects/device_drivers/spi_driver.cpp | 6 +- stm32_projects/device_drivers/spi_driver.h | 10 +- .../device_drivers/temp_max31855.cpp | 12 +-- stm32_projects/device_drivers/temp_max31855.h | 10 +- stm32_projects/device_drivers/ti_radio.cpp | 79 +++++++------- stm32_projects/device_drivers/ti_radio.h | 40 +++---- stm32_projects/device_drivers/usb_std.cpp | 16 +-- 118 files changed, 947 insertions(+), 949 deletions(-) diff --git a/common/groundstation/groundstation.cpp b/common/groundstation/groundstation.cpp index 9ad9826c..10dc4bb5 100644 --- a/common/groundstation/groundstation.cpp +++ b/common/groundstation/groundstation.cpp @@ -14,11 +14,11 @@ #include #endif -static void OnDataRx(RadioRecievedPacket_s *packet) { - hm_usbTransmit(FIRST_ID_USB_STD, (uint8_t *)packet, sizeof(*packet)); +static void OnDataRx(RadioRecievedPacket_s* packet) { + hm_usbTransmit(FIRST_ID_USB_STD, (uint8_t*)packet, sizeof(*packet)); } -static void GroundstationParseCommand(GroundstationUsbCommand_s *command) { +static void GroundstationParseCommand(GroundstationUsbCommand_s* command) { if (command->data[0] == CHANNEL_COMMAND_ID) { uint8_t radioHw = command->data[1]; int8_t channel = command->data[2]; @@ -69,7 +69,7 @@ void Groundstation::runOnce() { static uint8_t heartbeatArr[sizeof(RadioRecievedPacket_s)] = {0}; memset(heartbeatArr, 0, sizeof(heartbeatArr)); memcpy(heartbeatArr, &heartbeat, sizeof(heartbeat)); - hm_usbTransmit(FIRST_ID_USB_STD, (uint8_t *)&heartbeatArr, + hm_usbTransmit(FIRST_ID_USB_STD, (uint8_t*)&heartbeatArr, sizeof(heartbeatArr)); } @@ -78,7 +78,7 @@ void Groundstation::runOnce() { if (cb_count(buffer) > 3) { static GroundstationUsbCommand_s command; size_t count = min(cb_count(buffer), sizeof(command)); - cb_peek(buffer, (uint8_t *)&command, &count); + cb_peek(buffer, (uint8_t*)&command, &count); // If we got at least enough bytes for one message to be done if (count >= static_cast(command.len + 3)) { diff --git a/common/groundstation/groundstation.h b/common/groundstation/groundstation.h index 0116a759..0b809645 100644 --- a/common/groundstation/groundstation.h +++ b/common/groundstation/groundstation.h @@ -46,7 +46,7 @@ class Groundstation { void runOnce(); protected: - CircularBuffer_s *buffer{}; + CircularBuffer_s* buffer{}; uint32_t start = 0; }; diff --git a/common/system/expressions/binary_func_expression.cpp b/common/system/expressions/binary_func_expression.cpp index 387d8639..196c2385 100644 --- a/common/system/expressions/binary_func_expression.cpp +++ b/common/system/expressions/binary_func_expression.cpp @@ -8,8 +8,8 @@ #include "hardware_manager.h" -BinaryFunctionWrapper::BinaryFunctionWrapper(const char *_stringRep, - BinaryFunction *function, +BinaryFunctionWrapper::BinaryFunctionWrapper(const char* _stringRep, + BinaryFunction* function, ExpressionValueType_e _op1Type, ExpressionValueType_e _op2Type, ExpressionValueType_e _valueType) { @@ -21,12 +21,12 @@ BinaryFunctionWrapper::BinaryFunctionWrapper(const char *_stringRep, this->valueType = _valueType; } -void BinaryFunctionWrapper::evaluate(Expression *expr, FilterData_s *filterData, - Expression *op1, Expression *op2) { +void BinaryFunctionWrapper::evaluate(Expression* expr, FilterData_s* filterData, + Expression* op1, Expression* op2) { this->function(expr, filterData, op1, op2); } -bool BinaryFunctionWrapper::matchesSlice(const StringSlice &slice) { +bool BinaryFunctionWrapper::matchesSlice(const StringSlice& slice) { return slice == this->stringRep; } @@ -126,7 +126,7 @@ BinaryFunctionWrapper binaryFunctionWrappers[NUM_BINARY_FUNCTION] = { BinaryFunctionWrapper("/", divFunc, number, number, number)}; int BinaryFuncExpression::toString( - char *buffer, int n, ExpressionPtrCallback &expressionPtrCallback) const { + char* buffer, int n, ExpressionPtrCallback& expressionPtrCallback) const { int selfLength = strlen(binaryFunctionWrappers[this->opcode].stringRep); if (n == 0) { return 0; @@ -155,14 +155,14 @@ int BinaryFuncExpression::toString( } void BinaryFuncExpression::evaluate( - FilterData_s *filterData, ExpressionPtrCallback &expressionPtrCallback) { + FilterData_s* filterData, ExpressionPtrCallback& expressionPtrCallback) { binaryFunctionWrappers[this->opcode].evaluate( this, filterData, expressionPtrCallback(operand1ID), expressionPtrCallback(operand2ID)); } void BinaryFuncExpression::serializeInto( - SerializedExpression_s *serialized) const { + SerializedExpression_s* serialized) const { serialized->triggerNum = this->triggerNum; serialized->type = binaryFunc; serialized->contents.binary.opcode = this->opcode; diff --git a/common/system/expressions/binary_func_expression.h b/common/system/expressions/binary_func_expression.h index e931d0f9..d3b21111 100644 --- a/common/system/expressions/binary_func_expression.h +++ b/common/system/expressions/binary_func_expression.h @@ -25,8 +25,8 @@ typedef enum { /** * Lambda for a binary function. */ -using BinaryFunction = void(Expression *expr, FilterData_s *filterData, - Expression *op1, Expression *op2); +using BinaryFunction = void(Expression* expr, FilterData_s* filterData, + Expression* op1, Expression* op2); /** * A wrapper class for a binary function lambda that makes it easier to use. @@ -36,7 +36,7 @@ using BinaryFunction = void(Expression *expr, FilterData_s *filterData, */ class BinaryFunctionWrapper { private: - BinaryFunction *function; + BinaryFunction* function; ExpressionValueType_e op1Type; ExpressionValueType_e op2Type; uint16_t stringLen; @@ -45,15 +45,15 @@ class BinaryFunctionWrapper { char stringRep[10]; ExpressionValueType_e valueType; - BinaryFunctionWrapper(const char *stringRep, BinaryFunction *function, + BinaryFunctionWrapper(const char* stringRep, BinaryFunction* function, ExpressionValueType_e op1Type, ExpressionValueType_e op2Type, ExpressionValueType_e valueType); - void evaluate(Expression *expr, FilterData_s *filterData, Expression *op1, - Expression *op2); + void evaluate(Expression* expr, FilterData_s* filterData, Expression* op1, + Expression* op2); - bool matchesSlice(const StringSlice &slice); + bool matchesSlice(const StringSlice& slice); bool acceptsArgument1Type(ExpressionValueType_e type); @@ -88,13 +88,13 @@ class BinaryFuncExpression : public Expression { this->setTriggerNum(triggerNum); } - void evaluate(FilterData_s *filterData, - ExpressionPtrCallback &expressionPtrCallback); + void evaluate(FilterData_s* filterData, + ExpressionPtrCallback& expressionPtrCallback); - int toString(char *buffer, int n, - ExpressionPtrCallback &expressionPtrCallback) const; + int toString(char* buffer, int n, + ExpressionPtrCallback& expressionPtrCallback) const; - void serializeInto(SerializedExpression_s *serialized) const; + void serializeInto(SerializedExpression_s* serialized) const; }; #endif // COMMON_SYSTEM_EXPRESSIONS_BINARY_FUNC_EXPRESSION_H_ diff --git a/common/system/expressions/const_expression.cpp b/common/system/expressions/const_expression.cpp index c339a472..0913b0f4 100644 --- a/common/system/expressions/const_expression.cpp +++ b/common/system/expressions/const_expression.cpp @@ -10,20 +10,20 @@ ConstExpression::ConstExpression(uint16_t _triggerNum, int value) { this->setTriggerNum(_triggerNum); } -void ConstExpression::evaluate(FilterData_s *filterData, - ExpressionPtrCallback &expressionPtrCallback) { +void ConstExpression::evaluate(FilterData_s* filterData, + ExpressionPtrCallback& expressionPtrCallback) { return; } int ConstExpression::toString( - char *buffer, int n, ExpressionPtrCallback &expressionPtrCallback) const { + char* buffer, int n, ExpressionPtrCallback& expressionPtrCallback) const { static char floatBuf[10]; dtoa(floatBuf, 10, this->getNumberValue(), 2); snprintf(buffer, n, "%s", floatBuf); return strlen(buffer); } -void ConstExpression::serializeInto(SerializedExpression_s *serialized) const { +void ConstExpression::serializeInto(SerializedExpression_s* serialized) const { serialized->triggerNum = this->triggerNum; serialized->type = constant; serialized->contents.constant = this->getNumberValue(); diff --git a/common/system/expressions/const_expression.h b/common/system/expressions/const_expression.h index 297fe16b..e7888fa0 100644 --- a/common/system/expressions/const_expression.h +++ b/common/system/expressions/const_expression.h @@ -27,13 +27,13 @@ class ConstExpression : public Expression { */ ConstExpression(uint16_t triggerNum, int value); - void evaluate(FilterData_s *filterData, - ExpressionPtrCallback &expressionPtrCallback); + void evaluate(FilterData_s* filterData, + ExpressionPtrCallback& expressionPtrCallback); - int toString(char *buffer, int n, - ExpressionPtrCallback &expressionPtrCallback) const; + int toString(char* buffer, int n, + ExpressionPtrCallback& expressionPtrCallback) const; - void serializeInto(SerializedExpression_s *serialized) const; + void serializeInto(SerializedExpression_s* serialized) const; }; #endif // COMMON_SYSTEM_EXPRESSIONS_CONST_EXPRESSION_H_ diff --git a/common/system/expressions/empty_expression.cpp b/common/system/expressions/empty_expression.cpp index e1b35da0..95ed180f 100644 --- a/common/system/expressions/empty_expression.cpp +++ b/common/system/expressions/empty_expression.cpp @@ -9,18 +9,18 @@ EmptyExpression::EmptyExpression() { bool EmptyExpression::isEmpty() const { return true; } // Does nothing -void EmptyExpression::evaluate(FilterData_s *filterData, - ExpressionPtrCallback &expressionPtrCallback) { +void EmptyExpression::evaluate(FilterData_s* filterData, + ExpressionPtrCallback& expressionPtrCallback) { return; } int EmptyExpression::toString( - char *buffer, int n, ExpressionPtrCallback &expressionPtrCallback) const { + char* buffer, int n, ExpressionPtrCallback& expressionPtrCallback) const { strncpy(buffer, "empty", n); return 5; } -void EmptyExpression::serializeInto(SerializedExpression_s *serialized) const { +void EmptyExpression::serializeInto(SerializedExpression_s* serialized) const { serialized->triggerNum = this->triggerNum; serialized->type = empty; } diff --git a/common/system/expressions/empty_expression.h b/common/system/expressions/empty_expression.h index 007976a6..07b2e205 100644 --- a/common/system/expressions/empty_expression.h +++ b/common/system/expressions/empty_expression.h @@ -21,13 +21,13 @@ class EmptyExpression : public Expression { bool isEmpty() const; // Does nothing - void evaluate(FilterData_s *filterData, - ExpressionPtrCallback &expressionPtrCallback); + void evaluate(FilterData_s* filterData, + ExpressionPtrCallback& expressionPtrCallback); - int toString(char *buffer, int n, - ExpressionPtrCallback &expressionPtrCallback) const; + int toString(char* buffer, int n, + ExpressionPtrCallback& expressionPtrCallback) const; - void serializeInto(SerializedExpression_s *serialized) const; + void serializeInto(SerializedExpression_s* serialized) const; }; #endif // COMMON_SYSTEM_EXPRESSIONS_EMPTY_EXPRESSION_H_ diff --git a/common/system/expressions/event_expression.cpp b/common/system/expressions/event_expression.cpp index 6893c45d..3bd13a4f 100644 --- a/common/system/expressions/event_expression.cpp +++ b/common/system/expressions/event_expression.cpp @@ -1,6 +1,6 @@ #include "event_expression.h" -const char *eventStrings[] = {"launch", "burnout", "apogee", "touchdown", +const char* eventStrings[] = {"launch", "burnout", "apogee", "touchdown", "unclean_restart"}; EventExpression::EventExpression(uint16_t triggerNum, Event_e event) { @@ -8,18 +8,18 @@ EventExpression::EventExpression(uint16_t triggerNum, Event_e event) { this->event = event; } -void EventExpression::evaluate(FilterData_s *filterData, - ExpressionPtrCallback &expressionPtrCallback) { +void EventExpression::evaluate(FilterData_s* filterData, + ExpressionPtrCallback& expressionPtrCallback) { this->setBooleanValue(eventManager_getEventStatus(this->event)); } int EventExpression::toString( - char *buffer, int n, ExpressionPtrCallback &expressionPtrCallback) const { + char* buffer, int n, ExpressionPtrCallback& expressionPtrCallback) const { snprintf(buffer, n, eventStrings[this->event]); return strlen(buffer); } -void EventExpression::serializeInto(SerializedExpression_s *serialized) const { +void EventExpression::serializeInto(SerializedExpression_s* serialized) const { serialized->triggerNum = this->triggerNum; serialized->type = ExpressionType_e::event; serialized->contents.event = this->event; diff --git a/common/system/expressions/event_expression.h b/common/system/expressions/event_expression.h index 97616e7f..94c11e80 100644 --- a/common/system/expressions/event_expression.h +++ b/common/system/expressions/event_expression.h @@ -5,7 +5,7 @@ #include "event_manager.h" #include "expression.h" -extern const char *eventStrings[]; +extern const char* eventStrings[]; /** * An event expression is an expression that evaluates directly to the status of @@ -26,13 +26,13 @@ class EventExpression : public Expression { */ EventExpression(uint16_t triggerNum, Event_e event); - void evaluate(FilterData_s *filterData, - ExpressionPtrCallback &expressionPtrCallback); + void evaluate(FilterData_s* filterData, + ExpressionPtrCallback& expressionPtrCallback); - int toString(char *buffer, int n, - ExpressionPtrCallback &expressionPtrCallback) const; + int toString(char* buffer, int n, + ExpressionPtrCallback& expressionPtrCallback) const; - void serializeInto(SerializedExpression_s *serialized) const; + void serializeInto(SerializedExpression_s* serialized) const; }; #endif // COMMON_SYSTEM_EXPRESSIONS_EVENT_EXPRESSION_H_ diff --git a/common/system/expressions/expression.h b/common/system/expressions/expression.h index 72b01b13..10b4e745 100644 --- a/common/system/expressions/expression.h +++ b/common/system/expressions/expression.h @@ -33,7 +33,7 @@ class Expression { * ExpressionStore to fetch from. * @return Pointer to that expression as the base class Expression. */ - using ExpressionPtrCallback = std::function; + using ExpressionPtrCallback = std::function; uint32_t firstTrue; uint32_t trueSince; uint16_t triggerNum; @@ -54,8 +54,8 @@ class Expression { * @param expressionPtrCallback ExpressionPtrCallback to get a pointer to a * given child expression. */ - virtual void evaluate(FilterData_s *filterData, - ExpressionPtrCallback &expressionPtrCallback) = 0; + virtual void evaluate(FilterData_s* filterData, + ExpressionPtrCallback& expressionPtrCallback) = 0; /** * If this is an empty expression. @@ -105,14 +105,14 @@ class Expression { * given child expression. * @return Number of characters used by this expression in the buffer. */ - virtual int toString(char *buffer, int n, - ExpressionPtrCallback &expressionPtrCallback) const = 0; + virtual int toString(char* buffer, int n, + ExpressionPtrCallback& expressionPtrCallback) const = 0; /** * Serialize this expression into a location. * @param serialized Struct to serialize into. */ - virtual void serializeInto(SerializedExpression_s *serialized) const = 0; + virtual void serializeInto(SerializedExpression_s* serialized) const = 0; }; #endif // COMMON_SYSTEM_EXPRESSIONS_EXPRESSION_H_ diff --git a/common/system/expressions/expression_builder.cpp b/common/system/expressions/expression_builder.cpp index 03edb6b6..926248ed 100644 --- a/common/system/expressions/expression_builder.cpp +++ b/common/system/expressions/expression_builder.cpp @@ -6,11 +6,11 @@ */ ExpressionValueType_e VarExpressionBuilder::build( - const StringSlice &slice, ExpressionStore *expressionStore, - uint16_t triggerNum, ExpressionVariant_v *parseInto, + const StringSlice& slice, ExpressionStore* expressionStore, + uint16_t triggerNum, ExpressionVariant_v* parseInto, uint16_t destinationID) { FilterData_e variableType = - getVariableEnumFromString((char *)slice.startPtr()); + getVariableEnumFromString((char*)slice.startPtr()); if (variableType != FilterData_e::invalid) { *parseInto = VarExpression(triggerNum, variableType); return ExpressionValueType_e::number; @@ -25,8 +25,8 @@ ExpressionValueType_e VarExpressionBuilder::build( */ ExpressionValueType_e EventExpressionBuilder::build( - const StringSlice &slice, ExpressionStore *expressionStore, - uint16_t triggerNum, ExpressionVariant_v *parseInto, + const StringSlice& slice, ExpressionStore* expressionStore, + uint16_t triggerNum, ExpressionVariant_v* parseInto, uint16_t destinationID) { for (int i = 0; i < Event_e::NUM_EVENT; ++i) { if (slice == eventStrings[i]) { @@ -43,11 +43,11 @@ ExpressionValueType_e EventExpressionBuilder::build( * constant is found. */ ExpressionValueType_e ConstExpressionBuilder::build( - const StringSlice &slice, ExpressionStore *expressionStore, - uint16_t triggerNum, ExpressionVariant_v *parseInto, + const StringSlice& slice, ExpressionStore* expressionStore, + uint16_t triggerNum, ExpressionVariant_v* parseInto, uint16_t destinationID) { - char *endptr; - double value = smallStrtod((char *)slice.startPtr(), &endptr); + char* endptr; + double value = smallStrtod((char*)slice.startPtr(), &endptr); if (endptr != slice.endptr()) { return ExpressionValueType_e::invalid_type; @@ -66,8 +66,8 @@ ExpressionValueType_e ConstExpressionBuilder::build( */ ExpressionValueType_e UnaryFuncExpressionBuilder::build( - const StringSlice &slice, ExpressionStore *expressionStore, - uint16_t triggerNum, ExpressionVariant_v *parseInto, + const StringSlice& slice, ExpressionStore* expressionStore, + uint16_t triggerNum, ExpressionVariant_v* parseInto, uint16_t destinationID) { if (slice[0] != '(' || slice[slice.length() - 1] != ')') { return ExpressionValueType_e::invalid_type; @@ -106,8 +106,8 @@ ExpressionValueType_e UnaryFuncExpressionBuilder::build( * (boolean or number) are valid inputs to the function already determined. */ ExpressionValueType_e BinaryFuncExpressionBuilder::build( - const StringSlice &slice, ExpressionStore *expressionStore, - uint16_t triggerNum, ExpressionVariant_v *parseInto, + const StringSlice& slice, ExpressionStore* expressionStore, + uint16_t triggerNum, ExpressionVariant_v* parseInto, uint16_t destinationID) { StringSlice slices[MAX_SLICE]; if (slice[0] != '(' || slice[slice.length() - 1] != ')') { diff --git a/common/system/expressions/expression_builder.h b/common/system/expressions/expression_builder.h index 08a33304..9ddf29a0 100644 --- a/common/system/expressions/expression_builder.h +++ b/common/system/expressions/expression_builder.h @@ -31,10 +31,10 @@ class ExpressionBuilder { * into. * @return The value type built by the builder, which may be invalid. */ - virtual ExpressionValueType_e build(const StringSlice &slice, - ExpressionStore *expressionStore, + virtual ExpressionValueType_e build(const StringSlice& slice, + ExpressionStore* expressionStore, uint16_t triggerNum, - ExpressionVariant_v *parseInto, + ExpressionVariant_v* parseInto, uint16_t destinationID) = 0; /** @@ -50,10 +50,10 @@ class ExpressionBuilder { */ class VarExpressionBuilder : public ExpressionBuilder { public: - ExpressionValueType_e build(const StringSlice &slice, - ExpressionStore *expressionStore, + ExpressionValueType_e build(const StringSlice& slice, + ExpressionStore* expressionStore, uint16_t triggerNum, - ExpressionVariant_v *parseInto, + ExpressionVariant_v* parseInto, uint16_t destinationID) override; }; @@ -64,10 +64,10 @@ class VarExpressionBuilder : public ExpressionBuilder { */ class EventExpressionBuilder : public ExpressionBuilder { public: - ExpressionValueType_e build(const StringSlice &slice, - ExpressionStore *expressionStore, + ExpressionValueType_e build(const StringSlice& slice, + ExpressionStore* expressionStore, uint16_t triggerNum, - ExpressionVariant_v *parseInto, + ExpressionVariant_v* parseInto, uint16_t destinationID) override; }; @@ -78,10 +78,10 @@ class EventExpressionBuilder : public ExpressionBuilder { */ class ConstExpressionBuilder : public ExpressionBuilder { public: - ExpressionValueType_e build(const StringSlice &slice, - ExpressionStore *expressionStore, + ExpressionValueType_e build(const StringSlice& slice, + ExpressionStore* expressionStore, uint16_t triggerNum, - ExpressionVariant_v *parseInto, + ExpressionVariant_v* parseInto, uint16_t destinationID) override; }; @@ -95,10 +95,10 @@ class ConstExpressionBuilder : public ExpressionBuilder { */ class UnaryFuncExpressionBuilder : public ExpressionBuilder { public: - ExpressionValueType_e build(const StringSlice &slice, - ExpressionStore *expressionStore, + ExpressionValueType_e build(const StringSlice& slice, + ExpressionStore* expressionStore, uint16_t triggerNum, - ExpressionVariant_v *parseInto, + ExpressionVariant_v* parseInto, uint16_t destinationID) override; }; @@ -112,10 +112,10 @@ class UnaryFuncExpressionBuilder : public ExpressionBuilder { */ class BinaryFuncExpressionBuilder : public ExpressionBuilder { public: - ExpressionValueType_e build(const StringSlice &slice, - ExpressionStore *expressionStore, + ExpressionValueType_e build(const StringSlice& slice, + ExpressionStore* expressionStore, uint16_t triggerNum, - ExpressionVariant_v *parseInto, + ExpressionVariant_v* parseInto, uint16_t destinationID) override; }; diff --git a/common/system/expressions/expression_store.cpp b/common/system/expressions/expression_store.cpp index dc5b9e40..7687413b 100644 --- a/common/system/expressions/expression_store.cpp +++ b/common/system/expressions/expression_store.cpp @@ -13,7 +13,7 @@ static UnaryFuncExpressionBuilder unaryFuncExpressionBuilder; static BinaryFuncExpressionBuilder binaryFuncExpressionBuilder; static EventExpressionBuilder eventExpressionBuilder; -static ExpressionBuilder *builders[] = { +static ExpressionBuilder* builders[] = { &varExpressionBuilder, &constExpressionBuilder, &eventExpressionBuilder, &unaryFuncExpressionBuilder, &binaryFuncExpressionBuilder}; @@ -21,7 +21,7 @@ static EmptyExpression emptyExpr; void ExpressionStore::init() { for (int i = 0; i < MAX_EXPRESSION; ++i) { - SerializedExpression_s *serialized = cli_getConfigs()->serializedExprs + i; + SerializedExpression_s* serialized = cli_getConfigs()->serializedExprs + i; switch (serialized->type) { case event: expressions[i] = @@ -56,24 +56,24 @@ void ExpressionStore::init() { } } -Expression *ExpressionStore::getExpressionPtr(uint16_t expressionNum) { - ExpressionVariant_v *varPtr = &(expressions[expressionNum]); - if (Expression *ret = std::get_if(varPtr)) { +Expression* ExpressionStore::getExpressionPtr(uint16_t expressionNum) { + ExpressionVariant_v* varPtr = &(expressions[expressionNum]); + if (Expression* ret = std::get_if(varPtr)) { return ret; } - if (Expression *ret = std::get_if(varPtr)) { + if (Expression* ret = std::get_if(varPtr)) { return ret; } - if (Expression *ret = std::get_if(varPtr)) { + if (Expression* ret = std::get_if(varPtr)) { return ret; } - if (Expression *ret = std::get_if(varPtr)) { + if (Expression* ret = std::get_if(varPtr)) { return ret; } - if (Expression *ret = std::get_if(varPtr)) { + if (Expression* ret = std::get_if(varPtr)) { return ret; } - if (Expression *ret = std::get_if(varPtr)) { + if (Expression* ret = std::get_if(varPtr)) { return ret; } return &emptyExpr; @@ -81,7 +81,7 @@ Expression *ExpressionStore::getExpressionPtr(uint16_t expressionNum) { void ExpressionStore::removeExpressionsForTrigger(int triggerNum) { for (int i = 0; i < MAX_EXPRESSION; ++i) { - if (std::visit([](auto &&var) { return var.triggerNum; }, + if (std::visit([](auto&& var) { return var.triggerNum; }, expressionBuffer[i]) == triggerNum) { expressionBuffer[i] = EmptyExpression(); } @@ -93,7 +93,7 @@ uint16_t ExpressionStore::getNextExpressionSpot(uint16_t startAt) const { return -1; } for (uint16_t i = startAt; i < MAX_EXPRESSION; ++i) { - if (std::visit([](auto &&var) { return var.isEmpty(); }, + if (std::visit([](auto&& var) { return var.isEmpty(); }, expressionBuffer[i])) { return i; } @@ -101,9 +101,9 @@ uint16_t ExpressionStore::getNextExpressionSpot(uint16_t startAt) const { return -1; } -ExpressionValueType_e ExpressionStore::parseForTrigger(uint16_t *resultID, +ExpressionValueType_e ExpressionStore::parseForTrigger(uint16_t* resultID, uint16_t triggerNum, - const StringSlice &slice, + const StringSlice& slice, uint16_t startAt) { if (startAt < 0 || startAt >= MAX_EXPRESSION) { return ExpressionValueType_e::invalid_type; @@ -112,9 +112,9 @@ ExpressionValueType_e ExpressionStore::parseForTrigger(uint16_t *resultID, if (nextSpot < 0) { return ExpressionValueType_e::invalid_type; } - ExpressionVariant_v *buildInto = &expressionBuffer[nextSpot]; + ExpressionVariant_v* buildInto = &expressionBuffer[nextSpot]; ExpressionValueType_e parseResult; - for (ExpressionBuilder *builder : builders) { + for (ExpressionBuilder* builder : builders) { parseResult = builder->build(slice, this, triggerNum, buildInto, nextSpot); if (parseResult != ExpressionValueType_e::invalid_type) { *resultID = nextSpot; @@ -128,7 +128,7 @@ bool ExpressionStore::getExprBoolValue(uint16_t expressionNum) const { if (expressionNum >= MAX_EXPRESSION || expressionNum < 0) { return false; } - return std::visit([&](auto &&var) { return var.getBooleanValue(); }, + return std::visit([&](auto&& var) { return var.getBooleanValue(); }, expressions[expressionNum]); } @@ -136,15 +136,15 @@ float ExpressionStore::getExprNumValue(uint16_t expressionNum) const { if (expressionNum >= MAX_EXPRESSION || expressionNum < 0) { return false; } - return std::visit([&](auto &&var) { return var.getNumberValue(); }, + return std::visit([&](auto&& var) { return var.getNumberValue(); }, expressions[expressionNum]); } -void ExpressionStore::tick(FilterData_s *filterData) { - std::function pointerCallback = +void ExpressionStore::tick(FilterData_s* filterData) { + std::function pointerCallback = std::bind(&ExpressionStore::getExpressionPtr, this, _1); for (int i = MAX_EXPRESSION - 1; i >= 0; --i) { - std::visit([&](auto &&var) { var.evaluate(filterData, pointerCallback); }, + std::visit([&](auto&& var) { var.evaluate(filterData, pointerCallback); }, expressions[i]); } } @@ -153,21 +153,21 @@ void ExpressionStore::writeNewConfigs() { for (int i = 0; i < MAX_EXPRESSION; ++i) { expressions[i] = expressionBuffer[i]; std::visit( - [&](auto &&var) { + [&](auto&& var) { var.serializeInto(cli_getConfigs()->serializedExprs + i); }, expressions[i]); } } -void ExpressionStore::conditionToString(uint16_t expressionNum, char *buffer, +void ExpressionStore::conditionToString(uint16_t expressionNum, char* buffer, int n) { if (expressionNum >= MAX_EXPRESSION || expressionNum < 0) { return; } - std::function pointerCallback = + std::function pointerCallback = std::bind(&ExpressionStore::getExpressionPtr, this, _1); - std::visit([&](auto &&var) { var.toString(buffer, n, pointerCallback); }, + std::visit([&](auto&& var) { var.toString(buffer, n, pointerCallback); }, expressions[expressionNum]); } diff --git a/common/system/expressions/expression_store.h b/common/system/expressions/expression_store.h index c55a9ec1..85e0d24d 100644 --- a/common/system/expressions/expression_store.h +++ b/common/system/expressions/expression_store.h @@ -69,7 +69,7 @@ class ExpressionStore { * @param expressionNum Index of the expression to get a pointer to. * @return Pointer to that expression. */ - Expression *getExpressionPtr(uint16_t expressionNum); + Expression* getExpressionPtr(uint16_t expressionNum); /** * Remove all of the expressions for a certain trigger number. @@ -88,8 +88,8 @@ class ExpressionStore { * @param startAt The start location to potentially store this expression. * @return The value type of this expression, or invalid if it couldn't parse. */ - ExpressionValueType_e parseForTrigger(uint16_t *resultID, uint16_t triggerNum, - const StringSlice &slice, + ExpressionValueType_e parseForTrigger(uint16_t* resultID, uint16_t triggerNum, + const StringSlice& slice, uint16_t startAt = 0); /** @@ -110,7 +110,7 @@ class ExpressionStore { * Should be run once per cycle. Evaluates all expressions with updated data. * @param filterData */ - void tick(FilterData_s *filterData); + void tick(FilterData_s* filterData); /** * After a delete/update of triggers, actually write all of the changes to the @@ -124,6 +124,6 @@ class ExpressionStore { * @param buffer Buffer to format into. * @param n Maximum size of buffer. */ - void conditionToString(uint16_t expressionNum, char *buffer, int n); + void conditionToString(uint16_t expressionNum, char* buffer, int n); }; #endif // COMMON_SYSTEM_EXPRESSIONS_EXPRESSION_STORE_H_ diff --git a/common/system/expressions/unary_func_expression.cpp b/common/system/expressions/unary_func_expression.cpp index f277eb82..c1c14925 100644 --- a/common/system/expressions/unary_func_expression.cpp +++ b/common/system/expressions/unary_func_expression.cpp @@ -7,8 +7,8 @@ #include "string_slice.h" -UnaryFunctionWrapper::UnaryFunctionWrapper(const char *stringRep, - UnaryFunction *function, +UnaryFunctionWrapper::UnaryFunctionWrapper(const char* stringRep, + UnaryFunction* function, ExpressionValueType_e opType, ExpressionValueType_e valueType, bool defaultValue) { @@ -21,12 +21,12 @@ UnaryFunctionWrapper::UnaryFunctionWrapper(const char *stringRep, this->defaultValue = defaultValue; } -void UnaryFunctionWrapper::evaluate(Expression *expr, FilterData_s *filterData, - Expression *op1) { +void UnaryFunctionWrapper::evaluate(Expression* expr, FilterData_s* filterData, + Expression* op1) { this->function(expr, filterData, op1); } -bool UnaryFunctionWrapper::matchesSlice(const StringSlice &slice) { +bool UnaryFunctionWrapper::matchesSlice(const StringSlice& slice) { return slice == this->stringRep; } @@ -73,7 +73,7 @@ UnaryFunctionWrapper unaryFunctionWrappers[NUM_UNARY_FUNCTION] = { }; int UnaryFuncExpression::toString( - char *buffer, int n, ExpressionPtrCallback &expressionPtrCallback) const { + char* buffer, int n, ExpressionPtrCallback& expressionPtrCallback) const { int selfLength = strnlen(unaryFunctionWrappers[this->opcode].stringRep, 7); snprintf(buffer, n, "(%s ", unaryFunctionWrappers[this->opcode].stringRep); if (selfLength + 2 < n) { @@ -91,13 +91,13 @@ int UnaryFuncExpression::toString( } void UnaryFuncExpression::evaluate( - FilterData_s *filterData, ExpressionPtrCallback &expressionPtrCallback) { + FilterData_s* filterData, ExpressionPtrCallback& expressionPtrCallback) { unaryFunctionWrappers[this->opcode].evaluate( this, filterData, expressionPtrCallback(operandID)); } void UnaryFuncExpression::serializeInto( - SerializedExpression_s *serialized) const { + SerializedExpression_s* serialized) const { serialized->triggerNum = this->triggerNum; serialized->type = unaryFunc; serialized->contents.unary.opcode = this->opcode; diff --git a/common/system/expressions/unary_func_expression.h b/common/system/expressions/unary_func_expression.h index 979713c5..539d1e3d 100644 --- a/common/system/expressions/unary_func_expression.h +++ b/common/system/expressions/unary_func_expression.h @@ -19,8 +19,8 @@ typedef enum { /** * Definition of a UnaryFunction lambda. */ -using UnaryFunction = void(Expression *expr, FilterData_s *filterData, - Expression *operand); +using UnaryFunction = void(Expression* expr, FilterData_s* filterData, + Expression* operand); /** * A wrapper class for a lambda that makes it easier to use. This wrapper class @@ -28,7 +28,7 @@ using UnaryFunction = void(Expression *expr, FilterData_s *filterData, * information about how the function works and what argument it takes. */ class UnaryFunctionWrapper { - UnaryFunction *function; + UnaryFunction* function; ExpressionValueType_e opType; uint16_t stringLen; bool defaultValue; @@ -45,7 +45,7 @@ class UnaryFunctionWrapper { * @param valueType The type of result this function returns. * @param defaultValue Default boolean value to set. */ - UnaryFunctionWrapper(const char *stringRep, UnaryFunction *function, + UnaryFunctionWrapper(const char* stringRep, UnaryFunction* function, ExpressionValueType_e opType, ExpressionValueType_e valueType, bool defaultValue); @@ -55,14 +55,14 @@ class UnaryFunctionWrapper { * @param filterData * @param op1 The expression operand. */ - void evaluate(Expression *expr, FilterData_s *filterData, Expression *op1); + void evaluate(Expression* expr, FilterData_s* filterData, Expression* op1); /** * See if this wrapper's string name matches a slice of a string. * @param slice * @return bool of match or not. */ - bool matchesSlice(const StringSlice &slice); + bool matchesSlice(const StringSlice& slice); /** * See if this wrapper matches a type of operand. @@ -103,13 +103,13 @@ class UnaryFuncExpression : public Expression { this->setTriggerNum(triggerNum); } - void evaluate(FilterData_s *filterData, - ExpressionPtrCallback &expressionPtrCallback); + void evaluate(FilterData_s* filterData, + ExpressionPtrCallback& expressionPtrCallback); - int toString(char *buffer, int n, - ExpressionPtrCallback &expressionPtrCallback) const; + int toString(char* buffer, int n, + ExpressionPtrCallback& expressionPtrCallback) const; - void serializeInto(SerializedExpression_s *serialized) const; + void serializeInto(SerializedExpression_s* serialized) const; }; #endif // COMMON_SYSTEM_EXPRESSIONS_UNARY_FUNC_EXPRESSION_H_ diff --git a/common/system/expressions/var_expression.cpp b/common/system/expressions/var_expression.cpp index ef6300c3..d84d4289 100644 --- a/common/system/expressions/var_expression.cpp +++ b/common/system/expressions/var_expression.cpp @@ -7,19 +7,19 @@ VarExpression::VarExpression(uint16_t triggerNum, FilterData_e dataMember) { this->setTriggerNum(triggerNum); } -void VarExpression::evaluate(FilterData_s *filterData, - ExpressionPtrCallback &expressionPtrCallback) { +void VarExpression::evaluate(FilterData_s* filterData, + ExpressionPtrCallback& expressionPtrCallback) { this->setNumberValue( static_cast(getVariableValue(filterData, this->dataMember))); } int VarExpression::toString( - char *buffer, int n, ExpressionPtrCallback &expressionPtrCallback) const { + char* buffer, int n, ExpressionPtrCallback& expressionPtrCallback) const { fillVariableName(buffer, n, this->dataMember); return strnlen(buffer, 17); } -void VarExpression::serializeInto(SerializedExpression_s *serialized) const { +void VarExpression::serializeInto(SerializedExpression_s* serialized) const { serialized->triggerNum = this->triggerNum; serialized->type = variable; serialized->contents.variable = this->dataMember; diff --git a/common/system/expressions/var_expression.h b/common/system/expressions/var_expression.h index 21a7d3c8..0ae4ca5d 100644 --- a/common/system/expressions/var_expression.h +++ b/common/system/expressions/var_expression.h @@ -21,13 +21,13 @@ class VarExpression : public Expression { */ VarExpression(uint16_t triggerNum, FilterData_e dataMember); - void evaluate(FilterData_s *filterData, - ExpressionPtrCallback &expressionPtrCallback); + void evaluate(FilterData_s* filterData, + ExpressionPtrCallback& expressionPtrCallback); - int toString(char *buffer, int n, - ExpressionPtrCallback &expressionPtrCallback) const; + int toString(char* buffer, int n, + ExpressionPtrCallback& expressionPtrCallback) const; - void serializeInto(SerializedExpression_s *serialized) const; + void serializeInto(SerializedExpression_s* serialized) const; }; #endif // COMMON_SYSTEM_EXPRESSIONS_VAR_EXPRESSION_H_ diff --git a/common/system/filtering/filterdata_types.cpp b/common/system/filtering/filterdata_types.cpp index c0afc1e5..3914d44a 100644 --- a/common/system/filtering/filterdata_types.cpp +++ b/common/system/filtering/filterdata_types.cpp @@ -4,7 +4,7 @@ * and run it with Python to generate this file automatically. */ #include "filterdata_types.h" -FilterData_e getVariableEnumFromString(char *input) { +FilterData_e getVariableEnumFromString(char* input) { if (strncmp(input, "heading", 7) == 0) { return heading; } @@ -92,7 +92,7 @@ FilterData_e getVariableEnumFromString(char *input) { // Matched no other valid value return invalid; } -double getVariableValue(FilterData_s *filterData, FilterData_e valueType) { +double getVariableValue(FilterData_s* filterData, FilterData_e valueType) { switch (valueType) { case invalid: return 0; @@ -156,7 +156,7 @@ double getVariableValue(FilterData_s *filterData, FilterData_e valueType) { return 0; } } -void fillVariableName(char *buffer, size_t n, FilterData_e valueType) { +void fillVariableName(char* buffer, size_t n, FilterData_e valueType) { switch (valueType) { case invalid: strncpy(buffer, "invalid", n); diff --git a/common/system/filtering/filterdata_types.h b/common/system/filtering/filterdata_types.h index 79ef2edb..1592bdbe 100644 --- a/common/system/filtering/filterdata_types.h +++ b/common/system/filtering/filterdata_types.h @@ -76,9 +76,9 @@ typedef enum { angle_vertical, } FilterData_e; -FilterData_e getVariableEnumFromString(char *input); -double getVariableValue(FilterData_s *filterData, FilterData_e valueType); -void fillVariableName(char *buffer, size_t n, FilterData_e valueType); +FilterData_e getVariableEnumFromString(char* input); +double getVariableValue(FilterData_s* filterData, FilterData_e valueType); +void fillVariableName(char* buffer, size_t n, FilterData_e valueType); #ifdef __cplusplus } #endif diff --git a/common/system/hardware_manager.cpp b/common/system/hardware_manager.cpp index d4c98fe9..0e70adbf 100644 --- a/common/system/hardware_manager.cpp +++ b/common/system/hardware_manager.cpp @@ -260,7 +260,7 @@ static size_t SENSOR_DATA_SIZE = sizeof(SensorData_s); /* Hardware manager sim mode trackers */ static bool inSim = false; -static CircularBuffer_s *simRxBuffer = NULL; +static CircularBuffer_s* simRxBuffer = NULL; void hm_hardwareInit() { /* Accelerometers */ @@ -299,7 +299,7 @@ void hm_hardwareInit() { // Register each client with the 1 chip (1 chip should be enforced by config) for (int i = 0; i < NUM_BLE_CLIENT_STD; i++) { #if HAS_DEV(BLE_CHIP_NRF) - bleClientStd_init(&bleClientStd[i], (BleChip_s *)(&bleChipNrf[0]), + bleClientStd_init(&bleClientStd[i], (BleChip_s*)(&bleChipNrf[0]), bleClientStdAddress[i]); #endif // HAS_DEV(BLE_CHIP_NRF) hardwareStatusBleClient[FIRST_ID_BLE_CLIENT_STD + i] = true; @@ -407,7 +407,7 @@ void hm_hardwareInit() { hardwareStatusPyro[FIRST_ID_PYRO_DIGITAL + i] = true; } halCallbacks_registerTimPeriodElapsedCallback( - pyroDigitalTickTim, (void (*)(void *))(hm_pyroUpdate), NULL); + pyroDigitalTickTim, (void (*)(void*))(hm_pyroUpdate), NULL); HAL_TIM_Base_Start_IT(pyroDigitalTickTim); #endif // HAS_DEV(PYRO_DIGITAL) @@ -417,7 +417,7 @@ void hm_hardwareInit() { // Register each BLE line cutter with the 1 chip (1 chip should be enforced // by config) #if HAS_DEV(BLE_CHIP_NRF) - lineCutterBle_init(&lineCutterBle[i], (BleChip_s *)(&bleChipNrf[0]), + lineCutterBle_init(&lineCutterBle[i], (BleChip_s*)(&bleChipNrf[0]), lineCutterBleAddress[i]); hardwareStatusLineCutter[FIRST_ID_LINE_CUTTER_BLE + i] = true; #endif // HAS_DEV(BLE_CHIP_NRF) @@ -562,7 +562,7 @@ void hm_hardwareInit() { uint32_t hm_millis() { return HAL_GetTick(); } bool hm_flashReadStart(int flashId, uint32_t startLoc, uint32_t numBytes, - uint8_t *pData) { + uint8_t* pData) { #if HAS_DEV(FLASH_S25FLX) if (IS_DEVICE(flashId, FLASH_S25FLX)) { return flashS25flx_readStart( @@ -581,7 +581,7 @@ bool hm_flashReadStart(int flashId, uint32_t startLoc, uint32_t numBytes, } bool hm_flashWriteStart(int flashId, uint32_t startLoc, uint32_t numBytes, - uint8_t *data) { + uint8_t* data) { #if HAS_DEV(FLASH_S25FLX) if (IS_DEVICE(flashId, FLASH_S25FLX)) { return flashS25flx_writeStart( @@ -707,18 +707,18 @@ void hm_ledToggle(int ledId) { #endif // HAS_DEV(LED_DIGITAL) } -bool hm_radioSend(int radioNum, uint8_t *data, uint16_t numBytes) { +bool hm_radioSend(int radioNum, uint8_t* data, uint16_t numBytes) { (void)numBytes; #if HAS_DEV(RADIO_TI_433) if (IS_DEVICE(radioNum, RADIO_TI_433)) { - TiRadioCtrl_s *pRadio = &radioTi433[radioNum - FIRST_ID_RADIO_TI_433]; + TiRadioCtrl_s* pRadio = &radioTi433[radioNum - FIRST_ID_RADIO_TI_433]; return tiRadio_addTxPacket(pRadio, data, pRadio->payloadSize); } #endif // HAS_DEV(RADIO_TI_433) #if HAS_DEV(RADIO_TI_915) if (IS_DEVICE(radioNum, RADIO_TI_915)) { - TiRadioCtrl_s *pRadio = &radioTi915[radioNum - FIRST_ID_RADIO_TI_915]; + TiRadioCtrl_s* pRadio = &radioTi915[radioNum - FIRST_ID_RADIO_TI_915]; return tiRadio_addTxPacket(pRadio, data, pRadio->payloadSize); } #endif // HAS_DEV(RADIO_TI_915) @@ -740,17 +740,17 @@ void hm_radioUpdate() { #endif // HAS_DEV(RADIO_TI_915) } -void hm_radioRegisterConsumer(int radioNum, CircularBuffer_s *rxBuffer) { +void hm_radioRegisterConsumer(int radioNum, CircularBuffer_s* rxBuffer) { #if HAS_DEV(RADIO_TI_433) if (IS_DEVICE(radioNum, RADIO_TI_433)) { - TiRadioCtrl_s *pRadio = &radioTi433[radioNum - FIRST_ID_RADIO_TI_433]; + TiRadioCtrl_s* pRadio = &radioTi433[radioNum - FIRST_ID_RADIO_TI_433]; tiRadio_registerConsumer(pRadio, rxBuffer); } #endif // HAS_DEV(RADIO_TI_433) #if HAS_DEV(RADIO_TI_915) if (IS_DEVICE(radioNum, RADIO_TI_915)) { - TiRadioCtrl_s *pRadio = &radioTi915[radioNum - FIRST_ID_RADIO_TI_915]; + TiRadioCtrl_s* pRadio = &radioTi915[radioNum - FIRST_ID_RADIO_TI_915]; tiRadio_registerConsumer(pRadio, rxBuffer); } #endif // HAS_DEV(RADIO_TI_915) @@ -761,7 +761,7 @@ void hm_radioSetChannel(int radioNum, int channel) { // We set channels by starting from channel 0's frequency and incrementing // by a fixed bandwidth between channels float centerFrequency; - TiRadioCtrl_s *rad = NULL; + TiRadioCtrl_s* rad = NULL; TiRadioBand_e band; #if HAS_DEV(RADIO_TI_433) @@ -795,7 +795,7 @@ bool hm_usbIsConnected(int usbId) { return false; } -bool hm_usbTransmit(int usbId, uint8_t *data, uint16_t numBytes) { +bool hm_usbTransmit(int usbId, uint8_t* data, uint16_t numBytes) { #if HAS_DEV(USB_STD) if (IS_DEVICE(usbId, USB_STD)) { return usbStd_transmit(data, numBytes); @@ -805,7 +805,7 @@ bool hm_usbTransmit(int usbId, uint8_t *data, uint16_t numBytes) { return false; } -CircularBuffer_s *hm_usbGetRxBuffer(int usbId) { +CircularBuffer_s* hm_usbGetRxBuffer(int usbId) { #if HAS_DEV(USB_STD) if (IS_DEVICE(usbId, USB_STD)) { return usbStd_getRxBuffer(); @@ -827,7 +827,7 @@ bool hm_bleClientConnected(int bleClientId) { return false; } -bool hm_bleClientSend(int bleClientId, const uint8_t *data, uint16_t numBytes) { +bool hm_bleClientSend(int bleClientId, const uint8_t* data, uint16_t numBytes) { #if HAS_DEV(BLE_CLIENT_STD) if (IS_DEVICE(bleClientId, BLE_CLIENT_STD)) { return bleClientStd[bleClientId - FIRST_ID_BLE_CLIENT_STD] @@ -840,7 +840,7 @@ bool hm_bleClientSend(int bleClientId, const uint8_t *data, uint16_t numBytes) { return false; } -CircularBuffer_s *hm_bleClientGetRxBuffer(int bleClientId) { +CircularBuffer_s* hm_bleClientGetRxBuffer(int bleClientId) { #if HAS_DEV(BLE_CLIENT_STD) if (IS_DEVICE(bleClientId, BLE_CLIENT_STD)) { return &bleClientStd[bleClientId - FIRST_ID_BLE_CLIENT_STD].parsedBuffer; @@ -869,7 +869,7 @@ void hm_bleTick() { #endif // HAS_DEV(LINE_CUTTER_BLE) } -LineCutterData_s *hm_getLineCutterData(int lineCutterId) { +LineCutterData_s* hm_getLineCutterData(int lineCutterId) { #if HAS_DEV(LINE_CUTTER_BLE) if (IS_DEVICE(lineCutterId, LINE_CUTTER_BLE)) { return &lineCutterBle[lineCutterId - FIRST_ID_LINE_CUTTER_BLE].lastData; @@ -878,7 +878,7 @@ LineCutterData_s *hm_getLineCutterData(int lineCutterId) { return NULL; } -LineCutterFlightVars_s *hm_getLineCutterFlightVariables(int lineCutterId) { +LineCutterFlightVars_s* hm_getLineCutterFlightVariables(int lineCutterId) { #if HAS_DEV(LINE_CUTTER_BLE) if (IS_DEVICE(lineCutterId, LINE_CUTTER_BLE)) { return &lineCutterBle[lineCutterId - FIRST_ID_LINE_CUTTER_BLE].flightVars; @@ -887,7 +887,7 @@ LineCutterFlightVars_s *hm_getLineCutterFlightVariables(int lineCutterId) { return NULL; } -bool hm_lineCutterSendString(int lineCutterNumber, char *string) { +bool hm_lineCutterSendString(int lineCutterNumber, char* string) { if (!string) return false; #if HAS_DEV(LINE_CUTTER_BLE) for (int i = 0; i < NUM_LINE_CUTTER_BLE; i++) { @@ -958,7 +958,7 @@ void hm_pyroSetPwm(int pyroId, uint32_t duration, uint32_t frequency, #endif // HAS_DEV(PYRO_DIGITAL) } -void hm_pyroUpdate(void *pUserData) { +void hm_pyroUpdate(void* pUserData) { #if HAS_DEV(PYRO_DIGITAL) for (int i = 0; i < NUM_PYRO_DIGITAL; i++) { pyroDigital_tick(&pyroDigital[i]); @@ -1108,11 +1108,11 @@ void hm_readSensorData() { } } -SensorData_s *hm_getSensorData() { return &sensorData; } +SensorData_s* hm_getSensorData() { return &sensorData; } -SensorProperties_s *hm_getSensorProperties() { return &sensorProperties; } +SensorProperties_s* hm_getSensorProperties() { return &sensorProperties; } -void hm_enableSimMode(CircularBuffer_s *rxBuffer) { +void hm_enableSimMode(CircularBuffer_s* rxBuffer) { inSim = true; simRxBuffer = rxBuffer; } diff --git a/common/system/states/cli/state_cli_offload.cpp b/common/system/states/cli/state_cli_offload.cpp index a5832557..c284d521 100644 --- a/common/system/states/cli/state_cli_offload.cpp +++ b/common/system/states/cli/state_cli_offload.cpp @@ -11,7 +11,7 @@ #include "data_log.h" // This include is only needed to pass a flightID to userSetFlightID before command line implementation #include "data_offload.h" -static void formatTimeSeconds(char *result, int resultLen, uint32_t seconds) { +static void formatTimeSeconds(char* result, int resultLen, uint32_t seconds) { uint32_t minutes = seconds / 60; seconds %= 60; @@ -87,7 +87,7 @@ EndCondition_e CliOffloadState::run() { cli_send(sendString); for (uint8_t num = 1; num <= lastFlightNum; ++num) { dataLog_readFlightNumMetadata(num); - FlightMetadata_s *metadataPacket = dataLog_getFlightMetadata(); + FlightMetadata_s* metadataPacket = dataLog_getFlightMetadata(); flight_timestamp = (time_t)metadataPacket->gpsTimestamp; // Check timestamp between 2000 and 2100 if (flight_timestamp > 946702800 && flight_timestamp < 4102462800) { diff --git a/common/system/tasks/cli/task_cli_sense.cpp b/common/system/tasks/cli/task_cli_sense.cpp index f0cbc7e0..a1580e77 100644 --- a/common/system/tasks/cli/task_cli_sense.cpp +++ b/common/system/tasks/cli/task_cli_sense.cpp @@ -9,7 +9,7 @@ #include "hardware_manager.h" #if HAS_DEV(FLASH) -static void flashUsageBar(char *barStr, uint8_t usage, uint8_t totalBarWidth) { +static void flashUsageBar(char* barStr, uint8_t usage, uint8_t totalBarWidth) { barStr[0] = '['; int i; for (i = 1; i <= (usage / 100.0) * totalBarWidth; ++i) { @@ -30,7 +30,7 @@ void CliTasks::sense() { // Read sensor data and send in human-readable format hm_readSensorData(); - SensorData_s *data = hm_getSensorData(); + SensorData_s* data = hm_getSensorData(); char cliStr[60]; char float1[10]; char float2[10]; diff --git a/common/system/tasks/data_log.cpp b/common/system/tasks/data_log.cpp index 49323289..0ad60b48 100644 --- a/common/system/tasks/data_log.cpp +++ b/common/system/tasks/data_log.cpp @@ -102,8 +102,8 @@ static const uint16_t kFlightMetadataSize = sizeof(FlightMetadata_s); static const uint16_t kWrappedCliConfigSize = sizeof(WrappedCliConfigs_s); -static void addressToFlashId(uint32_t startLoc, int *flashId, - uint32_t *flashOffset) { +static void addressToFlashId(uint32_t startLoc, int* flashId, + uint32_t* flashOffset) { uint32_t sum = 0; for (int i = 0; i < NUM_FLASH; i++) { if (startLoc < kFlashSizeBytes[i] + sum) { @@ -115,7 +115,7 @@ static void addressToFlashId(uint32_t startLoc, int *flashId, } } -static void flashRead(uint32_t startLoc, uint32_t numBytes, uint8_t *pData) { +static void flashRead(uint32_t startLoc, uint32_t numBytes, uint8_t* pData) { int flashId = -1; uint32_t flashOffset = 0; addressToFlashId(startLoc, &flashId, &flashOffset); @@ -126,7 +126,7 @@ static void flashRead(uint32_t startLoc, uint32_t numBytes, uint8_t *pData) { } } -static void flashWrite(uint32_t startLoc, uint32_t numBytes, uint8_t *pData) { +static void flashWrite(uint32_t startLoc, uint32_t numBytes, uint8_t* pData) { uint32_t dataOffset = 0; // Continue writing page by page while (dataOffset < numBytes) { @@ -206,7 +206,7 @@ static uint32_t dataLog_getLastFlightNumType(bool launched) { flashRead(metadataReadAddress, kFlightMetadataSize, metadataBuff); // Read the metadata FlightMetadata_s tempFlightMetadataPacket = - *(FlightMetadata_s *)metadataBuff; + *(FlightMetadata_s*)metadataBuff; if (tempFlightMetadataPacket.launched == 1) { // Only update last if it was launched lastFlightNum = tempFlightNum; @@ -230,8 +230,8 @@ uint32_t dataLog_getLastLaunchedFlightNum() { return dataLog_getLastFlightNumType(true); } -static void dataLog_getFlightSectors(uint32_t flightNum, uint32_t *firstSector, - uint32_t *lastSector) { +static void dataLog_getFlightSectors(uint32_t flightNum, uint32_t* firstSector, + uint32_t* lastSector) { *firstSector = 0; *lastSector = 0; uint32_t tempCurSectorNum = 1; @@ -326,10 +326,10 @@ void dataLog_readFlightNumMetadata(uint32_t flightNum) { uint32_t metadataReadAddress = firstSector * FLASH_MAX_SECTOR_BYTES; // Read the metadata flashRead(metadataReadAddress, kFlightMetadataSize, metadataBuff); - flightMetadataPacket = *(FlightMetadata_s *)metadataBuff; + flightMetadataPacket = *(FlightMetadata_s*)metadataBuff; } -FlightMetadata_s *dataLog_getFlightMetadata() { return &flightMetadataPacket; } +FlightMetadata_s* dataLog_getFlightMetadata() { return &flightMetadataPacket; } void dataLog_writeFlightMetadata() { if (curFlightNum > 0) { @@ -338,11 +338,11 @@ void dataLog_writeFlightMetadata() { FLASH_MAX_SECTOR_BYTES; // Metadata is located at the // start of the flight sector flashWrite(metadataWriteAddress, kFlightMetadataSize, - (uint8_t *)&flightMetadataPacket); // Write the metadata packet + (uint8_t*)&flightMetadataPacket); // Write the metadata packet } } -void dataLog_write(SensorData_s *sensorData, FilterData_s *filterData, +void dataLog_write(SensorData_s* sensorData, FilterData_s* filterData, uint8_t state) { if (curFlightNum > 0) { // Check if current sector is beyond flash capacity. If so, stop @@ -351,7 +351,7 @@ void dataLog_write(SensorData_s *sensorData, FilterData_s *filterData, LogData_s logPacket; logPacket.packetType = LOG_ID_FCB; logPacket.timestampMs = sensorData->timestampMs; - FcbLogData_s *fcbLogData = &(logPacket.dataPacket.fcbData); + FcbLogData_s* fcbLogData = &(logPacket.dataPacket.fcbData); #if HAS_DEV(MAG) for (int i = 0; i < NUM_IMU; i++) { fcbLogData->imuData[i].accel = sensorData->imuData[i].accelRaw; @@ -450,7 +450,7 @@ void dataLog_write(SensorData_s *sensorData, FilterData_s *filterData, cb_peek(&logPacketBuffer, (unknownPtr_t)&dequeuedData, &numElements); while (numElements != 0) { cb_dequeue(&logPacketBuffer, 1); - flashWrite(curWriteAddress, kLogDataSize, (uint8_t *)&dequeuedData); + flashWrite(curWriteAddress, kLogDataSize, (uint8_t*)&dequeuedData); // Increment write address to be next address to write to curWriteAddress += kLogDataSize; cb_peek(&logPacketBuffer, (unknownPtr_t)&dequeuedData, &numElements); @@ -460,7 +460,7 @@ void dataLog_write(SensorData_s *sensorData, FilterData_s *filterData, } } -uint32_t dataLog_read(uint32_t flightNum, uint32_t maxBytes, uint8_t *pdata, +uint32_t dataLog_read(uint32_t flightNum, uint32_t maxBytes, uint8_t* pdata, bool reset) { static uint32_t firstSector; static uint32_t lastSector; @@ -502,7 +502,7 @@ uint32_t dataLog_read(uint32_t flightNum, uint32_t maxBytes, uint8_t *pdata, return maxBytes; } -static bool packetIsEmpty(uint8_t *buffer, uint16_t packetSize) { +static bool packetIsEmpty(uint8_t* buffer, uint16_t packetSize) { for (int i = 0; i < packetSize; ++i) { if (buffer[i] != 0xFF) return false; } @@ -536,7 +536,7 @@ static uint32_t dataLog_getLastPacketType(uint32_t firstAddress, } uint32_t dataLog_getLastFlightTimestamp(uint32_t flightNum) { - LogData_s *dataPacket; + LogData_s* dataPacket; uint32_t firstSector; uint32_t lastSector; // Find sectors of flight num using metadata @@ -553,7 +553,7 @@ uint32_t dataLog_getLastFlightTimestamp(uint32_t flightNum) { (sectorBytes - FLIGHT_METADATA_PAGES * FLASH_MIN_PAGE_SIZE_BYTES) / kLogDataSize; dataLog_getLastPacketType(firstAddress, maxCount, kLogDataSize); - dataPacket = (LogData_s *)tempPacketBuffer; + dataPacket = (LogData_s*)tempPacketBuffer; return dataPacket->timestampMs; } @@ -564,7 +564,7 @@ uint8_t dataLog_getFlashUsage() { } void dataLog_loadCliConfigs() { - CliConfigs_s *cliConfig = cli_getConfigs(); + CliConfigs_s* cliConfig = cli_getConfigs(); uint32_t firstAddress = CONFIG_START_ADDRESS; uint32_t maxCount = (FLASH_MAX_SECTOR_BYTES - CONFIG_START_ADDRESS) / kWrappedCliConfigSize; @@ -572,9 +572,9 @@ void dataLog_loadCliConfigs() { dataLog_getLastPacketType(firstAddress, maxCount, kWrappedCliConfigSize); flashRead(lastPacketAddress, kWrappedCliConfigSize, tempPacketBuffer); currentConfigAddress = kWrappedCliConfigSize + lastPacketAddress; - wrappedConfig = *(WrappedCliConfigs_s *)tempPacketBuffer; + wrappedConfig = *(WrappedCliConfigs_s*)tempPacketBuffer; crc.reset(); - crc.add((uint8_t *)&(wrappedConfig.cliConfigs), sizeof(CliConfigs_s)); + crc.add((uint8_t*)&(wrappedConfig.cliConfigs), sizeof(CliConfigs_s)); uint16_t calculatedCRC = crc.getCRC(); if (calculatedCRC != wrappedConfig.crc) { cli_setDefaultConfig(); @@ -591,14 +591,14 @@ void dataLog_loadCliConfigs() { } void dataLog_writeCliConfigs() { - CliConfigs_s *cliConfig = cli_getConfigs(); + CliConfigs_s* cliConfig = cli_getConfigs(); wrappedConfig.cliConfigs = *cliConfig; crc.reset(); - crc.add((uint8_t *)cliConfig, sizeof(CliConfigs_s)); + crc.add((uint8_t*)cliConfig, sizeof(CliConfigs_s)); wrappedConfig.crc = crc.getCRC(); // Write configs to flash flashWrite(currentConfigAddress, kWrappedCliConfigSize, - (uint8_t *)&wrappedConfig); + (uint8_t*)&wrappedConfig); currentConfigAddress += kWrappedCliConfigSize; if (currentConfigAddress > FLASH_MAX_SECTOR_BYTES - kWrappedCliConfigSize) { diff --git a/common/system/tasks/data_log.h b/common/system/tasks/data_log.h index 230b6233..319a8aa5 100644 --- a/common/system/tasks/data_log.h +++ b/common/system/tasks/data_log.h @@ -64,7 +64,7 @@ void dataLog_loadLastStoredFlightMetadata(); * @brief Get current flight metadata * @return Pointer to current FlightMetadata_s */ -FlightMetadata_s *dataLog_getFlightMetadata(); +FlightMetadata_s* dataLog_getFlightMetadata(); /** * @brief Load metadata from a flight load into the current packet @@ -82,7 +82,7 @@ void dataLog_writeFlightMetadata(); * @param filterData: Filter info to write to log * @param state: Current state ID to write to log */ -void dataLog_write(SensorData_s *sensorData, FilterData_s *filterData, +void dataLog_write(SensorData_s* sensorData, FilterData_s* filterData, uint8_t state); /** @@ -96,7 +96,7 @@ void dataLog_write(SensorData_s *sensorData, FilterData_s *filterData, * flightNum no matter what * @return Number of bytes actually read from the data log */ -uint32_t dataLog_read(uint32_t flightNum, uint32_t maxBytes, uint8_t *pdata, +uint32_t dataLog_read(uint32_t flightNum, uint32_t maxBytes, uint8_t* pdata, bool reset); /** diff --git a/common/system/tasks/event_manager.cpp b/common/system/tasks/event_manager.cpp index f65bf8fb..52b04ef8 100644 --- a/common/system/tasks/event_manager.cpp +++ b/common/system/tasks/event_manager.cpp @@ -2,7 +2,7 @@ static bool eventStatus[Event_e::NUM_EVENT]; void eventManager_init() { - for (bool &b : eventStatus) { + for (bool& b : eventStatus) { b = false; } } diff --git a/common/system/tasks/radio_manager.cpp b/common/system/tasks/radio_manager.cpp index 974db66e..1e801be7 100644 --- a/common/system/tasks/radio_manager.cpp +++ b/common/system/tasks/radio_manager.cpp @@ -23,7 +23,7 @@ static DataTransmitState_s lastSent[NUM_RADIO]; static RadioPacket_s transmitPacket[NUM_RADIO]; -static const char *call = "KM6GNL"; +static const char* call = "KM6GNL"; // https://stackoverflow.com/q/9695329 #define ROUND_2_INT(f) ((int)((f) >= 0.0 ? (f + 0.5) : (f - 0.5))) @@ -69,7 +69,7 @@ void radioManager_tick() { } void radioManager_sendInternal(int radioId) { - hm_radioSend(radioId, (uint8_t *)&transmitPacket[radioId], + hm_radioSend(radioId, (uint8_t*)&transmitPacket[radioId], sizeof(RadioPacket_s)); } @@ -83,8 +83,8 @@ void radioManager_addMessageCallback(int radioId, RadioCallback_t callback) { #define POSITION_RATE 10 #define HARDWARE_STATUS_RATE 1 -void radioManager_transmitData(int radioId, SensorData_s *sensorData, - FilterData_s *filterData, uint8_t state) { +void radioManager_transmitData(int radioId, SensorData_s* sensorData, + FilterData_s* filterData, uint8_t state) { uint32_t currentTime = hm_millis(); if (currentTime % RADIO_INTERVAL_MS >= RADIO_SEND_MS) return; transmitPacket[radioId].timestampMs = currentTime; @@ -256,7 +256,7 @@ void radioManager_transmitData(int radioId, SensorData_s *sensorData, #endif // HAS_DEV(LINE_CUTTER) } -void radioManager_transmitString(int radioId, uint8_t *data, size_t len) { +void radioManager_transmitString(int radioId, uint8_t* data, size_t len) { static uint8_t lastTxId = 0; while (len) { @@ -300,6 +300,6 @@ void radioManager_transmitString(int radioId, uint8_t *data, size_t len) { } } -void radioManager_transmitStringDefault(uint8_t *data, size_t len) { +void radioManager_transmitStringDefault(uint8_t* data, size_t len) { radioManager_transmitString(RADIO_CLI_ID, data, len); } diff --git a/common/system/tasks/trigger_manager.h b/common/system/tasks/trigger_manager.h index 9b3f785d..8f1bdeca 100644 --- a/common/system/tasks/trigger_manager.h +++ b/common/system/tasks/trigger_manager.h @@ -45,7 +45,7 @@ enum class TriggerState { /** * @brief Manage array because Sam says users are stupid */ -const char *triggerManager_triggerStatusToString(TriggerState i); +const char* triggerManager_triggerStatusToString(TriggerState i); /** * @brief Initializes Trigger Manager @@ -71,7 +71,7 @@ void triggerManager_setTriggerFireStatus(uint16_t status); * updates triggerManager_checkExpectedTriggers() * @param filterData: Current filter data */ -void triggerManager_update(FilterData_s *filterData); +void triggerManager_update(FilterData_s* filterData); /** * @brief Sets a default configuration for triggers, presuming that current @@ -94,7 +94,7 @@ void triggerManager_triggerFire(uint8_t triggerNum, bool logFire); * @param configString string to parse as config */ bool triggerManager_setTriggerConfig(uint8_t triggerNum, - const char **configString); + const char** configString); /** * @brief returns the configuration of the Trigger @@ -115,7 +115,7 @@ void triggerManager_removeTrigger(uint8_t triggerNum); * @param Buffer to fill * @param size of buffer */ -void triggerManager_getConfigString(uint8_t triggerNum, char *buffer, int n); +void triggerManager_getConfigString(uint8_t triggerNum, char* buffer, int n); #ifdef __cplusplus } #endif diff --git a/common/utils/circular_buffer.c b/common/utils/circular_buffer.c index 6058cc87..7e168691 100644 --- a/common/utils/circular_buffer.c +++ b/common/utils/circular_buffer.c @@ -6,7 +6,7 @@ #include -void cb_init(CircularBuffer_s *cb, unknownPtr_t buffer, size_t capacity, +void cb_init(CircularBuffer_s* cb, unknownPtr_t buffer, size_t capacity, size_t size) { if (cb == NULL) { return; @@ -20,8 +20,8 @@ void cb_init(CircularBuffer_s *cb, unknownPtr_t buffer, size_t capacity, cb->tail = cb->buffer; } -void cb_peek(CircularBuffer_s *cb, unknownPtr_t outputBuffer, - size_t *numElements) { +void cb_peek(CircularBuffer_s* cb, unknownPtr_t outputBuffer, + size_t* numElements) { if (cb == NULL || outputBuffer == NULL) return; size_t count = cb_count(cb); @@ -42,7 +42,7 @@ void cb_peek(CircularBuffer_s *cb, unknownPtr_t outputBuffer, } } -size_t cb_count(CircularBuffer_s *cb) { +size_t cb_count(CircularBuffer_s* cb) { if (!cb) { return 0; } @@ -59,11 +59,11 @@ size_t cb_count(CircularBuffer_s *cb) { return ret_bytes / cb->size; } -size_t cb_capacity(CircularBuffer_s *cb) { +size_t cb_capacity(CircularBuffer_s* cb) { return ((size_t)(cb->buffer_end - cb->buffer) / cb->size) - (size_t)1u; } -bool cb_enqueue(CircularBuffer_s *cb, const unknownPtr_t item) { +bool cb_enqueue(CircularBuffer_s* cb, const unknownPtr_t item) { // Figure out what next spot to fill in buffer is unknownPtr_t next = cb->head + cb->size; if (next >= cb->buffer_end) { @@ -81,7 +81,7 @@ bool cb_enqueue(CircularBuffer_s *cb, const unknownPtr_t item) { return true; } -void cb_dequeue(CircularBuffer_s *cb, size_t numElements) { +void cb_dequeue(CircularBuffer_s* cb, size_t numElements) { size_t count = cb_count(cb); if (numElements > count) { numElements = count; @@ -93,7 +93,7 @@ void cb_dequeue(CircularBuffer_s *cb, size_t numElements) { } } -bool cb_full(CircularBuffer_s *cb) { +bool cb_full(CircularBuffer_s* cb) { unknownPtr_t next = cb->head + cb->size; if (next >= cb->buffer_end) { next = cb->buffer; @@ -102,4 +102,4 @@ bool cb_full(CircularBuffer_s *cb) { return next == cb->tail; } -void cb_flush(CircularBuffer_s *cb) { cb->tail = cb->head; } +void cb_flush(CircularBuffer_s* cb) { cb->tail = cb->head; } diff --git a/common/utils/circular_buffer.h b/common/utils/circular_buffer.h index b5d851f8..1d6db7d4 100644 --- a/common/utils/circular_buffer.h +++ b/common/utils/circular_buffer.h @@ -13,7 +13,7 @@ extern "C" { #include #include -#define unknownPtr_t uint8_t * +#define unknownPtr_t uint8_t* typedef struct { // We use @@ -35,7 +35,7 @@ typedef struct { * Note that circular buffer wraps an existing buffer. Memory of the existing * buffer must be allocated externally. */ -void cb_init(CircularBuffer_s *cb, unknownPtr_t buffer, size_t capacity, +void cb_init(CircularBuffer_s* cb, unknownPtr_t buffer, size_t capacity, size_t size); /** @@ -47,22 +47,22 @@ void cb_init(CircularBuffer_s *cb, unknownPtr_t buffer, size_t capacity, * @param numElements: [in] Max number of elements to read, or NULL if all * elements should be read. [out] Number of elements actually read */ -void cb_peek(CircularBuffer_s *cb, unknownPtr_t outputBuffer, - size_t *numElements); +void cb_peek(CircularBuffer_s* cb, unknownPtr_t outputBuffer, + size_t* numElements); /** * @brief Get the number of items currently in the circular buffer * @param cb: Circular buffer to get count of * @return Number of items in buffer */ -size_t cb_count(CircularBuffer_s *cb); +size_t cb_count(CircularBuffer_s* cb); /** * @brief Get the maximum number of items this buffer can hold * @param cb: Circular buffer to get capacity of * @return Max items it can hold */ -size_t cb_capacity(CircularBuffer_s *cb); +size_t cb_capacity(CircularBuffer_s* cb); /** * @brief Adds an item to the queue if there's room. If buffer is at capacity, @@ -72,7 +72,7 @@ size_t cb_capacity(CircularBuffer_s *cb); * size * @return: True if successful, false if buffer full */ -bool cb_enqueue(CircularBuffer_s *cb, const unknownPtr_t item); +bool cb_enqueue(CircularBuffer_s* cb, const unknownPtr_t item); /** * @brief Removes a given number of elements from the front of the circular @@ -80,20 +80,20 @@ bool cb_enqueue(CircularBuffer_s *cb, const unknownPtr_t item); * @param cb: Circular buffer to dequeue * @param numElements: Max number of elements to dequeue */ -void cb_dequeue(CircularBuffer_s *cb, size_t numElements); +void cb_dequeue(CircularBuffer_s* cb, size_t numElements); /** * @brief Return whether circular buffer is full * @param cb: Circular buffer to check * @return: True if circular buffer full, False otherwises */ -bool cb_full(CircularBuffer_s *cb); +bool cb_full(CircularBuffer_s* cb); /** * @brief Delete the circular buffer's contents by resetting it * @param cb: Circular buffer to flush */ -void cb_flush(CircularBuffer_s *cb); +void cb_flush(CircularBuffer_s* cb); #ifdef __cplusplus } diff --git a/common/utils/fcb_matrix.h b/common/utils/fcb_matrix.h index a0dee61b..0c6b3037 100644 --- a/common/utils/fcb_matrix.h +++ b/common/utils/fcb_matrix.h @@ -84,7 +84,7 @@ class Matrix { * @return New matrix from the multiplication, Rows * Columns of other */ template - Matrix operator*(const Matrix &other) { + Matrix operator*(const Matrix& other) { static_assert(Cols == oRows, "Must multiply matrices with matching column and row count " "(a x n * n x b)"); @@ -133,7 +133,7 @@ class Matrix { * @return New matrix from the multiplication */ template - Matrix operator^(const Matrix &other) { + Matrix operator^(const Matrix& other) { static_assert(Rows == oRows && Cols == oCols, "Matrices must have same dimension!"); float newElems[Rows * Cols] = {0}; @@ -153,7 +153,7 @@ class Matrix { * @return New matrix from the addition */ template - Matrix operator+(const Matrix &other) { + Matrix operator+(const Matrix& other) { static_assert(Rows == oRows && Cols == oCols, "Matrices must have same dimension!"); float newElems[Rows * Cols] = {0}; @@ -176,7 +176,7 @@ class Matrix { * @return New matrix from the subtraction */ template - Matrix operator-(const Matrix &other) { + Matrix operator-(const Matrix& other) { static_assert(Rows == oRows && Cols == oCols, "Matrices must have same dimension!"); float newElems[Rows * Cols] = {0}; @@ -290,7 +290,7 @@ class Matrix { /** * @brief Calculate elementwise cosine of the values in the given matrix */ - static Matrix cos(const Matrix &start) { + static Matrix cos(const Matrix& start) { float32_t values[Rows * Cols] = {0}; for (int i = 0; i < Rows * Cols; ++i) { values[i] = arm_cos_f32(start.m_backingArray[i]); @@ -301,7 +301,7 @@ class Matrix { /** * @brief Calculate elementwise sine of the values in the given matrix */ - static Matrix sin(const Matrix &start) { + static Matrix sin(const Matrix& start) { float32_t values[Rows * Cols] = {0}; for (int i = 0; i < Rows * Cols; ++i) { values[i] = arm_sin_f32(start.m_backingArray[i]); diff --git a/common/utils/string_slice.cpp b/common/utils/string_slice.cpp index 29bc93c9..bf31b78c 100644 --- a/common/utils/string_slice.cpp +++ b/common/utils/string_slice.cpp @@ -2,7 +2,7 @@ #include -StringSlice::StringSlice(const char **src, int start, int end) { +StringSlice::StringSlice(const char** src, int start, int end) { this->src = src; this->start = start; this->end = end; @@ -16,16 +16,16 @@ StringSlice::StringSlice() { this->len = 0; } -bool StringSlice::operator==(const char *other) const { +bool StringSlice::operator==(const char* other) const { if (strnlen(other, this->len + 1) != static_cast(this->len)) { return false; } return strncmp(other, startPtr(), this->len) == 0; } -const char **StringSlice::basePtr() const { return this->src; } +const char** StringSlice::basePtr() const { return this->src; } -const char *StringSlice::startPtr() const { return *(this->src) + this->start; } +const char* StringSlice::startPtr() const { return *(this->src) + this->start; } int StringSlice::length() const { return this->len; } @@ -33,7 +33,7 @@ char StringSlice::operator[](int index) const { if (index >= length()) { return '\0'; } - const char *src = *(this->src); + const char* src = *(this->src); return src[start + index]; } @@ -41,17 +41,17 @@ StringSlice StringSlice::inner() const { return StringSlice(this->src, start + 1, end - 1); } -const char *StringSlice::endptr() const { +const char* StringSlice::endptr() const { return *(this->src) + length() + this->start; } -void StringSlice::copy(char *buffer, int n) const { +void StringSlice::copy(char* buffer, int n) const { for (int i = 0; i < this->length() && i < n; ++i) { buffer[i] = this->operator[](i); } } -int StringSlice::split(StringSlice *slices, int sliceCount, const char delim) { +int StringSlice::split(StringSlice* slices, int sliceCount, const char delim) { int sliceIndex = 0; int start = 0; int current = 0; diff --git a/common/utils/string_slice.h b/common/utils/string_slice.h index 0c8be278..3026b2da 100644 --- a/common/utils/string_slice.h +++ b/common/utils/string_slice.h @@ -5,7 +5,7 @@ */ class StringSlice { private: - const char **src; + const char** src; int start; int end; int len; @@ -17,7 +17,7 @@ class StringSlice { * @param start The starting character, included * @param end The ending character, excluded */ - StringSlice(const char **src, int start, int end); + StringSlice(const char** src, int start, int end); /** * Default constructor. @@ -27,13 +27,13 @@ class StringSlice { /* * See if this StringSlice matches a string constant. */ - bool operator==(const char *other) const; + bool operator==(const char* other) const; /** * Get a pointer to the first character of the slice. * @return Pointer to the first character in the slice. */ - const char *startPtr() const; + const char* startPtr() const; /** * Get a (double) pointer to the base character of the backing string. @@ -41,7 +41,7 @@ class StringSlice { * This will not necessarily be equivalent to the start of this * slice. */ - const char **basePtr() const; + const char** basePtr() const; /** * Get the length of the slice. @@ -60,14 +60,14 @@ class StringSlice { * Get a pointer to the end of this slice. * @return The endpointer. */ - const char *endptr() const; + const char* endptr() const; /** * Copy characters from this slice into a buffer. * @param buffer buffer to copy into. * @param n number of characters to copy. */ - void copy(char *buffer, int n) const; + void copy(char* buffer, int n) const; /** * If this string is wrapped by (), return a new slice @@ -84,7 +84,7 @@ class StringSlice { * @param delim Delimiter character to split on * @return int representing the number of splits made. */ - int split(StringSlice *slices, int sliceCount, const char delim); + int split(StringSlice* slices, int sliceCount, const char delim); }; #endif // COMMON_UTILS_STRING_SLICE_H_ diff --git a/desktop_projects/desktop_devices/arm_math.h b/desktop_projects/desktop_devices/arm_math.h index f7c9e7d1..1ceddb2d 100644 --- a/desktop_projects/desktop_devices/arm_math.h +++ b/desktop_projects/desktop_devices/arm_math.h @@ -7,7 +7,7 @@ typedef float float32_t; typedef struct { uint16_t numRows; /**< number of rows of the matrix. */ uint16_t numCols; /**< number of columns of the matrix. */ - float32_t *pData; /**< points to the data of the matrix. */ + float32_t* pData; /**< points to the data of the matrix. */ } arm_matrix_instance_f32; #endif // DESKTOP_PROJECTS_DESKTOP_DEVICES_ARM_MATH_H_ diff --git a/desktop_projects/desktop_devices/fake_internal_flash.cpp b/desktop_projects/desktop_devices/fake_internal_flash.cpp index e47c4072..174297bc 100644 --- a/desktop_projects/desktop_devices/fake_internal_flash.cpp +++ b/desktop_projects/desktop_devices/fake_internal_flash.cpp @@ -8,14 +8,14 @@ #include "file_backed_flash.h" #include "internal_flash.h" -extern FileBackedFlash *internalFlash; +extern FileBackedFlash* internalFlash; -bool internalFlash_write(uint32_t RelFlashAddress, uint8_t *data, +bool internalFlash_write(uint32_t RelFlashAddress, uint8_t* data, uint32_t numBytes) { return internalFlash->writeStart(RelFlashAddress, numBytes, data); } -bool internalFlash_read(uint32_t RelFlashAddress, uint8_t *pData, +bool internalFlash_read(uint32_t RelFlashAddress, uint8_t* pData, uint32_t numBytes) { return internalFlash->readStart(RelFlashAddress, numBytes, pData); } diff --git a/desktop_projects/desktop_devices/file_backed_flash.cpp b/desktop_projects/desktop_devices/file_backed_flash.cpp index 0a33ce19..0f6d1dfb 100644 --- a/desktop_projects/desktop_devices/file_backed_flash.cpp +++ b/desktop_projects/desktop_devices/file_backed_flash.cpp @@ -9,8 +9,8 @@ #include bool FileBackedFlash::writeStart(uint32_t startLoc, uint32_t numBytes, - uint8_t *pdata) { - FILE *ptr; + uint8_t* pdata) { + FILE* ptr; ptr = fopen(filepath.c_str(), "r+b"); // w for write, b for binary if (!ptr) return false; @@ -26,8 +26,8 @@ bool FileBackedFlash::writeStart(uint32_t startLoc, uint32_t numBytes, } bool FileBackedFlash::readStart(uint32_t startLoc, uint32_t numBytes, - uint8_t *pdata) { - FILE *ptr; + uint8_t* pdata) { + FILE* ptr; ptr = fopen(filepath.c_str(), "rb"); // r for read, b for binary if (!ptr) return false; @@ -41,7 +41,7 @@ bool FileBackedFlash::readStart(uint32_t startLoc, uint32_t numBytes, return true; } -bool fileExists(const std::string &filename) { +bool fileExists(const std::string& filename) { struct stat buf; if (stat(filename.c_str(), &buf) != -1) { return true; @@ -63,8 +63,8 @@ void FileBackedFlash::reinit(bool overwrite) { ofs.open(filepath, std::ios::out | std::ios::binary); while (len > sizeof(ff)) { size_t bytes_to_write = std::min(sizeof(ff), len); - ofs.write((char *)ff, bytes_to_write); + ofs.write((char*)ff, bytes_to_write); len -= bytes_to_write; } - ofs.write((char *)ff, len); + ofs.write((char*)ff, len); } diff --git a/desktop_projects/desktop_devices/file_backed_flash.h b/desktop_projects/desktop_devices/file_backed_flash.h index 37c7b8f6..12a9ca63 100644 --- a/desktop_projects/desktop_devices/file_backed_flash.h +++ b/desktop_projects/desktop_devices/file_backed_flash.h @@ -18,8 +18,8 @@ class FileBackedFlash { } void reinit(bool overwrite); - bool readStart(uint32_t startLoc, uint32_t numBytes, uint8_t *pdata); - bool writeStart(uint32_t startLoc, uint32_t numBytes, uint8_t *pdata); + bool readStart(uint32_t startLoc, uint32_t numBytes, uint8_t* pdata); + bool writeStart(uint32_t startLoc, uint32_t numBytes, uint8_t* pdata); private: std::string filepath; diff --git a/desktop_projects/desktop_devices/flight_replay.h b/desktop_projects/desktop_devices/flight_replay.h index 8ab68add..d713efcd 100644 --- a/desktop_projects/desktop_devices/flight_replay.h +++ b/desktop_projects/desktop_devices/flight_replay.h @@ -10,7 +10,7 @@ class FlightReplay { public: - virtual void getNext(SensorData_s *data) {} + virtual void getNext(SensorData_s* data) {} virtual ~FlightReplay() = default; }; @@ -19,7 +19,7 @@ class CsvReplay : FlightReplay { public: explicit CsvReplay(std::string path); - void getNext(SensorData_s *data) override; + void getNext(SensorData_s* data) override; ~CsvReplay() = default; diff --git a/desktop_projects/desktop_devices/internal_flash.h b/desktop_projects/desktop_devices/internal_flash.h index 439c0488..b9826573 100644 --- a/desktop_projects/desktop_devices/internal_flash.h +++ b/desktop_projects/desktop_devices/internal_flash.h @@ -12,10 +12,10 @@ extern "C" { #endif -bool internalFlash_write(uint32_t RelFlashAddress, uint8_t *data, +bool internalFlash_write(uint32_t RelFlashAddress, uint8_t* data, uint32_t numBytes); -bool internalFlash_read(uint32_t RelFlashAddress, uint8_t *pData, +bool internalFlash_read(uint32_t RelFlashAddress, uint8_t* pData, uint32_t numBytes); #ifdef __cplusplus diff --git a/desktop_projects/desktop_devices/print_pyro.cpp b/desktop_projects/desktop_devices/print_pyro.cpp index 8176c22b..cc8a1b54 100644 --- a/desktop_projects/desktop_devices/print_pyro.cpp +++ b/desktop_projects/desktop_devices/print_pyro.cpp @@ -5,12 +5,12 @@ #include // NOLINT -void printPyro_init(PrintPyroCtrl_s *pyro, int id) { +void printPyro_init(PrintPyroCtrl_s* pyro, int id) { pyro->expireTime = 0; pyro->id = id; } -void printPyro_start(PrintPyroCtrl_s *pyro, uint32_t duration) { +void printPyro_start(PrintPyroCtrl_s* pyro, uint32_t duration) { pyro->expireTime = std::chrono::duration_cast( std::chrono::system_clock::now().time_since_epoch()) .count() + @@ -18,17 +18,17 @@ void printPyro_start(PrintPyroCtrl_s *pyro, uint32_t duration) { printf("Writing pyro %i to ON\n", pyro->id); } -void printPyro_set(PrintPyroCtrl_s *pyro, bool enable) { +void printPyro_set(PrintPyroCtrl_s* pyro, bool enable) { printf("Setting pyro %i to %s\n", pyro->id, enable ? "ON" : "OFF"); } -void printPyro_pwmStart(PrintPyroCtrl_s *pyro, uint32_t duration, +void printPyro_pwmStart(PrintPyroCtrl_s* pyro, uint32_t duration, uint32_t frequency, uint32_t pulseWidth) { printf("Initializing PWM on pyro %i with %i duty cycle \n", pyro->id, pulseWidth); } -void printPyro_tick(PrintPyroCtrl_s *pyro) { +void printPyro_tick(PrintPyroCtrl_s* pyro) { if (pyro->expireTime != 0 && std::chrono::duration_cast( std::chrono::system_clock::now().time_since_epoch()) diff --git a/desktop_projects/desktop_devices/print_pyro.h b/desktop_projects/desktop_devices/print_pyro.h index 148e655a..d9c79a80 100644 --- a/desktop_projects/desktop_devices/print_pyro.h +++ b/desktop_projects/desktop_devices/print_pyro.h @@ -19,11 +19,11 @@ typedef struct { int id; } PrintPyroCtrl_s; -void printPyro_init(PrintPyroCtrl_s *pyro, int id); -void printPyro_start(PrintPyroCtrl_s *pyro, uint32_t duration); -void printPyro_set(PrintPyroCtrl_s *pyro, bool enable); -void printPyro_tick(PrintPyroCtrl_s *pyro); -void printPyro_pwmStart(PrintPyroCtrl_s *pyro, uint32_t duration, +void printPyro_init(PrintPyroCtrl_s* pyro, int id); +void printPyro_start(PrintPyroCtrl_s* pyro, uint32_t duration); +void printPyro_set(PrintPyroCtrl_s* pyro, bool enable); +void printPyro_tick(PrintPyroCtrl_s* pyro); +void printPyro_pwmStart(PrintPyroCtrl_s* pyro, uint32_t duration, uint32_t frequency, uint32_t pulseWidth); #ifdef __cplusplus } diff --git a/desktop_projects/desktop_devices/tcp_socket.cpp b/desktop_projects/desktop_devices/tcp_socket.cpp index fe70cb62..d16a27e2 100644 --- a/desktop_projects/desktop_devices/tcp_socket.cpp +++ b/desktop_projects/desktop_devices/tcp_socket.cpp @@ -24,7 +24,7 @@ TcpSocket::TcpSocket(int port) { // Forcefully attaching socket to the port 8080 if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, - reinterpret_cast(&opt), sizeof(opt))) { + reinterpret_cast(&opt), sizeof(opt))) { perror("setsockopt"); exit(EXIT_FAILURE); } @@ -34,7 +34,7 @@ TcpSocket::TcpSocket(int port) { address.sin_port = htons(port); // Forcefully attaching socket to the port 8080 - if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) { + if (bind(server_fd, (struct sockaddr*)&address, sizeof(address)) < 0) { perror("bind failed"); exit(EXIT_FAILURE); } @@ -46,8 +46,8 @@ TcpSocket::TcpSocket(int port) { #if defined(__WIN32__) && !defined(socketlen_t) #define socklen_t int #endif - if ((new_socket = accept(server_fd, (struct sockaddr *)&address, - (socklen_t *)&addrlen)) < 0) { + if ((new_socket = accept(server_fd, (struct sockaddr*)&address, + (socklen_t*)&addrlen)) < 0) { perror("accept"); exit(EXIT_FAILURE); } @@ -55,13 +55,13 @@ TcpSocket::TcpSocket(int port) { // Set receive timeout struct timeval tv = {0, 10000}; - setsockopt(client_fd, SOL_SOCKET, SO_RCVTIMEO, reinterpret_cast(&tv), + setsockopt(client_fd, SOL_SOCKET, SO_RCVTIMEO, reinterpret_cast(&tv), sizeof(tv)); } -bool TcpSocket::writeData(uint8_t *data, size_t len) { +bool TcpSocket::writeData(uint8_t* data, size_t len) { if (this && client_fd) { - send(client_fd, (char *)data, len, 0); + send(client_fd, (char*)data, len, 0); } return true; } @@ -79,10 +79,10 @@ bool TcpSocket::readData() { packet.crc = true; packet.lqi = 0; - void *stringPacket = buffer + offsetof(RadioPacket_s, payload); - uint8_t len = *((uint8_t *)stringPacket + offsetof(CliStringPacket_s, len)); - uint8_t *fullString = - (uint8_t *)stringPacket + offsetof(CliStringPacket_s, string); + void* stringPacket = buffer + offsetof(RadioPacket_s, payload); + uint8_t len = *((uint8_t*)stringPacket + offsetof(CliStringPacket_s, len)); + uint8_t* fullString = + (uint8_t*)stringPacket + offsetof(CliStringPacket_s, string); RadioPacket_s packetOnAir = {0}; packetOnAir.packetType = buffer[0]; @@ -109,6 +109,6 @@ bool TcpSocket::readData() { return true; } -void TcpSocket::setRXBuffer(CircularBuffer_s *rx_buffer) { +void TcpSocket::setRXBuffer(CircularBuffer_s* rx_buffer) { rxBuffer = rx_buffer; } diff --git a/desktop_projects/desktop_devices/tcp_socket.h b/desktop_projects/desktop_devices/tcp_socket.h index 5d6b9a4e..545e818c 100644 --- a/desktop_projects/desktop_devices/tcp_socket.h +++ b/desktop_projects/desktop_devices/tcp_socket.h @@ -22,11 +22,11 @@ class TcpSocket { public: explicit TcpSocket(int port); - bool writeData(uint8_t *data, size_t len); + bool writeData(uint8_t* data, size_t len); bool readData(); - void setRXBuffer(CircularBuffer_s *rx_buffer); + void setRXBuffer(CircularBuffer_s* rx_buffer); private: struct sockaddr_in address {}; @@ -39,7 +39,7 @@ class TcpSocket { #endif volatile int client_fd; - CircularBuffer_s *rxBuffer; + CircularBuffer_s* rxBuffer; std::thread acceptThread; diff --git a/desktop_projects/desktop_sim/desktop_hardware_manager.cpp b/desktop_projects/desktop_sim/desktop_hardware_manager.cpp index d5057761..e1529988 100644 --- a/desktop_projects/desktop_sim/desktop_hardware_manager.cpp +++ b/desktop_projects/desktop_sim/desktop_hardware_manager.cpp @@ -96,7 +96,7 @@ bool hardwareStatusMag[NUM_MAG]; /* Hardware objects */ -FileBackedFlash *internalFlash; +FileBackedFlash* internalFlash; bool do_networking; CircularBuffer_s bleBuffer; uint8_t bleArray[1024] = {0}; @@ -104,11 +104,11 @@ uint8_t bleArray[1024] = {0}; #if HAS_DEV(ACCEL_DESKTOP_FILE) || HAS_DEV(BAROMETER_DESKTOP_FILE) || \ HAS_DEV(GPS_DESKTOP_FILE) || HAS_DEV(IMU_DESKTOP_FILE) || \ HAS_DEV(PYRO_CONT_DESKTOP_FILE) || HAS_DEV(VBAT_DESKTOP_FILE) -static CsvReplay *flightReplay; +static CsvReplay* flightReplay; #endif // HAS_DEV(XXX_DESKTOP_FILE) #if HAS_DEV(FLASH_DESKTOP_FILE_BACKED) -static FileBackedFlash *externalFlash[NUM_FLASH_DESKTOP_FILE_BACKED]; +static FileBackedFlash* externalFlash[NUM_FLASH_DESKTOP_FILE_BACKED]; #endif // HAS_DEV(FLASH_DESKTOP_FILE_BACKED) #if HAS_DEV(PYRO_DESKTOP_PRINT) @@ -116,7 +116,7 @@ static PrintPyroCtrl_s printPyro[NUM_PYRO_DESKTOP_PRINT]; #endif // HAS_DEV(PYRO_DESKTOP_PRINT) #if HAS_DEV(RADIO_DESKTOP_SOCKET) -static TcpSocket *radioSocket[NUM_RADIO_DESKTOP_SOCKET]; +static TcpSocket* radioSocket[NUM_RADIO_DESKTOP_SOCKET]; #endif // HAS_DEV(RADIO_DESKTOP_SOCKET) static SensorData_s sensorData = {0}; @@ -198,7 +198,7 @@ uint32_t hm_millis() { } bool hm_flashReadStart(int flashId, uint32_t startLoc, uint32_t numBytes, - uint8_t *pData) { + uint8_t* pData) { #if HAS_DEV(FLASH_DESKTOP_FILE_BACKED) if (IS_DEVICE(flashId, FLASH_DESKTOP_FILE_BACKED)) { return externalFlash[flashId - FIRST_ID_FLASH_DESKTOP_FILE_BACKED] @@ -210,7 +210,7 @@ bool hm_flashReadStart(int flashId, uint32_t startLoc, uint32_t numBytes, } bool hm_flashWriteStart(int flashId, uint32_t startLoc, uint32_t numBytes, - uint8_t *data) { + uint8_t* data) { #if HAS_DEV(FLASH_DESKTOP_FILE_BACKED) if (IS_DEVICE(flashId, FLASH_DESKTOP_FILE_BACKED)) { return externalFlash[flashId - FIRST_ID_FLASH_DESKTOP_FILE_BACKED] @@ -236,7 +236,7 @@ void hm_servoSetAngle(int servoId, float degrees) {} void hm_ledSet(int ledId, bool set) {} void hm_ledToggle(int ledId) {} -bool hm_radioSend(int radioNum, uint8_t *data, uint16_t numBytes) { +bool hm_radioSend(int radioNum, uint8_t* data, uint16_t numBytes) { static RadioRecievedPacket_s packet; packet.crc = true; packet.lqi = 4; @@ -247,7 +247,7 @@ bool hm_radioSend(int radioNum, uint8_t *data, uint16_t numBytes) { if (IS_DEVICE(radioNum, RADIO_DESKTOP_SOCKET)) { packet.radioId = radioNum; if (radioSocket[radioNum]) { - radioSocket[radioNum]->writeData((uint8_t *)&packet, sizeof(packet)); + radioSocket[radioNum]->writeData((uint8_t*)&packet, sizeof(packet)); } return true; } @@ -263,7 +263,7 @@ void hm_radioUpdate() { } } -void hm_radioRegisterConsumer(int radioNum, CircularBuffer_s *rxBuffer) { +void hm_radioRegisterConsumer(int radioNum, CircularBuffer_s* rxBuffer) { // Need to put code here to pass the rxBuffer onto the TCP socket // TCP socket then needs to add new data to rxBuffer @@ -275,17 +275,17 @@ void hm_radioRegisterConsumer(int radioNum, CircularBuffer_s *rxBuffer) { void hm_radioSetChannel(int radioNum, int channel) {} bool hm_usbIsConnected(int usbId) { return false; } -bool hm_usbTransmit(int usbId, uint8_t *data, uint16_t numBytes) { +bool hm_usbTransmit(int usbId, uint8_t* data, uint16_t numBytes) { std::cout << data << std::endl; return true; } -CircularBuffer_s *hm_usbGetRxBuffer(int usbId) { return nullptr; } +CircularBuffer_s* hm_usbGetRxBuffer(int usbId) { return nullptr; } bool hm_bleClientConnected(int bleClientId) { return false; } -bool hm_bleClientSend(int bleClientId, const uint8_t *data, uint16_t numBytes) { +bool hm_bleClientSend(int bleClientId, const uint8_t* data, uint16_t numBytes) { return false; } -CircularBuffer_s *hm_bleClientGetRxBuffer(int bleClientId) { return nullptr; } +CircularBuffer_s* hm_bleClientGetRxBuffer(int bleClientId) { return nullptr; } void hm_bleTick() {} LineCutterData_s dummyData[2] = {{ @@ -301,14 +301,14 @@ LineCutterFlightVars_s dummyVars[2] = {{ .lineCutterNumber = 2, }}; -LineCutterData_s *hm_getLineCutterData(int lineCutterId) { +LineCutterData_s* hm_getLineCutterData(int lineCutterId) { return dummyData + lineCutterId; } -LineCutterFlightVars_s *hm_getLineCutterFlightVariables(int lineCutterId) { +LineCutterFlightVars_s* hm_getLineCutterFlightVariables(int lineCutterId) { return dummyVars + lineCutterId; } -bool hm_lineCutterSendString(int lineCutterNumber, char *string) { +bool hm_lineCutterSendString(int lineCutterNumber, char* string) { printf("[Sent to LC %i] %s\n", lineCutterNumber, string); return true; } @@ -345,7 +345,7 @@ void hm_pyroSetPwm(int pyroId, uint32_t frequency, uint32_t pulseWidth, #endif // HAS_DEV(PYRO_DESKTOP_PRINT) } -void hm_pyroUpdate(void *pUserData) { +void hm_pyroUpdate(void* pUserData) { #if HAS_DEV(PYRO_DESKTOP_PRINT) for (int i = 0; i < NUM_PYRO_DESKTOP_PRINT; i++) { printPyro_tick(&printPyro[i]); @@ -357,11 +357,11 @@ void hm_dcMotorSetPercent(int dcMotorId, double percent) {} void hm_readSensorData() { flightReplay->getNext(&sensorData); } -SensorData_s *hm_getSensorData() { return &sensorData; } +SensorData_s* hm_getSensorData() { return &sensorData; } -SensorProperties_s *hm_getSensorProperties() { return &sensorProperties; } +SensorProperties_s* hm_getSensorProperties() { return &sensorProperties; } -void hm_enableSimMode(CircularBuffer_s *rxBuffer) {} +void hm_enableSimMode(CircularBuffer_s* rxBuffer) {} void hm_disableSimMode() {} diff --git a/desktop_projects/desktop_sim/tests/test_expressions.cpp b/desktop_projects/desktop_sim/tests/test_expressions.cpp index 24777327..17d7d87c 100644 --- a/desktop_projects/desktop_sim/tests/test_expressions.cpp +++ b/desktop_projects/desktop_sim/tests/test_expressions.cpp @@ -29,7 +29,7 @@ class ExpressionStorageTests : public testing::Test { TEST_F(ExpressionStorageTests, expressionParsing) { uint16_t resID; - const char *test1Input = + const char* test1Input = "((not unclean_restart) and ((2.00 after burnout) and ((not apogee) and " "((world_vel_z > 30.00) and ((angle_vertical < 40.00) and ((pos_z_agl > " "150.00) and (not (ever (launch and (angle_vertical > 45.00))))))))))"; @@ -41,7 +41,7 @@ TEST_F(ExpressionStorageTests, expressionParsing) { expressionStore.conditionToString(resID, stringBuf, sizeof(stringBuf)); ASSERT_EQ(strcmp(stringBuf, test1Input), 0); - const char *test2Input = + const char* test2Input = "(-6.00 == (12.00 - (9.00 * (1.00 + (2.00 / 2.00)))))"; slice = StringSlice(&test2Input, 0, strlen(test2Input)); valueType = expressionStore.parseForTrigger(&resID, 0, slice, 0); @@ -57,9 +57,9 @@ TEST_F(ExpressionStorageTests, expressionEvaluation) { eventManager_setEventIncomplete(Event_e::launch); ASSERT_EQ(expressionStore.getNextExpressionSpot(0), 0); - const char *test1Input = "(angle_vertical < 30)"; + const char* test1Input = "(angle_vertical < 30)"; - const char *test2Input = "(not (ever (launch and (angle_vertical > 45))))"; + const char* test2Input = "(not (ever (launch and (angle_vertical > 45))))"; StringSlice slice1 = StringSlice(&test1Input, 0, strlen(test1Input)); StringSlice slice2 = StringSlice(&test2Input, 0, strlen(test2Input)); @@ -95,9 +95,9 @@ TEST_F(ExpressionStorageTests, expressionEvaluation) { TEST_F(ExpressionStorageTests, chainedAndOr) { ASSERT_EQ(expressionStore.getNextExpressionSpot(0), 0); - const char *test1Input = "((3 == (3 / 1)) and (not (3 > 4)))"; + const char* test1Input = "((3 == (3 / 1)) and (not (3 > 4)))"; - const char *test2Input = + const char* test2Input = "((1 == 1) and ((1 == 1) and ((not (not (1 == 1))) or (not ((1 == 2) or " "(3 > 4))))))"; diff --git a/desktop_projects/desktop_sim/tests/test_file_flash.cpp b/desktop_projects/desktop_sim/tests/test_file_flash.cpp index 5447c79b..d7194c44 100644 --- a/desktop_projects/desktop_sim/tests/test_file_flash.cpp +++ b/desktop_projects/desktop_sim/tests/test_file_flash.cpp @@ -6,7 +6,7 @@ TEST(FileFlash, ReadWrite) { std::string ext_flash_path = "flash_test_file.hex"; - FileBackedFlash *externalFlash = new FileBackedFlash(ext_flash_path, 0x4000); + FileBackedFlash* externalFlash = new FileBackedFlash(ext_flash_path, 0x4000); uint8_t pdata[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; uint8_t pdata2[10] = {0}; @@ -36,7 +36,7 @@ TEST(FileFlash, ReadWrite) { TEST(FileFlash, WriteMiddle) { std::string ext_flash_path = "flash_test_file2.hex"; - FileBackedFlash *externalFlash = new FileBackedFlash(ext_flash_path, 0x100); + FileBackedFlash* externalFlash = new FileBackedFlash(ext_flash_path, 0x100); externalFlash->reinit(true); uint8_t correct[0x100]; diff --git a/platformio_projects/lib/device_drivers/gps/gps.cpp b/platformio_projects/lib/device_drivers/gps/gps.cpp index 1aeb47fb..6afb6d9f 100644 --- a/platformio_projects/lib/device_drivers/gps/gps.cpp +++ b/platformio_projects/lib/device_drivers/gps/gps.cpp @@ -10,7 +10,7 @@ Gps::Gps() = default; bool Gps::hasNewFix() const { return newFix; } -GpsData_s *Gps::getLastFix() { +GpsData_s* Gps::getLastFix() { newFix = false; return &gpsData; } diff --git a/platformio_projects/lib/device_drivers/gps/gps.h b/platformio_projects/lib/device_drivers/gps/gps.h index 660cc0ed..42d24b4b 100644 --- a/platformio_projects/lib/device_drivers/gps/gps.h +++ b/platformio_projects/lib/device_drivers/gps/gps.h @@ -16,7 +16,7 @@ class Gps : public virtual BaseDevice { bool hasNewFix() const; - GpsData_s *getLastFix(); + GpsData_s* getLastFix(); void fillTimeStamp(); diff --git a/platformio_projects/lib/device_drivers/gps/nmea_0183_gps.cpp b/platformio_projects/lib/device_drivers/gps/nmea_0183_gps.cpp index d8c179cc..e370c29e 100644 --- a/platformio_projects/lib/device_drivers/gps/nmea_0183_gps.cpp +++ b/platformio_projects/lib/device_drivers/gps/nmea_0183_gps.cpp @@ -6,7 +6,7 @@ Nmea0183Gps::Nmea0183Gps() = default; -void Nmea0183Gps::init(Uart *serial_port, int baud_rate) { +void Nmea0183Gps::init(Uart* serial_port, int baud_rate) { serialPort = serial_port; serialPort->begin(baud_rate); diff --git a/platformio_projects/lib/device_drivers/gps/nmea_0183_gps.h b/platformio_projects/lib/device_drivers/gps/nmea_0183_gps.h index 34061871..53c21522 100644 --- a/platformio_projects/lib/device_drivers/gps/nmea_0183_gps.h +++ b/platformio_projects/lib/device_drivers/gps/nmea_0183_gps.h @@ -14,12 +14,12 @@ class Nmea0183Gps : public Gps { public: Nmea0183Gps(); - void init(Uart *serial_port, int baud_rate); + void init(Uart* serial_port, int baud_rate); void tick() override; protected: - Uart *serialPort = nullptr; + Uart* serialPort = nullptr; TinyGPSPlus tinyGpsPlus; }; diff --git a/platformio_projects/lib/device_drivers/imu/bno055_imu.cpp b/platformio_projects/lib/device_drivers/imu/bno055_imu.cpp index a7bc246b..7a629331 100644 --- a/platformio_projects/lib/device_drivers/imu/bno055_imu.cpp +++ b/platformio_projects/lib/device_drivers/imu/bno055_imu.cpp @@ -4,17 +4,17 @@ #include "bno055_imu.h" -std::array adafruitVectorToArray(const sensors_vec_t &vector) { +std::array adafruitVectorToArray(const sensors_vec_t& vector) { return {vector.x, vector.y, vector.z}; } Bno055Imu::Bno055Imu() = default; -void Bno055Imu::init(TwoWire *wire, uint8_t address) { +void Bno055Imu::init(TwoWire* wire, uint8_t address) { // Need to construct the object here, so we do this weird thing to avoid // dynamic memory allocation new (&driver_memory) Adafruit_BNO055(55, address, wire); - bno055 = ((Adafruit_BNO055 *)&driver_memory); + bno055 = ((Adafruit_BNO055*)&driver_memory); // Init the sensor and turn off the internal fusion sensorStatus = bno055->begin(); @@ -37,7 +37,7 @@ void Bno055Imu::tick() { gyroscopeData = adafruitVectorToArray(gyroscope_data.gyro); magnetometerData = adafruitVectorToArray(magnetometer_data.magnetic); - for (double &i : magnetometerData) { + for (double& i : magnetometerData) { i *= 0.01; // Convert from uT to Gauss } } diff --git a/platformio_projects/lib/device_drivers/imu/bno055_imu.h b/platformio_projects/lib/device_drivers/imu/bno055_imu.h index 1686faff..d9227457 100644 --- a/platformio_projects/lib/device_drivers/imu/bno055_imu.h +++ b/platformio_projects/lib/device_drivers/imu/bno055_imu.h @@ -25,13 +25,13 @@ class Bno055Imu : public Imu { public: Bno055Imu(); - void init(TwoWire *wire, uint8_t address); + void init(TwoWire* wire, uint8_t address); void tick() override; private: uint8_t driver_memory[sizeof(Adafruit_BNO055)]{}; - Adafruit_BNO055 *bno055{}; + Adafruit_BNO055* bno055{}; }; #endif // PLATFORMIO_PROJECTS_LIB_DEVICE_DRIVERS_IMU_BNO055_IMU_H_ diff --git a/platformio_projects/lib/device_drivers/radio/radio.cpp b/platformio_projects/lib/device_drivers/radio/radio.cpp index dc5bf6f1..35486799 100644 --- a/platformio_projects/lib/device_drivers/radio/radio.cpp +++ b/platformio_projects/lib/device_drivers/radio/radio.cpp @@ -6,11 +6,11 @@ Radio::Radio(int max_message_length) { maxMessageLength = max_message_length; } -bool Radio::sendData(uint8_t *data, size_t len) { return false; } +bool Radio::sendData(uint8_t* data, size_t len) { return false; } bool Radio::isDataAvailable() { return false; } -bool Radio::readData(uint8_t *buffer, size_t buffer_length) { return false; } +bool Radio::readData(uint8_t* buffer, size_t buffer_length) { return false; } int Radio::getMaxMessageLength() { return maxMessageLength; } diff --git a/platformio_projects/lib/device_drivers/radio/radio.h b/platformio_projects/lib/device_drivers/radio/radio.h index 72f2e022..82a1b091 100644 --- a/platformio_projects/lib/device_drivers/radio/radio.h +++ b/platformio_projects/lib/device_drivers/radio/radio.h @@ -14,11 +14,11 @@ class Radio : public virtual BaseDevice { public: explicit Radio(int max_message_length); - virtual bool sendData(uint8_t *data, size_t len); + virtual bool sendData(uint8_t* data, size_t len); virtual bool isDataAvailable(); - virtual bool readData(uint8_t *buffer, size_t buffer_length); + virtual bool readData(uint8_t* buffer, size_t buffer_length); int getMaxMessageLength(); diff --git a/platformio_projects/lib/device_drivers/radio/rfm_950.cpp b/platformio_projects/lib/device_drivers/radio/rfm_950.cpp index ead7b545..45f2c13a 100644 --- a/platformio_projects/lib/device_drivers/radio/rfm_950.cpp +++ b/platformio_projects/lib/device_drivers/radio/rfm_950.cpp @@ -10,7 +10,7 @@ void Rfm950::init(int reset_pin, int cs_pin, int interrupt_pin) { // Need to construct the object here, so we do this weird thing to avoid // dynamic memory allocation new (&driver_memory) RH_RF95(cs_pin, interrupt_pin); - rf95 = ((RH_RF95 *)&driver_memory); + rf95 = ((RH_RF95*)&driver_memory); // Basically copied from Adafruit example code pinMode(reset_pin, OUTPUT); @@ -31,7 +31,7 @@ void Rfm950::init(int reset_pin, int cs_pin, int interrupt_pin) { rf95->setTxPower(23, false); // High power } -bool Rfm950::sendData(uint8_t *data, size_t len) { +bool Rfm950::sendData(uint8_t* data, size_t len) { // long start_time = millis(); rf95->send(data, len); @@ -49,7 +49,7 @@ bool Rfm950::sendData(uint8_t *data, size_t len) { bool Rfm950::isDataAvailable() { return rf95->available(); } -bool Rfm950::readData(uint8_t *buffer, size_t buffer_length) { +bool Rfm950::readData(uint8_t* buffer, size_t buffer_length) { uint8_t len = min((uint8_t)buffer_length, getMaxMessageLength()); bool success = rf95->recv(buffer, &len); lastRssi = rf95->lastRssi(); diff --git a/platformio_projects/lib/device_drivers/radio/rfm_950.h b/platformio_projects/lib/device_drivers/radio/rfm_950.h index 229d1d0a..1cef89e5 100644 --- a/platformio_projects/lib/device_drivers/radio/rfm_950.h +++ b/platformio_projects/lib/device_drivers/radio/rfm_950.h @@ -18,15 +18,15 @@ class Rfm950 : public Radio { void init(int reset_pin, int cs_pin, int interrupt_pin); - bool sendData(uint8_t *data, size_t len) override; + bool sendData(uint8_t* data, size_t len) override; bool isDataAvailable() override; - bool readData(uint8_t *buffer, size_t buffer_length) override; + bool readData(uint8_t* buffer, size_t buffer_length) override; protected: uint8_t driver_memory[sizeof(RH_RF95)]{}; - RH_RF95 *rf95{}; + RH_RF95* rf95{}; }; #endif // PLATFORMIO_PROJECTS_LIB_DEVICE_DRIVERS_RADIO_RFM_950_H_ diff --git a/platformio_projects/lib/new_hal/arduino_hardware_manager.cpp b/platformio_projects/lib/new_hal/arduino_hardware_manager.cpp index a11a6db4..3414119e 100644 --- a/platformio_projects/lib/new_hal/arduino_hardware_manager.cpp +++ b/platformio_projects/lib/new_hal/arduino_hardware_manager.cpp @@ -13,7 +13,7 @@ #define USB_SERIAL_BUFFER_SIZE 500 -void stdArrayToAxis3d(Axis3dReal_s *s, std::array array) { +void stdArrayToAxis3d(Axis3dReal_s* s, std::array array) { s->x = array[0]; s->y = array[1]; s->z = array[2]; @@ -23,7 +23,7 @@ void stdArrayToAxis3d(Axis3dReal_s *s, std::array array) { // hardware drivers DeviceManager deviceManager; -DeviceManager *getDeviceManager() { return &deviceManager; } +DeviceManager* getDeviceManager() { return &deviceManager; } // Hardware statuses #if HAS_DEV(ACCEL) @@ -90,7 +90,7 @@ static uint8_t serialBuffer[USB_SERIAL_BUFFER_SIZE]; static CircularBuffer_s serialCircularBuffer; // Circular buffer for radio reads -CircularBuffer_s *radioCircularBuffer; +CircularBuffer_s* radioCircularBuffer; void hm_hardwareInit() { pinMode(LED_BUILTIN, OUTPUT); @@ -130,13 +130,13 @@ void hm_hardwareInit() { uint32_t hm_millis() { return millis(); } bool hm_flashReadStart(int flashId, uint32_t startLoc, uint32_t numBytes, - uint8_t *pData) { + uint8_t* pData) { memset(pData, 0xff, numBytes); return false; } bool hm_flashWriteStart(int flashId, uint32_t startLoc, uint32_t numBytes, - uint8_t *data) { + uint8_t* data) { return false; } @@ -167,7 +167,7 @@ void hm_ledToggle(int ledId) { led_on = !led_on; } -bool hm_radioSend(int radioNum, uint8_t *data, uint16_t numBytes) { +bool hm_radioSend(int radioNum, uint8_t* data, uint16_t numBytes) { if (deviceManager.getRadio(0)) { return deviceManager.getRadio(0)->sendData(data, numBytes); } @@ -176,7 +176,7 @@ bool hm_radioSend(int radioNum, uint8_t *data, uint16_t numBytes) { } void hm_radioUpdate() { - for (auto &radio : deviceManager.radios) { + for (auto& radio : deviceManager.radios) { if (radio->isDataAvailable()) { static RadioRecievedPacket_s packet; packet.radioId = 0; @@ -194,7 +194,7 @@ void hm_radioUpdate() { } } -void hm_radioRegisterConsumer(int radioNum, CircularBuffer_s *rxBuffer) { +void hm_radioRegisterConsumer(int radioNum, CircularBuffer_s* rxBuffer) { radioCircularBuffer = rxBuffer; } @@ -202,7 +202,7 @@ void hm_radioSetChannel(int radioNum, int channel) {} bool hm_usbIsConnected(int usbId) { return false; } -bool hm_usbTransmit(int usbId, uint8_t *data, uint16_t numBytes) { +bool hm_usbTransmit(int usbId, uint8_t* data, uint16_t numBytes) { for (int i = 0; i < numBytes; i++) { Serial.print((char)data[i]); } @@ -210,25 +210,25 @@ bool hm_usbTransmit(int usbId, uint8_t *data, uint16_t numBytes) { return true; } -CircularBuffer_s *hm_usbGetRxBuffer(int usbId) { return &serialCircularBuffer; } +CircularBuffer_s* hm_usbGetRxBuffer(int usbId) { return &serialCircularBuffer; } bool hm_bleClientConnected(int bleClientId) { return false; } -bool hm_bleClientSend(int bleClientId, const uint8_t *data, uint16_t numBytes) { +bool hm_bleClientSend(int bleClientId, const uint8_t* data, uint16_t numBytes) { return false; } -CircularBuffer_s *hm_bleClientGetRxBuffer(int bleClientId) { return nullptr; } +CircularBuffer_s* hm_bleClientGetRxBuffer(int bleClientId) { return nullptr; } void hm_bleTick() {} -LineCutterData_s *hm_getLineCutterData(int lineCutterId) { return nullptr; } +LineCutterData_s* hm_getLineCutterData(int lineCutterId) { return nullptr; } -LineCutterFlightVars_s *hm_getLineCutterFlightVariables(int lineCutterId) { +LineCutterFlightVars_s* hm_getLineCutterFlightVariables(int lineCutterId) { return nullptr; } -bool hm_lineCutterSendString(int lineCutterNumber, char *string) { +bool hm_lineCutterSendString(int lineCutterNumber, char* string) { printf("[Sent to LC %i] %s\n", lineCutterNumber, string); return true; } @@ -253,7 +253,7 @@ void hm_pyroSetPwm(int pyroId, uint32_t frequency, uint32_t pulseWidth, // TODO: Analogwrite()? } -void hm_pyroUpdate(void *pUserData) { +void hm_pyroUpdate(void* pUserData) { // TODO: Actually do this } @@ -314,11 +314,11 @@ void hm_readSensorData() { sensorData.timestampMs = hm_millis(); } -SensorData_s *hm_getSensorData() { return &sensorData; } +SensorData_s* hm_getSensorData() { return &sensorData; } -SensorProperties_s *hm_getSensorProperties() { return &sensorProperties; } +SensorProperties_s* hm_getSensorProperties() { return &sensorProperties; } -void hm_enableSimMode(CircularBuffer_s *rxBuffer) {} +void hm_enableSimMode(CircularBuffer_s* rxBuffer) {} void hm_disableSimMode() {} diff --git a/platformio_projects/lib/new_hal/arduino_hardware_manager.h b/platformio_projects/lib/new_hal/arduino_hardware_manager.h index f55f43d8..c74447ca 100644 --- a/platformio_projects/lib/new_hal/arduino_hardware_manager.h +++ b/platformio_projects/lib/new_hal/arduino_hardware_manager.h @@ -6,6 +6,6 @@ #include "device_manager.h" #include "hardware_manager.h" -DeviceManager *getDeviceManager(); +DeviceManager* getDeviceManager(); #endif // PLATFORMIO_PROJECTS_LIB_NEW_HAL_ARDUINO_HARDWARE_MANAGER_H_ diff --git a/platformio_projects/lib/new_hal/device_manager.cpp b/platformio_projects/lib/new_hal/device_manager.cpp index 0e796169..df47dce7 100644 --- a/platformio_projects/lib/new_hal/device_manager.cpp +++ b/platformio_projects/lib/new_hal/device_manager.cpp @@ -17,7 +17,7 @@ bool DeviceManager::addBatteryMonitorAdc(int pin, double multiplier) { return false; } -bool DeviceManager::addRadio(Radio *radio) { +bool DeviceManager::addRadio(Radio* radio) { if (!radios.full()) { radios.push_back(radio); return true; @@ -26,7 +26,7 @@ bool DeviceManager::addRadio(Radio *radio) { } } -bool DeviceManager::addBarometer(Barometer *barometer) { +bool DeviceManager::addBarometer(Barometer* barometer) { if (!barometers.full()) { barometers.push_back(barometer); return true; @@ -35,7 +35,7 @@ bool DeviceManager::addBarometer(Barometer *barometer) { } } -bool DeviceManager::addGps(Gps *gps_ptr) { +bool DeviceManager::addGps(Gps* gps_ptr) { if (!gps.full()) { gps.push_back(gps_ptr); return true; @@ -44,7 +44,7 @@ bool DeviceManager::addGps(Gps *gps_ptr) { } } -bool DeviceManager::addImu(Imu *imu, bool has_mag) { +bool DeviceManager::addImu(Imu* imu, bool has_mag) { if (!gyroscopes.full() && !accelerometers.full()) { gyroscopes.push_back(imu); accelerometers.push_back(imu); @@ -60,7 +60,7 @@ bool DeviceManager::addImu(Imu *imu, bool has_mag) { } } -bool DeviceManager::addMagnetometer(Magnetometer *mag) { +bool DeviceManager::addMagnetometer(Magnetometer* mag) { if (!magnetometers.full()) { magnetometers.push_back(mag); return true; @@ -70,33 +70,33 @@ bool DeviceManager::addMagnetometer(Magnetometer *mag) { } void DeviceManager::init() { - for (auto &device : accelerometers) { + for (auto& device : accelerometers) { devices.push_back(device); } - for (auto &device : barometers) { + for (auto& device : barometers) { devices.push_back(device); } - for (auto &device : gps) { + for (auto& device : gps) { devices.push_back(device); } - for (auto &device : gyroscopes) { + for (auto& device : gyroscopes) { devices.push_back(device); } - for (auto &device : magnetometers) { + for (auto& device : magnetometers) { devices.push_back(device); } - for (auto &device : radios) { + for (auto& device : radios) { devices.push_back(device); } } void DeviceManager::readSensors() { - for (auto &device : devices) { + for (auto& device : devices) { device->tick(); } } @@ -114,7 +114,7 @@ double DeviceManager::readBatteryVoltage(uint battery_num) { return -1; } -Accelerometer *DeviceManager::getAccelerometer(uint index) { +Accelerometer* DeviceManager::getAccelerometer(uint index) { if (0 <= index && index < accelerometers.size()) { return accelerometers[index]; } else { @@ -122,7 +122,7 @@ Accelerometer *DeviceManager::getAccelerometer(uint index) { } } -Barometer *DeviceManager::getBarometer(uint index) { +Barometer* DeviceManager::getBarometer(uint index) { if (0 <= index && index < barometers.size()) { return barometers[index]; } else { @@ -130,7 +130,7 @@ Barometer *DeviceManager::getBarometer(uint index) { } } -Gps *DeviceManager::getGps(uint index) { +Gps* DeviceManager::getGps(uint index) { if (0 <= index && index < gps.size()) { return gps[index]; } else { @@ -138,7 +138,7 @@ Gps *DeviceManager::getGps(uint index) { } } -Gyroscope *DeviceManager::getGyroscope(uint index) { +Gyroscope* DeviceManager::getGyroscope(uint index) { if (0 <= index && index < gyroscopes.size()) { return gyroscopes[index]; } else { @@ -146,7 +146,7 @@ Gyroscope *DeviceManager::getGyroscope(uint index) { } } -Magnetometer *DeviceManager::getMagnetometer(uint index) { +Magnetometer* DeviceManager::getMagnetometer(uint index) { if (0 <= index && index < magnetometers.size()) { return magnetometers[index]; } else { @@ -154,7 +154,7 @@ Magnetometer *DeviceManager::getMagnetometer(uint index) { } } -Radio *DeviceManager::getRadio(uint index) { +Radio* DeviceManager::getRadio(uint index) { if (0 <= index && index < radios.size()) { return radios[index]; } else { diff --git a/platformio_projects/lib/new_hal/device_manager.h b/platformio_projects/lib/new_hal/device_manager.h index e126ab56..ef10c461 100644 --- a/platformio_projects/lib/new_hal/device_manager.h +++ b/platformio_projects/lib/new_hal/device_manager.h @@ -37,31 +37,31 @@ class DeviceManager { public: // Driver objects - Array accelerometers{}; - Array barometers{}; - Array gps{}; - Array gyroscopes{}; + Array accelerometers{}; + Array barometers{}; + Array gps{}; + Array gyroscopes{}; // Array imus{}; - Array magnetometers{}; - Array radios{}; + Array magnetometers{}; + Array radios{}; // Also store all the driver objects as an array of base class pointers // IDK how useful this really is, but we'll see - Array devices{}; + Array devices{}; DeviceManager(); bool addBatteryMonitorAdc(int pin, double multiplier); - bool addRadio(Radio *radio); + bool addRadio(Radio* radio); - bool addBarometer(Barometer *barometer); + bool addBarometer(Barometer* barometer); - bool addGps(Gps *gps); + bool addGps(Gps* gps); - bool addImu(Imu *imu, bool has_mag = false); + bool addImu(Imu* imu, bool has_mag = false); - bool addMagnetometer(Magnetometer *mag); + bool addMagnetometer(Magnetometer* mag); void init(); @@ -71,17 +71,17 @@ class DeviceManager { double readBatteryVoltage(uint battery_num); - Accelerometer *getAccelerometer(uint index); + Accelerometer* getAccelerometer(uint index); - Barometer *getBarometer(uint index); + Barometer* getBarometer(uint index); - Gps *getGps(uint index); + Gps* getGps(uint index); - Gyroscope *getGyroscope(uint index); + Gyroscope* getGyroscope(uint index); - Magnetometer *getMagnetometer(uint index); + Magnetometer* getMagnetometer(uint index); - Radio *getRadio(uint index); + Radio* getRadio(uint index); // Imu *getImu(int index); diff --git a/platformio_projects/lib/new_hal/hal_callbacks.c b/platformio_projects/lib/new_hal/hal_callbacks.c index 87c9789a..0c3e63f8 100644 --- a/platformio_projects/lib/new_hal/hal_callbacks.c +++ b/platformio_projects/lib/new_hal/hal_callbacks.c @@ -14,19 +14,19 @@ #ifdef HAL_SPI_MODULE_ENABLED typedef struct { - SPI_HandleTypeDef *hspi; - void (*txCallback)(void *); - void (*txRxCallback)(void *); - void *txCallbackUserData; - void *txRxCallbackUserData; + SPI_HandleTypeDef* hspi; + void (*txCallback)(void*); + void (*txRxCallback)(void*); + void* txCallbackUserData; + void* txRxCallbackUserData; } SpiCallbackProperty_s; static SpiCallbackProperty_s spiCallbacks[MAX_SPI_HANDLES]; static int numSpiCallbacksRegistered = 0; -void halCallbacks_registerSpiTxCpltCallback(SPI_HandleTypeDef *hspi, - void (*callback)(void *), - void *userData) { +void halCallbacks_registerSpiTxCpltCallback(SPI_HandleTypeDef* hspi, + void (*callback)(void*), + void* userData) { // See if handle already has callback registered to it for (int i = 0; i < numSpiCallbacksRegistered; i++) { if (spiCallbacks[i].hspi == hspi) { @@ -43,9 +43,9 @@ void halCallbacks_registerSpiTxCpltCallback(SPI_HandleTypeDef *hspi, numSpiCallbacksRegistered++; } -void halCallbacks_registerSpiTxRxCpltCallback(SPI_HandleTypeDef *hspi, - void (*callback)(void *), - void *userData) { +void halCallbacks_registerSpiTxRxCpltCallback(SPI_HandleTypeDef* hspi, + void (*callback)(void*), + void* userData) { // See if handle already has callback registered to it for (int i = 0; i < numSpiCallbacksRegistered; i++) { if (spiCallbacks[i].hspi == hspi) { @@ -63,7 +63,7 @@ void halCallbacks_registerSpiTxRxCpltCallback(SPI_HandleTypeDef *hspi, } // The actuall callback functions -void HAL_SPI_TxCpltCallback(SPI_HandleTypeDef *hspi) { +void HAL_SPI_TxCpltCallback(SPI_HandleTypeDef* hspi) { for (int i = 0; i < numSpiCallbacksRegistered; i++) { if (spiCallbacks[i].hspi == hspi) { if (spiCallbacks[i].txCallback != NULL) { @@ -74,7 +74,7 @@ void HAL_SPI_TxCpltCallback(SPI_HandleTypeDef *hspi) { } } -void HAL_SPI_TxRxCpltCallback(SPI_HandleTypeDef *hspi) { +void HAL_SPI_TxRxCpltCallback(SPI_HandleTypeDef* hspi) { for (int i = 0; i < numSpiCallbacksRegistered; i++) { if (spiCallbacks[i].hspi == hspi) { if (spiCallbacks[i].txRxCallback != NULL) { @@ -88,21 +88,21 @@ void HAL_SPI_TxRxCpltCallback(SPI_HandleTypeDef *hspi) { #ifdef HAL_UART_MODULE_ENABLED typedef struct { - UART_HandleTypeDef *huart; - void (*rxHalfCallback)(void *); - void (*rxCallback)(void *); - void (*rxIdleCallback)(void *, size_t); // user data, size - void *rxHalfCallbackUserData; - void *rxCallbackUserData; - void *rxIdleCallbackUserData; + UART_HandleTypeDef* huart; + void (*rxHalfCallback)(void*); + void (*rxCallback)(void*); + void (*rxIdleCallback)(void*, size_t); // user data, size + void* rxHalfCallbackUserData; + void* rxCallbackUserData; + void* rxIdleCallbackUserData; } UartCallbackProperty_s; static UartCallbackProperty_s uartCallbacks[MAX_UART_HANDLES]; static int numUartCallbacksRegistered = 0; -void halCallbacks_registerUartRxHalfCpltCallback(UART_HandleTypeDef *huart, - void (*callback)(void *), - void *userData) { +void halCallbacks_registerUartRxHalfCpltCallback(UART_HandleTypeDef* huart, + void (*callback)(void*), + void* userData) { // See if handle already has callback registered to it for (int i = 0; i < numUartCallbacksRegistered; i++) { if (uartCallbacks[i].huart == huart) { @@ -119,9 +119,9 @@ void halCallbacks_registerUartRxHalfCpltCallback(UART_HandleTypeDef *huart, numUartCallbacksRegistered++; } -void halCallbacks_registerUartRxCpltCallback(UART_HandleTypeDef *huart, - void (*callback)(void *), - void *userData) { +void halCallbacks_registerUartRxCpltCallback(UART_HandleTypeDef* huart, + void (*callback)(void*), + void* userData) { // See if handle already has callback registered to it for (int i = 0; i < numUartCallbacksRegistered; i++) { if (uartCallbacks[i].huart == huart) { @@ -138,7 +138,7 @@ void halCallbacks_registerUartRxCpltCallback(UART_HandleTypeDef *huart, numUartCallbacksRegistered++; } -void HAL_UART_RxHalfCpltCallback(UART_HandleTypeDef *huart) { +void HAL_UART_RxHalfCpltCallback(UART_HandleTypeDef* huart) { for (int i = 0; i < numUartCallbacksRegistered; i++) { if (uartCallbacks[i].huart == huart) { if (uartCallbacks[i].rxHalfCallback != NULL) { @@ -150,7 +150,7 @@ void HAL_UART_RxHalfCpltCallback(UART_HandleTypeDef *huart) { } } -void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) { +void HAL_UART_RxCpltCallback(UART_HandleTypeDef* huart) { for (int i = 0; i < numUartCallbacksRegistered; i++) { if (uartCallbacks[i].huart == huart) { if (uartCallbacks[i].rxCallback != NULL) { @@ -161,9 +161,9 @@ void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) { } } -void halCallbacks_registerUartRxIdleCallback(UART_HandleTypeDef *huart, - void (*callback)(void *, size_t), - void *userData) { +void halCallbacks_registerUartRxIdleCallback(UART_HandleTypeDef* huart, + void (*callback)(void*, size_t), + void* userData) { // See if handle already has callback registered to it for (int i = 0; i < numUartCallbacksRegistered; i++) { if (uartCallbacks[i].huart == huart) { @@ -180,7 +180,7 @@ void halCallbacks_registerUartRxIdleCallback(UART_HandleTypeDef *huart, numUartCallbacksRegistered++; } -void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t size) { +void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef* huart, uint16_t size) { for (int i = 0; i < numUartCallbacksRegistered; i++) { if (uartCallbacks[i].huart == huart) { if (uartCallbacks[i].rxIdleCallback != NULL) { @@ -196,17 +196,17 @@ void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t size) { #ifdef HAL_ADC_MODULE_ENABLED typedef struct { - ADC_HandleTypeDef *hadc; - void (*convCallback)(void *); - void *convCallbackUserData; + ADC_HandleTypeDef* hadc; + void (*convCallback)(void*); + void* convCallbackUserData; } AdcCallbackProperty_s; static AdcCallbackProperty_s adcCallbacks[MAX_ADC_HANDLES]; static int numAdcCallbacksRegistered = 0; -void halCallbacks_registerAdcConvCpltCallback(ADC_HandleTypeDef *hadc, - void (*callback)(void *), - void *userData) { +void halCallbacks_registerAdcConvCpltCallback(ADC_HandleTypeDef* hadc, + void (*callback)(void*), + void* userData) { // See if handle already has callback registered to it for (int i = 0; i < numAdcCallbacksRegistered; i++) { if (adcCallbacks[i].hadc == hadc) { @@ -223,7 +223,7 @@ void halCallbacks_registerAdcConvCpltCallback(ADC_HandleTypeDef *hadc, numAdcCallbacksRegistered++; } -void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef *hadc) { +void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc) { for (int i = 0; i < numAdcCallbacksRegistered; i++) { if (adcCallbacks[i].hadc == hadc) { if (adcCallbacks[i].convCallback != NULL) { @@ -239,16 +239,16 @@ void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef *hadc) { #ifdef HAL_EXTI_MODULE_ENABLED typedef struct { uint16_t extInterruptGpioPin; - void (*extInterruptCallback)(void *); - void *extInterruptCallbackUserData; + void (*extInterruptCallback)(void*); + void* extInterruptCallbackUserData; } ExtInterruptCallbackProperty_s; static ExtInterruptCallbackProperty_s extInterruptCallbacks[MAX_EXTI_HANDLES]; static int numExtInterruptCallbacksRegistered = 0; void halCallbacks_registerExtInterruptCallback(uint16_t gpioPin, - void (*callback)(void *), - void *userData) { + void (*callback)(void*), + void* userData) { // See if handle already has callback registered to it for (int i = 0; i < numExtInterruptCallbacksRegistered; i++) { if (extInterruptCallbacks[i].extInterruptGpioPin == gpioPin) { @@ -284,18 +284,18 @@ void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin) { #ifdef HAL_TIM_MODULE_ENABLED typedef struct { - TIM_HandleTypeDef *htim; - void (*irqCallback)(void *); - void *irqCallbackUserData; + TIM_HandleTypeDef* htim; + void (*irqCallback)(void*); + void* irqCallbackUserData; } TimPeriodElapsedCallbackProperty_s; static TimPeriodElapsedCallbackProperty_s timPeriodElapsedCallbacks[MAX_TIM_HANDLES]; static int numTimPeriodElapsedCallbacksRegistered = 0; -void halCallbacks_registerTimPeriodElapsedCallback(TIM_HandleTypeDef *htim, - void (*callback)(void *), - void *userData) { +void halCallbacks_registerTimPeriodElapsedCallback(TIM_HandleTypeDef* htim, + void (*callback)(void*), + void* userData) { for (int i = 0; i < numTimPeriodElapsedCallbacksRegistered; i++) { if (timPeriodElapsedCallbacks[i].htim == htim) { timPeriodElapsedCallbacks[i].irqCallback = callback; @@ -312,7 +312,7 @@ void halCallbacks_registerTimPeriodElapsedCallback(TIM_HandleTypeDef *htim, numTimPeriodElapsedCallbacksRegistered++; } -void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim) { +void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef* htim) { for (int i = 0; i < numTimPeriodElapsedCallbacksRegistered; i++) { if (timPeriodElapsedCallbacks[i].htim == htim) { if (timPeriodElapsedCallbacks[i].irqCallback != NULL) { diff --git a/platformio_projects/lib/new_hal/hal_callbacks.h b/platformio_projects/lib/new_hal/hal_callbacks.h index bb4c3aa3..15dc088e 100644 --- a/platformio_projects/lib/new_hal/hal_callbacks.h +++ b/platformio_projects/lib/new_hal/hal_callbacks.h @@ -8,42 +8,42 @@ #include "board_config_common.h" #ifdef HAL_SPI_MODULE_ENABLED -void halCallbacks_registerSpiTxCpltCallback(SPI_HandleTypeDef *hspi, - void (*callback)(void *), - void *userData); -void halCallbacks_registerSpiTxRxCpltCallback(SPI_HandleTypeDef *hspi, - void (*callback)(void *), - void *userData); +void halCallbacks_registerSpiTxCpltCallback(SPI_HandleTypeDef* hspi, + void (*callback)(void*), + void* userData); +void halCallbacks_registerSpiTxRxCpltCallback(SPI_HandleTypeDef* hspi, + void (*callback)(void*), + void* userData); #endif // HAL_SPI_MODULE_ENABLED #ifdef HAL_ADC_MODULE_ENABLED -void halCallbacks_registerAdcConvCpltCallback(ADC_HandleTypeDef *hadc, - void (*callback)(void *), - void *userData); +void halCallbacks_registerAdcConvCpltCallback(ADC_HandleTypeDef* hadc, + void (*callback)(void*), + void* userData); #endif // HAL_ADC_MODULE_ENABLED #ifdef HAL_UART_MODULE_ENABLED -void halCallbacks_registerUartRxHalfCpltCallback(UART_HandleTypeDef *huart, - void (*callback)(void *), - void *userData); -void halCallbacks_registerUartRxCpltCallback(UART_HandleTypeDef *huart, - void (*callback)(void *), - void *userData); -void halCallbacks_registerUartRxIdleCallback(UART_HandleTypeDef *huart, - void (*callback)(void *, size_t), - void *userData); +void halCallbacks_registerUartRxHalfCpltCallback(UART_HandleTypeDef* huart, + void (*callback)(void*), + void* userData); +void halCallbacks_registerUartRxCpltCallback(UART_HandleTypeDef* huart, + void (*callback)(void*), + void* userData); +void halCallbacks_registerUartRxIdleCallback(UART_HandleTypeDef* huart, + void (*callback)(void*, size_t), + void* userData); #endif // HAL_UART_MODULE_ENABLED #ifdef HAL_EXTI_MODULE_ENABLED void halCallbacks_registerExtInterruptCallback(uint16_t gpioPin, - void (*callback)(void *), - void *userData); + void (*callback)(void*), + void* userData); #endif // HAL_EXTI_MODULE_ENABLED #ifdef HAL_TIM_MODULE_ENABLED -void halCallbacks_registerTimPeriodElapsedCallback(TIM_HandleTypeDef *htim, - void (*callback)(void *), - void *userData); +void halCallbacks_registerTimPeriodElapsedCallback(TIM_HandleTypeDef* htim, + void (*callback)(void*), + void* userData); #endif // HAL_TIM_MODULE_ENABLED #endif // PLATFORMIO_PROJECTS_LIB_NEW_HAL_HAL_CALLBACKS_H_ diff --git a/platformio_projects/lib/new_hal/internal_flash.c b/platformio_projects/lib/new_hal/internal_flash.c index 4acfd7eb..12be549b 100644 --- a/platformio_projects/lib/new_hal/internal_flash.c +++ b/platformio_projects/lib/new_hal/internal_flash.c @@ -19,7 +19,7 @@ * @param data - Array of uint8_t to write * @param numBytes - Number of bytes to be written from data */ -bool internalFlash_write(uint32_t RelFlashAddress, uint8_t *data, +bool internalFlash_write(uint32_t RelFlashAddress, uint8_t* data, uint32_t numBytes) { return true; } @@ -31,7 +31,7 @@ bool internalFlash_write(uint32_t RelFlashAddress, uint8_t *data, * @param pData - Array of uint8_t to read into * @param numBytes - Number of bytes to be read from flash */ -bool internalFlash_read(uint32_t RelFlashAddress, uint8_t *pData, +bool internalFlash_read(uint32_t RelFlashAddress, uint8_t* pData, uint32_t numBytes) { return false; } diff --git a/platformio_projects/lib/new_hal/internal_flash.h b/platformio_projects/lib/new_hal/internal_flash.h index 250a0aa8..e444005f 100644 --- a/platformio_projects/lib/new_hal/internal_flash.h +++ b/platformio_projects/lib/new_hal/internal_flash.h @@ -25,10 +25,10 @@ extern "C" { #define MAX_FLASH_ADDRESS INTERNAL_FLASH_END - INTERNAL_FLASH_START -bool internalFlash_write(uint32_t RelFlashAddress, uint8_t *data, +bool internalFlash_write(uint32_t RelFlashAddress, uint8_t* data, uint32_t numBytes); -bool internalFlash_read(uint32_t RelFlashAddress, uint8_t *pData, +bool internalFlash_read(uint32_t RelFlashAddress, uint8_t* pData, uint32_t numBytes); #ifdef __cplusplus diff --git a/platformio_projects/src/testing/pico_test.cpp b/platformio_projects/src/testing/pico_test.cpp index 95f8e6d9..3967915b 100644 --- a/platformio_projects/src/testing/pico_test.cpp +++ b/platformio_projects/src/testing/pico_test.cpp @@ -39,7 +39,7 @@ void loop() { uint8_t packet_str[] = {3, 1, 2, 3}; memcpy(packet.data, packet_str, sizeof(packet_str)); size_t inputNum = sizeof(TestPacket_s); - uint8_t *input = (uint8_t *)&packet; + uint8_t* input = (uint8_t*)&packet; // Generate CRC { @@ -75,7 +75,7 @@ void loop() { FecDecoder decoder; // uint8_t decoded_data[sizeof(packet)]; TestPacket_s rxPacket; - decoder.FecDecode(fec_output, reinterpret_cast(&rxPacket), + decoder.FecDecode(fec_output, reinterpret_cast(&rxPacket), sizeof(rxPacket)); uint32_t t2 = micros(); @@ -84,7 +84,7 @@ void loop() { sizeof(rxPacket)); Serial.print(buff); for (int i = 0; i < sizeof(rxPacket); i++) { - snprintf(buff, sizeof(buff), "%02X%s", ((uint8_t *)&rxPacket)[i], + snprintf(buff, sizeof(buff), "%02X%s", ((uint8_t*)&rxPacket)[i], (i % 8 == 7) ? "\n" : (i % 2 == 1) ? " " : " "); diff --git a/platformio_projects/src/testing/radio_test.cpp b/platformio_projects/src/testing/radio_test.cpp index 8c6e0d9f..b7b8ea51 100644 --- a/platformio_projects/src/testing/radio_test.cpp +++ b/platformio_projects/src/testing/radio_test.cpp @@ -147,7 +147,7 @@ void loop() { Serial.println("Sending..."); delay(10); - rf95.send((uint8_t *)radiopacket, 20); + rf95.send((uint8_t*)radiopacket, 20); Serial.println("Waiting for packet to complete..."); delay(10); @@ -161,7 +161,7 @@ void loop() { // Should be a reply message for us now if (rf95.recv(buf, &len)) { Serial.print("Got reply: "); - Serial.println((char *)buf); + Serial.println((char*)buf); Serial.print("RSSI: "); Serial.println(rf95.lastRssi(), DEC); } else { diff --git a/stm32_projects/device_drivers/accel_h3lis331dl.cpp b/stm32_projects/device_drivers/accel_h3lis331dl.cpp index 29c96bb2..4dc734af 100644 --- a/stm32_projects/device_drivers/accel_h3lis331dl.cpp +++ b/stm32_projects/device_drivers/accel_h3lis331dl.cpp @@ -30,11 +30,11 @@ #define Y_AXIS_ENABLE (1 << 1) #define X_AXIS_ENABLE (1 << 0) -static uint8_t whoAmI(AccelH3lis331dlCtrl_s *sensor) { +static uint8_t whoAmI(AccelH3lis331dlCtrl_s* sensor) { return spi_readRegister(&sensor->spi, H3LIS331DL_SPI_REG_MASK | REG_WHO_AM_I); } -static void accelH3lis331dl_getDataRaw(AccelH3lis331dlCtrl_s *sensor) { +static void accelH3lis331dl_getDataRaw(AccelH3lis331dlCtrl_s* sensor) { // Takes x, y, and z axis readings uint8_t x_l = spi_readRegister(&sensor->spi, H3LIS331DL_SPI_REG_MASK | REG_OUT_X_L); @@ -55,11 +55,11 @@ static void accelH3lis331dl_getDataRaw(AccelH3lis331dlCtrl_s *sensor) { sensor->val.raw.z = static_cast((z_h << 8) | (z_l)); } -static void accelH3lis331dl_getGain(AccelH3lis331dlCtrl_s *sensor) { +static void accelH3lis331dl_getGain(AccelH3lis331dlCtrl_s* sensor) { sensor->gain = 0.02942; } -bool accelH3lis331dl_init(AccelH3lis331dlCtrl_s *sensor, SpiCtrl_t spi) { +bool accelH3lis331dl_init(AccelH3lis331dlCtrl_s* sensor, SpiCtrl_t spi) { sensor->spi = spi; HAL_GPIO_WritePin(sensor->spi.port, sensor->spi.pin, GPIO_PIN_SET); HAL_Delay(1); @@ -76,7 +76,7 @@ bool accelH3lis331dl_init(AccelH3lis331dlCtrl_s *sensor, SpiCtrl_t spi) { return true; } -void accelH3lis331dl_getData(AccelH3lis331dlCtrl_s *sensor) { +void accelH3lis331dl_getData(AccelH3lis331dlCtrl_s* sensor) { accelH3lis331dl_getDataRaw(sensor); sensor->val.realMps2.x = sensor->gain * sensor->val.raw.x; sensor->val.realMps2.y = sensor->gain * sensor->val.raw.y; diff --git a/stm32_projects/device_drivers/accel_h3lis331dl.h b/stm32_projects/device_drivers/accel_h3lis331dl.h index 637f90c0..790da2e7 100644 --- a/stm32_projects/device_drivers/accel_h3lis331dl.h +++ b/stm32_projects/device_drivers/accel_h3lis331dl.h @@ -22,8 +22,8 @@ typedef struct { AccelData_s val; } AccelH3lis331dlCtrl_s; -bool accelH3lis331dl_init(AccelH3lis331dlCtrl_s *sensor, SpiCtrl_t spi); -void accelH3lis331dl_getData(AccelH3lis331dlCtrl_s *sensor); +bool accelH3lis331dl_init(AccelH3lis331dlCtrl_s* sensor, SpiCtrl_t spi); +void accelH3lis331dl_getData(AccelH3lis331dlCtrl_s* sensor); #ifdef __cplusplus } diff --git a/stm32_projects/device_drivers/adc_device.cpp b/stm32_projects/device_drivers/adc_device.cpp index 3f95d428..dae19c13 100644 --- a/stm32_projects/device_drivers/adc_device.cpp +++ b/stm32_projects/device_drivers/adc_device.cpp @@ -14,11 +14,11 @@ #define MAX_RAW_VAL_10B 1 << 10 #define MAX_RAW_VAL_8B 1 << 8 -static void adcDev_conversionCpltCallback(void *adc) { - (static_cast(adc))->bConvCplt = true; +static void adcDev_conversionCpltCallback(void* adc) { + (static_cast(adc))->bConvCplt = true; } -bool adcDev_init(AdcDevCtrl_s *adc, ADC_HandleTypeDef *hadc, +bool adcDev_init(AdcDevCtrl_s* adc, ADC_HandleTypeDef* hadc, bool bSingleEnded) { // Set struct values adc->hadc = hadc; @@ -70,7 +70,7 @@ bool adcDev_init(AdcDevCtrl_s *adc, ADC_HandleTypeDef *hadc, return true; } -void adcDev_convertAllChannels(AdcDevCtrl_s *adc) { +void adcDev_convertAllChannels(AdcDevCtrl_s* adc) { // Register callback for completed adc conversion (will overwrite any existing // callback/data for existing ADC handle) halCallbacks_registerAdcConvCpltCallback(adc->hadc, @@ -84,7 +84,7 @@ void adcDev_convertAllChannels(AdcDevCtrl_s *adc) { HAL_ADC_Start_DMA(adc->hadc, adc->rawVals, adc->hadc->Init.NbrOfConversion); } -bool adcDev_getValue(AdcDevCtrl_s *adc, uint8_t rank, float *pval, float minVal, +bool adcDev_getValue(AdcDevCtrl_s* adc, uint8_t rank, float* pval, float minVal, float maxVal, uint32_t timeoutMS) { // Wait for something to happen uint32_t startTime = HAL_GetTick(); diff --git a/stm32_projects/device_drivers/adc_device.h b/stm32_projects/device_drivers/adc_device.h index 19994751..5d147bd9 100644 --- a/stm32_projects/device_drivers/adc_device.h +++ b/stm32_projects/device_drivers/adc_device.h @@ -18,7 +18,7 @@ extern "C" { #if (HAS_DEV(STM_HADC)) typedef struct { - ADC_HandleTypeDef *hadc; + ADC_HandleTypeDef* hadc; bool bConvCplt; uint32_t rawVals[MAX_CHANNELS]; float maxRawVal; @@ -29,20 +29,20 @@ typedef struct { * @param minVal: correlates to raw 0 * @param maxVal: correlates to highest raw value of ADC's resolution */ -bool adcDev_init(AdcDevCtrl_s *adc, ADC_HandleTypeDef *hadc, bool bSingleEnded); +bool adcDev_init(AdcDevCtrl_s* adc, ADC_HandleTypeDef* hadc, bool bSingleEnded); /** * Starts a one-time ADC read/conversion on all channels currently configured. * Access the results using adcDev_getValue. */ -void adcDev_convertAllChannels(AdcDevCtrl_s *adc); +void adcDev_convertAllChannels(AdcDevCtrl_s* adc); /** * Returns true with converted ADC value if available, otherwise returns false * (hardware conversion hasn't completed) * @param rank: The rank of the ADC channel to retrieve the value orf */ -bool adcDev_getValue(AdcDevCtrl_s *adc, uint8_t rank, float *pval, +bool adcDev_getValue(AdcDevCtrl_s* adc, uint8_t rank, float* pval, float minValue, float maxValue, uint32_t timeoutMS); #endif diff --git a/stm32_projects/device_drivers/adc_mcp3564.cpp b/stm32_projects/device_drivers/adc_mcp3564.cpp index 5bff6ea9..0d81e31c 100644 --- a/stm32_projects/device_drivers/adc_mcp3564.cpp +++ b/stm32_projects/device_drivers/adc_mcp3564.cpp @@ -67,7 +67,7 @@ static const uint8_t DEV_ADDR = 0x1; * @param val the value to set into the register * @return an error code, if any */ -static int mcp356x_modifyReg8(AdcMcp3564Ctrl_s *dev, uint16_t reg_addr, +static int mcp356x_modifyReg8(AdcMcp3564Ctrl_s* dev, uint16_t reg_addr, uint8_t mask, int val) { // 1: Read data from register uint8_t tx_read[2] = {0}; @@ -118,7 +118,7 @@ static int mcp356x_modifyReg8(AdcMcp3564Ctrl_s *dev, uint16_t reg_addr, * @param val the value to set into the register * @return an error code, if any */ -static int mcp356x_modifyReg24(AdcMcp3564Ctrl_s *dev, int reg_addr, int mask, +static int mcp356x_modifyReg24(AdcMcp3564Ctrl_s* dev, int reg_addr, int mask, int val) { // 1: Read data from register uint8_t tx_read[4]; @@ -163,9 +163,9 @@ static int mcp356x_modifyReg24(AdcMcp3564Ctrl_s *dev, int reg_addr, int mask, return 0; } -void mcp356x_txRxCpltCallback(void *pdev) { +void mcp356x_txRxCpltCallback(void* pdev) { // When the DMA transaction is done, deassert CS and process the data - AdcMcp3564Ctrl_s *dev = static_cast(pdev); + AdcMcp3564Ctrl_s* dev = static_cast(pdev); CHIP_DESELECT // third byte from bottom, DR_STATUS @@ -182,14 +182,14 @@ void mcp356x_txRxCpltCallback(void *pdev) { (static_cast(dev->rx_read_buf[4])); // TODO make this respect different DATA_FORMAT modes - AdcMcp3564_DataFormat_11 *output = - reinterpret_cast(&raw); + AdcMcp3564_DataFormat_11* output = + reinterpret_cast(&raw); uint8_t channelID = output->channel_id; dev->result[channelID] = output->data; } -void mcp356x_read(void *pdev) { - AdcMcp3564Ctrl_s *dev = static_cast(pdev); +void mcp356x_read(void* pdev) { + AdcMcp3564Ctrl_s* dev = static_cast(pdev); // Static read (Table 6-2) dev->tx_read_buf[0] = DEV_ADDR << 6 | MCP356X_REG_ADCDATA << 2 | (MCP356X_CMD_TYPE_STATIC_READ & 0x3); @@ -199,8 +199,8 @@ void mcp356x_read(void *pdev) { HAL_SPI_TransmitReceive_DMA(dev->hspi, dev->tx_read_buf, dev->rx_read_buf, 5); } -int mcp3564_init(AdcMcp3564Ctrl_s *dev, SPI_HandleTypeDef *hspi, - GPIO_TypeDef *csPort, uint16_t csPin, GPIO_TypeDef *intPort, +int mcp3564_init(AdcMcp3564Ctrl_s* dev, SPI_HandleTypeDef* hspi, + GPIO_TypeDef* csPort, uint16_t csPin, GPIO_TypeDef* intPort, uint16_t intPin) { dev->hspi = hspi; dev->csPort = csPort; @@ -307,7 +307,7 @@ int mcp3564_init(AdcMcp3564Ctrl_s *dev, SPI_HandleTypeDef *hspi, return 0; } -int mcp356x_channelSetup(AdcMcp3564Ctrl_s *dev, +int mcp356x_channelSetup(AdcMcp3564Ctrl_s* dev, const AdcMcp3564MuxChannels_e in_p, const AdcMcp3564MuxChannels_e in_n) { // 1: Configure the MUX register to select the correct channel diff --git a/stm32_projects/device_drivers/adc_mcp3564.h b/stm32_projects/device_drivers/adc_mcp3564.h index 9b6a4bc0..9824e01e 100644 --- a/stm32_projects/device_drivers/adc_mcp3564.h +++ b/stm32_projects/device_drivers/adc_mcp3564.h @@ -13,10 +13,10 @@ extern "C" { #include "board_config_common.h" typedef struct { - SPI_HandleTypeDef *hspi; - GPIO_TypeDef *csPort; + SPI_HandleTypeDef* hspi; + GPIO_TypeDef* csPort; uint16_t csPin; - GPIO_TypeDef *intPort; + GPIO_TypeDef* intPort; uint16_t intPin; int32_t result[8]; @@ -90,13 +90,13 @@ typedef struct { AdcMcp3564ScanModeChannels_e channel_id : 4; // (See table 5-14, page 54) } AdcMcp3564_DataFormat_11; -void mcp356x_read(void *pdev); -int mcp356x_process(AdcMcp3564Ctrl_s *dev); -int mcp356x_channelSetup(AdcMcp3564Ctrl_s *dev, +void mcp356x_read(void* pdev); +int mcp356x_process(AdcMcp3564Ctrl_s* dev); +int mcp356x_channelSetup(AdcMcp3564Ctrl_s* dev, const AdcMcp3564MuxChannels_e in_p, const AdcMcp3564MuxChannels_e in_n); -int mcp3564_init(AdcMcp3564Ctrl_s *dev, SPI_HandleTypeDef *hspi, - GPIO_TypeDef *csPort, uint16_t csPin, GPIO_TypeDef *intPort, +int mcp3564_init(AdcMcp3564Ctrl_s* dev, SPI_HandleTypeDef* hspi, + GPIO_TypeDef* csPort, uint16_t csPin, GPIO_TypeDef* intPort, uint16_t intPin); #ifdef __cplusplus diff --git a/stm32_projects/device_drivers/barometer_ms5607.cpp b/stm32_projects/device_drivers/barometer_ms5607.cpp index 7096b168..e36a1433 100644 --- a/stm32_projects/device_drivers/barometer_ms5607.cpp +++ b/stm32_projects/device_drivers/barometer_ms5607.cpp @@ -20,8 +20,8 @@ typedef enum { * Initializes MS5607 temperature and pressure sensor * with specific MS5607Ctrl_t configuration */ -bool barometerMs5607_init(BarometerMs5607Ctrl_s *ms5607, - SPI_HandleTypeDef *hspi, GPIO_TypeDef *csPort, +bool barometerMs5607_init(BarometerMs5607Ctrl_s* ms5607, + SPI_HandleTypeDef* hspi, GPIO_TypeDef* csPort, uint16_t csPin) { ms5607->hspi = hspi; ms5607->csPort = csPort; @@ -64,7 +64,7 @@ bool barometerMs5607_init(BarometerMs5607Ctrl_s *ms5607, * Temperature in C stored in ms5607->altData.temp * Pressure in Atm stored in ms5607->altData.baro */ -void barometerMs5607_getData(BarometerMs5607Ctrl_s *ms5607) { +void barometerMs5607_getData(BarometerMs5607Ctrl_s* ms5607) { // Stores raw pressure and temperature values uint8_t presStore[4]; uint8_t tempStore[4]; diff --git a/stm32_projects/device_drivers/barometer_ms5607.h b/stm32_projects/device_drivers/barometer_ms5607.h index 961e3b1a..58f6e650 100644 --- a/stm32_projects/device_drivers/barometer_ms5607.h +++ b/stm32_projects/device_drivers/barometer_ms5607.h @@ -11,17 +11,17 @@ extern "C" { #include "data_structures.h" typedef struct { - SPI_HandleTypeDef *hspi; - GPIO_TypeDef *csPort; + SPI_HandleTypeDef* hspi; + GPIO_TypeDef* csPort; uint16_t csPin; BarometerData_s data; uint16_t promVals[6]; } BarometerMs5607Ctrl_s; -bool barometerMs5607_init(BarometerMs5607Ctrl_s *ms5607, - SPI_HandleTypeDef *hspi, GPIO_TypeDef *csPort, +bool barometerMs5607_init(BarometerMs5607Ctrl_s* ms5607, + SPI_HandleTypeDef* hspi, GPIO_TypeDef* csPort, uint16_t csPin); -void barometerMs5607_getData(BarometerMs5607Ctrl_s *altCtrl); +void barometerMs5607_getData(BarometerMs5607Ctrl_s* altCtrl); #ifdef __cplusplus } diff --git a/stm32_projects/device_drivers/ble_chip.h b/stm32_projects/device_drivers/ble_chip.h index 95ed659e..81a0b3c7 100644 --- a/stm32_projects/device_drivers/ble_chip.h +++ b/stm32_projects/device_drivers/ble_chip.h @@ -12,12 +12,12 @@ #define BT_MAX_PACKET_SIZE 0xff // or 256 typedef struct { - void (*registerAddress)(void *ctrl, uint8_t address, CircularBuffer_s *cb); - bool (*sendRequest)(void *ctrl, uint8_t address, const void *pdata, + void (*registerAddress)(void* ctrl, uint8_t address, CircularBuffer_s* cb); + bool (*sendRequest)(void* ctrl, uint8_t address, const void* pdata, uint16_t len); - bool (*isAddressConnected)(void *ctrl, uint8_t address); - bool (*pollConnectedClients)(void *ctrl); - size_t (*dequeuePacket)(CircularBuffer_s *buffer, uint8_t *pdata); + bool (*isAddressConnected)(void* ctrl, uint8_t address); + bool (*pollConnectedClients)(void* ctrl); + size_t (*dequeuePacket)(CircularBuffer_s* buffer, uint8_t* pdata); } BleChip_s; #endif // STM32_PROJECTS_DEVICE_DRIVERS_BLE_CHIP_H_ diff --git a/stm32_projects/device_drivers/ble_chip_nrf.cpp b/stm32_projects/device_drivers/ble_chip_nrf.cpp index bb26be1d..fef33cc8 100644 --- a/stm32_projects/device_drivers/ble_chip_nrf.cpp +++ b/stm32_projects/device_drivers/ble_chip_nrf.cpp @@ -13,7 +13,7 @@ #include "hal_callbacks.h" -static bool bleChipNrf_txBusy(BleChipNrfCtrl_t *ctrl) { +static bool bleChipNrf_txBusy(BleChipNrfCtrl_t* ctrl) { return HAL_UART_STATE_READY != ctrl->ble_uart->gState; } @@ -28,8 +28,8 @@ static bool bleChipNrf_txBusy(BleChipNrfCtrl_t *ctrl) { * @return the status code from the HAL library from * sending a transmission. */ -static HAL_StatusTypeDef bleChipNrf_txInternal(BleChipNrfCtrl_t *ctrl, - uint8_t *buf, uint16_t bufLen) { +static HAL_StatusTypeDef bleChipNrf_txInternal(BleChipNrfCtrl_t* ctrl, + uint8_t* buf, uint16_t bufLen) { uint32_t start = HAL_GetTick(); while (HAL_GetTick() - start < @@ -50,8 +50,8 @@ static HAL_StatusTypeDef bleChipNrf_txInternal(BleChipNrfCtrl_t *ctrl, INCOMING_PACKET_SIZE) // A transmission Size bytes long just ended that began at the old dma_buff_head -static void bleChipNrf_rxEventCallback(void *userData, size_t Size) { - BleChipNrfCtrl_t *ctrl = (BleChipNrfCtrl_t *)userData; +static void bleChipNrf_rxEventCallback(void* userData, size_t Size) { + BleChipNrfCtrl_t* ctrl = (BleChipNrfCtrl_t*)userData; // Our new data starts at dma_buff_begin // Let's just cast it to a pointer to a RecievedPacket and @@ -59,7 +59,7 @@ static void bleChipNrf_rxEventCallback(void *userData, size_t Size) { uint8_t address = ctrl->dma_buff_begin[0]; uint16_t len = static_cast(ctrl->dma_buff_begin[1] | ctrl->dma_buff_begin[2] << 8); - uint8_t *pdata = ctrl->dma_buff_begin + 3; + uint8_t* pdata = ctrl->dma_buff_begin + 3; // Dumb exception for "connected clients" packet if (address == BLEINTERFACE_SELF_ADDR && len == 1) { @@ -80,16 +80,16 @@ static void bleChipNrf_rxEventCallback(void *userData, size_t Size) { START_DMA; } -static void bleChipNrf_rxCpltCallback(void *userData) { +static void bleChipNrf_rxCpltCallback(void* userData) { // The buffer should be full at this point bleChipNrf_rxEventCallback(userData, DMA_BUFF_SIZE); } // Associate a given circular buffer with an address. Bytes addressed to it will // be added to the buffer. -static void bleChipNrf_registerAddress(void *ctrl, uint8_t address, - CircularBuffer_s *cb) { - BleChipNrfCtrl_t *realCtrl = (BleChipNrfCtrl_t *)ctrl; +static void bleChipNrf_registerAddress(void* ctrl, uint8_t address, + CircularBuffer_s* cb) { + BleChipNrfCtrl_t* realCtrl = (BleChipNrfCtrl_t*)ctrl; realCtrl->circular_buffers[address] = cb; } @@ -99,9 +99,9 @@ static void bleChipNrf_registerAddress(void *ctrl, uint8_t address, * which MUST be below MAX_PACKET Note that this blocks while transmission * happens */ -static bool bleChipNrf_sendRequest(void *ctrl, uint8_t address, - const void *pdata, uint16_t len) { - BleChipNrfCtrl_t *realCtrl = (BleChipNrfCtrl_t *)ctrl; +static bool bleChipNrf_sendRequest(void* ctrl, uint8_t address, + const void* pdata, uint16_t len) { + BleChipNrfCtrl_t* realCtrl = (BleChipNrfCtrl_t*)ctrl; // We need to transmit 1 byte addr, 2 byte len, n bytes of data const uint16_t headerSize = sizeof(address) + sizeof(len); @@ -125,8 +125,8 @@ static bool bleChipNrf_sendRequest(void *ctrl, uint8_t address, return ret == HAL_OK; } -static size_t bleChipNrf_dequeuePacket(CircularBuffer_s *buffer, - uint8_t *pdata) { +static size_t bleChipNrf_dequeuePacket(CircularBuffer_s* buffer, + uint8_t* pdata) { // We should have at least 2 bytes (the len bytes) in our array if (cb_count(buffer) < 2) return 0; @@ -156,21 +156,21 @@ static size_t bleChipNrf_dequeuePacket(CircularBuffer_s *buffer, // Check if a particular address was reported as connected. Note that this uses // the cached connectedClients value! connectedClients should be updated // periodically -static bool bleChipNrf_isAddressConnected(void *ctrl, uint8_t address) { - BleChipNrfCtrl_t *realCtrl = (BleChipNrfCtrl_t *)ctrl; +static bool bleChipNrf_isAddressConnected(void* ctrl, uint8_t address) { + BleChipNrfCtrl_t* realCtrl = (BleChipNrfCtrl_t*)ctrl; uint8_t mask = 0b1 << (address - 1); return (bool)(realCtrl->connectedClients & mask); } // Send a request to the Bluetooth chip on the FCB to tell us what clients are // connected -static bool bleChipNrf_pollConnectedClients(void *ctrl) { +static bool bleChipNrf_pollConnectedClients(void* ctrl) { uint8_t one = 0x01; return HAL_OK == bleChipNrf_sendRequest(ctrl, BLEINTERFACE_SELF_ADDR, &one, 1); } -void bleChipNrf_init(BleChipNrfCtrl_t *ctrl, UART_HandleTypeDef *ble_uart) { +void bleChipNrf_init(BleChipNrfCtrl_t* ctrl, UART_HandleTypeDef* ble_uart) { ctrl->bleChip.dequeuePacket = bleChipNrf_dequeuePacket; ctrl->bleChip.isAddressConnected = bleChipNrf_isAddressConnected; ctrl->bleChip.pollConnectedClients = bleChipNrf_pollConnectedClients; @@ -195,7 +195,7 @@ void bleChipNrf_init(BleChipNrfCtrl_t *ctrl, UART_HandleTypeDef *ble_uart) { START_DMA; } -void bleChipNrf_tick(BleChipNrfCtrl_t *ctrl) { +void bleChipNrf_tick(BleChipNrfCtrl_t* ctrl) { if (HAL_GetTick() > ctrl->lastPollTimestamp + BLE_POLL_INTERVAL) { bleChipNrf_pollConnectedClients(ctrl); ctrl->lastPollTimestamp = HAL_GetTick(); diff --git a/stm32_projects/device_drivers/ble_chip_nrf.h b/stm32_projects/device_drivers/ble_chip_nrf.h index a0ac56ec..33809c4c 100644 --- a/stm32_projects/device_drivers/ble_chip_nrf.h +++ b/stm32_projects/device_drivers/ble_chip_nrf.h @@ -36,7 +36,7 @@ typedef struct __attribute__((__packed__)) { #define INCOMING_PACKET_BUFF_LEN 10 #define INCOMING_PACKET_SIZE (sizeof(BleChipNrfRecievedPacket_s) + 1) #define DMA_BUFF_SIZE \ - INCOMING_PACKET_BUFF_LEN *INCOMING_PACKET_SIZE // Buffer that DMA writes to + INCOMING_PACKET_BUFF_LEN* INCOMING_PACKET_SIZE // Buffer that DMA writes to /* * A bluetooth client inplements the comm protocol defined here: @@ -53,12 +53,12 @@ typedef struct __attribute__((__packed__)) { typedef struct { BleChip_s bleChip; - UART_HandleTypeDef *ble_uart; + UART_HandleTypeDef* ble_uart; uint8_t dma_buff_begin[INCOMING_PACKET_SIZE]; // List of pointers to circular buffers for our 4 addresses. Set these from // device drivers - CircularBuffer_s *circular_buffers[MAX_ADDRESSES]; + CircularBuffer_s* circular_buffers[MAX_ADDRESSES]; uint8_t connectedClients; // bits: 0 for phone, 1 for LC1, 2 for LC2 @@ -66,8 +66,8 @@ typedef struct { uint32_t lastPollTimestamp; } BleChipNrfCtrl_t; -void bleChipNrf_init(BleChipNrfCtrl_t *ctrl, UART_HandleTypeDef *ble_uart); -void bleChipNrf_tick(BleChipNrfCtrl_t *ctrl); +void bleChipNrf_init(BleChipNrfCtrl_t* ctrl, UART_HandleTypeDef* ble_uart); +void bleChipNrf_tick(BleChipNrfCtrl_t* ctrl); #endif diff --git a/stm32_projects/device_drivers/ble_client_std.cpp b/stm32_projects/device_drivers/ble_client_std.cpp index 76777fe9..caad7e48 100644 --- a/stm32_projects/device_drivers/ble_client_std.cpp +++ b/stm32_projects/device_drivers/ble_client_std.cpp @@ -14,7 +14,7 @@ #define MAX_PACKETS_PER_TICK 10 static uint8_t tempDataBuffer[DATA_BUFFER_SIZE] = {0}; -void bleClientStd_init(BleClientStdCtrl_s *ctrl, BleChip_s *bleChip, +void bleClientStd_init(BleClientStdCtrl_s* ctrl, BleChip_s* bleChip, uint8_t address) { ctrl->bleChip = bleChip; ctrl->address = address; @@ -25,7 +25,7 @@ void bleClientStd_init(BleClientStdCtrl_s *ctrl, BleChip_s *bleChip, ctrl->bleChip->registerAddress(ctrl->bleChip, address, &ctrl->dmaBuffer); } -void bleClientStd_tick(BleClientStdCtrl_s *ctrl) { +void bleClientStd_tick(BleClientStdCtrl_s* ctrl) { size_t dequeuedLen; uint8_t packetCount = 0; do { diff --git a/stm32_projects/device_drivers/ble_client_std.h b/stm32_projects/device_drivers/ble_client_std.h index 47ffba65..38e86a6d 100644 --- a/stm32_projects/device_drivers/ble_client_std.h +++ b/stm32_projects/device_drivers/ble_client_std.h @@ -17,7 +17,7 @@ typedef struct { // Reference to the BLE chip driver "class" - BleChip_s *bleChip; + BleChip_s* bleChip; // BLE "address" data comes from uint8_t address; @@ -32,8 +32,8 @@ typedef struct { CircularBuffer_s parsedBuffer; } BleClientStdCtrl_s; -void bleClientStd_init(BleClientStdCtrl_s *ctrl, BleChip_s *bleChip, +void bleClientStd_init(BleClientStdCtrl_s* ctrl, BleChip_s* bleChip, uint8_t address); -void bleClientStd_tick(BleClientStdCtrl_s *ctrl); +void bleClientStd_tick(BleClientStdCtrl_s* ctrl); #endif // STM32_PROJECTS_DEVICE_DRIVERS_BLE_CLIENT_STD_H_ diff --git a/stm32_projects/device_drivers/buzzer_pwm.cpp b/stm32_projects/device_drivers/buzzer_pwm.cpp index 06cb4610..fb5d57c0 100644 --- a/stm32_projects/device_drivers/buzzer_pwm.cpp +++ b/stm32_projects/device_drivers/buzzer_pwm.cpp @@ -8,7 +8,7 @@ static const float TWO_POWER_SIXTEEN = 65535.0f; -void buzzerPwm_init(BuzzerPwmCtrl_s *buzzer, TIM_HandleTypeDef *htim, +void buzzerPwm_init(BuzzerPwmCtrl_s* buzzer, TIM_HandleTypeDef* htim, uint32_t channel, float minFrequency) { // Set buzzer struct values buzzer->htim = htim; @@ -29,7 +29,7 @@ void buzzerPwm_init(BuzzerPwmCtrl_s *buzzer, TIM_HandleTypeDef *htim, (static_cast(htim->Init.Prescaler + 1) * TWO_POWER_SIXTEEN * 2); } -void buzzerPwm_setFrequency(BuzzerPwmCtrl_s *buzzer, float fHz) { +void buzzerPwm_setFrequency(BuzzerPwmCtrl_s* buzzer, float fHz) { // Calculate period based on minimum and given frequencies if (fHz < buzzer->minFrequency) { buzzer->htim->Init.Period = 0; @@ -46,12 +46,12 @@ void buzzerPwm_setFrequency(BuzzerPwmCtrl_s *buzzer, float fHz) { buzzer->htim->Init.Period / 2); } -void buzzerPwm_start(BuzzerPwmCtrl_s *buzzer) { +void buzzerPwm_start(BuzzerPwmCtrl_s* buzzer) { // Start PWM generation HAL_TIM_PWM_Start(buzzer->htim, buzzer->channel); } -void buzzerPwm_stop(BuzzerPwmCtrl_s *buzzer) { +void buzzerPwm_stop(BuzzerPwmCtrl_s* buzzer) { // Stop PWM generation HAL_TIM_PWM_Stop(buzzer->htim, buzzer->channel); } diff --git a/stm32_projects/device_drivers/buzzer_pwm.h b/stm32_projects/device_drivers/buzzer_pwm.h index 53f356c0..d7326f30 100644 --- a/stm32_projects/device_drivers/buzzer_pwm.h +++ b/stm32_projects/device_drivers/buzzer_pwm.h @@ -16,16 +16,16 @@ extern "C" { #if HAS_DEV(BUZZER_PWM) typedef struct { - TIM_HandleTypeDef *htim; + TIM_HandleTypeDef* htim; uint32_t channel; double minFrequency; } BuzzerPwmCtrl_s; -void buzzerPwm_init(BuzzerPwmCtrl_s *buzzer, TIM_HandleTypeDef *htim, +void buzzerPwm_init(BuzzerPwmCtrl_s* buzzer, TIM_HandleTypeDef* htim, uint32_t channel, float minFrequency); -void buzzerPwm_setFrequency(BuzzerPwmCtrl_s *buzzer, float fHz); -void buzzerPwm_start(BuzzerPwmCtrl_s *buzzer); -void buzzerPwm_stop(BuzzerPwmCtrl_s *buzzer); +void buzzerPwm_setFrequency(BuzzerPwmCtrl_s* buzzer, float fHz); +void buzzerPwm_start(BuzzerPwmCtrl_s* buzzer); +void buzzerPwm_stop(BuzzerPwmCtrl_s* buzzer); #endif diff --git a/stm32_projects/device_drivers/dc_motor_pwm.cpp b/stm32_projects/device_drivers/dc_motor_pwm.cpp index 5302adbb..8f7d35c6 100644 --- a/stm32_projects/device_drivers/dc_motor_pwm.cpp +++ b/stm32_projects/device_drivers/dc_motor_pwm.cpp @@ -6,7 +6,7 @@ #include /* inits a DC motor specified by the user */ -void dcMotorPwm_init(DcMotorPwmCtrl_s *dev, TIM_HandleTypeDef *htim, +void dcMotorPwm_init(DcMotorPwmCtrl_s* dev, TIM_HandleTypeDef* htim, uint32_t channel) { dev->htim = htim; dev->channel = channel; @@ -18,7 +18,7 @@ void dcMotorPwm_init(DcMotorPwmCtrl_s *dev, TIM_HandleTypeDef *htim, } /* STARTS a given user defined DC motor, with a certain speed percentage */ -void dcMotorPwm_setPercent(DcMotorPwmCtrl_s *dev, double speed_percent) { +void dcMotorPwm_setPercent(DcMotorPwmCtrl_s* dev, double speed_percent) { /* If percent too large, stop */ if (fabs(speed_percent) > 100) return; diff --git a/stm32_projects/device_drivers/dc_motor_pwm.h b/stm32_projects/device_drivers/dc_motor_pwm.h index a9d1f7e2..573a7be0 100644 --- a/stm32_projects/device_drivers/dc_motor_pwm.h +++ b/stm32_projects/device_drivers/dc_motor_pwm.h @@ -12,16 +12,16 @@ extern "C" { /* Definition of DC motor control struct */ /* user needs to config timer */ typedef struct { - TIM_HandleTypeDef *htim; + TIM_HandleTypeDef* htim; uint32_t channel; } DcMotorPwmCtrl_s; /* creates a new DC motor that can be started and stopped */ -void dcMotorPwm_init(DcMotorPwmCtrl_s *dev, TIM_HandleTypeDef *htim, +void dcMotorPwm_init(DcMotorPwmCtrl_s* dev, TIM_HandleTypeDef* htim, uint32_t channel); /* start a specified DC motor with a given speed percentage -100-100 */ -void dcMotorPwm_setPercent(DcMotorPwmCtrl_s *dev, double speed_percent); +void dcMotorPwm_setPercent(DcMotorPwmCtrl_s* dev, double speed_percent); #endif diff --git a/stm32_projects/device_drivers/flash_mb85rsx.cpp b/stm32_projects/device_drivers/flash_mb85rsx.cpp index 673b0504..f94a008a 100644 --- a/stm32_projects/device_drivers/flash_mb85rsx.cpp +++ b/stm32_projects/device_drivers/flash_mb85rsx.cpp @@ -21,24 +21,24 @@ #define READ_CMD 0b11 #define WRITE_CMD 0b10 -static bool writeDisable(FlashMb85rsxCtrl_s *mb85rsx) { +static bool writeDisable(FlashMb85rsxCtrl_s* mb85rsx) { uint8_t cmd = WRITE_DISABLE; spi_writeArray(&mb85rsx->spi, &cmd, sizeof(cmd)); return true; // TODO error checking } -static bool writeEnable(FlashMb85rsxCtrl_s *mb85rsx) { +static bool writeEnable(FlashMb85rsxCtrl_s* mb85rsx) { uint8_t cmd = WRITE_ENABLE; spi_writeArray(&mb85rsx->spi, &cmd, sizeof(cmd)); return true; // TODO error checking } -static void csPull(const FlashMb85rsxCtrl_s *mb85rsx, GPIO_PinState direction) { +static void csPull(const FlashMb85rsxCtrl_s* mb85rsx, GPIO_PinState direction) { HAL_GPIO_WritePin(mb85rsx->spi.port, mb85rsx->spi.pin, direction); } -void flashMb85rsx_init(FlashMb85rsxCtrl_s *mb85rsx, SPI_HandleTypeDef *hspi, - GPIO_TypeDef *csPort, uint16_t csPin) { +void flashMb85rsx_init(FlashMb85rsxCtrl_s* mb85rsx, SPI_HandleTypeDef* hspi, + GPIO_TypeDef* csPort, uint16_t csPin) { // Set struct properties mb85rsx->spi.hspi = hspi; mb85rsx->spi.port = csPort; @@ -54,11 +54,11 @@ void flashMb85rsx_init(FlashMb85rsxCtrl_s *mb85rsx, SPI_HandleTypeDef *hspi, // disable protection on all blocks FlashMb85rsxStatusReg_s reg = {.bp0 = false, .bp1 = false}; - spi_writeRegister(&mb85rsx->spi, WRITE_STATUS_REG, *(uint8_t *)®); + spi_writeRegister(&mb85rsx->spi, WRITE_STATUS_REG, *(uint8_t*)®); } -bool flashMb85rsx_readStart(FlashMb85rsxCtrl_s *mb85rsx, uint32_t startLoc, - uint32_t numBytes, uint8_t *pData) { +bool flashMb85rsx_readStart(FlashMb85rsxCtrl_s* mb85rsx, uint32_t startLoc, + uint32_t numBytes, uint8_t* pData) { // Check for valid parameters if ((startLoc + numBytes) > mb85rsx->flashSizeBytes || pData == NULL || startLoc) { @@ -79,8 +79,8 @@ bool flashMb85rsx_readStart(FlashMb85rsxCtrl_s *mb85rsx, uint32_t startLoc, return true; } -bool flashMb85rsx_writeStart(FlashMb85rsxCtrl_s *mb85rsx, uint32_t startLoc, - uint32_t numBytes, uint8_t *pData) { +bool flashMb85rsx_writeStart(FlashMb85rsxCtrl_s* mb85rsx, uint32_t startLoc, + uint32_t numBytes, uint8_t* pData) { // Check for valid parameters if (startLoc + numBytes > mb85rsx->flashSizeBytes || pData == NULL) return false; diff --git a/stm32_projects/device_drivers/flash_mb85rsx.h b/stm32_projects/device_drivers/flash_mb85rsx.h index ec6945b9..022c3be9 100644 --- a/stm32_projects/device_drivers/flash_mb85rsx.h +++ b/stm32_projects/device_drivers/flash_mb85rsx.h @@ -32,17 +32,17 @@ typedef struct { uint32_t flashSizeBytes; } FlashMb85rsxCtrl_s; -void flashMb85rsx_init(FlashMb85rsxCtrl_s *s25flx, SPI_HandleTypeDef *hspi, - GPIO_TypeDef *csPort, uint16_t csPin); -bool flashMb85rsx_readStart(FlashMb85rsxCtrl_s *s25flx, uint32_t startLoc, - uint32_t numBytes, uint8_t *pData); -bool flashMb85rsx_writeStart(FlashMb85rsxCtrl_s *s25flx, uint32_t startLoc, - uint32_t numBytes, uint8_t *data); +void flashMb85rsx_init(FlashMb85rsxCtrl_s* s25flx, SPI_HandleTypeDef* hspi, + GPIO_TypeDef* csPort, uint16_t csPin); +bool flashMb85rsx_readStart(FlashMb85rsxCtrl_s* s25flx, uint32_t startLoc, + uint32_t numBytes, uint8_t* pData); +bool flashMb85rsx_writeStart(FlashMb85rsxCtrl_s* s25flx, uint32_t startLoc, + uint32_t numBytes, uint8_t* data); #ifdef USE_S25FLx_DMA -bool flashMb85rsx_isReadComplete(const FlashMb85rsxCtrl_s *s25flx); +bool flashMb85rsx_isReadComplete(const FlashMb85rsxCtrl_s* s25flx); #endif -bool flashMb85rsx_isWriteComplete(FlashMb85rsxCtrl_s *s25flx); -bool flashMb85rsx_isEraseComplete(FlashMb85rsxCtrl_s *s25flx); +bool flashMb85rsx_isWriteComplete(FlashMb85rsxCtrl_s* s25flx); +bool flashMb85rsx_isEraseComplete(FlashMb85rsxCtrl_s* s25flx); #ifdef __cplusplus } diff --git a/stm32_projects/device_drivers/flash_s25flx.cpp b/stm32_projects/device_drivers/flash_s25flx.cpp index 1beb0237..94d661bd 100644 --- a/stm32_projects/device_drivers/flash_s25flx.cpp +++ b/stm32_projects/device_drivers/flash_s25flx.cpp @@ -27,11 +27,11 @@ #define PAGE_SIZE_BYTES 512 #define SECTOR_SIZE_BYTES 262144 -static void csPull(const FlashS25flxCtrl_s *s25flx, GPIO_PinState direction) { +static void csPull(const FlashS25flxCtrl_s* s25flx, GPIO_PinState direction) { HAL_GPIO_WritePin(s25flx->csPort, s25flx->csPin, direction); } -static bool writeDisable(FlashS25flxCtrl_s *s25flx) { +static bool writeDisable(FlashS25flxCtrl_s* s25flx) { csPull(s25flx, GPIO_PIN_RESET); uint8_t tx = WRITE_DISABLE_CMD; // Write-disable command is too short to require DMA @@ -41,7 +41,7 @@ static bool writeDisable(FlashS25flxCtrl_s *s25flx) { return bSuccess; } -static bool writeEnable(FlashS25flxCtrl_s *s25flx) { +static bool writeEnable(FlashS25flxCtrl_s* s25flx) { csPull(s25flx, GPIO_PIN_RESET); uint8_t tx = WRITE_ENABLE_CMD; // Write-enable command is too short to require DMA @@ -51,7 +51,7 @@ static bool writeEnable(FlashS25flxCtrl_s *s25flx) { return bSuccess; } -static void checkWriteInProgress(FlashS25flxCtrl_s *s25flx) { +static void checkWriteInProgress(FlashS25flxCtrl_s* s25flx) { csPull(s25flx, GPIO_PIN_RESET); uint8_t tx[] = {READ_STAT_REG_CMD, 0}; uint8_t rx[] = {0, 0}; @@ -69,10 +69,10 @@ static void checkWriteInProgress(FlashS25flxCtrl_s *s25flx) { } #ifdef USE_S25FLx_DMA -static void spiTxCpltCallback(void *s25flx) { +static void spiTxCpltCallback(void* s25flx) { // Input must be void to use this function as a callback, but this is assumed // to be a S25FLXCtrl_t type - FlashS25flxCtrl_t *ps25flx = (FlashS25flxCtrl_s *)s25flx; + FlashS25flxCtrl_t* ps25flx = (FlashS25flxCtrl_s*)s25flx; ps25flx->bTxComplete = true; // There is no instance where a complete DMA TX alone would not be followed by // a CS pull high to end a command. Therefore, it makes sense to do that here @@ -81,10 +81,10 @@ static void spiTxCpltCallback(void *s25flx) { csPull(s25flx, GPIO_PIN_SET); } -static void spiRxCpltCallback(void *s25flx) { +static void spiRxCpltCallback(void* s25flx) { // Input must be void to use this function as a callback, but this is assumed // to be a S25FLXCtrl_t type - FlashS25flxCtrl_t *ps25flx = (FlashS25flxCtrl_s *)s25flx; + FlashS25flxCtrl_t* ps25flx = (FlashS25flxCtrl_s*)s25flx; ps25flx->bRxComplete = true; // There is no instance where a complete DMA RX would not be followed by a CS // pull high to end a command. Therefore, it makes sense to do that here @@ -94,8 +94,8 @@ static void spiRxCpltCallback(void *s25flx) { } #endif -void flashS25flx_init(FlashS25flxCtrl_s *s25flx, SPI_HandleTypeDef *hspi, - GPIO_TypeDef *csPort, uint16_t csPin, +void flashS25flx_init(FlashS25flxCtrl_s* s25flx, SPI_HandleTypeDef* hspi, + GPIO_TypeDef* csPort, uint16_t csPin, uint32_t flashSizeBytes) { // Set struct properties s25flx->hspi = hspi; @@ -118,8 +118,8 @@ void flashS25flx_init(FlashS25flxCtrl_s *s25flx, SPI_HandleTypeDef *hspi, HAL_GPIO_WritePin(s25flx->csPort, s25flx->csPin, GPIO_PIN_SET); } -bool flashS25flx_readStart(FlashS25flxCtrl_s *s25flx, uint32_t startLoc, - uint16_t numBytes, uint8_t *pData) { +bool flashS25flx_readStart(FlashS25flxCtrl_s* s25flx, uint32_t startLoc, + uint16_t numBytes, uint8_t* pData) { // Check for valid parameters if (startLoc + numBytes > s25flx->flashSizeBytes || pData == NULL || s25flx->bWIP @@ -171,8 +171,8 @@ bool flashS25flx_readStart(FlashS25flxCtrl_s *s25flx, uint32_t startLoc, return true; } -bool flashS25flx_writeStart(FlashS25flxCtrl_s *s25flx, uint32_t startLoc, - uint16_t numBytes, uint8_t *data) { +bool flashS25flx_writeStart(FlashS25flxCtrl_s* s25flx, uint32_t startLoc, + uint16_t numBytes, uint8_t* data) { // Only allows writing to 1 page at a time // Check for valid parameters @@ -239,7 +239,7 @@ bool flashS25flx_writeStart(FlashS25flxCtrl_s *s25flx, uint32_t startLoc, return true; } -bool flashS25flx_eraseSectorStart(FlashS25flxCtrl_s *s25flx, +bool flashS25flx_eraseSectorStart(FlashS25flxCtrl_s* s25flx, uint32_t sectorNum) { // Check for valid parameters if (sectorNum * SECTOR_SIZE_BYTES >= s25flx->flashSizeBytes) return false; @@ -275,7 +275,7 @@ bool flashS25flx_eraseSectorStart(FlashS25flxCtrl_s *s25flx, return true; } -bool flashS25flx_eraseChipStart(FlashS25flxCtrl_s *s25flx) { +bool flashS25flx_eraseChipStart(FlashS25flxCtrl_s* s25flx) { // Enable writing to flash (also necessary for erasing) if (!writeEnable(s25flx)) return false; @@ -299,12 +299,12 @@ bool flashS25flx_eraseChipStart(FlashS25flxCtrl_s *s25flx) { } #ifdef USE_S25FLx_DMA -bool flashS25flx_isReadComplete(const FlashS25flxCtrl_s *s25flx) { +bool flashS25flx_isReadComplete(const FlashS25flxCtrl_s* s25flx) { return s25flx->bRxComplete; } #endif -bool flashS25flx_isWriteComplete(FlashS25flxCtrl_s *s25flx) { +bool flashS25flx_isWriteComplete(FlashS25flxCtrl_s* s25flx) { checkWriteInProgress(s25flx); if (s25flx->bWIP) { HAL_Delay(1); @@ -315,7 +315,7 @@ bool flashS25flx_isWriteComplete(FlashS25flxCtrl_s *s25flx) { return !s25flx->bWIP; } -bool flashS25flx_isEraseComplete(FlashS25flxCtrl_s *s25flx) { +bool flashS25flx_isEraseComplete(FlashS25flxCtrl_s* s25flx) { // Same functionality as write, but different public function name is clearer // for programmers at higher levels return flashS25flx_isWriteComplete(s25flx); diff --git a/stm32_projects/device_drivers/flash_s25flx.h b/stm32_projects/device_drivers/flash_s25flx.h index 117897b9..4dfc095d 100644 --- a/stm32_projects/device_drivers/flash_s25flx.h +++ b/stm32_projects/device_drivers/flash_s25flx.h @@ -20,8 +20,8 @@ extern "C" { // TODO: Make DMA functional typedef struct { - SPI_HandleTypeDef *hspi; - GPIO_TypeDef *csPort; + SPI_HandleTypeDef* hspi; + GPIO_TypeDef* csPort; uint16_t csPin; uint32_t flashSizeBytes; bool bWIP; // Write in progress @@ -31,21 +31,21 @@ typedef struct { #endif } FlashS25flxCtrl_s; -void flashS25flx_init(FlashS25flxCtrl_s *s25flx, SPI_HandleTypeDef *hspi, - GPIO_TypeDef *csPort, uint16_t csPin, +void flashS25flx_init(FlashS25flxCtrl_s* s25flx, SPI_HandleTypeDef* hspi, + GPIO_TypeDef* csPort, uint16_t csPin, uint32_t flashSizeBytes); -bool flashS25flx_readStart(FlashS25flxCtrl_s *s25flx, uint32_t startLoc, - uint16_t numBytes, uint8_t *pData); -bool flashS25flx_writeStart(FlashS25flxCtrl_s *s25flx, uint32_t startLoc, - uint16_t numBytes, uint8_t *data); -bool flashS25flx_eraseSectorStart(FlashS25flxCtrl_s *s25flx, +bool flashS25flx_readStart(FlashS25flxCtrl_s* s25flx, uint32_t startLoc, + uint16_t numBytes, uint8_t* pData); +bool flashS25flx_writeStart(FlashS25flxCtrl_s* s25flx, uint32_t startLoc, + uint16_t numBytes, uint8_t* data); +bool flashS25flx_eraseSectorStart(FlashS25flxCtrl_s* s25flx, uint32_t sectorNum); -bool flashS25flx_eraseChipStart(FlashS25flxCtrl_s *s25flx); +bool flashS25flx_eraseChipStart(FlashS25flxCtrl_s* s25flx); #ifdef USE_S25FLx_DMA -bool flashS25flx_isReadComplete(const FlashS25flxCtrl_s *s25flx); +bool flashS25flx_isReadComplete(const FlashS25flxCtrl_s* s25flx); #endif -bool flashS25flx_isWriteComplete(FlashS25flxCtrl_s *s25flx); -bool flashS25flx_isEraseComplete(FlashS25flxCtrl_s *s25flx); +bool flashS25flx_isWriteComplete(FlashS25flxCtrl_s* s25flx); +bool flashS25flx_isEraseComplete(FlashS25flxCtrl_s* s25flx); #ifdef __cplusplus } diff --git a/stm32_projects/device_drivers/gps.cpp b/stm32_projects/device_drivers/gps.cpp index 5999f14e..c113f68d 100644 --- a/stm32_projects/device_drivers/gps.cpp +++ b/stm32_projects/device_drivers/gps.cpp @@ -13,12 +13,12 @@ #define GPS_UART_TIMEOUT_MS 50 -char *gps_getActiveBuff(GpsCtrl_s *gps, bool swapBuff) { +char* gps_getActiveBuff(GpsCtrl_s* gps, bool swapBuff) { bool desiredBuff = swapBuff ? gps->firstBuf : !gps->firstBuf; return desiredBuff ? gps->rx_firstBuff : gps->rx_secondBuff; } -static void parseString(GpsCtrl_s *gps, char line[]) { +static void parseString(GpsCtrl_s* gps, char line[]) { switch (minmea_sentence_id(line, false)) { case MINMEA_SENTENCE_GGA: { struct minmea_sentence_gga frame1; @@ -75,11 +75,11 @@ static void parseString(GpsCtrl_s *gps, char line[]) { } } -static void gps_processData(GpsCtrl_s *gps) { +static void gps_processData(GpsCtrl_s* gps) { // Get the buffer to use // The false flips which buffer we get, as we want to parse // the inactive buffer, not the active buffer - char *buff = gps_getActiveBuff(gps, false); + char* buff = gps_getActiveBuff(gps, false); // Iterate over the entire buffer for (int i = 0; i < GPS_RX_BUF_SIZE;) { @@ -105,9 +105,9 @@ static void gps_processData(GpsCtrl_s *gps) { gps->data_available = false; } -void gps_rxEventCallback(void *gps, size_t Size) { +void gps_rxEventCallback(void* gps, size_t Size) { // GPS data received - GpsCtrl_s *pgps = static_cast(gps); + GpsCtrl_s* pgps = static_cast(gps); pgps->data_available = true; pgps->lastBufferedSize = Size; @@ -117,16 +117,15 @@ void gps_rxEventCallback(void *gps, size_t Size) { // Reconfigure the UART HAL_UARTEx_ReceiveToIdle_DMA( - pgps->gps_uart, - reinterpret_cast(gps_getActiveBuff(pgps, true)), + pgps->gps_uart, reinterpret_cast(gps_getActiveBuff(pgps, true)), GPS_RX_BUF_SIZE); } -void gps_RxCpltCallback(void *gps) { +void gps_RxCpltCallback(void* gps) { gps_rxEventCallback(gps, GPS_RX_BUF_SIZE); } -bool gps_newData(GpsCtrl_s *gps) { +bool gps_newData(GpsCtrl_s* gps) { if (gps->data_available) { gps_processData(gps); return true; @@ -134,7 +133,7 @@ bool gps_newData(GpsCtrl_s *gps) { return false; } -void gps_addUbxChecksum(uint8_t *data, int len) { +void gps_addUbxChecksum(uint8_t* data, int len) { uint8_t CK_A = 0, CK_B = 0; for (int i = 2; i < len - 2; i++) { CK_A = CK_A + data[i]; @@ -144,7 +143,7 @@ void gps_addUbxChecksum(uint8_t *data, int len) { data[len - 1] = CK_B; } -void gps_setMessagesUsed(GpsCtrl_s *gps) { +void gps_setMessagesUsed(GpsCtrl_s* gps) { // UBX->CFG->MSG uint8_t ubloxBuff[] = { @@ -240,7 +239,7 @@ void gps_setMessagesUsed(GpsCtrl_s *gps) { GPS_UART_TIMEOUT_MS); } -void gps_setRate(GpsCtrl_s *gps, uint16_t rate) { +void gps_setRate(GpsCtrl_s* gps, uint16_t rate) { // UBX->CFG->RATE uint8_t ubloxBuff[14] = { // Header @@ -273,7 +272,7 @@ void gps_setRate(GpsCtrl_s *gps, uint16_t rate) { GPS_UART_TIMEOUT_MS); } -void gps_enable4g(GpsCtrl_s *gps) { +void gps_enable4g(GpsCtrl_s* gps) { // UBX->CFG->RATE uint8_t ubloxBuff[36 + 2 + 4 + 2] = { // Header @@ -298,7 +297,7 @@ void gps_enable4g(GpsCtrl_s *gps) { GPS_UART_TIMEOUT_MS); } -void gps_init(GpsCtrl_s *gps, UART_HandleTypeDef *huart, GpsType_e type) { +void gps_init(GpsCtrl_s* gps, UART_HandleTypeDef* huart, GpsType_e type) { gps->gps_uart = huart; gps->type = type; @@ -311,7 +310,7 @@ void gps_init(GpsCtrl_s *gps, UART_HandleTypeDef *huart, GpsType_e type) { // Tell HAL to receive DMA serial data gps->firstBuf = true; HAL_UARTEx_ReceiveToIdle_DMA(gps->gps_uart, - reinterpret_cast(gps->rx_firstBuff), + reinterpret_cast(gps->rx_firstBuff), GPS_RX_BUF_SIZE); if (gps->type == GPS_TYPE_UBLOX) { diff --git a/stm32_projects/device_drivers/gps.h b/stm32_projects/device_drivers/gps.h index c24d1dff..eb016ff8 100644 --- a/stm32_projects/device_drivers/gps.h +++ b/stm32_projects/device_drivers/gps.h @@ -14,7 +14,7 @@ typedef enum { GPS_TYPE_STD = 0, GPS_TYPE_UBLOX } GpsType_e; typedef struct { - UART_HandleTypeDef *gps_uart; + UART_HandleTypeDef* gps_uart; GpsType_e type; @@ -30,21 +30,21 @@ typedef struct { bool firstBuf; } GpsCtrl_s; -void gps_init(GpsCtrl_s *gps, UART_HandleTypeDef *huart, GpsType_e type); +void gps_init(GpsCtrl_s* gps, UART_HandleTypeDef* huart, GpsType_e type); -bool gps_newData(GpsCtrl_s *gps); +bool gps_newData(GpsCtrl_s* gps); -void gps_rxEventCallback(void *gps, size_t Size); +void gps_rxEventCallback(void* gps, size_t Size); -void gps_RxCpltCallback(void *gps); +void gps_RxCpltCallback(void* gps); -void gps_setRate(GpsCtrl_s *gps, uint16_t rate); +void gps_setRate(GpsCtrl_s* gps, uint16_t rate); -void gps_setMessagesUsed(GpsCtrl_s *gps); +void gps_setMessagesUsed(GpsCtrl_s* gps); -void gps_enable4g(GpsCtrl_s *gps); +void gps_enable4g(GpsCtrl_s* gps); -void gps_addUbxChecksum(uint8_t *data, int len); +void gps_addUbxChecksum(uint8_t* data, int len); #endif diff --git a/stm32_projects/device_drivers/hal_callbacks.cpp b/stm32_projects/device_drivers/hal_callbacks.cpp index 87c9789a..0c3e63f8 100644 --- a/stm32_projects/device_drivers/hal_callbacks.cpp +++ b/stm32_projects/device_drivers/hal_callbacks.cpp @@ -14,19 +14,19 @@ #ifdef HAL_SPI_MODULE_ENABLED typedef struct { - SPI_HandleTypeDef *hspi; - void (*txCallback)(void *); - void (*txRxCallback)(void *); - void *txCallbackUserData; - void *txRxCallbackUserData; + SPI_HandleTypeDef* hspi; + void (*txCallback)(void*); + void (*txRxCallback)(void*); + void* txCallbackUserData; + void* txRxCallbackUserData; } SpiCallbackProperty_s; static SpiCallbackProperty_s spiCallbacks[MAX_SPI_HANDLES]; static int numSpiCallbacksRegistered = 0; -void halCallbacks_registerSpiTxCpltCallback(SPI_HandleTypeDef *hspi, - void (*callback)(void *), - void *userData) { +void halCallbacks_registerSpiTxCpltCallback(SPI_HandleTypeDef* hspi, + void (*callback)(void*), + void* userData) { // See if handle already has callback registered to it for (int i = 0; i < numSpiCallbacksRegistered; i++) { if (spiCallbacks[i].hspi == hspi) { @@ -43,9 +43,9 @@ void halCallbacks_registerSpiTxCpltCallback(SPI_HandleTypeDef *hspi, numSpiCallbacksRegistered++; } -void halCallbacks_registerSpiTxRxCpltCallback(SPI_HandleTypeDef *hspi, - void (*callback)(void *), - void *userData) { +void halCallbacks_registerSpiTxRxCpltCallback(SPI_HandleTypeDef* hspi, + void (*callback)(void*), + void* userData) { // See if handle already has callback registered to it for (int i = 0; i < numSpiCallbacksRegistered; i++) { if (spiCallbacks[i].hspi == hspi) { @@ -63,7 +63,7 @@ void halCallbacks_registerSpiTxRxCpltCallback(SPI_HandleTypeDef *hspi, } // The actuall callback functions -void HAL_SPI_TxCpltCallback(SPI_HandleTypeDef *hspi) { +void HAL_SPI_TxCpltCallback(SPI_HandleTypeDef* hspi) { for (int i = 0; i < numSpiCallbacksRegistered; i++) { if (spiCallbacks[i].hspi == hspi) { if (spiCallbacks[i].txCallback != NULL) { @@ -74,7 +74,7 @@ void HAL_SPI_TxCpltCallback(SPI_HandleTypeDef *hspi) { } } -void HAL_SPI_TxRxCpltCallback(SPI_HandleTypeDef *hspi) { +void HAL_SPI_TxRxCpltCallback(SPI_HandleTypeDef* hspi) { for (int i = 0; i < numSpiCallbacksRegistered; i++) { if (spiCallbacks[i].hspi == hspi) { if (spiCallbacks[i].txRxCallback != NULL) { @@ -88,21 +88,21 @@ void HAL_SPI_TxRxCpltCallback(SPI_HandleTypeDef *hspi) { #ifdef HAL_UART_MODULE_ENABLED typedef struct { - UART_HandleTypeDef *huart; - void (*rxHalfCallback)(void *); - void (*rxCallback)(void *); - void (*rxIdleCallback)(void *, size_t); // user data, size - void *rxHalfCallbackUserData; - void *rxCallbackUserData; - void *rxIdleCallbackUserData; + UART_HandleTypeDef* huart; + void (*rxHalfCallback)(void*); + void (*rxCallback)(void*); + void (*rxIdleCallback)(void*, size_t); // user data, size + void* rxHalfCallbackUserData; + void* rxCallbackUserData; + void* rxIdleCallbackUserData; } UartCallbackProperty_s; static UartCallbackProperty_s uartCallbacks[MAX_UART_HANDLES]; static int numUartCallbacksRegistered = 0; -void halCallbacks_registerUartRxHalfCpltCallback(UART_HandleTypeDef *huart, - void (*callback)(void *), - void *userData) { +void halCallbacks_registerUartRxHalfCpltCallback(UART_HandleTypeDef* huart, + void (*callback)(void*), + void* userData) { // See if handle already has callback registered to it for (int i = 0; i < numUartCallbacksRegistered; i++) { if (uartCallbacks[i].huart == huart) { @@ -119,9 +119,9 @@ void halCallbacks_registerUartRxHalfCpltCallback(UART_HandleTypeDef *huart, numUartCallbacksRegistered++; } -void halCallbacks_registerUartRxCpltCallback(UART_HandleTypeDef *huart, - void (*callback)(void *), - void *userData) { +void halCallbacks_registerUartRxCpltCallback(UART_HandleTypeDef* huart, + void (*callback)(void*), + void* userData) { // See if handle already has callback registered to it for (int i = 0; i < numUartCallbacksRegistered; i++) { if (uartCallbacks[i].huart == huart) { @@ -138,7 +138,7 @@ void halCallbacks_registerUartRxCpltCallback(UART_HandleTypeDef *huart, numUartCallbacksRegistered++; } -void HAL_UART_RxHalfCpltCallback(UART_HandleTypeDef *huart) { +void HAL_UART_RxHalfCpltCallback(UART_HandleTypeDef* huart) { for (int i = 0; i < numUartCallbacksRegistered; i++) { if (uartCallbacks[i].huart == huart) { if (uartCallbacks[i].rxHalfCallback != NULL) { @@ -150,7 +150,7 @@ void HAL_UART_RxHalfCpltCallback(UART_HandleTypeDef *huart) { } } -void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) { +void HAL_UART_RxCpltCallback(UART_HandleTypeDef* huart) { for (int i = 0; i < numUartCallbacksRegistered; i++) { if (uartCallbacks[i].huart == huart) { if (uartCallbacks[i].rxCallback != NULL) { @@ -161,9 +161,9 @@ void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) { } } -void halCallbacks_registerUartRxIdleCallback(UART_HandleTypeDef *huart, - void (*callback)(void *, size_t), - void *userData) { +void halCallbacks_registerUartRxIdleCallback(UART_HandleTypeDef* huart, + void (*callback)(void*, size_t), + void* userData) { // See if handle already has callback registered to it for (int i = 0; i < numUartCallbacksRegistered; i++) { if (uartCallbacks[i].huart == huart) { @@ -180,7 +180,7 @@ void halCallbacks_registerUartRxIdleCallback(UART_HandleTypeDef *huart, numUartCallbacksRegistered++; } -void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t size) { +void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef* huart, uint16_t size) { for (int i = 0; i < numUartCallbacksRegistered; i++) { if (uartCallbacks[i].huart == huart) { if (uartCallbacks[i].rxIdleCallback != NULL) { @@ -196,17 +196,17 @@ void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t size) { #ifdef HAL_ADC_MODULE_ENABLED typedef struct { - ADC_HandleTypeDef *hadc; - void (*convCallback)(void *); - void *convCallbackUserData; + ADC_HandleTypeDef* hadc; + void (*convCallback)(void*); + void* convCallbackUserData; } AdcCallbackProperty_s; static AdcCallbackProperty_s adcCallbacks[MAX_ADC_HANDLES]; static int numAdcCallbacksRegistered = 0; -void halCallbacks_registerAdcConvCpltCallback(ADC_HandleTypeDef *hadc, - void (*callback)(void *), - void *userData) { +void halCallbacks_registerAdcConvCpltCallback(ADC_HandleTypeDef* hadc, + void (*callback)(void*), + void* userData) { // See if handle already has callback registered to it for (int i = 0; i < numAdcCallbacksRegistered; i++) { if (adcCallbacks[i].hadc == hadc) { @@ -223,7 +223,7 @@ void halCallbacks_registerAdcConvCpltCallback(ADC_HandleTypeDef *hadc, numAdcCallbacksRegistered++; } -void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef *hadc) { +void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc) { for (int i = 0; i < numAdcCallbacksRegistered; i++) { if (adcCallbacks[i].hadc == hadc) { if (adcCallbacks[i].convCallback != NULL) { @@ -239,16 +239,16 @@ void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef *hadc) { #ifdef HAL_EXTI_MODULE_ENABLED typedef struct { uint16_t extInterruptGpioPin; - void (*extInterruptCallback)(void *); - void *extInterruptCallbackUserData; + void (*extInterruptCallback)(void*); + void* extInterruptCallbackUserData; } ExtInterruptCallbackProperty_s; static ExtInterruptCallbackProperty_s extInterruptCallbacks[MAX_EXTI_HANDLES]; static int numExtInterruptCallbacksRegistered = 0; void halCallbacks_registerExtInterruptCallback(uint16_t gpioPin, - void (*callback)(void *), - void *userData) { + void (*callback)(void*), + void* userData) { // See if handle already has callback registered to it for (int i = 0; i < numExtInterruptCallbacksRegistered; i++) { if (extInterruptCallbacks[i].extInterruptGpioPin == gpioPin) { @@ -284,18 +284,18 @@ void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin) { #ifdef HAL_TIM_MODULE_ENABLED typedef struct { - TIM_HandleTypeDef *htim; - void (*irqCallback)(void *); - void *irqCallbackUserData; + TIM_HandleTypeDef* htim; + void (*irqCallback)(void*); + void* irqCallbackUserData; } TimPeriodElapsedCallbackProperty_s; static TimPeriodElapsedCallbackProperty_s timPeriodElapsedCallbacks[MAX_TIM_HANDLES]; static int numTimPeriodElapsedCallbacksRegistered = 0; -void halCallbacks_registerTimPeriodElapsedCallback(TIM_HandleTypeDef *htim, - void (*callback)(void *), - void *userData) { +void halCallbacks_registerTimPeriodElapsedCallback(TIM_HandleTypeDef* htim, + void (*callback)(void*), + void* userData) { for (int i = 0; i < numTimPeriodElapsedCallbacksRegistered; i++) { if (timPeriodElapsedCallbacks[i].htim == htim) { timPeriodElapsedCallbacks[i].irqCallback = callback; @@ -312,7 +312,7 @@ void halCallbacks_registerTimPeriodElapsedCallback(TIM_HandleTypeDef *htim, numTimPeriodElapsedCallbacksRegistered++; } -void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim) { +void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef* htim) { for (int i = 0; i < numTimPeriodElapsedCallbacksRegistered; i++) { if (timPeriodElapsedCallbacks[i].htim == htim) { if (timPeriodElapsedCallbacks[i].irqCallback != NULL) { diff --git a/stm32_projects/device_drivers/hal_callbacks.h b/stm32_projects/device_drivers/hal_callbacks.h index 1e22b65b..a339397d 100644 --- a/stm32_projects/device_drivers/hal_callbacks.h +++ b/stm32_projects/device_drivers/hal_callbacks.h @@ -8,42 +8,42 @@ #include "board_config_common.h" #ifdef HAL_SPI_MODULE_ENABLED -void halCallbacks_registerSpiTxCpltCallback(SPI_HandleTypeDef *hspi, - void (*callback)(void *), - void *userData); -void halCallbacks_registerSpiTxRxCpltCallback(SPI_HandleTypeDef *hspi, - void (*callback)(void *), - void *userData); +void halCallbacks_registerSpiTxCpltCallback(SPI_HandleTypeDef* hspi, + void (*callback)(void*), + void* userData); +void halCallbacks_registerSpiTxRxCpltCallback(SPI_HandleTypeDef* hspi, + void (*callback)(void*), + void* userData); #endif // HAL_SPI_MODULE_ENABLED #ifdef HAL_ADC_MODULE_ENABLED -void halCallbacks_registerAdcConvCpltCallback(ADC_HandleTypeDef *hadc, - void (*callback)(void *), - void *userData); +void halCallbacks_registerAdcConvCpltCallback(ADC_HandleTypeDef* hadc, + void (*callback)(void*), + void* userData); #endif // HAL_ADC_MODULE_ENABLED #ifdef HAL_UART_MODULE_ENABLED -void halCallbacks_registerUartRxHalfCpltCallback(UART_HandleTypeDef *huart, - void (*callback)(void *), - void *userData); -void halCallbacks_registerUartRxCpltCallback(UART_HandleTypeDef *huart, - void (*callback)(void *), - void *userData); -void halCallbacks_registerUartRxIdleCallback(UART_HandleTypeDef *huart, - void (*callback)(void *, size_t), - void *userData); +void halCallbacks_registerUartRxHalfCpltCallback(UART_HandleTypeDef* huart, + void (*callback)(void*), + void* userData); +void halCallbacks_registerUartRxCpltCallback(UART_HandleTypeDef* huart, + void (*callback)(void*), + void* userData); +void halCallbacks_registerUartRxIdleCallback(UART_HandleTypeDef* huart, + void (*callback)(void*, size_t), + void* userData); #endif // HAL_UART_MODULE_ENABLED #ifdef HAL_EXTI_MODULE_ENABLED void halCallbacks_registerExtInterruptCallback(uint16_t gpioPin, - void (*callback)(void *), - void *userData); + void (*callback)(void*), + void* userData); #endif // HAL_EXTI_MODULE_ENABLED #ifdef HAL_TIM_MODULE_ENABLED -void halCallbacks_registerTimPeriodElapsedCallback(TIM_HandleTypeDef *htim, - void (*callback)(void *), - void *userData); +void halCallbacks_registerTimPeriodElapsedCallback(TIM_HandleTypeDef* htim, + void (*callback)(void*), + void* userData); #endif // HAL_TIM_MODULE_ENABLED #endif // STM32_PROJECTS_DEVICE_DRIVERS_HAL_CALLBACKS_H_ diff --git a/stm32_projects/device_drivers/imu_icm20600.cpp b/stm32_projects/device_drivers/imu_icm20600.cpp index 9bcc2615..cda877e2 100644 --- a/stm32_projects/device_drivers/imu_icm20600.cpp +++ b/stm32_projects/device_drivers/imu_icm20600.cpp @@ -47,7 +47,7 @@ static float getGyroSensitivity(ImuICM20600GyroFullscale_e scale) { return f; } -static void setGyroFullscale(ImuICM20600Ctrl_s *sensor, +static void setGyroFullscale(ImuICM20600Ctrl_s* sensor, ImuICM20600GyroFullscale_e range) { spi_writeRegister(&sensor->spi, 0x1B, 0x00 | range << 3); sensor->gyroSensitivity = getGyroSensitivity(range); @@ -73,20 +73,20 @@ static float getAccelSensitivity(ImuICM20600AccelFullscale_e scale) { return f; } -static void setAccelFullscale(ImuICM20600Ctrl_s *sensor, +static void setAccelFullscale(ImuICM20600Ctrl_s* sensor, ImuICM20600AccelFullscale_e range) { spi_writeRegister(&sensor->spi, 0x1C, 0x00 | range << 3); sensor->accelSensitivity = getAccelSensitivity(range); } -static bool isConnected(ImuICM20600Ctrl_s *sensor) { +static bool isConnected(ImuICM20600Ctrl_s* sensor) { uint8_t id = spi_readRegister(&sensor->spi, REG_WHO_AM_I); return (id == WHOAMI) || (id == 0xAF); // icm 20608-g special case // page 21, // https://invensense.tdk.com/wp-content/uploads/2015/03/RM-000030-v1.0.pdf } -bool icm20600_init(ImuICM20600Ctrl_s *sensor, +bool icm20600_init(ImuICM20600Ctrl_s* sensor, ImuICM20600AccelFullscale_e accelFullscale, ImuICM20600GyroFullscale_e gyroFullscale) { HAL_GPIO_WritePin(sensor->spi.port, sensor->spi.pin, GPIO_PIN_SET); @@ -110,7 +110,7 @@ bool icm20600_init(ImuICM20600Ctrl_s *sensor, return true; } -void icm20600_getData(ImuICM20600Ctrl_s *sensor) { +void icm20600_getData(ImuICM20600Ctrl_s* sensor) { // Allocate a buffer uint8_t txBuf[ACCEL_OUT_SIZE + 1] = {0}; uint8_t rxBuf[ACCEL_OUT_SIZE + 1] = {0}; diff --git a/stm32_projects/device_drivers/imu_icm20600.h b/stm32_projects/device_drivers/imu_icm20600.h index 08120c1a..58ff7bca 100644 --- a/stm32_projects/device_drivers/imu_icm20600.h +++ b/stm32_projects/device_drivers/imu_icm20600.h @@ -43,10 +43,10 @@ typedef struct ICM20600Ctrl_s { double tVal; } ImuICM20600Ctrl_s; -bool icm20600_init(ImuICM20600Ctrl_s *sensor, +bool icm20600_init(ImuICM20600Ctrl_s* sensor, ImuICM20600AccelFullscale_e accelFullscale, ImuICM20600GyroFullscale_e gyroFullscale); -void icm20600_getData(ImuICM20600Ctrl_s *sensor); +void icm20600_getData(ImuICM20600Ctrl_s* sensor); #ifdef __cplusplus } diff --git a/stm32_projects/device_drivers/imu_iis2mdc.cpp b/stm32_projects/device_drivers/imu_iis2mdc.cpp index 8ede0f81..7374ab3e 100644 --- a/stm32_projects/device_drivers/imu_iis2mdc.cpp +++ b/stm32_projects/device_drivers/imu_iis2mdc.cpp @@ -6,8 +6,8 @@ #if HAS_DEV(IMU_IIS2MDC) -bool iis2mdc_init(ImuIIS2MDCCtrl_s *sensor) { return true; } +bool iis2mdc_init(ImuIIS2MDCCtrl_s* sensor) { return true; } -void iis2mdc_getData(ImuIIS2MDCCtrl_s *sensor) {} +void iis2mdc_getData(ImuIIS2MDCCtrl_s* sensor) {} #endif // HAS_DEV(IMU_LSM9DS1) diff --git a/stm32_projects/device_drivers/imu_lsm9ds1.cpp b/stm32_projects/device_drivers/imu_lsm9ds1.cpp index 8d9236e3..c98da177 100644 --- a/stm32_projects/device_drivers/imu_lsm9ds1.cpp +++ b/stm32_projects/device_drivers/imu_lsm9ds1.cpp @@ -8,17 +8,17 @@ #define LSM9DS1_SPI_REG_MASK (1 << 7) -static uint8_t agWhoAmI(Lsm9ds1AgCtrl_s *sensor) { +static uint8_t agWhoAmI(Lsm9ds1AgCtrl_s* sensor) { return spi_readRegister(&sensor->lsm9ds1Spi, LSM9DS1_SPI_REG_MASK | REG_WHO_AM_I_AG); } -static uint8_t mWhoAmI(Lsm9ds1MCtrl_s *sensor) { +static uint8_t mWhoAmI(Lsm9ds1MCtrl_s* sensor) { return spi_readRegister(&sensor->lsm9ds1Spi, LSM9DS1_SPI_REG_MASK | REG_WHO_AM_I_M); } -static void lsm9ds1_getDataRaw(ImuLsm9ds1Ctrl_s *sensor) { +static void lsm9ds1_getDataRaw(ImuLsm9ds1Ctrl_s* sensor) { // Takes x, y, and z axis readings uint8_t x_l_xl = spi_readRegister(&sensor->ag.lsm9ds1Spi, LSM9DS1_SPI_REG_MASK | OUT_X_L_XL); @@ -80,7 +80,7 @@ static void lsm9ds1_getDataRaw(ImuLsm9ds1Ctrl_s *sensor) { sensor->ag.tRawVal = static_cast((t_h << 8) | t_l); } -void lsm9ds1_getData(ImuLsm9ds1Ctrl_s *sensor) { +void lsm9ds1_getData(ImuLsm9ds1Ctrl_s* sensor) { lsm9ds1_getDataRaw(sensor); sensor->agData.accelRealMps2.x = sensor->ag.aRes * sensor->agData.accelRaw.x; sensor->agData.accelRealMps2.y = sensor->ag.aRes * sensor->agData.accelRaw.y; @@ -98,7 +98,7 @@ void lsm9ds1_getData(ImuLsm9ds1Ctrl_s *sensor) { sensor->mData.realGauss.z = sensor->m.mRes * sensor->mData.raw.z; } -static void lsm9ds1_calcRes(ImuLsm9ds1Ctrl_s *sensor) { +static void lsm9ds1_calcRes(ImuLsm9ds1Ctrl_s* sensor) { switch (sensor->ag.aFs) { case 0 << 3: sensor->ag.aRes = SENSITIVITY_ACCELEROMETER_2; @@ -150,7 +150,7 @@ static void lsm9ds1_calcRes(ImuLsm9ds1Ctrl_s *sensor) { } } -bool lsm9ds1_init(ImuLsm9ds1Ctrl_s *sensor) { +bool lsm9ds1_init(ImuLsm9ds1Ctrl_s* sensor) { // Pull CS High HAL_GPIO_WritePin(sensor->ag.lsm9ds1Spi.port, sensor->ag.lsm9ds1Spi.pin, GPIO_PIN_SET); diff --git a/stm32_projects/device_drivers/imu_lsm9ds1.h b/stm32_projects/device_drivers/imu_lsm9ds1.h index 9311e9ff..7f8a7456 100644 --- a/stm32_projects/device_drivers/imu_lsm9ds1.h +++ b/stm32_projects/device_drivers/imu_lsm9ds1.h @@ -168,8 +168,8 @@ typedef struct LSM9DS1Ctrl_s { Lsm9ds1MCtrl_s m; } ImuLsm9ds1Ctrl_s; -bool lsm9ds1_init(ImuLsm9ds1Ctrl_s *sensor); -void lsm9ds1_getData(ImuLsm9ds1Ctrl_s *sensor); +bool lsm9ds1_init(ImuLsm9ds1Ctrl_s* sensor); +void lsm9ds1_getData(ImuLsm9ds1Ctrl_s* sensor); #ifdef __cplusplus } diff --git a/stm32_projects/device_drivers/internal_flash.cpp b/stm32_projects/device_drivers/internal_flash.cpp index 60048280..db9d8a35 100644 --- a/stm32_projects/device_drivers/internal_flash.cpp +++ b/stm32_projects/device_drivers/internal_flash.cpp @@ -33,8 +33,8 @@ HAL_StatusTypeDef Internal_Flash_Program(uint32_t FlashAddress, #endif // STM32H743XX #ifdef STM32H750xx HAL_StatusTypeDef status; - __IO uint32_t *dest_addr = (__IO uint32_t *)FlashAddress; - __IO uint32_t *src_addr = (__IO uint32_t *)DataAddress; + __IO uint32_t* dest_addr = (__IO uint32_t*)FlashAddress; + __IO uint32_t* src_addr = (__IO uint32_t*)DataAddress; uint32_t bank; uint8_t row_index = FLASH_NB_32BITWORD_IN_FLASHWORD; /* Check the parameters */ @@ -91,7 +91,7 @@ HAL_StatusTypeDef Internal_Flash_Program(uint32_t FlashAddress, * @param data - Array of uint8_t to write * @param numBytes - Number of bytes to be written from data */ -bool internalFlash_write(uint32_t RelFlashAddress, uint8_t *data, +bool internalFlash_write(uint32_t RelFlashAddress, uint8_t* data, uint32_t numBytes) { if (RelFlashAddress % FLASH_BYTE_INCREMENT || RelFlashAddress > @@ -137,7 +137,7 @@ bool internalFlash_write(uint32_t RelFlashAddress, uint8_t *data, * @param pData - Array of uint8_t to read into * @param numBytes - Number of bytes to be read from flash */ -bool internalFlash_read(uint32_t RelFlashAddress, uint8_t *pData, +bool internalFlash_read(uint32_t RelFlashAddress, uint8_t* pData, uint32_t numBytes) { if (RelFlashAddress > MAX_FLASH_ADDRESS) { return false; @@ -145,7 +145,7 @@ bool internalFlash_read(uint32_t RelFlashAddress, uint8_t *pData, uint32_t readAddress = INTERNAL_FLASH_START + RelFlashAddress; - memcpy(pData, reinterpret_cast(readAddress), numBytes); + memcpy(pData, reinterpret_cast(readAddress), numBytes); return true; } diff --git a/stm32_projects/device_drivers/internal_flash.h b/stm32_projects/device_drivers/internal_flash.h index 6bf81f7c..eb0bf8de 100644 --- a/stm32_projects/device_drivers/internal_flash.h +++ b/stm32_projects/device_drivers/internal_flash.h @@ -25,10 +25,10 @@ extern "C" { #define MAX_FLASH_ADDRESS INTERNAL_FLASH_END - INTERNAL_FLASH_START -bool internalFlash_write(uint32_t RelFlashAddress, uint8_t *data, +bool internalFlash_write(uint32_t RelFlashAddress, uint8_t* data, uint32_t numBytes); -bool internalFlash_read(uint32_t RelFlashAddress, uint8_t *pData, +bool internalFlash_read(uint32_t RelFlashAddress, uint8_t* pData, uint32_t numBytes); #ifdef __cplusplus diff --git a/stm32_projects/device_drivers/led.cpp b/stm32_projects/device_drivers/led.cpp index 9a67a53b..0df1eb8a 100644 --- a/stm32_projects/device_drivers/led.cpp +++ b/stm32_projects/device_drivers/led.cpp @@ -2,19 +2,19 @@ #if HAS_DEV(LED_DIGITAL) -void led_init(LedCtrl_s *led) { +void led_init(LedCtrl_s* led) { if (led->port) { HAL_GPIO_WritePin(led->port, led->pin, GPIO_PIN_RESET); } } -void led_set(LedCtrl_s *led, bool set) { +void led_set(LedCtrl_s* led, bool set) { if (led->port) { HAL_GPIO_WritePin(led->port, led->pin, set ? GPIO_PIN_SET : GPIO_PIN_RESET); } } -void led_toggle(LedCtrl_s *led) { +void led_toggle(LedCtrl_s* led) { if (led->port) { HAL_GPIO_TogglePin(led->port, led->pin); } diff --git a/stm32_projects/device_drivers/led.h b/stm32_projects/device_drivers/led.h index 8e31bdc5..c6abcb54 100644 --- a/stm32_projects/device_drivers/led.h +++ b/stm32_projects/device_drivers/led.h @@ -10,15 +10,15 @@ extern "C" { #endif typedef struct { - GPIO_TypeDef *port; + GPIO_TypeDef* port; uint16_t pin; } LedCtrl_s; -void led_init(LedCtrl_s *led); +void led_init(LedCtrl_s* led); -void led_set(LedCtrl_s *led, bool set); +void led_set(LedCtrl_s* led, bool set); -void led_toggle(LedCtrl_s *led); +void led_toggle(LedCtrl_s* led); #ifdef __cplusplus } diff --git a/stm32_projects/device_drivers/line_cutter_ble.cpp b/stm32_projects/device_drivers/line_cutter_ble.cpp index f9d9aa6e..168bce20 100644 --- a/stm32_projects/device_drivers/line_cutter_ble.cpp +++ b/stm32_projects/device_drivers/line_cutter_ble.cpp @@ -19,16 +19,16 @@ static uint8_t tempBuffer[PACKET_TEMP_BUFFER_SIZE]; #define MAX_PACKETS_PER_TICK 10 // Things we can ask the line cutter. note that strlen doesn't include the null -static const char *REQ_DATA_CMD = "!fcbdata\n\0"; -static const char *REQ_CFG_CMD = "!fcbcfg\n\0"; -static const char *REQ_CUT_1_CMD = "!cut 1\n\0"; -static const char *REQ_CUT_2_CMD = "!cut 2\n\0"; -static const char *REQ_RESET_CMD = "!reset\n\0"; +static const char* REQ_DATA_CMD = "!fcbdata\n\0"; +static const char* REQ_CFG_CMD = "!fcbcfg\n\0"; +static const char* REQ_CUT_1_CMD = "!cut 1\n\0"; +static const char* REQ_CUT_2_CMD = "!cut 2\n\0"; +static const char* REQ_RESET_CMD = "!reset\n\0"; static LineCutterForwardStringCb_t stringCallback = NULL; -bool lineCutterBle_sendString(LineCutterBleCtrl_t *lineCutter, - const char *cmd) { +bool lineCutterBle_sendString(LineCutterBleCtrl_t* lineCutter, + const char* cmd) { // We used to have more checks here, but IMO we really just wanna send it // regardless bool ret = lineCutter->bleChip->sendRequest( @@ -38,7 +38,7 @@ bool lineCutterBle_sendString(LineCutterBleCtrl_t *lineCutter, } #define BT_CMD_DEF(NAME, CMD) \ - bool lineCutterBle_##NAME(LineCutterBleCtrl_t *lineCutter) { \ + bool lineCutterBle_##NAME(LineCutterBleCtrl_t* lineCutter) { \ return lineCutterBle_sendString(lineCutter, CMD); \ } @@ -56,7 +56,7 @@ BT_CMD_DEF(reset, REQ_RESET_CMD) // but it doesn't hurt #define LC_VARS_INTERVAL_MS 10000 + 124 -void lineCutterBle_tick(LineCutterBleCtrl_t *lineCutter) { +void lineCutterBle_tick(LineCutterBleCtrl_t* lineCutter) { size_t dequeuedLen; uint8_t packetCount = 0; do { @@ -88,8 +88,8 @@ void lineCutterBle_tick(LineCutterBleCtrl_t *lineCutter) { } } -void lineCutterBle_parse(LineCutterBleCtrl_t *lineCutter, uint16_t len, - uint8_t *arr) { +void lineCutterBle_parse(LineCutterBleCtrl_t* lineCutter, uint16_t len, + uint8_t* arr) { // If the first character is an invalid ASCII code, parse as a binary message if (len && arr[0] == 128) { // Skip first non-valid byte indicating byte-packed data @@ -103,11 +103,11 @@ void lineCutterBle_parse(LineCutterBleCtrl_t *lineCutter, uint16_t len, lineCutter->lastAckTimestamp = HAL_GetTick(); success = true; } else if (len == sizeof(LineCutterData_s)) { - lineCutter->lastData = *((LineCutterData_s *)arr); + lineCutter->lastData = *((LineCutterData_s*)arr); lineCutter->lastDataTimestamp = HAL_GetTick(); success = true; } else if (len == sizeof(LineCutterFlightVars_s)) { - lineCutter->flightVars = *((LineCutterFlightVars_s *)arr); + lineCutter->flightVars = *((LineCutterFlightVars_s*)arr); lineCutter->lastFlightVarsTimestamp = HAL_GetTick(); success = true; } @@ -116,12 +116,12 @@ void lineCutterBle_parse(LineCutterBleCtrl_t *lineCutter, uint16_t len, } else { // Otherwise, we got a string -- we should just send it to the callback if (stringCallback) { - stringCallback((uint8_t *)arr, len); + stringCallback((uint8_t*)arr, len); } } } -void lineCutterBle_init(LineCutterBleCtrl_t *lineCutter, BleChip_s *bleChip, +void lineCutterBle_init(LineCutterBleCtrl_t* lineCutter, BleChip_s* bleChip, uint8_t address) { lineCutter->bleChip = bleChip; lineCutter->address = address; @@ -132,11 +132,11 @@ void lineCutterBle_init(LineCutterBleCtrl_t *lineCutter, BleChip_s *bleChip, &lineCutter->buffer); } -bool lineCutterBle_isConnected(LineCutterBleCtrl_t *ctrl) { +bool lineCutterBle_isConnected(LineCutterBleCtrl_t* ctrl) { return ctrl->bleChip->isAddressConnected(ctrl->bleChip, ctrl->address); } -bool lineCutterBle_isAwaitingReply(LineCutterBleCtrl_t *ctrl) { +bool lineCutterBle_isAwaitingReply(LineCutterBleCtrl_t* ctrl) { return ctrl->lastRequestTimestamp > 0; } diff --git a/stm32_projects/device_drivers/line_cutter_ble.h b/stm32_projects/device_drivers/line_cutter_ble.h index afd44719..3359ccf2 100644 --- a/stm32_projects/device_drivers/line_cutter_ble.h +++ b/stm32_projects/device_drivers/line_cutter_ble.h @@ -20,11 +20,11 @@ extern "C" { #define LINE_CUTTER_CB_SIZE 512 -typedef void (*LineCutterForwardStringCb_t)(uint8_t *, size_t); +typedef void (*LineCutterForwardStringCb_t)(uint8_t*, size_t); typedef struct { // Reference to the BLE chip driver - BleChip_s *bleChip; + BleChip_s* bleChip; // The address assigned by the FCB bluetooth chip uint8_t address; @@ -47,39 +47,39 @@ typedef struct { uint32_t lastRequestTimestamp; } LineCutterBleCtrl_t; -void lineCutterBle_init(LineCutterBleCtrl_t *lineCutter, BleChip_s *bleChip, +void lineCutterBle_init(LineCutterBleCtrl_t* lineCutter, BleChip_s* bleChip, uint8_t address); -void lineCutterBle_parse(LineCutterBleCtrl_t *lineCutter, uint16_t len, - uint8_t *arr); -void lineCutterBle_tick(LineCutterBleCtrl_t *lineCutter); +void lineCutterBle_parse(LineCutterBleCtrl_t* lineCutter, uint16_t len, + uint8_t* arr); +void lineCutterBle_tick(LineCutterBleCtrl_t* lineCutter); // Send a string to the line cutter over Bluetooth -bool lineCutterBle_sendString(LineCutterBleCtrl_t *ctrl, const char *cmd); +bool lineCutterBle_sendString(LineCutterBleCtrl_t* ctrl, const char* cmd); // Send a request for the latest data packet from a line cutter at a specified // clientAddress -bool lineCutterBle_requestData(LineCutterBleCtrl_t *ctrl); +bool lineCutterBle_requestData(LineCutterBleCtrl_t* ctrl); // Request the line cutter variables struct -bool lineCutterBle_requestConfig(LineCutterBleCtrl_t *ctrl); +bool lineCutterBle_requestConfig(LineCutterBleCtrl_t* ctrl); // Send a request for the line cutter at clientAddress to cut the first line -bool lineCutterBle_cut1(LineCutterBleCtrl_t *ctrl); +bool lineCutterBle_cut1(LineCutterBleCtrl_t* ctrl); // Send a request for the line cutter at clientAddress to cut the second line -bool lineCutterBle_cut2(LineCutterBleCtrl_t *ctrl); +bool lineCutterBle_cut2(LineCutterBleCtrl_t* ctrl); // Send a request for the line cutter at clientAddress reset itself. Note that // this may change the address of the other line cutter if the first line cutter // disconnects as line cutter 1 is the first connected, cutter 2 is second, etc // (see the fcb ble code for details) -bool lineCutterBle_reset(LineCutterBleCtrl_t *ctrl); +bool lineCutterBle_reset(LineCutterBleCtrl_t* ctrl); // Returns if this line cutter is connected -bool lineCutterBle_isConnected(LineCutterBleCtrl_t *ctrl); +bool lineCutterBle_isConnected(LineCutterBleCtrl_t* ctrl); // Returns if this line cutter is awaiting a reply to a command -bool lineCutterBle_isAwaitingReply(LineCutterBleCtrl_t *ctrl); +bool lineCutterBle_isAwaitingReply(LineCutterBleCtrl_t* ctrl); // Registers a function to call to forward strings to void lineCutterBle_registerForwardStringCb(LineCutterForwardStringCb_t cb); diff --git a/stm32_projects/device_drivers/mag_iis2mdc.cpp b/stm32_projects/device_drivers/mag_iis2mdc.cpp index 99930347..8795a64a 100644 --- a/stm32_projects/device_drivers/mag_iis2mdc.cpp +++ b/stm32_projects/device_drivers/mag_iis2mdc.cpp @@ -8,7 +8,7 @@ #if HAS_DEV(MAG_IIS2MDC) -static uint8_t readByte(ImuIIS2MDCCtrl_s *sensor, uint8_t addr) { +static uint8_t readByte(ImuIIS2MDCCtrl_s* sensor, uint8_t addr) { // HAL_I2C_Master_Transmit(sensor->hi2c, sensor->address, &addr, 1, // HAL_MAX_DELAY); uint8_t ret; @@ -19,7 +19,7 @@ static uint8_t readByte(ImuIIS2MDCCtrl_s *sensor, uint8_t addr) { return ret; } -static void readArray(ImuIIS2MDCCtrl_s *sensor, uint8_t addr, uint8_t *pData, +static void readArray(ImuIIS2MDCCtrl_s* sensor, uint8_t addr, uint8_t* pData, uint8_t len) { // HAL_I2C_Master_Transmit(sensor->hi2c, sensor->address, &addr, 1, // HAL_MAX_DELAY); HAL_I2C_Master_Receive(sensor->hi2c, sensor->address, @@ -29,7 +29,7 @@ static void readArray(ImuIIS2MDCCtrl_s *sensor, uint8_t addr, uint8_t *pData, HAL_MAX_DELAY); } -static void writeByte(ImuIIS2MDCCtrl_s *sensor, uint8_t addr, uint8_t val) { +static void writeByte(ImuIIS2MDCCtrl_s* sensor, uint8_t addr, uint8_t val) { // uint8_t pData[2] = {addr, val}; // HAL_I2C_Master_Transmit(sensor->hi2c, sensor->address, pData, // sizeof(pData), HAL_MAX_DELAY); @@ -48,7 +48,7 @@ static void writeByte(ImuIIS2MDCCtrl_s *sensor, uint8_t addr, uint8_t val) { #include -bool iis2mdc_init(ImuIIS2MDCCtrl_s *sensor, uint8_t address7bit) { +bool iis2mdc_init(ImuIIS2MDCCtrl_s* sensor, uint8_t address7bit) { for (int i = 1; i < 128; i++) { uint8_t ret = HAL_I2C_IsDeviceReady(sensor->hi2c, (uint16_t)(i << 1), 3, 5); if (ret != HAL_OK) /* No ACK Received At That Address */ { @@ -73,7 +73,7 @@ bool iis2mdc_init(ImuIIS2MDCCtrl_s *sensor, uint8_t address7bit) { return true; } -void iis2mdc_getData(ImuIIS2MDCCtrl_s *sensor) { +void iis2mdc_getData(ImuIIS2MDCCtrl_s* sensor) { // Currently still polling! TODO we can set up a latching drdy interrupt? uint8_t raw[6]; readArray(sensor, OUTX_L_REG, raw, sizeof(raw)); diff --git a/stm32_projects/device_drivers/mag_iis2mdc.h b/stm32_projects/device_drivers/mag_iis2mdc.h index 176ed048..5ed0cd00 100644 --- a/stm32_projects/device_drivers/mag_iis2mdc.h +++ b/stm32_projects/device_drivers/mag_iis2mdc.h @@ -21,12 +21,12 @@ typedef struct IIS2MDCCtrl_s { // The most recent sensor reading MagData_s data; - I2C_HandleTypeDef *hi2c; + I2C_HandleTypeDef* hi2c; uint8_t address; } ImuIIS2MDCCtrl_s; -bool iis2mdc_init(ImuIIS2MDCCtrl_s *sensor, uint8_t address7bit); -void iis2mdc_getData(ImuIIS2MDCCtrl_s *sensor); +bool iis2mdc_init(ImuIIS2MDCCtrl_s* sensor, uint8_t address7bit); +void iis2mdc_getData(ImuIIS2MDCCtrl_s* sensor); #endif // HAL_I2C_MODULE_ENABLED diff --git a/stm32_projects/device_drivers/minmea.c b/stm32_projects/device_drivers/minmea.c index 77e58552..7e99a279 100644 --- a/stm32_projects/device_drivers/minmea.c +++ b/stm32_projects/device_drivers/minmea.c @@ -25,7 +25,7 @@ static int hex2int(char c) { return -1; } -uint8_t minmea_checksum(const char *sentence) { +uint8_t minmea_checksum(const char* sentence) { // Support senteces with or without the starting dollar sign. if (*sentence == '$') sentence++; @@ -37,7 +37,7 @@ uint8_t minmea_checksum(const char *sentence) { return checksum; } -bool minmea_check(const char *sentence, bool strict) { +bool minmea_check(const char* sentence, bool strict) { uint8_t checksum = 0x00; // Sequence length is limited. @@ -78,13 +78,13 @@ static inline bool minmea_isfield(char c) { return isprint((unsigned char)c) && c != ',' && c != '*'; } -bool minmea_scan(const char *sentence, const char *format, ...) { +bool minmea_scan(const char* sentence, const char* format, ...) { bool result = false; bool optional = false; va_list ap; va_start(ap, format); - const char *field = sentence; + const char* field = sentence; #define next_field() \ do { \ /* Progress to the next field. */ \ @@ -118,7 +118,7 @@ bool minmea_scan(const char *sentence, const char *format, ...) { if (field && minmea_isfield(*field)) value = *field; - *va_arg(ap, char *) = value; + *va_arg(ap, char*) = value; } break; case 'd': { // Single character direction field (int). @@ -139,7 +139,7 @@ bool minmea_scan(const char *sentence, const char *format, ...) { } } - *va_arg(ap, int *) = value; + *va_arg(ap, int*) = value; } break; case 'f': { // Fractional value with scale (struct minmea_float). @@ -193,7 +193,7 @@ bool minmea_scan(const char *sentence, const char *format, ...) { } if (sign) value *= sign; - *va_arg(ap, struct minmea_float *) = + *va_arg(ap, struct minmea_float*) = (struct minmea_float){value, scale}; // NOLINT } break; @@ -201,16 +201,16 @@ bool minmea_scan(const char *sentence, const char *format, ...) { int value = 0; if (field) { - char *endptr; + char* endptr; value = strtol(field, &endptr, 10); if (minmea_isfield(*endptr)) goto parse_error; } - *va_arg(ap, int *) = value; + *va_arg(ap, int*) = value; } break; case 's': { // String value (char *). - char *buf = va_arg(ap, char *); + char* buf = va_arg(ap, char*); if (field) { while (minmea_isfield(*field)) *buf++ = *field++; @@ -227,13 +227,13 @@ bool minmea_scan(const char *sentence, const char *format, ...) { for (int f = 0; f < 5; f++) if (!minmea_isfield(field[1 + f])) goto parse_error; - char *buf = va_arg(ap, char *); + char* buf = va_arg(ap, char*); memcpy(buf, field + 1, 5); buf[5] = '\0'; } break; case 'D': { // Date (int, int, int), -1 if empty. - struct minmea_date *date = va_arg(ap, struct minmea_date *); + struct minmea_date* date = va_arg(ap, struct minmea_date*); int d = -1, m = -1, y = -1; @@ -256,7 +256,7 @@ bool minmea_scan(const char *sentence, const char *format, ...) { } break; case 'T': { // Time (int, int, int, int), -1 if empty. - struct minmea_time *time_ = va_arg(ap, struct minmea_time *); + struct minmea_time* time_ = va_arg(ap, struct minmea_time*); int h = -1, i = -1, s = -1, u = -1; @@ -311,7 +311,7 @@ bool minmea_scan(const char *sentence, const char *format, ...) { return result; } -bool minmea_talker_id(char talker[3], const char *sentence) { +bool minmea_talker_id(char talker[3], const char* sentence) { char type[6]; if (!minmea_scan(sentence, "t", type)) return false; @@ -322,7 +322,7 @@ bool minmea_talker_id(char talker[3], const char *sentence) { return true; } -enum minmea_sentence_id minmea_sentence_id(const char *sentence, bool strict) { +enum minmea_sentence_id minmea_sentence_id(const char* sentence, bool strict) { if (!minmea_check(sentence, strict)) return MINMEA_INVALID; char type[6]; @@ -340,7 +340,7 @@ enum minmea_sentence_id minmea_sentence_id(const char *sentence, bool strict) { return MINMEA_UNKNOWN; } -bool minmea_parse_rmc(struct minmea_sentence_rmc *frame, const char *sentence) { +bool minmea_parse_rmc(struct minmea_sentence_rmc* frame, const char* sentence) { // $GPRMC,081836,A,3751.65,S,14507.36,E,000.0,360.0,130998,011.3,E*62 char type[6]; char validity; @@ -362,7 +362,7 @@ bool minmea_parse_rmc(struct minmea_sentence_rmc *frame, const char *sentence) { return true; } -bool minmea_parse_gga(struct minmea_sentence_gga *frame, const char *sentence) { +bool minmea_parse_gga(struct minmea_sentence_gga* frame, const char* sentence) { // $GPGGA,123519,4807.038,N,01131.000,E,1,08,0.9,545.4,M,46.9,M,,*47 char type[6]; int latitude_direction; @@ -383,7 +383,7 @@ bool minmea_parse_gga(struct minmea_sentence_gga *frame, const char *sentence) { return true; } -bool minmea_parse_gsa(struct minmea_sentence_gsa *frame, const char *sentence) { +bool minmea_parse_gsa(struct minmea_sentence_gsa* frame, const char* sentence) { // $GPGSA,A,3,04,05,,09,12,,,24,,,,,2.5,1.3,2.1*39 char type[6]; @@ -399,7 +399,7 @@ bool minmea_parse_gsa(struct minmea_sentence_gsa *frame, const char *sentence) { return true; } -bool minmea_parse_gll(struct minmea_sentence_gll *frame, const char *sentence) { +bool minmea_parse_gll(struct minmea_sentence_gll* frame, const char* sentence) { // $GPGLL,3723.2475,N,12158.3416,W,161229.487,A,A*41$; char type[6]; int latitude_direction; @@ -417,7 +417,7 @@ bool minmea_parse_gll(struct minmea_sentence_gll *frame, const char *sentence) { return true; } -bool minmea_parse_gst(struct minmea_sentence_gst *frame, const char *sentence) { +bool minmea_parse_gst(struct minmea_sentence_gst* frame, const char* sentence) { // $GPGST,024603.00,3.2,6.6,4.7,47.3,5.8,5.6,22.0*58 char type[6]; @@ -432,7 +432,7 @@ bool minmea_parse_gst(struct minmea_sentence_gst *frame, const char *sentence) { return true; } -bool minmea_parse_gsv(struct minmea_sentence_gsv *frame, const char *sentence) { +bool minmea_parse_gsv(struct minmea_sentence_gsv* frame, const char* sentence) { // $GPGSV,3,1,11,03,03,111,00,04,15,270,00,06,01,010,00,13,06,292,00*74 // $GPGSV,3,3,11,22,42,067,42,24,14,311,43,27,05,244,00,,,,*4D // $GPGSV,4,2,11,08,51,203,30,09,45,215,28*75 @@ -456,7 +456,7 @@ bool minmea_parse_gsv(struct minmea_sentence_gsv *frame, const char *sentence) { return true; } -bool minmea_parse_vtg(struct minmea_sentence_vtg *frame, const char *sentence) { +bool minmea_parse_vtg(struct minmea_sentence_vtg* frame, const char* sentence) { // $GPVTG,054.7,T,034.4,M,005.5,N,010.2,K*48 // $GPVTG,156.1,T,140.9,M,0.0,N,0.0,K*41 // $GPVTG,096.5,T,083.5,M,0.0,N,0.0,K,D*22 @@ -478,7 +478,7 @@ bool minmea_parse_vtg(struct minmea_sentence_vtg *frame, const char *sentence) { return true; } -bool minmea_parse_zda(struct minmea_sentence_zda *frame, const char *sentence) { +bool minmea_parse_zda(struct minmea_sentence_zda* frame, const char* sentence) { // $GPZDA,201530.00,04,07,2002,00,00*60 char type[6]; @@ -496,8 +496,8 @@ bool minmea_parse_zda(struct minmea_sentence_zda *frame, const char *sentence) { return true; } -int minmea_gettime(struct timespec *ts, const struct minmea_date *date, - const struct minmea_time *time_) { +int minmea_gettime(struct timespec* ts, const struct minmea_date* date, + const struct minmea_time* time_) { if (date->year == -1 || time_->hours == -1) return -1; struct tm tm; diff --git a/stm32_projects/device_drivers/minmea.h b/stm32_projects/device_drivers/minmea.h index db7d329e..e839992f 100644 --- a/stm32_projects/device_drivers/minmea.h +++ b/stm32_projects/device_drivers/minmea.h @@ -168,22 +168,22 @@ struct minmea_sentence_zda { /** * Calculate raw sentence checksum. Does not check sentence integrity. */ -uint8_t minmea_checksum(const char *sentence); +uint8_t minmea_checksum(const char* sentence); /** * Check sentence validity and checksum. Returns true for valid sentences. */ -bool minmea_check(const char *sentence, bool strict); +bool minmea_check(const char* sentence, bool strict); /** * Determine talker identifier. */ -bool minmea_talker_id(char talker[3], const char *sentence); +bool minmea_talker_id(char talker[3], const char* sentence); /** * Determine sentence identifier. */ -enum minmea_sentence_id minmea_sentence_id(const char *sentence, bool strict); +enum minmea_sentence_id minmea_sentence_id(const char* sentence, bool strict); /** * Scanf-like processor for NMEA sentences. Supports the following formats: @@ -196,30 +196,30 @@ enum minmea_sentence_id minmea_sentence_id(const char *sentence, bool strict); * T - date/time stamp (int *, int *, int *) * Returns true on success. See library source code for details. */ -bool minmea_scan(const char *sentence, const char *format, ...); +bool minmea_scan(const char* sentence, const char* format, ...); /* * Parse a specific type of sentence. Return true on success. */ -bool minmea_parse_rmc(struct minmea_sentence_rmc *frame, const char *sentence); -bool minmea_parse_gga(struct minmea_sentence_gga *frame, const char *sentence); -bool minmea_parse_gsa(struct minmea_sentence_gsa *frame, const char *sentence); -bool minmea_parse_gll(struct minmea_sentence_gll *frame, const char *sentence); -bool minmea_parse_gst(struct minmea_sentence_gst *frame, const char *sentence); -bool minmea_parse_gsv(struct minmea_sentence_gsv *frame, const char *sentence); -bool minmea_parse_vtg(struct minmea_sentence_vtg *frame, const char *sentence); -bool minmea_parse_zda(struct minmea_sentence_zda *frame, const char *sentence); +bool minmea_parse_rmc(struct minmea_sentence_rmc* frame, const char* sentence); +bool minmea_parse_gga(struct minmea_sentence_gga* frame, const char* sentence); +bool minmea_parse_gsa(struct minmea_sentence_gsa* frame, const char* sentence); +bool minmea_parse_gll(struct minmea_sentence_gll* frame, const char* sentence); +bool minmea_parse_gst(struct minmea_sentence_gst* frame, const char* sentence); +bool minmea_parse_gsv(struct minmea_sentence_gsv* frame, const char* sentence); +bool minmea_parse_vtg(struct minmea_sentence_vtg* frame, const char* sentence); +bool minmea_parse_zda(struct minmea_sentence_zda* frame, const char* sentence); /** * Convert GPS UTC date/time representation to a UNIX timestamp. */ -int minmea_gettime(struct timespec *ts, const struct minmea_date *date, - const struct minmea_time *time_); +int minmea_gettime(struct timespec* ts, const struct minmea_date* date, + const struct minmea_time* time_); /** * Rescale a fixed-point value to a different scale. Rounds towards zero. */ -static inline int_least32_t minmea_rescale(struct minmea_float *f, +static inline int_least32_t minmea_rescale(struct minmea_float* f, int_least32_t new_scale) { if (f->scale == 0) return 0; if (f->scale == new_scale) return f->value; @@ -235,7 +235,7 @@ static inline int_least32_t minmea_rescale(struct minmea_float *f, * Convert a fixed-point value to a floating-point value. * Returns NaN for "unknown" values. */ -static inline float minmea_tofloat(struct minmea_float *f) { +static inline float minmea_tofloat(struct minmea_float* f) { if (f->scale == 0) return NAN; return (float)f->value / (float)f->scale; } @@ -244,7 +244,7 @@ static inline float minmea_tofloat(struct minmea_float *f) { * Convert a raw coordinate to a floating point DD.DDD... value. * Returns NaN for "unknown" values. */ -static inline float minmea_tocoord(struct minmea_float *f) { +static inline float minmea_tocoord(struct minmea_float* f) { if (f->scale == 0) return NAN; int_least32_t degrees = f->value / (f->scale * 100); int_least32_t minutes = f->value % (f->scale * 100); diff --git a/stm32_projects/device_drivers/pyro_digital.cpp b/stm32_projects/device_drivers/pyro_digital.cpp index c6204526..1368cccd 100644 --- a/stm32_projects/device_drivers/pyro_digital.cpp +++ b/stm32_projects/device_drivers/pyro_digital.cpp @@ -9,7 +9,7 @@ #if HAS_DEV(PYRO_DIGITAL) -void pyroDigital_init(PyroDigitalCtrl_s *pyro) { +void pyroDigital_init(PyroDigitalCtrl_s* pyro) { // Make sure our pyros are OFF if (pyro->port) { HAL_GPIO_WritePin(pyro->port, pyro->pin, GPIO_PIN_RESET); @@ -18,13 +18,13 @@ void pyroDigital_init(PyroDigitalCtrl_s *pyro) { pyro->pwm = false; } -void pyroDigital_start(PyroDigitalCtrl_s *pyro, uint32_t duration) { +void pyroDigital_start(PyroDigitalCtrl_s* pyro, uint32_t duration) { HAL_GPIO_WritePin(pyro->port, pyro->pin, GPIO_PIN_SET); pyro->expireTime = HAL_GetTick() + duration; pyro->stayEnabled = false; } -void pyroDigital_set(PyroDigitalCtrl_s *pyro, bool enable) { +void pyroDigital_set(PyroDigitalCtrl_s* pyro, bool enable) { if (pyro->port) { HAL_GPIO_WritePin(pyro->port, pyro->pin, enable ? GPIO_PIN_SET : GPIO_PIN_RESET); @@ -32,7 +32,7 @@ void pyroDigital_set(PyroDigitalCtrl_s *pyro, bool enable) { } } -void pyroDigital_tick(PyroDigitalCtrl_s *pyro) { +void pyroDigital_tick(PyroDigitalCtrl_s* pyro) { if (pyro->expireTime != 0 && HAL_GetTick() >= pyro->expireTime && pyro->port != NULL && !pyro->stayEnabled) { HAL_GPIO_WritePin(pyro->port, pyro->pin, GPIO_PIN_RESET); @@ -52,7 +52,7 @@ void pyroDigital_tick(PyroDigitalCtrl_s *pyro) { } } -void pyroDigital_pwmStart(PyroDigitalCtrl_s *pyro, uint32_t duration, +void pyroDigital_pwmStart(PyroDigitalCtrl_s* pyro, uint32_t duration, uint32_t frequency, uint32_t pulseWidth) { if (pyro->port) { pyro->pwm = true; diff --git a/stm32_projects/device_drivers/pyro_digital.h b/stm32_projects/device_drivers/pyro_digital.h index d42c3007..1af431ce 100644 --- a/stm32_projects/device_drivers/pyro_digital.h +++ b/stm32_projects/device_drivers/pyro_digital.h @@ -15,8 +15,8 @@ #define CLOCK_FREQUENCY_HZ 1000 typedef struct { - GPIO_TypeDef *port; - TIM_HandleTypeDef *htim; + GPIO_TypeDef* port; + TIM_HandleTypeDef* htim; uint16_t pin; bool stayEnabled; uint32_t expireTime; @@ -26,11 +26,11 @@ typedef struct { uint32_t counterMax; } PyroDigitalCtrl_s; -void pyroDigital_init(PyroDigitalCtrl_s *pyro); -void pyroDigital_start(PyroDigitalCtrl_s *pyro, uint32_t duration); -void pyroDigital_set(PyroDigitalCtrl_s *pyro, bool enable); -void pyroDigital_tick(PyroDigitalCtrl_s *pyro); -void pyroDigital_pwmStart(PyroDigitalCtrl_s *pyro, uint32_t duration, +void pyroDigital_init(PyroDigitalCtrl_s* pyro); +void pyroDigital_start(PyroDigitalCtrl_s* pyro, uint32_t duration); +void pyroDigital_set(PyroDigitalCtrl_s* pyro, bool enable); +void pyroDigital_tick(PyroDigitalCtrl_s* pyro); +void pyroDigital_pwmStart(PyroDigitalCtrl_s* pyro, uint32_t duration, uint32_t frequency, uint32_t pulseWidth); #endif // HAL_TIM_MODULE_ENABLED diff --git a/stm32_projects/device_drivers/servo_pwm.cpp b/stm32_projects/device_drivers/servo_pwm.cpp index c5217d37..3dad8b7d 100644 --- a/stm32_projects/device_drivers/servo_pwm.cpp +++ b/stm32_projects/device_drivers/servo_pwm.cpp @@ -6,7 +6,7 @@ #if HAS_DEV(SERVO_PWM) -bool servoPwm_init(ServoPwmCtrl_t *servo, TIM_HandleTypeDef *htim, +bool servoPwm_init(ServoPwmCtrl_t* servo, TIM_HandleTypeDef* htim, uint32_t channel, uint32_t periodMS, float minPulseMS, float maxPulseMS, float minAngle, float maxAngle) { // Set servo struct values @@ -40,7 +40,7 @@ bool servoPwm_init(ServoPwmCtrl_t *servo, TIM_HandleTypeDef *htim, return true; } -void servoPwm_setAngle(ServoPwmCtrl_t *servo, float degrees) { +void servoPwm_setAngle(ServoPwmCtrl_t* servo, float degrees) { // Calculate pulse from degrees float pulsePercent = (degrees - servo->minAngle) / (servo->maxAngle - servo->minAngle); diff --git a/stm32_projects/device_drivers/servo_pwm.h b/stm32_projects/device_drivers/servo_pwm.h index db10475f..2903f360 100644 --- a/stm32_projects/device_drivers/servo_pwm.h +++ b/stm32_projects/device_drivers/servo_pwm.h @@ -17,7 +17,7 @@ extern "C" { #if HAS_DEV(SERVO_PWM) typedef struct { - TIM_HandleTypeDef *htim; + TIM_HandleTypeDef* htim; uint32_t channel; uint32_t periodMS; float minPulseMS; @@ -26,10 +26,10 @@ typedef struct { float maxAngle; } ServoPwmCtrl_t; -bool servoPwm_init(ServoPwmCtrl_t *servo, TIM_HandleTypeDef *htim, +bool servoPwm_init(ServoPwmCtrl_t* servo, TIM_HandleTypeDef* htim, uint32_t channel, uint32_t periodMS, float minPulseMS, float maxPulseMS, float minAngle, float maxAngle); -void servoPwm_setAngle(ServoPwmCtrl_t *servo, float degrees); +void servoPwm_setAngle(ServoPwmCtrl_t* servo, float degrees); #endif diff --git a/stm32_projects/device_drivers/spi_driver.cpp b/stm32_projects/device_drivers/spi_driver.cpp index 5521a6aa..0e6c5dcb 100644 --- a/stm32_projects/device_drivers/spi_driver.cpp +++ b/stm32_projects/device_drivers/spi_driver.cpp @@ -11,7 +11,7 @@ #define SPI_MAX_DELAY 10 // ms -uint8_t spi_readRegister(SpiCtrl_t *sensor, uint8_t reg) { +uint8_t spi_readRegister(SpiCtrl_t* sensor, uint8_t reg) { uint8_t rxBuff[2] = {0}; uint8_t txBuff[2] = {0}; txBuff[0] = reg; @@ -28,7 +28,7 @@ uint8_t spi_readRegister(SpiCtrl_t *sensor, uint8_t reg) { return rxBuff[1]; } -void spi_writeRegister(SpiCtrl_t *sensor, uint8_t reg, uint8_t val) { +void spi_writeRegister(SpiCtrl_t* sensor, uint8_t reg, uint8_t val) { uint8_t txBuff[2]; txBuff[0] = reg; txBuff[1] = val; @@ -44,7 +44,7 @@ void spi_writeRegister(SpiCtrl_t *sensor, uint8_t reg, uint8_t val) { HAL_GPIO_WritePin(sensor->port, sensor->pin, GPIO_PIN_SET); } -void spi_writeArray(SpiCtrl_t *sensor, uint8_t *pTxData, size_t len) { +void spi_writeArray(SpiCtrl_t* sensor, uint8_t* pTxData, size_t len) { // bring CS pin low HAL_GPIO_WritePin(sensor->port, sensor->pin, GPIO_PIN_RESET); diff --git a/stm32_projects/device_drivers/spi_driver.h b/stm32_projects/device_drivers/spi_driver.h index 4748212d..8d65a300 100644 --- a/stm32_projects/device_drivers/spi_driver.h +++ b/stm32_projects/device_drivers/spi_driver.h @@ -15,15 +15,15 @@ extern "C" { #include "board_config_common.h" typedef struct { - SPI_HandleTypeDef *hspi; - GPIO_TypeDef *port; + SPI_HandleTypeDef* hspi; + GPIO_TypeDef* port; uint16_t pin; } SpiCtrl_t; -uint8_t spi_readRegister(SpiCtrl_t *sensor, uint8_t reg); -void spi_writeRegister(SpiCtrl_t *sensor, uint8_t reg, uint8_t val); +uint8_t spi_readRegister(SpiCtrl_t* sensor, uint8_t reg); +void spi_writeRegister(SpiCtrl_t* sensor, uint8_t reg, uint8_t val); -void spi_writeArray(SpiCtrl_t *sensor, uint8_t *pTxData, size_t len); +void spi_writeArray(SpiCtrl_t* sensor, uint8_t* pTxData, size_t len); #ifdef __cplusplus } diff --git a/stm32_projects/device_drivers/temp_max31855.cpp b/stm32_projects/device_drivers/temp_max31855.cpp index 998b51b8..d1471483 100644 --- a/stm32_projects/device_drivers/temp_max31855.cpp +++ b/stm32_projects/device_drivers/temp_max31855.cpp @@ -29,7 +29,7 @@ static float voltageToTemperature(float voltage) { // https://github.com/Tuckie/max31855/blob/71b2724f6280a0970ff094290c63e01c889126c3/max31855.py#L111 // Calculate internal raw counts, given the register value -static void convertThermocouple(TempMax31855Ctrl_s *dev, uint32_t raw) { +static void convertThermocouple(TempMax31855Ctrl_s* dev, uint32_t raw) { struct { int raw_temp : 14; } reg; @@ -46,7 +46,7 @@ static void convertThermocouple(TempMax31855Ctrl_s *dev, uint32_t raw) { } // Calculate internal raw counts, given the register value -static void convertReferenceJunction(TempMax31855Ctrl_s *dev, uint32_t raw) { +static void convertReferenceJunction(TempMax31855Ctrl_s* dev, uint32_t raw) { struct { int raw_temp : 12; } reg; @@ -55,7 +55,7 @@ static void convertReferenceJunction(TempMax31855Ctrl_s *dev, uint32_t raw) { dev->data.internalTemp = static_cast(reg.raw_temp * 0.0625); } -void tempMax31855_read(TempMax31855Ctrl_s *dev) { +void tempMax31855_read(TempMax31855Ctrl_s* dev) { // Read 32 bits from SPI uint8_t rxBuff[4] = {0}; HAL_GPIO_WritePin(dev->csPort, dev->csPin, GPIO_PIN_RESET); @@ -72,7 +72,7 @@ void tempMax31855_read(TempMax31855Ctrl_s *dev) { d |= rxBuff[3]; // Fun pointer wizardry to convert to our struct - Max31855Raw_s *raw = reinterpret_cast(&d); + Max31855Raw_s* raw = reinterpret_cast(&d); // Convert to real numbers convertReferenceJunction(dev, d >> 4); @@ -85,8 +85,8 @@ void tempMax31855_read(TempMax31855Ctrl_s *dev) { (raw->gndFault << 2) | (raw->vccFault << 3)); } -void tempMax31855_init(TempMax31855Ctrl_s *dev, SPI_HandleTypeDef *hspi, - GPIO_TypeDef *csPort, uint16_t csPin) { +void tempMax31855_init(TempMax31855Ctrl_s* dev, SPI_HandleTypeDef* hspi, + GPIO_TypeDef* csPort, uint16_t csPin) { dev->hspi = hspi; dev->csPort = csPort; dev->csPin = csPin; diff --git a/stm32_projects/device_drivers/temp_max31855.h b/stm32_projects/device_drivers/temp_max31855.h index a75f39bd..44872b7c 100644 --- a/stm32_projects/device_drivers/temp_max31855.h +++ b/stm32_projects/device_drivers/temp_max31855.h @@ -42,15 +42,15 @@ typedef struct __attribute__((packed)) { } Max31855Data_s; typedef struct { - SPI_HandleTypeDef *hspi; - GPIO_TypeDef *csPort; + SPI_HandleTypeDef* hspi; + GPIO_TypeDef* csPort; uint16_t csPin; Max31855Data_s data; } TempMax31855Ctrl_s; -void tempMax31855_init(TempMax31855Ctrl_s *dev, SPI_HandleTypeDef *hspi, - GPIO_TypeDef *csPort, uint16_t csPin); -void tempMax31855_read(TempMax31855Ctrl_s *dev); +void tempMax31855_init(TempMax31855Ctrl_s* dev, SPI_HandleTypeDef* hspi, + GPIO_TypeDef* csPort, uint16_t csPin); +void tempMax31855_read(TempMax31855Ctrl_s* dev); #ifdef __cplusplus } diff --git a/stm32_projects/device_drivers/ti_radio.cpp b/stm32_projects/device_drivers/ti_radio.cpp index 90f48746..b24df0c2 100644 --- a/stm32_projects/device_drivers/ti_radio.cpp +++ b/stm32_projects/device_drivers/ti_radio.cpp @@ -18,30 +18,30 @@ #include "cc1120_cc1200_defs.h" // Forward declarations for all internal register read/writes -static uint8_t tiRadio_spiReadReg(TiRadioCtrl_s *radio, uint16_t addr, - uint8_t *data, uint8_t len); -static uint8_t tiRadio_spiWriteReg(TiRadioCtrl_s *radio, uint16_t addr, - uint8_t *data, uint8_t len); -static uint8_t tiRadio_spiWriteTxFifo(TiRadioCtrl_s *radio, uint8_t *pWriteData, +static uint8_t tiRadio_spiReadReg(TiRadioCtrl_s* radio, uint16_t addr, + uint8_t* data, uint8_t len); +static uint8_t tiRadio_spiWriteReg(TiRadioCtrl_s* radio, uint16_t addr, + uint8_t* data, uint8_t len); +static uint8_t tiRadio_spiWriteTxFifo(TiRadioCtrl_s* radio, uint8_t* pWriteData, uint8_t len); -static uint8_t tiRadio_spiReadRxFifo(TiRadioCtrl_s *radio, uint8_t *pReadData, +static uint8_t tiRadio_spiReadRxFifo(TiRadioCtrl_s* radio, uint8_t* pReadData, uint8_t len); -static uint8_t tiRadio_txRxSpiCmdStrobe(TiRadioCtrl_s *radio, uint8_t cmd); -static void tiRadio_txRxReadWriteBurstSingle(TiRadioCtrl_s *radio, uint8_t addr, - uint8_t *pData, uint16_t len); +static uint8_t tiRadio_txRxSpiCmdStrobe(TiRadioCtrl_s* radio, uint8_t cmd); +static void tiRadio_txRxReadWriteBurstSingle(TiRadioCtrl_s* radio, uint8_t addr, + uint8_t* pData, uint16_t len); //! Try to transmit a packet. Returns true if we were able to add the packet to //! TX FIFO -static bool tiRadio_TransmitPacket(TiRadioCtrl_s *radio, uint8_t *payload, +static bool tiRadio_TransmitPacket(TiRadioCtrl_s* radio, uint8_t* payload, uint8_t payloadLength); #if RADIO_TI_TYPE == RADIO_TI_TYPE_CC1120 -static bool manualCalibration(TiRadioCtrl_s *radio); +static bool manualCalibration(TiRadioCtrl_s* radio); #endif #define TIRADIO_MAX_DELAY 10 // ms // Initially configure radio, apply settings provided -bool tiRadio_init(TiRadioCtrl_s *radio) { +bool tiRadio_init(TiRadioCtrl_s* radio) { // Set SPI pins into a known good state. Lots of waiting to make sure it // actually happens HAL_GPIO_WritePin(radio->RST_port, radio->RST_pin, GPIO_PIN_SET); @@ -119,7 +119,7 @@ bool tiRadio_init(TiRadioCtrl_s *radio) { // The main tick function. Checks for new packets and transmits the waiting one, // if non-zero -void tiRadio_update(TiRadioCtrl_s *radio) { +void tiRadio_update(TiRadioCtrl_s* radio) { // Don't let anything happen if radio isn't initialized if (!radio->initialized) return; @@ -226,7 +226,7 @@ static bool cc1120InTx(uint8_t status) { status == TIRADIO_STATE_SETTLING; } -static bool tiRadio_TransmitPacket(TiRadioCtrl_s *radio, uint8_t *payload, +static bool tiRadio_TransmitPacket(TiRadioCtrl_s* radio, uint8_t* payload, uint8_t payloadLength) { static bool added = false; @@ -301,7 +301,7 @@ static bool tiRadio_TransmitPacket(TiRadioCtrl_s *radio, uint8_t *payload, return added; } -static void cc1120EnqueuePacket(TiRadioCtrl_s *radio, uint8_t *buff, +static void cc1120EnqueuePacket(TiRadioCtrl_s* radio, uint8_t* buff, uint8_t size, bool crc) { // Fill our packet static RadioRecievedPacket_s packet; @@ -314,14 +314,14 @@ static void cc1120EnqueuePacket(TiRadioCtrl_s *radio, uint8_t *buff, // uint8_t *pPacket = (uint8_t *) &packet; for (int i = 0; i < MAX_COMSUMER; i++) { - CircularBuffer_s *consumer = radio->messageConsumers[i]; + CircularBuffer_s* consumer = radio->messageConsumers[i]; if (consumer == NULL) continue; cb_enqueue(consumer, reinterpret_cast(&packet)); } } -bool tiRadio_addTxPacket(TiRadioCtrl_s *radio, uint8_t *packet, uint8_t len) { +bool tiRadio_addTxPacket(TiRadioCtrl_s* radio, uint8_t* packet, uint8_t len) { // Need to transmit in distinct packets, and we assume in fixed that there's // no delimination between packets This will require some refactoring to // support variable packet length @@ -345,13 +345,13 @@ bool tiRadio_addTxPacket(TiRadioCtrl_s *radio, uint8_t *packet, uint8_t len) { return true; } -void tiRadio_registerConsumer(TiRadioCtrl_s *radio, - CircularBuffer_s *rxBuffer) { +void tiRadio_registerConsumer(TiRadioCtrl_s* radio, + CircularBuffer_s* rxBuffer) { radio->messageConsumers[radio->currentConsumerCount] = rxBuffer; radio->currentConsumerCount++; } -bool tiRadio_checkNewPacket(TiRadioCtrl_s *radio) { +bool tiRadio_checkNewPacket(TiRadioCtrl_s* radio) { static uint8_t rxbytes = 0x00; static uint8_t rxBuffer[128] = {0}; @@ -385,8 +385,7 @@ bool tiRadio_checkNewPacket(TiRadioCtrl_s *radio) { // Fixed means we have payloadSize many data bytes, then RSSI and CRC_LQI // appended tiRadio_spiReadRxFifo(radio, rxBuffer, radio->payloadSize); - tiRadio_spiReadRxFifo(radio, reinterpret_cast(&radio->RSSI), - 1); + tiRadio_spiReadRxFifo(radio, reinterpret_cast(&radio->RSSI), 1); uint8_t crc_lqi; tiRadio_spiReadRxFifo(radio, &crc_lqi, 1); @@ -402,7 +401,7 @@ bool tiRadio_checkNewPacket(TiRadioCtrl_s *radio) { return false; } -bool tiRadio_forceIdle(TiRadioCtrl_s *radio) { +bool tiRadio_forceIdle(TiRadioCtrl_s* radio) { // return the radio to idle somehow uint8_t status; status = tiRadio_txRxSpiCmdStrobe(radio, TIRADIO_SNOP); @@ -447,7 +446,7 @@ bool tiRadio_forceIdle(TiRadioCtrl_s *radio) { return false; } -bool tiRadio_startRx(TiRadioCtrl_s *radio) { +bool tiRadio_startRx(TiRadioCtrl_s* radio) { uint8_t readByte; tiRadio_txRxSpiCmdStrobe(radio, TIRADIO_SRX); @@ -471,7 +470,7 @@ static const size_t maxValue24Bits = 16777216 - 1; #define RADIO_OSC_FREQ CC1200_OSC_FREQ #endif -void tiRadio_setRadioFrequency(TiRadioCtrl_s *radio, TiRadioBand_e band, +void tiRadio_setRadioFrequency(TiRadioCtrl_s* radio, TiRadioBand_e band, float frequencyHz) { // LO divider and stuff should already be set for us, as we assume we must // be on the correct band already @@ -524,7 +523,7 @@ void tiRadio_setRadioFrequency(TiRadioCtrl_s *radio, TiRadioBand_e band, tiRadio_calibrate(radio); } -bool tiRadio_calibrate(TiRadioCtrl_s *radio) { +bool tiRadio_calibrate(TiRadioCtrl_s* radio) { #if RADIO_TI_TYPE == RADIO_TI_TYPE_CC1120 // calibrate the radio per errata return manualCalibration(radio); @@ -540,7 +539,7 @@ bool tiRadio_calibrate(TiRadioCtrl_s *radio) { #define FS_CHP_INDEX 2 #if RADIO_TI_TYPE == RADIO_TI_TYPE_CC1120 -static bool manualCalibration(TiRadioCtrl_s *radio) { +static bool manualCalibration(TiRadioCtrl_s* radio) { uint8_t original_fs_cal2; uint8_t calResults_for_vcdac_start_high[3]; uint8_t calResults_for_vcdac_start_mid[3]; @@ -628,7 +627,7 @@ static bool manualCalibration(TiRadioCtrl_s *radio) { #endif //! Set power in db. Make sure to respect your PA maximum! -void tiRadio_setOutputPower(TiRadioCtrl_s *radio, uint8_t powerDbM) { +void tiRadio_setOutputPower(TiRadioCtrl_s* radio, uint8_t powerDbM) { if (radio->has_cc1190 && powerDbM > 10) powerDbM = 10; // output = (ramp + 1)/2-18 @@ -659,7 +658,7 @@ void tiRadio_setOutputPower(TiRadioCtrl_s *radio, uint8_t powerDbM) { //! Configure a GPIO pin. register should be TIRADIO_IOCFG3 or TIRADIO_IOCFG2 or //! TIRADIO_IOCFG1 or TIRADIO_IOCFG0 gpio_config from tiRadio_GPIO_CFG, and //! outputInverted flips the logic of the pin -void tiRadio_configGpio(TiRadioCtrl_s *radio, uint16_t gpio_register, +void tiRadio_configGpio(TiRadioCtrl_s* radio, uint16_t gpio_register, uint8_t gpio_config, bool outputInverted) { uint8_t invert = (outputInverted ? 1 : 0); // invert is bit 6, 7th from bottom @@ -668,8 +667,8 @@ void tiRadio_configGpio(TiRadioCtrl_s *radio, uint16_t gpio_register, tiRadio_spiWriteReg(radio, gpio_register, ®, 1); } -uint8_t trx8BitRegAccess(TiRadioCtrl_s *radio, uint8_t accessType, - uint8_t addrByte, uint8_t *pData, uint16_t len) { +uint8_t trx8BitRegAccess(TiRadioCtrl_s* radio, uint8_t accessType, + uint8_t addrByte, uint8_t* pData, uint16_t len) { uint8_t readValue; uint8_t txBuf = (accessType | addrByte); @@ -692,8 +691,8 @@ uint8_t trx8BitRegAccess(TiRadioCtrl_s *radio, uint8_t accessType, return (readValue); } -uint8_t trx16BitRegAccess(TiRadioCtrl_s *radio, uint8_t accessType, - uint8_t extAddr, uint8_t regAddr, uint8_t *pData, +uint8_t trx16BitRegAccess(TiRadioCtrl_s* radio, uint8_t accessType, + uint8_t extAddr, uint8_t regAddr, uint8_t* pData, uint16_t len) { uint8_t readValue; uint8_t txBuf = (accessType | extAddr); @@ -722,7 +721,7 @@ uint8_t trx16BitRegAccess(TiRadioCtrl_s *radio, uint8_t accessType, return (readValue); } -uint8_t tiRadio_txRxSpiCmdStrobe(TiRadioCtrl_s *radio, uint8_t cmd) { +uint8_t tiRadio_txRxSpiCmdStrobe(TiRadioCtrl_s* radio, uint8_t cmd) { uint8_t rc; HAL_GPIO_WritePin(radio->CS_port, radio->CS_pin, GPIO_PIN_RESET); @@ -739,8 +738,8 @@ uint8_t tiRadio_txRxSpiCmdStrobe(TiRadioCtrl_s *radio, uint8_t cmd) { return (rc); } -void tiRadio_txRxReadWriteBurstSingle(TiRadioCtrl_s *radio, uint8_t addr, - uint8_t *pData, uint16_t len) { +void tiRadio_txRxReadWriteBurstSingle(TiRadioCtrl_s* radio, uint8_t addr, + uint8_t* pData, uint16_t len) { uint16_t i; uint8_t pushByte = 0x00; uint8_t rxdump; @@ -773,7 +772,7 @@ void tiRadio_txRxReadWriteBurstSingle(TiRadioCtrl_s *radio, uint8_t addr, return; } -uint8_t tiRadio_spiReadReg(TiRadioCtrl_s *radio, uint16_t addr, uint8_t *pData, +uint8_t tiRadio_spiReadReg(TiRadioCtrl_s* radio, uint16_t addr, uint8_t* pData, uint8_t len) { uint8_t tempExt = static_cast(addr >> 8); uint8_t tempAddr = static_cast(addr & 0x00FF); @@ -796,7 +795,7 @@ uint8_t tiRadio_spiReadReg(TiRadioCtrl_s *radio, uint16_t addr, uint8_t *pData, return (rc); } -uint8_t tiRadio_spiWriteReg(TiRadioCtrl_s *radio, uint16_t addr, uint8_t *pData, +uint8_t tiRadio_spiWriteReg(TiRadioCtrl_s* radio, uint16_t addr, uint8_t* pData, uint8_t len) { uint8_t tempExt = static_cast(addr >> 8); uint8_t tempAddr = static_cast(addr & 0x00FF); @@ -824,14 +823,14 @@ uint8_t tiRadio_spiWriteReg(TiRadioCtrl_s *radio, uint16_t addr, uint8_t *pData, return (rc); } -uint8_t tiRadio_spiWriteTxFifo(TiRadioCtrl_s *radio, uint8_t *pData, +uint8_t tiRadio_spiWriteTxFifo(TiRadioCtrl_s* radio, uint8_t* pData, uint8_t len) { uint8_t rc; rc = trx8BitRegAccess(radio, (RADIO_BURST_ACCESS | RADIO_WRITE_ACCESS), TIRADIO_BURST_TXFIFO, pData, len); return (rc); } -uint8_t tiRadio_spiReadRxFifo(TiRadioCtrl_s *radio, uint8_t *pData, +uint8_t tiRadio_spiReadRxFifo(TiRadioCtrl_s* radio, uint8_t* pData, uint8_t len) { uint8_t rc; rc = trx8BitRegAccess(radio, 0x00, TIRADIO_BURST_RXFIFO, pData, len); diff --git a/stm32_projects/device_drivers/ti_radio.h b/stm32_projects/device_drivers/ti_radio.h index 651e5af3..c9db394d 100644 --- a/stm32_projects/device_drivers/ti_radio.h +++ b/stm32_projects/device_drivers/ti_radio.h @@ -77,18 +77,18 @@ typedef enum { typedef struct { // GPIO pins - SPI_HandleTypeDef *radhspi; - GPIO_TypeDef *RST_port; + SPI_HandleTypeDef* radhspi; + GPIO_TypeDef* RST_port; uint16_t RST_pin; - GPIO_TypeDef *CS_port; + GPIO_TypeDef* CS_port; uint16_t CS_pin; - GPIO_TypeDef *MISO_port; + GPIO_TypeDef* MISO_port; uint16_t MISO_pin; - GPIO_TypeDef *GP0_port; + GPIO_TypeDef* GP0_port; uint16_t GP0_pin; - GPIO_TypeDef *GP2_port; + GPIO_TypeDef* GP2_port; uint16_t GP2_pin; - GPIO_TypeDef *GP3_port; + GPIO_TypeDef* GP3_port; uint16_t GP3_pin; // 0x00 is fixed packet size, payload determined by payloadSize @@ -104,7 +104,7 @@ typedef struct { uint8_t payloadSize; // Buffers for incoming/outgoing packets - CircularBuffer_s *messageConsumers[MAX_COMSUMER]; + CircularBuffer_s* messageConsumers[MAX_COMSUMER]; uint8_t currentConsumerCount; uint8_t txArray[PACKET_TX_SIZE]; @@ -118,29 +118,29 @@ typedef struct { uint8_t LQI; // Set from smartRF config - const RegisterSetting_s *settingsPtr; + const RegisterSetting_s* settingsPtr; size_t settingsSize; bool initialized; } TiRadioCtrl_s; -bool tiRadio_init(TiRadioCtrl_s *radio); +bool tiRadio_init(TiRadioCtrl_s* radio); -void tiRadio_update(TiRadioCtrl_s *radio); +void tiRadio_update(TiRadioCtrl_s* radio); //! Add one packet to the transmit queue, if there is space in it -bool tiRadio_addTxPacket(TiRadioCtrl_s *radio, uint8_t *packet, uint8_t len); -void tiRadio_registerConsumer(TiRadioCtrl_s *radio, CircularBuffer_s *rxBuffer); +bool tiRadio_addTxPacket(TiRadioCtrl_s* radio, uint8_t* packet, uint8_t len); +void tiRadio_registerConsumer(TiRadioCtrl_s* radio, CircularBuffer_s* rxBuffer); -void tiRadio_setRadioFrequency(TiRadioCtrl_s *radio, TiRadioBand_e band, +void tiRadio_setRadioFrequency(TiRadioCtrl_s* radio, TiRadioBand_e band, float frequencyHz); -bool tiRadio_forceIdle(TiRadioCtrl_s *radio); -bool tiRadio_startRx(TiRadioCtrl_s *radio); -bool tiRadio_checkNewPacket(TiRadioCtrl_s *radio); -void tiRadio_setOutputPower(TiRadioCtrl_s *radio, uint8_t powerDbM); -void tiRadio_configGpio(TiRadioCtrl_s *radio, uint16_t gpio_register, +bool tiRadio_forceIdle(TiRadioCtrl_s* radio); +bool tiRadio_startRx(TiRadioCtrl_s* radio); +bool tiRadio_checkNewPacket(TiRadioCtrl_s* radio); +void tiRadio_setOutputPower(TiRadioCtrl_s* radio, uint8_t powerDbM); +void tiRadio_configGpio(TiRadioCtrl_s* radio, uint16_t gpio_register, uint8_t gpio_config, bool outputInverted); -bool tiRadio_calibrate(TiRadioCtrl_s *radio); +bool tiRadio_calibrate(TiRadioCtrl_s* radio); #endif diff --git a/stm32_projects/device_drivers/usb_std.cpp b/stm32_projects/device_drivers/usb_std.cpp index 3b2a8df4..5cd952f9 100644 --- a/stm32_projects/device_drivers/usb_std.cpp +++ b/stm32_projects/device_drivers/usb_std.cpp @@ -17,18 +17,18 @@ static uint8_t rxBuffer[APP_RX_DATA_SIZE]; static CircularBuffer_s rxCircBuffer; -static int8_t (*cdcRxReceive)(uint8_t *Buf, uint32_t *Len); +static int8_t (*cdcRxReceive)(uint8_t* Buf, uint32_t* Len); static uint32_t lastTransmit; extern USBD_HandleTypeDef hUsbDeviceFS; -static int8_t usbReceive(uint8_t *buf, uint32_t *len) { +static int8_t usbReceive(uint8_t* buf, uint32_t* len) { // First, call original CDC receive function to receive new packet int8_t ret = cdcRxReceive(buf, len); // Next, add received packet to circular buffer - USBD_CDC_HandleTypeDef *pClassData = - static_cast(hUsbDeviceFS.pClassData); + USBD_CDC_HandleTypeDef* pClassData = + static_cast(hUsbDeviceFS.pClassData); for (uint32_t i = 0; i < pClassData->RxLength; i++) { cb_enqueue(&rxCircBuffer, static_cast(pClassData->RxBuffer + i)); @@ -46,7 +46,7 @@ void usbStd_init() { USBD_Interface_fops_FS.Receive = usbReceive; } -bool usbStd_transmit(uint8_t *buf, uint16_t len) { +bool usbStd_transmit(uint8_t* buf, uint16_t len) { // Wait for time since last transmit while (HAL_GetTick() - lastTransmit < TIME_BETWEEN_TRANSMITS_MS) { } @@ -54,16 +54,16 @@ bool usbStd_transmit(uint8_t *buf, uint16_t len) { return CDC_Transmit_FS(buf, len) == USBD_OK; } -CircularBuffer_s *usbStd_getRxBuffer() { return &rxCircBuffer; } +CircularBuffer_s* usbStd_getRxBuffer() { return &rxCircBuffer; } bool usbStd_isConnected() { return hUsbDeviceFS.dev_state == USBD_STATE_CONFIGURED; } // Overwrite _write so printf prints to USB -int _write(int file, char *ptr, int len) { +int _write(int file, char* ptr, int len) { if (hUsbDeviceFS.dev_state != USBD_STATE_CONFIGURED) return 0; - if (USBD_OK == CDC_Transmit_FS(reinterpret_cast(ptr), len)) + if (USBD_OK == CDC_Transmit_FS(reinterpret_cast(ptr), len)) return len; return 0; }