tiny4412 linux-4.2 移植（六）加速度传感器mma7660

最新推荐文章于 2022-09-08 20:44:51 发布
最新推荐文章于 2022-09-08 20:44:51 发布
阅读量2.6k 收藏 1
点赞数
分类专栏： Tiny4412 Linux_4.2移植 文章标签： tiny4412 linux-4.2 linux移植
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_27136111/article/details/102614173
版权

简介

mm7660跟exynos 4412通过i2c进行通信，它所占用的引脚有：中断引脚XEINT25、i2c数据线i2cSDA3_OUT和i2c时钟线i2cSCL3_OUT。上上节我们已经了解了samsung的i2c控制器，现在我们需要在dts中配置i2c相关信息，然后移植mma7660驱动到linux-4.20。
在这里插入图片描述
在这里插入图片描述

dts

mma7660使用的是i2c3，所以这里需要配置i2c3。

&i2c_3 {
    samsung,i2c-sda-delay = <100>;    //esynos4412所有dts中的delay都是100，所以这个选择100
    samsung,i2c-max-bus-freq = <200000>;    //最高400 kbit/s，当然你可以填100000 Supports up to 400 kbit/s in the Fast mode.
    status = "okay";
    mma7660: mma7660@4c {
        compatible = "tiny4412,mma7660";
        reg = <0x4c>;			//设备地址
        interrupt-parent = <&gpx3>;
        interrupts = <1 IRQ_TYPE_EDGE_FALLING>;    /* 选中的是GPX3_1  */
        input_fuzz = <4>;
        input_flat = <4>;
        poll_interval = <100>;
        status = "okay";
    };
};

mma7660.c

mma7660的移植参考友善之臂官方的驱动程序就行了，下面是我移植后的程序。

diff --git a/drivers/input/misc/Kconfig b/drivers/input/misc/Kconfig
old mode 100644
new mode 100755
index ca59a2b..79b52da
--- a/drivers/input/misc/Kconfig
+++ b/drivers/input/misc/Kconfig
@@ -12,6 +12,12 @@ menuconfig INPUT_MISC
if INPUT_MISC
+config INPUT_MMA7660
+       tristate "Tiny4412 Accelerometer mma7660"
+       help
+               Say Y here to support Accelerometer mma7660 for tiny4412.
+               If unsure, say N.
+
config INPUT_88PM860X_ONKEY
        tristate "88PM860x ONKEY support"
        depends on MFD_88PM860X
