全志平台Tina PWM控制LED调试

其他 2018-10-15 02:42:02 阅读次数: 0

基础操作：

LED：红灯与蓝灯，红灯---亮/灭，蓝灯---亮/灭/呼吸
节点：/sys/class/misc/misc_dev/pwm_leds/ 
blue_func： 
cat 读取状态 
echo 写入：0：低亮；1：中亮；2：高亮；4：灭；6：呼吸灯 
 
red_func 
cat 读取状态 
echo 写入：1：中亮；4：灭；

可调节led占空比，输入任意101-199的数字，其值减去100即为输入占空比，如：

        想输入占空比为95，则输入：

        echo 195 > /sys/class/misc/misc_dev/pwm_leds/blue_func

        想输入占空比为4，则输入：

        echo 104 > /sys/class/misc/misc_dev/pwm_leds/blue_func

效果展示：

pwm led驱动源码

#include <linux/kernel.h>
#include <linux/platform_device.h>
#include <linux/err.h>
#include <linux/gpio.h>
#include <linux/module.h>
#include <linux/ktime.h>
#include <linux/miscdevice.h>
#include <linux/delay.h>
#include <linux/proc_fs.h>
#include <linux/fs.h>
#include <linux/syslog.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include <linux/pwm.h>
#include <linux/platform_device.h>
#include <linux/slab.h>


/*red led gpio PE1*/
#define RLED_NUM 129
#define ENABLE 1
#define DISABLE 0
#define MAX    100
#define LED_DEFAULT_STATE 9
#define LED_DEFAULT_DELAY (HZ / 20)
//#define DEBUG_PWM

#ifdef DEBUG_PWM
#define  pwm_printf  pr_info
#else
#define  pwm_printf  pr_debug
#endif


static unsigned int duty_ns = 8000000; /*占空，高电平 u32*/
static unsigned long long period_ns = 10000000; /*周期__u64*/
static struct mutex     pwm_muter;
static struct delayed_work blue_led_delay_work;
static struct delayed_work green_led_delay_work;

struct pwm_green_led {
    struct pwm_device *pwm0_dev;
    int pwm_id; /*0:green;1:blue*/
    unsigned long green_status;
    int time_delay;
};

struct pwm_blue_led {
    struct pwm_device *pwm1_dev;
    int pwm_id; /*0:green;1:blue*/
    unsigned long blue_status;
    int time_delay;
};

struct pwm_red_led {
     unsigned long red_status;
     u32 rled_gpio;
};

static struct pwm_green_led *t_pwm_green_led;
static struct pwm_blue_led *t_pwm_blue_led;
static struct pwm_red_led  *t_pwm_red_led;


static void set_pwm(int pwm_id, int level)
{
    unsigned int ret = 0;
    unsigned duty_ns, period_ns ;

    mutex_lock(&pwm_muter);
    period_ns = 100000; /*1000000000/10000 freq=10KHz, 1s=1000000000ns*/
    duty_ns = (period_ns * level)/MAX ;
    if (pwm_id == 0) {
        ret = pwm_config(t_pwm_green_led->pwm0_dev, duty_ns, period_ns);
        ret = pwm_enable(t_pwm_green_led->pwm0_dev);
    } else if (pwm_id == 1) {
        ret = pwm_config(t_pwm_blue_led->pwm1_dev, duty_ns, period_ns);
        ret = pwm_enable(t_pwm_blue_led->pwm1_dev);
    }
    pwm_printf("[pwm_leds] pwm_config pwm%d:<%d | %d>, ret = %d\n",
            pwm_id, duty_ns, period_ns, ret);
     mutex_unlock(&pwm_muter);
}


static ssize_t get_blue_func(struct device *dev,
        struct device_attribute *attr, char *buf)
{
    return sprintf(buf, "%d\n", (int)t_pwm_blue_led->blue_status);
}

