基于Dragonboard 410c的智能遥控器（二）

最新推荐文章于 2018-02-09 17:14:41 发布
最新推荐文章于 2018-02-09 17:14:41 发布
阅读量770 收藏
点赞数
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/s_jason/article/details/77528939
本文介绍了一款基于ET4007芯片的智能遥控器驱动程序设计与实现，通过GPIO模拟I2C通信，实现了遥控信号的发送与接收等功能。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

     之前已经做过智能遥控器的硬件介绍，这里就不再详细赘述了，现在主要看看软件实现。


#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/poll.h>
#include <linux/fb.h>
#include <linux/slab.h>
#include <linux/miscdevice.h>
#include <linux/delay.h>
#include <linux/timer.h>
#include <linux/jiffies.h>
#include <linux/platform_device.h>
#include <linux/irq.h>
#include <asm/irq.h>
#include <asm/io.h>
#include <linux/gpio.h>
#include <linux/of_gpio.h>
#include "et4007.h"

#define DEVICE_NAME        "irremote"
#define DRIVER_NAME        "et4007"

#define START_DELAY     200
#define STOP_DELAY      200
#define CLK_DELAY       50
.............

.............
static DECLARE_WAIT_QUEUE_HEAD(remote_waitq);

static volatile int busy_status = 0;
struct timer_list remote_timer;
struct class *et4007_class = NULL;
...............
...............

static int et4007_compare_alldata(struct remote_data rmt_data, uint16_t *sample, int index)
{
    int i;
    uint16_t timeHigh, timeLow;

    for (i = 0; i < index; i += 2) {
        timeHigh = sample[i];
        timeLow = sample[i + 1];
        if (et4007_compare_time(rmt_data, timeHigh, timeLow)) {
            return 1; // rmt_data is equal sample data
        }
    }
    return 0; // rmt_data is not equal sample data
}

static void et4007_push_sample_time_data(struct remote_data data, uint16_t *sample, int index)
{
    sample[index] = data.high_level;
    sample[index + 1] = data.low_level;
}


............

int et4007_get_index(struct remote_data data, uint16_t *sample, int index)
{
    int i = 0;
    uint16_t timeHigh, timeLow;
    for (i = 0; i < index; i += 2) {
        timeHigh = sample[i];
        timeLow = sample[i+1];
        if (et4007_compare_time(data, timeHigh, timeLow)) {
            return i;
        }
    }
    return 32;
}


static int et4007_get_data_index(struct ir_remocon_data *ir_data)
{
    int i, j = 0, count = 0;
    char temp;
    struct remote_data rmt_data;

    for (i = 0; i < ir_data->count; i += 2) {
        rmt_data.high_level = ir_data->original[i];
        rmt_data.low_level = ir_data->original[i+1];

        temp = et4007_get_index(rmt_data, ir_data->sample, ir_data->index);
        if (temp > 32) {
            return -1;
        }
        ir_data->data[count++] = (temp / 2) ;
    }

    ir_data->couple = count;
    i = 0;
    j = 0;
    while (i < count) {
        temp = (ir_data->data[i++] << 4) & 0xf0;
        temp |= (ir_data->data[i++]) & 0x0f;
        ir_data->data[j++] = temp;

        if (j > MAX_DATA) {
            j = MAX_DATA;
            return -1;
        }
    }

    ir_data->data_count = j;

    return j;
}

static int et4007_depress_sample(struct ir_remocon_data *ir_data)
{
    int i, j = 0;
    if (ir_data->index>MAX_SAMPLE_INDEX){
        ir_data->index = MAX_SAMPLE_INDEX;
        return -1;
    }

    for (i = 0; i < ir_data->index; i++) {
        ir_data->zp_sample[j++] = (uint8_t)(ir_data->sample[i] >> 8) & 0xff;
        ir_data->zp_sample[j++] = (uint8_t)ir_data->sample[i];
    }
    ir_data->index = j;
    return j;
}

..............

