linux rk3506 mmc5633 mmc5603驱动

原创 已于 2026-03-17 11:02:28 修改 · 593 阅读 · 10 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
于 2026-03-03 17:07:02 首次发布
该文章已生成可运行项目，

1.设备树修改

完整文件

/**********TP**********/
&i2c2{
	status = "okay";
	pinctrl-names = "default";
	pinctrl-0 = <&rm_io1_i2c2_scl &rm_io0_i2c2_sda>;
	clock-frequency = <400000>;//i2c 400k oled

	mmc5633@30 {  // 传感器 I2C 地址（通常为 0x30，需核对硬件）
		compatible = "memsic,mmc5603";  // 匹配驱动的 of_match_table
		reg = <0x30>;  // I2C 从地址
		status = "okay";
	};
	 // 添加OLED设备节点
    oled@3c {
        compatible = "ssd1306"; // 0.96寸OLED主控芯片（SSD1306）
        reg = <0x3c>;           // OLED的I2C地址（0x3c/0x3d二选一）
        status = "okay";
        width = <128>;          // 屏幕宽度
        height = <64>;          // 屏幕高度
        //reset-gpios = <&gpio2 RK_PB0 GPIO_ACTIVE_LOW>; // 可选：复位引脚（无则注释）
    };
其它：
&pinctrl {
	rm_io0 {
		rm_io0_i2c2_sda: rm-io0-i2c2-sda {
			rockchip,pins =
				<0 RK_PA0 35 &pcfg_pull_none>;
		};
	};

	rm_io1 {
		rm_io1_i2c2_scl: rm-io1-i2c2-scl {
			rockchip,pins =
				<0 RK_PA1 34 &pcfg_pull_none>;
		};
	};
};

2.Kconfig

config MMC5633
	tristate "MEMSIC MMC5633 3-axis magnetic sensor"
	select REGMAP_I2C
	select REGMAP_I3C if I3C
	depends on I2C
	depends on I3C || !I3C
	help
	  Say yes here to build support for the MEMSIC MMC5633 3-axis
	  magnetic sensor.

	  To compile this driver as a module, choose M here: the module
	  will be called mmc5633

3.Makefile

在这里插入图片描述

4.驱动

// SPDX-License-Identifier: GPL-2.0-only
/*
 * MMC5633 - MEMSIC 3-axis Magnetic Sensor
 *
 * Copyright (c) 2015, Intel Corporation.
 * Copyright (c) 2025, NXP
 *
 * IIO driver for MMC5633, base on mmc35240.c
 */

#include <linux/bitfield.h>
#include <linux/bits.h>
#include <linux/cleanup.h>
#include <linux/delay.h>
#include <linux/device.h>
#include <linux/dev_printk.h>
#include <linux/err.h>
#include <linux/errno.h>
#include <linux/i2c.h>
#include <linux/i3c/device.h>
#include <linux/iio/iio.h>
#include <linux/iio/sysfs.h>
#include <linux/iio/buffer.h>
#include <linux/iio/trigger.h>
#include <linux/iio/triggered_buffer.h>
#include <linux/iio/trigger_consumer.h>
#include <linux/init.h>
#include <linux/iopoll.h>
#include <linux/module.h>
#include <linux/mod_devicetable.h>
#include <linux/mutex.h>
#include <linux/pm.h>
#include <linux/regmap.h>
#include <linux/time.h>
#include <linux/timer.h>
#include <linux/types.h>

#define MMC5633_REG_XOUT0	0x00
#define MMC5633_REG_XOUT1	0x01
#define MMC5633_REG_YOUT0	0x02
#define MMC5633_REG_YOUT1	0x03
#define MMC5633_REG_ZOUT0	0x04
#define MMC5633_REG_ZOUT1	0x05
#define MMC5633_REG_XOUT2	0x06
#define MMC5633_REG_YOUT2	0x07
#define MMC5633_REG_ZOUT2	0x08
#define MMC5633_REG_TOUT	0x09

#define MMC5633_REG_STATUS1	0x18
#define MMC5633_REG_STATUS0	0x19
#define MMC5633_REG_CTRL0	0x1b
#define MMC5633_REG_CTRL1	0x1c
#define MMC5633_REG_CTRL2	0x1d

#define MMC5633_REG_ID		0x39

#define MMC5633_STATUS1_MEAS_T_DONE_BIT	BIT(7)
#define MMC5633_STATUS1_MEAS_M_DONE_BIT	BIT(6)

#define MMC5633_CTRL0_CMM_FREQ_EN	BIT(7)
#define MMC5633_CTRL0_AUTO_ST_EN	BIT(6)
#define MMC5633_CTRL0_AUTO_SR_EN	BIT(5)
#define MMC5633_CTRL0_RESET		BIT(4)
#define MMC5633_CTRL0_SET		BIT(3)
#define MMC5633_CTRL0_MEAS_T		BIT(1)
#define MMC5633_CTRL0_MEAS_M		BIT(0)

#define MMC5633_CTRL1_BW_MASK		GENMASK(1, 0)

#define MMC5633_WAIT_SET_RESET_US	(1 * USEC_PER_MSEC)

#define MMC5633_HDR_CTRL0_MEAS_M	0x01
#define MMC5633_HDR_CTRL0_MEAS_T	0x03
#define MMC5633_HDR_CTRL0_SET		0x05
#define MMC5633_HDR_CTRL0_RESET		0x07

enum mmc5633_axis {
	MMC5633_AXIS_X,
	MMC5633_AXIS_Y,
	MMC5633_AXIS_Z,
	MMC5633_TEMPERATURE,
};

struct mmc5633_data {
	struct regmap *regmap;
	struct i3c_device *i3cdev;
	struct mutex mutex; /* protect to finish one whole measurement */
	struct iio_trigger *trig; /* 触发源 */
	struct timer_list timer; /* 软件定时器，自动触发采集 */
	unsigned int samp_freq_hz; /* 当前采样频率（Hz） */
};

// 采样频率映射：[Hz, 微秒补偿]
static int mmc5633_samp_freq[][2] = {
	{ 1, 200000 },
	{ 2, 0 },
	{ 3, 500000 },
	{ 6, 600000 },
};

// 定义扫描通道（带Buffer配置）
#define MMC5633_CHANNEL(_axis) { \
	.type = IIO_MAGN, \
	.modified = 1, \
	.channel2 = IIO_MOD_ ## _axis, \
	.address = MMC5633_AXIS_ ## _axis, \
	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
	.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SAMP_FREQ) | \
				    BIT(IIO_CHAN_INFO_SCALE), \
	.scan_index = MMC5633_AXIS_ ## _axis, \
	.scan_type = { \
		.sign = 's', \
		.realbits = 20, /* MMC5633磁强计20位有效数据 */ \
		.storagebits = 32, /* 存储为32位整型 */ \
		.endianness = IIO_CPU, \
	}, \
}