static ssize_t set_blue_func(struct device *dev, struct device_attribute *attr,
        const char *buf, size_t size)
{
    int ret;

    ret = kstrtoul(buf, 10, &t_pwm_blue_led->blue_status);

    if (t_pwm_blue_led->time_delay != 0)
        cancel_delayed_work_sync(&blue_led_delay_work);

    pwm_printf("id = %d, status= %d\n",
            t_pwm_blue_led->pwm_id, t_pwm_blue_led->blue_status);
    switch (t_pwm_blue_led->blue_status) {
    case 0: /*LOW_BRIGHT*/
        t_pwm_blue_led->time_delay = 0;
        set_pwm(t_pwm_blue_led->pwm_id, 90);
        break;
    case 1: /*MIDIUM_BRIGHT*/
        t_pwm_blue_led->time_delay = 0;
        set_pwm(t_pwm_blue_led->pwm_id, 50);
        break;
    case 2: /*HIGHT_BRIGHT*/
        t_pwm_blue_led->time_delay = 0;
        set_pwm(t_pwm_blue_led->pwm_id, 10);
        break;
    case 4: /*DISABLE*/
        t_pwm_blue_led->time_delay = 0;
        pwm_disable(t_pwm_blue_led->pwm1_dev);
        break;
    case 6: /*ADJEST_BRGHT*/
        t_pwm_blue_led->time_delay = HZ / 2;
        break;
    case 7: /*test*/
        t_pwm_blue_led->time_delay = 0;
        set_pwm(t_pwm_blue_led->pwm_id, 99);
        break;
    case 8: /*test*/
        t_pwm_blue_led->time_delay = 0;
        set_pwm(t_pwm_blue_led->pwm_id, 50);
        break;
    case 9: /*test*/
        t_pwm_blue_led->time_delay = 0;
        set_pwm(t_pwm_blue_led->pwm_id, 4);
        break;
    default:
        if(t_pwm_blue_led->blue_status > 100 || t_pwm_blue_led->blue_status < 200){
            t_pwm_blue_led->time_delay = 0;
            set_pwm(t_pwm_blue_led->pwm_id, (t_pwm_blue_led->blue_status-100));
        }else{
            t_pwm_blue_led->time_delay = 0;
            pr_err("inval cmd\n");
        }
        break;
    }

    if (t_pwm_blue_led->time_delay)
        schedule_delayed_work(&blue_led_delay_work,
        t_pwm_blue_led->time_delay);
    return size;
}

static ssize_t get_green_func(struct device *dev,
        struct device_attribute *attr, char *buf)
{
    return sprintf(buf, "%d\n", (int)t_pwm_green_led->green_status);
}

static ssize_t set_green_func(struct device *dev, struct device_attribute *attr,
        const char *buf, size_t size)
{
     int ret;

    ret = kstrtoul(buf, 10,  &t_pwm_green_led->green_status);
    if (t_pwm_green_led->time_delay != 0)
        cancel_delayed_work_sync(&green_led_delay_work);
    pwm_printf("pwm_id = %d, status= %d\n",
                t_pwm_green_led->pwm_id,
                t_pwm_green_led->green_status);
    switch (t_pwm_green_led->green_status) {
    case 0: /*LOW_BRIGHT*/
        t_pwm_green_led->time_delay = 0;
        set_pwm(t_pwm_green_led->pwm_id, 90);
        break;
    case 1: /*MIDIUM_BRIGHT*/
        t_pwm_green_led->time_delay = 0;
        set_pwm(t_pwm_green_led->pwm_id, 50);
        break;
    case 2: /*HIGHT_BRIGHT*/
        t_pwm_green_led->time_delay = 0;
        set_pwm(t_pwm_green_led->pwm_id, 10);
        break;
    case 4: /*DISABLE*/
        t_pwm_green_led->time_delay = 0;
        pwm_disable(t_pwm_green_led->pwm0_dev);
        break;
    case 6: /*ADJEST_BRGHT*/
        t_pwm_green_led->time_delay = HZ / 20;
        break;
    default:
        if(t_pwm_green_led->green_status > 100 || t_pwm_green_led->green_status < 200){
            t_pwm_green_led->time_delay = 0;
            set_pwm(t_pwm_green_led->pwm_id, (t_pwm_green_led->green_status-100));
        }else{
            t_pwm_green_led->time_delay = 0;
            pr_err("inval cmd\n");
        }
        break;
    }

    if (t_pwm_green_led->time_delay)
        schedule_delayed_work(&green_led_delay_work,
        t_pwm_green_led->time_delay);

#if 0
    /*int pwm_id = 0;*/
    switch (green_status) {
    case 1: /*MIDIUM_BRIGHT*/
        set_pwm0(0, 30);
        break;
    case 4: /*DISABLE*/
        pwm_disable(pwm0_dev);
        break;
    default:
        pr_err("inval cmd\n");
        break;
    }
#endif
    return size;
}
static ssize_t set_red_func(struct device *dev, struct device_attribute *attr,
                const char *buf, size_t size)
{
        int ret;

        ret = kstrtoul(buf, 10,  &t_pwm_red_led->red_status);
        pwm_printf("red_status= %d\n", t_pwm_red_led->red_status);
        switch (t_pwm_red_led->red_status) {
        case 0:
        case 1: /*MIDIUM_BRIGHT*/
        case 2:
            gpio_set_value(t_pwm_red_led->rled_gpio, 1);
            break;
        case 4: /*DISABLE*/
            gpio_set_value(t_pwm_red_led->rled_gpio, 0);
            break;
        default:
            pr_err("inval cmd\n");
            break;
        }
        return size;
}
static ssize_t get_red_func(struct device *dev,
        struct device_attribute *attr, char *buf)
{
        return sprintf(buf, "%d\n", (int)t_pwm_red_led->red_status);
}


