基于DragonBoard 410c的自动浇花机（二）

     在http://blog.csdn.net/weixin_40109283/article/details/79227038博客中已经介绍了基于DragonBoard 410c的自动浇花机的硬件设计，接下来介绍一下软件设计。

代码如下所示：

#include <linux/module.h>

#include <linux/kernel.h>

#include <linux/init.h>

#include <linux/sysfs.h>

#include <linux/delay.h>

#include <linux/platform_device.h>

#include <linux/err.h>

#include <linux/device.h>

#include <linux/of_gpio.h>

#include <asm/uaccess.h>

#include <linux/kdev_t.h>

#include <linux/slab.h>

#include <linux/timer.h>

#include <linux/jiffies.h>

struct water_pdata {

    struct platform_device *pdev;

    int machine_gpio;

    int humidity_gpio1;

    int humidity_gpio2;

    int humidity_gpio3;

    int irq;

    

    struct timer_list watertime;

};

struct water_pdata* pdata;

static void water_flowers_func(unsigned long data)

{

    int a, b, c;

    printk(KERN_INFO "water_flowesr_func enter\n");

    a = gpio_get_value(pdata->humidity_gpio1);

    printk("humidity gpio1 = %d.\n", a);    

    b = gpio_get_value(pdata->humidity_gpio2);    

    printk("humidity gpio2 = %d.\n", b);    

    c = gpio_get_value(pdata->humidity_gpio3);    

    printk("humidity gpio3 = %d.\n", c);    

    if (a+b+c >= 2) {

        gpio_set_value(pdata->machine_gpio, 1);

        printk("watering flowers!\n");

    }

    else {

        gpio_set_value(pdata->machine_gpio, 0);

        printk("Not water flowers.\n");

    }

    mod_timer(&(pdata->watertime), jiffies + HZ);

}

static int water_probe(struct platform_device *pdev)

{

    int result;

    struct device_node* node = pdev->dev.of_node;

    

    printk("water probe enter\n");

    pdata = devm_kzalloc(&pdev->dev, sizeof(pdata), GFP_KERNEL);

    if (!pdata) {

        pr_err("%s kzalloc error\n", __FUNCTION__);

        return -ENOMEM;

    }

    dev_set_drvdata(&pdev->dev, pdata);

    pdata->humidity_gpio1 = of_get_named_gpio(node, "thundersoft,humidity_gpio1", 0);

    if (!gpio_is_valid(pdata->humidity_gpio1)) {

        pr_err("humidity gpio1 not specified\n");

        goto err1;

    } else {

        result = gpio_request(pdata->humidity_gpio1, "humidity_gpio1");

        if (result < 0) {

            pr_err("Unable to request humidity gpio1\n");

            goto err1;

        } else {

            gpio_direction_input(pdata->humidity_gpio1);

        }

    }

    pdata->humidity_gpio2 = of_get_named_gpio(node, "thundersoft,humidity_gpio2", 0);

    if (!gpio_is_valid(pdata->humidity_gpio2)) {

        pr_err("humidity gpio2 not specified\n");

        goto err2;

    } else {

        result = gpio_request(pdata->humidity_gpio2, "humidity_gpio2");

        if (result < 0) {

            pr_err("Unable to request humidity gpio2\n");

            goto err2;

        } else {

            gpio_direction_input(pdata->humidity_gpio2);

        }

    }

    pdata->humidity_gpio3 = of_get_named_gpio(node, "thundersoft,humidity_gpio3", 0);

    if (!gpio_is_valid(pdata->humidity_gpio3)) {

        pr_err("humidity gpio3 not specified\n");

        goto err3;

    } else {

        result = gpio_request(pdata->humidity_gpio3, "humidity_gpio3");

        if (result < 0) {

            pr_err("Unable to request humidity gpio3\n");

            goto err3;

        } else {

            gpio_direction_input(pdata->humidity_gpio3);

        }

    }

    pdata->machine_gpio = of_get_named_gpio(node, "thundersoft,machine_gpio", 0);

    if (!gpio_is_valid(pdata->machine_gpio)) {

        pr_err("machine gpio not secified\n");

        goto err4;

    } else {

        result = gpio_request(pdata->machine_gpio, "machine_gpio");

        if (result < 0) {

            pr_err("Unable to request machine gpio\n");

            goto err4;

        } else {

            gpio_direction_output(pdata->machine_gpio, 0);

        }

    }

    setup_timer(&(pdata->watertime), water_flowers_func, (unsigned long)pdata);

    pdata->watertime.expires = jiffies + HZ;

    add_timer(&(pdata->watertime));

    printk(KERN_INFO "water probe success\n");

    return 0;

err4:

    gpio_free(pdata->humidity_gpio3);

err3:

    gpio_free(pdata->humidity_gpio2);

err2:

    gpio_free(pdata->humidity_gpio1);

err1:

    kfree(pdata);

    printk(KERN_ERR "water probe failed\n");

    return -EINVAL;

}

static int water_remove(struct platform_device *pdev)

{

    gpio_free(pdata->machine_gpio);

    gpio_free(pdata->humidity_gpio3);

    gpio_free(pdata->humidity_gpio2);

    gpio_free(pdata->humidity_gpio1);

    del_timer(&(pdata->watertime));

    kfree(pdata);

    

    return 0;

}

static struct of_device_id water_match_table[] = {

    { .compatible = "thundersoft,water"},

    { },

};

static struct platform_driver water_driver = {

    .probe = water_probe,

    .remove = water_remove,

    .driver = {

        .owner = THIS_MODULE,

        .name = "water",

        .of_match_table = water_match_table,

    },

};

module_platform_driver(water_driver);

MODULE_AUTHOR("heql0703@thundersoft.com");

MODULE_LICENSE("GPL");