会员卡管理系统哪里买_品牌的三大核心价值_百度搜索广告怎么投放_竞价账户托管

一、概述

1、系统组成：

光感模块：通过环境光传感器（如BH1730、BH1750、TSL2561等）获取当前环境的光强度（通常以Lux为单位）。

PWM背光控制：利用PWM信号控制屏幕背光亮度，PWM信号的占空比决定了亮度的高低，系统通过调节该信号来改变屏幕亮度。

2、工作原理：

• 光感模块通过I2C接口读取环境光数据，并将其传输给系统。
• 系统根据光强度计算适当的屏幕亮度值，并通过控制PWM信号来调整屏幕亮度。
• 通常在低光环境下，屏幕亮度会自动降低，反之则提高，从而在保证视觉效果的同时节省电能。

上述光感模块和PWM背光的功能调试在前面的文章中已经实现

BH1730FVC光感模块调试_bh1730fvc sensor-CSDN博客

GPIO模拟输出PWM调节屏幕背光亮度_gpio模拟pwm输出-CSDN博客

二、光感和PWM背光

1、读取背光值

cat /sys/devices/soc0/blacklight/light_level

2、背光亮度控制

echo 值 > /sys/devices/soc0/blacklight/light_level

3、读取光感值

cat /sys/bus/iio/devices/iio:device0/in_illuminance_raw

4、背光和光感映射关系

        得到背光等级与屏幕亮度之间的关系。我们就能将 sensor上报感光----手机屏幕亮度，转换为 sensor上报感光----背光等级。

init/backlight.ini

到这里，我们要关注的就是 sensor上报感光----背光等级 之间的关系曲线了。
sensor上报感光 就是 config_autoBrightnessLevels —LUX
背光等级 就是 config_screenBrightnessBacklight -----BL

0~ lux_threshold1 对应 bl_level1

光照强度和背光级别函数

Android Q自动背光曲线调节-CSDN博客

frameworks/base/services/core/java/com/android/server/display/DisplayPowerController.java

255级背光

backlight设备树分析_brightness-levels-CSDN博客

三、APP实现

自动背光服务的实现，光感自动调光

1、Qt 光感应用服务层

application/swc_light_sensor/LightSensorThread.cpp

#include "LightSensorThread.h"
#include "SwcLightSensorManager.h"#include <Peripherals/IoHwAb/IoHwAb.h>#include <string>
#include <errno.h>
#include <QDebug>LightSensorThread::LightSensorThread(SwcLightSensorManager* swcPtr,int timeoutMs, QString name)
: mSwcPtr(swcPtr),mTimeoutMs(timeoutMs), mThreadName(name)
{setObjectName(mThreadName);}void LightSensorThread::run()
{IoHwAb* ioHwAbPtr = IoHwAb::getInstance();
//  SwcFailureDetection* swcFailureDetectionPtr = SwcFailureDetection::getInstance();while(true) {//std::unique_lock<std::mutex> lck(listen_mutex);int ret = ioHwAbPtr->getLightSensorVal();if(ret == 0) {mSensorVal = ioHwAbPtr->readLightSensorVal();emit mSwcPtr->lightSensorSignal(mSensorVal);//swcFailureDetectionPtr->clearDtcMap(SwcFailureDetection::LEFT_DTC_MAP_BIT_LIGHT_SENSOR_FAILED);}else if(ret == -EIO) {ioHwAbPtr->initLightSensorModule();//swcFailureDetectionPtr->setDtcMap(SwcFailureDetection::LEFT_DTC_MAP_BIT_LIGHT_SENSOR_FAILED);QThread::msleep(1000);}else {//ioHwAbPtr->initLightSensorModule();qDebug() << "getLightSensorVal ret " << ret ;emit mSwcPtr->lightSensorSignal(-1);}QThread::msleep(mTimeoutMs);}
}

application/swc_light_sensor/SwcLightSensorManager.cpp

#include "SwcLightSensorManager.h"
#include "LightSensorThread.h"
//#include <application/swc_model/SwcModel.h>//extern GUI_Interface gui_interface;std::mutex SwcLightSensorManager::mutex;
/*static*/ SwcLightSensorManager* SwcLightSensorManager::mSwcLightSensorManagerPtr = nullptr;SwcLightSensorManager* SwcLightSensorManager::getInstance() {std::lock_guard<std::mutex> lock(mutex);if(mSwcLightSensorManagerPtr == nullptr){mSwcLightSensorManagerPtr = new SwcLightSensorManager();mSwcLightSensorManagerPtr->starUpStateMachine();}return mSwcLightSensorManagerPtr;
}SwcLightSensorManager::SwcLightSensorManager()
{//创建回调std::cout << "SwcLightSensorManager  " <<std::endl;mLightSensorThreadPtr = new LightSensorThread(this);mLightSensorThreadPtr->start();
}SwcLightSensorManager::~SwcLightSensorManager()
{}void SwcLightSensorManager::starUpStateMachine(void)
{}

2、自动背光服务

application/swc_backlight_manager/SwcBacklightManager.cpp