static const struct iio_chan_spec mmc5633_channels[] = {
	MMC5633_CHANNEL(X),
	MMC5633_CHANNEL(Y),
	MMC5633_CHANNEL(Z),
	{
		.type = IIO_TEMP,
		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
				      BIT(IIO_CHAN_INFO_SCALE) |
				      BIT(IIO_CHAN_INFO_OFFSET),
		.address = MMC5633_TEMPERATURE,
		.scan_index = MMC5633_TEMPERATURE,
		.scan_type = {
			.sign = 's',
			.realbits = 8, /* 温度8位有效数据 */
			.storagebits = 32,
			.endianness = IIO_CPU,
		},
	},
	// 时间戳通道（Buffer必须）
	IIO_CHAN_SOFT_TIMESTAMP(4),
};

// 获取采样频率索引
static int mmc5633_get_samp_freq_index(struct mmc5633_data *data,
				       int val, int val2)
{
	unsigned int i;

	for (i = 0; i < ARRAY_SIZE(mmc5633_samp_freq); i++)
		if (mmc5633_samp_freq[i][0] == val &&
		    mmc5633_samp_freq[i][1] == val2)
			return i;
	return -EINVAL;
}

// 传感器初始化
static int mmc5633_init(struct mmc5633_data *data)
{
	unsigned int reg_id;
	int ret;

	ret = regmap_read(data->regmap, MMC5633_REG_ID, &reg_id);
	if (ret)
		return dev_err_probe(regmap_get_device(data->regmap), ret,
				     "Error reading product id\n");

	dev_err(regmap_get_device(data->regmap), "MMC5633 chip id %x\n", reg_id);

	// SET/RESET序列恢复传感器默认配置
	ret = regmap_write(data->regmap, MMC5633_REG_CTRL0, MMC5633_CTRL0_SET);
	if (ret)
		return ret;

	fsleep(MMC5633_WAIT_SET_RESET_US);

	ret = regmap_write(data->regmap, MMC5633_REG_CTRL0, MMC5633_CTRL0_RESET);
	if (ret)
		return ret;

    dev_err(regmap_get_device(data->regmap), "MMC5633 fre 0-1hz\n");

	// 设置默认采样频率（1Hz）
	return regmap_update_bits(data->regmap, MMC5633_REG_CTRL1,
				  MMC5633_CTRL1_BW_MASK,
				  FIELD_PREP(MMC5633_CTRL1_BW_MASK, 0));
}

// 触发单次测量
static int mmc5633_take_measurement(struct mmc5633_data *data, int address)
{
	unsigned int reg_status, val;
	int ret;

	val = (address == MMC5633_TEMPERATURE) ? MMC5633_CTRL0_MEAS_T : MMC5633_CTRL0_MEAS_M;
	ret = regmap_write(data->regmap, MMC5633_REG_CTRL0, val);
	if (ret < 0)
		return ret;

	val = (address == MMC5633_TEMPERATURE) ?
	      MMC5633_STATUS1_MEAS_T_DONE_BIT : MMC5633_STATUS1_MEAS_M_DONE_BIT;
	ret = regmap_read_poll_timeout(data->regmap, MMC5633_REG_STATUS1, reg_status,
				       reg_status & val,
				       10 * USEC_PER_MSEC,
				       100 * 10 * USEC_PER_MSEC);
	if (ret) {
		dev_err(regmap_get_device(data->regmap), "data not ready\n");
		return ret;
	}

	return 0;
}

// 读取测量数据
static int mmc5633_read_measurement(struct mmc5633_data *data, int address, void *buf, size_t sz)
{	
	int ret;

	// 降级到I2C/SDR模式读取
	ret = mmc5633_take_measurement(data, address);
	if (ret < 0)
		return ret;

	if (address == MMC5633_TEMPERATURE)
		return regmap_bulk_read(data->regmap, MMC5633_REG_TOUT, buf + sz - 1, 1);

	return regmap_bulk_read(data->regmap, MMC5633_REG_XOUT0, buf, sz);
}

#define MMC5633_ALL_SIZE (3 * 3 + 1) // X/Y/Z各3字节 + Temp1字节

// 解析原始数据
static int mmc5633_get_raw(struct mmc5633_data *data, int index, unsigned char *buf, int *val)
{
	if (index == MMC5633_TEMPERATURE) {
		*val = buf[MMC5633_ALL_SIZE - 1];
		return 0;
	}

	// 解析20位磁强计数据：X[19:12] X[11:4] Y[19:12] Y[11:4] Z[19:12] Z[11:4] X[3:0] Y[3:0] Z[3:0]
	*val = get_unaligned_be16(buf + 2 * index) << 4;
	*val |= buf[index + 6] >> 4;

	return 0;
}

// 读取原始数据/scale/采样频率
static int mmc5633_read_raw(struct iio_dev *indio_dev,
			    struct iio_chan_spec const *chan, int *val,
			    int *val2, long mask)
{
	struct mmc5633_data *data = iio_priv(indio_dev);
	char buf[MMC5633_ALL_SIZE];
	unsigned int reg, i;
	int ret;

	switch (mask) {
	case IIO_CHAN_INFO_RAW:
		mutex_lock(&data->mutex);
		ret = mmc5633_read_measurement(data, chan->address, buf, MMC5633_ALL_SIZE);
		mutex_unlock(&data->mutex);
		if (ret < 0)
			return ret;

		ret = mmc5633_get_raw(data, chan->address, buf, val);
		if (ret < 0)
			return ret;
		return IIO_VAL_INT;

	case IIO_CHAN_INFO_SCALE:
		if (chan->type == IIO_MAGN) {
			*val = 0;
			*val2 = 62500; // 0.0000625 G/LSB = 62500 nT/LSB
		} else {
			*val = 0;
			*val2 = 800000000; // 0.8°C/LSB
		}
		return IIO_VAL_INT_PLUS_NANO;

	case IIO_CHAN_INFO_OFFSET:
		if (chan->type == IIO_TEMP) {
			*val = -75; // 温度偏移：-75°C
			return IIO_VAL_INT;
		}
		return -EINVAL;

	case IIO_CHAN_INFO_SAMP_FREQ:
		mutex_lock(&data->mutex);
		ret = regmap_read(data->regmap, MMC5633_REG_CTRL1, &reg);
		mutex_unlock(&data->mutex);
		if (ret < 0)
			return ret;

		i = FIELD_GET(MMC5633_CTRL1_BW_MASK, reg);
		if (i >= ARRAY_SIZE(mmc5633_samp_freq))
			return -EINVAL;

		*val = mmc5633_samp_freq[i][0];
		*val2 = mmc5633_samp_freq[i][1];
		return IIO_VAL_INT_PLUS_MICRO;

	default:
		return -EINVAL;
	}
}