static void remote_timer_handle(unsigned long data)
{
    if (!busy_status) {
        mod_timer(&remote_timer,jiffies+msecs_to_jiffies(100));
        if (!ET4007_GET_BUSY_STATE()) {
            busy_status = 1;
            wake_up_interruptible(&remote_waitq);
        }
    }
}

void et4007_start(void)
{
    ET4007_SET_SDA_OUTPUT();
    ET4007_SET_SDA_HIGH();
    ET4007_SET_SCL_OUTPUT();
    ET4007_SET_SCL_HIGH();
    ET4007_SET_SDA_LOW();
    udelay(START_DELAY);
    udelay(START_DELAY);
    udelay(START_DELAY);
    ET4007_SET_SCL_LOW();
    udelay(START_DELAY);
    udelay(START_DELAY);
}

void et4007_stop(void)
{
    udelay(STOP_DELAY);
    ET4007_SET_SDA_LOW();
    ET4007_SET_SDA_OUTPUT();
    udelay(STOP_DELAY);
    ET4007_SET_SCL_HIGH();
    udelay(STOP_DELAY);
    ET4007_SET_SDA_HIGH();
    udelay(STOP_DELAY);
    //ET4007_SET_SDA_INPUT();
    udelay(STOP_DELAY);
}

int et4007_i2c_write_byte(uint8_t dat)
{
    int err = 0;
    uint8_t i, dat_temp;

    dat_temp = dat;
    ET4007_SET_SDA_OUTPUT();
    for (i = 0; i < 8; i++) {
        udelay(10);
        if (dat_temp & 0x80) {
            ET4007_SET_SDA_HIGH();
        } else {
            ET4007_SET_SDA_LOW();
        }
        udelay(CLK_DELAY);
        ET4007_SET_SCL_HIGH();
        dat_temp <<= 1;
        udelay(CLK_DELAY);  // optional
        ET4007_SET_SCL_LOW();
        udelay(CLK_DELAY);
    }
    ET4007_SET_SDA_HIGH();
    ET4007_SET_SDA_INPUT();
    udelay(CLK_DELAY);
    ET4007_SET_SCL_HIGH();
    udelay(CLK_DELAY);
    //if(ET4007_GET_SDA_STATE())err=1;
    //else err=0;
    ET4007_SET_SCL_LOW();
    udelay(CLK_DELAY);

    return err;
}

uint8_t et4007_i2c_read_byte(void)
{
    uint8_t dat, i;

    ET4007_SET_SDA_HIGH();
    ET4007_SET_SDA_INPUT();
    dat = 0;
    for (i = 0; i != 8; i++) {
        udelay(CLK_DELAY);
        ET4007_SET_SCL_HIGH();
        udelay(CLK_DELAY);
        dat <<= 1;
        if(ET4007_GET_SDA_STATE()) dat++;
        ET4007_SET_SCL_LOW();
        udelay(10);
    }

    ET4007_SET_SDA_OUTPUT();
    ET4007_SET_SDA_LOW();
    udelay(CLK_DELAY);
    ET4007_SET_SCL_HIGH();
    udelay(CLK_DELAY);
    ET4007_SET_SCL_LOW();
    udelay(CLK_DELAY);

    return dat;
}


static int et4007_read_device_info(void)
{
    int ret = 0;
    int i;
    char buf[8] = {0};
    pr_info("%s: +\n", __func__);

    et4007_start();

    /* write addr and cmd */
    et4007_i2c_write_byte(ET4007_ADDRESS);
    et4007_i2c_write_byte(ET4007_CONTROL_READ_VERSION);

    /* read device info */
    for (i = 0; i < 4; i++) {
        buf[i] = et4007_i2c_read_byte();
    }

    et4007_stop();

    pr_info("%s: dev_id: 0x%02x, 0x%02x, 0x%02x, 0x%02x \n", __func__,
            buf[0], buf[1], buf[2], buf[3]);

    ret = buf[0]*0x1000000 + buf[1]*0x10000 + buf[2]*0x100 + buf[3];

    pr_info("%s: -\n", __func__);
    return ret;
}

static long et4007_ioctl(struct file *filp, unsigned int cmd,unsigned long arg)
{
    int i;
    char buf[4];

...........

...........
    return 0;
}

