Statistics
| Branch: | Tag: | Revision:

amiro-os / periphery-lld / periphAL.h @ 542939ea

History | View | Annotate | Download (20.6 KB)

1 e545e620 Thomas Schöpping
/*
2
AMiRo-OS is an operating system designed for the Autonomous Mini Robot (AMiRo) platform.
3 84f0ce9e Thomas Schöpping
Copyright (C) 2016..2019  Thomas Schöpping et al.
4 e545e620 Thomas Schöpping

5
This program is free software: you can redistribute it and/or modify
6
it under the terms of the GNU General Public License as published by
7
the Free Software Foundation, either version 3 of the License, or
8
(at your option) any later version.
9

10
This program is distributed in the hope that it will be useful,
11
but WITHOUT ANY WARRANTY; without even the implied warranty of
12
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
GNU General Public License for more details.
14

15
You should have received a copy of the GNU General Public License
16
along with this program.  If not, see <http://www.gnu.org/licenses/>.
17
*/
18
19 6ff06bbf Thomas Schöpping
#ifndef AMIROOS_PERIPHAL_H
20
#define AMIROOS_PERIPHAL_H
21 e545e620 Thomas Schöpping
22 3940ba8a Thomas Schöpping
#include <amiro-lld.h>
23
24 e545e620 Thomas Schöpping
/*============================================================================*/
25
/* VERSION                                                                    */
26
/*============================================================================*/
27
28
/**
29
 * @brief   The periphery abstraction layer interface major version.
30
 * @note    Changes of the major version imply incompatibilities.
31
 */
32
#define PERIPHAL_VERSION_MAJOR    1
33
34
/**
35
 * @brief   The periphery abstraction layer interface minor version.
36
 * @note    A higher minor version implies new functionalty, but all old interfaces are still available.
37
 */
38
#define PERIPHAL_VERSION_MINOR    0
39
40
/*============================================================================*/
41
/* DEPENDENCIES                                                               */
42
/*============================================================================*/
43
44 1f94ac64 Thomas Schöpping
#include <aosconf.h>
45 e545e620 Thomas Schöpping
#include <hal.h>
46
47
/*============================================================================*/
48 1f94ac64 Thomas Schöpping
/* DEBUG                                                                      */
49
/*============================================================================*/
50
51
#if (AMIROOS_CFG_DBG == true) || defined(__DOXYGEN__)
52
53 7de0cc90 Thomas Schöpping
#if defined(__cplusplus)
54 1f94ac64 Thomas Schöpping
extern "C" {
55 7de0cc90 Thomas Schöpping
#endif /* defined(__cplusplus) */
56 1f94ac64 Thomas Schöpping
  void _apalDbgAssertMsg(const bool c, const char* fmt, ...);
57
  void apalDbgPrintf(const char* fmt, ...);
58 7de0cc90 Thomas Schöpping
#if defined(__cplusplus)
59 1f94ac64 Thomas Schöpping
}
60 7de0cc90 Thomas Schöpping
#endif /* defined(__cplusplus) */
61 1f94ac64 Thomas Schöpping
62
/**
63
 * @brief Assert function to check a given condition.
64
 *
65
 * @param[in] c     The condition to check.
66
 */
67
#define apalDbgAssert(c)                                                      \
68
  _apalDbgAssertMsg(c, "%s(%u): apalDbgAssert failed", __FILE__, __LINE__);
69
70 7de0cc90 Thomas Schöpping
#else /* (AMIROOS_CFG_DBG != true) */
71 1f94ac64 Thomas Schöpping
72
#define apalDbgAssert(constition)
73
#define apalDbgAssertMsg(condition, fmt, ...)
74
#define apalDbgPrintf(fmt, ...)
75
76 7de0cc90 Thomas Schöpping
#endif /* (AMIROOS_CFG_DBG == true) */
77 1f94ac64 Thomas Schöpping
78
/*============================================================================*/
79 e545e620 Thomas Schöpping
/* GENERAL                                                                    */
80
/*============================================================================*/
81
82
/**
83
 * @brief Delay execution by a specific number of microseconds.
84
 *
85
 * @param[in]   us    Time to sleep until execution continues in microseconds.
86
 */