// 写入采样频率
static int mmc5633_write_raw(struct iio_dev *indio_dev,
			     struct iio_chan_spec const *chan, int val,
			     int val2, long mask)
{
	struct mmc5633_data *data = iio_priv(indio_dev);
	int ret;

	switch (mask) {
	case IIO_CHAN_INFO_SAMP_FREQ: {
		ret = mmc5633_get_samp_freq_index(data, val, val2);
		if (ret < 0)
			return ret;

		mutex_lock(&data->mutex);
		// 更新硬件采样频率
		ret = regmap_update_bits(data->regmap, MMC5633_REG_CTRL1,
					  MMC5633_CTRL1_BW_MASK,
					  FIELD_PREP(MMC5633_CTRL1_BW_MASK, ret));
        if(val==1)
            {
val=20;
        }
         dev_err(regmap_get_device(data->regmap), "MMC5633 fre %d-%dhz\n",ret,val);
		// 更新定时器采样频率
		data->samp_freq_hz = val;
		mod_timer(&data->timer, jiffies + msecs_to_jiffies(1000 / data->samp_freq_hz));
		mutex_unlock(&data->mutex);

		return ret;
	}
	default:
		return -EINVAL;
	}
}

// 读取可用采样频率
static int mmc5633_read_avail(struct iio_dev *indio_dev,
			      struct iio_chan_spec const *chan,
			      const int **vals, int *type, int *length,
			      long mask)
{
	switch (mask) {
	case IIO_CHAN_INFO_SAMP_FREQ:
		*vals = (const int *)mmc5633_samp_freq;
		*length = ARRAY_SIZE(mmc5633_samp_freq) * 2;
		*type = IIO_VAL_INT_PLUS_MICRO;
		return IIO_AVAIL_LIST;
	default:
		return -EINVAL;
	}
}

// Buffer触发回调函数：采集数据并写入Buffer
static irqreturn_t mmc5633_trigger_handler(int irq, void *p)
{
	struct iio_poll_func *pf = p;
	struct iio_dev *indio_dev = pf->indio_dev;
	struct mmc5633_data *data = iio_priv(indio_dev);
	char buf[MMC5633_ALL_SIZE] = {0};
	int32_t buffer_data[4] = {0}; // X/Y/Z/Temp
	int ret;

	mutex_lock(&data->mutex);

	// 读取所有通道数据
	ret = mmc5633_read_measurement(data, MMC5633_AXIS_X, buf, MMC5633_ALL_SIZE);
	if (ret < 0) {
		mutex_unlock(&data->mutex);
		goto done;
	}

	// 解析数据
	mmc5633_get_raw(data, MMC5633_AXIS_X, buf, (int *)&buffer_data[0]);
	mmc5633_get_raw(data, MMC5633_AXIS_Y, buf, (int *)&buffer_data[1]);
	mmc5633_get_raw(data, MMC5633_AXIS_Z, buf, (int *)&buffer_data[2]);
	mmc5633_get_raw(data, MMC5633_TEMPERATURE, buf, (int *)&buffer_data[3]);

	// 写入Buffer（带时间戳）
	iio_push_to_buffers_with_timestamp(indio_dev, buffer_data,
					   iio_get_time_ns(indio_dev));

	mutex_unlock(&data->mutex);

done:
	iio_trigger_notify_done(indio_dev->trig);
	return IRQ_HANDLED;
}

// 软件定时器回调：自动触发数据采集
static void mmc5633_timer_trigger(struct timer_list *t)
{
	struct mmc5633_data *data = from_timer(data, t, timer);
    iio_trigger_get_drvdata(data->trig);

	// 触发采集
	iio_trigger_poll(data->trig);

	// 重启定时器
	mod_timer(&data->timer, jiffies + msecs_to_jiffies(1000 / data->samp_freq_hz));
}

// 创建软件触发源
static int mmc5633_setup_trigger(struct iio_dev *indio_dev)
{
	struct mmc5633_data *data = iio_priv(indio_dev);
	struct device *dev = indio_dev->dev.parent;
	int ret;

	// 分配触发源
	data->trig = devm_iio_trigger_alloc(dev, "%s-trigger", indio_dev->name);
	if (!data->trig)
		return -ENOMEM;

	// 设置触发源私有数据
	iio_trigger_set_drvdata(data->trig, indio_dev);

	// 注册触发源
	ret = devm_iio_trigger_register(dev, data->trig);
	if (ret)
		return ret;

	// 初始化定时器（默认1Hz采样）
	timer_setup(&data->timer, mmc5633_timer_trigger, 0);
	data->samp_freq_hz = 20;
	mod_timer(&data->timer, jiffies + msecs_to_jiffies(1000));

	// 关联触发源到IIO设备
	indio_dev->trig = data->trig;

	return 0;
}

// IIO设备信息
static const struct iio_info mmc5633_info = {
	.read_raw	= mmc5633_read_raw,
	.write_raw	= mmc5633_write_raw,
	.read_avail	= mmc5633_read_avail,
};

// Regmap可写寄存器判断
static bool mmc5633_is_writeable_reg(struct device *dev, unsigned int reg)
{
	switch (reg) {
	case MMC5633_REG_CTRL0:
	case MMC5633_REG_CTRL1:
		return true;
	default:
		return false;
	}
}

// Regmap可读寄存器判断
static bool mmc5633_is_readable_reg(struct device *dev, unsigned int reg)
{
	switch (reg) {
	case MMC5633_REG_XOUT0 ... MMC5633_REG_ZOUT2:
	case MMC5633_REG_TOUT:
	case MMC5633_REG_STATUS1:
	case MMC5633_REG_ID:
		return true;
	default:
		return false;
	}
}