diff --git a/drivers/input/misc/Makefile b/drivers/input/misc/Makefile
old mode 100644
new mode 100755
index 9d0f9d1..2aa2600
--- a/drivers/input/misc/Makefile
+++ b/drivers/input/misc/Makefile
@@ -5,6 +5,7 @@
# Each configuration option enables a list of files.
+obj-$(CONFIG_INPUT_MMA7660)         += mma7660.o
obj-$(CONFIG_INPUT_88PM860X_ONKEY)     += 88pm860x_onkey.o
obj-$(CONFIG_INPUT_88PM80X_ONKEY)      += 88pm80x_onkey.o
obj-$(CONFIG_INPUT_AB8500_PONKEY)      += ab8500-ponkey.o

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/i2c.h>
#include <linux/input.h>
#include <linux/hwmon.h>
#include <linux/hwmon-sysfs.h>
#include <linux/input-polldev.h>
#include <linux/of_device.h>
#include <linux/interrupt.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/mutex.h>
#include <linux/log2.h>
#include <linux/bitops.h>
#include <linux/jiffies.h>
#include <linux/property.h>
#include <linux/acpi.h>
#include <linux/regmap.h>
#include <linux/pm_runtime.h>
#include <linux/gpio/consumer.h>
#include <linux/err.h>
/* MMA7760 Registers */
#define MMA7660_XOUT            0x00    // 6-bit output value X
#define MMA7660_YOUT            0x01    // 6-bit output value Y
#define MMA7660_ZOUT            0x02    // 6-bit output value Z
#define MMA7660_TILT            0x03    // Tilt status
#define MMA7660_SRST            0x04    // Sampling Rate Status
#define MMA7660_SPCNT            0x05    // Sleep Count
#define MMA7660_INTSU            0x06    // Interrupt Setup
#define MMA7660_MODE            0x07    // Mode
#define MMA7660_SR                0x08    // Auto-Wake/Sleep and Debounce Filter
#define MMA7660_PDET            0x09    // Tap Detection
#define MMA7660_PD                0x0a    // Tap Debounce Count
static const char *mma7660_bafro[] = {
    "Unknown", "Front", "Back"
};
static const char *mma7660_pola[] = {
    "Unknown",
    "Left", "Right",
    "Rsvd", "Rsvd",
    "Down", "Up",
    "Rsvd",
};
#define MMA7660_NAME    "mma7660"
#define INPUT_FUZZ            4    //default vale
#define INPUT_FLAT            4    //default vale
#define POLL_INTERVAL        100    //default vale
#define __need_retry(__v)    (__v & (1 << 6))
#define __is_negative(__v)    (__v & (1 << 5))
static int                    last_tilt = 0;
static struct device        *hwmon_dev;
struct regmap *g_regmap = NULL;
static struct input_polled_dev    *mma7660_idev;
static struct i2c_client    *mma7660_client;
static const struct i2c_device_id mma7660_id[] = {
    { MMA7660_NAME, 0 },
    { },
};
MODULE_DEVICE_TABLE(i2c, mma7660_id);