static DEVICE_ATTR(blue_func, 0664,
        get_blue_func, set_blue_func);
static DEVICE_ATTR(green_func, 0664,
        get_green_func, set_green_func);
static DEVICE_ATTR(red_func, 0664,
        get_red_func, set_red_func);


static struct attribute *sunxi_pwmleds_attributes[] = {
    &dev_attr_blue_func.attr,
    &dev_attr_green_func.attr,
    &dev_attr_red_func.attr,
    NULL
};

static struct attribute_group sunxi_pwmleds_attribute_group = {
    .name = "pwm_leds",
    .attrs = sunxi_pwmleds_attributes
};

static struct miscdevice sunxi_pwmleds_dev = {
    .minor = MISC_DYNAMIC_MINOR,
    .name = "misc_dev",
};
static void pwm_blue_led_delay_work(struct work_struct *work)
{
    static int level;
    static int pol;

    pwm_printf(">>>led_timer_func level= %d, pol=%d+++\n", level, pol);
    int pwm_id = t_pwm_blue_led->pwm_id;

    switch (level) {
#if 1
    case 0:
        set_pwm(pwm_id, 99);
        break;
    case 1:
        set_pwm(pwm_id, 96);
        break;
    case 2:
        set_pwm(pwm_id, 92);
        break;
    case 3:
        set_pwm(pwm_id, 88);
        break;
    case 4:
        set_pwm(pwm_id, 84);
        break;
    case 5:
        set_pwm(pwm_id, 80);
        break;
    case 6:
        set_pwm(pwm_id, 76);
        break;
    case 7:
        set_pwm(pwm_id, 72);
        break;
    case 8:
        set_pwm(pwm_id, 68);
        break;
    case 9:
        set_pwm(pwm_id, 64);
        break;
    case 10:
        set_pwm(pwm_id, 60);
        break;
    case 11:
        set_pwm(pwm_id, 56);
        break;
    case 12:
        set_pwm(pwm_id, 52);
        break;
    case 13:
        set_pwm(pwm_id, 48);
        break;
    case 14:
        set_pwm(pwm_id, 44);
        break;
    case 15:
        set_pwm(pwm_id, 40);
        break;
    case 16:
        set_pwm(pwm_id, 36);
        break;
    case 17:
        set_pwm(pwm_id, 32);
        break;
    case 18:
        set_pwm(pwm_id, 28);
        break;
    case 19:
        set_pwm(pwm_id, 24);
        break;
    case 20:
        set_pwm(pwm_id, 20);
        break;
    case 21:
        set_pwm(pwm_id, 16);
        break;
    case 22:
        set_pwm(pwm_id, 12);
        break;
    case 23:
        set_pwm(pwm_id, 8);
        break;
    case 24:
        set_pwm(pwm_id, 4);
        break;
#else
    case 0:
        set_pwm(pwm_id, 100);
        break;
/*    case 1: set_pwm(pwm_id, 96); break;*/
    case 2:
        set_pwm(pwm_id, 92);
        break;
/*    case 3: set_pwm(pwm_id, 88); break;*/
    case 4:
        set_pwm(pwm_id, 84);
        break;
/*    case 5: set_pwm(pwm_id, 80); break;*/
    case 6:
        set_pwm(pwm_id, 76);
        break;
/*    case 7: set_pwm(pwm_id, 72); break;*/
    case 8:
        set_pwm(pwm_id, 68);
        break;
/*    case 9: set_pwm(pwm_id, 64); break;*/
    case 10:
        set_pwm(pwm_id, 60);
        break;
/*    case 11: set_pwm(pwm_id, 56); break;*/
    case 12:
        set_pwm(pwm_id, 52);
        break;
/*    case 13: set_pwm(pwm_id, 48); break;*/
    case 14:
        set_pwm(pwm_id, 44);
        break;
/*    case 15: set_pwm(pwm_id, 40); break;*/
    case 16:
        set_pwm(pwm_id, 36);
        break;
/*    case 17: set_pwm(pwm_id, 32); break;*/
    case 18:
        set_pwm(pwm_id, 28);
        break;
/*    case 19: set_pwm(pwm_id, 24); break;*/
    case 20:
        set_pwm(pwm_id, 20);
        break;
/*    case 21: set_pwm(pwm_id, 16); break;*/
    case 22:
        set_pwm(pwm_id, 12);
        break;
/*    case 23: set_pwm(pwm_id, 8); break;*/
    case 24:
        set_pwm(pwm_id, 4);
        break;
#endif
        default:
            break;
    }

    if (pol == 1) {
        level = level + 1;
        if (level >= 24) {
            level = 24;
            pol = 0;
        }
    } else {
        level = level - 1;
        if (level <= 0) {
            level = 0;
            pol = 1;
        }
    }

    if (level == 24)
        schedule_delayed_work(&blue_led_delay_work, HZ/1);
    else if (level == 0)
        schedule_delayed_work(&blue_led_delay_work, HZ/2);
    else
        schedule_delayed_work(&blue_led_delay_work, HZ/(level+4));
}