// Regmap易失性寄存器判断
static bool mmc5633_is_volatile_reg(struct device *dev, unsigned int reg)
{
	switch (reg) {
	case MMC5633_REG_CTRL0:
	case MMC5633_REG_CTRL1:
		return false;
	default:
		return true;
	}
}

// Regmap默认值
static const struct reg_default mmc5633_reg_defaults[] = {
	{ MMC5633_REG_CTRL0,  0x00 },
	{ MMC5633_REG_CTRL1,  0x00 },
};

// Regmap配置
static const struct regmap_config mmc5633_regmap_config = {
	.name = "mmc5633_regmap",
	.reg_bits = 8,
	.val_bits = 8,
	.max_register = MMC5633_REG_ID,
	.cache_type = REGCACHE_FLAT,
	.writeable_reg = mmc5633_is_writeable_reg,
	.readable_reg = mmc5633_is_readable_reg,
	.volatile_reg = mmc5633_is_volatile_reg,
	.reg_defaults = mmc5633_reg_defaults,
	.num_reg_defaults = ARRAY_SIZE(mmc5633_reg_defaults),
};

// 通用probe函数
static int mmc5633_common_probe(struct regmap *regmap, char *name,
				struct i3c_device *i3cdev)
{
	struct device *dev = regmap_get_device(regmap);
	struct mmc5633_data *data;
	struct iio_dev *indio_dev;
	int ret;

	// 分配IIO设备
	indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
	if (!indio_dev)
		return -ENOMEM;

	// 初始化私有数据
	data = iio_priv(indio_dev);
	data->regmap = regmap;
	data->i3cdev = i3cdev;
	dev_set_drvdata(dev, indio_dev); // 设置设备私有数据
	mutex_init(&data->mutex);

	// 配置IIO设备
	indio_dev->info = &mmc5633_info;
	indio_dev->name = name;
	indio_dev->channels = mmc5633_channels;
	indio_dev->num_channels = ARRAY_SIZE(mmc5633_channels);
	indio_dev->modes = INDIO_DIRECT_MODE;

	// 初始化触发源和Buffer
	ret = mmc5633_setup_trigger(indio_dev);
	if (ret)
		return dev_err_probe(dev, ret, "Failed to setup trigger\n");

	ret = devm_iio_triggered_buffer_setup(dev, indio_dev,
					       NULL,
					       mmc5633_trigger_handler,
					       NULL);
	if (ret)
		return dev_err_probe(dev, ret, "Failed to setup buffer\n");

	// 初始化传感器
	ret = mmc5633_init(data);
	if (ret < 0)
		return dev_err_probe(dev, ret, "mmc5633 chip init failed\n");

	// 注册IIO设备
	return devm_iio_device_register(dev, indio_dev);
}

// 休眠回调
static int mmc5633_suspend(struct device *dev)
{
	struct iio_dev *indio_dev = dev_get_drvdata(dev);
	struct mmc5633_data *data = iio_priv(indio_dev);
	struct regmap *regmap = data->regmap;

	// 停止定时器
	del_timer_sync(&data->timer);
	// 缓存寄存器
	regcache_cache_only(regmap, true);

	return 0;
}

// 恢复回调
static int mmc5633_resume(struct device *dev)
{
	struct iio_dev *indio_dev = dev_get_drvdata(dev);
	struct mmc5633_data *data = iio_priv(indio_dev);
	struct regmap *regmap = data->regmap;
	int ret;

	// 恢复寄存器配置
	regcache_mark_dirty(regmap);
	ret = regcache_sync_region(regmap, MMC5633_REG_CTRL0, MMC5633_REG_CTRL1);
	if (ret)
		dev_err(dev, "Failed to restore control registers\n");

	// 重启定时器
	mod_timer(&data->timer, jiffies + msecs_to_jiffies(1000 / data->samp_freq_hz));
	regcache_cache_only(regmap, false);

	return 0;
}

// I2C Probe
static int mmc5633_i2c_probe(struct i2c_client *client,
                  const struct i2c_device_id *id)
{
	struct device *dev = &client->dev;
	struct regmap *regmap;

	// 初始化Regmap
	regmap = devm_regmap_init_i2c(client, &mmc5633_regmap_config);
	if (IS_ERR(regmap))
		return dev_err_probe(dev, PTR_ERR(regmap), "regmap init failed\n");

	return mmc5633_common_probe(regmap, client->name, NULL);
}

// PM操作
static DEFINE_SIMPLE_DEV_PM_OPS(mmc5633_pm_ops, mmc5633_suspend, mmc5633_resume);

// 设备树匹配表
static const struct of_device_id mmc5633_of_match[] = {
	{ .compatible = "memsic,mmc5603" },
	{ .compatible = "memsic,mmc5633" },
	{ }
};
MODULE_DEVICE_TABLE(of, mmc5633_of_match);

// I2C设备ID表
static const struct i2c_device_id mmc5633_i2c_id[] = {
	{ "mmc5603" },
	{ "mmc5633" },
	{ }
};
MODULE_DEVICE_TABLE(i2c, mmc5633_i2c_id);

// I2C驱动结构体
static struct i2c_driver mmc5633_i2c_driver = {
	.driver = {
		.name = "mmc5633_i2c",
		.of_match_table = mmc5633_of_match,
		.pm = pm_sleep_ptr(&mmc5633_pm_ops),
	},
	.probe = mmc5633_i2c_probe,
	.id_table = mmc5633_i2c_id,
};
module_i2c_driver(mmc5633_i2c_driver);

MODULE_AUTHOR("Frank Li <Frank.li@nxp.com>");
MODULE_DESCRIPTION("MEMSIC MMC5633 magnetic sensor driver");
MODULE_LICENSE("GPL");

应用程序

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <time.h>
#include <dirent.h>
#include <math.h>
#include <getopt.h>

// 传感器 IIO 设备路径
char *IIO_DEV_PATH = NULL;

// 校准文件路径
#define CALIBRATION_FILE "./mmc5603_calibration.txt"

// 错误处理宏
#define CHECK_ERROR(ret, msg) do { if (ret < 0) { printf("Error: %s\n", msg); return ret; } } while (0)

// 读取文件内容（通用函数）
static int read_iio_file(const char *path, char *buf, size_t len) {
    FILE *fp = fopen(path, "r");
    if (!fp) {
        // 不打印错误，避免过多输出
        return -1;
    }
    memset(buf, 0, len);
    if (fgets(buf, len - 1, fp) == NULL) {
        fclose(fp);
        return -1;
    }
    fclose(fp);
    return 0;
}