87
static inline void usleep(apalTime_t us)
88
{
89
  // check if the specified time can be represented by the system
90 1f94ac64 Thomas Schöpping
  apalDbgAssert(us <= chTimeI2US(TIME_INFINITE));
91 e545e620 Thomas Schöpping
92 3940ba8a Thomas Schöpping
  const sysinterval_t interval = chTimeUS2I(us);
93 e545e620 Thomas Schöpping
  // TIME_IMMEDIATE makes no sense and would even cause system halt
94 3940ba8a Thomas Schöpping
  if (interval != TIME_IMMEDIATE) {
95
    chThdSleep(interval);
96 e545e620 Thomas Schöpping
  }
97
  return;
98
}
99
100
/*============================================================================*/
101
/* GPIO                                                                       */
102
/*============================================================================*/
103
104 7de0cc90 Thomas Schöpping
#if (HAL_USE_PAL == TRUE) || defined (__DOXYGEN__)
105 e545e620 Thomas Schöpping
106
/**
107
 * @brief GPIO driver type.
108
 */
109
struct apalGpio_t {
110 1e5f7648 Thomas Schöpping
  ioportid_t port;
111
  iopadid_t pad;
112 e545e620 Thomas Schöpping
} PACKED_VAR;
113
114
/**
115
 * @brief Read the current value of a GPIO pin.
116
 *
117
 * @param[in]   gpio  GPIO to read.
118
 * @param[out]  val   Current value of the GPIO.
119
 *
120
 * @return The status indicates whether the function call was successful.
121
 */
122
static inline apalExitStatus_t apalGpioRead(apalGpio_t* gpio, apalGpioState_t* const val)
123
{
124 1f94ac64 Thomas Schöpping
  apalDbgAssert(gpio != NULL);
125
  apalDbgAssert(val != NULL);
126 e545e620 Thomas Schöpping
127
  *val = (palReadPad(gpio->port, gpio->pad) == PAL_HIGH) ? APAL_GPIO_HIGH : APAL_GPIO_LOW;
128
  return APAL_STATUS_OK;
129
}
130
131
/**
132
 * @brief Set the value of a GPIO pin.
133
 *
134
 * @param[in] gpio  GPIO to write.
135
 * @param[in] val   Value to set for the GPIO.
136
 *
137
 * @return The status indicates whether the function call was successful.
138
 */
139
static inline apalExitStatus_t apalGpioWrite(apalGpio_t* gpio, const apalGpioState_t val)
140
{
141 1f94ac64 Thomas Schöpping
  apalDbgAssert(gpio != NULL);
142 e545e620 Thomas Schöpping
143
  // palWritePad() is not guaranteed to be atomic, thus the scheduler is locked.
144
  syssts_t sysstatus = chSysGetStatusAndLockX();
145
  palWritePad(gpio->port, gpio->pad, (val == APAL_GPIO_HIGH) ? PAL_HIGH : PAL_LOW);
146
  chSysRestoreStatusX(sysstatus);
147
  return APAL_STATUS_OK;
148
}
149
150
/**
151
 * @brief Toggle the output of a GPIO.
152
 *
153
 * @param[in] gpio  GPIO to toggle.
154
 *
155
 * @return The status indicates whether the function call was successful.
156
 */
157
static inline apalExitStatus_t apalGpioToggle(apalGpio_t* gpio)
158
{
159 1f94ac64 Thomas Schöpping
  apalDbgAssert(gpio != NULL);
160 e545e620 Thomas Schöpping
161
  // palWritePad() is not guaranteed to be atomic, thus the scheduler is locked.
162
  syssts_t sysstatus = chSysGetStatusAndLockX();
163
  palWritePad(gpio->port, gpio->pad, (palReadPad(gpio->port, gpio->pad) == PAL_HIGH) ? PAL_LOW : PAL_HIGH);
164
  chSysRestoreStatusX(sysstatus);
165
  return APAL_STATUS_OK;
166
}
167
168
/**
169
 * @brief Get the current on/off state of a control GPIO.
170
 *
171
 * @param[in]   gpio  Control GPIO to read.
172
 * @param[out]  val   Current activation status of the control GPIO.
173
 *
174
 * @return The status indicates whether the function call was successful.
175
 */