#include "SwcBacklightManager.h"
#include "SwcBacklightManagerStrategyFawJ100.h"
#include "SwcBacklightManagerStrategyShanQiHD10.h"
#include "BrightnessAdjustThread.h"
#include "StateBacklightOn.h"
#include "StateBacklightOff.h"//#include <application/swc_model/SwcModel.h>
#include <utils/Spline.h>
#include <iniparser.h>
#include <log.h>
#include <cmath>
#define DEBUG 0//extern GUI_Interface gui_interface;std::mutex SwcBacklightManager::mutex;
/*static*/ SwcBacklightManager* SwcBacklightManager::mSwcBacklightManagerPtr = nullptr;SwcBacklightManager* SwcBacklightManager::getInstance() {std::lock_guard<std::mutex> lock(mutex);if(mSwcBacklightManagerPtr == nullptr){//SwcModel* modelPtr = SwcModel::getInstance();//QString vendorName = modelPtr->getVendorName();QString vendorName = "FawJ100";if(vendorName == QString("FawJ100")){Spline::setBrightnessRange(10, 100);mSwcBacklightManagerPtr = new SwcBacklightManagerStrategyFawJ100();}else if(vendorName == QString("ShanQiHD10")){Spline::setBrightnessRange(70, 245);mSwcBacklightManagerPtr = new SwcBacklightManagerStrategyShanQiHD10();}else {mSwcBacklightManagerPtr = new SwcBacklightManagerStrategyShanQiHD10();}mSwcBacklightManagerPtr->initBacklightConfig();mSwcBacklightManagerPtr->starUpStateMachine();}return mSwcBacklightManagerPtr;
}SwcBacklightManager::SwcBacklightManager()
{//创建回调std::cout << "SwcBacklightManager  " <<std::endl;mBrightnessAdjustThreadPtr = new BrightnessAdjustThread();mBrightnessAdjustThreadPtr->start();
}SwcBacklightManager::~SwcBacklightManager()
{}void SwcBacklightManager::create_default_backlight_ini(const char *name)
{FILE *fp = fopen(name, "w+");if(fp != nullptr) {fprintf(fp,"[backlight]\n""auto       = 1\n""level      = 1\n""[lux_array]\n""maxlevel       = 6\n""lux_threshold1 = 6246\n""lux_threshold2 = 12457\n""lux_threshold3 = 20789\n""lux_threshold4 = 34826\n""lux_threshold5 = 59661\n""[backlight_array]\n""bl_level1      = 10\n""bl_level2      = 30\n""bl_level3      = 50\n""bl_level4      = 60\n""bl_level5      = 80\n""bl_level6      = 100\n");fclose(fp);}
}int SwcBacklightManager::prase_backlight_ini(dictionary *ini)
{int i;int sec_num;int ret;double threshold_temp;char property_name[256];sec_num = iniparser_getnsec(ini);for(i = 0; i < sec_num; i++){if(strcmp(iniparser_getsecname(ini, i), "backlight") == 0){break;}}if(i == sec_num){//elog("%s property not found in ini, use default setting", "backlight");goto notfound;}/*if(iniparser_getsecnkeys(ini, "backlight") != 3){//elog("%s miss some property", "backlight");goto notfound;}*/sprintf(property_name, "backlight:auto");if((ret = iniparser_getint(ini, property_name, -1)) == -1){//elog("%s auto value miss", "backlight");goto notfound;}if(ret == 1 || ret == 0) {mAutoBrightnessFlag = ret;}sprintf(property_name, "backlight:night_factor");if((mTargetNightFactor = iniparser_getdouble(ini, property_name, 1.0)) == 1.0) {elog("%s auto value miss", "night_factor");}sprintf(property_name, "backlight:level");if((ret = iniparser_getint(ini, property_name, -1)) == -1){//elog("%s level value miss", "backlight");goto notfound;}mBacklightLevel = ret;sprintf(property_name, "backlight:auto");if((ret = iniparser_getint(ini, property_name, 1)) == 1){elog("%s level value miss", "backlight");//goto notfound;}mAutoBrightnessFlag = ret;if(iniparser_getsecnkeys(ini, "lux_array") == 0 || iniparser_getsecnkeys(ini, "backlight_array") == 0){return 0;}sprintf(property_name, "lux_array:maxlevel");if((ret = iniparser_getint(ini, property_name, -1)) == -1){return 0;}mMaxLevel = ret;for(i = 1; i <= mMaxLevel; i++){sprintf(property_name, "backlight_array:bl_level%d", i);if((ret = iniparser_getint(ini, property_name, -1)) == -1){return 0;}mBacklightLevelArray[i-1] = ret;ilog("l_bl_level_array[%d] = %d, ret %d", i-1, mBacklightLevelArray[i-1], ret);}for(i = 1; i <= (mMaxLevel - 1); i++){sprintf(property_name, "lux_array:lux_threshold%d", i);if((threshold_temp = iniparser_getdouble(ini, property_name, 0)) == 0){return 0;}mLuxThresholdArray[i-1] = threshold_temp;ilog("l_lux_threshold[%d] = %f, threshold_temp %lf", i-1, mLuxThresholdArray[i-1], threshold_temp);}mAutoBrightnessSpline = createAutoBrightnessSpline(mLuxThresholdArray,  mMaxLevel - 1,  mBacklightLevelArray, mMaxLevel);if(mAutoBrightnessSpline == nullptr) {printf("backlight.ini parse error\n");}ilog(">>>>>>>>>>>>>>>>>>>>>l_adjust_ini 1");mAdjustIniCompleted = 1;return 0;notfound:return -1;
}void SwcBacklightManager::initBacklightConfig(void)
{//mBacklightIniFilePath = std::string("/home/root/ini/backlight.ini");const char* cBacklightIniFilePath = mBacklightIniFilePath.c_str();if(access(cBacklightIniFilePath, F_OK)){create_default_backlight_ini(cBacklightIniFilePath);std::cout << "create_default_backlight_ini 111" <<std::endl;}load_ini:mBacklightIni = iniparser_load(cBacklightIniFilePath);if(mBacklightIni == NULL){//elog("load %s failed", cBacklightIniFilePath);create_default_backlight_ini(cBacklightIniFilePath);std::cout<<"create_default_backlight_ini 333"<<std::endl;goto load_ini;}else {//elog("load %s success", cBacklightIniFilePath);}if(prase_backlight_ini(mBacklightIni)){//elog("prase_backlight_ini failed");create_default_backlight_ini(cBacklightIniFilePath);std::cout<<"create_default_backlight_ini 222"<<std::endl;goto load_ini;}else {//elog("prase_backlight_ini success");}}void SwcBacklightManager::addStateTransition(QState* sourceState, QState* targetState, QSignalTransition* sigTrans)
{sigTrans->setTargetState(targetState);sourceState->addTransition(sigTrans);
}void SwcBacklightManager::addStateBacklightOnTransition(void)
{}void SwcBacklightManager::addStateBacklightOffTransition(void)
{}void SwcBacklightManager::starUpStateMachine(void)
{//int argc = 0;std::cout << "StateManualCannotAdjustRearLine  starUpStateMachine" <<std::endl;// 创建状态机和根状态// 创建自定义状态和终止状态mStateBacklightOnPtr = new StateBacklightOn(nullptr, this);mStateBacklightOffPtr = new StateBacklightOff(nullptr, this);mStateMachine.addState(mStateBacklightOnPtr);mStateMachine.addState(mStateBacklightOffPtr);//有目标转换//无目标转换的信号处理在状态类中实现addStateBacklightOnTransition();addStateBacklightOffTransition();mStateMachine.setInitialState(mStateBacklightOnPtr);std::cout << "SwcBacklightManager   starUpStateMachine" <<std::endl;// 将状态机启动 mStateMachine.start();mRunning = 1;std::cout << "SwcBacklightManager   starUpStateMachine  mRunning = 1" <<std::endl;}SwcBacklightManager::BACKLIGHT_STATUS SwcBacklightManager::getBacklightStatus(void)
{return mBacklightStatus;
}int SwcBacklightManager::getCurrentBrightness(void)
{return mBrightnessAdjustThreadPtr->getCurrentBrightness();
}int SwcBacklightManager::getMaxBrightness(void)
{return mBrightnessAdjustThreadPtr->getMaxBrightness();
}void SwcBacklightManager::setLightSensorVal(double sensorVal)
{if(mAutoBrightnessFlag == 1 && sensorVal > 0) {if(mAutoBrightnessSpline != nullptr) {float calBrightness = mAutoBrightnessSpline->interpolate(sensorVal, mMaxLevel);float rounded_number = std::round(calBrightness  * Spline::PowerManager_BRIGHTNESS_ON) * mAutoFactor * mCurNightFactor + mAutoOffset;if(DEBUG == 1) {std::cout << "setLightSensorVal sensorVal: " << sensorVal << " calBrightness: " << rounded_number << " PowerManager_BRIGHTNESS_ON " << Spline::PowerManager_BRIGHTNESS_ON << std::endl;}mBrightnessAdjustThreadPtr->setAutoTargetBrightness((int)rounded_number);}else {mBrightnessAdjustThreadPtr->setAutoTargetBrightness(Spline::PowerManager_BRIGHTNESS_ON/2);}}else if(mAutoBrightnessFlag == 1 && sensorVal < 0){mBrightnessAdjustThreadPtr->setAutoTargetBrightness(Spline::PowerManager_BRIGHTNESS_ON/2);}else { }
}void SwcBacklightManager::setAutoBrightness(void)
{mAutoBrightnessFlag = 1;mBrightnessAdjustThreadPtr->setAutoBrightnessFlag(1);
}void SwcBacklightManager::setAutoBrightnessFactor(int factor)
{mAutoFactor = (float)factor / 100;}void SwcBacklightManager::setAutoBrightnessOffset(int offset)
{if(offset < 0 || offset > 100) {return ;}mAutoOffset =  offset - 50;
}void SwcBacklightManager::setManualBrightness(int percent)
{mAutoBrightnessFlag = 0;mBrightnessAdjustThreadPtr->setAutoBrightnessFlag(0);if(percent >=1 && percent <= 100) {float rounded_number = std::round((float)percent  * Spline::PowerManager_BRIGHTNESS_ON / 100 * mCurNightFactor);mBrightnessAdjustThreadPtr->setManualTargetBrightness((int)rounded_number);}else {}
}void SwcBacklightManager::setScreenOn(void)
{mBacklightStatus = SwcBacklightManager::BACKLIGHT_ON;mBrightnessAdjustThreadPtr->setBacklightStatus(BrightnessAdjustThread::BACKLIGHT_ON);elog("setScreenOn");
}void SwcBacklightManager::setScreenOff(void)
{mBacklightStatus = SwcBacklightManager::BACKLIGHT_OFF;mBrightnessAdjustThreadPtr->setBacklightStatus(BrightnessAdjustThread::BACKLIGHT_OFF);elog("setScreenOff");
}void SwcBacklightManager::setDayNightState(int state)
{/*GUI_Interface::DAY_NIGHT_STATE time =  static_cast<GUI_Interface::DAY_NIGHT_STATE>(state);if(time == GUI_Interface::NIGHTTIME){mCurNightFactor = mTargetNightFactor;}else {mCurNightFactor = 1.0;}*/}

3、光感数值和目标亮度映射服务

utils/Spline.cpp

#include "Spline.h"
//#include <system/log.h>/*static*/ int  Spline::PowerManager_BRIGHTNESS_ON = 100;
/*static*/ int  Spline::PowerManager_BRIGHTNESS_OFF = 10;float Spline::interpolate(float x, unsigned int x_length)
{return x;}
/*static*/ Spline* Spline::createMonotoneCubicSpline(float x [], unsigned int x_length, float y [], unsigned int y_length) {printf("createMonotoneCubicSpline x[0] = %f, x_length %u, y[0] = %f, y_length %u", x[0], x_length, y[0], y_length);return new MonotoneCubicSpline(x, x_length, y, y_length);
}static int constrain(int amount, int low, int high) {return amount < low ? low : (amount > high ? high : amount);}static int clampAbsoluteBrightness(int value) {return constrain(value, Spline::PowerManager_BRIGHTNESS_OFF, Spline::PowerManager_BRIGHTNESS_ON);
}
static float normalizeAbsoluteBrightness(int value) {return (float)clampAbsoluteBrightness(value) / Spline::PowerManager_BRIGHTNESS_ON;
}/*static*/ int Spline::setBrightnessRange(int minVal, int maxVal)
{if(minVal > maxVal) {return -1;}if(minVal < 0 || maxVal < 0 ) {return -2;}PowerManager_BRIGHTNESS_OFF = minVal;PowerManager_BRIGHTNESS_ON = maxVal;return 0;
}/*static*/ Spline* createAutoBrightnessSpline(float* lux,  unsigned int lux_length,  int* brightness, unsigned int brightness_length) {if (lux == nullptr || lux_length == 0 || brightness == nullptr || brightness_length == 0) {printf("Could not create auto-brightness spline.");return nullptr;}//try {int n = brightness_length;float* x = new float[n];float* y = new float[n];x[0] = 0;y[0] = normalizeAbsoluteBrightness(brightness[0]);printf("createMonotoneCubicSpline x[%d] = %7.1f,  y[%d] = %7.1f, brightness_length %u", 0, x[0], 0, y[0], brightness_length);for (int i = 1; i < n; i++) {x[i] = lux[i - 1];y[i] = normalizeAbsoluteBrightness(brightness[i]);printf("createMonotoneCubicSpline x[%d] = %7.1f,  y[%d] = %7.1f, brightness_length %u", i, x[i], i, y[i], brightness_length);}Spline *spline = Spline::createSpline(x, n, y, n);if (true) {//dlog("Auto-brightness spline: " + spline);for (float v = 1.0; v < lux[lux_length - 1] * 1.25f; v *= 1.25f) {printf("  %7.1f: %7.1f\n", v, spline->interpolate(v, brightness_length));}}return spline;/*} catch (IllegalArgumentException ex) {Slog.e(TAG, "Could not create auto-brightness spline.", ex);return null;}*/
}#if 1
#define LCD_HIGHEST_TEMP 125
#define LCD_LOWEST_TEMP -40
/*
static int clampAbsoluteTemparature(int value) {return constrain(value, LCD_LOWEST_TEMP, LCD_HIGHEST_TEMP);
}
static float normalizeAbsoluteTemparature(int value) {return (float)clampAbsoluteBrightness(value) / LCD_HIGHEST_TEMP;
}
*/
Spline* createLcdNtcSpline(float* resistor,  unsigned int resistor_length,  float* temparature, unsigned int temparature_length) {if (resistor == nullptr || resistor_length == 0 || temparature == nullptr || temparature_length == 0) {printf("Could not create auto-brightness spline.");return nullptr;}//try {int n = resistor_length;float* x = new float[n];float* y = new float[n];x[0] = resistor[0];//y[0] = normalizeAbsoluteTemparature(temparature[0]);y[0] = temparature[0];printf("createLcdNtcSpline x[%d] = %7.1f,  y[%d] = %7.1f, temparature_length %u", 0, x[0], 0, y[0], temparature_length);for (int i = 1; i < n; i++) {x[i] = resistor[i - 1];//y[i] = normalizeAbsoluteTemparature(temparature[i]);y[i] = temparature[i];printf("createLcdNtcSpline x[%d] = %7.1f,  y[%d] = %7.1f, temparature_length %u", i, x[i], i, y[i], temparature_length);}Spline *spline = Spline::createSpline(x, n, y, n);if (true) {//dlog("Auto-brightness spline: " + spline);for (float v = 1.0; v < resistor[resistor_length - 1] * 1.25f; v *= 1.25f) {printf("  %7.1f: %7.1f", v, spline->interpolate(v, temparature_length));}}return spline;}
#endif

4、背光亮度缓慢调节服务

application/swc_backlight_manager/BrightnessAdjustThread.cpp

#include "BrightnessAdjustThread.h"
#include <string>#include "../Peripherals/IoHwAb/IoHwAb.h"
#include <iostream>
#include <sstream>#define DEBUG 0BrightnessAdjustThread::BrightnessAdjustThread(int timeoutMs, QString name)
: mTimeoutMs(timeoutMs), mThreadName(name)
{setObjectName(mThreadName);IoHwAb* ioHwAbPtr = IoHwAb::getInstance();int ret = ioHwAbPtr->getMaxBrightness();if(ret == 0) {mMaxBrightness = (int)ioHwAbPtr->readMaxBrightness();}else {}ret = ioHwAbPtr->getBrightness();if(ret == 0) {mAutoTargetBrightness = (int)ioHwAbPtr->readBrightness();mCurrentBrightness = mAutoTargetBrightness;}else {}}void BrightnessAdjustThread::setAutoBrightnessFlag(int flag)
{if(flag < 0 || flag > 1){}else {mAutoBrightnessFlag  =  flag;}
}int BrightnessAdjustThread::getAutoBrightnessFlag(void)
{return mAutoBrightnessFlag;
}int BrightnessAdjustThread::setAutoTargetBrightness(int brightness)
{if(brightness < mMinBrightness) {brightness = mMinBrightness;}else if(brightness > mMaxBrightness) {brightness = mMaxBrightness;}mAutoTargetBrightness = brightness;if(DEBUG == 1) {std::cout << "setAutoTargetBrightness: " << mAutoTargetBrightness << std::endl;}IoHwAb* ioHwAbPtr = IoHwAb::getInstance();int ret = ioHwAbPtr->getBrightness();if(ret == 0) {mCurrentBrightness = (int)ioHwAbPtr->readBrightness();}else {ioHwAbPtr->initBacklightModule();}return 0;}int BrightnessAdjustThread::setManualTargetBrightness(int brightness)
{if(brightness < mMinBrightness) {brightness = mMinBrightness;}else if(brightness > mMaxBrightness) {brightness = mMaxBrightness;}mManualTargetBrightness = brightness;if(DEBUG == 1) {std::cout << "setManualTargetBrightness: " << mManualTargetBrightness << std::endl;}IoHwAb* ioHwAbPtr = IoHwAb::getInstance();int ret = ioHwAbPtr->getBrightness();if(ret == 0) {mCurrentBrightness = (int)ioHwAbPtr->readBrightness();}else {ioHwAbPtr->initBacklightModule();}return 0;}int BrightnessAdjustThread::setCurrentBrightness(int brightness)
{IoHwAb* ioHwAbPtr = IoHwAb::getInstance();int ret = ioHwAbPtr->setBrightness((double)brightness);if(ret == 0) {mCurrentBrightness = brightness;}else {ioHwAbPtr->initBacklightModule();}return ret;
}int BrightnessAdjustThread::getCurrentBrightness(void)
{return mCurrentBrightness;
}int BrightnessAdjustThread::getMaxBrightness(void)
{return mMaxBrightness;
}void BrightnessAdjustThread::setBacklightStatus(BACKLIGHT_STATUS status)
{mBacklightStatus = status;
}int BrightnessAdjustThread::setBacklightOffBrightness(void)
{setCurrentBrightness(0);return 0;}void BrightnessAdjustThread::run()
{//IoHwAb* ioHwAbPtr = IoHwAb::getInstance();while(true) {if(mBacklightStatus == BACKLIGHT_OFF) {setBacklightOffBrightness();}else {//std::unique_lock<std::mutex> lck(listen_mutex);/** 自动调光功能开启*/if(getAutoBrightnessFlag() == 1) {if(mAutoTargetBrightness > mCurrentBrightness) {mCurrentBrightness += 1;setCurrentBrightness(mCurrentBrightness);}else if(mAutoTargetBrightness < mCurrentBrightness) {mCurrentBrightness -= 1;setCurrentBrightness(mCurrentBrightness);}else {}                                }else {/** 手动调光模式*/if(mManualTargetBrightness != mCurrentBrightness) {setCurrentBrightness(mManualTargetBrightness);}else {}}}QThread::msleep(mTimeoutMs);}
}

5、光感 背光模块 硬件抽象层

Peripherals/IoHwAb/IoHwAb.cpp

//#include <boards/imx6/adc/AdcModule.h>
#include <boards/imx6/backlight/BacklightModule.h>
#include <boards/imx6/sensor/LightSensorModule.h>
//#include <boards/imx6/gpio/GpioModule.h>
#include <Peripherals/IoHwAb/IoHwAb.h>#include <QThread>
#include <QTimer>
#include <unistd.h>
#include <iostream>
#include <sstream>
#include <fcntl.h>/*static*/ std::mutex IoHwAb::IoHwAb_mutex;
/*static*/ IoHwAb* IoHwAb::mInstance = NULL;IoHwAb* IoHwAb::getInstance(void)
{std::lock_guard<std::mutex> lock(IoHwAb_mutex);if(mInstance == NULL) {mInstance = new IoHwAb();//mInstance->initAdcModule();mInstance->initBacklightModule();mInstance->initLightSensorModule();//mInstance->initGpioModule();//mInstance->start();}return mInstance;
}IoHwAb::IoHwAb()
{
#if 0mLCD_NTC_ADC_MPUPtr = new LcdNtcAdcModule();mLCD_NTC_ADC_MPUPtr->rawValFilePath = std::string("/sys/bus/iio/devices/iio:device0/in_voltage2_raw");mLCD_NTC_ADC_MPUPtr->rawFd = -1;mLCD_NTC_ADC_MPUPtr->voltageScaleFilePath = std::string("/sys/bus/iio/devices/iio:device0/in_voltage_scale");mLCD_NTC_ADC_MPUPtr->scaleFd = -1;mLCD_NTC_ADC_MPUPtr->vdd = 1800;//mvmLCD_NTC_ADC_MPUPtr->pullType = PULL_UP;mLCD_NTC_ADC_MPUPtr->pullResistor = 10;//k ohmmLCD_NTC_ADC_MPUPtr->calTargetType = AdcModule::ADC_CAL_TARGET_SAMPLE_RESISTOR;addAdcModule(mLCD_NTC_ADC_MPUPtr);mVCC_24V_ADC_MPUPtr = new AdcModule();mVCC_24V_ADC_MPUPtr->rawValFilePath = std::string("/sys/bus/iio/devices/iio:device0/in_voltage0_raw");mVCC_24V_ADC_MPUPtr->rawFd = -1;mVCC_24V_ADC_MPUPtr->voltageScaleFilePath = std::string("/sys/bus/iio/devices/iio:device0/in_voltage_scale");mVCC_24V_ADC_MPUPtr->scaleFd = -1;mVCC_24V_ADC_MPUPtr->pullType = PULL_UP;mVCC_24V_ADC_MPUPtr->pullResistor = 100;//k ohmmVCC_24V_ADC_MPUPtr->sampleResistor = 3.3;//k ohmmVCC_24V_ADC_MPUPtr->calTargetType = AdcModule::ADC_CAL_TARGET_VDD;mVCC_24V_ADC_MPUPtr->calibFilePath = "/home/root/ini/adc.ini";mVCC_24V_ADC_MPUPtr->calibSessionName = "VCC_24V_ADC_MPU";//mVCC_24V_ADC_MPUPtr->k_calib = (8000.0/(1621 - 1037));//mv//mVCC_24V_ADC_MPUPtr->b_calib = (16000.0 - 1037*mVCC_24V_ADC_MPUPtr->k_calib);//mvaddAdcModule(mVCC_24V_ADC_MPUPtr);
#endif  mBacklightModulePtr = new BacklightModule();mLightSensorModulePtr = new LightSensorModule();#if 0int gpioValidLevel = 0;mAccGpioModulePtr = new GpioModule(399, GpioModule::INPUT, gpioValidLevel);addGpioModule(mAccGpioModulePtr);gpioValidLevel = 0;mKeyWakeUpGpioModulePtr = new GpioModule(397, GpioModule::INPUT, gpioValidLevel);addGpioModule(mKeyWakeUpGpioModulePtr);//FAULT_LCD_MPU-gpio, 低有效， 表示发生故障gpioValidLevel = 1;mLcdFaultGpioModulePtr = new GpioModule(424, GpioModule::INPUT, gpioValidLevel);addGpioModule(mAccGpioModulePtr);gpioValidLevel = 1;mCameraPreheatGpioModulePtr = new GpioModule(373, GpioModule::OUTPUT, gpioValidLevel);addGpioModule(mCameraPreheatGpioModulePtr);/** 低电平发生故障*/gpioValidLevel = 0;mBacklightFault1GpioModulePtr = new GpioModule(460, GpioModule::INPUT, gpioValidLevel);addGpioModule(mBacklightFault1GpioModulePtr);gpioValidLevel = 0;mBacklightFault2GpioModulePtr = new GpioModule(461, GpioModule::INPUT, gpioValidLevel);addGpioModule(mBacklightFault2GpioModulePtr);#endif  
}
IoHwAb::~IoHwAb()
{}int IoHwAb::addAdcModule(AdcModule* adcModulePtr)
{if(adcModulePtr != nullptr) {mAdcModuleVector.push_back(adcModulePtr);}return 0;}   int IoHwAb::addGpioModule(GpioModule* gpioModulePtr)
{if(gpioModulePtr != nullptr) {mGpioModuleVector.push_back(gpioModulePtr);}return 0;
}int IoHwAb::initAdcModule(void)
{return 0;
}int IoHwAb::initBacklightModule(void)
{return mBacklightModulePtr->initModule();}int IoHwAb::initLightSensorModule(void)
{return mLightSensorModulePtr->initModule();
}int IoHwAb::initGpioModule(void)
{return 0;
}void IoHwAb::run()
{
}double IoHwAb::getLcdNtcPhysicalVal(void)
{return 0;}double IoHwAb::getMpuVoltage(void)
{return 0;
}   int IoHwAb::getBrightness(void)
{return mBacklightModulePtr->getBrightness();
}int IoHwAb::setBrightness(double brightness)
{return mBacklightModulePtr->setBrightness(brightness);
}int IoHwAb::setBrightnessOff(void)
{return mBacklightModulePtr->setBrightness(0);
}double IoHwAb::readBrightness(void)
{return mBacklightModulePtr->readBrightness();
}int IoHwAb::getMaxBrightness(void)
{return mBacklightModulePtr->getMaxBrightness(); 
}double IoHwAb::readMaxBrightness(void)
{return mBacklightModulePtr->readMaxBrightness();    
}int IoHwAb::getLightSensorVal(void)
{return mLightSensorModulePtr->getSensorVal();
}double IoHwAb::readLightSensorVal(void)
{return mLightSensorModulePtr->readSensorVal();
}int IoHwAb::initAccGpioModule(void)
{return 0;
}int IoHwAb::getAccGpioVal(void)
{return 0;
}int IoHwAb::readAccGpioVal(void)
{return 0;
}int IoHwAb::getAccGpioValidLevel(void)
{return 0;
}int IoHwAb::initKeyWakeUpGpioModule(void)
{return 0;
}int IoHwAb::getKeyWakeUpGpioVal(void)
{return 0;
}int IoHwAb::readKeyWakeUpGpioVal(void)
{return 0;
}int IoHwAb::getKeyWakeUpGpioValidLevel(void)
{return 0;
}int IoHwAb::initLcdFaultGpioModule(void)
{return 0;
}int IoHwAb::getLcdFaultGpioVal(void)
{return 0;
}int IoHwAb::readLcdFaultGpioVal(void)
{return 0;
}int IoHwAb::getLcdFaultGpioValidLevel(void)
{return 0;
}int IoHwAb::initBacklightFault1GpioModule(void)
{return 0;
}int IoHwAb::getBacklightFault1GpioVal(void)
{return 0;
}int IoHwAb::readBacklightFault1GpioVal(void)
{return 0;
}int IoHwAb::getBacklightFault1GpioValidLevel(void)
{return 0;
}int IoHwAb::initBacklightFault2GpioModule(void)
{return 0;
}int IoHwAb::getBacklightFault2GpioVal(void)
{return 0;
}int IoHwAb::readBacklightFault2GpioVal(void)
{return 0;
}int IoHwAb::getBacklightFault2GpioValidLevel(void)
{return 0;
}int IoHwAb::setCameraPreheatGpioValid(void)
{//int val = mCameraPreheatGpioModulePtr->getGpioValidLevel();return 0;
}int IoHwAb::setCameraPreheatGpioInValid(void)
{//int val = !mCameraPreheatGpioModulePtr->getGpioValidLevel();return 0;
}

6、背光平台驱动层，对接sys系统文件

boards/imx8qm/backlight/BacklightModule.cpp

#include <QThread>
#include <QTimer>
#include <unistd.h>
#include <iostream>
#include <sstream>
#include <fcntl.h>
#include "BacklightModule.h"
#include "../../../utils/Spline.h"#define DEBUG 0BacklightModule::BacklightModule()
{brightnessFilePath  = std::string("/sys/devices/soc0/blacklight/light_level");maxBrightnessFilePath  = std::string("/sys/devices/soc0/blacklight/max_light_level");
}BacklightModule::~BacklightModule()
{}int BacklightModule::initModule(void)
{        const char* cBrightnessFilePath = brightnessFilePath.c_str();int fd = open(cBrightnessFilePath, O_RDWR); // 读写方式打开文件// 检查文件是否成功打开if (fd == -1) {std::cerr << "Failed to open file: " << cBrightnessFilePath << std::endl;return fd;}else {brightnessFd = fd;//getBrightness();}const char* cMaxBrightnessFilePath = maxBrightnessFilePath.c_str();fd = open(cMaxBrightnessFilePath, O_RDONLY); // 只读方式打开文件// 检查文件是否成功打开if (fd == -1) {std::cerr << "Failed to open file: " << cMaxBrightnessFilePath << std::endl;return fd;}else {maxBrightnessFd = fd;//getMaxBrightness();}return 0;
}int BacklightModule::getBrightness(void)
{   const int bufferSize = 20; // 假设字符串最大长度为 20 字节char buffer[bufferSize] = { 0 }; // 缓冲区用于存储读取的字节序列lseek(brightnessFd, SEEK_SET, 0);ssize_t bytesRead = read(brightnessFd, buffer, bufferSize - 1); // 读取数据if (bytesRead > 0) {// 在读取到的字节序列后面添加字符串终止符buffer[bytesRead] = '\0';// 将读取到的字节序列转换为浮点数double floatValue;std::istringstream iss(buffer);if (iss >> floatValue) {brightnessVal = floatValue;if(DEBUG == 1) {std::cout << "getBrightness Read float value: " << floatValue << std::endl;}return 0;} else {std::cerr << "getBrightness Failed to convert to float" << std::endl;return -1;}} else if (bytesRead == -1) {std::cerr << "getBrightness Failed to read data from file descriptor" << std::endl;return bytesRead;} else {std::cerr << "getBrightness Incomplete data read from file descriptor" << std::endl;return bytesRead;}//close(fd); // 关闭文件描述符}int BacklightModule::setBrightness(double brightness)
{int val = (int)brightness;int ret = 0;lseek(brightnessFd, SEEK_SET, 0);char buf[128] = {0};sprintf(buf, "%d", val);#if 0if((ret = write(brightnessFd, &val, sizeof(int))) < 0) {std::cerr << "setBrightness Failed " << std::endl;return ret;}
#elseif((ret = write(brightnessFd, buf, strlen(buf))) < 0) {std::cerr << "setBrightness Failed " << std::endl;return ret;}
#endifreturn 0;
}double BacklightModule::readBrightness(void)
{return brightnessVal;
}int BacklightModule::getMaxBrightness(void)
{   const int bufferSize = 20; // 假设字符串最大长度为 20 字节char buffer[bufferSize]; // 缓冲区用于存储读取的字节序列lseek(maxBrightnessFd, SEEK_SET, 0);ssize_t bytesRead = read(maxBrightnessFd, buffer, bufferSize - 1); // 读取数据if (bytesRead > 0) {// 在读取到的字节序列后面添加字符串终止符buffer[bytesRead] = '\0';// 将读取到的字节序列转换为浮点数double floatValue;std::istringstream iss(buffer);if (iss >> floatValue) {maxBrightness = floatValue;std::cout << "getMaxBrightness Read float value: " << floatValue << std::endl;return 0;} else {std::cerr << "getMaxBrightness Failed to convert to float" << std::endl;return -1;}} else if (bytesRead == -1) {std::cerr << "getMaxBrightness Failed to read data from file descriptor" << std::endl;return bytesRead;} else {std::cerr << "getMaxBrightness Incomplete data read from file descriptor" << std::endl;return bytesRead;}//close(fd); // 关闭文件描述符}double BacklightModule::readMaxBrightness(void)
{return maxBrightness;
}

7、光感平台驱动层， 具体读取光感数值的实现

boards/imx8qm/sensor/LightSensorModule.cpp

#include <QThread>
#include <QTimer>
#include <unistd.h>
#include <iostream>
#include <sstream>
#include <fcntl.h>
#include <errno.h>
#include "LightSensorModule.h"#define DEBUG 0
LightSensorModule::LightSensorModule()
{sensorFilePath  = std::string("/sys/bus/iio/devices/iio:device0/in_illuminance_raw");}LightSensorModule::~LightSensorModule()
{}int LightSensorModule::initModule(void)
{deInitModule();const char* cBrightnessFilePath = sensorFilePath.c_str();int fd = open(cBrightnessFilePath, O_RDONLY); // 读写方式打开文件// 检查文件是否成功打开if (fd == -1) {std::cerr << "Failed to open file: " << cBrightnessFilePath << std::endl;return fd;}else {sensorFd = fd;}return 0;
}int LightSensorModule::deInitModule(void)
{close(sensorFd);sensorFd = -1;return 0;
}#if 0
int LightSensorModule::getSensorVal(void)
{   const int bufferSize = 128; // 假设字符串最大长度为 20 字节char buffer[bufferSize] = { 0 }; // 缓冲区用于存储读取的字节序列lseek(sensorFd, SEEK_SET, 0);ssize_t bytesRead = read(sensorFd, buffer, bufferSize - 1); // 读取数据if (bytesRead > 0) {// 在读取到的字节序列后面添加字符串终止符buffer[bytesRead] = '\0';// 将读取到的字节序列转换为浮点数double floatValue;std::istringstream iss(buffer);if (iss >> floatValue) {sensorVal = floatValue;if(DEBUG == 1) {std::cout << "getSensorVal Read float value: " << floatValue << std::endl;}continuousReadErrorTimes = 0;return 0;} else {std::cerr << "getSensorVal Failed to convert to float" << std::endl;return -1;}} else if (bytesRead == -1) {std::cerr << "getSensorVal Failed to read data from file descriptor" << std::endl;continuousReadErrorTimes++;/** 连续超过5次读取失败，认为sensor 异常*/if(continuousReadErrorTimes <= 5) {//std::cerr << "continuousReadErrorTimes " << continuousReadErrorTimes << std::endl;return 0;}else {return bytesRead;}} else {std::cerr << "getSensorVal Incomplete data read from file descriptor" << std::endl;return bytesRead;}//close(fd); // 关闭文件描述符}#endifint LightSensorModule::getSensorVal(void){   fd_set readfds;struct timeval timeout;// 设置超时时间（0秒0微秒表示立即返回，不阻塞）timeout.tv_sec = 0;timeout.tv_usec = 0;if(sensorFd < 0) {return -EIO;}// 清空文件描述符集合FD_ZERO(&readfds);// 将套接字添加到文件描述符集合FD_SET(sensorFd, &readfds);// 使用 select 监视文件描述符int ready = select(sensorFd + 1, &readfds, NULL, NULL, NULL);if (ready == -1) {perror("select");//exit(EXIT_FAILURE);return ready;} else if (ready == 0) {printf("套接字没有准备好读取数据\n");return 0;} else {if (FD_ISSET(sensorFd, &readfds)) {const int bufferSize = 128; // 假设字符串最大长度为 20 字节char buffer[bufferSize] = { 0 }; // 缓冲区用于存储读取的字节序列lseek(sensorFd, SEEK_SET, 0);ssize_t bytesRead = read(sensorFd, buffer, bufferSize - 1); // 读取数据if (bytesRead > 0) {// 在读取到的字节序列后面添加字符串终止符buffer[bytesRead] = '\0';// 将读取到的字节序列转换为浮点数double floatValue;std::istringstream iss(buffer);if (iss >> floatValue) {sensorVal = floatValue;if(DEBUG == 1) {std::cout << "getSensorVal Read float value: " << floatValue << std::endl;}continuousReadErrorTimes = 0;return 0;} else {std::cerr << "getSensorVal Failed to convert to float" << std::endl;return -1;}} else if (bytesRead == -1) {std::cerr << "getSensorVal Failed to read data from file descriptor" << std::endl;continuousReadErrorTimes++;/** 连续超过5次读取失败，认为sensor 异常*/if(continuousReadErrorTimes <= 5) {//std::cerr << "continuousReadErrorTimes " << continuousReadErrorTimes << std::endl;return 0;}else {return bytesRead;}} else {std::cerr << "getSensorVal Incomplete data read from file descriptor" << std::endl;return bytesRead;}}}//close(fd); // 关闭文件描述符return 0;}double LightSensorModule::readSensorVal(void)
{return sensorVal;
}

8、main.cpp

#include <QGuiApplication>
#include <QQmlApplicationEngine>
#include <QQmlContext>
#include "QuickTool/QuickTool.h"
#include "Trans/Trans.h"
#include <QDir>
#include "Frameless/TaoFrameLessView.h"
#include "gui_interface.h"
#include "Logger/Logger.h"
#include "deviceaddmodel.h"
#include "config.h"#include <app_backlight/swc_backlight_manager/SwcBacklightManager.h>
#include <app_backlight/swc_light_sensor/SwcLightSensorManager.h>GUI_Interface gui_interface;DeviceAddModel model;int main(int argc, char *argv[])
{QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling);QApplication app(argc, argv);Config mConfig;gui_interface.setAudioVolume(theConfig.volume);gui_interface.setBrightness(theConfig.brightness);//add backlightSwcBacklightManager::getInstance();SwcLightSensorManager::getInstance();QObject::connect(SwcLightSensorManager::getInstance(), &SwcLightSensorManager::lightSensorSignal, SwcBacklightManager::getInstance(), &SwcBacklightManager::setLightSensorVal);
//add endreturn app.exec();
}