// 写入文件内容（配置采样频率用）
static int write_iio_file(const char *path, const char *value) {
    FILE *fp = fopen(path, "w");
    if (!fp) {
        // 不打印错误，避免过多输出
        return -1;
    }
    if (fputs(value, fp) < 0) {
        fclose(fp);
        return -1;
    }
    fclose(fp);
    return 0;
}

// 读取浮点数
static int read_float(const char *path, float *value) {
    char buf[64];
    if (read_iio_file(path, buf, sizeof(buf)) < 0)
        return -1;
    *value = strtof(buf, NULL);
    return 0;
}

// 读取整数
static int read_int(const char *path, int *value) {
    char buf[64];
    if (read_iio_file(path, buf, sizeof(buf)) < 0)
        return -1;
    *value = atoi(buf);
    return 0;
}

// 自动检测磁强计设备路径
static char* find_magnetometer_device(void) {
    static char path[128];
    DIR *dir;
    struct dirent *entry;
    char dev_path[128];
    char name[64];
    
    dir = opendir("/sys/bus/iio/devices/");
    if (!dir) {
        perror("opendir failed");
        return NULL;
    }
    
    while ((entry = readdir(dir)) != NULL) {
        if (strstr(entry->d_name, "iio:device") != NULL) {
            snprintf(dev_path, sizeof(dev_path), "/sys/bus/iio/devices/%s/name", entry->d_name);
            FILE *fp = fopen(dev_path, "r");
            if (fp) {
                if (fgets(name, sizeof(name), fp) != NULL) {
                    if (strstr(name, "mmc56") != NULL) {
                        snprintf(path, sizeof(path), "/sys/bus/iio/devices/%s", entry->d_name);
                        fclose(fp);
                        closedir(dir);
                        return path;
                    }
                }
                fclose(fp);
            }
        }
    }
    
    closedir(dir);
    return NULL;
}

// 计算磁场方向和强度
static void calculate_magnetic_orientation(float x, float y, float z, float *heading, float *intensity) {
	// 计算磁场强度
	*intensity = sqrt(x*x + y*y + z*z);
	
	// 计算方位角（与北方的夹角）
	// 尝试不同的轴组合，找出正确的方向计算方式
	
	// 选项1: 标准方式 (x=东, y=北)
	float heading1 = atan2(y, x) * 180.0 / M_PI;
	if (heading1 < 0) heading1 += 360.0;
	
	// 选项2: 交换x和y (x=北, y=东)
	float heading2 = atan2(x, y) * 180.0 / M_PI;
	if (heading2 < 0) heading2 += 360.0;
	
	// 选项3: 可能的传感器安装方向 (x=北, y=西)
	float heading3 = atan2(-y, x) * 180.0 / M_PI;
	if (heading3 < 0) heading3 += 360.0;
	
	// 选项4: 可能的传感器安装方向 (x=东, y=南)
	float heading4 = atan2(-x, y) * 180.0 / M_PI;
	if (heading4 < 0) heading4 += 360.0;
	
	// 打印所有选项的结果
	printf("Debug: Headings - Option1: %.1f, Option2: %.1f, Option3: %.1f, Option4: %.1f\n", 
		heading1, heading2, heading3, heading4);
	
	// 选择一个选项进行测试
	*heading = heading3;
}

// 触发单次测量
static int trigger_measurement(void) {
	char path[128];
	
	// 尝试多种触发方式
	
	// 方式1: 使用oneshot触发
	snprintf(path, sizeof(path), "%s/trigger/current_trigger", IIO_DEV_PATH);
	if (write_iio_file(path, "oneshot") == 0) {
		printf("Trigger: oneshot mode\n");
		usleep(5000); // 5ms
		return 0;
	}
	
	// 方式2: 启用磁场测量
	snprintf(path, sizeof(path), "%s/in_magn_en", IIO_DEV_PATH);
	if (write_iio_file(path, "1") == 0) {
		printf("Trigger: enabled mode\n");
		usleep(5000);
		return 0;
	}
	
	// 方式3: 尝试写入采样频率来触发
	snprintf(path, sizeof(path), "%s/in_magn_sampling_frequency", IIO_DEV_PATH);
	if (write_iio_file(path, "100") == 0) {
		printf("Trigger: sampling frequency set to 100Hz\n");
		usleep(5000);
		return 0;
	}
	
	// 触发失败，继续执行
	printf("Warning: all trigger methods failed\n");
	usleep(10000); // 10ms
	return 0;
}

// 读取传感器数据
static int read_mmc5633_data(float *x, float *y, float *z, float *temp) {
	char path[128];
	int raw_x, raw_y, raw_z, raw_temp;
	float magn_scale, temp_scale;
	int temp_offset;

	// 触发测量
	trigger_measurement();

	// 1. 读取磁场缩放系数
	snprintf(path, sizeof(path), "%s/in_magn_scale", IIO_DEV_PATH);
	if (read_float(path, &magn_scale) < 0) {
		printf("Error reading magn scale\n");
		return -1;
	}

	// 2. 读取 X 轴磁场原始值
	snprintf(path, sizeof(path), "%s/in_magn_x_raw", IIO_DEV_PATH);
	if (read_int(path, &raw_x) < 0) {
		printf("Error reading x raw\n");
		return -1;
	}

	// 3. 读取 Y 轴磁场
	snprintf(path, sizeof(path), "%s/in_magn_y_raw", IIO_DEV_PATH);
	if (read_int(path, &raw_y) < 0) {
		printf("Error reading y raw\n");
		return -1;
	}

	// 4. 读取 Z 轴磁场
	snprintf(path, sizeof(path), "%s/in_magn_z_raw", IIO_DEV_PATH);
	if (read_int(path, &raw_z) < 0) {
		printf("Error reading z raw\n");
		return -1;
	}

	// 计算磁场值
	*x = raw_x * magn_scale;
	*y = raw_y * magn_scale;
	*z = raw_z * magn_scale;

	// 5. 读取温度
	snprintf(path, sizeof(path), "%s/in_temp_raw", IIO_DEV_PATH);
	if (read_int(path, &raw_temp) < 0) {
		printf("Error reading temp raw\n");
		return -1;
	}

	// 读取温度缩放系数
	snprintf(path, sizeof(path), "%s/in_temp_scale", IIO_DEV_PATH);
	if (read_float(path, &temp_scale) < 0) {
		printf("Error reading temp scale\n");
		return -1;
	}

	// 读取温度偏移
	snprintf(path, sizeof(path), "%s/in_temp_offset", IIO_DEV_PATH);
	if (read_int(path, &temp_offset) < 0) {
		printf("Error reading temp offset\n");
		return -1;
	}

	*temp = raw_temp * temp_scale + temp_offset;

	// 打印调试信息
	printf("Debug: magn_scale=%.9f\n", magn_scale);
	printf("Debug: raw_x=%d, x=%.4f uT\n", raw_x, *x);
	printf("Debug: raw_y=%d, y=%.4f uT\n", raw_y, *y);
	printf("Debug: raw_z=%d, z=%.4f uT\n", raw_z, *z);

	return 0;
}