176
static inline apalExitStatus_t apalControlGpioGet(const apalControlGpio_t* const cgpio, apalControlGpioState_t* const val)
177
{
178 1f94ac64 Thomas Schöpping
  apalDbgAssert(cgpio != NULL);
179
  apalDbgAssert(cgpio->gpio != NULL);
180
  apalDbgAssert(val != NULL);
181 e545e620 Thomas Schöpping
182
  *val = ((palReadPad(cgpio->gpio->port, cgpio->gpio->pad) == PAL_HIGH) ^ (cgpio->meta.active == APAL_GPIO_ACTIVE_HIGH)) ? APAL_GPIO_OFF : APAL_GPIO_ON;
183
  return APAL_STATUS_OK;
184
}
185
186
/**
187
 * @brief Turn a control GPIO 'on' or 'off' respectively.
188
 *
189
 * @param[in] gpio  Control GPIO to set.
190
 * @param[in] val   Activation value to set for the control GPIO.
191
 *
192
 * @return The status indicates whether the function call was successful.
193
 */
194
static inline apalExitStatus_t apalControlGpioSet(const apalControlGpio_t* const cgpio, const apalControlGpioState_t val)
195
{
196 1f94ac64 Thomas Schöpping
  apalDbgAssert(cgpio != NULL);
197
  apalDbgAssert(cgpio->gpio != NULL);
198
  apalDbgAssert(cgpio->meta.direction == APAL_GPIO_DIRECTION_OUTPUT || cgpio->meta.direction == APAL_GPIO_DIRECTION_BIDIRECTIONAL);
199 e545e620 Thomas Schöpping
200
  // palWritePad() is not guaranteed to be atomic, thus the scheduler is locked.
201
  syssts_t sysstatus = chSysGetStatusAndLockX();
202
  palWritePad(cgpio->gpio->port, cgpio->gpio->pad, ((cgpio->meta.active == APAL_GPIO_ACTIVE_HIGH) ^ (val == APAL_GPIO_ON)) ? PAL_LOW : PAL_HIGH);
203
  chSysRestoreStatusX(sysstatus);
204
  return APAL_STATUS_OK;
205
}
206
207
/**
208 1e5f7648 Thomas Schöpping
 * @brief   Converts an apalGpioEdge_t to an ChibiOS PAL edge.
209 e545e620 Thomas Schöpping
 */
210 1e5f7648 Thomas Schöpping
#define APAL2CH_EDGE(edge)                                            \
211
  ((edge == APAL_GPIO_EDGE_RISING) ? PAL_EVENT_MODE_RISING_EDGE :     \
212
    (edge == APAL_GPIO_EDGE_FALLING) ? PAL_EVENT_MODE_FALLING_EDGE :  \
213 542939ea Thomas Schöpping
     (edge == APAL_GPIO_EDGE_BOTH) ? PAL_EVENT_MODE_BOTH_EDGES :      \
214
      PAL_EVENT_MODE_DISABLED)
215 e545e620 Thomas Schöpping
216 7de0cc90 Thomas Schöpping
#endif /* (HAL_USE_PAL == TRUE) */
217 e545e620 Thomas Schöpping
218
/*============================================================================*/
219
/* PWM                                                                        */
220
/*============================================================================*/
221
222 7de0cc90 Thomas Schöpping
#if (HAL_USE_PWM == TRUE) || defined (__DOXYGEN__)
223 e545e620 Thomas Schöpping
224
/**
225
 * @brief PWM driver type.
226
 */
227
typedef PWMDriver apalPWMDriver_t;
228
229
/**
230
 * @brief   Set the PWM with given parameters.
231
 *
232
 * @param[in] pwm       PWM driver to set.
233
 * @param[in] channel   Channel of the PWM driver to set.
234
 * @param[in] width     Width to set the channel to.
235
 *
236
 * @return  The status indicates whether the function call was successful.
237
 */
238
static inline apalExitStatus_t apalPWMSet(apalPWMDriver_t* pwm, const apalPWMchannel_t channel, const apalPWMwidth_t width)
239
{
240 1f94ac64 Thomas Schöpping
  apalDbgAssert(pwm != NULL);
241 e545e620 Thomas Schöpping
242
  pwmEnableChannel(pwm, (pwmchannel_t)channel, pwm->period * ((float)width / (float)APAL_PWM_WIDTH_MAX) + 0.5f);
243
  return APAL_STATUS_OK;
244
}
245
246
/**
247
 * @brief   Retrieve the current frequency of the PWM.
248
 *
249
 * @param[in]  pwm        PWM driver to read.
250
 * @param[out] frequency  The currently set frequency.
251
 *
252
 * @return  The status indicates whether the function call was successful.
253
 */
