Android Senor Framework (四)SensorService加载

最新推荐文章于 2023-09-20 18:44:29 发布
最新推荐文章于 2023-09-20 18:44:29 发布
阅读量783 收藏 2
点赞数 1
分类专栏： Android Sensor 文章标签： sensor
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/top5419/article/details/119276959
版权

onFirstRef

前个内容介绍了 SystemServer启动SensorService的过程，同时描述了 SensorService有集成它的类间接父类RefBase，SesnorService中重写了onFirstRef方法，该方法在SensorService对象被第一次强引用时自动调用其onFirstRef方法； 下面是Sensor Service的onFirstRef实现：

代码路径：./frameworks/native/services/sensorservice/SensorService.cpp

void SensorService::onFirstRef() {
        ALOGD("nuSensorService starting...");
        SensorDevice& dev(SensorDevice::getInstance());
 //创建 SensorDevice 的实例   
 //......   
        if (dev.initCheck() == NO_ERROR) {
            sensor_t const* list;
            ssize_t count = dev.getSensorList(&list);
            if (count > 0) {
                //......
                for (ssize_t i=0 ; i<count ; i++) {
                //......
                    if (useThisSensor) {
                        registerSensor( new HardwareSensor(list[i]) );
                //调用 Sensor HAL 提供的 get_sensors_list 接口，获取所支持的 Sensor 信息,用registerSensor函数把Sensor保存起来
                // 每个sensor 对应一个HardwareSensor；
                    }
                }
                SensorFusion::getInstance();
                // SensorFusion功能，传感融合。它的主要作用就是，按照一定的算法计算系统的多个传感器对某一个值的上报的数据，得到更准确的值。
                if (hasGyro && hasAccel && hasMag) {
                    // 添加 Android virtual sensors 如果HAL中还未有
                    bool needRotationVector =   (virtualSensorsNeeds & (1<<SENSOR_TYPE_ROTATION_VECTOR)) != 0;
    
                    registerSensor(new RotationVectorSensor(), !needRotationVector, true);
                    registerSensor(new OrientationSensor(), !needRotationVector, true);
                    registerSensor(new LinearAccelerationSensor(list, count),     !needLinearAcceleration, true);
                    // virtual debugging sensors are not for user
                    registerSensor( new CorrectedGyroSensor(list, count), true, true);
                    registerSensor( new GyroDriftSensor(), true, true);
                }
                if (hasAccel && hasGyro) {
                    registerSensor(new GravitySensor(list, count), !needGravitySensor, true);
                    bool needGameRotationVector = (virtualSensorsNeeds & (1<<SENSOR_TYPE_GAME_ROTATION_VECTOR)) != 0;
                    registerSensor(new GameRotationVectorSensor(), !needGameRotationVector, true);
                }
                if (hasAccel && hasMag) {
                    bool needGeoMagRotationVector =
                            (virtualSensorsNeeds & (1<<SENSOR_TYPE_GEOMAGNETIC_ROTATION_VECTOR)) != 0;
                    registerSensor(new GeoMagRotationVectorSensor(), !needGeoMagRotationVector, true);
                }
    
                //创建Looper  Looper 用于 enable sensor 后，进行数据的接收；
                mLooper = new Looper(false);
                const size_t minBufferSize = SensorEventQueue::MAX_RECEIVE_BUFFER_EVENT_COUNT;
                mSensorEventBuffer = new sensors_event_t[minBufferSize];
                mSensorEventScratch = new sensors_event_t[minBufferSize];
                mMapFlushEventsToConnections = new wp<const SensorEventConnection> [minBufferSize];
                mCurrentOperatingMode = NORMAL;
    
                mNextSensorRegIndex = 0;
                for (int i = 0; i < SENSOR_REGISTRATIONS_BUF_SIZE; ++i) {
                    mLastNSensorRegistrations.push();
                }
    
                mInitCheck = NO_ERROR;
                mAckReceiver = new SensorEventAckReceiver(this);
                //创建 SensorEventAckReceiver 用于在 dispatch wake up sensor event 给上层后，接收上层返回的确认 ACK
                mAckReceiver->run("SensorEventAckReceiver", PRIORITY_URGENT_DISPLAY);
                run("SensorService", PRIORITY_URGENT_DISPLAY);
                enableSchedFifoMode();
            }
        }
    }