static void pwm_green_led_delay_work(struct work_struct *work)
{
    static int level;
    static int pol;
    int pwm_id = t_pwm_green_led->pwm_id;

    pwm_printf(">>>led_timer_func level= %d, pol=%d+++\n", level, pol);

    switch (level) {
#if 1
    case 0:
        set_pwm(pwm_id, 99);
        break;
    case 1:
        set_pwm(pwm_id, 96);
        break;
    case 2:
        set_pwm(pwm_id, 92);
        break;
    case 3:
        set_pwm(pwm_id, 88);
        break;
    case 4:
        set_pwm(pwm_id, 84);
        break;
    case 5:
        set_pwm(pwm_id, 80);
        break;
    case 6:
        set_pwm(pwm_id, 76);
        break;
    case 7:
        set_pwm(pwm_id, 72);
        break;
    case 8:
        set_pwm(pwm_id, 68);
        break;
    case 9:
        set_pwm(pwm_id, 64);
        break;
    case 10:
        set_pwm(pwm_id, 60);
        break;
    case 11:
        set_pwm(pwm_id, 56);
        break;
    case 12:
        set_pwm(pwm_id, 52);
        break;
    case 13:
        set_pwm(pwm_id, 48);
        break;
    case 14:
        set_pwm(pwm_id, 44);
        break;
    case 15:
        set_pwm(pwm_id, 40);
        break;
    case 16:
        set_pwm(pwm_id, 36);
        break;
    case 17:
        set_pwm(pwm_id, 32);
        break;
    case 18:
        set_pwm(pwm_id, 28);
        break;
    case 19:
        set_pwm(pwm_id, 24);
        break;
    case 20:
        set_pwm(pwm_id, 20);
        break;
    case 21:
        set_pwm(pwm_id, 16);
        break;
    case 22:
        set_pwm(pwm_id, 12);
        break;
    case 23:
        set_pwm(pwm_id, 8);
        break;
    case 24:
        set_pwm(pwm_id, 4);
        break;
#else
    case 0:
        set_pwm(pwm_id, 100);
        break;
/*    case 1: set_pwm(pwm_id, 96); break;*/
    case 2:
        set_pwm(pwm_id, 92);
        break;
/*    case 3: set_pwm(pwm_id, 88); break;*/
    case 4:
        set_pwm(pwm_id, 84);
        break;
/*    case 5: set_pwm(pwm_id, 80); break;*/
    case 6:
        set_pwm(pwm_id, 76);
        break;
/*    case 7: set_pwm(pwm_id, 72); break;*/
    case 8:
        set_pwm(pwm_id, 68);
        break;
/*    case 9: set_pwm(pwm_id, 64); break;*/
    case 10:
        set_pwm(pwm_id, 60);
        break;
/*    case 11: set_pwm(pwm_id, 56); break;*/
    case 12:
        set_pwm(pwm_id, 52);
        break;
/*    case 13: set_pwm(pwm_id, 48); break;*/
    case 14:
        set_pwm(pwm_id, 44);
        break;
/*    case 15: set_pwm(pwm_id, 40); break;*/
    case 16:
        set_pwm(pwm_id, 36);
        break;
/*    case 17: set_pwm(pwm_id, 32); break;*/
    case 18:
        set_pwm(pwm_id, 28);
        break;
/*    case 19: set_pwm(pwm_id, 24); break;*/
    case 20:
        set_pwm(pwm_id, 20);
        break;
/*    case 21: set_pwm(pwm_id, 16); break;*/
    case 22:
        set_pwm(pwm_id, 12);
        break;
/*    case 23: set_pwm(pwm_id, 8); break;*/
    case 24:
        set_pwm(pwm_id, 4);
        break;
#endif
        default:
            break;
    }

    if (pol == 1) {
        level = level + 1;
        if (level >= 24) {
            level = 24;
            pol = 0;
        }
    } else {
        level = level - 1;
        if (level <= 0) {
            level = 0;
            pol = 1;
        }
    }

    if (level == 24)
        schedule_delayed_work(&green_led_delay_work, HZ/1);
    else if (level == 0)
        schedule_delayed_work(&green_led_delay_work, HZ/2);
    else
        schedule_delayed_work(&green_led_delay_work, HZ/(level+4));
}