254
static inline apalExitStatus_t apalPWMGetFrequency(apalPWMDriver_t* pwm, apalPWMfrequency_t* const frequency)
255
{
256 1f94ac64 Thomas Schöpping
  apalDbgAssert(pwm != NULL);
257
  apalDbgAssert(frequency != NULL);
258 e545e620 Thomas Schöpping
259
  *frequency = pwm->config->frequency;
260
  return APAL_STATUS_OK;
261
}
262
263
/**
264
 * @brief   Retrieve the current period of the PWM.
265
 *
266
 * @param[in]   pwm     PWM driver to read.
267
 * @param[out]  period  The currently set period.
268
 *
269
 * @return  The status indicates whether the function call was successful.
270
 */
271
static inline apalExitStatus_t apalPWMGetPeriod(apalPWMDriver_t* pwm, apalPWMperiod_t* const period)
272
{
273 1f94ac64 Thomas Schöpping
  apalDbgAssert(pwm != NULL);
274
  apalDbgAssert(period != NULL);
275 e545e620 Thomas Schöpping
276
  *period = pwm->period;
277
  return APAL_STATUS_OK;
278
}
279
280 7de0cc90 Thomas Schöpping
#endif /* (HAL_USE_PWM == TRUE) */
281 e545e620 Thomas Schöpping
282
/*============================================================================*/
283
/* QEI                                                                        */
284
/*============================================================================*/
285
286 7de0cc90 Thomas Schöpping
#if (HAL_USE_QEI == TRUE) || defined (__DOXYGEN__)
287 e545e620 Thomas Schöpping
288
/**
289
 * @brief QEI driver type.
290
 */
291
typedef QEIDriver apalQEIDriver_t;
292
293
/**
294
 * @brief Gets the direction of the last transition.
295
 *
296
 * @param[in]   qei         The QEI driver to use.
297
 * @param[out]  direction   The direction of the last transition.
298
 *
299
 * @return The status indicates whether the function call was successful.
300
 */
301
static inline apalExitStatus_t apalQEIGetDirection(apalQEIDriver_t* qei, apalQEIDirection_t* const direction)
302
{
303 1f94ac64 Thomas Schöpping
  apalDbgAssert(qei != NULL);
304
  apalDbgAssert(direction != NULL);
305 e545e620 Thomas Schöpping
306
  *direction = (qei_lld_get_direction(qei)) ? APAL_QEI_DIRECTION_DOWN : APAL_QEI_DIRECTION_UP;
307
308
  return APAL_STATUS_OK;
309
}
310
311
/**
312
 * @brief Gets the current position of the ecnoder.
313
 *
314
 * @param[in]   qei       The QEI driver to use.
315
 * @param[out]  position  The current position of the encoder.
316
 *
317
 * @return The status indicates whether the function call was successful.
318
 */
319
static inline apalExitStatus_t apalQEIGetPosition(apalQEIDriver_t* qei, apalQEICount_t* const position)
320
{
321 1f94ac64 Thomas Schöpping
  apalDbgAssert(qei != NULL);
322
  apalDbgAssert(position != NULL);
323 e545e620 Thomas Schöpping
324
  *position = qei_lld_get_position(qei);
325
326
  return APAL_STATUS_OK;
327
}
328
329
/**
330
 * @brief Gets the value range of the encoder.
331
 *
332
 * @param[in]   qei     The QEI driver to use.
333
 * @param[out]  range   The value range of the encoder.
334
 *
335
 * @return The status indicates whether the function call was successful.
336
 */
337
static inline apalExitStatus_t apalQEIGetRange(apalQEIDriver_t* qei, apalQEICount_t* const range)
338
{
339 1f94ac64 Thomas Schöpping
  apalDbgAssert(qei != NULL);
340
  apalDbgAssert(range != NULL);
341 e545e620 Thomas Schöpping
342
  *range = qei_lld_get_range(qei);
343
344
  return APAL_STATUS_OK;
345
}
346
347 7de0cc90 Thomas Schöpping
#endif /* (HAL_USE_QEI == TRUE) */
348 e545e620 Thomas Schöpping
349
/*============================================================================*/
350
/* I2C                                                                        */
351
/*============================================================================*/
352
353 7de0cc90 Thomas Schöpping
#if (HAL_USE_I2C == TRUE) || defined(__DOXYGEN__)
354 e545e620 Thomas Schöpping
355
/**
356
 * @brief I2C driver type.
357
 */