从以上内容可知，onFirstRef在最开始的阶段便，创建 SensorDevice 的实例 ，使用SersorDevice 获取SensorList（实际访问了HAL），

registerSensor， 创建了mLooper,mSensorEventBuffer, SensorEventAckReceiver， 调用其run函数；调用SensorService的run函数；

下面分别对这些内容做简要分析：

SensorDevice

代码路径: ./native/services/sensorservice/SensorDevice.cpp

SensorDevice::SensorDevice()
    :  mSensorDevice(0),
       mSensorModule(0) {
    status_t err = hw_get_module(SENSORS_HARDWARE_MODULE_ID,
            (hw_module_t const**)&mSensorModule);
 //!< 加载Sensor HAL 的动态库 >! NoteBy: yujixuan
    ALOGE_IF(err, "couldn't load %s module (%s)",
            SENSORS_HARDWARE_MODULE_ID, strerror(-err));

    if (mSensorModule) {
        err = sensors_open_1(&mSensorModule->common, &mSensorDevice);
 //!< 调用其open方法，获取Hal中 的device >! NoteBy: yujixuan
        ALOGE_IF(err, "couldn't open device for module %s (%s)",
                SENSORS_HARDWARE_MODULE_ID, strerror(-err));
            sensor_t const* list;
            ssize_t count = mSensorModule->get_sensors_list(mSensorModule, &list);
 //!< 获取sensor list >! NoteBy: yujixuan
            mActivationCount.setCapacity(count);
            Info model;
            for (size_t i=0 ; i<size_t(count) ; i++) {
                mActivationCount.add(list[i].handle, model);
                mSensorDevice->activate(
                        reinterpret_cast<struct sensors_poll_device_t *>(mSensorDevice),
                        list[i].handle, 0);
            }
        }
    }
}

在SensorDevice的构造函数中可以看得到，在这里是与HAL层交互的实现。 通过hw_get_module 获取HAL hw_module_t 结构体mSensorModule, 通过其注册的open方法，获取到mSensorDevice; 调用get_sernsor_list获取到sensorlist；

通过前面在msm8909平台的SesnorHAL分析，与之对应这里获取的mSensorModule既是：

struct sensors_module_t HAL_MODULE_INFO_SYM = {
        common: {
           //......
                methods: &sensors_module_methods,  
        },
        get_sensors_list: sensors__get_sensors_list, 
};

sensors_open_1回调：sensors_module_methods的open函数；在open函数，填充获取了 device，也就是当前的mSensorDevice；

open_sensors(const struct hw_module_t* module, const char*,
						struct hw_device_t** device)
//......
		dev->device.common.module   = const_cast<hw_module_t*>(module);
		dev->device.common.close	= poll__close;
		dev->device.activate		= poll__activate;
		dev->device.setDelay		= poll__setDelay;
		dev->device.poll		= poll__poll;
		dev->device.calibrate		= poll_calibrate;
//......
		*device = &dev->device.common;
}

HAL层的实现由平台厂商和Sensor ic厂商来完成实现非AOSP标准的框架内的细节，Sensor device 完成了相同过程的访问过程；拥有对Sensor 控制，Sensor数据获取的访问接口；

SensorList

class SensorService{
   //......
    SensorList mSensors;
    const Sensor& registerSensor(SensorInterface* sensor,
                                 bool isDebug = false, bool isVirtual = false);    
   //......
}

前面的分析，通过SensorDevice获取到sensor_t 组成的sensor list； 而在SensorService中， Sensorlist的定义是SensorList类的 mSensors； 在 onFirstRef的过程中，也可以看到，通过sensor device获取了 count和list，根据每一个sensor调用registerSensor （以及其他SensorList中提供的方法）注册到SensorService中；其函数内容如下：