// 配置采样频率（单位：Hz，需匹配驱动支持的频率）
static int set_sampling_freq(int freq) {
    char path[128];
    char value[32];

    // 拼接采样频率配置文件路径
    snprintf(path, sizeof(path), "%s/in_magn_sampling_frequency", IIO_DEV_PATH);
    // 标准 IIO 格式：直接写入频率值
    snprintf(value, sizeof(value), "%d", freq);
    return write_iio_file(path, value);
}

// 检查传感器是否存在
static int check_sensor_exist(void) {
    if (!IIO_DEV_PATH) {
        IIO_DEV_PATH = find_magnetometer_device();
        if (!IIO_DEV_PATH) {
            printf("Magnetometer sensor not found\n");
            return -1;
        }
    }
    return 0;
}

// 打印传感器信息
static void print_sensor_info(void) {
    char buf[64];
    char path[128];

    // 打印传感器名称
    snprintf(path, sizeof(path), "%s/name", IIO_DEV_PATH);
    if (read_iio_file(path, buf, sizeof(buf)) == 0) {
        printf("Sensor Name: %s", buf);
    }

    // 打印可用的采样频率
    snprintf(path, sizeof(path), "%s/in_magn_sampling_frequency_available", IIO_DEV_PATH);
    if (read_iio_file(path, buf, sizeof(buf)) == 0) {
        printf("Available Sampling Frequencies: %s", buf);
    }
}

// 保存校准值到文件
static int save_calibration(float min_x, float max_x, float min_y, float max_y, float min_z, float max_z) {
	FILE *fp = fopen(CALIBRATION_FILE, "w");
	if (!fp) {
		perror("Failed to open calibration file");
		return -1;
	}
	
	fprintf(fp, "%.4f %.4f\n", min_x, max_x);
	fprintf(fp, "%.4f %.4f\n", min_y, max_y);
	fprintf(fp, "%.4f %.4f\n", min_z, max_z);
	
	fclose(fp);
	printf("Calibration saved to %s\n", CALIBRATION_FILE);
	return 0;
}

// 从文件加载校准值
static int load_calibration(float *min_x, float *max_x, float *min_y, float *max_y, float *min_z, float *max_z) {
	FILE *fp = fopen(CALIBRATION_FILE, "r");
	if (!fp) {
		printf("No calibration file found, using default values\n");
		// 使用默认值
		*min_x = -100.0;
		*max_x = 100.0;
		*min_y = -100.0;
		*max_y = 100.0;
		*min_z = -100.0;
		*max_z = 100.0;
		return -1;
	}
	
	if (fscanf(fp, "%f %f", min_x, max_x) != 2 ||
		fscanf(fp, "%f %f", min_y, max_y) != 2 ||
		fscanf(fp, "%f %f", min_z, max_z) != 2) {
		fclose(fp);
		printf("Invalid calibration file, using default values\n");
		// 使用默认值
		*min_x = -100.0;
		*max_x = 100.0;
		*min_y = -100.0;
		*max_y = 100.0;
		*min_z = -100.0;
		*max_z = 100.0;
		return -1;
	}
	
	fclose(fp);
	printf("Calibration loaded from %s\n", CALIBRATION_FILE);
	printf("X: min=%.4f uT, max=%.4f uT, offset=%.4f uT\n", *min_x, *max_x, (*min_x + *max_x) / 2);
	printf("Y: min=%.4f uT, max=%.4f uT, offset=%.4f uT\n", *min_y, *max_y, (*min_y + *max_y) / 2);
	printf("Z: min=%.4f uT, max=%.4f uT, offset=%.4f uT\n", *min_z, *max_z, (*min_z + *max_z) / 2);
	return 0;
}

// 简单的磁场校准
static void calibrate_magnetometer(float *min_x, float *max_x, float *min_y, float *max_y, float *min_z, float *max_z) {
	float x, y, z, temp;
	int i;
	
	printf("\n=== Magnetometer Calibration ===\n");
	printf("Rotate the board in all directions for 10 seconds...\n");
	
	// 初始化最小值和最大值
	*min_x = 999999.0;
	*max_x = -999999.0;
	*min_y = 999999.0;
	*max_y = -999999.0;
	*min_z = 999999.0;
	*max_z = -999999.0;
	
	// 采集10秒数据
	for (i = 0; i < 100; i++) {
		if (read_mmc5633_data(&x, &y, &z, &temp) < 0) {
			printf("Calibration failed\n");
			return;
		}
		
		// 更新最小值和最大值
		if (x < *min_x) *min_x = x;
		if (x > *max_x) *max_x = x;
		if (y < *min_y) *min_y = y;
		if (y > *max_y) *max_y = y;
		if (z < *min_z) *min_z = z;
		if (z > *max_z) *max_z = z;
		
		usleep(100000); // 100ms
	}
	
	// 打印校准结果
	printf("Calibration complete!\n");
	printf("X: min=%.4f uT, max=%.4f uT, offset=%.4f uT\n", *min_x, *max_x, (*min_x + *max_x) / 2);
	printf("Y: min=%.4f uT, max=%.4f uT, offset=%.4f uT\n", *min_y, *max_y, (*min_y + *max_y) / 2);
	printf("Z: min=%.4f uT, max=%.4f uT, offset=%.4f uT\n", *min_z, *max_z, (*min_z + *max_z) / 2);
	printf("=============================\n\n");
	
	// 保存校准值到文件
	save_calibration(*min_x, *max_x, *min_y, *max_y, *min_z, *max_z);
}