static long et4007_ioctl_compat(struct file *filp, unsigned int cmd,unsigned long arg)
{
    int i;
    char buf[4];

    ...........

    ...........
    return 0;
}

static unsigned int et4007_poll( struct file *file,struct poll_table_struct *wait)
{
    unsigned int mask = 0;
    mod_timer(&remote_timer, jiffies + msecs_to_jiffies(40));
    poll_wait(file, &remote_waitq, wait);
    if (busy_status) {
        busy_status = 0;
        mask |= POLLIN | POLLRDNORM;
    }
    return mask;
}

static ssize_t et4007_write(struct file *file, const char *buffer, size_t count, loff_t *ppos)
{
    char send_buff[256];
    int ret;
    int i;

    if (count == 0) {
        return -1;
    }
    if(buffer[0]==ET4007_CONTROL_SEND_CODE_3) {
        if (count > 384) {
            printk("ET4007---count error---\n");
            return -1;
        }
        et4007_start();
        et4007_i2c_write_byte(ET4007_ADDRESS);
        for (i = 0; i < count; i++) {
            et4007_i2c_write_byte(buffer[i]);
        }
        et4007_stop();
        return count;
    } else if (buffer[0] == ET4007_CONTROL_SEND_CODE_1) {
        if (count> 129) {
            count = 129;
            printk("ET4007---size error---\n");
            return count;
        }
        memset(send_buff,0x00,129);
        ret = copy_from_user(send_buff, buffer, count) ;

        if (ret) {
            printk("ET4007---copy error---\n");
            return ret;
        }
        et4007_start();
        et4007_i2c_write_byte(ET4007_ADDRESS);
        for (i = 0; i < 129; i++) {
            et4007_i2c_write_byte(send_buff[i]);
        }
        et4007_stop();
        return count;
    } else {
        printk("ET4007---command  error---\n");
        return -1;
    }
    return count;
}

static ssize_t et4007_read(struct file *filp, char *buff,size_t count, loff_t *ppos)
{
    int i, err;
    int ET_crc;
    int ET_PartIndexCount;
    int ET_Sample;
    int ET_Index;
    int ET_Freq;
    int m = 0;
    int max = 0;
    char buf_ir_test[384];

    pr_info("%s: +\n", __func__);

    et4007_start();
    et4007_i2c_write_byte(ET4007_ADDRESS);
    et4007_i2c_write_byte(ET4007_CONTROL_READ_CODE);
    ET_crc = et4007_i2c_read_byte();
    buf_ir_test[m++] = ET_crc;
    ET_PartIndexCount = et4007_i2c_read_byte();
    buf_ir_test[m++] = ET_PartIndexCount;
    ET_Sample = et4007_i2c_read_byte();
    buf_ir_test[m++] = ET_Sample;
    ET_Index = et4007_i2c_read_byte();
    buf_ir_test[m++] = ET_Index;
    ET_Freq = et4007_i2c_read_byte();
    buf_ir_test[m++] = ET_Freq;
    max = ET_PartIndexCount+ET_Sample+ET_Index;
    if (max > 380) {
        et4007_stop();
        return  -EFAULT;
    }

    for (i = 0; i < max; i++) {
        buf_ir_test[m] = et4007_i2c_read_byte();
        m++;
    }

    et4007_stop();

    if (m > sizeof(buf_ir_test)) {
        m = sizeof(buf_ir_test);
    }

    err = copy_to_user((void *)buff, (const void *)(&buf_ir_test[0]), m);

    pr_info("%s: -\n", __func__);

    return err ? -EFAULT : m;
}

static int et4007_open(struct inode *inode, struct file *file)
{
    et4007_read_device_info();
    setup_timer(&remote_timer, remote_timer_handle, (unsigned long)"remote");
    return 0;
}

static int et4007_close(struct inode *inode, struct file *file)
{
    del_timer_sync(&remote_timer);
    return 0;
}