const Sensor& SensorService::registerSensor(SensorInterface* s, bool isDebug, bool isVirtual) {
    int handle = s->getSensor().getHandle();
    int type = s->getSensor().getType();
    if (mSensors.add(handle, s, isDebug, isVirtual)){
        mRecentEvent.emplace(handle, new RecentEventLogger(type));
        return s->getSensor();
    } else {
        return mSensors.getNonSensor();
    }
}

主要是调用SensorList的add 方法填充每一个sensor到List中去；
SensorList的存在是维系记录着所有的sensor对象；以下列出SensorList 类的主要内容：

代码路径：frameworks\native\services\sensorservice\SensorList.h

class SensorList : public Dumpable {
public:
    bool add(int handle, SensorInterface* si, bool isForDebug = false, bool isVirtual = false);
    bool remove(int handle);
    inline bool hasAnySensor() const { return mHandleMap.size() > 0;}
    //helper functions
    const Vector<Sensor> getUserSensors() const;
    const Vector<Sensor> getUserDebugSensors() const;
    const Vector<Sensor> getDynamicSensors() const;
    const Vector<Sensor> getVirtualSensors() const;
    String8 getName(int handle) const;
    sp<SensorInterface> getInterface(int handle) const;
    bool isNewHandle(int handle) const;
    void forEachSensor(const TF& f) const;
    const Sensor& getNonSensor() const { return mNonSensor;}
    // Dumpable interface
    virtual std::string dump() const override;
    virtual ~SensorList();
private:
    struct Entry {
        sp<SensorInterface> si;
        const bool isForDebug;
        const bool isVirtual;
        Entry(SensorInterface* si_, bool debug_, bool virtual_) :
            si(si_), isForDebug(debug_), isVirtual(virtual_) {
        }
    };
    const static Sensor mNonSensor; //.getName() == "unknown",
//......
}

其中 存放Sensor的对象结构是 const static Sensor mNonSensor; Sensor类：它代表一个sensor，和前面application中提到的Sensor对象一一对应，中间会通过JNI 完成相应的类型转换；

class Sensor : public ASensor, public LightFlattenable<Sensor>
{
public:
    enum {
        TYPE_ACCELEROMETER  = ASENSOR_TYPE_ACCELEROMETER,
        TYPE_MAGNETIC_FIELD = ASENSOR_TYPE_MAGNETIC_FIELD,
        TYPE_GYROSCOPE      = ASENSOR_TYPE_GYROSCOPE,
        TYPE_LIGHT          = ASENSOR_TYPE_LIGHT,
        TYPE_PROXIMITY      = ASENSOR_TYPE_PROXIMITY
    };
    struct uuid_t{
        union {
            uint8_t b[16];
            int64_t i64[2];
        };
        uuid_t(const uint8_t (&uuid)[16]) { memcpy(b, uuid, sizeof(b));}
        uuid_t() : b{0} {}
    };
    Sensor(const char * name = "");
    Sensor(struct sensor_t const* hwSensor, int halVersion = 0);
    Sensor(struct sensor_t const& hwSensor, const uuid_t& uuid, int halVersion = 0);
    ~Sensor();
    const String8& getName() const;
    const String8& getVendor() const;
    int32_t getHandle() const;
    int32_t getType() const;
    float getMinValue() const;
    float getMaxValue() const;
    float getResolution() const;
    float getPowerUsage() const;
    int32_t getMinDelay() const;
    nsecs_t getMinDelayNs() const;
    int32_t getVersion() const;
    uint32_t getFifoReservedEventCount() const;
    uint32_t getFifoMaxEventCount() const;
    const String8& getStringType() const;
//......
    const uuid_t& getUuid() const;
    int32_t getId() const;
//......
private:
    String8 mName;
    String8 mVendor;
    int32_t mHandle;
    int32_t mType;
    float   mMinValue;
    float   mMaxValue;
    float   mResolution;
    float   mPower;
    int32_t mMinDelay;
    int32_t mVersion;
//......
};