int main(int argc, char *argv[]) {
	float x, y, z, temp;
	int i, freq = 1;
	struct timespec start, end;
	double elapsed;
	
	// 校准参数
	float min_x, max_x, min_y, max_y, min_z, max_z;
	
	// 命令行选项
	int calibrate = 0;
	int opt;
	
	// 解析命令行参数
	while ((opt = getopt(argc, argv, "cf:")) != -1) {
		switch (opt) {
		case 'c':
			calibrate = 1;
			break;
		case 'f':
			freq = atoi(optarg);
			break;
		default:
			printf("Usage: %s [-c] [-f freq]\n", argv[0]);
			printf("  -c: Calibrate the magnetometer\n");
			printf("  -f: Set sampling frequency (Hz)\n");
			return 1;
		}
	}

	// 检查传感器是否存在
	CHECK_ERROR(check_sensor_exist(), "Sensor not found");
	printf("Found magnetometer at: %s\n", IIO_DEV_PATH);

	// 打印传感器信息
	print_sensor_info();

	// 配置采样频率
	printf("Setting sampling frequency to %d Hz\n", freq);
	if (set_sampling_freq(freq) < 0) {
		printf("Warning: set sampling freq failed (may need root权限)\n");
	}

	// 加载或执行校准
	if (calibrate) {
		// 执行磁场校准
		calibrate_magnetometer(&min_x, &max_x, &min_y, &max_y, &min_z, &max_z);
	} else {
		// 从文件加载校准值
		load_calibration(&min_x, &max_x, &min_y, &max_y, &min_z, &max_z);
	}

	// 循环读取数据
	for (i = 0; i < 10; i++) {
		clock_gettime(CLOCK_MONOTONIC, &start);

		if (read_mmc5633_data(&x, &y, &z, &temp) < 0) {
			printf("read data failed\n");
			return -1;
		}

		// 应用校准偏移
		float x_cal = x - (min_x + max_x) / 2;
		float y_cal = y - (min_y + max_y) / 2;
		float z_cal = z - (min_z + max_z) / 2;

		clock_gettime(CLOCK_MONOTONIC, &end);
		elapsed = (end.tv_sec - start.tv_sec) + (end.tv_nsec - start.tv_nsec) / 1e9;

		// 计算磁场方向和强度
		float heading, intensity;
		calculate_magnetic_orientation(x_cal, y_cal, z_cal, &heading, &intensity);
		
		// 打印结果
		printf("=== MMC5603 Sensor Data ===\n");
		printf("Raw: X=%.4f uT, Y=%.4f uT, Z=%.4f uT\n", x, y, z);
		printf("Calibrated: X=%.4f uT, Y=%.4f uT, Z=%.4f uT\n", x_cal, y_cal, z_cal);
		printf("Magnetic Intensity: %.4f uT\n", intensity);
		printf("Heading: %.1f degrees\n", heading);
		printf("Temperature: %.2f °C\n", temp);
		printf("Reading Time: %.3f ms\n", elapsed * 1000);
		printf("\nInstructions: \n");
		printf("1. Rotate the board 360 degrees\n");
		printf("2. Observe which heading option changes most consistently\n");
		printf("3. Modify calculate_magnetic_orientation to use the best option\n");
		printf("---------------------------./mmc5603_test -c -f 10   ./mmc5603_test -f 10 \n");

		// 间隔指定时间读取一次
		sleep(1);
	}

	return 0;
}

应用程序makefile

SDK=/home/book/work/rk3506/sdk
KERNELDIR ?= $(SDK)/kernel-6.1
CROSS_COMPILE = $(SDK)/prebuilts/gcc/linux-x86/arm/gcc-arm-10.3-2021.07-x86_64-arm-none-linux-gnueabihf/bin/arm-none-linux-gnueabihf-
 
PWD := $(shell pwd)
app_name=mmc5603_test

all:
	$(CROSS_COMPILE)gcc mmc5603app.c -lm -o $(app_name)
	chmod +x $(app_name)

clean:
	rm -rf $(app_name)

运行

chmod +x mmc5603_test ;./mmc5603_test -c -f 1000
Trigger: sampling frequency set to 100Hz
Debug: magn_scale=0.000062500
Debug: raw_x=528147, x=33.0092 uT
Debug: raw_y=515869, y=32.2418 uT
Debug: raw_z=542233, z=33.8896 uT
Debug: Headings - Option1: 100.1, Option2: 349.9, Option3: 259.9, Option4: 10.1
=== MMC5603 Sensor Data ===
Raw: X=33.0092 uT, Y=32.2418 uT, Z=33.8896 uT
Calibrated: X=-0.0215 uT, Y=0.1205 uT, Z=0.0001 uT
Magnetic Intensity: 0.1224 uT
Heading: 259.9 degrees
Temperature: 22.60 °C
Reading Time: 46.453 ms

Instructions:

  1. Rotate the board 360 degrees
  2. Observe which heading option changes most consistently
  3. Modify calculate_magnetic_orientation to use the best option
    ---------------------------./mmc5603_test -c -f 10 ./mmc5603_test -f 10
