From 3a9593e6d8c7fadf46b446946f4312f4a98a6914 Mon Sep 17 00:00:00 2001 From: Romain Reignier Date: Mon, 12 Mar 2018 21:13:46 +0100 Subject: fatfs: update to latest ChibiOS changes --- os/various/fatfs_bindings/fatfs.mk | 2 +- os/various/fatfs_bindings/fatfs_diskio.c | 20 ++++++++++---------- 2 files changed, 11 insertions(+), 11 deletions(-) (limited to 'os/various') diff --git a/os/various/fatfs_bindings/fatfs.mk b/os/various/fatfs_bindings/fatfs.mk index 238037e..f2feeb5 100644 --- a/os/various/fatfs_bindings/fatfs.mk +++ b/os/various/fatfs_bindings/fatfs.mk @@ -2,6 +2,6 @@ FATFSSRC = ${CHIBIOS_CONTRIB}/os/various/fatfs_bindings/fatfs_diskio.c \ ${CHIBIOS}/os/various/fatfs_bindings/fatfs_syscall.c \ ${CHIBIOS}/ext/fatfs/src/ff.c \ - ${CHIBIOS}/ext/fatfs/src/option/unicode.c + $(CHIBIOS)/ext/fatfs/src/ffunicode.c FATFSINC = ${CHIBIOS}/ext/fatfs/src diff --git a/os/various/fatfs_bindings/fatfs_diskio.c b/os/various/fatfs_bindings/fatfs_diskio.c index 9fa41e2..80d1502 100644 --- a/os/various/fatfs_bindings/fatfs_diskio.c +++ b/os/various/fatfs_bindings/fatfs_diskio.c @@ -89,7 +89,7 @@ DSTATUS disk_initialize ( /* Return Disk Status */ DSTATUS disk_status ( - BYTE pdrv /* Physical drive nmuber (0..) */ + BYTE pdrv /* Physical drive number (0..) */ ) { DSTATUS stat; @@ -132,9 +132,9 @@ DSTATUS disk_status ( /* Read Sector(s) */ DRESULT disk_read ( - BYTE pdrv, /* Physical drive nmuber (0..) */ - BYTE *buff, /* Data buffer to store read data */ - DWORD sector, /* Sector address (LBA) */ + BYTE pdrv, /* Physical drive number (0..) */ + BYTE *buff, /* Data buffer to store read data */ + DWORD sector, /* Sector address (LBA) */ UINT count /* Number of sectors to read (1..255) */ ) { @@ -181,10 +181,10 @@ DRESULT disk_read ( /* Write Sector(s) */ DRESULT disk_write ( - BYTE pdrv, /* Physical drive nmuber (0..) */ - const BYTE *buff, /* Data to be written */ - DWORD sector, /* Sector address (LBA) */ - UINT count /* Number of sectors to write (1..255) */ + BYTE pdrv, /* Physical drive number (0..) */ + const BYTE *buff, /* Data to be written */ + DWORD sector, /* Sector address (LBA) */ + UINT count /* Number of sectors to write (1..255) */ ) { switch (pdrv) { @@ -232,8 +232,8 @@ DRESULT disk_write ( /* Miscellaneous Functions */ DRESULT disk_ioctl ( - BYTE pdrv, /* Physical drive nmuber (0..) */ - BYTE cmd, /* Control code */ + BYTE pdrv, /* Physical drive number (0..) */ + BYTE cmd, /* Control code */ void *buff /* Buffer to send/receive control data */ ) { -- cgit v1.2.3 From 345e218afd4f8009729dddc6eb541d8ec6a91565 Mon Sep 17 00:00:00 2001 From: Romain Reignier Date: Mon, 12 Mar 2018 21:27:50 +0100 Subject: lib_sci: FIX 'for' loop initial declarations are only allowed in C99 or C11 mode --- os/various/lib_scsi.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'os/various') diff --git a/os/various/lib_scsi.c b/os/various/lib_scsi.c index ea2adda..720a90f 100644 --- a/os/various/lib_scsi.c +++ b/os/various/lib_scsi.c @@ -364,7 +364,8 @@ static bool data_read_write10(SCSITarget *scsip, const uint8_t *cmd) { size_t bs = bdi.blk_size; uint8_t *buf = scsip->config->blkbuf; - for (size_t i=0; i Date: Thu, 22 Mar 2018 16:30:35 +0100 Subject: Adding PID library --- os/various/pid.c | 191 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ os/various/pid.h | 78 +++++++++++++++++++++++ 2 files changed, 269 insertions(+) create mode 100644 os/various/pid.c create mode 100644 os/various/pid.h (limited to 'os/various') diff --git a/os/various/pid.c b/os/various/pid.c new file mode 100644 index 0000000..fa9b92f --- /dev/null +++ b/os/various/pid.c @@ -0,0 +1,191 @@ +/********************************************************************************************** +* Arduino PID Library - Version 1.2.1 +* by Brett Beauregard brettbeauregard.com +* Modified by Fabien Poussin for ChibiOS. +* +* This Library is licensed under the MIT License +**********************************************************************************************/ + +#include "pid.h" +#include "osal.h" + +#define TIME_MS (osalOsGetSystemTimeX() / (OSAL_ST_FREQUENCY / 1000)) + +/*Constructor (...)********************************************************* +* The parameters specified here are those for for which we can't set up +* reliable defaults, so we need to have the user set them. +***************************************************************************/ +void pid_create(pid_t* p, float* Input, float* Output, float* Setpoint, + float Kp, float Ki, float Kd, int POn, int ControllerDirection) +{ + p->myOutput = Output; + p->myInput = Input; + p->mySetpoint = Setpoint; + p->inAuto = false; + + pid_setOutputLimits(p, 0, 255); // default output limit corresponds to + // the arduino pwm limits + + p->SampleTime = 100; // default Controller Sample Time is 100ms + + pid_setControllerDirection(p, ControllerDirection); + pid_setTunings(p, Kp, Ki, Kd, POn); + + p->lastTime = TIME_MS - p->SampleTime; +} + + +/* Compute() ********************************************************************** +* This, as they say, is where the magic happens. this function should be called +* every time "void loop()" executes. the function will decide for itself whether a new +* pid Output needs to be computed. returns true when the output is computed, +* false when nothing has been done. +**********************************************************************************/ +bool pid_compute(pid_t* p) +{ + if(!p->inAuto) return false; + unsigned long now = TIME_MS; + unsigned long timeChange = (now - p->lastTime); + if(timeChange >= p->SampleTime) + { + /* Compute all the working error variables */ + float input = *p->myInput; + float error = *p->mySetpoint - input; + float dInput = (input - p->lastInput); + p->outputSum += (p->ki * error); + + /* Add Proportional on Measurement, if P_ON_M is specified */ + if(!p->pOnE) p->outputSum -= p->kp * dInput; + + if(p->outputSum > p->outMax) p->outputSum = p->outMax; + else if(p->outputSum < p->outMin) p->outputSum = p->outMin; + + /* Add Proportional on Error, if P_ON_E is specified */ + float output; + if(p->pOnE) output = p->kp * error; + else output = 0; + + /* Compute Rest of PID Output */ + output += p->outputSum - p->kd * dInput; + + if(output > p->outMax) output = p->outMax; + else if(output < p->outMin) output = p->outMin; + *p->myOutput = output; + + /* Remember some variables for next time */ + p->lastInput = input; + p->lastTime = now; + return true; + } + else return false; +} + +/* SetTunings(...)************************************************************* +* This function allows the controller's dynamic performance to be adjusted. +* it's called automatically from the constructor, but tunings can also +* be adjusted on the fly during normal operation +******************************************************************************/ +void pid_setTunings(pid_t* p, float Kp, float Ki, float Kd, int POn) +{ + if (Kp<0 || Ki<0 || Kd<0) return; + + p->pOn = POn; + p->pOnE = POn == PID_P_ON_E; + + p->dispKp = Kp; p->dispKi = Ki; p->dispKd = Kd; + + float SampleTimeInSec = ((float)p->SampleTime)/1000; + p->kp = Kp; + p->ki = Ki * SampleTimeInSec; + p->kd = Kd / SampleTimeInSec; + + if(p->controllerDirection == PID_REVERSE) + { + p->kp = (0 - p->kp); + p->ki = (0 - p->ki); + p->kd = (0 - p->kd); + } +} + +/* SetSampleTime(...) ********************************************************* +* sets the period, in Milliseconds, at which the calculation is performed +******************************************************************************/ +void pid_setSampleTime(pid_t* p, int NewSampleTime) +{ + if (NewSampleTime > 0) + { + float ratio = (float)NewSampleTime / (float)p->SampleTime; + p->ki *= ratio; + p->kd /= ratio; + p->SampleTime = (unsigned long)NewSampleTime; + } +} + +/* SetOutputLimits(...)**************************************************** +* This function will be used far more often than SetInputLimits. while +* the input to the controller will generally be in the 0-1023 range (which is +* the default already,) the output will be a little different. maybe they'll +* be doing a time window and will need 0-8000 or something. or maybe they'll +* want to clamp it from 0-125. who knows. at any rate, that can all be done +* here. +**************************************************************************/ +void pid_setOutputLimits(pid_t* p, float Min, float Max) +{ + if(Min >= Max) return; + p->outMin = Min; + p->outMax = Max; + + if(p->inAuto) + { + if(*p->myOutput > p->outMax) *p->myOutput = p->outMax; + else if(*p->myOutput < p->outMin) *p->myOutput = p->outMin; + + if(p->outputSum > p->outMax) p->outputSum = p->outMax; + else if(p->outputSum < p->outMin) p->outputSum = p->outMin; + } +} + +/* SetMode(...)**************************************************************** +* Allows the controller Mode to be set to manual (0) or Automatic (non-zero) +* when the transition from manual to auto occurs, the controller is +* automatically initialized +******************************************************************************/ +void pid_setMode(pid_t* p, int Mode) +{ + bool newAuto = (Mode == PID_AUTOMATIC); + if(newAuto && !p->inAuto) + { /* we just went from manual to auto */ + pid_initialize(p); + } + p->inAuto = newAuto; +} + +/* Initialize()**************************************************************** +* does all the things that need to happen to ensure a bumpless transfer +* from manual to automatic mode. +******************************************************************************/ +void pid_initialize(pid_t* p) +{ + p->outputSum = *p->myOutput; + p->lastInput = *p->myInput; + if(p->outputSum > p->outMax) p->outputSum = p->outMax; + else if(p->outputSum < p->outMin) p->outputSum = p->outMin; +} + +/* SetControllerDirection(...)************************************************* +* The PID will either be connected to a DIRECT acting process (+Output leads +* to +Input) or a REVERSE acting process(+Output leads to -Input.) we need to +* know which one, because otherwise we may increase the output when we should +* be decreasing. This is called from the constructor. +******************************************************************************/ +void pid_setControllerDirection(pid_t* p, int Direction) +{ + if(p->inAuto && Direction != p->controllerDirection) + { + p->kp = (0 - p->kp); + p->ki = (0 - p->ki); + p->kd = (0 - p->kd); + } + p->controllerDirection = Direction; +} + diff --git a/os/various/pid.h b/os/various/pid.h new file mode 100644 index 0000000..d98df3e --- /dev/null +++ b/os/various/pid.h @@ -0,0 +1,78 @@ +#ifndef PID_h +#define PID_h + +#include "chtypes.h" + +//Constants used in some of the functions below +#define PID_AUTOMATIC 1 +#define PID_MANUAL 0 +#define PID_DIRECT 0 +#define PID_REVERSE 1 +#define PID_P_ON_M 0 +#define PID_P_ON_E 1 + + +typedef struct { + + float dispKp; // * we'll hold on to the tuning parameters in user-entered + float dispKi; // format for display purposes + float dispKd; // + + float kp; // * (P)roportional Tuning Parameter + float ki; // * (I)ntegral Tuning Parameter + float kd; // * (D)erivative Tuning Parameter + + int controllerDirection; + int pOn; + + float *myInput; // * Pointers to the Input, Output, and Setpoint variables + float *myOutput; // This creates a hard link between the variables and the + float *mySetpoint; // PID, freeing the user from having to constantly tell us + // what these values are. with pointers we'll just know. + unsigned long lastTime; + float outputSum; + float lastInput; + + unsigned long SampleTime; + float outMin; + float outMax; + + bool inAuto; + bool pOnE; + +} pid_t; + + +//commonly used functions ************************************************************************** +void pid_create(pid_t* p, float* Input, float* Output, float* Setpoint, // * constructor. links the PID to the Input, Output, and + float Kp, float Ki, float Kd, int POn, int ControllerDirection); // Setpoint. Initial tuning parameters are also set here. + // (overload for specifying proportional mode) + +void pid_setmode(pid_t* p, int mode); // * sets PID to either Manual (0) or Auto (non-0) + +bool pid_compute(pid_t* p); // * performs the PID calculation. it should be + // called every time loop() cycles. ON/OFF and + // calculation frequency can be set using SetMode + // SetSampleTime respectively + +void pid_setOutputLimits(pid_t* p, float Min, float Max); // * clamps the output to a specific range. 0-255 by default, but + // it's likely the user will want to change this depending on + // the application + + + +//available but not commonly used functions ******************************************************** +void pid_setTunings(pid_t* p, float Kp, float Ki, float Kd, int POn); // * While most users will set the tunings once in the + // constructor, this function gives the user the option + // of changing tunings during runtime for Adaptive control + +void pid_setControllerDirection(pid_t* p, int Direction); // * Sets the Direction, or "Action" of the controller. DIRECT + // means the output will increase when error is positive. REVERSE + // means the opposite. it's very unlikely that this will be needed + // once it is set in the constructor. +void pid_setSampleTime(pid_t* p, int NewSampleTime); // * sets the frequency, in Milliseconds, with which + // the PID calculation is performed. default is 100 + +void pid_initialize(pid_t* p); + +#endif -- cgit v1.2.3 From 12552897f32efc7448810c8ccd70d3c22dadccf7 Mon Sep 17 00:00:00 2001 From: Fabien Poussin Date: Thu, 22 Mar 2018 16:58:48 +0100 Subject: Cleaning PID lib. --- os/various/pid.c | 51 +++++++++++++++++++++++++++------------------------ os/various/pid.h | 34 +++++++++++++++++----------------- 2 files changed, 44 insertions(+), 41 deletions(-) (limited to 'os/various') diff --git a/os/various/pid.c b/os/various/pid.c index fa9b92f..07209ec 100644 --- a/os/various/pid.c +++ b/os/various/pid.c @@ -16,22 +16,23 @@ * reliable defaults, so we need to have the user set them. ***************************************************************************/ void pid_create(pid_t* p, float* Input, float* Output, float* Setpoint, - float Kp, float Ki, float Kd, int POn, int ControllerDirection) + float Kp, float Ki, float Kd, int POn, int Direction) { - p->myOutput = Output; - p->myInput = Input; - p->mySetpoint = Setpoint; + p->output = Output; + p->input = Input; + p->setPoint = Setpoint; p->inAuto = false; pid_setOutputLimits(p, 0, 255); // default output limit corresponds to // the arduino pwm limits - p->SampleTime = 100; // default Controller Sample Time is 100ms + p->sampleTime = 100; // default Controller Sample Time is 100ms - pid_setControllerDirection(p, ControllerDirection); + pid_setDirection(p, Direction); pid_setTunings(p, Kp, Ki, Kd, POn); + pid_initialize(p); - p->lastTime = TIME_MS - p->SampleTime; + p->lastTime = TIME_MS - p->sampleTime; } @@ -46,11 +47,11 @@ bool pid_compute(pid_t* p) if(!p->inAuto) return false; unsigned long now = TIME_MS; unsigned long timeChange = (now - p->lastTime); - if(timeChange >= p->SampleTime) + if(timeChange >= p->sampleTime) { /* Compute all the working error variables */ - float input = *p->myInput; - float error = *p->mySetpoint - input; + float input = *p->input; + float error = *p->setPoint - input; float dInput = (input - p->lastInput); p->outputSum += (p->ki * error); @@ -70,7 +71,7 @@ bool pid_compute(pid_t* p) if(output > p->outMax) output = p->outMax; else if(output < p->outMin) output = p->outMin; - *p->myOutput = output; + *p->output = output; /* Remember some variables for next time */ p->lastInput = input; @@ -87,19 +88,21 @@ bool pid_compute(pid_t* p) ******************************************************************************/ void pid_setTunings(pid_t* p, float Kp, float Ki, float Kd, int POn) { - if (Kp<0 || Ki<0 || Kd<0) return; + if (Kp < 0 || Ki < 0 || Kd < 0) return; p->pOn = POn; p->pOnE = POn == PID_P_ON_E; - p->dispKp = Kp; p->dispKi = Ki; p->dispKd = Kd; + p->dispKp = Kp; + p->dispKi = Ki; + p->dispKd = Kd; - float SampleTimeInSec = ((float)p->SampleTime)/1000; + float SampleTimeInSec = ((float)p->sampleTime) / 1000.0; p->kp = Kp; p->ki = Ki * SampleTimeInSec; p->kd = Kd / SampleTimeInSec; - if(p->controllerDirection == PID_REVERSE) + if(p->direction == PID_REVERSE) { p->kp = (0 - p->kp); p->ki = (0 - p->ki); @@ -114,10 +117,10 @@ void pid_setSampleTime(pid_t* p, int NewSampleTime) { if (NewSampleTime > 0) { - float ratio = (float)NewSampleTime / (float)p->SampleTime; + float ratio = (float)NewSampleTime / (float)p->sampleTime; p->ki *= ratio; p->kd /= ratio; - p->SampleTime = (unsigned long)NewSampleTime; + p->sampleTime = (unsigned long)NewSampleTime; } } @@ -137,8 +140,8 @@ void pid_setOutputLimits(pid_t* p, float Min, float Max) if(p->inAuto) { - if(*p->myOutput > p->outMax) *p->myOutput = p->outMax; - else if(*p->myOutput < p->outMin) *p->myOutput = p->outMin; + if(*p->output > p->outMax) *p->output = p->outMax; + else if(*p->output < p->outMin) *p->output = p->outMin; if(p->outputSum > p->outMax) p->outputSum = p->outMax; else if(p->outputSum < p->outMin) p->outputSum = p->outMin; @@ -166,8 +169,8 @@ void pid_setMode(pid_t* p, int Mode) ******************************************************************************/ void pid_initialize(pid_t* p) { - p->outputSum = *p->myOutput; - p->lastInput = *p->myInput; + p->outputSum = *p->output; + p->lastInput = *p->input; if(p->outputSum > p->outMax) p->outputSum = p->outMax; else if(p->outputSum < p->outMin) p->outputSum = p->outMin; } @@ -178,14 +181,14 @@ void pid_initialize(pid_t* p) * know which one, because otherwise we may increase the output when we should * be decreasing. This is called from the constructor. ******************************************************************************/ -void pid_setControllerDirection(pid_t* p, int Direction) +void pid_setDirection(pid_t* p, int Direction) { - if(p->inAuto && Direction != p->controllerDirection) + if(p->inAuto && Direction != p->direction) { p->kp = (0 - p->kp); p->ki = (0 - p->ki); p->kd = (0 - p->kd); } - p->controllerDirection = Direction; + p->direction = Direction; } diff --git a/os/various/pid.h b/os/various/pid.h index d98df3e..d20b35d 100644 --- a/os/various/pid.h +++ b/os/various/pid.h @@ -14,26 +14,26 @@ typedef struct { + float kp; // * (P)roportional Tuning Parameter + float ki; // * (I)ntegral Tuning Parameter + float kd; // * (D)erivative Tuning Parameter + float dispKp; // * we'll hold on to the tuning parameters in user-entered float dispKi; // format for display purposes float dispKd; // - - float kp; // * (P)roportional Tuning Parameter - float ki; // * (I)ntegral Tuning Parameter - float kd; // * (D)erivative Tuning Parameter - int controllerDirection; + int direction; int pOn; - float *myInput; // * Pointers to the Input, Output, and Setpoint variables - float *myOutput; // This creates a hard link between the variables and the - float *mySetpoint; // PID, freeing the user from having to constantly tell us - // what these values are. with pointers we'll just know. + float *input; // * Pointers to the Input, Output, and Setpoint variables + float *output; // This creates a hard link between the variables and the + float *setPoint; // PID, freeing the user from having to constantly tell us + // what these values are. with pointers we'll just know. unsigned long lastTime; float outputSum; float lastInput; - unsigned long SampleTime; + unsigned long sampleTime; float outMin; float outMax; @@ -45,15 +45,15 @@ typedef struct { //commonly used functions ************************************************************************** void pid_create(pid_t* p, float* Input, float* Output, float* Setpoint, // * constructor. links the PID to the Input, Output, and - float Kp, float Ki, float Kd, int POn, int ControllerDirection); // Setpoint. Initial tuning parameters are also set here. - // (overload for specifying proportional mode) + float Kp, float Ki, float Kd, int POn, int Direction); // Setpoint. Initial tuning parameters are also set here. + // (overload for specifying proportional mode) void pid_setmode(pid_t* p, int mode); // * sets PID to either Manual (0) or Auto (non-0) bool pid_compute(pid_t* p); // * performs the PID calculation. it should be // called every time loop() cycles. ON/OFF and // calculation frequency can be set using SetMode - // SetSampleTime respectively + // SetsampleTime respectively void pid_setOutputLimits(pid_t* p, float Min, float Max); // * clamps the output to a specific range. 0-255 by default, but // it's likely the user will want to change this depending on @@ -66,10 +66,10 @@ void pid_setTunings(pid_t* p, float Kp, float Ki, float Kd, int POn); // * Whil // constructor, this function gives the user the option // of changing tunings during runtime for Adaptive control -void pid_setControllerDirection(pid_t* p, int Direction); // * Sets the Direction, or "Action" of the controller. DIRECT - // means the output will increase when error is positive. REVERSE - // means the opposite. it's very unlikely that this will be needed - // once it is set in the constructor. +void pid_setDirection(pid_t* p, int Direction); // * Sets the Direction, or "Action" of the controller. DIRECT + // means the output will increase when error is positive. REVERSE + // means the opposite. it's very unlikely that this will be needed + // once it is set in the constructor. void pid_setSampleTime(pid_t* p, int NewSampleTime); // * sets the frequency, in Milliseconds, with which // the PID calculation is performed. default is 100 -- cgit v1.2.3 From 9e5aba8bd9da9fbba617f6abc95a4e1a2a841882 Mon Sep 17 00:00:00 2001 From: Fabien Poussin Date: Thu, 22 Mar 2018 18:16:20 +0100 Subject: Adding basic PID demo. --- os/various/pid.c | 4 ++-- os/various/pid.h | 6 +++--- 2 files changed, 5 insertions(+), 5 deletions(-) (limited to 'os/various') diff --git a/os/various/pid.c b/os/various/pid.c index 07209ec..f704b29 100644 --- a/os/various/pid.c +++ b/os/various/pid.c @@ -55,7 +55,7 @@ bool pid_compute(pid_t* p) float dInput = (input - p->lastInput); p->outputSum += (p->ki * error); - /* Add Proportional on Measurement, if P_ON_M is specified */ + /* Add Proportional on Measurement, if PID_ON_M is specified */ if(!p->pOnE) p->outputSum -= p->kp * dInput; if(p->outputSum > p->outMax) p->outputSum = p->outMax; @@ -91,7 +91,7 @@ void pid_setTunings(pid_t* p, float Kp, float Ki, float Kd, int POn) if (Kp < 0 || Ki < 0 || Kd < 0) return; p->pOn = POn; - p->pOnE = POn == PID_P_ON_E; + p->pOnE = POn == PID_ON_E; p->dispKp = Kp; p->dispKi = Ki; diff --git a/os/various/pid.h b/os/various/pid.h index d20b35d..74d116d 100644 --- a/os/various/pid.h +++ b/os/various/pid.h @@ -8,8 +8,8 @@ #define PID_MANUAL 0 #define PID_DIRECT 0 #define PID_REVERSE 1 -#define PID_P_ON_M 0 -#define PID_P_ON_E 1 +#define PID_ON_M 0 +#define PID_ON_E 1 typedef struct { @@ -48,7 +48,7 @@ void pid_create(pid_t* p, float* Input, float* Output, float* Setpoint, // * co float Kp, float Ki, float Kd, int POn, int Direction); // Setpoint. Initial tuning parameters are also set here. // (overload for specifying proportional mode) -void pid_setmode(pid_t* p, int mode); // * sets PID to either Manual (0) or Auto (non-0) +void pid_setMode(pid_t* p, int mode); // * sets PID to either Manual (0) or Auto (non-0) bool pid_compute(pid_t* p); // * performs the PID calculation. it should be // called every time loop() cycles. ON/OFF and -- cgit v1.2.3 From 71fe8e7ced20bbcea503e0ef22e155c09f63a1f7 Mon Sep 17 00:00:00 2001 From: Fabien Poussin Date: Sun, 25 Mar 2018 04:21:11 +0200 Subject: Renaming PID struct typedef to avoid conflicts --- os/various/pid.c | 22 +++++++++++----------- os/various/pid.h | 54 +++++++++++++++++++++++++++--------------------------- 2 files changed, 38 insertions(+), 38 deletions(-) (limited to 'os/various') diff --git a/os/various/pid.c b/os/various/pid.c index f704b29..fee9608 100644 --- a/os/various/pid.c +++ b/os/various/pid.c @@ -9,13 +9,13 @@ #include "pid.h" #include "osal.h" -#define TIME_MS (osalOsGetSystemTimeX() / (OSAL_ST_FREQUENCY / 1000)) +#define TIME_MS ((osalOsGetSystemTimeX() * 1000) / OSAL_ST_FREQUENCY ) /*Constructor (...)********************************************************* * The parameters specified here are those for for which we can't set up * reliable defaults, so we need to have the user set them. ***************************************************************************/ -void pid_create(pid_t* p, float* Input, float* Output, float* Setpoint, +void pid_create(pidc_t* p, float* Input, float* Output, float* Setpoint, float Kp, float Ki, float Kd, int POn, int Direction) { p->output = Output; @@ -23,8 +23,8 @@ void pid_create(pid_t* p, float* Input, float* Output, float* Setpoint, p->setPoint = Setpoint; p->inAuto = false; - pid_setOutputLimits(p, 0, 255); // default output limit corresponds to - // the arduino pwm limits + pid_setOutputLimits(p, 0, 4095); // default output limit corresponds to + // the 12 bit dac limit p->sampleTime = 100; // default Controller Sample Time is 100ms @@ -42,7 +42,7 @@ void pid_create(pid_t* p, float* Input, float* Output, float* Setpoint, * pid Output needs to be computed. returns true when the output is computed, * false when nothing has been done. **********************************************************************************/ -bool pid_compute(pid_t* p) +bool pid_compute(pidc_t* p) { if(!p->inAuto) return false; unsigned long now = TIME_MS; @@ -86,7 +86,7 @@ bool pid_compute(pid_t* p) * it's called automatically from the constructor, but tunings can also * be adjusted on the fly during normal operation ******************************************************************************/ -void pid_setTunings(pid_t* p, float Kp, float Ki, float Kd, int POn) +void pid_setTunings(pidc_t* p, float Kp, float Ki, float Kd, int POn) { if (Kp < 0 || Ki < 0 || Kd < 0) return; @@ -113,7 +113,7 @@ void pid_setTunings(pid_t* p, float Kp, float Ki, float Kd, int POn) /* SetSampleTime(...) ********************************************************* * sets the period, in Milliseconds, at which the calculation is performed ******************************************************************************/ -void pid_setSampleTime(pid_t* p, int NewSampleTime) +void pid_setSampleTime(pidc_t* p, int NewSampleTime) { if (NewSampleTime > 0) { @@ -132,7 +132,7 @@ void pid_setSampleTime(pid_t* p, int NewSampleTime) * want to clamp it from 0-125. who knows. at any rate, that can all be done * here. **************************************************************************/ -void pid_setOutputLimits(pid_t* p, float Min, float Max) +void pid_setOutputLimits(pidc_t* p, float Min, float Max) { if(Min >= Max) return; p->outMin = Min; @@ -153,7 +153,7 @@ void pid_setOutputLimits(pid_t* p, float Min, float Max) * when the transition from manual to auto occurs, the controller is * automatically initialized ******************************************************************************/ -void pid_setMode(pid_t* p, int Mode) +void pid_setMode(pidc_t* p, int Mode) { bool newAuto = (Mode == PID_AUTOMATIC); if(newAuto && !p->inAuto) @@ -167,7 +167,7 @@ void pid_setMode(pid_t* p, int Mode) * does all the things that need to happen to ensure a bumpless transfer * from manual to automatic mode. ******************************************************************************/ -void pid_initialize(pid_t* p) +void pid_initialize(pidc_t* p) { p->outputSum = *p->output; p->lastInput = *p->input; @@ -181,7 +181,7 @@ void pid_initialize(pid_t* p) * know which one, because otherwise we may increase the output when we should * be decreasing. This is called from the constructor. ******************************************************************************/ -void pid_setDirection(pid_t* p, int Direction) +void pid_setDirection(pidc_t* p, int Direction) { if(p->inAuto && Direction != p->direction) { diff --git a/os/various/pid.h b/os/various/pid.h index 74d116d..49ccd6f 100644 --- a/os/various/pid.h +++ b/os/various/pid.h @@ -13,11 +13,11 @@ typedef struct { - + float kp; // * (P)roportional Tuning Parameter float ki; // * (I)ntegral Tuning Parameter float kd; // * (D)erivative Tuning Parameter - + float dispKp; // * we'll hold on to the tuning parameters in user-entered float dispKi; // format for display purposes float dispKd; // @@ -36,43 +36,43 @@ typedef struct { unsigned long sampleTime; float outMin; float outMax; - + bool inAuto; bool pOnE; -} pid_t; +} pidc_t; //commonly used functions ************************************************************************** -void pid_create(pid_t* p, float* Input, float* Output, float* Setpoint, // * constructor. links the PID to the Input, Output, and - float Kp, float Ki, float Kd, int POn, int Direction); // Setpoint. Initial tuning parameters are also set here. - // (overload for specifying proportional mode) +void pid_create(pidc_t* p, float* Input, float* Output, float* Setpoint, // * constructor. links the PID to the Input, Output, and + float Kp, float Ki, float Kd, int POn, int Direction); // Setpoint. Initial tuning parameters are also set here. + // (overload for specifying proportional mode) -void pid_setMode(pid_t* p, int mode); // * sets PID to either Manual (0) or Auto (non-0) +void pid_setMode(pidc_t* p, int mode); // * sets PID to either Manual (0) or Auto (non-0) -bool pid_compute(pid_t* p); // * performs the PID calculation. it should be - // called every time loop() cycles. ON/OFF and - // calculation frequency can be set using SetMode - // SetsampleTime respectively +bool pid_compute(pidc_t* p); // * performs the PID calculation. it should be + // called every time loop() cycles. ON/OFF and + // calculation frequency can be set using SetMode + // SetsampleTime respectively -void pid_setOutputLimits(pid_t* p, float Min, float Max); // * clamps the output to a specific range. 0-255 by default, but - // it's likely the user will want to change this depending on - // the application +void pid_setOutputLimits(pidc_t* p, float Min, float Max); // * clamps the output to a specific range. 0-255 by default, but + // it's likely the user will want to change this depending on + // the application //available but not commonly used functions ******************************************************** -void pid_setTunings(pid_t* p, float Kp, float Ki, float Kd, int POn); // * While most users will set the tunings once in the - // constructor, this function gives the user the option - // of changing tunings during runtime for Adaptive control - -void pid_setDirection(pid_t* p, int Direction); // * Sets the Direction, or "Action" of the controller. DIRECT - // means the output will increase when error is positive. REVERSE - // means the opposite. it's very unlikely that this will be needed - // once it is set in the constructor. -void pid_setSampleTime(pid_t* p, int NewSampleTime); // * sets the frequency, in Milliseconds, with which - // the PID calculation is performed. default is 100 - -void pid_initialize(pid_t* p); +void pid_setTunings(pidc_t* p, float Kp, float Ki, float Kd, int POn); // * While most users will set the tunings once in the + // constructor, this function gives the user the option + // of changing tunings during runtime for Adaptive control + +void pid_setDirection(pidc_t* p, int Direction); // * Sets the Direction, or "Action" of the controller. DIRECT + // means the output will increase when error is positive. REVERSE + // means the opposite. it's very unlikely that this will be needed + // once it is set in the constructor. +void pid_setSampleTime(pidc_t* p, int NewSampleTime); // * sets the frequency, in Milliseconds, with which + // the PID calculation is performed. default is 100 + +void pid_initialize(pidc_t* p); #endif -- cgit v1.2.3