显然，因为类型不一致的原因，从HAL中获取的Sensor直接注册到SensorService中的，registerSensor接收的对象是 SensorInterface* sensor； 在处理HAL sensor list sensor的for循环中可以看到， 每循环一个registerSensor 注册的是new的HardwareSensor； 以下是 HardwareSensor的实现：

class HardwareSensor : public BaseSensor ```cpp class HardwareSensor : public BaseSensor { public: HardwareSensor(const sensor_t& sensor); HardwareSensor(const sensor_t& sensor, const uint8_t (&uuid)[16]); 
virtual ~HardwareSensor();

virtual bool process(sensors_event_t* outEvent,
        const sensors_event_t& event);
virtual status_t activate(void* ident, bool enabled) override;
virtual status_t batch(void* ident, int handle, int flags, int64_t samplingPeriodNs,
                       int64_t maxBatchReportLatencyNs) override;
virtual status_t setDelay(void* ident, int handle, int64_t ns) override;
virtual status_t flush(void* ident, int handle) override;
virtual bool isVirtual() const override { return false; }
virtual void autoDisable(void *ident, int handle) override;

};


</details>

它继承自BaseSensor，BaseSensor定义如下：

<details>
<summary>class BaseSensor : public SensorInterface</summary>


```cpp
class BaseSensor : public SensorInterface {
public:
    BaseSensor(const sensor_t& sensor);
    BaseSensor(const sensor_t& sensor, const uint8_t (&uuid)[16]);

    // Not all sensors need to support batching.
    virtual status_t batch(void* ident, int handle, int, int64_t samplingPeriodNs,
                           int64_t maxBatchReportLatencyNs) override {
        if (maxBatchReportLatencyNs == 0) {
            return setDelay(ident, handle, samplingPeriodNs);
        }
        return -EINVAL;
    }

    virtual status_t flush(void* /*ident*/, int /*handle*/) override {
        return -EINVAL;
    }
    virtual const Sensor& getSensor() const override { return mSensor; }
    virtual void autoDisable(void* /*ident*/, int /*handle*/) override { }
protected:
    SensorDevice& mSensorDevice;
    Sensor mSensor;
};

SensorInterface 继承自SensorInterface ， SensorInterface 定义如下：

class SensorInterface : public VirtualLightRefBase 
class SensorInterface : public VirtualLightRefBase {
public:
    virtual ~SensorInterface() {}

    virtual bool process(sensors_event_t* outEvent, const sensors_event_t& event) = 0;

    virtual status_t activate(void* ident, bool enabled) = 0;
    virtual status_t setDelay(void* ident, int handle, int64_t ns) = 0;
    virtual status_t batch(void* ident, int handle, int /*flags*/, int64_t samplingPeriodNs,
                           int64_t maxBatchReportLatencyNs) = 0;

    virtual status_t flush(void* /*ident*/, int /*handle*/) = 0;

    virtual const Sensor& getSensor() const = 0;
    virtual bool isVirtual() const = 0;
    virtual void autoDisable(void* /*ident*/, int /*handle*/) = 0;
};

HardwareSensor集成SensorInterface 做了相应的实现，也是对Sensor数据结构的转换；

SensorEventAckReceiver

最后阶段，SesnorService创建了 SensorEvent 接收器： 其定义如下:

class SensorService::SensorEventAckReceiver : public Thread {
    sp<SensorService> const mService;
public:
    virtual bool threadLoop();
    SensorEventAckReceiver(const sp<SensorService>& service)
            : mService(service) {
    }
};

主要是实现一个线程，线程内容如下:

