UBYTE pwm_monitor()
{
UBYTE data[60];
UBYTE ret;
UBYTE i;
printf("Pwm monitor\n\r");
printf("Hit any key to stop\n\r");
while(!kbhit())
{
disable_interrupts(GLOBAL);
ret=pwm_get(data,60,4000);
enable_interrupts(GLOBAL);
printf("Return %u\n\r",ret);
for(i=0; i<ret; i++)
{
printf("%X ",data[i]);
}
printf("\n\r\n\r");
}
while(kbhit())
{
getch2();
}
return 0;
}
static void wobble(void) {
uint8_t cur = pwm_get();
int8_t delta = (cur > WOBBLE_DELTA) ? (-WOBBLE_DELTA) : WOBBLE_DELTA;
for(uint8_t i = 0; i < 3; i++) {
fade_to(cur + delta, WOBBLE_DELAY);
fade_to(cur, WOBBLE_DELAY);
}
}
static void fade_to(uint8_t target, uint8_t delay) {
uint8_t cur = pwm_get();
int8_t delta = (target > cur) ? 1 : -1;
for(; cur != target; cur += delta) {
pwm_set(cur);
delay_ticks(delay);
}
pwm_set(target);
}
void vex_default_routine(void)
{
pwm_write(RIGHT_DRIVE_PORT, rc_read_data(1));
pwm_write(LEFT_DRIVE_PORT, rc_read_data(2));
/* Drive motors face opposite directions, so reverse left side. */
pwm_write(3, -rc_read_data(3));
pwm_write(4, rc_read_data(4));
/* Handle Channel 5 receiver button */
if (rc_read_data(5) < BUTTON_REV_THRESH)
pwm_write(5, MOTOR_FULL_FWD);
else if (rc_read_data(5) > BUTTON_FWD_THRESH)
pwm_write(5, MOTOR_STOP);
else
pwm_write(5, MOTOR_STOP);
/* Handle Channel 6 receiver button */
if (rc_read_data(6) < BUTTON_REV_THRESH)
pwm_write(6, MOTOR_FULL_FWD);
else if (rc_read_data(6) > BUTTON_FWD_THRESH)
pwm_write(6, MOTOR_STOP);
else
pwm_write(6, MOTOR_STOP);
/* When Jumper 15 is on CONFIGURATION C is selected */
if (io_read_digital(15) == DIGITAL_IN_CLOSED)
{
/* CONFIGURATION C */
pwm_write(7, pwm_get(2));
pwm_write(8, pwm_get(3));
}
else
{
/* CONFIGURATION A & B */
pwm_write(7, ~pwm_get(5));
pwm_write(8, ~pwm_get(6));
}
}
static ssize_t pwm_test_store_request(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
int rc;
struct pwm_test *pwm_test = dev_get_drvdata(dev);
rc = kstrtoul(buf, 0, &pwm_test->requested_s);
if (rc)
return rc;
if (pwm_test->requested_s) {
if(pwm_test->requested) // Allready requested
return count;
pwm_test->pwm = pwm_get(dev, NULL);
if (IS_ERR(pwm_test->pwm)) {
dev_err(dev, "%s() %d %ld\n", __func__, __LINE__,
PTR_ERR(pwm_test->pwm));
rc = -EINVAL;
}
} else {
pwm_free(pwm_test->pwm);
pwm_test->polarity = 0;
pwm_test->run = 0;
pwm_test->duty = 0;
pwm_test->period = 0;
pwm_test->polarity_s = 0;
pwm_test->run_s = 0;
pwm_test->duty_s = 0;
pwm_test->period_s = 0;
rc = 0;
}
if (rc) {
pr_err("operation failed %d\n", rc);
pwm_test->requested_s = pwm_test->requested;
return rc;
}
pwm_test->requested = pwm_test->requested_s;
return count;
}
static int pwm_beeper_probe(struct platform_device *pdev)
{
unsigned long pwm_id = (unsigned long)pdev->dev.platform_data;
struct pwm_beeper *beeper;
int error;
beeper = kzalloc(sizeof(*beeper), GFP_KERNEL);
if (!beeper)
return -ENOMEM;
beeper->pwm = pwm_get(&pdev->dev, NULL);
if (IS_ERR(beeper->pwm)) {
dev_dbg(&pdev->dev, "unable to request PWM, trying legacy API\n");
beeper->pwm = pwm_request(pwm_id, "pwm beeper");
}
if (IS_ERR(beeper->pwm)) {
error = PTR_ERR(beeper->pwm);
dev_err(&pdev->dev, "Failed to request pwm device: %d\n", error);
goto err_free;
}
beeper->input = input_allocate_device();
if (!beeper->input) {
dev_err(&pdev->dev, "Failed to allocate input device\n");
error = -ENOMEM;
goto err_pwm_free;
}
beeper->input->dev.parent = &pdev->dev;
beeper->input->name = "pwm-beeper";
beeper->input->phys = "pwm/input0";
beeper->input->id.bustype = BUS_HOST;
beeper->input->id.vendor = 0x001f;
beeper->input->id.product = 0x0001;
beeper->input->id.version = 0x0100;
beeper->input->evbit[0] = BIT(EV_SND);
beeper->input->sndbit[0] = BIT(SND_TONE) | BIT(SND_BELL);
beeper->input->event = pwm_beeper_event;
input_set_drvdata(beeper->input, beeper);
error = input_register_device(beeper->input);
if (error) {
dev_err(&pdev->dev, "Failed to register input device: %d\n", error);
goto err_input_free;
}
platform_set_drvdata(pdev, beeper);
return 0;
err_input_free:
input_free_device(beeper->input);
err_pwm_free:
pwm_free(beeper->pwm);
err_free:
kfree(beeper);
return error;
}
struct lego_port_device
*ev3_output_port_register(struct ev3_output_port_platform_data *pdata,
struct device *parent)
{
struct ev3_output_port_data *data;
struct pwm_device *pwm;
int err;
if (WARN(!pdata, "Platform data is required."))
return ERR_PTR(-EINVAL);
data = kzalloc(sizeof(struct ev3_output_port_data), GFP_KERNEL);
if (!data)
return ERR_PTR(-ENOMEM);
data->id = pdata->id;
data->analog = get_legoev3_analog();
if (IS_ERR(data->analog)) {
dev_err(parent, "Could not get legoev3-analog device.\n");
err = PTR_ERR(data->analog);
goto err_request_legoev3_analog;
}
data->gpio[GPIO_PIN1].gpio = pdata->pin1_gpio;
data->gpio[GPIO_PIN1].flags = GPIOF_IN;
data->gpio[GPIO_PIN1].label = "pin1";
data->gpio[GPIO_PIN2].gpio = pdata->pin2_gpio;
data->gpio[GPIO_PIN2].flags = GPIOF_IN;
data->gpio[GPIO_PIN2].label = "pin2";
data->gpio[GPIO_PIN5].gpio = pdata->pin5_gpio;
data->gpio[GPIO_PIN5].flags = GPIOF_IN;
data->gpio[GPIO_PIN5].label = "pin5";
data->gpio[GPIO_PIN5_INT].gpio = pdata->pin5_int_gpio;
data->gpio[GPIO_PIN5_INT].flags = GPIOF_IN;
data->gpio[GPIO_PIN5_INT].label = "pin5_tacho";
data->gpio[GPIO_PIN6_DIR].gpio = pdata->pin6_dir_gpio;
data->gpio[GPIO_PIN6_DIR].flags = GPIOF_IN;
data->gpio[GPIO_PIN6_DIR].label = "pin6";
err = gpio_request_array(data->gpio, ARRAY_SIZE(data->gpio));
if (err) {
dev_err(parent, "Requesting GPIOs failed.\n");
goto err_gpio_request_array;
}
data->out_port.name = ev3_output_port_type.name;
snprintf(data->out_port.port_name, LEGO_PORT_NAME_SIZE, "out%c",
data->id + 'A');
pwm = pwm_get(NULL, data->out_port.port_name);
if (IS_ERR(pwm)) {
dev_err(parent, "Could not get pwm! (%ld)\n", PTR_ERR(pwm));
err = PTR_ERR(pwm);
goto err_pwm_get;
}
err = pwm_config(pwm, 0, NSEC_PER_SEC / 10000);
if (err) {
dev_err(parent,
"Failed to set pwm duty percent and frequency! (%d)\n",
err);
goto err_pwm_config;
}
err = pwm_enable(pwm);
if (err) {
dev_err(parent, "Failed to start pwm! (%d)\n", err);
goto err_pwm_start;
}
/* This lets us set the pwm duty cycle in an atomic context */
pm_runtime_irq_safe(pwm->chip->dev);
data->pwm = pwm;
data->out_port.num_modes = NUM_EV3_OUTPUT_PORT_MODE;
data->out_port.mode_info = legoev3_output_port_mode_info;
data->out_port.set_mode = ev3_output_port_set_mode;
data->out_port.set_device = ev3_output_port_set_device;
data->out_port.get_status = ev3_output_port_get_status;
data->out_port.dc_motor_ops = &ev3_output_port_motor_ops;
data->out_port.context = data;
err = lego_port_register(&data->out_port, &ev3_output_port_type, parent);
if (err) {
dev_err(parent, "Failed to register lego_port_device. (%d)\n",
err);
goto err_lego_port_register;
}
INIT_WORK(&data->change_uevent_work, ev3_output_port_change_uevent_work);
INIT_WORK(&data->work, NULL);
data->con_state = CON_STATE_INIT;
hrtimer_init(&data->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
data->timer.function = ev3_output_port_timer_callback;
hrtimer_start(&data->timer, ktime_set(0, OUTPUT_PORT_POLL_NS),
HRTIMER_MODE_REL);
return &data->out_port;
err_lego_port_register:
pwm_disable(pwm);
err_pwm_start:
err_pwm_config:
pwm_put(pwm);
err_pwm_get:
gpio_free_array(data->gpio, ARRAY_SIZE(data->gpio));
err_gpio_request_array:
put_legoev3_analog(data->analog);
err_request_legoev3_analog:
kfree(data);
return ERR_PTR(err);
}
static void dualLedProcess(struct kfish_led_info * led1, struct kfish_led_info * led2)
{
#define PWM_INC(pwm, inc) do{if(255 - pwm < inc){pwm = 255;}else{pwm=pwm+inc;}}while(0)
#define PWM_DEC(pwm, dec) do{ \
if(pwm < dec){ \
pwm = 0; \
}else{ \
pwm=pwm-dec; \
} \
}while(0)
#define LED_PWM_SET(id, pwm) pwm_set(id+1, pwm)
#define LED_PWM_GET(id) pwm_get(id+1)
UINT8 beginVal, endVal;
UINT8 fan_pwm, led_pwm;
INT16 temperature;
UINT8 i;
struct rtc_time time;
INT16 diff;
temperature = local_max_temperature_get();
/* 每2秒检查一次 */
if(local_time_diff_ms(led1->lastTime) < 2000){
return;
}
led1->lastTime = local_ms_get();
local_time_get(&time);
/* led需要时刻检查温度是否正常，需要动态调整风扇转速度
* 如果温度超高，还需要降低led功率
*/
/* 计算新的风扇PWM值 */
fan_pwm = pwm_get(0);
if(temperature > 60){ /* 大于60度，风扇全速 */
fan_pwm = 255;
}else if(temperature < 30){ /* 35度以下停止转动 */
fan_pwm = 0;
}else if(temperature < 40){/* 40度以下开始降低转速 */
PWM_DEC(fan_pwm, 5);
}else if(temperature > 50){/* 50度以下开始增加转速 */
PWM_INC(fan_pwm, 5);
}
for(i=0; i<2; i++){
if(temperature > 65){ /* 温度失控，降低灯亮度 */
if(__local_ctrl[i].ctrl.led.pwm_now > 50)
PWM_DEC(__local_ctrl[i].ctrl.led.pwm_now, 30);
}else if(get_pause_value(i, &diff) > 0){ /* 暂停状态，使用暂停的配置 */
__local_ctrl[i].ctrl.led.pwm_now = (UINT8)diff;
}else{ /* 根据分钟数算一个pwm值 */
beginVal = __local_ctrl[i].ctrl.led.pwm[time.hour];
endVal = __local_ctrl[i].ctrl.led.pwm[(time.hour + 1) % 24];
diff = (INT16)endVal - (INT16)beginVal;
diff = diff * time.min / 60;
diff += (INT16)beginVal;
/* 渐变，不一下子亮度跳变 */
beginVal = LED_PWM_GET(i);
DBG_PRINT("led %d %d->%d\n", i, beginVal, diff);
if(beginVal > diff){
__local_ctrl[i].ctrl.led.pwm_now = beginVal - 1;
}else if(beginVal < diff){
__local_ctrl[i].ctrl.led.pwm_now = beginVal + 1;
}else{
/* 相同，不处理 */
__local_ctrl[i].ctrl.led.pwm_now = beginVal;
}
}
LED_PWM_SET(i, __local_ctrl[i].ctrl.led.pwm_now);
DBG_PRINT("led %d pwm %d fan %d temp %d\n", i, LED_PWM_GET(i), fan_pwm, temperature);
}
pwm_set(0, fan_pwm); /* 设置风扇 */
printk("%x %x %x\n", pwm_get(0), pwm_get(1), pwm_get(2));
}
static void toggle(void) {
if(pwm_get())
pwm_set(0);
else
pwm_set(PWM_MAX);
}
