//Enables the peripherals associated with the strain amplifier and
//sets the default values.
//Make sure that you initialize I2C1 first!
void init_strain(void)
{
int i = 0, j = 0;
//Array prep:
//=-=-=-=-=-=
init_adc_delsig_dma_array();
//Peripherals:
//=-=-=-=-=-=
//16-bits ADC:
ADC_DelSig_1_Start();
//ADC_DelSig_1_IRQ_Enable();
dma_2_config();
isr_delsig_StartEx(isr_delsig_Interrupt_InterruptCallback);
//Defaults:
//=-=-=-=-=-=
for(i = 0; i < STRAIN_CHANNELS; i++)
{
strain[i].offset = STRAIN_DEFAULT_OFFSET;
for(j = 0; j < STRAIN_BUF_LEN; j++)
{
strain[i].strain_raw[j] = 0;
}
strain[i].strain_filtered = 0;
strain_config(i, strain[i].offset);
}
ADC_DelSig_1_StartConvert();
}
/*******************************************************************************
* Function Name: main
********************************************************************************
*
* Summary:
* main() performs following functions:
* 1: Initializes the LCD
* 2: Starts ADC
* 3: Starts ADC converstion.
* 4: Gets the converted result and displays it in LCD.
*
* Parameters:
* None.
*
* Return:
* None.
*
*******************************************************************************/
int main()
{
int16 output;
/* Start the components */
LCD_Start();
ADC_DelSig_1_Start();
/* Start the ADC conversion */
ADC_DelSig_1_StartConvert();
/* Display the value of ADC output on LCD */
LCD_Position(0u, 0u);
LCD_PrintString("ADC_Output");
for(;;)
{
if(ADC_DelSig_1_IsEndConversion(ADC_DelSig_1_RETURN_STATUS))
{
output = ADC_DelSig_1_GetResult16();
/* Saturate ADC result to positive numbers. */
if(output < 0)
{
output = 0;
}
LCD_Position(1u, 0u);
LCD_PrintInt16(output);
}
}
}
/*******************************************************************************
* 初始化函数
********************************************************************************/
void init()
{
CyGlobalIntEnable; //全局中断开启
ADC_DelSig_1_Start(); /* 配置并开启ADC */
ADC_DelSig_1_StartConvert(); /* 开始进行转换 */
Uart_Rx_ISR_StartEx(RxInterruptHandler); /* 开启 Uart Rx 中断 并连接到 RxInterruptHandler */
Uart_Tx_ISR_StartEx(TxInterruptHandler); /* 开启 Uart Tx 并连接到 TxInterruptHandler */
UART_Start(); /* 开启 UART */
Uart_Rx_ISR_1_StartEx(Rx_1_InterruptHandler); /* 开启 Uart Rx 中断 并连接到 RxInterruptHandler */
Uart_Tx_ISR_1_StartEx(Tx_1_InterruptHandler); /* 开启 Uart Tx 并连接到 TxInterruptHandler */
UART_1_Start(); /* 开启 UART1 */
Uart_Rx_ISR_2_StartEx(Rx_1_InterruptHandler); /* 开启 Uart Rx 中断 并连接到 RxInterruptHandler */
Uart_Tx_ISR_2_StartEx(Tx_1_InterruptHandler); /* 开启 Uart Tx 并连接到 TxInterruptHandler */
UART_2_Start(); /* 开启 UART2 */
Timer_ISR_StartEx(TimerInterruptHandler); /* 开启 Timer 中断并连接到 TimerInterruptHandler */
Timer_Start(); /* 开启定时器 */
LCD_Char_1_Start(); /* 初始化并清除LCD */
//LCD_Char_1_PrintString("init");
}
//Case 3: Strain Gauge DelSig ADC, SAR ADC
void main_fsm_case_3(void)
{
//Start a new conversion
ADC_DelSig_1_StartConvert();
//Filter the previous results
strain_filter_dma();
}
/*******************************************************************************
* Function Name: ADC_DelSig_1_Wakeup
********************************************************************************
*
* Summary:
* Restores the user configuration and enables the power to the block.
*
* Parameters:
* None
*
* Return:
* None
*
* Global variables:
* ADC_DelSig_1_backup: The structure field 'enableState' is used to
* restore the enable state of block after wakeup from sleep mode.
*
*******************************************************************************/
void ADC_DelSig_1_Wakeup(void)
{
/* Restore the configuration */
ADC_DelSig_1_RestoreConfig();
/* Enables the component operation */
if(ADC_DelSig_1_backup.enableState != ADC_DelSig_1_DISABLED)
{
ADC_DelSig_1_Enable();
if((ADC_DelSig_1_backup.enableState & ADC_DelSig_1_STARTED) != 0u)
{
ADC_DelSig_1_StartConvert();
}
} /* Do nothing if component was disable before */
}
/*******************************************************************************
* Function Name: ADC_DelSig_1_Wakeup
********************************************************************************
*
* Summary:
* Restores the user configuration and enables the power to the block.
*
* Parameters:
* void
*
* Return:
* void
*
* Global variables:
* ADC_DelSig_1_backup: The structure field 'enableState' is used to
* restore the enable state of block after wakeup from sleep mode.
*
*******************************************************************************/
void ADC_DelSig_1_Wakeup(void)
{
/* Restore the configuration */
ADC_DelSig_1_RestoreConfig();
/* Enable's the component operation */
if(ADC_DelSig_1_backup.enableState == ADC_DelSig_1_ENABLED)
{
ADC_DelSig_1_Enable();
/* Start the conversion only if conversion is not triggered by the hardware */
if(!(ADC_DelSig_1_DEC_CR_REG & ADC_DelSig_1_DEC_XSTART_EN))
{
ADC_DelSig_1_StartConvert();
}
} /* Do nothing if component was disable before */
}
void main()
{
/* Place your initialization/startup code here (e.g. MyInst_Start()) */
Opamp_1_Start();
Opamp_3_Start();
Clock_1_Start();
ADC_DelSig_1_Start();
ADC_DelSig_1_StartConvert();
VDAC8_1_Start();
VDAC8_2_Start();
CyGlobalIntEnable; /* Uncomment this line to enable global interrupts. */
isr_StartEx(filterVDAC);
for(;;)
{
/* Place your application code here. */
}
}
/*main*/
void main(void)
{
/*Preliminary parts not important*/
LCD_Char_1_Start();
ADC_DelSig_1_Start();
ADC_DelSig_1_StartConvert();
Configure_DMA();
isr_1_StartEx(Buffer_complete);
isr_2_StartEx(LPF_buffer_complete);
ADC_DelSig_1_SetCoherency(ADC_DelSig_1_COHER_MID);
Filter_SetDalign(Filter_STAGEA_DALIGN,Filter_ENABLED);
Filter_SetDalign(Filter_HOLDA_DALIGN,Filter_ENABLED);
Filter_SetCoherency(Filter_STAGEA_COHER,Filter_KEY_MID);
Filter_SetCoherency(Filter_HOLDA_COHER,Filter_KEY_MID);
Filter_SetCoherency(Filter_CHANNEL_A,Filter_KEY_MID);
Filter_SetDalign(Filter_STAGEB_DALIGN,Filter_ENABLED);
Filter_SetDalign(Filter_HOLDB_DALIGN,Filter_ENABLED);
Filter_SetCoherency(Filter_STAGEB_COHER,Filter_KEY_MID);
Filter_SetCoherency(Filter_HOLDB_COHER,Filter_KEY_MID);
Filter_SetCoherency(Filter_CHANNEL_B,Filter_KEY_MID);
CyGlobalIntEnable;
Filter_Start();
/*Writes ADC values to ADC_samples array*/
while(1){
if (isr_BC_flag==1){
arm_cfft_q15(&arm_cfft_sR_q15_len256, Buffer_samples, 0, 1);
arm_cmplx_mag_q15(Buffer_samples, magoutput, fftlength);
CyDmaChEnable(DMA_2_Chan, 1);
isr_BC_flag=0;
isr_1_ClearPending();
}
}
}
void main()
{
uint8 state, var_mask, ADC_in, auto_mode, continous_mode;
uint8 DigitsPrecision, MaximumWeight;
int16 MaxAvgReading = null, \
MinAvgReading = null, \
ScaledRange = null;
//uint8 Digit[5], ScaledRange, LastFractionResult, Remainder;
/* Start the components */
ADC_DelSig_1_Start();
//ADC_DelSig_1_IRQ_Start(); //disable for manual polling instead so can single step
CYGlobalIntEnable; //enable for ADC and USB interrupts
/* Start the ADC conversion */
ADC_DelSig_1_StartConvert();
ADC_DelSig_1_IRQ_Disable(); //disable for manual polling instead so can single step
/* Start USBFS Operation with 5V operation */
USBFS_1_Start(0u, USBFS_1_5V_OPERATION); //USBFS_1_5V_OPERATION);
/* Wait for Device to enumerate i.e. detects USB settings from host PC */
while(USBFS_1_GetConfiguration() != 0u);
/* Enumeration is done, enable OUT endpoint for receive data from Host */
USBFS_1_EnableOutEP(OUT_EP);
state=0u;
for(;;) // this is infinite state loop
{
if(state==0u)
{
/* Check that configuration is changed (there is only one configured on the USBFS )*/
if(USBFS_1_IsConfigurationChanged() != 0u)
{
/* Re-enable endpoint when device is configured */
if(USBFS_1_GetConfiguration() != 0u)
{
USBFS_1_EnableOutEP(OUT_EP);
}
}
/* GET MODE STATE Read USB PC host application*/
if(USBFS_1_GetEPState(OUT_EP) == USBFS_1_OUT_BUFFER_FULL)
{
/* Read received bytes count */
length = USBFS_1_GetEPCount(OUT_EP);
/* Unload the OUT buffer */
USBFS_1_ReadOutEP(OUT_EP, &in_buffer[0u], length);
state= in_buffer[MODE_BYTE];
var_mask=in_buffer[SET_VARS_MASK_BYTE];
if(var_mask & CONTINOUS_MODE_MASK_BIT)
continous_mode = TRUE;
else
continous_mode = FALSE;
}
}
if(state & INIT_SCALE_VARS)
{
if(var_mask & MAX_WEIGHT_VAR_MASK_BIT)
MaximumWeight=in_buffer[MAX_WEIGHT_VAR_BYTE];
if(MaximumWeight<MIN_WEIGHT_SCALE)
MaximumWeight=MIN_WEIGHT_SCALE;
if(MaximumWeight>MAX_WEIGHT_SCALE)
MaximumWeight=MAX_WEIGHT_SCALE;
if(var_mask & PRECISION_VAR_MASK_BIT)
DigitsPrecision=in_buffer[PRECISION_VAR_BYTE];
if(DigitsPrecision<MIN_PRECISION_DIGITS)
DigitsPrecision=MIN_PRECISION_DIGITS;
if(DigitsPrecision>MAX_PRECISION_DIGITS)
DigitsPrecision=MAX_PRECISION_DIGITS;
if(var_mask & AUTO_MODE_MASK_BIT)
auto_mode=TRUE;
else
auto_mode=FALSE;
state=0u;
}
if(state & GET_SCALE_LOW_LIMIT)
{
MinAvgReading = get_adc_average(NUMBER_SAMPLES);
clear_buffer(out_buffer,BUF_SIZE);
out_buffer[0u]=(uint8)MinAvgReading;
//respond with min avg adc value (this requires host request)
SendOutData(out_buffer);
state=0u;
}
if(state & GET_SCALE_HIGH_LIMIT)
{
MaxAvgReading = get_adc_average(NUMBER_SAMPLES);
clear_buffer(out_buffer,BUF_SIZE);
out_buffer[0u]=(uint8)MaxAvgReading;
//respond with max avg adc value (this requires host request)
SendOutData(out_buffer);
state=0u;
}
if(state & SEND_SCALE_WEIGHT)
{
do
{
//this flag tests if the ADC interrupt occurred meaning data is ready
adc_flag=Status_Reg_1_Read(); //note the interrupt is disabled so read EOC bit instead
if(adc_flag==1u)
{
ADC_in=ADC_DelSig_1_GetResult8(); //read adc byte
adc_flag=0u;
clear_buffer(out_buffer,BUF_SIZE);
if(auto_mode==FALSE)
calculate_fixed_weight(ADC_in, out_buffer);
if(auto_mode==TRUE)
if( (MaxAvgReading == null) || (MinAvgReading == null) )
// Send Error Message
continue;
ScaledRange = (MaxAvgReading - MinAvgReading) / MaximumWeight;
calculate_scaled_weight(ADC_in, out_buffer, ScaledRange);
//send weight data (this requires host request)
SendOutData(out_buffer);
}
}while(USBFS_1_GetEPState(OUT_EP) != USBFS_1_OUT_BUFFER_FULL \
&& continous_mode == TRUE);
state=0u;
}
}
}
uint8 campbell_cond_br_read(float* Rs){
uint8 i, chan = 0u;
AMux_1_Select(chan);
// if i == 5, Mux could not be reset to 0
ADC_DelSig_1_StartConvert();
CyDelay(1u);
for (i = 0u; i < 100; i++) {
if(ADC_DelSig_1_IsEndConversion(ADC_DelSig_1_RETURN_STATUS)){
if (chan == 0)
{
ADC_DelSig_1_StopConvert(); // Stop the conversion so signals don't
// get mixed when switching the mux
chan = 1u;
AMux_1_Select(chan);
res1 = ADC_DelSig_1_GetResult16();
dvpp = ADC_DelSig_1_CountsTo_Volts(res1) ;
CyDelay(1u);
ADC_DelSig_1_StartConvert();
CyDelay(49u);
}
else {
ADC_DelSig_1_StopConvert(); // Stop the conversion so signals don't
// get mixed when switching the mux
AMux_1_DisconnectAll();
res2 = ADC_DelSig_1_GetResult16();
vpp1 = (ADC_DelSig_1_CountsTo_Volts(res2)/2);
vpp2 = vpp1 - dvpp;
break;
}
}
CyDelay(1u);
}
//*Rs_half = 2*(vpp2-(vpp1)/2)/(vpp1); // BR_HALF: Voltage divider between Cond LO and GND
//*Rs_full = 2*(vpp2-(vpp1)/2)/(vpp1); // BR_FULL: Reversed Differential measurement bewteen Cond HI and cond LO
//*Rs_half = vpp2/vpp1; // BR_HALF: Voltage divider between Cond LO and GND
*Rs = vpp2/vpp1; // BR_FULL: Reversed Differential measurement bewteen Cond HI and cond LO
// ADC range is configured as min(v1) +/- 6.114
// Readings are expected to be between min(v1) to +6.114
// and misreading min(v1) as max(v1) results in overflow (eg values like 7.8 and 11)
if (vpp1 > 6.114 || vpp2 > 6.114) {
return 0u;
// Range of excitation signal is 2-2.5 VAC
} else if (vpp1 > 2.6) {
return 0u;
// vpp2 should always be less than vpp1
} else if (*Rs > 1) {
return 0u;
} else if (*Rs < 0) {
return 0u;
} else {
return 1u;
}
}
uint8 campbell_temp_br_read(float* VsVx){
uint8 i, chan = 2u;
float mult = 1.0, ratio = 0.0, R = 0.0;
if (! campbell_temp_start()) {
return 0u;
}
AMux_1_Select(chan);
ADC_DelSig_1_StartConvert();
CyDelay(100u);
for (i = 0u; i < 100; i++) {
if(ADC_DelSig_1_IsEndConversion(ADC_DelSig_1_RETURN_STATUS)){
if (chan == 2)
{
ADC_DelSig_1_StopConvert(); // Stop the conversion so signals don't
// get mixed when switching the mux
res1 = ADC_DelSig_1_GetResult16();
Vx = ADC_DelSig_1_CountsTo_Volts(res1) ;
mult = 8/Vx; // See Sec 12 http://s.campbellsci.com/documents/au/manuals/cs547a.pdf
// Multiplier scales Vx to 8000 mV
chan = 3u;
AMux_1_Select(chan);
//ADC_DelSig_1_SelectConfiguration(2u, 1u);
CyDelay(1u);
ADC_DelSig_1_StartConvert();
CyDelay(99u);
}
else {
ADC_DelSig_1_StopConvert(); // Stop the conversion so signals don't
// get mixed when switching the mux
AMux_1_DisconnectAll();
res2 = ADC_DelSig_1_GetResult16();
Vs = ADC_DelSig_1_CountsTo_Volts(res2) ;
break;
}
}
CyDelay(1u);
}
if (! campbell_temp_stop()) {
return 0u;
}
//*VsVx = mult * VsVx * 8000;
ratio = Vs/Vx; // Added to adjust for using 100 kOhm instead of 1 kOhm
R = (100000 - (ratio*349000)) / ratio; // Added to adjust for using 100 kOhm instead of 1 kOhm
*VsVx = 1000 / (R + 250000) * 8000; // Now that Rs is known, use original equation
// note: Datasheet says 800, but 8000 yields correct results
// According to Therm107 Datasheet, http://s.campbellsci.com/documents/au/manuals/107.pdf
// VsVx*8000 should range between 0 and 30
if (*VsVx > 0 && *VsVx < 30) {
return 1u; // Result is valid
} else {
return 0u;
}
}
void main()
{
CYGlobalIntEnable; /* Enable global interrupts */
ADC_DelSig_1_Start();/* Configure and power up ADC */
LCD_Char_1_Start(); /* Initialize and clear the LCD */
/* Move the cursor to Row 0 Column 0 */
LCD_Char_1_Position(ROW_0,COLUMN_0);
/* Print Label for the pot voltage raw count */
LCD_Char_1_PrintString("TEMP NOW: C");
LCD_Char_1_Position(ROW_1,COLUMN_0);
LCD_Char_1_PrintString("TEMP SET: C");
ADC_DelSig_1_StartConvert(); /* Force ADC to initiate a conversion */
/* Start capsense and initialize baselines and enable scan */
CapSense_Start();
CapSense_InitializeAllBaselines();
CapSense_ScanEnabledWidgets();
/* CyGlobalIntEnable; */ /* Uncomment this line to enable global interrupts. */
//Start the pwm;
PWM_1_Start();
for(;;)
{
/* If scanning is completed update the baseline count and check if sensor is active */
while(CapSense_IsBusy());
/* Update baseline for all the sensors */
CapSense_UpdateEnabledBaselines();
CapSense_ScanEnabledWidgets();
/* Test if button widget is active */
stateB_1 = CapSense_CheckIsWidgetActive(CapSense_BUTTON0__BTN);
stateB_2 = CapSense_CheckIsWidgetActive(CapSense_BUTTON1__BTN);
/* Wait for end of conversion */
ADC_DelSig_1_IsEndConversion(ADC_DelSig_1_WAIT_FOR_RESULT);
/* Get converted result */
voltageRawCount = ADC_DelSig_1_GetResult16();
//Change voltageRawCount to Temperature;
temp = voltageRawCount / 3.870 * 0.1017 + 0.5;
cold = (9999 - (temp > temp_set ? temp - temp_set : 0) * 50);
if(cold < 1000)
cold = 1000;
if(cold > 9999)
cold = 9999;
//Change the pwm;
PWM_1_WriteCompare(cold);
/* Set range limit */
if (temp > 0x7FFF)
{
temp = 0;
}
else
{
/* Continue on */
}
if(show < 10)
{
show++;
}
else
{
show = 0;
UpdateDisplay(temp, 0); /* Print result on LCD */
UpdateButtonState(stateB_1, stateB_2);
}
}
}
int main(void)
{
//Local variables:
uint8 i = 0;
unsigned char result = 0;
uint8 toggle_wdclk = 0;
uint8 cmd_ready_485_1 = 0, cmd_ready_usb = 0;
static uint8 new_cmd_led = 0;
uint16 safety_delay = 0;
uint8 i2c_time_share = 0;
//Power on delay with LEDs
power_on();
//Initialize all the peripherals
init_peripherals();
//Start with an empty buffer
flexsea_clear_slave_read_buffer();
//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
//Blocking Test code - enable one and only one for special
//debugging. Normal code WILL NOT EXECUTE when this is enabled!
//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//strain_test_blocking();
//safety_cop_comm_test_blocking();
//imu_test_code_blocking();
//motor_fixed_pwm_test_code_blocking(141);
//wdclk_test_blocking();
//timing_test_blocking();
//test_current_tracking_blocking();
//test_pwm_pulse_blocking();
//test_uart_dma_xmit();
//motor_cancel_damping_test_code_blocking();
//csea_knee_up_down_test_demo();
//motor_stepper_test_blocking_1(80);
//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//Non-Blocking Test code
//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
#ifdef USE_SPI_COMMUT
motor_stepper_test_init(0);
//Note: deadtime is 55, small PWM values won't make it move.
//Starting at 0, GUI will change that when it wants.
#endif //USE_SPI_COMMUT
//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//Special code for the ExoBoots:
#ifdef PROJECT_EXOCUTE
init_exo();
#endif
//Main loop
while(1)
{
if(t1_new_value == 1)
{
//If the time share slot changed we run the timing FSM. Refer to
//timing.xlsx for more details. 't1_new_value' updates at 10kHz,
//each slot at 1kHz.
t1_new_value = 0;
//Timing FSM:
switch(t1_time_share)
{
//Case 0: I2C
case 0:
i2c_time_share++;
i2c_time_share %= 4;
#ifdef USE_I2C_INT
//Subdivided in 4 slots.
switch(i2c_time_share)
{
//Case 0.0: Accelerometer
case 0:
#ifdef USE_IMU
get_accel_xyz();
i2c_last_request = I2C_RQ_ACCEL;
#endif //USE_IMU
break;
//Case 0.1: Gyroscope
case 1:
#ifdef USE_IMU
get_gyro_xyz();
i2c_last_request = I2C_RQ_GYRO;
#endif //USE_IMU
break;
//Case 0.2: Safety-Cop
case 2:
safety_cop_get_status();
i2c_last_request = I2C_RQ_SAFETY;
break;
//Case 0.3: Free
case 3:
//I2C RGB LED
//minm_test_code();
update_minm_rgb(); //ToDo: That's EXT_I2C, not INT
break;
default:
break;
}
#endif //USE_I2C_INT
#ifdef USE_SPI_COMMUT
angle = as5047_read_single(AS5047_REG_ANGLEUNC);
#endif //USE_SPI_COMMUT
break;
//Case 1:
case 1:
break;
//Case 2:
case 2:
break;
//Case 3: Strain Gauge DelSig ADC, SAR ADC
case 3:
//Start a new conversion
ADC_DelSig_1_StartConvert();
//Filter the previous results
strain_filter_dma();
break;
//Case 4: User Interface
case 4:
//Alive LED
alive_led();
//UI RGB LED:
if(safety_delay > SAFETY_DELAY)
{
//status_error_codes(safety_cop.status1, safety_cop.status2, &eL0, &eL1, &eL2);
}
else
{
safety_delay++;
}
//Display temperature status on RGB
overtemp_error(&eL1, &eL2); //Comment this line if safety code is problematic
rgb_led_ui(eL0, eL1, eL2, new_cmd_led); //ToDo add more error codes
if(new_cmd_led)
{
new_cmd_led = 0;
}
break;
//Case 5: Quadrature encoder & Position setpoint
case 5:
#ifdef USE_QEI1
//Refresh encoder readings
encoder_read();
#endif //USE_QEI1
#ifdef USE_TRAPEZ
if((ctrl.active_ctrl == CTRL_POSITION) || (ctrl.active_ctrl == CTRL_IMPEDANCE))
{
//Trapezoidal trajectories (can be used for both Position & Impedance)
ctrl.position.setp = trapez_get_pos(steps); //New setpoint
ctrl.impedance.setpoint_val = trapez_get_pos(steps); //New setpoint
}
#endif //USE_TRAPEZ
break;
//Case 6: P & Z controllers, 0 PWM
case 6:
#ifdef USE_TRAPEZ
if(ctrl.active_ctrl == CTRL_POSITION)
{
motor_position_pid(ctrl.position.setp, ctrl.position.pos);
}
else if(ctrl.active_ctrl == CTRL_IMPEDANCE)
{
//Impedance controller
motor_impedance_encoder(ctrl.impedance.setpoint_val, ctrl.impedance.actual_val);
}
#endif //USE_TRAPEZ
//If no controller is used the PWM should be 0:
if(ctrl.active_ctrl == CTRL_NONE)
{
motor_open_speed_1(0);
}
break;
case 7:
#ifdef USE_SPI_COMMUT
//Stepper test code:
motor_stepper_test_runtime(10);
#endif //USE_SPI_COMMUT
break;
//Case 8: SAR ADC filtering
case 8:
filter_sar_adc();
break;
//Case 9: User functions
case 9:
//ExoBoot code - 1kHz
#ifdef PROJECT_EXOCUTE
exo_fsm();
#endif
break;
default:
break;
}
//The code below is executed every 100us, after the previous slot.
//Keep it short!
//BEGIN - 10kHz Refresh
//RS-485 Byte Input
#ifdef USE_RS485
//get_uart_data(); //Now done via DMA
if(data_ready_485_1)
{
data_ready_485_1 = 0;
//Got new data in, try to decode
cmd_ready_485_1 = unpack_payload_485_1();
}
#endif //USE_RS485
//USB Byte Input
#ifdef USE_USB
get_usb_data();
if(data_ready_usb)
{
data_ready_usb = 0;
//Got new data in, try to decode
cmd_ready_usb = unpack_payload_usb();
eL1 = 1;
}
#endif //USE_USB
//FlexSEA Network Communication
#ifdef USE_COMM
//Valid communication from RS-485 #1?
if(cmd_ready_485_1 != 0)
{
cmd_ready_485_1 = 0;
//Cheap trick to get first line //ToDo: support more than 1
for(i = 0; i < PAYLOAD_BUF_LEN; i++)
{
tmp_rx_command_485_1[i] = rx_command_485_1[0][i];
}
//payload_parse_str() calls the functions (if valid)
result = payload_parse_str(tmp_rx_command_485_1);
//LED:
if(result == PARSE_SUCCESSFUL)
{
//Green LED only if the ID matched and the command was known
new_cmd_led = 1;
}
}
//Valid communication from USB?
if(cmd_ready_usb != 0)
{
cmd_ready_usb = 0;
//Cheap trick to get first line //ToDo: support more than 1
for(i = 0; i < PAYLOAD_BUF_LEN; i++)
{
tmp_rx_command_usb[i] = rx_command_usb[0][i];
}
//payload_parse_str() calls the functions (if valid)
result = payload_parse_str(tmp_rx_command_usb);
//LED:
if(result == PARSE_SUCCESSFUL)
{
//Green LED only if the ID matched and the command was known
new_cmd_led = 1;
}
}
#endif //USE_COMM
//END - 10kHz Refresh
}
else
{
//Asynchronous code goes here.
//WatchDog Clock (Safety-CoP)
toggle_wdclk ^= 1;
WDCLK_Write(toggle_wdclk);
}
}
}