358
typedef I2CDriver apalI2CDriver_t;
359
360
/**
361
 * @brief Transmit data and receive a response.
362
 *
363
 * @param[in]   i2cd      The I2C driver to use.
364
 * @param[in]   addr      Address to write to.
365
 * @param[in]   txbuf     Buffer containing data to send.
366
 * @param[in]   txbytes   Number of bytes to send.
367
 * @param[out]  rxbuf     Buffer to store a response to.
368
 * @param[in]   rxbytes   Number of bytes to receive.
369
 * @param[in]   timeout   Timeout for the function to return (in microseconds).
370
 *
371
 * @return The status indicates whether the function call was succesful or a timeout occurred.
372
 */
373
static inline apalExitStatus_t apalI2CMasterTransmit(apalI2CDriver_t* i2cd, const apalI2Caddr_t addr, const uint8_t* const txbuf, const size_t txbytes, uint8_t* const rxbuf, const size_t rxbytes, const apalTime_t timeout)
374
{
375 1f94ac64 Thomas Schöpping
  apalDbgAssert(i2cd != NULL);
376 e545e620 Thomas Schöpping
377
#if (I2C_USE_MUTUAL_EXCLUSION == TRUE)
378 5ab6a6a4 Thomas Schöpping
  // check whether the I2C driver was locked externally
379
  const bool i2cd_locked_external = i2cd->mutex.owner == currp;
380
  if (!i2cd_locked_external) {
381
    i2cAcquireBus(i2cd);
382
  }
383 7de0cc90 Thomas Schöpping
#endif /* (I2C_USE_MUTUAL_EXCLUSION == TRUE) */
384 e545e620 Thomas Schöpping
385 1e5f7648 Thomas Schöpping
#pragma GCC diagnostic push
386
#pragma GCC diagnostic ignored "-Wtype-limits"
387 e545e620 Thomas Schöpping
#if defined(STM32F1XX_I2C)
388
  // Due to a hardware limitation, for STM32F1 platform the minimum number of bytes that can be received is two.
389
  msg_t status = MSG_OK;
390
  if (rxbytes == 1) {
391
    uint8_t buffer[2];
392 0128be0f Marc Rothmann
    status = i2cMasterTransmitTimeout(i2cd, addr, txbuf, txbytes, buffer, 2, ((timeout >= TIME_INFINITE) ? TIME_INFINITE : TIME_US2I(timeout)) );
393 e545e620 Thomas Schöpping
    rxbuf[0] = buffer[0];
394
  } else {
395 0128be0f Marc Rothmann
    status = i2cMasterTransmitTimeout(i2cd, addr, txbuf, txbytes, rxbuf, rxbytes, ((timeout >= TIME_INFINITE) ? TIME_INFINITE : TIME_US2I(timeout)) );
396 e545e620 Thomas Schöpping
  }
397 7de0cc90 Thomas Schöpping
#else /* defined(STM32F1XX_I2C) */
398 0128be0f Marc Rothmann
  const msg_t status = i2cMasterTransmitTimeout(i2cd, addr, txbuf, txbytes, rxbuf, rxbytes, ((timeout >= TIME_INFINITE) ? TIME_INFINITE : TIME_US2I(timeout)) );
399 7de0cc90 Thomas Schöpping
#endif /* defined(STM32F1XX_I2C) */
400 1e5f7648 Thomas Schöpping
#pragma GCC diagnostic pop
401 e545e620 Thomas Schöpping
402
#if (I2C_USE_MUTUAL_EXCLUSION == TRUE)
403 5ab6a6a4 Thomas Schöpping
  if (!i2cd_locked_external) {
404
    i2cReleaseBus(i2cd);
405
  }
406 7de0cc90 Thomas Schöpping
#endif /* (I2C_USE_MUTUAL_EXCLUSION == TRUE) */
407 e545e620 Thomas Schöpping
408
  switch (status)
409
  {
410
    case MSG_OK:
411
#if defined(STM32F1XX_I2C)
412
      return (rxbytes != 1) ? APAL_STATUS_OK : APAL_STATUS_WARNING;
413 7de0cc90 Thomas Schöpping
#else /* defined(STM32F1XX_I2C) */
414 e545e620 Thomas Schöpping
      return APAL_STATUS_OK;
415 7de0cc90 Thomas Schöpping
#endif /* defined(STM32F1XX_I2C) */
416 e545e620 Thomas Schöpping
    case MSG_TIMEOUT:
417
      return APAL_STATUS_TIMEOUT;
418
    case MSG_RESET:
419
    default:
420
      return APAL_STATUS_ERROR;
421
  }
422
}
423
424
/**
425
 * @brief Read data from a specific address.
426
 *
427
 * @param[in]   i2cd      The I2C driver to use.
428
 * @param[in]   addr      Address to read.
429
 * @param[out]  rxbuf     Buffer to store the response to.
430
 * @param[in]   rxbytes   Number of bytes to receive.
431
 * @param[in]   timeout   Timeout for the function to return (in microseconds).
432
 *
433
 * @return The status indicates whether the function call was succesful or a timeout occurred.
434
 */
