//function to initialize pids
void init_pids()
{
pid_init(&roll);
pid_init(&yaw);
pid_init(&pitch);
pid_init(&height);
}
void init_robot(struct robot *bot){
rs_init(&bot->rs);
cs_init(&bot->cs_a);
cs_init(&bot->cs_d);
quadramp_init(&bot->qr_a);
quadramp_init(&bot->qr_d);
pid_init(&bot->pid_a);
pid_init(&bot->pid_d);
position_init(&bot->posr); //nous
// bot->EVENT_DO_CS =1;
bot->events = EVENT_DO_CS | EVENT_DO_POS;
quadramp_init(&bot->qr_a);
quadramp_init(&bot->qr_d);
#ifdef UART_VERBOSE
UART_CPutString("\r\n init robot structures : [OK]");
#endif
}
int fixedwing_att_control_rates(const struct vehicle_rates_setpoint_s *rate_sp,
const float rates[],
struct actuator_controls_s *actuators)
{
static int counter = 0;
static bool initialized = false;
static struct fw_rate_control_params p;
static struct fw_rate_control_param_handles h;
static PID_t roll_rate_controller;
static PID_t pitch_rate_controller;
static PID_t yaw_rate_controller;
static uint64_t last_run = 0;
const float deltaT = (hrt_absolute_time() - last_run) / 1000000.0f;
last_run = hrt_absolute_time();
if(!initialized)
{
parameters_init(&h);
parameters_update(&h, &p);
pid_init(&roll_rate_controller, p.rollrate_p, p.rollrate_i, 0, p.rollrate_awu, 1, PID_MODE_DERIVATIV_NONE); // set D part to 0 because the controller layout is with a PI rate controller
pid_init(&pitch_rate_controller, p.pitchrate_p, p.pitchrate_i, 0, p.pitchrate_awu, 1, PID_MODE_DERIVATIV_NONE); // set D part to 0 because the contpitcher layout is with a PI rate contpitcher
pid_init(&yaw_rate_controller, p.yawrate_p, p.yawrate_i, 0, p.yawrate_awu, 1, PID_MODE_DERIVATIV_NONE); // set D part to 0 because the contpitcher layout is with a PI rate contpitcher
initialized = true;
}
/* load new parameters with lower rate */
if (counter % 100 == 0) {
/* update parameters from storage */
parameters_update(&h, &p);
pid_set_parameters(&roll_rate_controller, p.rollrate_p, p.rollrate_i, 0, p.rollrate_awu, 1);
pid_set_parameters(&pitch_rate_controller, p.pitchrate_p, p.pitchrate_i, 0, p.pitchrate_awu, 1);
pid_set_parameters(&yaw_rate_controller, p.yawrate_p, p.yawrate_i, 0, p.yawrate_awu, 1);
}
/* Roll Rate (PI) */
actuators->control[0] = pid_calculate(&roll_rate_controller, rate_sp->roll, rates[0], 0, deltaT);
actuators->control[1] = pid_calculate(&pitch_rate_controller, rate_sp->pitch, rates[1], 0, deltaT); //TODO: (-) sign comes from the elevator (positive --> deflection downwards), this has to be moved to the mixer...
actuators->control[2] = 0;//pid_calculate(&yaw_rate_controller, rate_sp->yaw, rates[2], 0, deltaT); //XXX TODO disabled for now
counter++;
return 0;
}
/*
* Output functions
*
*/
void PID_lacet_Outputs_wrapper(const real_T *t,
const real_T *kp,
const real_T *ki,
const real_T *kd,
const real_T *rc,
const real_T *rmes,
real_T *com)
{
/* %%%-SFUNWIZ_wrapper_Outputs_Changes_BEGIN --- EDIT HERE TO _END */
/* This sample sets the output equal to the input
y0[0] = u0[0];
For complex signals use: y0[0].re = u0[0].re;
y0[0].im = u0[0].im;
y1[0].re = u1[0].re;
y1[0].im = u1[0].im;
*/
if (t[0]<=0.01){
t_av=0;
mon_pid = &mon_pid_t;
pid_init(mon_pid, kp[0], ki[0], kd[0], 1000, 1000, PID_MODE_DERIVATIV_SET, 0.00001);
pid_reset_integral(mon_pid);
pid_set_parameters(mon_pid, kp[0], ki[0], kd[0], 1000, 1000);
//pid_init(mon_pid, 6.8, 0, 0, 1000, 1000, PID_MODE_DERIVATIV_SET, 0.1);
//pid_set_parameters(mon_pid, 6.56, 0, 0, 4096, 4096);
toto++;
}
//com[0]=thetames[0];
dt=t[0]-t_av;
t_av=t[0];
com[0]=pid_calculate(mon_pid, rc[0] ,rmes[0], 0, dt);
/* %%%-SFUNWIZ_wrapper_Outputs_Changes_END --- EDIT HERE TO _BEGIN */
}
int rp_app_init(void)
{
fprintf(stderr, "Loading scope (with gen+pid extensions) version %s-%s.\n", VERSION_STR, REVISION_STR);
rp_default_calib_params(&rp_main_calib_params);
if(rp_read_calib_params(&rp_main_calib_params) < 0) {
fprintf(stderr, "rp_read_calib_params() failed, using default"
" parameters\n");
}
if(rp_osc_worker_init(&rp_main_params[0], PARAMS_NUM,
&rp_main_calib_params) < 0) {
return -1;
}
if(generate_init(&rp_main_calib_params) < 0) {
return -1;
}
if(pid_init() < 0) {
return -1;
}
rp_set_params(&rp_main_params[0], PARAMS_NUM);
return 0;
}
void ctrl_init(void)
{
control.mode = CTRL_MODE_HALT;
pid_init();
for(int32_t i=0;i<4;i++)
control.throttle[i] = 0;
}
int softdvb_init()
{
int ret = 0;
Filter_param param;
// xml 根pid
unsigned short root_pid = root_channel_get();
int filter1 = alloc_filter(root_pid, 0);
DEBUG("set dvb filter, pid=%d, fid=%d\n", root_pid, filter1);
// 升级pid
memset(¶m,0,sizeof(param));
param.filter[0] = 0xf0;
param.mask[0] = 0xff;
loader_dsc_fid=TC_alloc_filter(0x1ff0, ¶m, loader_des_section_handle, NULL, 0);
DEBUG("set upgrade filter, pid=0x1ff0, fid=%d\n", loader_dsc_fid);
// ca pid
memset(¶m,0,sizeof(param));
param.filter[0] = 0x1;
param.mask[0] = 0xff;
int ca_dsc_fid=TC_alloc_filter(0x1, ¶m, ca_section_handle, NULL, 0);
DEBUG("set ca filter, pid=0x1, fid=%d\n", ca_dsc_fid);
#ifdef PUSH_LOCAL_TEST
// prog/video
unsigned short video_pid = 123;
int filter5 = alloc_filter(video_pid, 1);
DEBUG("set dvb filter3, pid=%d, fid=%d\n", video_pid, filter5);
// prog/file
unsigned short file_pid = 654;
int filter4 = alloc_filter(file_pid, 1);
DEBUG("set dvb filter3, pid=%d, fid=%d\n", file_pid, filter4);
// prog/audio
unsigned short audio_pid = 8123;
int filter3 = alloc_filter(audio_pid, 1);
DEBUG("set dvb filter3, pid=%d, fid=%d\n", audio_pid, filter3);
#else
if(-1==pid_init(1)){
DEBUG("allpid init faild\n");
return -1;
}
#endif
tdt_time_sync_awake();
if(0==pthread_create(&pth_softdvb_id, NULL, softdvb_thread, NULL)){
//pthread_detach(pth_softdvb_id);
DEBUG("create soft dvb thread success\n");
ret = 0;
}
else{
ERROROUT("create multicast receive thread failed\n");
ret = -1;
}
return ret;
}
void ReflowOven::init (void) {
/**PID*************************************************************************/
//135 sec (Tu) oscillation at 100 gain (Ku)
pidVars.gain = 60; //Ku*0.60
pidVars.sampleTime = 2500; //milliseconds
pidVars.iTime = 33750; //milliseconds Tu*0.5 ::67500
pidVars.dTime = 8438; //milliseconds Tu*0.125 ::16875
pidVars.minI = -0.25;
pidVars.maxI = 0.75;
pid = pid_new ();
pid_init (pid, pidVars);
/**Initial Oven Variables******************************************************/
reflowVars.preheatRamp = 0.8f; // C/sec
reflowVars.soakTemp = 150.0f; // C
reflowVars.soakTime = 60; // sec
reflowVars.ramp = 0.6; // C/sec
reflowVars.peakTemp = 225.0f; // C
reflowVars.peakTime = 25; // sec
reflowVars.startTemp = 25.0f; // C
reflowVars.preheatTime = 0; // sec
reflowVars.rampTime = 0; // sec
reflowVars.cooldownTime = 0; // sec
reflowVars.totalTime = 0; // sec
reflowVars.soakTempIncrease = 10.0f; // C
reflowVars.cooldownRamp = 5.0f; // C/sec
temp = tc.readCelsius ();
if (temp > reflowVars.soakTemp)
temp = 25;
/**GUI*************************************************************************/
myBui.initUI ();
myBui.addScreen (OVEN_GRAPH, &ovenGraph);
myBui.changeScreens (OVEN_GRAPH);
/**Global/Class Variables******************************************************/
setpoint = temp;
startingTemp = temp;
runtime = 0;
reflowState = PREHEAT;
ms1000 = 0;
msPTerm = 0;
msITerm = 0;
msDTerm = 0;
elementOffTime = 0;
faultCount = 0;
ovenOn = false;
elementOn = false;
pinMode (RELAY_PIN, OUTPUT);
turnElementOff ();
ovenGraph.updateStage ("Off");
ovenGraph.updateSetpoint (setpoint);
}
int cpReactor_start(int sock)
{
int i;
int accept_epfd = epoll_create(512); //这个参数没用
if (cpEpoll_add(accept_epfd, sock, EPOLLIN) < 0)
{
return FAILURE;
};
pid_init();
set_pid(CPGS->master_pid);
struct timeval timeo;
timeo.tv_sec = CP_REACTOR_TIMEO_SEC;
timeo.tv_usec = CP_REACTOR_TIMEO_USEC;
pthread_t pidt;
for (i = 0; i < CPGC.reactor_num; i++)
{
int *index = (int*) malloc(sizeof (int));
*index = i;
if (pthread_create(&pidt, NULL, (void * (*)(void *)) cpReactor_thread_loop, (void *) index) < 0)
{
cpLog("pthread_create[tcp_reactor] fail");
}
pthread_detach(pidt);
CPGS->reactor_threads[i].thread_id = pidt;
}
epoll_wait_handle handles[CP_MAX_EVENT];
handles[EPOLLIN] = cpServer_master_onAccept;
usleep(50000);
cpLog("start %s success", CPGC.title);
return cpEpoll_wait(handles, &timeo, accept_epfd);
}
void mctrl_init(void) {
SPIinit();
DACinit();
pid_init(K_P * PID_SCALING_FACTOR, K_I * PID_SCALING_FACTOR, K_D * PID_SCALING_FACTOR, 2097152, 1);
}
/* Act on select button pushes received from the ISR.
* Toggle the helicopter rotor on and off with each push.
*/
static void vStartStopPWM ( void *pvParameters )
{
/* Take the semaphore once to start with so the semaphore is empty before the
infinite loop is entered. The semaphore was created before the scheduler
was started so before this task ran for the first time.*/
xSemaphoreTake( xBinarySelectSemaphore, 0 );
portBASE_TYPE flying = pdFALSE;
for( ;; )
{
/* Use the semaphore to wait for the event. */
xSemaphoreTake( xBinarySelectSemaphore, portMAX_DELAY );
if (flying == pdFALSE) {
pid_init();
// Turn the main rotor on.
PWMOutputState(PWM_BASE, PWM_OUT_1_BIT, true);
// Reset the desired height
desiredAltitude = INITIAL_ALT;
flying = pdTRUE;
} else {
// Turn the thing off.
while (desiredAltitude > 5) {
desiredAltitude -= 2;
vTaskDelay( 100 / portTICK_RATE_MS );
}
PWMOutputState(PWM_BASE, PWM_OUT_1_BIT, false);
flying = pdFALSE;
}
}
}
void att_ctrl_init(void)
{
ASSERT_ONCE();
/* load parameters: */
opcd_param_t params[] =
{
{"p", &angle_p.value},
{"i", &angle_i.value},
{"i_max", &angle_i_max.value},
{"d", &angle_d.value},
{"filt_fg", &filt_fg},
{"pitch_bias", &biases[0]},
{"roll_bias", &biases[1]},
OPCD_PARAMS_END
};
opcd_params_apply("controllers.attitude.", params);
/* initialize filter: */
filter1_lp_init(&filter, tsfloat_get(&filt_fg), 0.0033333, 2);
/* initialize controllers: */
FOR_EACH(i, controllers)
{
pid_init(&controllers[i], &angle_p, &angle_i, &angle_d, &angle_i_max);
}
/*
* Kernel setup code, called from startup().
*/
void
kern_setup1(void)
{
proc_t *pp;
pp = &p0;
proc_sched = pp;
/*
* Initialize process 0 data structures
*/
pp->p_stat = SRUN;
pp->p_flag = SSYS;
pp->p_pidp = &pid0;
pp->p_pgidp = &pid0;
pp->p_sessp = &session0;
pp->p_tlist = &t0;
pid0.pid_pglink = pp;
pid0.pid_pgtail = pp;
/*
* XXX - we asssume that the u-area is zeroed out except for
* ttolwp(curthread)->lwp_regs.
*/
PTOU(curproc)->u_cmask = (mode_t)CMASK;
thread_init(); /* init thread_free list */
pid_init(); /* initialize pid (proc) table */
contract_init(); /* initialize contracts */
init_pages_pp_maximum();
}
/*********************************************************************
Main Program Loop
**********************************************************************/
int main()
{
/* Initializations */
debug_init(); /* This should be first. */
timer_init();
/* This should be before any GPIO activities. */
uint32 ret_val = bcm2835_init();
if ( ret_val == 0 )
{
DEBUG_MSG_ERROR("bcm2835_init() failed.");
}
pwm_init();
pump_init();
therm_init();
pid_init();
pump_start();
/* Take temperature as input from console. */
float setpoint;
printf("Set your desired temperature: ");
scanf("%f", &setpoint);
pid_update_temp_setpoint(setpoint);
pid_gain_params pid_gain;
pid_gain.k_p = 1;
pid_gain.k_d = 1;
pid_gain.k_i = 1;
pid_gain.k_windup = 1;
pid_set_gain(&pid_gain);
/* Main Program Loop */
while (1)
{
pwm_run();
therm_capture();
pid_loop();
}
pump_stop();
/* De-initializations */
pump_deinit();
pid_deinit();
pwm_deinit();
/* This should be after all GPIO activities. */
ret_val = bcm2835_close();
if ( ret_val == 0 )
{
DEBUG_MSG_ERROR("bcm2835_close() failed.");
}
timer_deinit();
debug_deinit(); /* This should be last. */
return 0;
}
void dc_init(void) {
#ifdef ENCODER
pid_init(&pid,
PID_K_P_DEFAULT,
PID_K_I_DEFAULT,
PID_K_D_DEFAULT,
PID_SAMPLE_TIME_DEFAULT,
PID_MAX_OUT_DEFAULT,
PID_MIN_OUT_DEFAULT);
encoder_init();
#endif
Pin dc_pins[] = {PINS_DC};
PIO_Configure(dc_pins, PIO_LISTSIZE(dc_pins));
// Configure and enable power measurements
Pin dc_power_management_pins[] = {VOLTAGE_STACK_PIN,
VOLTAGE_EXTERN_PIN,
VOLTAGE_STACK_SWITCH_PIN,
CURRENT_CONSUMPTION_PIN};
PIO_Configure(dc_power_management_pins,
PIO_LISTSIZE(dc_power_management_pins));
// Initialize PWM
PMC->PMC_PCER0 = 1 << ID_PWM;
dc_update_pwm_frequency();
adc_channel_enable(VOLTAGE_EXTERN_CHANNEL);
adc_channel_enable(VOLTAGE_STACK_CHANNEL);
adc_channel_enable(CURRENT_CONSUMPTION_CHANNEL);
}
void contrtemp_init(void)
{
struct pid_k_set *k_set;
struct settings *settings;
fixpt_t temp_setpoint;
settings = get_settings();
k_set = &settings->temp_k[TEMPBOOST_NORMAL];
pid_init(&contrtemp.pid,
#if CONF_DEBUG
PSTR("pid-t"),
#endif
k_set,
float_to_fixpt(CONTRTEMP_NEGLIM_I),
float_to_fixpt(CONTRTEMP_POSLIM_I),
float_to_fixpt(CONTRTEMP_NEGLIM),
float_to_fixpt(CONTRTEMP_POSLIM));
temp_setpoint = presets_get_active_value();
pid_set_setpoint(&contrtemp.pid, temp_setpoint);
/* Enable the controller. */
do_set_enabled(true);
do_set_emerg(false);
}
inline void control_quadrotor_attitude_init()
{
pid_init(&yaw_pos_controller, global_data.param[PARAM_PID_YAWPOS_P],
global_data.param[PARAM_PID_YAWPOS_I],
global_data.param[PARAM_PID_YAWPOS_D],
global_data.param[PARAM_PID_YAWPOS_AWU], PID_MODE_DERIVATIV_SET,
154);
pid_init(&yaw_speed_controller, global_data.param[PARAM_PID_YAWSPEED_P],
global_data.param[PARAM_PID_YAWSPEED_I],
global_data.param[PARAM_PID_YAWSPEED_D],
global_data.param[PARAM_PID_YAWSPEED_AWU], PID_MODE_DERIVATIV_CALC,
155);
pid_init(&nick_controller, 50, 0, 15, global_data.param[PARAM_PID_ATT_AWU],
PID_MODE_DERIVATIV_SET, 156);
pid_init(&roll_controller, 50, 0, 15, global_data.param[PARAM_PID_ATT_AWU],
PID_MODE_DERIVATIV_SET, 157);
}
void mctrl_init(void) {
int const integral_limit = 1000;
SPIinit();
DACinit();
pid_init(K_P * PID_SCALING_FACTOR, K_I * PID_SCALING_FACTOR, K_D * PID_SCALING_FACTOR, integral_limit, 0.25);
}
static
struct thread *
thread_create(const char *name)
{
if(counting == 0)
{
head = pid_init(99);
counting = 1;
}
struct thread *thread = kmalloc(sizeof(struct thread));
if (thread==NULL) {
return NULL;
}
thread->t_name = kstrdup(name);
if (thread->t_name==NULL) {
kfree(thread);
return NULL;
}
thread->t_sleepaddr = NULL;
thread->t_stack = NULL;
thread->t_vmspace = NULL;
thread->t_cwd = NULL;
// If you add things to the thread structure, be sure to initialize
// them here.
thread->iteration = 0;
pid_t randpid = 88;
if(forked == 0)
{
while((search_pid(randpid) == 0)&&(cnter != 0))
{
cnter++;
randpid = cnter;
}
add_threadpid(randpid, thread);
//thread -> pidnum = randpid;
}
else if(forked == 1)
{
while((search_pid(randpid) == 0)&&(cnter != 0))
{
cnter++;
randpid = cnter;
}
add_childpid(get_td(curthread) -> pidnum ,randpid, thread);
//thread -> pidnum = randpid;
}
forked = 0;
return thread;
}
int fixedwing_att_control_attitude(const struct vehicle_attitude_setpoint_s *att_sp,
const struct vehicle_attitude_s *att,
struct vehicle_rates_setpoint_s *rates_sp)
{
static int counter = 0;
static bool initialized = false;
static struct fw_att_control_params p;
static struct fw_pos_control_param_handles h;
static PID_t roll_controller;
static PID_t pitch_controller;
if(!initialized)
{
parameters_init(&h);
parameters_update(&h, &p);
pid_init(&roll_controller, p.roll_p, 0, 0, 0, p.rollrate_lim, PID_MODE_DERIVATIV_NONE); //P Controller
pid_init(&pitch_controller, p.pitch_p, 0, 0, 0, p.pitchrate_lim, PID_MODE_DERIVATIV_NONE); //P Controller
initialized = true;
}
/* load new parameters with lower rate */
if (counter % 100 == 0) {
/* update parameters from storage */
parameters_update(&h, &p);
pid_set_parameters(&roll_controller, p.roll_p, 0, 0, 0, p.rollrate_lim);
pid_set_parameters(&pitch_controller, p.pitch_p, 0, 0, 0, p.pitchrate_lim);
}
/* Roll (P) */
rates_sp->roll = pid_calculate(&roll_controller, att_sp->roll_tait_bryan, att->roll, 0, 0);
/* Pitch (P) */
float pitch_sp_rollcompensation = att_sp->pitch_tait_bryan + p.pitch_roll_compensation_p * att_sp->roll_tait_bryan;
rates_sp->pitch = pid_calculate(&pitch_controller, pitch_sp_rollcompensation, att->pitch, 0, 0);
/* Yaw (from coordinated turn constraint or lateral force) */
//TODO
counter++;
return 0;
}
/*************************************************
名称：pid_config(void)
功能：pid配置
输入参数：无
输出参数：无
返回值： 无
**************************************************/
void pid_config(void)
{
pid_init(&pid_yaw);
pid_init(&pid_roll);
pid_init(&pid_pitch);
pid_yaw.kp = -4.0f;
pid_yaw.ki = -1.0f;
pid_yaw.kd = -0.0f;
pid_pitch.kp = -2.0f;
pid_pitch.ki = -0.04f;
pid_pitch.kd = -2.0f;
pid_roll.kp = 2.0f;
pid_roll.ki = 0.04f;
pid_roll.kd = -2.0f;
}
void speed_control_init(void)
{
// initialize speed control hardware
servo_channel_enable(0);
set_servo_duty(500);
//servo_channel_set_duty(0, 0);
// initialize speed measurement hardware
// initialize speed control mechanism
pid_init(&speed_control_pid, 1, 0, 0, 100);
is_running = false;
}
void init(void)
{
hardware_lowlevel_init();
rtc_init_flag();
spi_drv_init();
spi_ext_init();
drv8301_init();
pid_init();
commutate_init();
motor_init();
EnableInterrupts; // enable Interrupts
}
/**
* @brief Init Wall follow controller
* @param pid param
*/
void pid_Wallfollow_init(PID_PARAMETERS pid_param)
{
pid_init();
pid_set_parameters(pid_param);
// if (pid_TimerID != 0xff)
// {
// TIMER_UnregisterEvent(pid_TimerID);
// }
pid_Runtimeout(&Pid_process_callback, pid_param.Ts);
ui32_msLoop = pid_param.Ts;
}
void u_speed_init(void)
{
ASSERT_ONCE();
opcd_param_t params[] =
{
{"p", &speed_p},
{"i", &speed_i},
{"imax", &speed_imax},
OPCD_PARAMS_END
};
opcd_params_apply("controllers.u_speed.", params);
pid_init(&ctrl, &speed_p, &speed_i, NULL, &speed_imax);
}
int charger_init(CHARGER& charger){
digitalWrite(P_SW, LOW);
analogWrite(P_PWM, MIN_PWM);
charger.fb=charger.vfb=charger.avg_vfb=charger.dfb_v=charger.ifb=charger.dfb_i=0.0;
//
// setpoint value
charger.sp=A2D(V_BATT);
//
// input value (charger.dfb_v is the output)
charger.pwm=charger.open_pwm=MIN_PWM;
pid_init(pid, MIN_PWM, MAX_PWM, aKp, aKi, aKd);
}
int main()
{
printf("System test begin \n");
pid_t* tset;
float real = 0;
tset = pid_init(35,0,0,0);
while(k < 100)
{
real = pid_calc(tset);
printf("%f\n",real);
k++;
}
free(tset);
return 0;
}
void cs_init(struct cs* cs, char process_out)
{
cs->process_out = process_out; //0 = ANGLE ou 1 = DISTANCE
cs->prev_process_out_value = 0;
cs->consign_value = 0;
cs->filtered_consign_value = 0;
cs->error_value = 0;
cs->out_value = 0;
cs->speed = 0;
pid_init(&cs->correct_filter_params);
if(process_out==PROCESS_ANGLE)
speed_filter_init(&cs->consign_filter_params, A_SPEED_POS, A_SPEED_NEG, A_ACC_POS, A_ACC_NEG);
else
speed_filter_init(&cs->consign_filter_params, D_SPEED_POS, D_SPEED_NEG, D_ACC_POS, D_ACC_NEG);
}
// entrypoint
int main() {
// initialize misc
cli(); // turn off interrupts during init
serial_init(MYUBRR);
serial_xmit("initialising");
HEATER_DDR |= _BV(HEATER_PIN); // set heater pin to output
HEATER_PORT &= ~_BV(HEATER_PIN); // turn off heater
tc_init();
pid_init(PFACTOR, IFACTOR, DFACTOR, 0, 10.0);
// set up program state
serial_xmit(" state");
reflow_state.stage = RS_OFF;
reflow_state.setpoint = SETPOINT_REFLOW;
pid_change_setpoint(SETPOINT_REFLOW);
reflow_state.time = 0;
// set up interrupts
serial_xmit(", interrupts");
// timer 0: control timer, for controlling the heating element
TCCR0A = 0b00000010; // CTC mode
TCCR0B = 0b00000011; // CTC mode, prescaler = 64
OCR0A = CT_COMPARE;
TIMSK0 = 0b00000000; // no compare interrupts for now
// timer 1: update timer, for determining new control values
TCCR1A = 0b00000000; // CTC mode
TCCR1B = 0b00001101; // CTC mode, prescaler = 1024
OCR1A = UT_COMPARE;
TIMSK1 = 0b00000010; // compare interrupt A only
sei(); // turn on all interrupts
// do nothing if no interrupts
serial_xmit(", all set!\n");
for(;;);
}
void u_ctrl_init(const float dt)
{
ASSERT_ONCE();
opcd_param_t params[] =
{
{"p", &pos_p},
{"d", &pos_d},
{"i", &pos_i},
{"imax", &pos_imax},
{"lpfg", &lpfg},
OPCD_PARAMS_END
};
opcd_params_apply("controllers.u_pos.", params);
pid_init(&ctrl, &pos_p, &pos_i, &pos_d, &pos_imax);
filter1_lp_init(&filter, tsfloat_get(&lpfg), dt, 1);
}
