STSW-STLKT01: Drivers/BSP/SensorTile/SensorTile_humidity.c Source File

STSW-STLKT01

previous page next page
STSW-STLKT01
SensorTile_humidity.c
Go to the documentation of this file.
1 
39 /* Includes ------------------------------------------------------------------*/
40 #include "SensorTile_humidity.h"
41 
59 static DrvContextTypeDef HUMIDITY_SensorHandle[ HUMIDITY_SENSORS_MAX_NUM ];
60 static HUMIDITY_Data_t HUMIDITY_Data[ HUMIDITY_SENSORS_MAX_NUM ]; // Humidity - all.
61 static HTS221_H_Data_t HTS221_H_0_Data; // Humidity - sensor 0.
62 
71 static DrvStatusTypeDef BSP_HTS221_HUMIDITY_Init( void **handle );
72 
88 DrvStatusTypeDef BSP_HUMIDITY_Init( HUMIDITY_ID_t id, void **handle )
89 {
90 
91  *handle = NULL;
92 
93  switch(id)
94  {
95  case HUMIDITY_SENSORS_AUTO:
96  default:
97  {
98  if( BSP_HTS221_HUMIDITY_Init(handle) == COMPONENT_ERROR )
99  {
100  return COMPONENT_ERROR;
101  }
102  break;
103  }
104  case HTS221_H_0:
105  {
106  if( BSP_HTS221_HUMIDITY_Init(handle) == COMPONENT_ERROR )
107  {
108  return COMPONENT_ERROR;
109  }
110  break;
111  }
112  }
113 
114  return COMPONENT_OK;
115 }
116 
117 
118 
119 static DrvStatusTypeDef BSP_HTS221_HUMIDITY_Init( void **handle )
120 {
121  HUMIDITY_Drv_t *driver = NULL;
122 
123  if(HUMIDITY_SensorHandle[ HTS221_H_0 ].isInitialized == 1)
124  {
125  /* We have reached the max num of instance for this component */
126  return COMPONENT_ERROR;
127  }
128 
129  if ( Sensor_IO_I2C_Init() == COMPONENT_ERROR )
130  {
131  return COMPONENT_ERROR;
132  }
133 
134  /* Setup sensor handle. */
135  HUMIDITY_SensorHandle[ HTS221_H_0 ].who_am_i = HTS221_WHO_AM_I_VAL;
136  HUMIDITY_SensorHandle[ HTS221_H_0 ].ifType = 0; // I2C interface
137  HUMIDITY_SensorHandle[ HTS221_H_0 ].address = HTS221_ADDRESS_DEFAULT;
138  HUMIDITY_SensorHandle[ HTS221_H_0 ].instance = HTS221_H_0;
139  HUMIDITY_SensorHandle[ HTS221_H_0 ].isInitialized = 0;
140  HUMIDITY_SensorHandle[ HTS221_H_0 ].isEnabled = 0;
141  HUMIDITY_SensorHandle[ HTS221_H_0 ].isCombo = 1;
142  HUMIDITY_SensorHandle[ HTS221_H_0 ].pData = ( void * )&HUMIDITY_Data[ HTS221_H_0 ];
143  HUMIDITY_SensorHandle[ HTS221_H_0 ].pVTable = ( void * )&HTS221_H_Drv;
144  HUMIDITY_SensorHandle[ HTS221_H_0 ].pExtVTable = 0;
145 
146  HTS221_H_0_Data.comboData = &HTS221_Combo_Data[0];
147  HUMIDITY_Data[ HTS221_H_0 ].pComponentData = ( void * )&HTS221_H_0_Data;
148  HUMIDITY_Data[ HTS221_H_0 ].pExtData = 0;
149 
150  *handle = (void *)&HUMIDITY_SensorHandle[ HTS221_H_0 ];
151 
152  driver = ( HUMIDITY_Drv_t * )((DrvContextTypeDef *)(*handle))->pVTable;
153 
154  if ( driver->Init == NULL )
155  {
156  memset((*handle), 0, sizeof(DrvContextTypeDef));
157  *handle = NULL;
158  return COMPONENT_ERROR;
159  }
160 
161  if ( driver->Init( (DrvContextTypeDef *)(*handle) ) == COMPONENT_ERROR )
162  {
163  memset((*handle), 0, sizeof(DrvContextTypeDef));
164  *handle = NULL;
165  return COMPONENT_ERROR;
166  }
167 
168  return COMPONENT_OK;
169 }
170 
171 
178 DrvStatusTypeDef BSP_HUMIDITY_DeInit( void **handle )
179 {
180 
181  DrvContextTypeDef *ctx = (DrvContextTypeDef *)(*handle);
182  HUMIDITY_Drv_t *driver = NULL;
183 
184  if(ctx == NULL)
185  {
186  return COMPONENT_ERROR;
187  }
188 
189  driver = ( HUMIDITY_Drv_t * )ctx->pVTable;
190 
191  if ( driver->DeInit == NULL )
192  {
193  return COMPONENT_ERROR;
194  }
195 
196  if ( driver->DeInit( ctx ) == COMPONENT_ERROR )
197  {
198  return COMPONENT_ERROR;
199  }
200 
201  memset(ctx, 0, sizeof(DrvContextTypeDef));
202 
203  *handle = NULL;
204 
205  return COMPONENT_OK;
206 }
207 
208 
209 
216 DrvStatusTypeDef BSP_HUMIDITY_Sensor_Enable( void *handle )
217 {
218 
219  DrvContextTypeDef *ctx = (DrvContextTypeDef *)handle;
220  HUMIDITY_Drv_t *driver = NULL;
221 
222  if(ctx == NULL)
223  {
224  return COMPONENT_ERROR;
225  }
226 
227  driver = ( HUMIDITY_Drv_t * )ctx->pVTable;
228 
229  if ( driver->Sensor_Enable == NULL )
230  {
231  return COMPONENT_ERROR;
232  }
233 
234  if ( driver->Sensor_Enable( ctx ) == COMPONENT_ERROR )
235  {
236  return COMPONENT_ERROR;
237  }
238 
239  return COMPONENT_OK;
240 }
241 
242 
243 
250 DrvStatusTypeDef BSP_HUMIDITY_Sensor_Disable( void *handle )
251 {
252 
253  DrvContextTypeDef *ctx = (DrvContextTypeDef *)handle;
254  HUMIDITY_Drv_t *driver = NULL;
255 
256  if(ctx == NULL)
257  {
258  return COMPONENT_ERROR;
259  }
260 
261  driver = ( HUMIDITY_Drv_t * )ctx->pVTable;
262 
263  if ( driver->Sensor_Disable == NULL )
264  {
265  return COMPONENT_ERROR;
266  }
267 
268  if ( driver->Sensor_Disable( ctx ) == COMPONENT_ERROR )
269  {
270  return COMPONENT_ERROR;
271  }
272 
273  return COMPONENT_OK;
274 }
275 
276 
284 DrvStatusTypeDef BSP_HUMIDITY_IsInitialized( void *handle, uint8_t *status )
285 {
286  DrvContextTypeDef *ctx = (DrvContextTypeDef *)handle;
287 
288  if(ctx == NULL)
289  {
290  return COMPONENT_ERROR;
291  }
292 
293  if ( status == NULL )
294  {
295  return COMPONENT_ERROR;
296  }
297 
298  *status = ctx->isInitialized;
299 
300  return COMPONENT_OK;
301 }
302 
303 
311 DrvStatusTypeDef BSP_HUMIDITY_IsEnabled( void *handle, uint8_t *status )
312 {
313  DrvContextTypeDef *ctx = (DrvContextTypeDef *)handle;
314 
315  if(ctx == NULL)
316  {
317  return COMPONENT_ERROR;
318  }
319 
320  if ( status == NULL )
321  {
322  return COMPONENT_ERROR;
323  }
324 
325  *status = ctx->isEnabled;
326 
327  return COMPONENT_OK;
328 }
329 
330 
338 DrvStatusTypeDef BSP_HUMIDITY_IsCombo( void *handle, uint8_t *status )
339 {
340  DrvContextTypeDef *ctx = (DrvContextTypeDef *)handle;
341 
342  if(ctx == NULL)
343  {
344  return COMPONENT_ERROR;
345  }
346 
347  if ( status == NULL )
348  {
349  return COMPONENT_ERROR;
350  }
351 
352  *status = ctx->isCombo;
353 
354  return COMPONENT_OK;
355 }
356 
357 
365 DrvStatusTypeDef BSP_HUMIDITY_Get_Instance( void *handle, uint8_t *instance )
366 {
367  DrvContextTypeDef *ctx = (DrvContextTypeDef *)handle;
368 
369  if(ctx == NULL)
370  {
371  return COMPONENT_ERROR;
372  }
373 
374  if ( instance == NULL )
375  {
376  return COMPONENT_ERROR;
377  }
378 
379  *instance = ctx->instance;
380 
381  return COMPONENT_OK;
382 }
383 
384 
385 
393 DrvStatusTypeDef BSP_HUMIDITY_Get_WhoAmI( void *handle, uint8_t *who_am_i )
394 {
395 
396  DrvContextTypeDef *ctx = (DrvContextTypeDef *)handle;
397  HUMIDITY_Drv_t *driver = NULL;
398 
399  if(ctx == NULL)
400  {
401  return COMPONENT_ERROR;
402  }
403 
404  driver = ( HUMIDITY_Drv_t * )ctx->pVTable;
405 
406  if ( who_am_i == NULL )
407  {
408  return COMPONENT_ERROR;
409  }
410  if ( driver->Get_WhoAmI == NULL )
411  {
412  return COMPONENT_ERROR;
413  }
414  if ( driver->Get_WhoAmI( ctx, who_am_i ) == COMPONENT_ERROR )
415  {
416  return COMPONENT_ERROR;
417  }
418 
419  return COMPONENT_OK;
420 }
421 
422 
423 
430 DrvStatusTypeDef BSP_HUMIDITY_Check_WhoAmI( void *handle )
431 {
432 
433  DrvContextTypeDef *ctx = (DrvContextTypeDef *)handle;
434  HUMIDITY_Drv_t *driver = NULL;
435 
436  if(ctx == NULL)
437  {
438  return COMPONENT_ERROR;
439  }
440 
441  driver = ( HUMIDITY_Drv_t * )ctx->pVTable;
442 
443  if ( driver->Check_WhoAmI == NULL )
444  {
445  return COMPONENT_ERROR;
446  }
447  if ( driver->Check_WhoAmI( ctx ) == COMPONENT_ERROR )
448  {
449  return COMPONENT_ERROR;
450  }
451 
452  return COMPONENT_OK;
453 }
454 
455 
456 
464 DrvStatusTypeDef BSP_HUMIDITY_Get_Hum( void *handle, float *humidity )
465 {
466 
467  DrvContextTypeDef *ctx = (DrvContextTypeDef *)handle;
468  HUMIDITY_Drv_t *driver = NULL;
469 
470  if(ctx == NULL)
471  {
472  return COMPONENT_ERROR;
473  }
474 
475  driver = ( HUMIDITY_Drv_t * )ctx->pVTable;
476 
477  if ( humidity == NULL )
478  {
479  return COMPONENT_ERROR;
480  }
481  if ( driver->Get_Hum == NULL )
482  {
483  return COMPONENT_ERROR;
484  }
485  if ( driver->Get_Hum( ctx, humidity ) == COMPONENT_ERROR )
486  {
487  return COMPONENT_ERROR;
488  }
489 
490  return COMPONENT_OK;
491 }
492 
493 
494 
502 DrvStatusTypeDef BSP_HUMIDITY_Get_ODR( void *handle, float *odr )
503 {
504 
505  DrvContextTypeDef *ctx = (DrvContextTypeDef *)handle;
506  HUMIDITY_Drv_t *driver = NULL;
507 
508  if(ctx == NULL)
509  {
510  return COMPONENT_ERROR;
511  }
512 
513  driver = ( HUMIDITY_Drv_t * )ctx->pVTable;
514 
515  if ( odr == NULL )
516  {
517  return COMPONENT_ERROR;
518  }
519  if ( driver->Get_ODR == NULL )
520  {
521  return COMPONENT_ERROR;
522  }
523  if ( driver->Get_ODR( ctx, odr ) == COMPONENT_ERROR )
524  {
525  return COMPONENT_ERROR;
526  }
527 
528  return COMPONENT_OK;
529 }
530 
531 
532 
533 
542 DrvStatusTypeDef BSP_HUMIDITY_Read_Reg( void *handle, uint8_t reg, uint8_t *data )
543 {
544 
545  DrvContextTypeDef *ctx = (DrvContextTypeDef *)handle;
546  HUMIDITY_Drv_t *driver = NULL;
547 
548  if(ctx == NULL)
549  {
550  return COMPONENT_ERROR;
551  }
552 
553  driver = ( HUMIDITY_Drv_t * )ctx->pVTable;
554 
555  if(data == NULL)
556  {
557  return COMPONENT_ERROR;
558  }
559 
560  if ( driver->Read_Reg == NULL )
561  {
562  return COMPONENT_ERROR;
563  }
564 
565  if ( driver->Read_Reg( ctx, reg, data ) == COMPONENT_ERROR )
566  {
567  return COMPONENT_ERROR;
568  }
569 
570  return COMPONENT_OK;
571 }
572 
573 
574 
583 DrvStatusTypeDef BSP_HUMIDITY_Write_Reg( void *handle, uint8_t reg, uint8_t data )
584 {
585 
586  DrvContextTypeDef *ctx = (DrvContextTypeDef *)handle;
587  HUMIDITY_Drv_t *driver = NULL;
588 
589  if(ctx == NULL)
590  {
591  return COMPONENT_ERROR;
592  }
593 
594  driver = ( HUMIDITY_Drv_t * )ctx->pVTable;
595 
596  if ( driver->Write_Reg == NULL )
597  {
598  return COMPONENT_ERROR;
599  }
600 
601  if ( driver->Write_Reg( ctx, reg, data ) == COMPONENT_ERROR )
602  {
603  return COMPONENT_ERROR;
604  }
605 
606  return COMPONENT_OK;
607 }
608 
609 
610 
618 DrvStatusTypeDef BSP_HUMIDITY_Get_DRDY_Status( void *handle, uint8_t *status )
619 {
620 
621  DrvContextTypeDef *ctx = (DrvContextTypeDef *)handle;
622  HUMIDITY_Drv_t *driver = NULL;
623 
624  if(ctx == NULL)
625  {
626  return COMPONENT_ERROR;
627  }
628 
629  driver = ( HUMIDITY_Drv_t * )ctx->pVTable;
630 
631  if ( driver->Get_DRDY_Status == NULL )
632  {
633  return COMPONENT_ERROR;
634  }
635 
636  if ( driver->Get_DRDY_Status( ctx, status ) == COMPONENT_ERROR )
637  {
638  return COMPONENT_ERROR;
639  }
640 
641  return COMPONENT_OK;
642 }
650 DrvStatusTypeDef BSP_HUMIDITY_Set_ODR( void *handle, SensorOdr_t odr )
651 {
652 
653  DrvContextTypeDef *ctx = (DrvContextTypeDef *)handle;
654  HUMIDITY_Drv_t *driver = NULL;
655 
656  if(ctx == NULL)
657  {
658  return COMPONENT_ERROR;
659  }
660 
661  driver = ( HUMIDITY_Drv_t * )ctx->pVTable;
662 
663  if ( driver->Set_ODR == NULL )
664  {
665  return COMPONENT_ERROR;
666  }
667  if ( driver->Set_ODR( ctx, odr ) == COMPONENT_ERROR )
668  {
669  return COMPONENT_ERROR;
670  }
671 
672  return COMPONENT_OK;
673 }
674 
675 
676 
684 DrvStatusTypeDef BSP_HUMIDITY_Set_ODR_Value( void *handle, float odr )
685 {
686 
687  DrvContextTypeDef *ctx = (DrvContextTypeDef *)handle;
688  HUMIDITY_Drv_t *driver = NULL;
689 
690  if(ctx == NULL)
691  {
692  return COMPONENT_ERROR;
693  }
694 
695  driver = ( HUMIDITY_Drv_t * )ctx->pVTable;
696 
697  if ( driver->Set_ODR_Value == NULL )
698  {
699  return COMPONENT_ERROR;
700  }
701  if ( driver->Set_ODR_Value( ctx, odr ) == COMPONENT_ERROR )
702  {
703  return COMPONENT_ERROR;
704  }
705 
706  return COMPONENT_OK;
707 }
708 
725 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
BSP_HUMIDITY_Set_ODR_Value
DrvStatusTypeDef BSP_HUMIDITY_Set_ODR_Value(void *handle, float odr)
Set the humidity sensor output data rate.
Definition: SensorTile_humidity.c:684
BSP_HUMIDITY_Get_DRDY_Status
DrvStatusTypeDef BSP_HUMIDITY_Get_DRDY_Status(void *handle, uint8_t *status)
Get humidity data ready status.
Definition: SensorTile_humidity.c:618
SensorTile_humidity.h
This file contains definitions for the SensorTile_humidity.c.
BSP_HUMIDITY_Init
DrvStatusTypeDef BSP_HUMIDITY_Init(HUMIDITY_ID_t id, void **handle)
Initialize a humidity sensor.
Definition: SensorTile_humidity.c:88
BSP_HUMIDITY_Sensor_Disable
DrvStatusTypeDef BSP_HUMIDITY_Sensor_Disable(void *handle)
Disable humidity sensor.
Definition: SensorTile_humidity.c:250
BSP_HUMIDITY_Write_Reg
DrvStatusTypeDef BSP_HUMIDITY_Write_Reg(void *handle, uint8_t reg, uint8_t data)
Write the data to register.
Definition: SensorTile_humidity.c:583
BSP_HUMIDITY_Set_ODR
DrvStatusTypeDef BSP_HUMIDITY_Set_ODR(void *handle, SensorOdr_t odr)
Set the humidity sensor output data rate.
Definition: SensorTile_humidity.c:650
BSP_HUMIDITY_IsEnabled
DrvStatusTypeDef BSP_HUMIDITY_IsEnabled(void *handle, uint8_t *status)
Check if the humidity sensor is enabled.
Definition: SensorTile_humidity.c:311
BSP_HUMIDITY_DeInit
DrvStatusTypeDef BSP_HUMIDITY_DeInit(void **handle)
Deinitialize a humidity sensor.
Definition: SensorTile_humidity.c:178
BSP_HUMIDITY_IsInitialized
DrvStatusTypeDef BSP_HUMIDITY_IsInitialized(void *handle, uint8_t *status)
Check if the humidity sensor is initialized.
Definition: SensorTile_humidity.c:284
BSP_HUMIDITY_IsCombo
DrvStatusTypeDef BSP_HUMIDITY_IsCombo(void *handle, uint8_t *status)
Check if the humidity sensor is combo.
Definition: SensorTile_humidity.c:338
BSP_HUMIDITY_Get_Hum
DrvStatusTypeDef BSP_HUMIDITY_Get_Hum(void *handle, float *humidity)
Get the humidity value.
Definition: SensorTile_humidity.c:464
BSP_HUMIDITY_Get_WhoAmI
DrvStatusTypeDef BSP_HUMIDITY_Get_WhoAmI(void *handle, uint8_t *who_am_i)
Get the WHO_AM_I ID of the humidity sensor.
Definition: SensorTile_humidity.c:393
Sensor_IO_I2C_Init
DrvStatusTypeDef Sensor_IO_I2C_Init(void)
Configures sensor SPI interface.
Definition: SensorTile.c:274
BSP_HUMIDITY_Get_ODR
DrvStatusTypeDef BSP_HUMIDITY_Get_ODR(void *handle, float *odr)
Get the humidity sensor output data rate.
Definition: SensorTile_humidity.c:502
BSP_HUMIDITY_Read_Reg
DrvStatusTypeDef BSP_HUMIDITY_Read_Reg(void *handle, uint8_t reg, uint8_t *data)
Read the data from register.
Definition: SensorTile_humidity.c:542
BSP_HUMIDITY_Check_WhoAmI
DrvStatusTypeDef BSP_HUMIDITY_Check_WhoAmI(void *handle)
Check the WHO_AM_I ID of the humidity sensor.
Definition: SensorTile_humidity.c:430
BSP_HUMIDITY_Sensor_Enable
DrvStatusTypeDef BSP_HUMIDITY_Sensor_Enable(void *handle)
Enable humidity sensor.
Definition: SensorTile_humidity.c:216
BSP_HUMIDITY_Get_Instance
DrvStatusTypeDef BSP_HUMIDITY_Get_Instance(void *handle, uint8_t *instance)
Get the humidity sensor instance.
Definition: SensorTile_humidity.c:365
Generated by   doxygen 1.8.13
previous page start next page