/ - Diff - AMiRo-OS - Research for Cognitive Interaction

       PCA9544A_LLD_CH_NONE  = 0xFFu, /**< identifier to select no channel */
     } pca9544a_lld_chid_t;
     /**
      * @brief Type holding a bit mask for the four channel interrupts.
      */
     typedef uint8_t pca9544a_lld_intstatus_t;
     /******************************************************************************/

source/alld_a3906.c
59	59	*
60	60	* @return The return status indicates whether the function call was successfull.
61	61	*/
62		inline apalExitStatus_t
63		a3906_lld_set_power(const A3906Driver* const a3906, const a3906_lld_power_t power_state)
	62	apalExitStatus_t a3906_lld_set_power(const A3906Driver* const a3906, const a3906_lld_power_t power_state)
64	63	{
65	64	apalDbgAssert(a3906 != NULL);
66	65
...	...
76	75	*
77	76	* @return The return status indicates whether the function call was successfull.
78	77	*/
79		inline apalExitStatus_t
80		a3906_lld_get_power(const A3906Driver* const a3906, a3906_lld_power_t* const power_state)
	78	apalExitStatus_t a3906_lld_get_power(const A3906Driver* const a3906, a3906_lld_power_t* const power_state)
81	79	{
82	80	apalDbgAssert(a3906 != NULL);
83	81	apalDbgAssert(power_state != NULL);
...	...
98	96	*
99	97	* @return The return status indicates whether the function call was successfull.
100	98	*/
101		inline apalExitStatus_t
102		a3906_lld_set_pwm(apalPWMDriver_t* pwm, const apalPWMchannel_t channel, const apalPWMwidth_t width)
	99	apalExitStatus_t a3906_lld_set_pwm(apalPWMDriver_t* pwm, const apalPWMchannel_t channel, const apalPWMwidth_t width)
103	100	{
104	101	apalDbgAssert(pwm != NULL);
105	102

source/alld_at24c01bn-sh-b.c
61	61	*
62	62	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
63	63	*/
64		inline apalExitStatus_t
65		at24c01bn_lld_poll_ack(const AT24C01BNDriver* const at24c01bn, const apalTime_t timeout)
	64	apalExitStatus_t at24c01bn_lld_poll_ack(const AT24C01BNDriver* const at24c01bn, const apalTime_t timeout)
66	65	{
67	66	apalDbgAssert(at24c01bn != NULL);
68	67
...	...
79	78	*
80	79	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
81	80	*/
82		inline apalExitStatus_t
83		at24c01bn_lld_read_current_address(const AT24C01BNDriver* const at24c01bn, uint8_t* const data, const uint8_t num, const apalTime_t timeout)
	81	apalExitStatus_t at24c01bn_lld_read_current_address(const AT24C01BNDriver* const at24c01bn, uint8_t* const data, const uint8_t num, const apalTime_t timeout)
84	82	{
85	83	apalDbgAssert(at24c01bn != NULL);
86	84	apalDbgAssert(data != NULL);
...	...
98	96	*
99	97	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
100	98	*/
101		inline apalExitStatus_t
102		at24c01bn_lld_read(const AT24C01BNDriver* const at24c01bn, const uint8_t addr, uint8_t* const data, const uint8_t num, const apalTime_t timeout)
	99	apalExitStatus_t at24c01bn_lld_read(const AT24C01BNDriver* const at24c01bn, const uint8_t addr, uint8_t* const data, const uint8_t num, const apalTime_t timeout)
103	100	{
104	101	apalDbgAssert(at24c01bn != NULL);
105	102	apalDbgAssert(data != NULL);
...	...
122	119	*
123	120	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
124	121	*/
125		inline apalExitStatus_t
126		at24c01bn_lld_write_byte(const AT24C01BNDriver* const at24c01bn, const uint8_t addr, const uint8_t data, const apalTime_t timeout)
	122	apalExitStatus_t at24c01bn_lld_write_byte(const AT24C01BNDriver* const at24c01bn, const uint8_t addr, const uint8_t data, const apalTime_t timeout)
127	123	{
128	124	apalDbgAssert(at24c01bn != NULL);
129	125
...	...
141	137	*
142	138	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
143	139	*/
144		inline apalExitStatus_t
145		at24c01bn_lld_write_page(const AT24C01BNDriver* const at24c01bn, const uint8_t addr, const uint8_t* const data, const uint8_t num, const apalTime_t timeout)
	140	apalExitStatus_t at24c01bn_lld_write_page(const AT24C01BNDriver* const at24c01bn, const uint8_t addr, const uint8_t* const data, const uint8_t num, const apalTime_t timeout)
146	141	{
147	142	apalDbgAssert(at24c01bn != NULL);
148	143	apalDbgAssert(data != NULL);

source/alld_at42qt1050.c
64	64	*
65	65	* @return Indicator whether the function call was successful or a timeout occurred.
66	66	*/
67		inline apalExitStatus_t
68		at42qt1050_lld_read_reg(const AT42QT1050Driver* at42qt1050d, const at42qt1050_lld_register_t reg, uint8_t* const data, const apalTime_t timeout)
	67	apalExitStatus_t at42qt1050_lld_read_reg(const AT42QT1050Driver* at42qt1050d, const at42qt1050_lld_register_t reg, uint8_t* const data, const apalTime_t timeout)
69	68	{
70	69	apalDbgAssert(at42qt1050d != NULL && at42qt1050d->i2cd != NULL);
71	70	apalDbgAssert(data != NULL);
...	...
84	83	*
85	84	* @return Indicator whether the function call was successful or a timeout occurred.
86	85	*/
87		inline apalExitStatus_t
88		at42qt1050_lld_write_reg(const AT42QT1050Driver* at42qt1050d, const at42qt1050_lld_register_t reg, const uint8_t data, const apalTime_t timeout)
	86	apalExitStatus_t at42qt1050_lld_write_reg(const AT42QT1050Driver* at42qt1050d, const at42qt1050_lld_register_t reg, const uint8_t data, const apalTime_t timeout)
89	87	{
90	88	apalDbgAssert(at42qt1050d != NULL && at42qt1050d->i2cd != NULL);
91	89
...	...
103	101	*
104	102	* @return Indicator whether the function call was successful or a timeout occurred.
105	103	*/
106		inline apalExitStatus_t
107		at42qt1050_lld_read_keyssignal(const AT42QT1050Driver* at42qt1050d, const uint8_t key, uint16_t* signal, const apalTime_t timeout)
	104	apalExitStatus_t at42qt1050_lld_read_keyssignal(const AT42QT1050Driver* at42qt1050d, const uint8_t key, uint16_t* signal, const apalTime_t timeout)
108	105	{
109	106	apalDbgAssert(at42qt1050d != NULL && at42qt1050d->i2cd != NULL);
110	107	apalDbgAssert(key < AT42QT1050_LLD_NUM_KEYS);
...	...
127	124	*
128	125	* @return Indicator whether the function call was successful or a timeout occurred.
129	126	*/
130		inline apalExitStatus_t
131		at42qt1050_lld_read_referencedata(const AT42QT1050Driver* at42qt1050d, const uint8_t key, uint16_t* refdata, const apalTime_t timeout)
	127	apalExitStatus_t at42qt1050_lld_read_referencedata(const AT42QT1050Driver* at42qt1050d, const uint8_t key, uint16_t* refdata, const apalTime_t timeout)
132	128	{
133	129	apalDbgAssert(at42qt1050d != NULL && at42qt1050d->i2cd != NULL);
134	130	apalDbgAssert(key < AT42QT1050_LLD_NUM_KEYS);
...	...
149	145	*
150	146	* @return Resulting sample count.
151	147	*/
152		inline uint16_t
153		at42qt1050_lld_pulse2samples(const uint8_t pulse)
	148	uint16_t at42qt1050_lld_pulse2samples(const uint8_t pulse)
154	149	{
155	150	apalDbgAssert(pulse <= 0x0Fu);
156	151
...	...
165	160	*
166	161	* @return The (theoretical) value to set to the pulse register.
167	162	*/
168		inline float
169		at42qt1050_lld_samples2pulse(const uint16_t samples)
	163	float at42qt1050_lld_samples2pulse(const uint16_t samples)
170	164	{
171	165	return log2f(samples);
172	166	}
...	...
179	173	*
180	174	* @return Resulting scaling factor.
181	175	*/
182		inline uint16_t
183		at42qt1050_lld_scale2scaling(const uint8_t scale)
	176	uint16_t at42qt1050_lld_scale2scaling(const uint8_t scale)
184	177	{
185	178	apalDbgAssert(scale <= 0x0Fu);
186	179
...	...
195	188	*
196	189	* @return The (theoretcial) value to set to the scale register.
197	190	*/
198		inline float
199		at42qt1050_lld_scaling2scale(const uint16_t factor)
	191	float at42qt1050_lld_scaling2scale(const uint16_t factor)
200	192	{
201	193	return log2f(factor);
202	194	}

      * @param[out]  pinstate    current value of the gpio pin
      * @return                  An indicator whether the call was successfull
      */
     inline apalExitStatus_t
     bq24103a_lld_get_enabled(const BQ24103ADriver* const bq24103a, bq24103a_lld_enable_t* const enable)
     apalExitStatus_t bq24103a_lld_get_enabled(const BQ24103ADriver* const bq24103a, bq24103a_lld_enable_t* const enable)
+    {
       apalDbgAssert(bq24103a != NULL);
       apalDbgAssert(enable != NULL);
-...
      * @param[in]   pinstate    new value of the gpio pin
      * @return                  An indicator whether the call was successfull
      */
     inline apalExitStatus_t
     bq24103a_lld_set_enabled(const BQ24103ADriver* const bq24103a, const bq24103a_lld_enable_t enable)
     apalExitStatus_t bq24103a_lld_set_enabled(const BQ24103ADriver* const bq24103a, const bq24103a_lld_enable_t enable)
+    {
       apalDbgAssert(bq24103a != NULL);
-...
      * @param[out]  pinstate    current value of the gpio pin
      * @return                  An indicator whether the call was successfull
      */
     inline apalExitStatus_t
     bq24103a_lld_get_charge_status(const BQ24103ADriver* const bq24103a, bq24103a_lld_charge_state_t* const charge)
     apalExitStatus_t bq24103a_lld_get_charge_status(const BQ24103ADriver* const bq24103a, bq24103a_lld_charge_state_t* const charge)
+    {
       apalDbgAssert(bq24103a != NULL);
       apalDbgAssert(charge != NULL);

source/alld_bq27500.c
61	61	*
62	62	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
63	63	*/
64		inline apalExitStatus_t
65		bq27500_lld_read_batlow(const BQ27500Driver* const bq27500, bq27500_lld_batlow_t* const batlow)
	64	apalExitStatus_t bq27500_lld_read_batlow(const BQ27500Driver* const bq27500, bq27500_lld_batlow_t* const batlow)
66	65	{
67	66	apalDbgAssert(bq27500 != NULL);
68	67	apalDbgAssert(batlow != NULL);
...	...
80	79	*
81	80	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
82	81	*/
83		inline apalExitStatus_t
84		bq27500_lld_read_batgood(const BQ27500Driver* const bq27500, bq27500_lld_batgood_t* const batgood)
	82	apalExitStatus_t bq27500_lld_read_batgood(const BQ27500Driver* const bq27500, bq27500_lld_batgood_t* const batgood)
85	83	{
86	84	apalDbgAssert(bq27500 != NULL);
87	85	apalDbgAssert(batgood != NULL);
...	...
101	99	*
102	100	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
103	101	*/
104		inline apalExitStatus_t
105		bq27500_lld_std_command(const BQ27500Driver* const bq27500, const bq27500_lld_std_command_t cmd, uint16_t* const dst, const apalTime_t timeout)
	102	apalExitStatus_t bq27500_lld_std_command(const BQ27500Driver* const bq27500, const bq27500_lld_std_command_t cmd, uint16_t* const dst, const apalTime_t timeout)
106	103	{
107	104	apalDbgAssert(bq27500 != NULL);
108	105	apalDbgAssert(dst != NULL);
...	...
121	118	*
122	119	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
123	120	*/
124		inline apalExitStatus_t
125		bq27500_lld_sub_command_call(const BQ27500Driver* const bq27500, const bq27500_lld_control_subcmd_t cmd, const apalTime_t timeout)
	121	apalExitStatus_t bq27500_lld_sub_command_call(const BQ27500Driver* const bq27500, const bq27500_lld_control_subcmd_t cmd, const apalTime_t timeout)
126	122	{
127	123	apalDbgAssert(bq27500 != NULL);
128	124
...	...
138	134	*
139	135	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
140	136	*/
141		inline apalExitStatus_t
142		bq27500_lld_sub_command_read(const BQ27500Driver* const bq27500, uint16_t* const data, const apalTime_t timeout)
	137	apalExitStatus_t bq27500_lld_sub_command_read(const BQ27500Driver* const bq27500, uint16_t* const data, const apalTime_t timeout)
143	138	{
144	139	apalDbgAssert(bq27500 != NULL);
145	140	apalDbgAssert(data != NULL);
...	...
162	157	*
163	158	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
164	159	*/
165		inline apalExitStatus_t
166		bq27500_lld_ext_command(const BQ27500Driver* const bq27500, const bq27500_lld_ext_command_t cmd, const bq27500_lld_ext_cmd_access_t rw, uint8_t* const buffer, const uint8_t length, const uint8_t offset, const apalTime_t timeout)
	160	apalExitStatus_t bq27500_lld_ext_command(const BQ27500Driver* const bq27500, const bq27500_lld_ext_command_t cmd, const bq27500_lld_ext_cmd_access_t rw, uint8_t* const buffer, const uint8_t length, const uint8_t offset, const apalTime_t timeout)
167	161	{
168	162	apalDbgAssert(bq27500 != NULL);
169	163	apalDbgAssert(buffer != NULL);
...	...
186	180	*
187	181	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
188	182	*/
189		inline apalExitStatus_t
190		bq27500_lld_send_ctnl_data(const BQ27500Driver* const bq27500, const uint16_t data, const apalTime_t timeout)
	183	apalExitStatus_t bq27500_lld_send_ctnl_data(const BQ27500Driver* const bq27500, const uint16_t data, const apalTime_t timeout)
191	184	{
192	185	apalDbgAssert(bq27500 != NULL);
193	186
...	...
202	195	*
203	196	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
204	197	*/
205		inline apalExitStatus_t
206		bq27500_lld_compute_blockdata_checksum(const uint8_t* const blockdata, uint8_t* const sum)
	198	apalExitStatus_t bq27500_lld_compute_blockdata_checksum(const uint8_t* const blockdata, uint8_t* const sum)
207	199	{
208	200	apalDbgAssert(blockdata != NULL);
209	201	apalDbgAssert(sum != NULL);

+     *
      */
     #include <alld_dw1000.h>
     #if defined(AMIROLLD_CFG_USE_DW1000) || defined(__DOXYGEN__)
     #include <alld_dw1000_regs.h>

source/alld_hmc5883l.c
63	63	*
64	64	* @return The return status indicates whether the function call was successfull or a timeout occured.
65	65	*/
66		inline apalExitStatus_t
67		hmc5883l_lld_check(const HMC5883LDriver* const hmcd, uint8_t* const rxbuffer, const uint8_t num, const apalTime_t timeout)
	66	apalExitStatus_t hmc5883l_lld_check(const HMC5883LDriver* const hmcd, uint8_t* const rxbuffer, const uint8_t num, const apalTime_t timeout)
68	67	{
69	68	apalDbgAssert(hmcd != NULL && hmcd->i2cd != NULL);
70	69	apalDbgAssert(rxbuffer != NULL);
...	...
83	82	*
84	83	* @return The return status indicates whether the function call was successfull or a timeout occured.
85	84	*/
86		inline apalExitStatus_t
87		hmc5883l_lld_write_register(const HMC5883LDriver* const hmcd, const hmc5883l_lld_register_t regaddr, const uint8_t* const data, const uint8_t num, const apalTime_t timeout)
	85	apalExitStatus_t hmc5883l_lld_write_register(const HMC5883LDriver* const hmcd, const hmc5883l_lld_register_t regaddr, const uint8_t* const data, const uint8_t num, const apalTime_t timeout)
88	86	{
89	87	apalDbgAssert(hmcd != NULL && hmcd->i2cd != NULL);
90	88	apalDbgAssert(data != NULL);
...	...
104	102	*
105	103	* @return The return status indicates whether the function call was successfull or a timeout occured.
106	104	*/
107		inline apalExitStatus_t
108		hmc5883l_lld_set_register(const HMC5883LDriver* const hmcd, const hmc5883l_lld_register_t regaddr, const uint8_t data, const apalTime_t timeout)
	105	apalExitStatus_t hmc5883l_lld_set_register(const HMC5883LDriver* const hmcd, const hmc5883l_lld_register_t regaddr, const uint8_t data, const apalTime_t timeout)
109	106	{
110	107	apalDbgAssert(hmcd != NULL && hmcd->i2cd != NULL);
111	108
...	...
125	122	*
126	123	* @return The return status indicates whether the function call was successfull or a timeout occured.
127	124	*/
128		inline apalExitStatus_t
129		hmc5883l_lld_read_register(const HMC5883LDriver* const hmcd, const hmc5883l_lld_register_t regaddr, uint8_t* const data, const uint8_t num, const apalTime_t timeout)
	125	apalExitStatus_t hmc5883l_lld_read_register(const HMC5883LDriver* const hmcd, const hmc5883l_lld_register_t regaddr, uint8_t* const data, const uint8_t num, const apalTime_t timeout)
130	126	{
131	127	apalDbgAssert(hmcd != NULL && hmcd->i2cd != NULL);
132	128	apalDbgAssert(data != NULL);
...	...
142	138	*
143	139	* @return The return status indicates whether the function call was successfull or a timeout occured.
144	140	*/
145		inline apalExitStatus_t
146		hmc5883l_lld_read_data(const HMC5883LDriver* const hmcd, uint16_t* const data, const apalTime_t timeout)
	141	apalExitStatus_t hmc5883l_lld_read_data(const HMC5883LDriver* const hmcd, uint16_t* const data, const apalTime_t timeout)
147	142	{
148	143	apalDbgAssert(data != NULL);
149	144
...	...
168	163	*
169	164	* @return The return status indicates whether the function call was successfull or a timeout occured.
170	165	*/
171		inline apalExitStatus_t
172		hmc5883l_lld_read_status(const HMC5883LDriver* const hmcd, uint8_t* const status, const apalTime_t timeout)
	166	apalExitStatus_t hmc5883l_lld_read_status(const HMC5883LDriver* const hmcd, uint8_t* const status, const apalTime_t timeout)
173	167	{
174	168	apalDbgAssert(status != NULL);
175	169
...	...
184	178	*
185	179	* @return The return status indicates whether the function call was successfull or a timeout occured.
186	180	*/
187		inline apalExitStatus_t
188		hmc5883l_lld_read_config(const HMC5883LDriver* const hmcd, hmc5883l_lld_config_t* const cfg, const apalTime_t timeout)
	181	apalExitStatus_t hmc5883l_lld_read_config(const HMC5883LDriver* const hmcd, hmc5883l_lld_config_t* const cfg, const apalTime_t timeout)
189	182	{
190	183	apalDbgAssert(cfg != NULL);
191	184
...	...
208	201	*
209	202	* @return The return status indicates whether the function call was successfull or a timeout occured.
210	203	*/
211		inline apalExitStatus_t
212		hmc5883l_lld_write_config(const HMC5883LDriver* const hmcd, const hmc5883l_lld_config_t cfg, const apalTime_t timeout)
	204	apalExitStatus_t hmc5883l_lld_write_config(const HMC5883LDriver* const hmcd, const hmc5883l_lld_config_t cfg, const apalTime_t timeout)
213	205	{
214	206	uint8_t conf[3];
215	207	conf[0] = cfg.avg \| cfg.outrate \| cfg.mbias;
...	...
226	218	*
227	219	* @return The return status indicates whether the function call was successfull or a timeout occured.
228	220	*/
229		inline apalExitStatus_t
230		hmc5883l_lld_read_lock(const HMC5883LDriver* const hmcd, uint8_t* const lock, const apalTime_t timeout)
	221	apalExitStatus_t hmc5883l_lld_read_lock(const HMC5883LDriver* const hmcd, uint8_t* const lock, const apalTime_t timeout)
231	222	{
232	223	apalDbgAssert(lock != NULL);
233	224
...	...
244	235	*
245	236	* @return The return status indicates whether the function call was successfull or a timeout occured.
246	237	*/
247		inline apalExitStatus_t
248		hmc5883l_lld_read_rdy(const HMC5883LDriver* const hmcd, uint8_t* const rdy, const apalTime_t timeout)
	238	apalExitStatus_t hmc5883l_lld_read_rdy(const HMC5883LDriver* const hmcd, uint8_t* const rdy, const apalTime_t timeout)
249	239	{
250	240	apalDbgAssert(rdy != NULL);
251	241

      * @param[in]   timeout     timeout
      * @return                  An indicator whether the call was successfull
      */
     inline apalExitStatus_t
     ina219_lld_read_register(const INA219Driver* const ina219, const ina219_lld_register_t addr, uint16_t* const data, const uint8_t num, const apalTime_t timeout)
     apalExitStatus_t ina219_lld_read_register(const INA219Driver* const ina219, const ina219_lld_register_t addr, uint16_t* const data, const uint8_t num, const apalTime_t timeout)
+    {
       apalDbgAssert(ina219 != NULL);
       apalDbgAssert(ina219->i2cd != NULL);
-...
      * @param[in]   timeout     timeout
      * @return                  An indicator whether the call was successfull
      */
     inline apalExitStatus_t
     ina219_lld_write_register(const INA219Driver* const ina219, const ina219_lld_register_t addr, const uint16_t* const data, const uint8_t num, const apalTime_t timeout)
     apalExitStatus_t ina219_lld_write_register(const INA219Driver* const ina219, const ina219_lld_register_t addr, const uint16_t* const data, const uint8_t num, const apalTime_t timeout)
+    {
       apalDbgAssert(ina219 != NULL);
       apalDbgAssert(ina219->i2cd != NULL);
-...
      * @param[in]   timeout     timeout
      * @return                  An indicator whether the call was successfull
      */
     inline apalExitStatus_t
     ina219_lld_calibration(INA219Driver* const ina219, const ina219_lld_calib_input_t* const calib_in, ina219_lld_calib_output_t* const calib_out)
     apalExitStatus_t ina219_lld_calibration(INA219Driver* const ina219, const ina219_lld_calib_input_t* const calib_in, ina219_lld_calib_output_t* const calib_out)
+    {
       apalDbgAssert(ina219 != NULL);
       apalDbgAssert(calib_in != NULL);
-...
      * @param[in]   timeout     timeout
      * @return                  An indicator whether the call was successfull
      */
     inline apalExitStatus_t
     ina219_lld_read_config(const INA219Driver* const ina219, ina219_lld_cfg_t* const cfg, const apalTime_t timeout)
     apalExitStatus_t ina219_lld_read_config(const INA219Driver* const ina219, ina219_lld_cfg_t* const cfg, const apalTime_t timeout)
+    {
       apalDbgAssert(ina219 != NULL);
       apalDbgAssert(cfg != NULL);
-...
      * @param[in]   timeout     timeout
      * @return                  An indicator whether the call was successfull
      */
     inline apalExitStatus_t
     ina219_lld_write_config(const INA219Driver* const ina219, ina219_lld_cfg_t cfg, const apalTime_t timeout)
     apalExitStatus_t ina219_lld_write_config(const INA219Driver* const ina219, ina219_lld_cfg_t cfg, const apalTime_t timeout)
+    {
       apalDbgAssert(ina219 != NULL);
-...
      * @param[in]   timeout     timeout
      * @return                  An indicator whether the call was successfull
      */
     inline apalExitStatus_t
     ina219_lld_read_calibration(const INA219Driver* const ina219, uint16_t* const calib, const apalTime_t timeout)
     apalExitStatus_t ina219_lld_read_calibration(const INA219Driver* const ina219, uint16_t* const calib, const apalTime_t timeout)
+    {
       apalDbgAssert(ina219 != NULL);
       apalDbgAssert(calib != NULL);
-...
      * @param[in]   timeout     timeout
      * @return                  An indicator whether the call was successfull
      */
     inline apalExitStatus_t
     ina219_lld_write_calibration(const INA219Driver* const ina219, const uint16_t calib, const apalTime_t timeout)
     apalExitStatus_t ina219_lld_write_calibration(const INA219Driver* const ina219, const uint16_t calib, const apalTime_t timeout)
+    {
       apalDbgAssert(ina219 != NULL);
-...
      * @param[in]   timeout     timeout
      * @return                  An indicator whether the call was successfull
      */
     inline apalExitStatus_t
     ina219_lld_reset(const INA219Driver* const ina219, const apalTime_t timeout)
     apalExitStatus_t ina219_lld_reset(const INA219Driver* const ina219, const apalTime_t timeout)
+    {
       apalDbgAssert(ina219 != NULL);
-...
      * @param[in]   timeout     timeout
      * @return                  An indicator whether the call was successfull
      */
     inline apalExitStatus_t
     ina219_lld_read_shunt_voltage(const INA219Driver* const ina219, int32_t* const data, const apalTime_t timeout)
     apalExitStatus_t ina219_lld_read_shunt_voltage(const INA219Driver* const ina219, int32_t* const data, const apalTime_t timeout)
+    {
       apalDbgAssert(ina219 != NULL);
       apalDbgAssert(data != NULL);
-...
      * @param[in]   timeout     timeout
      * @return                  An indicator whether the call was successfull
      */
     inline apalExitStatus_t
     ina219_lld_read_bus_voltage(const INA219Driver* const ina219, uint32_t* const data, const apalTime_t timeout)
     apalExitStatus_t ina219_lld_read_bus_voltage(const INA219Driver* const ina219, uint32_t* const data, const apalTime_t timeout)
+    {
       apalDbgAssert(ina219 != NULL);
       apalDbgAssert(data != NULL);
-...
      * @param[in]   timeout     timeout
      * @return                  An indicator whether the call was successfull
      */
     inline apalExitStatus_t
     ina219_lld_read_power(const INA219Driver* const ina219, uint32_t* const data, const apalTime_t timeout)
     apalExitStatus_t ina219_lld_read_power(const INA219Driver* const ina219, uint32_t* const data, const apalTime_t timeout)
+    {
       apalDbgAssert(ina219 != NULL);
       apalDbgAssert(data != NULL);
-...
      * @param[in]   timeout     timeout
      * @return                  An indicator whether the call was successfull
      */
     inline apalExitStatus_t
     ina219_lld_read_current(const INA219Driver* const ina219, int16_t* const data, const apalTime_t timeout)
     apalExitStatus_t ina219_lld_read_current(const INA219Driver* const ina219, int16_t* const data, const apalTime_t timeout)
+    {
       apalDbgAssert(ina219 != NULL);
       apalDbgAssert(data != NULL);
-...
      * @param[in]   timeout     timeout
      * @return                  An indicator whether the call was successfull
      */
     inline apalExitStatus_t
     ina219_lld_bus_conversion_ready(const INA219Driver* const ina219, uint16_t* const buscnv, const apalTime_t timeout)
     apalExitStatus_t ina219_lld_bus_conversion_ready(const INA219Driver* const ina219, uint16_t* const buscnv, const apalTime_t timeout)
+    {
       apalDbgAssert(ina219 != NULL);
       apalDbgAssert(buscnv != NULL);

source/alld_l3g4200d.c
63	63	*
64	64	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
65	65	*/
66		inline apalExitStatus_t
67		l3g4200d_lld_read_register(const L3G4200DDriver* const l3gd, const l3g4200d_lld_register_t regaddr, uint8_t* const data, const uint8_t length)
	66	apalExitStatus_t l3g4200d_lld_read_register(const L3G4200DDriver* const l3gd, const l3g4200d_lld_register_t regaddr, uint8_t* const data, const uint8_t length)
68	67	{
69	68	apalDbgAssert(l3gd != NULL && l3gd->spid != NULL);
70	69	apalDbgAssert(data != NULL);
...	...
85	84	*
86	85	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
87	86	*/
88		inline apalExitStatus_t
89		l3g4200d_lld_write_register(const L3G4200DDriver* const l3gd, const l3g4200d_lld_register_t regaddr, const uint8_t* const data, const uint8_t length)
	87	apalExitStatus_t l3g4200d_lld_write_register(const L3G4200DDriver* const l3gd, const l3g4200d_lld_register_t regaddr, const uint8_t* const data, const uint8_t length)
90	88	{
91	89	apalDbgAssert(l3gd != NULL && l3gd->spid != NULL);
92	90	apalDbgAssert(data != NULL);
...	...
105	103	*
106	104	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
107	105	*/
108		inline apalExitStatus_t
109		l3g4200d_lld_read_all_data(const L3G4200DDriver* const l3gd, int16_t* const data, const l3g4200d_lld_cfg_t* const cfg)
	106	apalExitStatus_t l3g4200d_lld_read_all_data(const L3G4200DDriver* const l3gd, int16_t* const data, const l3g4200d_lld_cfg_t* const cfg)
110	107	{
111	108	apalDbgAssert(data != NULL);
112	109	apalDbgAssert(cfg != NULL);
...	...
134	131	*
135	132	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
136	133	*/
137		inline apalExitStatus_t
138		l3g4200d_lld_read_data(const L3G4200DDriver* const l3gd, int16_t* const data, const l3g4200d_lld_axis_t axis, const l3g4200d_lld_cfg_t* const cfg)
	134	apalExitStatus_t l3g4200d_lld_read_data(const L3G4200DDriver* const l3gd, int16_t* const data, const l3g4200d_lld_axis_t axis, const l3g4200d_lld_cfg_t* const cfg)
139	135	{
140	136	apalDbgAssert(data != NULL);
141	137	apalDbgAssert(cfg != NULL);
...	...
171	167	*
172	168	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
173	169	*/
174		inline apalExitStatus_t
175		l3g4200d_lld_read_config(const L3G4200DDriver* const l3gd, l3g4200d_lld_cfg_t* const cfg)
	170	apalExitStatus_t l3g4200d_lld_read_config(const L3G4200DDriver* const l3gd, l3g4200d_lld_cfg_t* const cfg)
176	171	{
177	172	apalDbgAssert(cfg != NULL);
178	173
...	...
186	181	*
187	182	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
188	183	*/
189		inline apalExitStatus_t
190		l3g4200d_lld_write_config(const L3G4200DDriver* const l3gd, const l3g4200d_lld_cfg_t cfg)
	184	apalExitStatus_t l3g4200d_lld_write_config(const L3G4200DDriver* const l3gd, const l3g4200d_lld_cfg_t cfg)
191	185	{
192	186	return l3g4200d_lld_write_register(l3gd, L3G4200D_LLD_REGISTER_CTRL_REG1, cfg.data, 5);
193	187	}
...	...
199	193	*
200	194	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
201	195	*/
202		inline apalExitStatus_t
203		l3g4200d_lld_read_int_config(const L3G4200DDriver* const l3gd, l3g4200d_lld_int_cfg_t* const cfg)
	196	apalExitStatus_t l3g4200d_lld_read_int_config(const L3G4200DDriver* const l3gd, l3g4200d_lld_int_cfg_t* const cfg)
204	197	{
205	198	apalDbgAssert(cfg != NULL);
206	199
...	...
214	207	*
215	208	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
216	209	*/
217		inline apalExitStatus_t
218		l3g4200d_lld_write_int_config(const L3G4200DDriver* const l3gd, const l3g4200d_lld_int_cfg_t cfg)
	210	apalExitStatus_t l3g4200d_lld_write_int_config(const L3G4200DDriver* const l3gd, const l3g4200d_lld_int_cfg_t cfg)
219	211	{
220	212	apalExitStatus_t status = l3g4200d_lld_write_register(l3gd, L3G4200D_LLD_REGISTER_INT1_CFG, cfg.data, 1);
221	213	if (status != APAL_STATUS_OK) {
...	...
231	223	*
232	224	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
233	225	*/
234		inline apalExitStatus_t
235		l3g4200d_lld_read_status_register(const L3G4200DDriver* const l3gd, uint8_t* const status)
	226	apalExitStatus_t l3g4200d_lld_read_status_register(const L3G4200DDriver* const l3gd, uint8_t* const status)
236	227	{
237	228	apalDbgAssert(status != NULL);
238	229
...	...
261	252	*
262	253	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
263	254	*/
264		inline apalExitStatus_t
265		l3g4200d_lld_write_fifo_ctrl_register(const L3G4200DDriver* const l3gd, const uint8_t fifo)
	255	apalExitStatus_t l3g4200d_lld_write_fifo_ctrl_register(const L3G4200DDriver* const l3gd, const uint8_t fifo)
266	256	{
267	257	return l3g4200d_lld_write_register(l3gd, L3G4200D_LLD_REGISTER_FIFO_CTRL_REG, &fifo, 1);
268	258	}
...	...
274	264	*
275	265	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
276	266	*/
277		inline apalExitStatus_t
278		l3g4200d_lld_read_fifo_src_register(const L3G4200DDriver* const l3gd, uint8_t* const fifo)
	267	apalExitStatus_t l3g4200d_lld_read_fifo_src_register(const L3G4200DDriver* const l3gd, uint8_t* const fifo)
279	268	{
280	269	apalDbgAssert(fifo != NULL);
281	270
...	...
289	278	*
290	279	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
291	280	*/
292		inline apalExitStatus_t
293		l3g4200d_lld_read_int_src(const L3G4200DDriver* const l3gd, uint8_t* const cfg)
	281	apalExitStatus_t l3g4200d_lld_read_int_src(const L3G4200DDriver* const l3gd, uint8_t* const cfg)
294	282	{
295	283	apalDbgAssert(cfg != NULL);
296	284

      * @param[in]   led_state   The state to set the LED to.
      * @return                  An indicator whether the call was successful.
      */
     inline apalExitStatus_t
     led_lld_set(const LEDDriver* const led, const led_lld_state_t state)
     apalExitStatus_t led_lld_set(const LEDDriver* const led, const led_lld_state_t state)
+    {
       apalDbgAssert(led != NULL);
-...
      * @param[out]  led_state   The state object to fill.
      * @return                  An indicator whether the call was successful.
      */
     inline apalExitStatus_t
     led_lld_get(const LEDDriver* const led, led_lld_state_t* const state)
     apalExitStatus_t led_lld_get(const LEDDriver* const led, led_lld_state_t* const state)
+    {
       apalDbgAssert(led != NULL);
       apalDbgAssert(state != NULL);
-...
      * @param[in]   ledp        The LED driver object.
      * @return                  An indicator whether the call was successful.
      */
     inline apalExitStatus_t
     led_lld_toggle(const LEDDriver* const led)
     apalExitStatus_t led_lld_toggle(const LEDDriver* const led)
+    {
       apalDbgAssert(led != NULL);

source/alld_lis331dlh.c
63	63	*
64	64	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
65	65	*/
66		inline apalExitStatus_t
67		lis331dlh_lld_read_register(const LIS331DLHDriver* const lisd, const lis331dlh_lld_register_t regaddr, uint8_t *data, const uint8_t length)
	66	apalExitStatus_t lis331dlh_lld_read_register(const LIS331DLHDriver* const lisd, const lis331dlh_lld_register_t regaddr, uint8_t *data, const uint8_t length)
68	67	{
69	68	apalDbgAssert(lisd != NULL && lisd->spid != NULL);
70	69	apalDbgAssert(data != NULL);
...	...
85	84	*
86	85	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
87	86	*/
88		inline apalExitStatus_t
89		lis331dlh_lld_write_register(const LIS331DLHDriver* const lisd, const lis331dlh_lld_register_t regaddr, const uint8_t *data, const uint8_t length)
	87	apalExitStatus_t lis331dlh_lld_write_register(const LIS331DLHDriver* const lisd, const lis331dlh_lld_register_t regaddr, const uint8_t *data, const uint8_t length)
90	88	{
91	89	apalDbgAssert(lisd != NULL && lisd->spid != NULL);
92	90	apalDbgAssert(data != NULL);
...	...
103	101	*
104	102	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
105	103	*/
106		inline apalExitStatus_t
107		lis331dlh_lld_reset_hp_filter(const LIS331DLHDriver* const lisd)
	104	apalExitStatus_t lis331dlh_lld_reset_hp_filter(const LIS331DLHDriver* const lisd)
108	105	{
109	106	return lis331dlh_lld_read_register(lisd, LIS331DLH_LLD_REGISTER_HP_FILTER_RESET, NULL, 0);
110	107	}
...	...
117	114	*
118	115	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
119	116	*/
120		inline apalExitStatus_t
121		lis331dlh_lld_read_all_data(const LIS331DLHDriver* const lisd, int16_t data, const lis331dlh_lld_cfg_t cfg)
	117	apalExitStatus_t lis331dlh_lld_read_all_data(const LIS331DLHDriver* const lisd, int16_t data, const lis331dlh_lld_cfg_t cfg)
122	118	{
123	119	apalDbgAssert(data != NULL);
124	120	apalDbgAssert(cfg != NULL);
...	...
146	142	*
147	143	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
148	144	*/
149		inline apalExitStatus_t
150		lis331dlh_lld_read_data(const LIS331DLHDriver* const lisd, int16_t data, const lis331dlh_lld_axis_t axis, const lis331dlh_lld_cfg_t cfg)
	145	apalExitStatus_t lis331dlh_lld_read_data(const LIS331DLHDriver* const lisd, int16_t data, const lis331dlh_lld_axis_t axis, const lis331dlh_lld_cfg_t cfg)
151	146	{
152	147	apalDbgAssert(data != NULL);
153	148	apalDbgAssert(cfg != NULL);
...	...
183	178	*
184	179	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
185	180	*/
186		inline apalExitStatus_t
187		lis331dlh_lld_read_config(const LIS331DLHDriver* const lisd, lis331dlh_lld_cfg_t *cfg)
	181	apalExitStatus_t lis331dlh_lld_read_config(const LIS331DLHDriver* const lisd, lis331dlh_lld_cfg_t *cfg)
188	182	{
189	183	apalDbgAssert(cfg != NULL);
190	184
...	...
198	192	*
199	193	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
200	194	*/
201		inline apalExitStatus_t
202		lis331dlh_lld_write_config(const LIS331DLHDriver* const lisd, const lis331dlh_lld_cfg_t *cfg)
	195	apalExitStatus_t lis331dlh_lld_write_config(const LIS331DLHDriver* const lisd, const lis331dlh_lld_cfg_t *cfg)
203	196	{
204	197	apalDbgAssert(cfg != NULL);
205	198
...	...
214	207	*
215	208	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
216	209	*/
217		inline apalExitStatus_t
218		lis331dlh_lld_read_int_config(const LIS331DLHDriver* const lisd, lis331dlh_lld_int_cfg_t *cfg, const lis331dlh_lld_int_t interrupt)
	210	apalExitStatus_t lis331dlh_lld_read_int_config(const LIS331DLHDriver* const lisd, lis331dlh_lld_int_cfg_t *cfg, const lis331dlh_lld_int_t interrupt)
219	211	{
220	212	apalDbgAssert(cfg != NULL);
221	213
...	...
244	236	*
245	237	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
246	238	*/
247		inline apalExitStatus_t
248		lis331dlh_lld_write_int_config(const LIS331DLHDriver* const lisd, const lis331dlh_lld_int_cfg_t *cfg, const lis331dlh_lld_int_t interrupt)
	239	apalExitStatus_t lis331dlh_lld_write_int_config(const LIS331DLHDriver* const lisd, const lis331dlh_lld_int_cfg_t *cfg, const lis331dlh_lld_int_t interrupt)
249	240	{
250	241	apalDbgAssert(cfg != NULL);
251	242
...	...
270	261	*
271	262	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
272	263	*/
273		inline apalExitStatus_t
274		lis331dlh_lld_read_status_register(const LIS331DLHDriver* const lisd, uint8_t *status)
	264	apalExitStatus_t lis331dlh_lld_read_status_register(const LIS331DLHDriver* const lisd, uint8_t *status)
275	265	{
276	266	apalDbgAssert(status != NULL);
277	267

      * @param[out]  pinstate    current value of the gpio pin
      * @return                  An indicator whether the call was successfull
      */
     inline apalExitStatus_t
     ltc4412_lld_get_ctrl(const LTC4412Driver* const ltc4412, ltc4412_lld_ctrl_t* const ctrl)
     apalExitStatus_t ltc4412_lld_get_ctrl(const LTC4412Driver* const ltc4412, ltc4412_lld_ctrl_t* const ctrl)
+    {
       apalDbgAssert(ltc4412 != NULL);
       apalDbgAssert(ctrl != NULL);
-...
      * @param[in]   ctrl        new value of the gpio pin
      * @return                  An indicator whether the call was successfull
      */
     inline apalExitStatus_t
     ltc4412_lld_set_ctrl(const LTC4412Driver* const ltc4412, const ltc4412_lld_ctrl_t ctrl)
     apalExitStatus_t ltc4412_lld_set_ctrl(const LTC4412Driver* const ltc4412, const ltc4412_lld_ctrl_t ctrl)
+    {
       apalDbgAssert(ltc4412 != NULL);
-...
      * @param[out]  pinstate    current value of the gpio pin
      * @return                  An indicator whether the call was successfull
      */
     inline apalExitStatus_t
     ltc4412_lld_get_stat(const LTC4412Driver* const ltc4412, ltc4412_lld_stat_t* const stat)
     apalExitStatus_t ltc4412_lld_get_stat(const LTC4412Driver* const ltc4412, ltc4412_lld_stat_t* const stat)
+    {
       apalDbgAssert(ltc4412 != NULL);
       apalDbgAssert(stat != NULL);

source/alld_mpr121.c
65	65	*
66	66	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
67	67	*/
68		inline apalExitStatus_t
69		mpr121_lld_read_register(const MPR121Driver* const mprd, const mpr121_lld_register_t regaddr, const uint8_t offset, const uint8_t size, uint8_t* const data, const apalTime_t timeout)
	68	apalExitStatus_t mpr121_lld_read_register(const MPR121Driver* const mprd, const mpr121_lld_register_t regaddr, const uint8_t offset, const uint8_t size, uint8_t* const data, const apalTime_t timeout)
70	69	{
71	70	apalDbgAssert(mprd != NULL && mprd->i2cd != NULL);
72	71	apalDbgAssert(data != NULL);
...	...
86	85	*
87	86	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
88	87	*/
89		inline apalExitStatus_t
90		mpr121_lld_write_register(const MPR121Driver* const mprd, const mpr121_lld_register_t regaddr, const uint8_t offset, const uint8_t size, const uint8_t* const data, const apalTime_t timeout)
	88	apalExitStatus_t mpr121_lld_write_register(const MPR121Driver* const mprd, const mpr121_lld_register_t regaddr, const uint8_t offset, const uint8_t size, const uint8_t* const data, const apalTime_t timeout)
91	89	{
92	90	apalDbgAssert(mprd != NULL && mprd->i2cd != NULL);
93	91	apalDbgAssert(data != NULL);
...	...
105	103	*
106	104	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
107	105	*/
108		inline apalExitStatus_t
109		mpr121_lld_soft_reset(const MPR121Driver* const mprd, const apalTime_t timeout)
	106	apalExitStatus_t mpr121_lld_soft_reset(const MPR121Driver* const mprd, const apalTime_t timeout)
110	107	{
111	108	apalDbgAssert(mprd != NULL && mprd->i2cd != NULL);
112	109
...	...
124	121	*
125	122	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
126	123	*/
127		inline apalExitStatus_t
128		mpr121_lld_read_filtered_data(const MPR121Driver* const mprd, const uint8_t index, const uint8_t num, uint16_t* const data, const apalTime_t timeout)
	124	apalExitStatus_t mpr121_lld_read_filtered_data(const MPR121Driver* const mprd, const uint8_t index, const uint8_t num, uint16_t* const data, const apalTime_t timeout)
129	125	{
130	126	apalDbgAssert(data != NULL);
131	127
...	...
147	143	*
148	144	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
149	145	*/
150		inline apalExitStatus_t
151		mpr121_lld_read_baseline_data(const MPR121Driver* const mprd, const uint8_t index, const uint8_t num, uint8_t* const data, const apalTime_t timeout)
	146	apalExitStatus_t mpr121_lld_read_baseline_data(const MPR121Driver* const mprd, const uint8_t index, const uint8_t num, uint8_t* const data, const apalTime_t timeout)
152	147	{
153	148	return mpr121_lld_read_register(mprd, MPR121_LLD_REGISTER_BASELINE, index, num, data, timeout);
154	149	}
...	...
163	158	*
164	159	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
165	160	*/
166		inline apalExitStatus_t
167		mpr121_lld_read_electrode_data(const MPR121Driver* const mprd, const uint8_t index, const uint8_t num, uint8_t* const data, const apalTime_t timeout)
	161	apalExitStatus_t mpr121_lld_read_electrode_data(const MPR121Driver* const mprd, const uint8_t index, const uint8_t num, uint8_t* const data, const apalTime_t timeout)
168	162	{
169	163	return mpr121_lld_read_register(mprd, MPR121_LLD_REGISTER_ELE_CURRENT, index, num, data, timeout);
170	164	}
...	...
177	171	*
178	172	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
179	173	*/
180		inline apalExitStatus_t
181		mpr121_lld_write_config(const MPR121Driver* const mprd, const mpr121_lld_config_t cfg, const apalTime_t timeout)
	174	apalExitStatus_t mpr121_lld_write_config(const MPR121Driver* const mprd, const mpr121_lld_config_t cfg, const apalTime_t timeout)
182	175	{
183	176	const apalExitStatus_t status = mpr121_lld_write_register(mprd, MPR121_LLD_REGISTER_AUTOCFG_CTRL_0, 0, 5, cfg.values, timeout);
184	177	if (status != APAL_STATUS_OK) {
...	...
196	189	*
197	190	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
198	191	*/
199		inline apalExitStatus_t
200		mpr121_lld_read_config(const MPR121Driver* const mprd, mpr121_lld_config_t* const cfg, const apalTime_t timeout)
	192	apalExitStatus_t mpr121_lld_read_config(const MPR121Driver* const mprd, mpr121_lld_config_t* const cfg, const apalTime_t timeout)
201	193	{
202	194	const apalExitStatus_t status = mpr121_lld_read_register(mprd, MPR121_LLD_REGISTER_AUTOCFG_CTRL_0, 0, 5, cfg->values, timeout);
203	195	if (status != APAL_STATUS_OK) {

source/alld_pca9544a.c
61	61	*
62	62	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
63	63	*/
64		inline apalExitStatus_t
65		pca9544a_lld_read(const PCA9544ADriver* const pca9544a, uint8_t* const data, const apalTime_t timeout)
	64	apalExitStatus_t pca9544a_lld_read(const PCA9544ADriver* const pca9544a, uint8_t* const data, const apalTime_t timeout)
66	65	{
67	66	apalDbgAssert(pca9544a != NULL);
68	67	apalDbgAssert(data != NULL);
...	...
79	78	*
80	79	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
81	80	*/
82		inline apalExitStatus_t
83		pca9544a_lld_write(const PCA9544ADriver* const pca9544a, const uint8_t data, const apalTime_t timeout)
	81	apalExitStatus_t pca9544a_lld_write(const PCA9544ADriver* const pca9544a, const uint8_t data, const apalTime_t timeout)
84	82	{
85	83	apalDbgAssert(pca9544a != NULL);
86	84
...	...
96	94	*
97	95	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
98	96	*/
99		inline apalExitStatus_t
100		pca9544a_lld_getintstatus(const PCA9544ADriver* const pca9544a, pca9544a_lld_intstatus_t* const status, const apalTime_t timeout)
	97	apalExitStatus_t pca9544a_lld_getintstatus(const PCA9544ADriver* const pca9544a, pca9544a_lld_intstatus_t* const status, const apalTime_t timeout)
101	98	{
102	99	apalDbgAssert(pca9544a != NULL);
103	100	apalDbgAssert(status != NULL);
...	...
117	114	*
118	115	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
119	116	*/
120		inline apalExitStatus_t
121		pca9544a_lld_getcurrentchannel(const PCA9544ADriver* const pca9544a, pca9544a_lld_chid_t* const channel, const apalTime_t timeout)
	117	apalExitStatus_t pca9544a_lld_getcurrentchannel(const PCA9544ADriver* const pca9544a, pca9544a_lld_chid_t* const channel, const apalTime_t timeout)
122	118	{
123	119	apalDbgAssert(pca9544a != NULL);
124	120	apalDbgAssert(channel != NULL);
...	...
142	138	*
143	139	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
144	140	*/
145		inline apalExitStatus_t
146		pca9544a_lld_setchannel(const PCA9544ADriver* const pca9544a, const pca9544a_lld_chid_t channel, const apalTime_t timeout)
	141	apalExitStatus_t pca9544a_lld_setchannel(const PCA9544ADriver* const pca9544a, const pca9544a_lld_chid_t channel, const apalTime_t timeout)
147	142	{
148	143	apalDbgAssert(pca9544a != NULL);
149	144

     /* LOCAL DEFINITIONS                                                          */
     /******************************************************************************/
     #define _MAXIMUM_GROUP_SIZE           6
     #define _MAXIMUM_GROUP_SIZE                     6
     /******************************************************************************/
     /* EXPORTED VARIABLES                                                         */
-...
+     *
      * @return    The size of the group in bytes.
      */
     inline uint8_t pcal6524_lld_cmd_groupsize(const pcal6524_lld_cmd_t cmd)
     uint8_t pcal6524_lld_cmd_groupsize(const pcal6524_lld_cmd_t cmd)
+    {
       switch (cmd) {
         case PCAL6524_LLD_CMD_OUTPUTCONFIGURATION:
-...
     // *
     // * @return    Indicator whether the function call was successful or a timeout occurred.
     // */
     //inline apalExitStatus_t
     //pcal6524_lld_read_id(const PCAL6524Driver* const pcal6524d, pcal6524_lld_deviceid_t* const info, const apalTime_t timeout)
     //apalExitStatus_t pcal6524_lld_read_id(const PCAL6524Driver* const pcal6524d, pcal6524_lld_deviceid_t* const info, const apalTime_t timeout)
     //{
     //  apalDbgAssert(pcal6524d != NULL && pcal6524d->i2cd != NULL);
     //  apalDbgAssert(info != NULL);
-...
+     *
      * @return    Indicator whether the function call was successful or a timeout occurred.
      */
     inline apalExitStatus_t
     pcal6524_lld_read_reg(const PCAL6524Driver* const pcal6524d, const pcal6524_lld_cmd_t reg, uint8_t* const data, const apalTime_t timeout)
     apalExitStatus_t pcal6524_lld_read_reg(const PCAL6524Driver* const pcal6524d, const pcal6524_lld_cmd_t reg, uint8_t* const data, const apalTime_t timeout)
+    {
       apalDbgAssert(pcal6524d != NULL && pcal6524d->i2cd != NULL);
       apalDbgAssert(data != NULL);
-...
+     *
      * @return    Indicator whether the function call was successful or a timeout occurred.
      */
     inline apalExitStatus_t
     pcal6524_lld_write_reg(const PCAL6524Driver* const pcal6524d, const pcal6524_lld_cmd_t reg, const uint8_t data, const apalTime_t timeout)
     apalExitStatus_t pcal6524_lld_write_reg(const PCAL6524Driver* const pcal6524d, const pcal6524_lld_cmd_t reg, const uint8_t data, const apalTime_t timeout)
+    {
       apalDbgAssert(pcal6524d != NULL && pcal6524d->i2cd != NULL);
-...
+     *
      * @return    Indicator whether the function call was successful or a timeout occurred.
      */
     inline apalExitStatus_t
     pcal6524_lld_read_group(const PCAL6524Driver* const pcal6524d, const pcal6524_lld_cmd_t reg, uint8_t* const data, const apalTime_t timeout)
     apalExitStatus_t pcal6524_lld_read_group(const PCAL6524Driver* const pcal6524d, const pcal6524_lld_cmd_t reg, uint8_t* const data, const apalTime_t timeout)
+    {
       apalDbgAssert(pcal6524d != NULL && pcal6524d->i2cd != NULL);
       apalDbgAssert(data != NULL);
-...
+     *
      * @return    Indicator whether the function call was successful or a timeout occurred.
      */
     inline apalExitStatus_t
     pcal6524_lld_write_group(const PCAL6524Driver* const pcal6524d, const pcal6524_lld_cmd_t reg, const uint8_t* const data, const apalTime_t timeout)
     apalExitStatus_t pcal6524_lld_write_group(const PCAL6524Driver* const pcal6524d, const pcal6524_lld_cmd_t reg, const uint8_t* const data, const apalTime_t timeout)
+    {
       apalDbgAssert(pcal6524d != NULL && pcal6524d->i2cd != NULL);
       apalDbgAssert(data != NULL);
-...
+     *
      * @return    Indicator whether the function call was successful or a timeout occurred.
      */
     inline apalExitStatus_t
     pcal6524_lld_read_continuous(const PCAL6524Driver* const pcal6524d, const pcal6524_lld_cmd_t reg, uint8_t* const data, const uint8_t length, const apalTime_t timeout)
     apalExitStatus_t pcal6524_lld_read_continuous(const PCAL6524Driver* const pcal6524d, const pcal6524_lld_cmd_t reg, uint8_t* const data, const uint8_t length, const apalTime_t timeout)
+    {
       apalDbgAssert(pcal6524d != NULL && pcal6524d->i2cd != NULL);
       apalDbgAssert(data != NULL);
-...
+     *
      * @return    Indicator whether the function call was successful or a timeout occurred.
      */
     inline apalExitStatus_t
     pcal6524_lld_write_continuous(const PCAL6524Driver* const pcal6524d, const pcal6524_lld_cmd_t reg, const uint8_t* const data, const uint8_t length, const apalTime_t timeout)
     apalExitStatus_t pcal6524_lld_write_continuous(const PCAL6524Driver* const pcal6524d, const pcal6524_lld_cmd_t reg, const uint8_t* const data, const uint8_t length, const apalTime_t timeout)
+    {
       apalDbgAssert(pcal6524d != NULL && pcal6524d->i2cd != NULL);
       apalDbgAssert(data != NULL);

      * @param[in] pwm   The PWM driver to check.
      * @return  The return status indicates whether the function call was successful.
      */
     inline apalExitStatus_t
     pklcs1212e4001_lld_checkPWMconfiguration(apalPWMDriver_t* pwm)
     apalExitStatus_t pklcs1212e4001_lld_checkPWMconfiguration(apalPWMDriver_t* pwm)
+    {
       apalDbgAssert(pwm != NULL);
-...
      * @param[in] enable    Specifies whether the buzzer shall be turned on (true) or off (false).
      * @return  The return status indicates whether the function call was successful.
      */
     inline apalExitStatus_t
     pklcs1212e4001_lld_enable(apalPWMDriver_t* pwm, const apalPWMchannel_t channel, const bool enable)
     apalExitStatus_t pklcs1212e4001_lld_enable(apalPWMDriver_t* pwm, const apalPWMchannel_t channel, const bool enable)
+    {
       apalDbgAssert(pwm != NULL);

      * @param[in] blank     The state to set the TLC5947 driver to.
      * @return              An indicator whether the call was successful.
      */
     inline apalExitStatus_t
     tlc5947_lld_setBlank(const TLC5947Driver* const tlc5947, const tlc5947_lld_blank_t blank)
     apalExitStatus_t tlc5947_lld_setBlank(const TLC5947Driver* const tlc5947, const tlc5947_lld_blank_t blank)
+    {
       apalDbgAssert(tlc5947 != NULL);
-...
      * @param[out] blank    The state object to fill.
      * @return              An indicator whether the call was successful.
      */
     inline apalExitStatus_t
     tlc5947_lld_getBlank(const TLC5947Driver* const tlc5947, tlc5947_lld_blank_t* const blank)
     apalExitStatus_t tlc5947_lld_getBlank(const TLC5947Driver* const tlc5947, tlc5947_lld_blank_t* const blank)
+    {
       apalDbgAssert(tlc5947 != NULL);
       apalDbgAssert(blank != NULL);
-...
      * @brief Write buffer via SPI to the TLC5947.
      * @return                  An indicator whether the call was successful.
      */
     inline apalExitStatus_t
     tlc5947_lld_write(const TLC5947Driver* const tlc5947, const tlc5947_lld_buffer_t* const buffer)
     apalExitStatus_t tlc5947_lld_write(const TLC5947Driver* const tlc5947, const tlc5947_lld_buffer_t* const buffer)
+    {
       apalDbgAssert(tlc5947 != NULL);
       apalDbgAssert(buffer != NULL);
-...
      *                      Must be a 12bit value.
      * @return              An indicator whether the call was successful.
      */
     inline void
     tlc5947_lld_setBuffer(tlc5947_lld_buffer_t* const buffer, const uint8_t channel, const uint16_t value)
     void tlc5947_lld_setBuffer(tlc5947_lld_buffer_t* const buffer, const uint8_t channel, const uint16_t value)
+    {
       apalDbgAssert(buffer != NULL);
       apalDbgAssert(channel < TLC5947_LLD_NUM_CHANNELS);
-...
      * @param[in] channel   The channel to read
      * @return              An indicator whether the call was successful.
      */
     inline uint16_t
     tlc5947_lld_getBuffer(const tlc5947_lld_buffer_t* const buffer, const uint8_t channel)
     uint16_t tlc5947_lld_getBuffer(const tlc5947_lld_buffer_t* const buffer, const uint8_t channel)
+    {
       apalDbgAssert(buffer != NULL);
       apalDbgAssert(channel < TLC5947_LLD_NUM_CHANNELS);

      * @param[in]   enable      new state of the pin
      * @return                  An indicator whether the call was successfull
      */
     inline apalExitStatus_t
     tps2051b_lld_set_enable(const TPS2051BDriver* const tps2051b, const tps2051b_lld_enable_t enable)
     apalExitStatus_t tps2051b_lld_set_enable(const TPS2051BDriver* const tps2051b, const tps2051b_lld_enable_t enable)
+    {
       apalDbgAssert(tps2051b != NULL);
-...
      * @param[out]  enable      state of the enable pin
      * @return                  An indicator whether the call was successfull
      */
     inline apalExitStatus_t
     tps2051b_lld_read_enable(const TPS2051BDriver* const tps2051b, tps2051b_lld_enable_t* const enable)
     apalExitStatus_t tps2051b_lld_read_enable(const TPS2051BDriver* const tps2051b, tps2051b_lld_enable_t* const enable)
+    {
       apalDbgAssert(tps2051b != NULL);
       apalDbgAssert(enable != NULL);
-...
      * @param[out]  oc          state of the overcurrent pin
      * @return                  An indicator whether the call was successfull
      */
     inline apalExitStatus_t
     tps2051b_lld_read_overcurrent(const TPS2051BDriver* const tps2051b, tps2051b_lld_overcurrent_t* const oc)
     apalExitStatus_t tps2051b_lld_read_overcurrent(const TPS2051BDriver* const tps2051b, tps2051b_lld_overcurrent_t* const oc)
+    {
       apalDbgAssert(tps2051b != NULL);
       apalDbgAssert(oc != NULL);

      * @param[out]  pinstate    current value of the gpio pin
      * @return                  An indicator whether the call was successfull
      */
     inline apalExitStatus_t
     tps62113_lld_get_power_en(const TPS62113Driver* const tps62113, tps62113_lld_power_en_t* const power)
     apalExitStatus_t tps62113_lld_get_power_en(const TPS62113Driver* const tps62113, tps62113_lld_power_en_t* const power)
+    {
       apalDbgAssert(tps62113 != NULL);
       apalDbgAssert(power != NULL);
-...
      * @param[in]   pinstate    new value of the gpio pin
      * @return                  An indicator whether the call was successfull
      */
     inline apalExitStatus_t
     tps62113_lld_set_power_en(const TPS62113Driver* const tps62113, const tps62113_lld_power_en_t power)
     apalExitStatus_t tps62113_lld_set_power_en(const TPS62113Driver* const tps62113, const tps62113_lld_power_en_t power)
+    {
       apalDbgAssert(tps62113 != NULL);

source/alld_vcnl4020.c
63	63	*
64	64	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
65	65	*/
66		inline apalExitStatus_t
67		vcnl4020_lld_readreg(const VCNL4020Driver* const vcnld, const vcnl4020_lld_regaddr_t reg, uint8_t* const data, const apalTime_t timeout)
	66	apalExitStatus_t vcnl4020_lld_readreg(const VCNL4020Driver* const vcnld, const vcnl4020_lld_regaddr_t reg, uint8_t* const data, const apalTime_t timeout)
68	67	{
69	68	apalDbgAssert(vcnld != NULL && vcnld->i2cd != NULL);
70	69	apalDbgAssert(data != NULL);
...	...
81	80	*
82	81	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
83	82	*/
84		inline apalExitStatus_t
85		vcnl4020_lld_writereg(const VCNL4020Driver* const vcnld, const vcnl4020_lld_regaddr_t reg, const uint8_t data, const apalTime_t timeout)
	83	apalExitStatus_t vcnl4020_lld_writereg(const VCNL4020Driver* const vcnld, const vcnl4020_lld_regaddr_t reg, const uint8_t data, const apalTime_t timeout)
86	84	{
87	85	apalDbgAssert(vcnld != NULL && vcnld->i2cd != NULL);
88	86
...	...
101	99	*
102	100	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
103	101	*/
104		inline apalExitStatus_t
105		vcnl4020_lld_readals(const VCNL4020Driver* const vcnld, uint16_t* const als, const apalTime_t timeout)
	102	apalExitStatus_t vcnl4020_lld_readals(const VCNL4020Driver* const vcnld, uint16_t* const als, const apalTime_t timeout)
106	103	{
107	104	apalDbgAssert(vcnld != NULL && vcnld->i2cd != NULL);
108	105	apalDbgAssert(als != NULL);
...	...
123	120	*
124	121	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
125	122	*/
126		inline apalExitStatus_t
127		vcnl4020_lld_readprox(const VCNL4020Driver* const vcnld, uint16_t* const prox, const apalTime_t timeout)
	123	apalExitStatus_t vcnl4020_lld_readprox(const VCNL4020Driver* const vcnld, uint16_t* const prox, const apalTime_t timeout)
128	124	{
129	125	apalDbgAssert(vcnld != NULL && vcnld->i2cd != NULL);
130	126	apalDbgAssert(prox != NULL);
...	...
146	142	*
147	143	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
148	144	*/
149		inline apalExitStatus_t
150		vcnl4020_lld_readalsandprox(const VCNL4020Driver* const vcnld, uint16_t* const als, uint16_t* const prox, const apalTime_t timeout)
	145	apalExitStatus_t vcnl4020_lld_readalsandprox(const VCNL4020Driver* const vcnld, uint16_t* const als, uint16_t* const prox, const apalTime_t timeout)
151	146	{
152	147	apalDbgAssert(vcnld != NULL && vcnld->i2cd != NULL);
153	148	apalDbgAssert(als != NULL);
...	...
174	169	*
175	170	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
176	171	*/
177		inline apalExitStatus_t
178		vcnl4020_lld_readlth(const VCNL4020Driver* const vcnld, uint16_t* const th, const apalTime_t timeout)
	172	apalExitStatus_t vcnl4020_lld_readlth(const VCNL4020Driver* const vcnld, uint16_t* const th, const apalTime_t timeout)
179	173	{
180	174	apalDbgAssert(vcnld != NULL && vcnld->i2cd != NULL);
181	175	apalDbgAssert(th != NULL);
...	...
196	190	*
197	191	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
198	192	*/
199		inline apalExitStatus_t
200		vcnl4020_lld_readhth(const VCNL4020Driver* const vcnld, uint16_t* const th, const apalTime_t timeout)
	193	apalExitStatus_t vcnl4020_lld_readhth(const VCNL4020Driver* const vcnld, uint16_t* const th, const apalTime_t timeout)
201	194	{
202	195	apalDbgAssert(vcnld != NULL && vcnld->i2cd != NULL);
203	196	apalDbgAssert(th != NULL);
...	...
219	212	*
220	213	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
221	214	*/
222		inline apalExitStatus_t
223		vcnl4020_lld_readth(const VCNL4020Driver* const vcnld, uint16_t* const lth, uint16_t* const hth, const apalTime_t timeout)
	215	apalExitStatus_t vcnl4020_lld_readth(const VCNL4020Driver* const vcnld, uint16_t* const lth, uint16_t* const hth, const apalTime_t timeout)
224	216	{
225	217	apalDbgAssert(vcnld != NULL && vcnld->i2cd != NULL);
226	218	apalDbgAssert(lth != NULL);
...	...
243	235	*
244	236	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
245	237	*/
246		inline apalExitStatus_t
247		vcnl4020_lld_writelth(const VCNL4020Driver* const vcnld, const uint16_t th, const apalTime_t timeout)
	238	apalExitStatus_t vcnl4020_lld_writelth(const VCNL4020Driver* const vcnld, const uint16_t th, const apalTime_t timeout)
248	239	{
249	240	apalDbgAssert(vcnld != NULL && vcnld->i2cd != NULL);
250	241
...	...
261	252	*
262	253	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
263	254	*/
264		inline apalExitStatus_t
265		vcnl4020_lld_writehth(const VCNL4020Driver* const vcnld, const uint16_t th, const apalTime_t timeout)
	255	apalExitStatus_t vcnl4020_lld_writehth(const VCNL4020Driver* const vcnld, const uint16_t th, const apalTime_t timeout)
266	256	{
267	257	apalDbgAssert(vcnld != NULL && vcnld->i2cd != NULL);
268	258
...	...
280	270	*
281	271	* @return The return status indicates whether the function call was succesfull or a timeout occurred.
282	272	*/
283		inline apalExitStatus_t
284		vcnl4020_lld_writeth(const VCNL4020Driver* const vcnld, const uint16_t lth, const uint16_t hth, const apalTime_t timeout)
	273	apalExitStatus_t vcnl4020_lld_writeth(const VCNL4020Driver* const vcnld, const uint16_t lth, const uint16_t hth, const apalTime_t timeout)
285	274	{
286	275	apalDbgAssert(vcnld != NULL && vcnld->i2cd != NULL);
287	276

AMiRo-OS

Revision 21076167