only:shall we be just a little less Toyota

firmware/console/binary/tunerstudio_io.h

@@ -80,7 +80,7 @@ private:
 // This class represents a channel for a physical async serial poart
 class SerialTsChannelBase : public TsChannelBase {
 public:
-	SerialTsChannelBase(const char *name) : TsChannelBase(name) {};
+	SerialTsChannelBase(const char *p_name) : TsChannelBase(p_name) {};
 	// Open the serial port with the specified baud rate
 	virtual void start(uint32_t baud) = 0;
 };

firmware/controllers/algo/engine_configuration.cpp

@@ -250,13 +250,13 @@ static void initTemperatureCurve(float *bins, float *values, int size, float def
 	}
 }
 
-void prepareVoidConfiguration(engine_configuration_s *engineConfiguration) {
-	criticalAssertVoid(engineConfiguration != NULL, "ec NULL");
-	efi::clear(engineConfiguration);
+void prepareVoidConfiguration(engine_configuration_s *p_engineConfiguration) {
+	criticalAssertVoid(p_engineConfiguration != NULL, "ec NULL");
+	efi::clear(p_engineConfiguration);
 
-	engineConfiguration->clutchDownPinMode = PI_PULLUP;
-	engineConfiguration->clutchUpPinMode = PI_PULLUP;
-	engineConfiguration->brakePedalPinMode = PI_PULLUP;
+	p_engineConfiguration->clutchDownPinMode = PI_PULLUP;
+	p_engineConfiguration->clutchUpPinMode = PI_PULLUP;
+	p_engineConfiguration->brakePedalPinMode = PI_PULLUP;
 }
 
 void setDefaultBasePins() {
@@ -1024,8 +1024,8 @@ void resetConfigurationExt(configuration_callback_t boardCallback, engine_type_e
 	applyNonPersistentConfiguration();
 }
 
-void emptyCallbackWithConfiguration(engine_configuration_s * engineConfiguration) {
-	UNUSED(engineConfiguration);
+void emptyCallbackWithConfiguration(engine_configuration_s * p_engineConfiguration) {
+	UNUSED(p_engineConfiguration);
 }
 
 void resetConfigurationExt(engine_type_e engineType) {

firmware/controllers/algo/event_registry.h

@@ -23,8 +23,8 @@ struct AngleBasedEvent {
 
 	angle_t enginePhase;
 
-	void setAngle(angle_t enginePhase) {
-    	this->enginePhase = enginePhase;
+	void setAngle(angle_t p_enginePhase) {
+    	enginePhase = p_enginePhase;
     }
 
 	bool shouldSchedule(float currentPhase, float nextPhase) const;

firmware/controllers/algo/launch_control.cpp

@@ -138,15 +138,15 @@ bool LaunchControlBase::isLaunchFuelRpmRetardCondition() const {
 	return isLaunchRpmRetardCondition() && engineConfiguration->launchFuelCutEnable;
 }
 
-SoftSparkLimiter::SoftSparkLimiter(bool allowHardCut) {
-    this->allowHardCut = allowHardCut;
+SoftSparkLimiter::SoftSparkLimiter(bool p_allowHardCut) {
+    this->allowHardCut = p_allowHardCut;
 #if EFI_UNIT_TEST
     initLaunchControl();
 #endif // EFI_UNIT_TEST
 }
 
-void SoftSparkLimiter::setTargetSkipRatio(float targetSkipRatio) {
-	this->targetSkipRatio = targetSkipRatio;
+void SoftSparkLimiter::setTargetSkipRatio(float p_targetSkipRatio) {
+	this->targetSkipRatio = p_targetSkipRatio;
 }
 
 static tinymt32_t tinymt;

firmware/controllers/lua/can_filter.h

@@ -13,8 +13,8 @@ struct CanFilter {
 	int Bus;
 	int Callback;
 
-	bool accept(int Id) {
-	    return (Id & this->Mask) == this->Id;
+	bool accept(int p_Id) {
+	    return (p_Id & this->Mask) == Id;
 	}
 };
 

firmware/controllers/math/pid_auto_tune.cpp

@@ -97,11 +97,11 @@ double inline PID_AutoTune::fastArcTan(double x)
   return x / (1.0 + 0.28125 * pow(x, 2));
 }
 
-double PID_AutoTune::calculatePhaseLag(double inducedAmplitude)
+double PID_AutoTune::calculatePhaseLag(double p_inducedAmplitude)
 {
   // calculate phase lag
   // NB hysteresis = 2 * noiseBand;
-  double ratio = 2.0 * workingNoiseBand / inducedAmplitude;
+  double ratio = 2.0 * workingNoiseBand / p_inducedAmplitude;
   if (ratio > 1.0)
   {
     return CONST_PI / 2.0;
@@ -113,8 +113,8 @@ double PID_AutoTune::calculatePhaseLag(double inducedAmplitude)
   }
 }
 
-void PID_AutoTune::setState(PidAutoTune_AutoTunerState state) {
-	this->state = state;
+void PID_AutoTune::setState(PidAutoTune_AutoTunerState p_state) {
+	this->state = p_state;
 	efiPrintf("setState %s", getPidAutoTune_AutoTunerState(state));
 #if EFI_UNIT_TEST
 	if (verboseMode)
@@ -122,8 +122,8 @@ void PID_AutoTune::setState(PidAutoTune_AutoTunerState state) {
 #endif /* EFI_UNIT_TEST */
 }
 
-void PID_AutoTune::setPeakType(PidAutoTune_Peak peakType) {
-	this->peakType = peakType;
+void PID_AutoTune::setPeakType(PidAutoTune_Peak p_peakType) {
+	this->peakType = p_peakType;
 	efiPrintf("setPeakType %s", getPidAutoTune_Peak(peakType));
 #if EFI_UNIT_TEST
 	if (verboseMode)
@@ -134,10 +134,10 @@ void PID_AutoTune::setPeakType(PidAutoTune_Peak peakType) {
 /**
  * returns true when done, otherwise returns false
  */
-bool PID_AutoTune::Runtime(Logging *logger)
+bool PID_AutoTune::Runtime(Logging *p_logger)
 {
 
-	this->logger = logger; // a bit lazy but good enough
+	this->logger = p_logger; // a bit lazy but good enough
   // check ready for new input
   unsigned long now = getTimeNowMs();
 
@@ -821,8 +821,8 @@ float PID_AutoTune::GetKd() const
   return Kp * Td;
 }
 
-void PID_AutoTune::setOutput(float output) {
-	this->output = output;
+void PID_AutoTune::setOutput(float p_output) {
+	this->output = p_output;
 
 	efiPrintf("setOutput %f %s", output, getPidAutoTune_AutoTunerState(state));
 

firmware/controllers/math/pid_auto_tune.h

@@ -171,7 +171,7 @@ private:
   byte inputCount;
   float workingNoiseBand;
   float workingOutputstep;
-  float inducedAmplitude;
+//  float inducedAmplitude;
   float Kp, Ti, Td;
 
   // used by AMIGOf tuning rule

firmware/controllers/system/efi_output.h

@@ -12,8 +12,8 @@
 // This class acts as a boolean, but has a switch counter inside
 class SwitchedState {
 public:
-    SwitchedState(int8_t *state) {
-        this->state = state;
+    SwitchedState(int8_t *p_state) {
+        state = p_state;
     }
 
     // returns true if the state has been changed

firmware/controllers/system/timer/scheduler.h

@@ -14,13 +14,13 @@ public:
 	action_s() = default;
 
 	// Allow implicit conversion from schfunc_t to action_s
-	action_s(schfunc_t callback) : action_s(callback, nullptr) { }
-	action_s(schfunc_t callback, void *param) : callback(callback), param(param) { }
+	action_s(schfunc_t p_callback) : action_s(p_callback, nullptr) { }
+	action_s(schfunc_t p_callback, void *p_param) : callback(p_callback), param(p_param) { }
 
 	// Allow any function that takes a single pointer parameter, so long as param is also of the same pointer type.
 	// This constructor means you shouldn't ever have to cast to schfunc_t on your own.
 	template <typename TArg>
-	action_s(void (*callback)(TArg*), TArg* param) : callback((schfunc_t)callback), param(param) { }
+	action_s(void (*p_callback)(TArg*), TArg* p_param) : callback((schfunc_t)p_callback), param(p_param) { }
 
 	void execute();
 	schfunc_t getCallback() const;

firmware/hw_layer/drivers/can/can_msg_tx.h

@@ -94,7 +94,8 @@ class CanTxTyped final : public CanTxMessage
 #endif // EFI_CAN_SUPPORT
 
 public:
-	explicit CanTxTyped(CanCategory category, uint32_t id, bool isExtended, bool canChannel) : CanTxMessage(category, id, sizeof(TData), isExtended) { }
+// todo: unused 'canChannel'? BUG? https://github.com/rusefi/rusefi/issues/5675
+	explicit CanTxTyped(CanCategory p_category, uint32_t p_id, bool p_isExtended, bool canChannel) : CanTxMessage(p_category, p_id, sizeof(TData), p_isExtended) { }
 
 #if EFI_CAN_SUPPORT
 	/**