static struct file_operations et4007_fops = {
    .owner            = THIS_MODULE,
    .open            = et4007_open,
    .release        = et4007_close,
    .write          = et4007_write,
    .read            = et4007_read,
    .poll            = et4007_poll,
    .unlocked_ioctl    = et4007_ioctl,
#ifdef CONFIG_COMPAT
    .compat_ioctl   = et4007_ioctl_compat,
#endif
};

static void et4007_remocon_work(struct ir_remocon_data *ir_data)
{
    struct ir_remocon_data *data = ir_data;
    int sleep_timing;
    int emission_time;
    int i;

    //mutex_lock(&data->mutex);

    et4007_start();
    et4007_i2c_write_byte(ET4007_ADDRESS);
    for (i = 0; i < ir_data->length; i++) {
        et4007_i2c_write_byte(ir_data->signal[i]);
    }
    et4007_stop();

    //mutex_unlock(&data->mutex);

    emission_time = ( (data->ir_sum) * (data->freq) * 4 / 5000);
    sleep_timing = emission_time -10;
    if (sleep_timing < 0) {
        sleep_timing = 10;
    }

    data->freq = 0;
    data->ir_sum = 0;
}

static ssize_t et4007_ir_send_store(struct device *dev, struct device_attribute *attr,
        const char *buf, size_t size)
{
    unsigned int data;
    int err;
    int count = 0, i;

    ir_data->count = 0;
    ir_data->send_flag = 1;
...................
...................
    if (ir_data->count < 5) {
        printk("data->count < 5 error \n\r");
        return -1;
    }

    err = et4007_compress_original_data(ir_data);
    if (err < 0) {
        printk("et4007_compress_original_data  error \n\r");
        return -1;
    }

    et4007_remocon_work(ir_data);

    return size;
}

static ssize_t et4007_ir_send_show(struct device *dev, struct device_attribute *attr, char *buf)
{
    int i;
    int len = 0;
    char buf_read[8] = {0};

............

............
    return len;
}

static DEVICE_ATTR(ir_send, 0664, et4007_ir_send_show, et4007_ir_send_store);

static ssize_t et4007_ir_learn_store(struct device *dev, struct device_attribute *attr,
        const char *buf, size_t size)
{
    unsigned int data;

    if (sscanf(buf++, "%u", &data) == 1) {
  .......................
    }
    return size;
}

static ssize_t et4007_ir_learn_show(struct device *dev, struct device_attribute *attr, char *buf)
{
    int crc, part_index_count, sample, index, freq;
    int i, m = 0, max = 0, len = 0;
    char buf_read[386] = {0};

    et4007_start();
    et4007_i2c_write_byte(ET4007_ADDRESS);
    et4007_i2c_write_byte(ET4007_CONTROL_READ_CODE);

    /* crc */
    crc = et4007_i2c_read_byte();
    buf_read[m++] = crc;

    /* part index count */
    part_index_count = et4007_i2c_read_byte();
    buf_read[m++] = part_index_count;

    /* sample */
    sample = et4007_i2c_read_byte();
    buf_read[m++] = sample;

    /* index */
    index = et4007_i2c_read_byte();
    buf_read[m++] = index;

    /* freq */
    freq = et4007_i2c_read_byte();
    buf_read[m++] = freq;

    pr_info("%s: part_index_count = %d, sample = %d, index = %d\n", __func__,
            part_index_count, sample, index);

    max = part_index_count + sample + index;
    if (max > 380) {
        et4007_stop();
        sprintf(buf, "error");
        return len;
    }

    for (i = 0; i < max; i++) {
        buf_read[m] = et4007_i2c_read_byte();
        m++;
    }

    et4007_stop();

    for (i = 0; i < m; i++) {
        if (i == 0) {
            len = sprintf(buf, "%d", buf_read[i]);
        } else {
            len += sprintf(buf + len, ",%d", buf_read[i]);
        }
        //pr_info("%s: learn data[%d] = %d\n", __func__, i, buf_read[i]);
    }
    pr_info("\n");
    len += sprintf(buf + len, "\n");
    return    len;
}
static DEVICE_ATTR(ir_learn, 0664, et4007_ir_learn_show, et4007_ir_learn_store);

