单片机/MCU论坛
直播中

辛书伟

12年用户 110经验值
擅长:嵌入式技术
私信 关注
[文章]

【RA4M2设计挑战赛】模拟IIC isl29035驱动

参照上次文档添加模拟iic
https://bbs.elecfans.com/jishu_2336359_1_1.html
编写光照模块 isl29035 模块驱动
  1. #define DBG_TAG "sensor.isl29035"
  2. #define DBG_LVL DBG_INFO
  3. #include

  5. #include
  6. #include

  8. #include
  9. #include "hal_data.h"
  10. #include "isl29035.h"

  12. /*
  13. * Global Variables
  14. */

  16. uint8_t set_regs_data[2];
  17. struct isl29035_dev isl_dev;

  19. static char *i2c_bus_name = NULL;
  20. static struct rt_i2c_bus_device *i2c_bus = NULL;


  23. /** Performs a write operation on an I2C Master device.
  24. * @param[in] p_src     Pointer to the location to get write data from.
  25. * @param[in] bytes     Number of bytes to write.
  26. */
  27. fsp_err_t hal_i2c_write(uint8_t *const p_src,
  28.                         uint32_t const   bytes)
  29. {
  30.     struct rt_i2c_msg msgs[1];

  32.     msgs[0].addr = (rt_uint16_t)ISL29035_I2C_ADDR;
  33.     msgs[0].buf = p_src;
  34.     msgs[0].len = bytes;
  35.     msgs[0].flags = RT_I2C_WR ;

  37.     if (rt_i2c_transfer(i2c_bus, msgs, 1) == 1)
  38.     {
  39.         return FSP_SUCCESS;
  40.     }
  41.     else
  42.     {
  43.         LOG_E("i2c_write ERROR_I2C");
  44.         return -1;
  45.     }
  46. }

  48. /** Performs a read operation on an I2C Master device.
  49. * @param[in] p_dest    Pointer to the location to store read data.
  50. * @param[in] bytes     Number of bytes to read.
  51. */
  52. fsp_err_t hal_i2c_read(uint8_t *const p_dest,
  53.                        uint32_t const  bytes)
  54. {
  55.     struct rt_i2c_msg msgs[1];
  56.     msgs[0].addr = (rt_uint16_t)ISL29035_I2C_ADDR;
  57.     msgs[0].buf = p_dest;
  58.     msgs[0].len = bytes;
  59.     msgs[0].flags = RT_I2C_RD;

  61.     if (rt_i2c_transfer(i2c_bus, msgs, 1) == 1)
  62.     {
  63.         return FSP_SUCCESS;
  64.     }
  65.     else
  66.     {
  67.         LOG_E("i2c_read ERROR_I2C");
  68.         return -1;
  69.     }
  70. }

  72. fsp_err_t hal_i2c_open(char *bus_name)
  73. {
  74.     i2c_bus_name = bus_name;

  76.     i2c_bus = (struct rt_i2c_bus_device *)rt_device_find(i2c_bus_name);
  77.     if (i2c_bus == RT_NULL)
  78.     {
  79.         LOG_E("Device not found!");
  80.         return FSP_ERR_ASSERTION;
  81.     }
  82.     return FSP_SUCCESS;
  83. }

  85. fsp_err_t hal_i2c_close(void)
  86. {

  88.     return FSP_SUCCESS;
  89. }


  92. //ISL29035
  93. fsp_err_t isl29035_get_regs(uint8_t reg_addr,
  94.                             uint8_t *data,
  95.                             uint16_t len,
  96.                             const struct isl29035_dev *dev)
  97. {
  98.     fsp_err_t err         = FSP_SUCCESS;

  100.     /* Get register address to sensor */
  101.     err = hal_i2c_write(®_addr, 1);
  102.     /* handle error */
  103.     if (FSP_SUCCESS != err)
  104.     {
  105.         LOG_E("** hal_i2c_write API failed **
  106. ");
  107.     }
  108.     else
  109.     {
  110.         /* Read only when I2C write and its callback event is successful */
  111.         err = hal_i2c_read(data, len);
  112.         /* handle error */
  113.         if (FSP_SUCCESS != err)
  114.         {
  115.             LOG_E("** hal_i2c_read API failed **
  116. ");
  117.             //  Do nothing, the error is returned in the end
  118.         }
  119.     }
  120.     return err;
  121. }

  123. /*!
  124. * [url=home.php?mod=space&uid=2666770]@Brief[/url] This API writes the given data to the register address
  125. * of sensor.
  126. */
  127. fsp_err_t isl29035_set_regs(uint8_t reg_addr,
  128.                             uint8_t *data,
  129.                             uint16_t len,
  130.                             const struct isl29035_dev *dev)
  131. {
  132.     fsp_err_t err         = FSP_SUCCESS;

  134.     set_regs_data[0] = reg_addr;
  135.     set_regs_data[1] = *data;

  137.     err = hal_i2c_write(set_regs_data, len);
  138.     return err;
  139. }

  141. fsp_err_t isl29035_set_mode(struct isl29035_dev *dev)
  142. {
  143.     fsp_err_t err         = FSP_SUCCESS;
  144.     uint8_t val;

  146.     err = isl29035_get_regs(ISL29035_COMMAND_I_REG, &val, 1, dev);
  147.     if (FSP_SUCCESS == err)
  148.     {
  149.         val = (uint8_t)((val & ISL29035_OPMODE_MASK) | dev->adc_mode);

  151.         err = isl29035_set_regs(ISL29035_COMMAND_I_REG, &val, 2, dev);
  152.     }
  153.     return err;
  154. }

  156. fsp_err_t isl29035_set_range(struct isl29035_dev *dev)
  157. {
  158.     fsp_err_t err         = FSP_SUCCESS;
  159.     uint8_t val;

  161.     err = isl29035_get_regs(ISL29035_COMMAND_II_REG, &val, 1, dev);
  162.     if (FSP_SUCCESS == err)
  163.     {
  164.         val = (uint8_t)((val & ISL29035_LUX_RANGE_MASK) | dev->adc_range);

  166.         err = isl29035_set_regs(ISL29035_COMMAND_II_REG, &val, 2, dev);
  167.     }
  168.     return err;
  169. }

  171. fsp_err_t isl29035_set_res(struct isl29035_dev *dev)
  172. {
  173.     fsp_err_t err         = FSP_SUCCESS;
  174.     uint8_t val;

  176.     err = isl29035_get_regs(ISL29035_COMMAND_II_REG, &val, 1, dev);
  177.     if (FSP_SUCCESS == err)
  178.     {
  179.         val = (uint8_t)((val & ISL29035_ADC_RES_MASK) | dev->adc_res);

  181.         err = isl29035_set_regs(ISL29035_COMMAND_II_REG, &val, 2, dev);
  182.     }
  183.     return err;
  184. }

  186. fsp_err_t isl29035_init(struct isl29035_dev *dev, char *bus_name)
  187. {
  188.     uint8_t device_isl29035_id = 0x00;
  189.     fsp_err_t err     = FSP_SUCCESS;
  190.     uint8_t val;

  192.     /* opening IIC master module */
  193.     err = hal_i2c_open(bus_name);
  194.     /* handle error */
  195.     if (FSP_SUCCESS != err)
  196.     {
  197.         LOG_E("** hal_i2c_open API failed **
  198. ");
  199.         return err;
  200.     }

  202.     /* Get device ID as a start of communication */
  203.     err = isl29035_get_regs(ISL29035_REG_DEVICE_ID, &device_isl29035_id, 1, dev);

  205.     if ((FSP_SUCCESS == err) && (ISL29035_CHIP_ID == (device_isl29035_id & ISL29035_DEVICE_ID_MASK)))
  206.     {
  207.         val = (uint8_t)~ISL29035_BOUT_MASK;
  208.         err = isl29035_set_regs(ISL29035_REG_DEVICE_ID, &val, 2, dev);

  210.         if (FSP_SUCCESS != err)
  211.         {
  212.             LOG_E("** isl29035_set_regs API failed **
  213. ");
  214.         }
  215.     }
  216.     else
  217.     {
  218.         /* Failed to get Device ID */
  219.         LOG_E("Error in reading Device ID **
  220. ");
  221.     }
  222.     return err;
  223. }

  225. fsp_err_t isl29035_configure(struct isl29035_dev *dev)
  226. {
  227.     fsp_err_t err         = FSP_SUCCESS;
  228.     uint8_t val;

  230.     /* set command registers to set default attributes */
  231.     val = 0;
  232.     err = isl29035_set_regs(ISL29035_COMMAND_I_REG, &val, 2, dev);

  234.     R_BSP_SoftwareDelay(10, BSP_DELAY_UNITS_MILLISECONDS);
  235.     if (err != FSP_SUCCESS)
  236.         return err;

  238.     err = isl29035_set_regs(ISL29035_COMMAND_II_REG, &val, 2, dev);
  239.     R_BSP_SoftwareDelay(10, BSP_DELAY_UNITS_MILLISECONDS);
  240.     if (err != FSP_SUCCESS)
  241.         return err;

  243.     /* Set operation mode */
  244.     dev->adc_mode = ISL29035_ACTIVE_OPMODE_BITS;
  245.     err = isl29035_set_mode(dev);
  246.     R_BSP_SoftwareDelay(10, BSP_DELAY_UNITS_MILLISECONDS);
  247.     if (err != FSP_SUCCESS)
  248.         return err;

  250.     /* Set the lux range */
  251.     dev->adc_range = ISL29035_LUX_RANGE_BITS;
  252.     err = isl29035_set_range(dev);
  253.     R_BSP_SoftwareDelay(10, BSP_DELAY_UNITS_MILLISECONDS);
  254.     if (err != FSP_SUCCESS)
  255.         return err;

  257.     /* Set ADC resolution */
  258.     dev->adc_res = ISL29035_ADC_RES_BITS;
  259.     err = isl29035_set_res(dev);
  260.     R_BSP_SoftwareDelay(10, BSP_DELAY_UNITS_MILLISECONDS);
  261.     if (err != FSP_SUCCESS)
  262.         return err;

  264.     return err;
  265. }

  267. static float compute_scaling(struct isl29035_dev *dev)
  268. {
  269.     fsp_err_t err         = FSP_SUCCESS;
  270.     uint8_t val, reg_val;
  271.     float scale;
  272.     uint8_t adc_res = 0, lux;
  273.     uint16_t lux_range = 0;

  275.     /*
  276.      * Equation is lux = (Range/2 ^ n) * raw_data
  277.      */

  279.     err = isl29035_get_regs(ISL29035_COMMAND_II_REG, ®_val, 1, dev);
  280.     if (err != FSP_SUCCESS)
  281.         return err;

  283.     //get the ADC range value
  284.     val = (uint8_t)((reg_val & ISL29035_ADC_RES_MASK) >> 2);
  285.     switch (val)
  286.     {
  287.     case 0:
  288.         adc_res = 16;
  289.         break;
  290.     case 1:
  291.         adc_res = 12;
  292.         break;
  293.     case 2:
  294.         adc_res = 8;
  295.         break;
  296.     case 3:
  297.         adc_res = 4;
  298.         break;
  299.     default:
  300.         break;
  301.     }

  303.     //get the ADC resolution value
  304.     lux = (uint8_t)(reg_val & ISL29035_LUX_RANGE_MASK);
  305.     switch (lux)
  306.     {
  307.     case ISL29035_LUX_RANGE_1000:
  308.         lux_range = 1000;
  309.         break;
  310.     case ISL29035_LUX_RANGE_4000:
  311.         lux_range = 4000;
  312.         break;
  313.     case ISL29035_LUX_RANGE_16000:
  314.         lux_range = 16000;
  315.         break;
  316.     case ISL29035_LUX_RANGE_64000:
  317.         lux_range = 64000;
  318.         break;
  319.     default:
  320.         break;
  321.     }

  323.     scale = (float)(lux_range / (pow(2, adc_res)));
  324.     return scale;
  325. }

  327. fsp_err_t isl29035_read_als_data(struct isl29035_dev *dev, double *als_val)
  328. {
  329.     fsp_err_t err         = FSP_SUCCESS;
  330.     uint8_t als_data[2];
  331.     uint16_t als_raw;
  332.     float scale = 0.0;

  334.     err = isl29035_get_regs(ISL29035_DATA_LSB_REG, &als_data[0], 2, dev);
  335.     if (err != FSP_SUCCESS)
  336.         return err;

  338.     als_raw = (uint16_t)((als_data[1] << 8) | als_data[0]);

  340.     //compute scaling factor
  341.     scale = compute_scaling(dev);

  343.     *als_val = (als_raw * scale);

  345.     return err;
  346. }

  348. /*******************************************************************************************************************//**
  349. *  @brief       DeInitialize isl29035
  350. *  @param[IN]   None
  351. *  @retval      None
  352. **********************************************************************************************************************/
  353. void isl29035_deinit(void)
  354. {
  355.     fsp_err_t err     = FSP_SUCCESS;

  357.     /* close open modules */
  358.     err =  hal_i2c_close();

  360.     if (FSP_SUCCESS != err)
  361.     {
  362.         LOG_E("** hal_i2c_close API failed **
  363. ");
  364.     }
  365. }

  1. #define DBG_TAG "sensor.isl29035"
  2. #define DBG_LVL DBG_INFO
  3. #include
  4. #include
  5. #include

  7. #include "hal_data.h"
  8. #include "sensor_renesas_isl29035.h"
  9. #include "isl29035.h"

  11. #define SENSOR_LIGHT_RANGE_MAX (ISL29035_LUX_RANGE)
  12. #define SENSOR_LIGHT_RANGE_MIN (0)

  14. struct isl29035_device
  15. {
  16.     struct rt_i2c_bus_device *i2c;
  17.     rt_uint8_t addr;
  18.     struct isl29035_dev dev;
  19. };
  20. static struct isl29035_device isl29035_device;

  22. static rt_err_t _isl29035_init(struct rt_sensor_intf *intf)
  23. {
  24.     rt_int8_t ret;
  25.     isl29035_device.i2c = rt_i2c_bus_device_find(intf->dev_name);
  26.     if (isl29035_device.i2c == RT_NULL)
  27.     {
  28.         return -RT_ERROR;
  29.     }

  31.     isl29035_device.dev.id = ISL29035_I2C_ADDR;
  32.     isl29035_device.dev.interface = ISL29035_I2C_INTF;

  34.     ret = isl29035_init(&isl29035_device.dev, intf->dev_name);
  35.     if (ret)
  36.     {
  37.         LOG_E("Error %d during initialize hardware, exiting program!
  38. ", ret);
  39.         goto __exit_err;
  40.     }

  42.     ret = isl29035_configure(&isl29035_device.dev);

  44.     if (FSP_SUCCESS != ret)
  45.     {
  46.         /* Sensor init failed, so cleanup the sensor specific initialization */
  47.         LOG_E("** SENSOR ISL29035 CONFIGURATION FAILED **
  48. ");
  49.         isl29035_deinit();
  50.         goto __exit_err;
  51.     }

  53.     return RT_EOK;
  54. __exit_err:
  55.     return -RT_ERROR;
  56. }

  58. static void isl29035_polling_get_data(rt_sensor_t sensor, struct rt_sensor_data *data)
  59. {
  60.     RT_ASSERT(sensor != RT_NULL);
  61.     RT_ASSERT(data != RT_NULL);
  62.     rt_uint8_t ret;
  63.     double als_value; // Ambient Light sensor

  65.     /* Read sensor data */
  66.     ret = isl29035_read_als_data(&isl29035_device.dev, &als_value);
  67.     if (ret)
  68.     {
  69.         LOG_E("Error %d! SENSOR READ DATA FAILED
  70. ", ret);
  71.         goto __exit_err;
  72.     }

  74.     if (sensor->info.type == RT_SENSOR_TYPE_LIGHT)
  75.     {
  76.         data->data.light = als_value;
  77.     }

  79. __exit_err:
  80.     return;
  81. }

  83. static rt_ssize_t isl29035_fetch_data(struct rt_sensor_device *sensor,
  84.                                      struct rt_sensor_data *buf,
  85.                                      rt_size_t len)
  86. {
  87.     RT_ASSERT(buf);

  89.     if (sensor->config.irq_pin.mode == RT_SENSOR_MODE_FETCH_POLLING)
  90.     {
  91.         isl29035_polling_get_data(sensor, buf);
  92.         return 1;
  93.     }
  94.     else
  95.         return 0;
  96. }
  97. static rt_ssize_t isl29035_control(struct rt_sensor_device *sensor, int cmd, void *args)
  98. {
  99.     rt_ssize_t result = RT_EOK;

  101.     return result;
  102. }

  104. static struct rt_sensor_ops sensor_ops =
  105. {
  106.     isl29035_fetch_data,
  107.     isl29035_control
  108. };

  110. int rt_hw_isl29035_init(const char *name, struct rt_sensor_config *cfg)
  111. {
  112.     rt_int8_t result;
  113.     rt_sensor_t sensor_light = RT_NULL;

  115.     /* isl29035 LIGHT sensor register */
  116.     sensor_light = rt_calloc(1, sizeof(struct rt_sensor_device));
  117.     if (sensor_light == RT_NULL)
  118.         return -1;

  120.     sensor_light->info.type       = RT_SENSOR_TYPE_LIGHT;
  121.     sensor_light->info.vendor     = RT_SENSOR_VENDOR_UNKNOWN;
  122.     sensor_light->info.name      = "isl29035";
  123.     sensor_light->info.unit       = RT_SENSOR_UNIT_LUX;
  124.     sensor_light->info.intf_type  = RT_SENSOR_INTF_I2C;
  125.     sensor_light->info.scale.range_max  = SENSOR_LIGHT_RANGE_MAX;
  126.     sensor_light->info.scale.range_min  = SENSOR_LIGHT_RANGE_MIN;
  127.     sensor_light->info.acquire_min = 3000;
  128.     sensor_light->ops = &sensor_ops;
  129.     rt_memcpy(&sensor_light->config, cfg, sizeof(struct rt_sensor_config));

  131.     result = rt_hw_sensor_register(sensor_light,
  132.                                    name,
  133.                                    RT_DEVICE_FLAG_RDONLY,
  134.                                    RT_NULL);
  135.     if (result != RT_EOK)
  136.     {
  137.         LOG_E("device register err code: %d", result);
  138.         goto __exit_err;
  139.     }

  141.     if (RT_EOK != _isl29035_init(&cfg->intf))
  142.         goto __exit_err;

  144.     return RT_EOK;
  145. __exit_err:
  146.     rt_device_unregister(&sensor_light->parent);

  148.     if (sensor_light)
  149.         rt_free(sensor_light);
  150.     return -RT_ERROR;
  151. }


进行端口注册

  1. #include "sensor_renesas_isl29035.h"
  2. int rt_hw_isl29035_port(void)
  3. {
  4.     struct rt_sensor_config cfg;
  5.     cfg.intf.dev_name  = "i2c0";
  6.     rt_hw_isl29035_init("isl29035", &cfg);
  7.     return RT_EOK;
  8. }
  9. INIT_ENV_EXPORT(rt_hw_isl29035_port);
log 中正常打印光照强度值


更多回帖

0 0 2

相关帖子

瑞萨 RA4M2 RA4M2设计挑战赛
发帖
电子发烧友APP
|投诉反馈|电子发烧友网
© 2021 bbs.elecfans.com
湘ICP备2023018690号
×
20
完善资料，
赚取积分