435
static inline apalExitStatus_t apalI2CMasterReceive(apalI2CDriver_t* i2cd, const apalI2Caddr_t addr, uint8_t* const rxbuf, const size_t rxbytes, const apalTime_t timeout)
436
{
437 1f94ac64 Thomas Schöpping
  apalDbgAssert(i2cd != NULL);
438 e545e620 Thomas Schöpping
439
#if (I2C_USE_MUTUAL_EXCLUSION == TRUE)
440 5ab6a6a4 Thomas Schöpping
  // check whether the I2C driver was locked externally
441
  const bool i2cd_locked_external = i2cd->mutex.owner == currp;
442
  if (!i2cd_locked_external) {
443
    i2cAcquireBus(i2cd);
444
  }
445 7de0cc90 Thomas Schöpping
#endif /* (I2C_USE_MUTUAL_EXCLUSION == TRUE) */
446 e545e620 Thomas Schöpping
447 1e5f7648 Thomas Schöpping
#pragma GCC diagnostic push
448
#pragma GCC diagnostic ignored "-Wtype-limits"
449 e545e620 Thomas Schöpping
#if defined(STM32F1XX_I2C)
450
  // Due to a hardware limitation, for STM32F1 platform the minimum number of bytes that can be received is two.
451
  msg_t status = MSG_OK;
452
  if (rxbytes == 1) {
453
    uint8_t buffer[2];
454 0128be0f Marc Rothmann
    status = i2cMasterReceiveTimeout(i2cd, addr, buffer, 2, ((timeout >= TIME_INFINITE) ? TIME_INFINITE : TIME_US2I(timeout)) );
455 e545e620 Thomas Schöpping
    rxbuf[0] = buffer[0];
456
  } else {
457 0128be0f Marc Rothmann
    status = i2cMasterReceiveTimeout(i2cd, addr, rxbuf, rxbytes, ((timeout >= TIME_INFINITE) ? TIME_INFINITE : TIME_US2I(timeout)) );
458 e545e620 Thomas Schöpping
  }
459 7de0cc90 Thomas Schöpping
#else /* defined(STM32F1XX_I2C) */
460 0128be0f Marc Rothmann
  const msg_t status = i2cMasterReceiveTimeout(i2cd, addr, rxbuf, rxbytes, ((timeout >= TIME_INFINITE) ? TIME_INFINITE : TIME_US2I(timeout)) );
461 7de0cc90 Thomas Schöpping
#endif /* defined(STM32F1XX_I2C) */
462 1e5f7648 Thomas Schöpping
#pragma GCC diagnostic pop
463 e545e620 Thomas Schöpping
464
#if (I2C_USE_MUTUAL_EXCLUSION == TRUE)
465 5ab6a6a4 Thomas Schöpping
  if (!i2cd_locked_external) {
466
    i2cReleaseBus(i2cd);
467
  }
468 7de0cc90 Thomas Schöpping
#endif /* (I2C_USE_MUTUAL_EXCLUSION == TRUE) */
469 e545e620 Thomas Schöpping
470
  switch (status)
471
  {
472
    case MSG_OK:
473
#if defined(STM32F1XX_I2C)
474
      return (rxbytes != 1) ? APAL_STATUS_OK : APAL_STATUS_WARNING;
475 7de0cc90 Thomas Schöpping
#else /* defined(STM32F1XX_I2C) */
476 e545e620 Thomas Schöpping
      return APAL_STATUS_OK;
477 7de0cc90 Thomas Schöpping
#endif /* defined(STM32F1XX_I2C) */
478 e545e620 Thomas Schöpping
    case MSG_TIMEOUT:
479
      return APAL_STATUS_TIMEOUT;
480
    case MSG_RESET:
481
    default:
482
      return APAL_STATUS_ERROR;
483
  }
484
}
485
486 7de0cc90 Thomas Schöpping
#endif /* (HAL_USE_I2C == TRUE) */
487 e545e620 Thomas Schöpping
488
/*============================================================================*/
489
/* SPI                                                                        */
490
/*============================================================================*/
491
492 7de0cc90 Thomas Schöpping
#if (HAL_USE_SPI == TRUE) || defined(__DOXYGEN__)
493 e545e620 Thomas Schöpping
494
/**
495
 * @brief SPI driver type.
496
 */