static ssize_t et4007_ir_state_show(struct device *dev, struct device_attribute *attr, char *buf)
{
    int len = 0;
    if (ET4007_GET_BUSY_STATE()) {
        len = sprintf(buf + len, "%d\n", 1);
    } else {
        len = sprintf(buf + len, "%d\n", 0);
    }
    return    len;
}
static DEVICE_ATTR(ir_state, 0444, et4007_ir_state_show, NULL);

static ssize_t et4007_ir_info_show(struct device *dev, struct device_attribute *attr, char *buf)
{
    int i, len = 0;
    len += sprintf(buf + len, "%d,", ir_data->send_flag);
    len += sprintf(buf + len, "%d,", ir_data->orig_freq);
    for (i = 0; i < ir_data->count; i++) {
        len += sprintf(buf + len, "%d,", ir_data->original[i]);
    }

    len += sprintf(buf + len, "\n");
    ir_data->send_flag = 0;
    return    len;
}
static DEVICE_ATTR(ir_info, 0444, et4007_ir_info_show, NULL);

static int et4007_parse_dt(struct device *dev)
{
    if (!dev || !dev->of_node || !ir_data)
        return -1;

    ir_data->clk_gpio = of_get_named_gpio_flags(dev->of_node, "etek,clk-gpio", 0, NULL);
    if (!gpio_is_valid(ir_data->clk_gpio)) {
        pr_err("%s: clk gpio is invalid !\n ", __func__);
        return ir_data->clk_gpio;
    }

    pr_info("%s: clk gpio = %d\n", __func__, ir_data->clk_gpio);

    ir_data->sda_gpio = of_get_named_gpio_flags(dev->of_node, "etek,sda-gpio", 0, NULL);
    if (!gpio_is_valid(ir_data->sda_gpio)) {
        pr_err("%s: sda gpio is invalid\n ", __func__);
        return ir_data->sda_gpio;
    }

    pr_info("%s: sda gpio = %d\n", __func__, ir_data->sda_gpio);

    ir_data->busy_gpio = of_get_named_gpio_flags(dev->of_node, "etek,busy-gpio", 0, NULL);
    if (!gpio_is_valid(ir_data->busy_gpio)) {
        pr_err("%s: busy gpio is invalid\n ", __func__);
        return ir_data->busy_gpio;
    }

    pr_info("%s: busy gpio = %d\n", __func__, ir_data->busy_gpio);

    return 0;
}

static struct miscdevice et4007_misc_dev = {
    .minor = MISC_DYNAMIC_MINOR,
    .name = DEVICE_NAME,
    .fops = &et4007_fops,
};