static int pwm_leds_ctrl_init(void)
{
    int ret = 0;
    int pwm_id = 0; /*pwm0_para used*/
    pwm_printf("[pwm_leds]: %s: %d===into\n", __func__, __LINE__);
    t_pwm_green_led = kzalloc(sizeof(struct pwm_green_led), GFP_KERNEL);
    t_pwm_blue_led = kzalloc(sizeof(struct pwm_blue_led), GFP_KERNEL);
    t_pwm_red_led = kzalloc(sizeof(struct pwm_red_led), GFP_KERNEL);

    if (!t_pwm_green_led || !t_pwm_blue_led || !t_pwm_red_led) {
        pr_err("[pwm_leds] request memory fail!\n");
        return -1;
    }

    t_pwm_green_led->pwm0_dev = pwm_request(0, "led_green");
    if (t_pwm_green_led->pwm0_dev == NULL ||
            IS_ERR(t_pwm_green_led->pwm0_dev)) {
        pr_err("[pwm_leds] pwm_request pwm0 fail!\n");
        return -1;
    }
    t_pwm_green_led->green_status = LED_DEFAULT_STATE;
    t_pwm_green_led->pwm_id = 0;
    t_pwm_green_led->time_delay = LED_DEFAULT_DELAY;

    pwm_printf("[pwm_leds] pwm_request pwm0 success!\n");

    t_pwm_blue_led->pwm1_dev = pwm_request(1, "led_blue");
    if (t_pwm_blue_led->pwm1_dev ==  NULL ||
            IS_ERR(t_pwm_blue_led->pwm1_dev)) {
        pr_err("[pwm_leds] pwm_request pwm1 fail!\n");
        return -1;
    }
    t_pwm_blue_led->blue_status = LED_DEFAULT_STATE;
    t_pwm_blue_led->pwm_id = 1;
    t_pwm_blue_led->time_delay = LED_DEFAULT_DELAY;

    pwm_printf("[pwm_leds] pwm_request pwm1 success!\n");

    t_pwm_red_led->rled_gpio = RLED_NUM;
    t_pwm_red_led->red_status = LED_DEFAULT_STATE;

    if (!gpio_is_valid(t_pwm_red_led->rled_gpio)) {
        pr_err("failed to get gpio\n");
        return -EINVAL;
    }
    ret = gpio_request(t_pwm_red_led->rled_gpio, "rled_gpio");
    if (ret) {
        pr_err("failed to request rled gpio\n");
        return -EINVAL;
    }
    gpio_direction_output(t_pwm_red_led->rled_gpio, 1);
    gpio_set_value(t_pwm_red_led->rled_gpio, 0);


    mutex_init(&pwm_muter);
    INIT_DELAYED_WORK(&blue_led_delay_work, pwm_blue_led_delay_work);
    INIT_DELAYED_WORK(&green_led_delay_work, pwm_green_led_delay_work);
    return ret;
}