bool SensorService::SensorEventAckReceiver::threadLoop() {
    ALOGD("new thread SensorEventAckReceiver");
    sp<Looper> looper = mService->getLooper();
    do {
        bool wakeLockAcquired = mService->isWakeLockAcquired();
        int timeout = -1;
        if (wakeLockAcquired) timeout = 5000;
        int ret = looper->pollOnce(timeout);
        if (ret == ALOOPER_POLL_TIMEOUT) {
           mService->resetAllWakeLockRefCounts();
        }
    } while(!Thread::exitPending());
    return false;
}

定时执行pollOnce；

在onFirstRef中的调用：

mAckReceiver = new SensorEventAckReceiver(this);
mAckReceiver->run("SensorEventAckReceiver", PRIORITY_URGENT_DISPLAY);

SensorService run()

前面分析SensorService类定义时，有看到 他同时继承了threadLoop， 在onFirstRef的最后阶段，也可以看到其重写的run方法被调用；

 run("SensorService", PRIORITY_URGENT_DISPLAY);

最后看下 SensorService中 ThreadLoop的实现内容：

bool SensorService::threadLoop() {
//......
        SensorDevice& device(SensorDevice::getInstance());
//......
        do {
                ssize_t count = device.poll(mSensorEventBuffer, numEventMax);
                SortedVector< sp<SensorEventConnection> > activeConnections;
                populateActiveConnections(&activeConnections);
        //......   
                // handle virtual sensors
                if (count && vcount) {
                sensors_event_t const * const event = mSensorEventBuffer;
                if (!mActiveVirtualSensors.empty()) {
                        size_t k = 0;
                        SensorFusion& fusion(SensorFusion::getInstance());
                        if (fusion.isEnabled()) {
                        for (size_t i=0 ; i<size_t(count) ; i++) {
                                fusion.process(event[i]);
                        }
                        }
                        for (size_t i=0 ; i<size_t(count) && k<minBufferSize ; i++) {
                        for (int handle : mActiveVirtualSensors) {
                                sensors_event_t out;
                                sp<SensorInterface> si = mSensors.getInterface(handle);
                                }
                                if (si->process(&out, event[i])) {
                                mSensorEventBuffer[count + k] = out;
                                k++;
                                }
                        }
                        }
                        if (k) {
                        // record the last synthesized values
                        recordLastValueLocked(&mSensorEventBuffer[count], k);
                        count += k;
                        // sort the buffer by time-stamps
                        sortEventBuffer(mSensorEventBuffer, count);
                        }
                }
                }
                // handle backward compatibility for RotationVector sensor
                if (halVersion < SENSORS_DEVICE_API_VERSION_1_0) {
                for (int i = 0; i < count; i++) {
                        if (mSensorEventBuffer[i].type == SENSOR_TYPE_ROTATION_VECTOR) {
                        mSensorEventBuffer[i].data[4] = -1;
                        }
                }
                }    
                 //计算......      
                //......  
                bool needsWakeLock = false;
                size_t numConnections = activeConnections.size();
                for (size_t i=0 ; i < numConnections; ++i) {
                if (activeConnections[i] != 0) {
                        activeConnections[i]->sendEvents(mSensorEventBuffer, count, mSensorEventScratch,
                                mMapFlushEventsToConnections);
                        needsWakeLock |= activeConnections[i]->needsWakeLock();
                        // If the connection has one-shot sensors, it may be cleaned up after first trigger.
                        // Early check for one-shot sensors.
                        if (activeConnections[i]->hasOneShotSensors()) {
                        cleanupAutoDisabledSensorLocked(activeConnections[i], mSensorEventBuffer,
                                count);
                        }
                }
                }
//......
        } while (!Thread::exitPending());
        
        ALOGW("Exiting SensorService::threadLoop => aborting...");
        abort();
        return false;
        }

threadLoop的最开始，取到sensordevice的引用； 在threadLoop循环体内，调用了 device.poll 向hal层取数据；

调用sendEvents上报sensor信息；

总结时序图