static int et4007_probe(struct platform_device *pdev)
{
    struct device *ir_remocon_dev;
    int error;
    pr_info("%s: +\n", __func__);
#ifdef ET_POWERCONTROL
    ET4007_SET_POWER_HIGH();
    mdelay(1);
#endif
    ir_data = kzalloc(sizeof(struct ir_remocon_data), GFP_KERNEL);
    if (NULL == ir_data) {
        pr_err("%s: failed to kzalloc memory for ir_data !\n", __func__);
        error = -ENOMEM;
        goto err_free_mem;
    }

    error = et4007_parse_dt(&pdev->dev);
    if (error) {
        pr_err("%s: failed to parse dt !\n", __func__);
        return error;
    }

    error = gpio_request(ET4007_SCL_GPIO, DEVICE_NAME);
    if (error) {
        pr_err("%s: failed to request scl gpio (%d) !\n", __func__, ET4007_SCL_GPIO);
        return error;
    }

    error = gpio_request(ET4007_SDA_GPIO, DEVICE_NAME);
    if (error) {
        pr_err("%s: failed to request sda gpio (%d) !\n", __func__, ET4007_SDA_GPIO);
        return error;
    }

    error = gpio_request(ET4007_BUSY_GPIO, DEVICE_NAME);
    if (error) {
        pr_err("%s: failed to request busy gpio (%d) !\n", __func__, ET4007_BUSY_GPIO);
        return error;
    }

    et4007_class = class_create(THIS_MODULE, "etek");
    if (IS_ERR(et4007_class)) {
        pr_err("%s: failed to create class(etek)!\n", __func__);
        return PTR_ERR(et4007_class);
    }

    ir_remocon_dev = device_create(et4007_class, NULL, 0, ir_data, "sec_ir");

    if (IS_ERR(ir_remocon_dev))
        pr_err("%s: failed to create ir_remocon_dev device\n", __func__);

    if (device_create_file(ir_remocon_dev, &dev_attr_ir_send) < 0)
        pr_err("%s: failed to create device file(%s)!\n", __func__,
                dev_attr_ir_send.attr.name);

    if (device_create_file(ir_remocon_dev, &dev_attr_ir_state) < 0)
        pr_err("%s: failed to create device file(%s)!\n", __func__,
                dev_attr_ir_state.attr.name);

    if (device_create_file(ir_remocon_dev, &dev_attr_ir_learn) < 0)
        pr_err("%s: failed to create device file(%s)!\n", __func__,
                dev_attr_ir_learn.attr.name);

    if (device_create_file(ir_remocon_dev, &dev_attr_ir_info) < 0)
        pr_err("%s: failed to create device file(%s)!\n", __func__,
                dev_attr_ir_info.attr.name);

    ET4007_SET_SCL_OUTPUT();
    ET4007_SET_SDA_OUTPUT();
    ET4007_SET_BUSY_INPUT();
    ET4007_SET_SCL_HIGH();
    ET4007_SET_SDA_HIGH();

    et4007_read_device_info();

    pr_info("%s: -\n", __func__);

    return error;
err_free_mem:
#ifdef ET_POWERCONTROL
    ET4007_SET_POWER_LOW();
#endif
    kfree(ir_data);
    ir_data = NULL;
    return error;
}

static int et4007_remove(struct platform_device *pdev)
{
    if (et4007_class)
        device_destroy(et4007_class, 0);

    if (ir_data)
        kfree(ir_data);

    return 0;
}

static struct of_device_id et4007_match_table[] = {
    {.compatible = "etek,ir", },
    { },
};

static struct platform_driver et4007_driver = {
    .probe    = et4007_probe,
    .remove   = et4007_remove,
    // .suspend  = et4007_suspend,
    //  .resume   = et4007_resume,
    .driver   = {
        .owner   = THIS_MODULE,
        .name    = DEVICE_NAME,
        .of_match_table = et4007_match_table,
    },
};

static int __init et4007_init(void)
{
    if(misc_register(&et4007_misc_dev)) {
        pr_err("%s: misc_register register failed\n", __func__);
    }
    return platform_driver_register(&et4007_driver);
}

static void __exit et4007_exit(void)
{
    misc_deregister(&et4007_misc_dev);
    platform_driver_unregister(&et4007_driver);
}