static int __init pwm_leds_init(void)
{
    int ret, err, pwmleds_used;

    pwm_printf("pwmleds debug gpio driver init\n");

    ret = pwm_leds_ctrl_init();
    if (ret == 0)
        pwm_printf("pwm_leds_init is ok==============\n");
    else
        pwm_printf("pwm_leds_init is err==============\n");

    err = misc_register(&sunxi_pwmleds_dev);
    if (err) {
        pwm_printf("%s led register as misc device error\n", __func__);
        goto exit;
    }
    err = sysfs_create_group(&sunxi_pwmleds_dev.this_device->kobj,
                        &sunxi_pwmleds_attribute_group);
    if (err)
        pwm_printf("%s sysfs_create_group  error\n", __func__);

    return 0;
exit:
    return -1;
}

static void __exit pwm_leds_exit(void)
{
    pwm_printf("Bye, pwm_leds exit\n");
    gpio_set_value(t_pwm_red_led->rled_gpio, 0);
    gpio_free(t_pwm_red_led->rled_gpio);
    pwm_disable(t_pwm_green_led->pwm0_dev);
    pwm_disable(t_pwm_blue_led->pwm1_dev);
    cancel_delayed_work_sync(&blue_led_delay_work);
    cancel_delayed_work_sync(&green_led_delay_work);
    pwm_free(t_pwm_green_led->pwm0_dev);
    pwm_free(t_pwm_blue_led->pwm1_dev);
    kfree(t_pwm_green_led);
    kfree(t_pwm_blue_led);
    kfree(t_pwm_red_led);
    sysfs_remove_group(&sunxi_pwmleds_dev.this_device->kobj,
                    &sunxi_pwmleds_attribute_group);
    misc_deregister(&sunxi_pwmleds_dev);
}

module_init(pwm_leds_init);
module_exit(pwm_leds_exit);

MODULE_DESCRIPTION("a simple pwmleds driver");
MODULE_AUTHOR("yanu");
MODULE_LICENSE("GPL");

猜你喜欢

转载自blog.csdn.net/weixin_43094346/article/details/82846574
今日推荐
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
周排行
rbac——界面、权限
Apache CXF + SpringMVC 整合发布WebService
so插件化
Vue.js实战系列---图标字体制作（svg格式）
PAT乙级 1007 素数对猜想(孪生素数对) (20分) ---（C语言 + 详细注释）
被IRM保护的文档，打开失败
Calendar和Date计算日期差的小问题
win10子系统ubuntu18.4安装docker
利用Wrap Shell Script定位Android Native内存泄漏
MySQL: Transaction (Part I - Basic Concept)
每日归档
更多
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022