本文章已经生成可运行项目
标签
#linux #RK3506 #MMC5603 #MMC5633
liupeng08304
关注
mmc5603nj资料.zip
08-23
mmc5603nj 地磁传感器开发资料，快速上手
Lib-for-Keil-ARM.zip
09-18
mmc5603nj地磁传感器 接口调参考main_sample.c 函数， 1 第一步要先要拿到加速度及地磁数据， 2 开机初始化一次InitialAlgorithm 函数 3 打开指南针时，以50HZ 循环调用 while(1) 函数内容。 fAzimuth 为指向值。
MMC5603NJ地磁传感器在ARM开发中的应用
FslzLua的博客
09-20 1166
MMC5603NJ通过I2C接口与开发板通信，因此需要连接传感器的SDA（数据线）和SCL（时钟线）引脚到开发板的相应引脚上。通过以上代码，我们可以在ARM开发环境中使用MMC5603NJ地磁传感器，并读取磁场数据。MMC5603NJ是一款常用的地磁传感器，本文将介绍如何在ARM开发环境中使用MMC5603NJ地磁传感器，并提供相应的源代码示例。接下来，我们可以在ARM开发环境中编写代码来读取MMC5603NJ地磁传感器的数据。然后，我们可以通过适当的寄存器配置传感器，以适应特定的应用需求。
MMC5603NJ地磁传感器（指南针示例）
qq_36075612的博客
08-28 6972
概述 最近项目上的需要，增加指南针功能，通过网上搜索得知，这个传感器的资料比较少，在此写了一个Demo，希望能帮助到需要的攻城狮们，一起学习一起探讨，加油 加油 加油！ 一、原理图 二、平台 1、keil5.92 2、RTL8762D（瑞昱 蓝牙芯片） 三、编码 四、运行结果 五、总结 参考文章： https://blog.csdn.net/weixin_41675504/article/details/102564383 .........
MMC5603地磁传感器调试日志
weixin_41675504的博客
05-16 8965
/******************************************************************************/ /*开发平台:Keil uVision5 */ /*开发语言:C语言 ...
[Android][sensor][mag]指南针方向偏差，软磁三轴调整
csdn_liqian的博客
11-15 1632
指南针方向偏差，软磁三轴调整
MTK sensor调试日志
u010783226的专栏
12-14 4793
注 epl259x的驱动可以用于 epl2590 MN66213 MN26233TKDN - id = 0x91 MN25713EKDN - id = 0x81 8975 // 4个手势方向 - 4颗sensor排列 2219 // 4个手势方向 als 室内光照下应该为700左右 ps 底噪值应该为700左右 - *#*#3646633#*#* *#*#889988#*#* -&gt...
Python之adafruit-circuitpython-mmc56x3包语法、参数和实际应用案例
王国平的博客
10-11 1018
adafruit-circuitpython-mmc56x3 是一个用于控制 MMC5603/MMC5613 系列磁力计（磁传感器）的 CircuitPython 库。这些传感器能够测量地球磁场强度，常用于方向检测、罗盘应用、位置追踪等场景。该库提供了简单易用的接口，方便开发者读取磁场数据、温度数据，并配置传感器参数。
Adafruit MMC56x3磁力计驱动库详解：AMR传感器与统一抽象层实践
weixin_31620365的博客
04-12 583
磁力计是姿态感知、电子罗盘和工业导航的核心传感器，其性能取决于传感原理、数据链路设计与软件抽象能力。AMR（各向异性磁阻）技术相比霍尔效应具备更高分辨率与温度稳定性，而统一传感器抽象层（Adafruit_Sensor）通过标准化接口屏蔽硬件差异，显著提升嵌入式项目可移植性。本驱动深度集成MMC5603NJ的温度补偿、零偏校准与I²C时序控制，将原始寄存器操作封装为`getEvent()`等通用方法，使开发者直接获取µT单位磁场矢量。适用于Arduino、ESP32、STM32及FreeRTOS等平台，在AG
小智音箱MMC5603NJ高精度磁传感
weixin_42610671的博客
11-10 1024
小智音箱通过MMC5603NJ三轴磁传感器实现高精度方向感知，结合GMR技术和姿态算法，自动校准声场方向，提升听感体验，并支持多设备协同与手势识别等智能功能。
7.android 8.1 msensor移植
老道
03-27 1774
1.驱动移植A      update/alps/kernel-4.4/drivers/misc/mediatek/sensors-1.0/magnetometer/KconfigA      update/alps/kernel-4.4/drivers/misc/mediatek/sensors-1.0/magnetometer/MakefileA       update/alps/kerne...
akm地磁传感器
04-07
akm8963地磁传感器规格书资料，请参考
【亲测免费】 MMC5983地磁传感器：高精度测量的利器
gitblog_09759的博客
10-15 1336
MMC5983地磁传感器：高精度测量的利器 【下载地址】MMC5983地磁传感器C语言驱动及数据手册 本仓库提供了MMC5983地磁传感器的C语言驱动程序及详细的数据手册。MMC5983是一款高性能的地磁传感器，支持四线SPI数据通信，具有18位数据输出精度和高达200Hz的输出速率。该资源文件包含了驱动程序的源代码以及...
瑞芯微RK3506核心板SPI Slave从设备驱动开发与实战调试指南
convnet3designer的博客
02-14 285
本文详细解析瑞芯微RK3506核心板的SPI Slave驱动开发与调试实战。重点介绍自定义传输协议、GPIO同步信号处理及驱动源码架构，分享信号完整性优化、DMA配置与性能调优等实用技巧，帮助开发者高效解决SPI从设备开发中的常见问题。
RK3506 drm显示编程
m0_55916212的博客
12-19 2726
RK3506处理器drm的使用
MMC5603磁力计实战指南：从硬件连接到航向解算
最新发布
weixin_27006759的博客
05-13 591
磁力计是感知地球磁场、提供绝对航向参考的核心传感器，其工作原理基于霍尔效应或磁阻效应，能够测量磁场在三个正交轴上的分量。这项技术对于实现精确的方位感知至关重要，尤其在需要区分绝对方向的场景中，如无人机导航、机器人定位和智能设备姿态跟踪。通过I2C等数字接口，磁力计可以方便地集成到嵌入式系统中，其数据经过校准和滤波后，能够显著提升航向角的精度和稳定性。在实际应用中，磁力计常与加速度计、陀螺仪融合，构成9轴惯性测量单元（IMU），通过传感器融合算法（如卡尔曼滤波）实现鲁棒的姿态解算。本文以MMC5603磁力计为
瑞芯微RK3506开发板Ethercat主站适配开发详细攻略，实测微秒级抖动延迟！
Industio_CSDN的博客
05-09 3122
瑞芯微RK3506开发板Ethercat主站适配开发详细攻略，实测微秒级抖动延迟！
RK3506 linux LVGL控制小米CyberGear电机
m0_55916212的博客
12-19 3006
这是一场旧日技艺与新知好奇的邂逅：手握 HD-RK3506-MINI 开发板，搭配 小米 CyberGear 微电机，在代码与电机的交汇中寻得乐趣。文中探索了电机的通信秘密，解读控制指令与模式切换，只为让指尖的指令唤醒电机的灵动节奏。让我们在硬件与代码的世界里，一同起舞。
万象奥科RK3506MINI板 移植正点原子7寸屏 ft5426触摸驱动
baidu_38886562的博客
07-11 3045
万象奥科RK3506的MINI板，适配正点原子7寸LCD屏幕触摸调试记录
ESP-IDF专用MMC56X3磁力计驱动：高精度I²C罗盘开发指南
weixin_32480007的博客
03-20 165
磁力计是物联网设备实现电子罗盘、姿态感知与地理定位的核心传感器，其原理基于霍尔效应或各向异性磁阻（AMR）等物理机制，通过测量空间磁场矢量分量解算方向角。高性能驱动需兼顾I²C通信可靠性、温度补偿精度与低功耗实时性，技术价值体现在±30 Gauss宽量程、0.0625 mG/LSB高分辨率及1.5 µA待机电流。典型应用场景包括ESP32无人机航向参考、智能穿戴设备步态导航、GIS手持终端真北校准及资产追踪器中断唤醒采集。本文聚焦esp_mmc56x3这一生产就绪型ESP-IDF组件，深度解析其寄存器级控制
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值