static int pwm_backlight_enable(struct udevice *dev)
{
struct pwm_backlight_priv *priv = dev_get_priv(dev);
struct dm_regulator_uclass_platdata *plat;
uint duty_cycle;
int ret;
if (priv->reg) {
plat = dev_get_uclass_platdata(priv->reg);
debug("%s: Enable '%s', regulator '%s'/'%s'\n", __func__,
dev->name, priv->reg->name, plat->name);
ret = regulator_set_enable(priv->reg, true);
if (ret) {
debug("%s: Cannot enable regulator for PWM '%s'\n",
__func__, dev->name);
return ret;
}
mdelay(120);
}
duty_cycle = priv->period_ns * (priv->default_level - priv->min_level) /
(priv->max_level - priv->min_level + 1);
ret = pwm_set_config(priv->pwm, priv->channel, priv->period_ns,
duty_cycle);
if (ret)
return ret;
ret = pwm_set_enable(priv->pwm, priv->channel, true);
if (ret)
return ret;
mdelay(10);
dm_gpio_set_value(&priv->enable, 1);
return 0;
}
void lcd_blt_enable(int no,int enable)
{
if( lcd_pwm_enable ) return;
#ifdef CONFIG_LCD_BACKLIGHT_WMT
pwm_set_enable(no,enable);
#endif
return;
} /* End of vt8430_blt_enable */
/* Basic test of the pwm uclass */
static int dm_test_pwm_base(struct unit_test_state *uts)
{
struct udevice *dev;
ut_assertok(uclass_get_device(UCLASS_PWM, 0, &dev));
ut_assertnonnull(dev);
ut_assertok(pwm_set_config(dev, 0, 100, 50));
ut_assertok(pwm_set_enable(dev, 0, true));
ut_assertok(pwm_set_enable(dev, 1, true));
ut_assertok(pwm_set_enable(dev, 2, true));
ut_asserteq(-ENOSPC, pwm_set_enable(dev, 3, true));
ut_assertok(pwm_set_invert(dev, 0, true));
ut_assertok(uclass_get_device(UCLASS_PWM, 1, &dev));
ut_asserteq(-ENODEV, uclass_get_device(UCLASS_PWM, 2, &dev));
return 0;
}
/**
* Handle the next stage of device init
*/
static int handle_stage(const void *blob, struct tegra_lcd_priv *priv)
{
debug("%s: stage %d\n", __func__, priv->stage);
/* do the things for this stage */
switch (priv->stage) {
case STAGE_START:
/*
* It is possible that the FDT has requested that the LCD be
* disabled. We currently don't support this. It would require
* changes to U-Boot LCD subsystem to have LCD support
* compiled in but not used. An easier option might be to
* still have a frame buffer, but leave the backlight off and
* remove all mention of lcd in the stdout environment
* variable.
*/
funcmux_select(PERIPH_ID_DISP1, FUNCMUX_DEFAULT);
break;
case STAGE_PANEL_VDD:
if (dm_gpio_is_valid(&priv->panel_vdd))
dm_gpio_set_value(&priv->panel_vdd, 1);
break;
case STAGE_LVDS:
if (dm_gpio_is_valid(&priv->lvds_shutdown))
dm_gpio_set_value(&priv->lvds_shutdown, 1);
break;
case STAGE_BACKLIGHT_VDD:
if (dm_gpio_is_valid(&priv->backlight_vdd))
dm_gpio_set_value(&priv->backlight_vdd, 1);
break;
case STAGE_PWM:
/* Enable PWM at 15/16 high, 32768 Hz with divider 1 */
pinmux_set_func(PMUX_PINGRP_GPU, PMUX_FUNC_PWM);
pinmux_tristate_disable(PMUX_PINGRP_GPU);
pwm_set_config(priv->pwm, priv->pwm_channel, 0xdf, 0xff);
pwm_set_enable(priv->pwm, priv->pwm_channel, true);
break;
case STAGE_BACKLIGHT_EN:
if (dm_gpio_is_valid(&priv->backlight_en))
dm_gpio_set_value(&priv->backlight_en, 1);
break;
case STAGE_DONE:
break;
}
/* set up timer for next stage */
priv->timer_next = timer_get_us();
if (priv->stage < FDT_LCD_TIMINGS)
priv->timer_next += priv->panel_timings[priv->stage] * 1000;
/* move to next stage */
priv->stage++;
return 0;
}
static int pwm_backlight_enable(struct udevice *dev)
{
struct pwm_backlight_priv *priv = dev_get_priv(dev);
int ret;
ret = enable_sequence(dev, 0);
if (ret)
return log_ret(ret);
ret = set_pwm(priv);
if (ret)
return log_ret(ret);
ret = pwm_set_enable(priv->pwm, priv->channel, true);
if (ret)
return log_ret(ret);
ret = enable_sequence(dev, 1);
if (ret)
return log_ret(ret);
priv->enabled = true;
return 0;
}
static int pwm_regulator_enable(struct udevice *dev, bool enable)
{
struct pwm_regulator_info *priv = dev_get_priv(dev);
return pwm_set_enable(priv->pwm, priv->pwm_id, enable);
}
void temp_tick(void)
{
double pid_error = 0;
/* Read and average temperatures */
current_temp[EXTRUDER_0] = read_temp(EXTRUDER_0);
#ifdef EXP_Board
current_temp[HEATED_BED_0] = read_temp(HEATED_BED_0);
extruderBlockTemp = current_temp[HEATED_BED_0];
current_temp_r2c2 = read_R2C2_temp();
#endif
pid_error = target_temp[EXTRUDER_0] - current_temp[EXTRUDER_0];
pterm = config.kp * pid_error;
iterm += (config.ki*pid_error);
//pterm = kp * pid_error;
//iterm += (ki*pid_error);
if(iterm > PID_FUNTIONAL_RANGE){
iterm = PID_FUNTIONAL_RANGE;
}else if(iterm < 0){
iterm = 0;
}
dterm_temp = pid_error - last_error;
dterm = config.kd * dterm_temp;
//dterm = kd * dterm_temp;
output = pterm + iterm + dterm;
//output *= 0.95937 + 0.00907*currenBWSpeed + 0.01662*extruderFanSpeed + 0.000009*currenBWSpeed*currenBWSpeed - 0.000035*currenBWSpeed*extruderFanSpeed - 0.000068*extruderFanSpeed*extruderFanSpeed;
//output += output*config.kVent*extruderFanSpeed;
//output += output*config.kBlower*currenBWSpeed;
output = pterm + iterm + dterm;
/*
#ifdef EXP_Board
double p00 = -0.02242;
double p10 = -0.001512*extruderFanSpeed;
double p01 = 0.01811*currenBWSpeed;
double p20 = 0.0003169*extruderFanSpeed*extruderFanSpeed;
double p11 = -0.00006381*extruderFanSpeed*currenBWSpeed;
double p02 = -0.00008276*currenBWSpeed*currenBWSpeed;
double p30 = -0.000002056*extruderFanSpeed*extruderFanSpeed*extruderFanSpeed;
double p21 = -0.000000008015*currenBWSpeed*extruderFanSpeed*extruderFanSpeed;
double p12 = 0.0000002986*extruderFanSpeed*currenBWSpeed*currenBWSpeed;
double pxy = p00 + p10 + p01 + p20 + p11 + p02 + p30 + p21 + p12;
output = output*(1 + pxy);
#endif
*/
last_error = pid_error;
if(output > 100) {
output = 100;
}else if(output<0 ) {
output = 0;
}
if(target_temp[EXTRUDER_0] == 0){
output = 0;
pterm = 0;
iterm = 0;
dterm = 0;
pid_error = 0;
dterm_temp = 0;
}
pwm_set_duty_cycle(5, output);
pwm_set_enable(5);
}
void lcd_blt_enable(int no,int enable)
{
pwm_set_enable(no,enable);
} /* End of vt8430_blt_enable */
void output_38k(int delay)
{
pwm_set_enable(1);
delay_us(delay + PWM_ON_DELAY);
}
void output_38k_off(int delay)
{
pwm_set_enable(0);
delay_us(delay - PWM_OFF_DELAY);
}