497
typedef SPIDriver apalSPIDriver_t;
498
499
/**
500
 * @brief Transmit and receive data from SPI
501
 *
502
 * @param[in]   spid      The SPI driver to use.
503
 * @param[in]   txData    Buffer containing data to send.
504
 * @param[out]  rxData    Buffer to store.
505
 * @param[in]   length    Number of bytes to send.
506
 *
507
 * @return The status indicates whether the function call was succesful.
508
 */
509
static inline apalExitStatus_t apalSPIExchange(apalSPIDriver_t* spid, const uint8_t* const txData , uint8_t* const rxData, const size_t length)
510
{
511 1f94ac64 Thomas Schöpping
  apalDbgAssert(spid != NULL);
512 e545e620 Thomas Schöpping
513 7de0cc90 Thomas Schöpping
#if (SPI_USE_MUTUAL_EXCLUSION == TRUE)
514 5ab6a6a4 Thomas Schöpping
  // check whether the SPI driver was locked externally
515
  const bool spid_locked_external = spid->mutex.owner == currp;
516
  if (!spid_locked_external) {
517
    spiAcquireBus(spid);
518
  }
519 7de0cc90 Thomas Schöpping
#endif /* (SPI_USE_MUTUAL_EXCLUSION == TRUE) */
520 5ab6a6a4 Thomas Schöpping
521 e545e620 Thomas Schöpping
  spiSelect(spid);
522
  spiExchange(spid, length, txData, rxData);
523
  spiUnselect(spid);
524 5ab6a6a4 Thomas Schöpping
525 7de0cc90 Thomas Schöpping
#if (SPI_USE_MUTUAL_EXCLUSION == TRUE)
526 5ab6a6a4 Thomas Schöpping
  if (!spid_locked_external) {
527
    spiReleaseBus(spid);
528
  }
529 7de0cc90 Thomas Schöpping
#endif /* (SPI_USE_MUTUAL_EXCLUSION == TRUE) */
530 e545e620 Thomas Schöpping
531
  return APAL_STATUS_OK;
532
}
533
534
/**
535
 * @brief Receive data from SPI
536
 *
537
 * @param[in]   spid      The SPI driver to use.
538
 * @param[out]  data      Buffer to store.
539
 * @param[in]   length    Number of bytes to send.
540
 *
541
 * @return The status indicates whether the function call was succesful.
542
 */
543
static inline apalExitStatus_t apalSPIReceive(apalSPIDriver_t* spid, uint8_t* const data, const size_t length)
544
{
545 1f94ac64 Thomas Schöpping
  apalDbgAssert(spid != NULL);
546 e545e620 Thomas Schöpping
547 7de0cc90 Thomas Schöpping
#if (SPI_USE_MUTUAL_EXCLUSION == TRUE)
548 5ab6a6a4 Thomas Schöpping
  // check whether the SPI driver was locked externally
549
  const bool spid_locked_external = spid->mutex.owner == currp;
550
  if (!spid_locked_external) {
551
    spiAcquireBus(spid);
552
  }
553 7de0cc90 Thomas Schöpping
#endif /* (SPI_USE_MUTUAL_EXCLUSION == TRUE) */
554 5ab6a6a4 Thomas Schöpping
555 e545e620 Thomas Schöpping
  spiSelect(spid);
556
  spiReceive(spid, length, data);
557
  spiUnselect(spid);
558 5ab6a6a4 Thomas Schöpping
559 7de0cc90 Thomas Schöpping
#if (SPI_USE_MUTUAL_EXCLUSION == TRUE)
560 5ab6a6a4 Thomas Schöpping
  if (!spid_locked_external) {
561
    spiReleaseBus(spid);
562
  }
563 7de0cc90 Thomas Schöpping
#endif /* (SPI_USE_MUTUAL_EXCLUSION == TRUE) */
564 e545e620 Thomas Schöpping
565
  return APAL_STATUS_OK;
566
}
567
568
/**
569
 * @brief Transmit data to SPI
570
 *
571
 * @param[in]   spid      The SPI driver to use.
572
 * @param[in]   data      Buffer containing data to send.
573
 * @param[in]   length    Number of bytes to send.
574
 *
575
 * @return The status indicates whether the function call was succesful.
576
 */