static const struct of_device_id mma7660_dt_ids[] = {
    { .compatible = "tiny4412,mma7660", },
    { /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, mma7660_dt_ids);
static int mma7660_read_xyz(struct i2c_client *client, int idx, int *xyz)
{
    int val;
    do {
        val = i2c_smbus_read_byte_data(client, idx + MMA7660_XOUT);
        if (val < 0) {
            dev_err(&client->dev, "Read register %02x failed, %d\n",
                    idx + MMA7660_XOUT, val);
            return -EIO;
        }
    } while (__need_retry(val));
    *xyz = __is_negative(val) ? (val | ~0x3f) : (val & 0x3f);
    return 0;
}
static int mma7660_read_tilt(struct i2c_client *client, int *tilt)
{
    int val;
    do {
        val = i2c_smbus_read_byte_data(client, MMA7660_TILT);
        if (val < 0) {
            dev_err(&client->dev, "Read register %02x failed, %d\n",
                    MMA7660_TILT, val);
            return -EIO;
        }
    } while (__need_retry(val));
    *tilt = (val & 0xff);
    return 0;
}
static int mma7660_initialize(struct i2c_client *client)
{
    int val;
    /* Using test mode to probe chip */
    i2c_smbus_write_byte_data(client, MMA7660_MODE, 0x00);
    mdelay(10);
    i2c_smbus_write_byte_data(client, MMA7660_MODE, 0x04);
    mdelay(10);
    i2c_smbus_write_byte_data(client, MMA7660_XOUT, 0x3f);
    i2c_smbus_write_byte_data(client, MMA7660_YOUT, 0x01);
    i2c_smbus_write_byte_data(client, MMA7660_ZOUT, 0x15);
    val = i2c_smbus_read_byte_data(client, MMA7660_ZOUT);
    if (val != 0x15) {
        dev_err(&client->dev, "no device\n");
        return -ENODEV;
    }
    /* Goto standby mode for configuration */
    i2c_smbus_write_byte_data(client, MMA7660_MODE, 0x00);
    mdelay(10);
    /* Sample rate: 64Hz / 16Hz; Filt: 3 samples  */
    i2c_smbus_write_byte_data(client, MMA7660_SR, ((2<<5) | (1<<3) | 1));
    /* Sleep count */
    i2c_smbus_write_byte_data(client, MMA7660_SPCNT, 0xA0);
    /* Tap detect and debounce ~4ms */
    i2c_smbus_write_byte_data(client, MMA7660_PDET, 4);
    i2c_smbus_write_byte_data(client, MMA7660_PD, 15);
    /* Enable interrupt except exiting Auto-Sleep */
    i2c_smbus_write_byte_data(client, MMA7660_INTSU, 0xe7);
    /* IPP, Auto-wake, auto-sleep and standby */
    i2c_smbus_write_byte_data(client, MMA7660_MODE, 0x59);
    mdelay(10);
    /* Save current tilt status */
    mma7660_read_tilt(client, &last_tilt);
    mma7660_client = client;
    return 0;
}
/*-----------------------------------------------------------------------------
* sysfs group support
*/
static ssize_t mma7660_show_regs(struct device *dev,
        struct device_attribute *attr, char *buf)
{
    int reg, val;
    int i, len = 0;
    for (reg = 0; reg < 0x0b; reg++) {
        val = i2c_smbus_read_byte_data(mma7660_client, reg);
        len += sprintf(buf + len, "REG: 0x%02x = 0x%02x ...... [ ", reg, val);
        for (i = 7; i >= 0; i--) {
            len += sprintf(buf + len, "%d", (val >> i) & 1);
            if ((i % 4) == 0) {
                len += sprintf(buf + len, " ");
            }
        }
        len += sprintf(buf + len, "]\n");
    }
    return len;
}
static ssize_t mma7660_write_reg(struct device *dev,
        struct device_attribute *attr, const char *buf, size_t count)
{
    unsigned int reg, val;
    int ret;
    ret = sscanf(buf, "%x %x", &reg, &val);
    if (ret == 2) {
        if (reg >= 0 && reg <= 0x0a) {
            i2c_smbus_write_byte_data(mma7660_client, reg, val);
            val = i2c_smbus_read_byte_data(mma7660_client, reg);
            printk("REG: 0x%02x = 0x%02x\n", reg, val);
        }
    }
    return count;
}
static ssize_t mma7660_show_xyz_g(struct device *dev,
        struct device_attribute *attr, char *buf)
{
    int axis[3];
    int i;
    for (i = 0; i < 3; i++) {
        mma7660_read_xyz(mma7660_client, i, &axis[i]);
    }
    return sprintf(buf, "%3d, %3d, %3d\n", axis[0], axis[1], axis[2]);
}
static ssize_t mma7660_show_axis_g(struct device *dev,
        struct device_attribute *attr, char *buf)
{
    int n = to_sensor_dev_attr(attr)->index;
    int val;
    mma7660_read_xyz(mma7660_client, n, &val);
    return sprintf(buf, "%3d\n", val);
}
static ssize_t mma7660_show_tilt(struct device *dev,
        struct device_attribute *attr, char *buf)
{
    int val = 0, len = 0;
    mma7660_read_tilt(mma7660_client, &val);
    len += sprintf(buf + len, "%s", mma7660_bafro[val & 0x03]);
    len += sprintf(buf + len, ", %s", mma7660_pola[(val >> 2) & 0x07]);
    if (val & (1 << 5)) {
        len += sprintf(buf + len, ", Tap");
    }
    if (val & (1 << 7)) {
        len += sprintf(buf + len, ", Shake");
    }
    len += sprintf(buf + len, "\n");
    return len;
}
static SENSOR_DEVICE_ATTR(registers, 0660,mma7660_show_regs, mma7660_write_reg, 0);
static SENSOR_DEVICE_ATTR(x_axis_g, S_IRUGO, mma7660_show_axis_g, NULL, 0);
static SENSOR_DEVICE_ATTR(y_axis_g, S_IRUGO, mma7660_show_axis_g, NULL, 1);
static SENSOR_DEVICE_ATTR(z_axis_g, S_IRUGO, mma7660_show_axis_g, NULL, 2);
static SENSOR_DEVICE_ATTR(all_axis_g, S_IRUGO, mma7660_show_xyz_g, NULL, 0);
static SENSOR_DEVICE_ATTR(tilt_status, S_IRUGO, mma7660_show_tilt, NULL, 0);
static struct attribute* mma7660_attrs[] = {
    &sensor_dev_attr_registers.dev_attr.attr,
    &sensor_dev_attr_x_axis_g.dev_attr.attr,
    &sensor_dev_attr_y_axis_g.dev_attr.attr,
    &sensor_dev_attr_z_axis_g.dev_attr.attr,
    &sensor_dev_attr_all_axis_g.dev_attr.attr,
    &sensor_dev_attr_tilt_status.dev_attr.attr,
    NULL
};
static const struct attribute_group mma7660_group = {
    .attrs        = mma7660_attrs,
};
static void mma7660_worker(struct work_struct *work)
{
    int bafro, pola, shake, tap;
    int val = 0;
    mma7660_read_tilt(mma7660_client, &val);
    /* TODO: report it ? */
    bafro = val & 0x03;
    if (bafro != (last_tilt & 0x03)) {
        printk("%s\n", mma7660_bafro[bafro]);
    }
    pola = (val >> 2) & 0x07;
    if (pola != ((last_tilt >> 2) & 0x07)) {
        printk("%s\n", mma7660_pola[pola]);
    }
    shake = (val >> 5) & 0x01;
    if (shake && shake != ((last_tilt >> 5) & 0x01)) {
        printk("Tap\n");
    }
    tap = (val >> 7) & 0x01;
    if (tap && tap != ((last_tilt >> 7) & 0x01)) {
        printk("Shake\n");
    }
    /* Save current status */
    last_tilt = val;
}
DECLARE_WORK(mma7660_work, mma7660_worker);
static irqreturn_t mma7660_interrupt(int irq, void *data)
{
    printk("mma7660_interrupt\n");
    schedule_work(&mma7660_work);
    printk("mma7660_interrupt ok\n");
    return IRQ_HANDLED;
}
static void mma7660_report_abs(void)
{
    int axis[3];
    int i;
    for (i = 0; i < 3; i++) {
        mma7660_read_xyz(mma7660_client, i, &axis[i]);
    }
    input_report_abs(mma7660_idev->input, ABS_X, axis[0]);
    input_report_abs(mma7660_idev->input, ABS_Y, axis[1]);
    input_report_abs(mma7660_idev->input, ABS_Z, axis[2]);
    input_sync(mma7660_idev->input);


    //printk("3-Axis ... %3d, %3d, %3d\n", axis[0], axis[1], axis[2]);
}
static void mma7660_dev_poll(struct input_polled_dev *dev)
{
    mma7660_report_abs();
}
static int mma7760_probe(struct i2c_client *client,
             const struct i2c_device_id *id)
{
    struct device *dev = &client->dev;
    struct device_node *of_node = client->dev.of_node;
    struct regmap_config regmap_config = { };
    struct regmap *regmap;
    struct input_dev *idev;
    int input_fuzz = INPUT_FUZZ;
    int input_flat = INPUT_FLAT;
    int poll_interval = POLL_INTERVAL;
    int ret;
    u32 val;
    printk("enter %s\n", __func__);
    ret = i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE | I2C_FUNC_SMBUS_BYTE_DATA);
    if (!ret) {
        dev_err(&client->dev, "I2C check functionality failed\n");
        return -ENXIO;
    }
    if (of_node && of_match_device(mma7660_dt_ids, dev)){
        ret = device_property_read_u32(dev, "input_fuzz", &val);
        if (!ret)
            input_fuzz = val;
        ret = device_property_read_u32(dev, "input_flat", &val);
        if (!ret)
            input_flat = val;
        ret = device_property_read_u32(dev, "poll_interval", &val);
        if (!ret)
            poll_interval = val;
    }
    regmap_config.val_bits = 8;
    regmap_config.reg_bits = 8;
    regmap_config.disable_locking = true;
    regmap = devm_regmap_init_i2c(client, &regmap_config); //这个可以去掉，当时为了比较regmap后的i2c是否可以兼容smbus，结果阅读
    													 //源码发现优先使用i2c的操作接口，除非控制器不支持i2c，不然是不会调用smbus
    													 //函数去通信
    if (IS_ERR(regmap))
        return PTR_ERR(regmap);
    if(mma7660_initialize(client)<0){
        goto error_init_client;
    }
    ret = sysfs_create_group(&client->dev.kobj, &mma7660_group);
    if (ret) {
        dev_err(&client->dev, "create sysfs group failed!\n");
        goto error_init_client;
    }
    hwmon_dev = hwmon_device_register(&client->dev);
    if (IS_ERR(hwmon_dev)) {
        dev_err(&client->dev, "hwmon register failed!\n");
        ret = PTR_ERR(hwmon_dev);
        goto error_rm_dev_file;
    }
    mma7660_idev = input_allocate_polled_device();
    if (!mma7660_idev) {
        dev_err(&client->dev, "alloc poll device failed!\n");
        ret = -ENOMEM;
        goto error_init_client;
    }
    mma7660_idev->poll = mma7660_dev_poll;
    mma7660_idev->poll_interval = poll_interval;
    idev = mma7660_idev->input;
    idev->name = MMA7660_NAME;
    idev->id.bustype = BUS_I2C;
    idev->id.vendor = 0x12FA;
    idev->id.product = 0x7660;
    idev->id.version = 0x0100;
    idev->dev.parent = &client->dev;
    set_bit(EV_ABS, idev->evbit);
    set_bit(ABS_X, idev->absbit);
    set_bit(ABS_Y, idev->absbit);
    set_bit(ABS_Z, idev->absbit);
    input_set_abs_params(idev, ABS_X, -512, 512, input_fuzz, input_flat);
    input_set_abs_params(idev, ABS_Y, -512, 512, input_fuzz, input_flat);
    input_set_abs_params(idev, ABS_Z, -512, 512, input_fuzz, input_flat);
    ret = input_register_polled_device(mma7660_idev);
    if (ret) {
        dev_err(&client->dev, "register poll device failed!\n");
        goto error_free_poll_dev;
    }
    printk(" client->irq:%d\n",client->irq);
    ret = devm_request_irq(dev, client->irq, mma7660_interrupt , IRQF_TRIGGER_FALLING, "mma7660", NULL);
    if (ret) {
        dev_err(&client->dev, "request irq (%d) failed %d\n", client->irq, ret);
        goto error_rm_poll_dev;
    }
    printk("exit %s  input_fuzz:%d input_flat:%d poll_interval:%d \n", __func__,input_fuzz,input_flat,poll_interval);
    ret = 0;
    return ret;
error_rm_poll_dev:
    input_unregister_polled_device(mma7660_idev);
error_free_poll_dev:
    input_free_polled_device(mma7660_idev);
error_rm_hwmon_dev:
    hwmon_device_unregister(hwmon_dev);
error_rm_dev_file:
    sysfs_remove_group(&client->dev.kobj, &mma7660_group);
error_init_client:
    return ret;
}
static struct i2c_driver mma7660_driver = {
    .driver = {
        .name    = MMA7660_NAME,
        .of_match_table = mma7660_dt_ids,
    },
    .probe        = mma7760_probe,
    .id_table    = mma7660_id,
};
module_i2c_driver(mma7660_driver);
MODULE_AUTHOR("xiaohuangji, Inc.");
MODULE_DESCRIPTION("tiny4412 Accelerometer");
MODULE_LICENSE("GPL");
小黄鸡#
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ESP8266-Arduino编程实例-MMA7660加速计驱动
视觉与物联智能
08-23 282
MMA7660FC 是一款数字输出 I²C、超低功耗、薄型电容式微加工加速度计，具有低通滤波器、零重力偏移和增益误差补偿以及用户可配置输出数据转换为六位数字值速度。 该器件可通过中断引脚 (INT) 用于传感器数据更改、产品方向和手势检测。
mma7660驱动程序
07-30
This program was produced by the CodeWizardAVR V2.03.9 Standard Automatic Program Generator ?Copyright 1998-2008 Pavel Haiduc, HP InfoTech s.r.l. http://www.hpinfotech.com
重力加速传感器 mma7660
tansitongba
08-10 342
重力加速传感器 mma766 这两天要调试重力加速传感器mma7660, 但kernel中并没有直接的7660的驱动。到google搜索，结果搜到了一篇"调试mma7660" ,来自 loveyaya0716 的博客，真是太感谢她了。对我很有用，先转载下来了。 gsensor调试总结 上一篇/下一篇2010-06-25 17:34:27 / 个人...
HAL库版STM32双轮自平衡车(三) ———代码精讲
想要亿只独角兽的博客
09-08 6947
上一篇文章重点讲解了CubeMX的配置、原理图接线、物料准备，那么接下来本文将一步步开始编写小车的代码，精讲其中的代码原理。
gsensor架构和原理分析【转】
zzb2760715357的博客
03-02 371
本文转载自：http://blog.csdn.net/u012296694/article/details/48055491 本文主要描述了在android2.3平台G-sensor相关软硬件的体系架构和实现原理，按照Applications、Framework、HAL、Driver和Hardware五大层次分别介绍。 1.系统架构 (Architecture) 1.1 Android体系架构图...
tiny4412背光驱动，移植到linux-6.1
最新发布
12-22
在这个项目中，我们讨论的是将tiny4412背光驱动程序成功移植到了最新的Linux 6.1内核。 首先，我们要理解tiny4412背光驱动的原理。这种驱动通常包含初始化代码、亮度调节逻辑以及中断处理函数。在初始化阶段，驱动...
tiny4412-linux3.5.0内核
03-29
《tiny4412-linux3.5.0内核：移植与驱动修改详解》 Linux内核是开源操作系统的核心，其稳定性和可扩展性使其在各种嵌入式设备上广泛应用。tiny4412是一款基于Samsung ARM Cortex-A9处理器的开发板，常用于嵌入式...
uboot_tiny4412-master.tar.gz
06-04
《UBoot Tiny4412移植详解：深入理解与实践》 UBoot，全称“Universal Boot Loader”，是一款广泛应用于嵌入式系统的开源引导加载器。它的主要任务是在系统启动时加载操作系统内核，为设备的初始化和软件运行提供...
uboot_tiny4412-master.zip
03-29
linux系统f uboot_tiny4412-20130729.tgz的安装 版本名字f uboot_tiny4412-20130729.tgz
arm-none-linux-gnueabi-gcc-4.8.3
07-24
arm-none-linux-gnueabi-gcc-4.8.3 已验证可用，请放心使用。arm-none-linux-gnueabi-gcc是 Codesourcery 公司（目前已经被Mentor收购）基于GCC推出的的ARM交叉编译工具。可用于交叉编译ARM系统中所有环节的代码，...
飞思卡尔MMA7660加速度传感器I2C程序
01-14
MMA7660加速度传感器I2C程序 提供学习使用 飞思卡尔使用
MEMS 之重力加速传感器mma7660,与陀螺仪
09-22 1356
这两天调好了3轴g-sensor ,mma7660, 可以用了. 倾斜晃动或改变板子的方向(水平或垂直), mma7660就会产生中断, 并给出当前板子的姿态(水平/垂直, 上下,左右等).          这两天调好了3轴g-sensor ,mma7660, 可
sensor 传感器在 HAL 层的表现
Venus 的博客
02-16 2224
1、使用HAL 的方法 以Sensor 传感器为例，介绍使用 HAL 的 方法，具体流程如下所示。 （1）Native code 通过hw_get_module 调用获取 HAL stub. hw_get_module (LED_HARDWARE_MODULE_ID,(const hw_module_t** )&module) (2) 通过继承 hw_module_methods_t 的 callback 拉打开设备。 module->methods->open(module,
linux加速度传感器校准,树莓派小白教程（三）：MPU6050模块陀螺仪加速度传感器...
weixin_34093899的博客
05-15 645
本帖最后由 Earlobe 于 2019-7-30 12:07 编辑我来辽，一时写教程一时爽，一直写教程一直爽~对啦， 教程二之树莓派的远程控制 戳这里鸭：https://www.52pojie.cn/thread-998014-1-1.html这次讲讲，树莓派和MPU6050模块传感器连接的故事其实就是将MPU60550模块电子陀螺仪连接至树莓派，并通过python进行数据的读取拉~所需材料：1...
linux驱动调试技巧：灌寄存器---------以mma7660为例
tansitongba
08-17 181
参考资料：http://ebetteric.com/page.aspx?id=12&amp;show=1 本文可以使用linux的cat echo命令直接设置mma7660的寄存器的值 部分driver代码如下： static DEVICE_ATTR(mma7660_regs, S_IRUGO | S_IWUGO, show_7660regs, write_7660regs); //mma...
基础实验——三轴传感器
咸鱼菌
04-01 1853
基础实验——三轴传感器MMA7660FC测速原理加速度传感器实验所选设备基本案例示例代码：制作水平仪 加速度传感器是一种能够测量加速度的传感器。通常由质量块、阻尼器、弹性元件、敏感元件和适调电路等部分组成。传感器在加速过程中，通过对质量块所受惯性力的测量，利用牛顿第二定律获得加速度值。根据传感器敏感元件的不同，常见的加速度传感器包括电容式、电感式、应变式、压阻式、压电式等。 三轴加速度传感器用途广泛，可以计算物体倾斜角度，加速度以及通过算法来计算步数，比如日常用的手环计步。 ZTMR开发板上集成了一款三轴
tiny4412 设备树之i2c设备（二）
win9
09-03 4229
开发板：tiny4412(1611)内核：linux4.4编译器： arm-none-linux-gnueabi-gcc （gcc version 4.8.3 20140320）mma7660连接的是i2c3和xeint25。在以前的内核中（arch/arm/mach-exynos/mach-tiny4412.c）中，是这样初始化i2c控制器及设备的static struct s3c2410_pl...
tiny4412 驱动 （3）网卡驱动移植
有崖的博客
06-02 823
网卡驱动是后面驱动的基础 型号 DM9621 USB_HOST_ETHNET_DP1+ USB4604 USB_HOST_ETHNET_DP1- USB4604 其中USB4604有四路USB 一路接网卡DM9621， 一路引出标号USBH3， 另外两路USBH1heUSBH2,都是usb-typeA 对于USB4604 复位信号 ： GPM2_4_USBRST ， 接B35 ...
正点原子 战舰原理图pcb_「正点原子Linux连载」第五十八章Linux INPUT子系统实验（二）...
weixin_39978257的博客
11-10 240
1)实验平台：正点原子Linux开发板2)摘自《正点原子I.MX6U嵌入式Linux驱动开发指南》关注官方微信号公众号，获取更多资料：正点原子58.2 硬件原理图分析本章实验硬件原理图参考15.2小节即可。58.3实验程序编写本实验对应的例程路径为：开发板光盘->2、Linux驱动例程->20_input。58.3.1 修改设备树文件直接使用49.3.1小节创建的key节点即可。58....
Linux小项目-基于Tiny4412的数码相册设计
在硬件层面，需要编写LCD屏驱动(帧缓冲框架)、触摸屏驱动(输入子系统)、以及三轴加速度计驱动(mma7660飞思卡尔的芯片)。 整个项目的代码布局清晰，将涉及Linux驱动和应用层编程的各种技术点都能够较为全面地进行...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值