module_init(et4007_init);
module_exit(et4007_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("ETEK Inc.");
MODULE_DESCRIPTION("ETEK consumerir Driver");

我们是用gpio模拟的i2c，所以代码比较冗长，但是功能还是可以的。有兴趣的话可以自己动手试一下。

s_jason
关注
基于DragonBoard 410C的智能空调系统方案
weixin_43735236的博客
02-18 3
一、前言 日常生活工作中，有些场合需要特定的环境条件，如我们平时的电子设计实验室、舒适的婴儿寝室，对环境要求比较高，其中包括两个重要参数：温度、湿度，今天我们就基于DragonBoard410C做一个智能空调系统方案。 二、概述 如下图，原理很简单，我们就基于DragonBoard410C结合日常现有的空调机搭建了一个原理框图，因为要保证现有空调机完整的前提下进行，那么就我们...
基于DragonBoard 410c的彩灯设计（一）
He Qiliang
02-28 689
春节期间，城市中张灯结彩，举办节目来庆祝节日。LED彩灯由于其丰富的灯光色彩，低廉的造价以及控制简单等特点而得到广泛的应用，用彩灯来装饰街道和城市建筑物已经成为一种时尚。本博客和大家分享一下如何用DragonBoard 410c开发板实现对LED彩灯的控制。     本设计的采用的可编程彩灯带实物如图1所示： 图1 基本参数： 颜色： 全彩 防水等级：IP20（不
基于Dragonboard 410c的智能遥控器（一）
s_jason的博客
07-27 1347
现在电视机、冰箱、空调基本上已经是家家户户的标配了，那么对他们的操作和控制就是一个必不可少的过程了，最简单直接的就是遥控器了。以前的遥控器只能是一对一的控制，并且都是用的机械按键。随着物联网和智能家居概念的提出，越来越多的家用电器都可以通过网络来控制，并且配有体验效果很好的各色app，于是心血来潮，打算用dragonboard 410c的开发板做一个智能遥控器，先来看一下做智能遥控器需要些什么。
ET学习资料
nie341的博客
02-09 371
使用笔记：https://1090268920.docs.qq.com/JgzDmLgZnGK 数据库：http://www.runoob.com/mongodb/mongodb-window-install.html Actor：http://www.tinkingli.com/?p=117   学习笔记：http://www.liuocean.com/ 默认版本 2017.1.3p2 ...
基于Dragonboard410c的智能音箱（四）
尪錓chengx的博客
09-07 813
底层的驱动代码和相关的DTS文件都已经配置好了，开始实现应用的代码了，我们先来实现音乐播放器的基础功能。实现一个音乐播放器，可以直接扫描板子上的所有音乐并列出歌曲清单，同时可以控制进行音乐播放、停止、上一首、下一首。public class MainActivity extends Activity implements View.OnClickListener { private Butto
基于Dragonboard410c的智能音箱（五）
尪錓chengx的博客
09-14 656
前面我们已经简单的实现了一个音乐播放器，接下来就应该把讯飞的语音识别模块给合进去，实现我们的智能语音控制功能。我们可以设计成这样，在语音控制之前，我们按一下前面实现的按键功能，作为开始输入语音的信号，然后只要识别出我们的几个关键字“play/stop/next/last”，就按照不同的关键字进行相应的操作，如果识别到其他语音信息，就不做任何处理。下面是我的实现代码：public class Main
基于Dragonboard410c的智能音箱（二）
尪錓chengx的博客
09-07 789
上篇我们简单调研了一下语音识别技术，并准备使用国内语音识别做的比较好的科大讯飞提供的SDK包来进行开发。一、实现需求基础功能：应用可以直接扫描sd上的所有音乐并列出歌曲清单，同时可以控制进行音乐播放、停止、上一首、下一首。语音控制功能：通过对智能音箱说出关键字play、stop、next、last，可以语音控制应用实现音乐的播放、停止、上一首、下一首功能。二、硬件准备１、一块Dragonboard
基于DragonBoard 410c平台的移动图像监测系统
ANDYMFC的博客
08-09 1453
移动图像监测在智能监控、智能家居系统中有着非常广泛的应用，本文介绍了如何利用410c平台和motion开元移动监测软件来搭建简单的移动监测系统，该demo可以让开发者快速的在自己的410c产品中添加自己的移动监测应用。
基于Dragonboard 410c设计的智能管家
s_jason的博客
08-31 796
现在智能家居是个很热门的话题，也是将科技融入生活的很好的一种方式。现在网络上可以看到格式各样的智能音箱产品，比较火的像：小雅、天猫精灵、小米AI等。这些音箱不但有小巧可爱的外观，功能也是相当强悍的，基本上都集成了以下功能：语音遥控、语音点播、语音控制家电等。       这是个不错的产品，所以我们打算利用Dragonboard 410c也做一个智能音箱，首先是调研和硬件准备。       稍后
基于Dragonboard 410c的智能魔镜设计(8)-python脚本实现UI原型.docx
06-25
在本篇文档中，我们将探讨如何使用Python脚本来实现基于Dragonboard 410c的智能魔镜的UI原型设计。Dragonboard 410c是一款小巧而强大的开发板，适用于各种嵌入式项目，包括智能魔镜。在这个项目中，UI设计是至关重要...
基于Dragonboard 410c的智能魔镜设计(8)-python脚本实现UI原型.pdf
06-25
在本篇技术文章中，我们将探讨如何利用Python脚本实现基于Dragonboard 410c的智能魔镜的UI原型设计。Dragonboard 410c是一款基于Qualcomm Snapdragon 410处理器的开发板，适合开发嵌入式系统和物联网(IoT)应用。在...
基于DragonBoard 410c的遥控炮台一之舵机驱动(上)
ad3600的博客
03-02 5068
一.舵机介绍 1.舵机简介 舵机（英文叫Servo）：它由直流电机、减速齿轮组、传感器和控制电路组成的一套自动控制系统。最早的舵机是船舶上的一种大甲板机械。舵机的大小由外舾装按照船级社的规范决定，选型时主要考虑扭矩大小，通过发送信号，指定输出轴旋转角度。随着科技的发展与开发的需要(航模，微型机器人等)，小型的舵机逐渐在市场上出现。舵机一般而言都有最大旋转角度（比如180度。）与普通直流电机的区
基于DragonBoard 410c的遥控炮台二之舵机驱动(下)
ad3600的博客
03-02 1690
一.背景 在上篇，博主给大家介绍了关于舵机的相关知识以及PWM的控制原理，并且根据410c的特点写了个GPIO口模拟PWM的驱动，但是尽管输出的波形图还算稳定,但相对来讲，PWM作为稳定的硬件通讯信号，是需要时刻保持信号的输出，换言之，假如一个周期20ms，脉宽50%的波形，CPU平均在10ms内调度GPIO进行实时电平改变。上篇博客的stree.c驱动里，我们采用在工作队列里udelay的方式
电赛历年试题&经验分享.7z
08-12
电赛历年试题&经验分享.7z
PLC立体车库智能仿真系统：基于博途V15的西门子1200PLC控制与触摸屏操作 - PLC编程 v1.5
08-12
基于博途V15软件平台构建的3×2立体车库智能仿真系统。该系统采用西门子1200PLC进行控制，配备触摸屏操作界面，实现了自动出入库、电梯式小车移动以及变频器输出等功能。文中展示了详细的程序注释和模块化编程方法，如使用TON定时器实现载车板升降的速度控制，利用FC块封装车辆检测模块，通过GRAPH语言编写自动出入库逻辑等。此外，还提到了系统的IO表设计和故障处理机制，以及未来可能加入AI算法进行智能车位分配的设想。 适合人群：对PLC编程、工业自动化控制系统感兴趣的工程师和技术爱好者。 使用场景及目标：适用于学习和研究PLC编程技巧、工业自动化控制系统的仿真开发，帮助理解和掌握PLC控制逻辑、触摸屏交互设计、变频器仿真等关键技术。 其他说明：该项目不仅提供了完整的源代码和详细的注释，还能在博途PLCSIM Advanced环境中进行全仿真测试，为实际工程应用提供宝贵的经验和参考。
LuWu-陆吾，一个简单的无代码深度学习平台
08-12
资源下载链接为： https://pan.quark.cn/s/2f73b93e37c3 LuWu——陆吾，一个简单的无代码深度学习平台。（最新、最全版本！打开链接下载即可用！）
Python自动化测试框架pytest入门与实战.doc
08-12
Python自动化测试框架pytest入门与实战.doc
统计学习,机器学习,神经网络,深度学习,使用matlab实现
08-12
资源下载链接为： https://pan.quark.cn/s/6c421a94aa8d 统计学习,机器学习,神经网络,深度学习,使用matlab实现.（最新、最全版本！打开链接下载即可用！）
基于springboot的物流管理平台设计与实现.docx
最新发布
08-12
基于springboot的物流管理平台设计与实现
dragonboard410c烟雾报警器Python
10-27
DragonBoard410c是一款基于ARM Cortex-A53的开发板，而烟雾报警器是一种用于检测烟雾并发出警报的设备。Python是一种流行的编程语言，可以在DragonBoard410c上使用。因此，可以使用Python编写烟雾报警器程序并在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值