对该过程的绘制了简要的uml时序图如下：

  1. onFirstRef（)属于其父类RefBase，该函数在强引用sp新增引用计数时,第一次强引用会自动调用此函数； //参考：深入理解android 之sp和wp
  2. 获取一个SensorDevice实例对象，SensorDevice& dev(SensorDevice::getInstance());
  3. 加载HAL库， 查找 hal中对应的 module id 微"sensors"的moudle；
    hw_get_module(SENSORS_HARDWARE_MODULE_ID, (hw_module_t const**)&mSensorModule);得到mSensorModule；
  4. sensors_open_1：module->methods->open 调用open函数, hw_module_t除了设备信息外提供另外一个结构体hw_module_methods_t, 它只有一个open函数，调用设备注册的open回调；让调用者得到基于hw_device_t的设备结构体，hw_device_t包含了hw_module_t; (标红为HAL的三个关键结构体) HAL的核心内容是获取hw_device_t，向上转型，获得其中的设备数据结构以及函数接口；
  5. 通过HAL中添加的get_sensors_list获取list；
  6. qcom平台上，HAL中的实际管控是有NativeSensorManager来管控，这里也是返回单例NativeSensorManager对象中的sensorlist，及sensor个数
  7. 根据sensor个数，for循环，执行active；
  8. 完成SensorDevice的构造，SensorService得到了 实例对象SensorDevice dev；
  9. 获取sensor list，及sensor num；调用过程与上面相同；
  10. 根据sensor个数，for循环， 注册Sensor到sensorsercvice
  11. 注册的过程是创建对应的HardwareSensor;
  12. SensorService 创建SensorEeventReceiver，SensorEventAckReceiver : public 集成了Thread ；
  13. 启动mAckReceiver 重写实现的这个线程，SensorEventAckReceiver，调用run方法，启动这个线程："SensorEventAckReceiver"；
  14. SensorService自身也集成了 Thread， 在SensorService中重写threadLoop； 这个地方调用了其run方法，启动线程："SensorService"；
  15. 通过device poll 管理，sensorEvent