577
static inline apalExitStatus_t apalSPITransmit(apalSPIDriver_t* spid, const uint8_t* const data, const size_t length)
578
{
579 1f94ac64 Thomas Schöpping
  apalDbgAssert(spid != NULL);
580 e545e620 Thomas Schöpping
581 7de0cc90 Thomas Schöpping
#if (SPI_USE_MUTUAL_EXCLUSION == TRUE)
582 5ab6a6a4 Thomas Schöpping
  // check whether the SPI driver was locked externally
583
  const bool spid_locked_external = spid->mutex.owner == currp;
584
  if (!spid_locked_external) {
585
    spiAcquireBus(spid);
586
  }
587 7de0cc90 Thomas Schöpping
#endif /* (SPI_USE_MUTUAL_EXCLUSION == TRUE) */
588 5ab6a6a4 Thomas Schöpping
589 e545e620 Thomas Schöpping
  spiSelect(spid);
590
  spiSend(spid, length, data);
591
  spiUnselect(spid);
592 5ab6a6a4 Thomas Schöpping
593 7de0cc90 Thomas Schöpping
#if (SPI_USE_MUTUAL_EXCLUSION == TRUE)
594 5ab6a6a4 Thomas Schöpping
  if (!spid_locked_external) {
595
    spiReleaseBus(spid);
596
  }
597 7de0cc90 Thomas Schöpping
#endif /* (SPI_USE_MUTUAL_EXCLUSION == TRUE) */
598 e545e620 Thomas Schöpping
599
  return APAL_STATUS_OK;
600
}
601
602 e251c4e6 Robin Ewers
/**
603
 * @brief Transmit data to SPI and receive data afterwards without releasing the bus in between
604
 *
605
 * @param   spid        The SPI driver to use.
606
 * @param   txData      Transmit data buffer.
607
 * @param   rxData      Receive data buffer.
608
 * @param   txLength    Number of bytes to send.
609
 * @param   rxLength    Number of bytes to receive.
610
 *
611
 * @return The status indicates whether the function call was succesful.
612
 */
613
static inline apalExitStatus_t apalSPITransmitAndReceive(apalSPIDriver_t* spid, const uint8_t* const txData , uint8_t* const rxData, const size_t txLength, const size_t rxLength)
614
{
615 1f94ac64 Thomas Schöpping
  apalDbgAssert(spid != NULL);
616 e251c4e6 Robin Ewers
617 7de0cc90 Thomas Schöpping
#if (SPI_USE_MUTUAL_EXCLUSION == TRUE)
618 5ab6a6a4 Thomas Schöpping
  // check whether the SPI driver was locked externally
619
  const bool spid_locked_external = spid->mutex.owner == currp;
620
  if (!spid_locked_external) {
621
    spiAcquireBus(spid);
622
  }
623 7de0cc90 Thomas Schöpping
#endif /* (SPI_USE_MUTUAL_EXCLUSION == TRUE) */
624 5ab6a6a4 Thomas Schöpping
625 e251c4e6 Robin Ewers
  spiSelect(spid);
626
  spiSend(spid, txLength, txData);
627
  spiReceive(spid, rxLength, rxData);
628
  spiUnselect(spid);
629 5ab6a6a4 Thomas Schöpping
630 7de0cc90 Thomas Schöpping
#if (SPI_USE_MUTUAL_EXCLUSION == TRUE)
631 5ab6a6a4 Thomas Schöpping
  if (!spid_locked_external) {
632
    spiReleaseBus(spid);
633
  }
634 7de0cc90 Thomas Schöpping
#endif /* (SPI_USE_MUTUAL_EXCLUSION == TRUE) */
635 e545e620 Thomas Schöpping
636
  return APAL_STATUS_OK;
637
}
638
639 7de0cc90 Thomas Schöpping
#endif /* (HAL_USE_SPI == TRUE) */
640 1703dfdf Thomas Schöpping
641 6ff06bbf Thomas Schöpping
#endif /* AMIROOS_PERIPHAL_H */