void mean_readings(void)
{
//Calculate mean of cell adc readings
float temp;
for (uint8_t x = 0; x < cellNumber; x++) temp += adcConvert(adcReadings[x], cellReading);
adcReadingsMean = temp / cellNumber;
}
/*
* Application entry point.
*/
int main(void) {
/*
* System initializations.
* - HAL initialization, this also initializes the configured device drivers
* and performs the board-specific initializations.
* - Kernel initialization, the main() function becomes a thread and the
* RTOS is active.
*/
halInit();
chSysInit();
/*
* Activates the ADC1 driver.
*/
adcStart(&ADCD1, &adccfg1);
while (1) {
/*
* ADC linear conversion.
*/
adcConvert(&ADCD1, &adcgrpcfg1, samples1, ADC_GRP1_BUF_DEPTH);
chThdSleepMilliseconds(500);
}
}
static THD_FUNCTION(m3pyro_continuity_thd, arg)
{
(void)arg;
while(true) {
adcsample_t sampbuf[5];
adcStart(&ADCD1, NULL);
msg_t result = adcConvert(&ADCD1, &adc_grp, sampbuf, 1);
adcStop(&ADCD1);
if(result != MSG_OK) {
m3status_set_error(M3PYRO_COMPONENT_CONTINUITY, M3PYRO_ERROR_ADC);
chThdSleepMilliseconds(500);
continue;
}
uint8_t continuities[4];
continuities[0] = adc_to_resistance(sampbuf[0]);
continuities[1] = adc_to_resistance(sampbuf[1]);
continuities[2] = adc_to_resistance(sampbuf[2]);
continuities[3] = adc_to_resistance(sampbuf[3]);
can_send(CAN_MSG_ID_M3PYRO_CONTINUITY, false,
continuities, sizeof(continuities));
uint8_t supply;
supply = adc_to_voltage(sampbuf[4]);
can_send(CAN_MSG_ID_M3PYRO_SUPPLY_STATUS, false,
&supply, 1);
m3status_set_ok(M3PYRO_COMPONENT_CONTINUITY);
chThdSleepMilliseconds(500);
}
}
void readADC(void)
{
uint32_t i;
char Result2[6];
adcConvert(&ADCD1, &adcgrpcfg1, samples1, ADC_GRP1_BUF_DEPTH);
ADC2status = 0;
sum=0;
for (i=0;i<=ADC_GRP1_BUF_DEPTH;i++){
//chprintf(chp, "%d ", samples1[i]);
sum += samples1[i];
}
sum = ((uint64_t)sum)*VREFINT/(ADC_GRP1_BUF_DEPTH/16*VREFMeasured/100);
sprintf ( Result, "%i", (uint16_t)sum/10000 ); // megadja a feszültség egész részét
sprintf ( Result2, ".%iV", (uint16_t)sum%10000 );
strncat(Result, Result2, 6);
gwinSetText(ADCvalue, Result, TRUE);
//prints the averaged value with 4 digits precision
chprintf((BaseSequentialStream *)&SD2, "\r\nMeasured: %U.%04UV", sum/10000, sum%10000);
/*
i = avg;
sprintf ( Result, "%i", i ); // %d makes the result be a decimal integer
for (i=0; i<=4; i++)
{
chprintf( (BaseSequentialStream *)&SD2, "%c", Result[i] );
}
chprintf( (BaseSequentialStream *)&SD2, "\r\n", NULL);
*/
}
/*
* Application entry point.
*/
int main(void) {
/*
* System initializations.
* - HAL initialization, this also initializes the configured device drivers
* and performs the board-specific initializations.
* - Kernel initialization, the main() function becomes a thread and the
* RTOS is active.
*/
halInit();
chSysInit();
/*
* Activates the serial driver 1 using the driver default configuration.
*/
palSetPadMode(IOPORT2, 0, PAL_MODE_OUTPUT_PUSHPULL);
sdStart(&SD1, NULL);
#define ADC_GRP1_NUM_CHANNELS 3
#define ADC_GRP1_BUF_DEPTH 10
DDRD |= _BV(DDD5);
static adcsample_t samples[ADC_GRP1_NUM_CHANNELS * ADC_GRP1_BUF_DEPTH];
static const ADCConversionGroup adcgrpcfg = {
FALSE,
ADC_GRP1_NUM_CHANNELS,
NULL,
0b00000111 /* enabled channels */
};
ADCConfig adccfg = {
ANALOG_REFERENCE_AVCC /* use the AVCC pin as the ADC reference voltage */
};
adcStart(&ADCD1, &adccfg);
palSetGroupMode(IOPORTADC, 0b00000111, 0, PAL_MODE_INPUT_PULLUP);
while(TRUE)
{
int i;
adcConvert(&ADCD1, &adcgrpcfg, samples, ADC_GRP1_BUF_DEPTH);
chprintf((BaseSequentialStream *) &SD1,"Result:\r\n");
for(i=0; i < (ADC_GRP1_BUF_DEPTH * ADC_GRP1_NUM_CHANNELS); i++) {
if((i % ADC_GRP1_NUM_CHANNELS) == 0) chprintf((BaseSequentialStream *) &SD1,"\r\n");
chprintf((BaseSequentialStream *) &SD1," %d", samples[i]);
}
chprintf((BaseSequentialStream *) &SD1,"\r\n");
chThdSleepMilliseconds(500);
palTogglePad(IOPORT2, PORTB_LED1);
}
}
uint16_t analog_read(uint8_t index)
{
msg_t result;
result = adcConvert (&ADCD1, &adcgrpcfg, samples, ADC_GRP1_BUF_DEPTH);
//TODO
return samples[index];
}
int main(void) {
halInit();
chSysInit();
/*
* ADC init
*/
palSetPadMode(GPIOA, 0, PAL_MODE_INPUT_ANALOG);
adcStart(&ADCD1, NULL);
/*
* Activates the serial driver 2 using the driver default configuration:
* 38400 bauds, 8bits, 1 stop-bit, no parity
*/
sdStart(&SD2, NULL);
palSetPadMode(GPIOC, 5, PAL_MODE_ALTERNATE(7));
palSetPadMode(GPIOC, 6, PAL_MODE_ALTERNATE(7));
/*
* Normal main() thread activity, in this demo it does nothing except
* sleeping in a loop and check the button state.
*/
while (TRUE)
{
/*
* single analog conversion
* converts ADC_GRP1_BUF_DEPTH samples and averages them
* with ADC_GRP1_BUF_DEPTH==2048 this gives around 14 bit precision
* even though the ADC hardware has only 12 bits internal precision
* also at 2048 samples the 14 bit are nearly noise free, while
* each sample is very noisy.
* WARNING: If you average to many samples, the variable containing
* the sum may overflow. That means that your readings will be wrong.
* However: With the ADC delivering a max value of 2^12, with uint32_t
* you can average 2^20 = 1048576 samples.
*/
uint32_t sum=0;
unsigned int i;
adcConvert(&ADCD1, &adcgrpcfg1, samples1, ADC_GRP1_BUF_DEPTH);
//prints the first measured value
chprintf((BaseSequentialStream *)&SD2, "Measured: %d ", samples1[0]*16);
sum=0;
for (i=0;i<ADC_GRP1_BUF_DEPTH;i++){
sum += samples1[i];
}
//prints the averaged value with two digits precision
chprintf((BaseSequentialStream *)&SD2, "%U\r\n", sum/(ADC_GRP1_BUF_DEPTH/16));
chThdSleepMilliseconds(500);
}
}
float
board_get_core_temp()
{
adcsample_t sample;
adcAcquireBus(&ADCD1);
adcConvert(&ADCD1, &core_temp_conv_grp, &sample, 1);
adcReleaseBus(&ADCD1);
return (float)((((float)sample - TS_CAL1_CNT) / TS_AVG_SLOPE) + TS_CAL1_TMP);
}
void uart_out(void)
{
char adcDisplay[4];
char cellDisplay;
//Outputs BMS information and measurements to computer
uart_puts("Start");
uart_putc('\n');
uart_putc(*utoa(cellNumber, &cellDisplay, 10));
uart_putc('\n');
for (uint8_t x = 0; x < cellNumber; x++)
{
uart_puts(dtostrf(adcConvert(adcReadings[x], cellReading), 4, 2, adcDisplay));
uart_putc('\n');
uart_putc(*utoa(balanceByte[x], &cellDisplay, 10));
uart_putc('\n');
}
uart_puts(dtostrf(adcConvert(adcReadings_I, mainReading), 4, 2, adcDisplay));
uart_putc('\n');
uart_putc(*utoa(charger, &cellDisplay, 10));
uart_putc('\n');
}
/*
* Application entry point.
*/
int main(void) {
/*
* System initializations.
* - HAL initialization, this also initializes the configured device drivers
* and performs the board-specific initializations.
* - Kernel initialization, the main() function becomes a thread and the
* RTOS is active.
*/
halInit();
chSysInit();
/*
* Setting up analog inputs used by the demo.
*/
palSetGroupMode(GPIOC, PAL_PORT_BIT(1) | PAL_PORT_BIT(2),
0, PAL_MODE_INPUT_ANALOG);
/*
* Creates the blinker thread.
*/
chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL);
/*
* Activates the ADC1 driver and the temperature sensor.
*/
adcStart(&ADCD1, NULL);
adcSTM32EnableTS(&ADCD1);
adcSTM32EnableVBAT(&ADCD1);
/*
* Linear conversion.
*/
adcConvert(&ADCD1, &adcgrpcfg1, samples1, ADC_GRP1_BUF_DEPTH);
chThdSleepMilliseconds(1000);
/*
* Starts an ADC continuous conversion.
*/
adcStartConversion(&ADCD1, &adcgrpcfg2, samples2, ADC_GRP2_BUF_DEPTH);
/*
* Normal main() thread activity, in this demo it does nothing.
*/
while (true) {
if (palReadPad(GPIOA, GPIOA_BUTTON)) {
adcStopConversion(&ADCD1);
}
chThdSleepMilliseconds(500);
}
}
/**
* @brief Reads out the X direction.
*
* @note The samples are median filtered for greater noise reduction
*
* @notapi
*/
uint16_t ts_lld_read_x(void) {
uint16_t val1, val2;
adcsample_t samples[ADC_NUM_CHANNELS * ADC_BUF_DEPTH];
palSetPadMode(ts->yd_port, ts->yd_pin, PAL_MODE_INPUT_ANALOG);
palSetPadMode(ts->yu_port, ts->yu_pin, PAL_MODE_INPUT_ANALOG);
palSetPadMode(ts->xl_port, ts->xl_pin, PAL_MODE_OUTPUT_PUSHPULL);
palSetPadMode(ts->xr_port, ts->xr_pin, PAL_MODE_OUTPUT_PUSHPULL);
palSetPad(ts->xl_port, ts->xl_pin);
palClearPad(ts->xr_port, ts->xr_pin);
chThdSleepMilliseconds(1);
adcConvert(ts->adc_driver, &adc_x_config, samples, ADC_BUF_DEPTH);
val1 = ((samples[0] + samples[1])/2);
palClearPad(ts->xl_port, ts->xl_pin);
palSetPad(ts->xr_port, ts->xr_pin);
chThdSleepMilliseconds(1);
adcConvert(ts->adc_driver, &adc_x_config, samples, ADC_BUF_DEPTH);
val2 = ((samples[0] + samples[1])/2);
return ((val1+((1<<12)-val2))/4);
}
/*
* Application entry point.
*/
int main(void) {
/*
* System initializations.
* - HAL initialization, this also initializes the configured device drivers
* and performs the board-specific initializations.
* - Kernel initialization, the main() function becomes a thread and the
* RTOS is active.
*/
halInit();
chSysInit();
/*
* Creates the blinker thread.
*/
chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL);
/*
* Activates the ADC1 driver, the temperature sensor and the VBat
* measurement.
*/
adcStart(&ADCD1, NULL);
adcSTM32Calibrate(&ADCD1);
adcSTM32EnableTSVREFE();
adcSTM32EnableVBATE();
/*
* Linear conversion.
*/
adcConvert(&ADCD1, &adcgrpcfg1, samples1, ADC_GRP1_BUF_DEPTH);
chThdSleepMilliseconds(1000);
/*
* Starts an ADC continuous conversion.
*/
adcStartConversion(&ADCD1, &adcgrpcfg2, samples2, ADC_GRP2_BUF_DEPTH);
/*
* Normal main() thread activity, in this demo it does nothing.
*/
while (TRUE) {
if (palReadPad(GPIOA, GPIOA_WKUP_BUTTON)) {
adcStopConversion(&ADCD1);
}
chThdSleepMilliseconds(500);
}
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
int i = 0, j = 0;
int addr;
//usb atjungimo kintamasis
bool usbDisabled = true;
//adc variables
float *result;
char mockResult[600];
char UARTTxPacket[100];
static short ultrasoundPacketTxMultiplier = 0;
static int ULTRASOUND_PACKET_COUNT = 100;
//usart state machine switch
uartSwitch = 'r';
//USB buffer variables
uint8_t buf[255],outstrg[100],inchar;
uint8_t len;
//dac variables
uint16_t waveform[32];
uint8_t continueReading = 1;
uint8_t intCount = 0;
uint8_t charCount = 0;
bool bufferReadSuccessful = false;
char tempString[4];
int cs;
volatile float a,b,elapsedtime,angle,radius,angleinc;
RCC_ClocksTypeDef RCC_Clocks;
// Initialize System and Setup clocks.
SystemInit();
SystemCoreClockUpdate();
//ini ADC
adcConfigure();
//init USART
USARTInit();
USART_puts(USART2, "P_Cmd\n\n");
//USARTSendByte();
//USARTReadByte();
/* SysTick end of count event each 40ms */
RCC_GetClocksFreq(&RCC_Clocks);
//SysTick_Config(RCC_Clocks.HCLK_Frequency /100);
// Initialize FPU
*((volatile unsigned long*)0xE000ED88) = 0xF << 20;
// Initialize LEDs and User_Button on STM32F4-Discovery
STM_EVAL_LEDInit(LED4);
STM_EVAL_LEDInit(LED3);
STM_EVAL_LEDInit(LED5);
STM_EVAL_LEDInit(LED6);
if(!usbDisabled){
// USB Device Initialize
USBD_Init(&USB_OTG_dev,
USB_OTG_FS_CORE_ID,
&USR_desc,
&USBD_CDC_cb,
&USR_cb);
// Wait for USB connection goes live
while (!gbUsbDeviceReady);
// Clean USB RX buffer
while(VCP_get_string(&buf[0]) == 0);
// Output signon
printf("USB serial DEMO\r\n");
printf("test\n\r>");
}
// Main loop
while(1) {
//SPI (WITH MSP) STATE MACHINE
if(uartSwitchGet() != 'r')
switch(uartSwitchGet()){
case 't': //cmd tx packet
for (i=0;i<600;i++)
mockResult[i] = i;
for(i=0;i<100;i++)
UARTTxPacket[i] = mockResult[i+ultrasoundPacketTxMultiplier];
txDataArrayToMsp(UARTTxPacket);
uartSwitchSet('r');
break;
case 'e':
//Delay(1000);
USART_puts(USART2, "P_End\n\n");
ultrasoundPacketTxMultiplier = 0;
uartSwitchSet('r');
break;
case 'c': //cmd_packet_received_msg.
ultrasoundPacketTxMultiplier++;
if (ultrasoundPacketTxMultiplier >= 10)
uartSwitchSet('e'); //finish transmission, or...
else
uartSwitchSet('r'); // prepare for the next packet
break;
default:
break;
}
if(!usbDisabled){
//USB COMM STATE MACHINE
inchar = GetCharnw();
if(inchar) {
switch (inchar){
case 'a':
result = adcConvert();
float* k;
uint16_t j;
//for (j=0;j<250;j++){
for(k=result;k<result+10/*28000*/;k++){
printf("%f \n",*k);
}
// }
break;
case 'd':
intCount = charCount = bufferReadSuccessful = 0;
while(continueReading){
for(i=0;i<rxbuflen;i++){
if(inbuf[i]!='d' && inbuf[i]!='e' && inbuf[i]!=' ' && continueReading == true){
tempString[charCount]=inbuf[i];
charCount++;
if(charCount==4){
waveform[intCount] = 0;
for(j=0;j<4;j++)
waveform[intCount] += (int)(tempString[j]-'0')*pow(10,3-j);
intCount++;
charCount = 0;
}
}
if(inbuf[i]=='e'||intCount == 32) { continueReading = 0; bufferReadSuccessful = true;}
}
rxbuflen = 0;
char inchar = GetCharnw();
}
if(bufferReadSuccessful)DAC_SignalsGenerate(&waveform);
break;
case 's':
printf("\n\rF4 Discovery Test V0.55\n\r>");
break;
case 't':
printf("\n\rDo 10000 circular interpolation calculations\n\r");
TimingDelay4 = 10000;
angle = 0.125;
radius = 2.56;
angleinc = 0.0001;
for(i=0; i<100000; i++) {
a = radius * sinf(angle);
b = radius * cosf(angle);
angle += angleinc;
}
elapsedtime = ((float)(10000 - TimingDelay4))/25.0;
printf("timing delay=%d\n\r",TimingDelay4);
printf("Single precision finished in %f seconds or %f usec/loop\n\r",elapsedtime,elapsedtime*10.0);
TimingDelay4 = 10000;
angle = 0.125;
radius = 2.56;
angleinc = 0.0001;
for(i=0; i<100000; i++) {
a = radius * sinfp(angle);
b = radius * cosfp(angle);
angle += angleinc;
}
elapsedtime = ((float)(10000 - TimingDelay4))/25.0;
printf("timing delay=%d\n\r",TimingDelay4);
printf("Single prec fp finished in %f seconds or %f usec/loop\n\r",elapsedtime,elapsedtime*10.0);
TimingDelay4 = 10000;
angle = 0.125;
radius = 2.56;
angleinc = 0.0001;
printf("angle=%f radius=%f angleinc=%f\n\r",angle,radius,angleinc);
for(i=0; i<100000; i++) {
a = radius * sin(angle);
b = radius * cos(angle);
angle += angleinc;
}
printf("timing delay=%d\n\r",TimingDelay4);
elapsedtime = ((float)(10000 - TimingDelay4))/25.0;
printf("Double precision finished in %f seconds or %f usec/loop\n\r>",elapsedtime,elapsedtime*10.0);
break;
case 'f':
printf("f\n\rTry float output: 1.234\n\r");
a = 1.234;
printf("a = %f\n\r",a);
i = 35;
printf("i = %d\n\r",i);
a = 35.45;
printf("a = %f\n\r",a);
printf("a = %f\n\r",12.345);
printf("a = %f\n\r",-12.345);
printf("i = %d\n\r",i);
break;
case 'g':
printf("d\n\rRCC_Clocks.HCLK_Frequency=%ld",RCC_Clocks.HCLK_Frequency);
printf("\n\rDelay 2 second\n\r");
Delay(200);
printf("finished\n\r>");
break;
case CR:
printf("\n\r>");
break;
default:
printf("%c\n\r>",inchar);
break;
}
}
}
if (i == 0x100000) {
STM_EVAL_LEDOff(LED4);
STM_EVAL_LEDOff(LED3);
STM_EVAL_LEDOff(LED5);
STM_EVAL_LEDOff(LED6);
}
if (i++ == 0x200000) {
i = 0;
STM_EVAL_LEDOn(LED4);
STM_EVAL_LEDOn(LED3);
STM_EVAL_LEDOn(LED5);
STM_EVAL_LEDOn(LED6);
}
}
}
/**
* @brief This is the pressure control thread
* @param void* to a PID Loops configuration
* @retval msg_t status
*/
msg_t Pressure_Thread(void *This_Config) {
/* This thread is passed a pointer to a PID loop configuration */
PID_State Pressure_PID_Controllers[((Pressure_Config_Type*)This_Config)->Number_Setpoints];
memset(Pressure_PID_Controllers,0,((Pressure_Config_Type*)This_Config)->Number_Setpoints*sizeof(PID_State));/* Initialise as zeros */
float* Last_PID_Out=(float*)chHeapAlloc(NULL,sizeof(float)*((Pressure_Config_Type*)This_Config)->Number_Setpoints);/* PID output for interpol */
adcsample_t Pressure_Samples[PRESSURE_SAMPLES],Pressure_Sample;/* Use multiple pressure samples to drive down the noise */
float PID_Out,Pressure;//,step=0.01,sawtooth=0.7;
uint32_t Setpoint=0;
uint8_t Old_Setpoint=0, Previous_Setpoint;
chRegSetThreadName("PID_Pressure");
//palSetGroupMode(GPIOC, PAL_PORT_BIT(5) | PAL_PORT_BIT(4), 0, PAL_MODE_INPUT_ANALOG);
palSetPadMode(GPIOE, 9, PAL_MODE_ALTERNATE(1)); /* Only set the pin as AF output here, so as to avoid solenoid getting driven earlier*/
palSetPadMode(GPIOE, 11, PAL_MODE_ALTERNATE(1)); /* Experimental servo output here */
#ifndef USE_SERVO
/*
* Activates the PWM driver
*/
pwmStart(&PWM_Driver_Solenoid, &PWM_Config_Solenoid); /* Have to define the timer to use for PWM_Driver in hardware config */
/*
* Set the solenoid PWM to off
*/
pwmEnableChannel(&PWM_Driver_Solenoid, (pwmchannel_t)PWM_CHANNEL_SOLENOID, (pwmcnt_t)0);
#else
/*
* Activates the experimental servo driver
*/
pwmStart(&PWM_Driver_Servo, &PWM_Config_Servo); /* Have to define the timer to use for PWM_Driver in hardware config */
#endif
/*
* Activates the ADC2 driver *and the thermal sensor*.
*/
adcStart(&ADCD2, NULL);
//adcSTM32EnableTSVREFE();
/*
/ Now we run the sensor offset calibration loop
*/
do {
adcConvert(&ADCD2, &adcgrpcfg1, &Pressure_Sample, 1);/* This function blocks until it has one sample*/
} while(Calibrate_Sensor((uint16_t)Pressure_Sample));
systime_t time = chTimeNow(); /* T0 */
systime_t Interpolation_Timeout = time; /* Set to T0 to show there is no current interpolation */
/* Loop for the pressure control thread */
while(TRUE) {
/*
* Linear conversion.
*/
adcConvert(&ADCD2, &adcgrpcfg1, Pressure_Samples, PRESSURE_SAMPLES);/* This function blocks until it has the samples via DMA*/
/*
/ Now we process the data and apply the PID controller - we use a median filter to take out the non guassian noise
*/
Pressure_Sample = quick_select(Pressure_Samples, PRESSURE_SAMPLES);
Pressure = Convert_Pressure((uint16_t)Pressure_Sample);/* Converts to PSI as a float */
/* Retrieve a new setpoint from the setpoint mailbox, only continue if we get it*/
if(chMBFetch(&Pressures_Setpoint, (msg_t*)&Setpoint, TIME_IMMEDIATE) == RDY_OK) {
//Pressure=Run_Pressure_Filter(Pressure);/* Square root raised cosine filter for low pass with minimal lag */
Pressure = Pressure<0?0.0:Pressure; /* A negative pressure is impossible with current hardware setup - disregard*/
Setpoint &= 0x000000FF;
/* The controller is built around an interpolated array of independant PID controllers with seperate setpoints */
if(Setpoint != Old_Setpoint) { /* The setpoint has changed */
Previous_Setpoint = Old_Setpoint;/* This is for use by the interpolator */
Old_Setpoint = Setpoint; /* Store the setpoint */
/* Store the time at which the interpolation to new setpoint completes*/
Interpolation_Timeout = time + (systime_t)( 4.0 / ((Pressure_Config_Type*)This_Config)->Interpolation_Base );
}
if(Interpolation_Timeout > time) { /* If we have an ongoing interpolation - note, operates in tick units */
/* Value goes from 1 to -1 */
float interpol = erff( (float)(Interpolation_Timeout - time) *\
((Pressure_Config_Type*)This_Config)->Interpolation_Base - 2.0 );/* erf function interpolator */
interpol = ( (-interpol + 1.0) / 2.0);/* Interpolation value goes from 0 to 1 */
PID_Out = ( Last_PID_Out[Previous_Setpoint] * (1.0 - interpol) ) + ( Last_PID_Out[Setpoint] * interpol );
Pressure_PID_Controllers[Setpoint].Last_Input = Pressure;/* Make sure the input to next PID controller is continuous */
}
else {
PID_Out = Run_PID_Loop( ((Pressure_Config_Type*)This_Config)->PID_Loop_Config, &Pressure_PID_Controllers[Setpoint],\
(((Pressure_Config_Type*)This_Config)->Setpoints)[Setpoint], \
Pressure, (float)PRESSURE_TIME_INTERVAL/1000.0);/* Run PID */
Last_PID_Out[Setpoint] = PID_Out;/* Store for use by the interpolator */
}
}
else
PID_Out=0; /* So we can turn off the solenoid simply by failing to send Setpoints */
PID_Out=PID_Out>1.0?1.0:PID_Out;
PID_Out=PID_Out<0.0?0.0:PID_Out; /* Enforce range limits on the PID output */
//sawtooth+=step; /* Test code for debugging mechanics with a sawtooth */
//if(sawtooth>=1 || sawtooth<=0.65)
// step=-step;
//PID_Out=sawtooth;
#ifndef USE_SERVO
/*
/ Now we apply the PID output to the PWM based solenoid controller, and feed data into the mailbox output - Note fractional input
*/
pwmEnableChannel(&PWM_Driver_Solenoid, (pwmchannel_t)PWM_CHANNEL_SOLENOID, (pwmcnt_t)PWM_FRACTION_TO_WIDTH(&PWM_Driver_Solenoid, 1000\
, (uint32_t)(1000.0*PID_Out)));
#else
pwmEnableChannel(&PWM_Driver_Servo, (pwmchannel_t)PWM_CHANNEL_SERVO, (pwmcnt_t)PWM_FRACTION_TO_WIDTH(&PWM_Driver_Servo, 10000\
, (uint32_t)(1000.0*(PID_Out+1.0))));
#endif
chMBPost(&Pressures_Reported, *((msg_t*)&Pressure), TIME_IMMEDIATE);/* Non blocking write attempt to the Reported Pressure mailbox FIFO */
/*
/ The Thread is syncronised to system time
*/
time += MS2ST(PRESSURE_TIME_INTERVAL); /* Next deadline */
chThdSleepUntil(time); /* Gives us a thread with regular timing */
}
}
THD_FUNCTION(Thread1, arg) {
(void)arg;
/*
* Activate the serial driver 0 using the driver default configuration.
*/
sdStart(&SD1, NULL);
/* Activate the ADC driver 1 using its config */
adcStart(&ADCD1, &config);
while (chnGetTimeout(&SD1, TIME_INFINITE)) {
print(start_msg);
chThdSleepMilliseconds(2000);
/* Test 1 - 1ch1d, no circular */
run_test(test_1_msg, 1, 1, false);
/* Test 2 - 1ch8d, no circular */
run_test(test_2_msg, 1, 8, false);
/* Test 3 - 4chd1, no circular */
run_test(test_3_msg, 4, 1, false);
/* Test 4 - 4ch8d, no circular */
run_test(test_4_msg, 4, 8, false);
/* Test 5 - 1ch1d, circular */
run_test(test_5_msg, 1, 1, true);
/* Test 6 - 1ch8d, circular */
run_test(test_6_msg, 1, 8, true);
/* Test 7 - 4ch1d, circular */
run_test(test_7_msg, 4, 1, true);
/* Test 8 - 4ch8d, circular */
run_test(test_8_msg, 4, 8, true);
/* Test 9 - 1ch1d, synchronous */
print(test_9_msg);
cb_arg = 0;
group.num_channels = 1;
group.circular = false;
group.end_cb = adc_callback;
cb_expect = 1;
adcConvert(&ADCD1, &group, buffer, 1);
while (ADCD1.state == ADC_ACTIVE) ;
sniprintf(out_string, 128, chn_fmt_string, group.channels[0]);
print(out_string);
sniprintf(out_string, 128, raw_fmt_string, buffer[0]);
print(out_string);
buffer[0] = adcMSP430XAdjustTemp(&group, buffer[0]);
sniprintf(out_string, 128, cooked_fmt_string, buffer[0]);
print(out_string);
if (cb_arg == cb_expect) {
print(success_string);
}
else {
print(fail_string);
}
}
}