AutoStack
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android SensorService分析
小胡子_0214
02-12 1065
sensorServer分析
Android sensor 框架
小胡子_0214
03-28 932
自己总结
android 系统sensorservice 介绍
01-04
介绍android系统中 sensor的服务框架，对于学习framework以及系统架构的 有点帮助
Android系统之onFirstRef自动调用原理(一百三十八)
Android系统攻城狮
02-11 2575
Android之onFirstRef用法
Android13音频子系统分析(二)---初始化
最新发布
余静江的博客
09-20 2945
本文我会分别介绍AudioFlinger、AudioPolicyService和AudioService这三个模块的初始化过程。AudioHAL进程的核心源码AOSP里面没有，所以这里不做介绍。想了解AudioHAL进程的启动流程，可以从/hardware/interfaces/audio/common/all-versions/default/service/service.cpp文件的main()函数入手，进行分析。
Android Framework SensorService 分析
goodnight1994的博客
05-09 4124
1 SensorService  的启动1.1 SensorService:onFirsrRef()SensorService 运行在 system_server 里边，在android/frameworks/base/services/core/jni/com_android_server_SystemServer.cpp通过实例化一个 SensorService 对象启动，如下:1. stat...
Android 中 C++ Thread线程用法(五十七)
Android系统攻城狮
09-22 8099
Android对Linux线程提供了C++封装Thread类，它是线程的基类。使用Thread类，需创建一个新类继承于Thread类，并实现threadLoop()方法，它即是线程函数。要启动线程，调用run()函数即可。 /* * Android线程封装的基类 */ class Thread : virtual public RefBase { public:
sensor-box
07-22
用于android senor调试，很好用的工具，可以图形化显示，很方便使用
SensorSample_传感器_android_
09-28
各种传感器的使用方法，包括了方向传感器、磁场传感器、温度传感器、光传感器和压力传感器的各自调用用法等
Camera sensor 工作流程介绍
03-14
ensor（图像传感器） Senor 是一种半导体芯片，有两种类型：CCD 和 CMOS。Sensor 将从 lens 上传导过来的光线转换为电信号， 再通过内部的 AD 转换为数字信号。 由于 Sensor 的每个 pixel 只能感光 R 光或者 B 光...
NSA(da217).rar_DA217_G-senor_pagerwe_驱动
07-15
DA217驱动，纯C，移植方便，适用于iot等应用，可以直接用于各平台开发
关于pulse sensor 程序的实现流程图.vsd
03-09
pulse senor的实现流程图，在程序的基础上实现流程，直观的实现，生动体现其过程，加深理解，有助于提高使用者对pulse senor的认识
一、Android CameraService服务启动
BirdsLife的博客
05-20 1087
Android CameraService服务启动
android的智能指针
10-09 831
android的应用程序框架层大多使用C++开发，为了解决C++指针易出错的问题，android提供了C++智能指针。 通常我们使用引用计数计数来维护对象的声明周期，对象引用计数计数的核心问题在于谁来维护对象的引用计数。手动维护方式显然不可取，智能指针提供了一种自动维护对象引用计数的计数。要强调的是智能指针不是一个指针，但是它引用了一个实际使用的对象，作为对象它能够自动地维护世纪对象的引用计数。
Android7.1 Offload模式下的音频数据播放流程
zhuyong006的博客
04-16 4434
在Android7.1 Offload模式下的音频数据抽取过程完成数据的抽取后，紧跟着会将数据交给AudioFlinger的track进行播放 MixerThread是Android音频输出的核心部分，所有Android的音频都需要经过MixerThread进行混音后再输出到音频设备。   MixerThread的继承关系如下： MixerThread--->PlaybackThr...
深入浅出 - Android系统移植与平台开发（十三） - Sensor HAL框架分析之三
热门推荐
mr_raptor的专栏
10-30 1万+
让我们来看看SensorManager的代码 SensorManager框架层代码 @frameworks/base/core/java/android/hardware/SensorManager.java public SensorManager(Looper mainLooper) { mMainLooper = mainLooper; // 上面说了...
Android Native Thread
SuperLi
11-20 1663
Android 本地线程
Android 12(S) 图形显示系统 - 示例应用（二）
fcryuuhou的专栏
02-22 2068
1 前言 为了更深刻的理解Android图形系统抽象的概念和BufferQueue的工作机制，这篇文章我们将从Native Level入手，基于Android图形系统API写作一个简单的图形处理小程序。透过这个小程序我们将学习如何使用Native API创建Surface，如何请求图形缓冲区，如何向图形缓冲区中写入数据等知识。Talk is cheap, show me the code。让我们马上开始吧！ 注：本系列文章的分析及代码均基于Android 12(S) Source Code，可参考：AO
sensorservice代码阅读
bob_fly1984的专栏
03-05 1149
1：onFirstRef方法 sensorservice实例化被调用，只会调用一次。具体就是在systemserve启动过程中会启动这个binder服务。 void SensorService::onFirstRef() { ALOGD("nuSensorService starting..."); SensorDevice& dev(SensorDevice::getInst
pulse senor脉搏传感器与51单片机
05-12
脉搏传感器是一种用于检测人体脉搏信号的传感器，它可以将脉搏信号转换成电信号输出，通常使用的是光学式脉搏传感器。而51单片机是一种广泛应用于嵌入式系统中的单片机，它能够进行数据的采集、处理和输出等操作。 在应用上，常将脉搏传感器与51单片机结合起来使用。通过将脉搏传感器输出的电信号接入到51单片机的输入端口，可以实现对脉搏信号的采集和处理，从而达到监测人体生理指标的目的。 在具体实现上，需要编写相应的程序，并选用合适的硬件模块进行组装。同时，需要定义好传感器与单片机之间的通信协议，以确保数据的有效传输和处理。此外，还需要进行一定的滤波处理，以提高采集的信号质量和减少误差。 总之，通过将脉搏传感器与51单片机结合使用，可以实现对人体脉搏信号的实时采集、处理和分析，从而实现实时监测人体生理指标的目的，具有广泛的应用价值。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值