Statistics
| Branch: | Tag: | Revision:

amiro-os / periphery-lld / aos_periphAL.c @ e977b199

History | View | Annotate | Download (14.7 KB)

1 e545e620 Thomas Schöpping
/*
2
AMiRo-OS is an operating system designed for the Autonomous Mini Robot (AMiRo) platform.
3 96621a83 Thomas Schöpping
Copyright (C) 2016..2020  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 dd56d656 Thomas Schöpping
#include <periphAL.h>
20 e545e620 Thomas Schöpping
21
/*============================================================================*/
22 1f94ac64 Thomas Schöpping
/* DEBUG                                                                      */
23
/*============================================================================*/
24
25 dd56d656 Thomas Schöpping
#if (AMIROOS_CFG_DBG == true)
26 1f94ac64 Thomas Schöpping
27 dd56d656 Thomas Schöpping
#include <amiroos.h>
28
#include <chprintf.h>
29 1f94ac64 Thomas Schöpping
30 dd56d656 Thomas Schöpping
void apalDbgAssertMsg(const bool c, const char* fmt, ...)
31
{
32
  if (!c) {
33
    va_list ap;
34 232ccea6 Thomas Schöpping
35 dd56d656 Thomas Schöpping
    va_start(ap, fmt);
36
    chvprintf((BaseSequentialStream*)&aos.iostream, fmt, ap);
37
    va_end(ap);
38
    chThdExit(MSG_RESET);
39
  }
40 1f94ac64 Thomas Schöpping
41 dd56d656 Thomas Schöpping
  return;
42
}
43 1f94ac64 Thomas Schöpping
44 dd56d656 Thomas Schöpping
int apalDbgPrintf(const char* fmt, ...)
45
{
46
  va_list ap;
47 b7ac1f29 Thomas Schöpping
48 dd56d656 Thomas Schöpping
  va_start(ap, fmt);
49
  const int chars = chvprintf((BaseSequentialStream*)&aos.iostream, fmt, ap);
50
  va_end(ap);
51 b7ac1f29 Thomas Schöpping
52 dd56d656 Thomas Schöpping
  return chars;
53
}
54 1f94ac64 Thomas Schöpping
55 7de0cc90 Thomas Schöpping
#endif /* (AMIROOS_CFG_DBG == true) */
56 1f94ac64 Thomas Schöpping
57
/*============================================================================*/
58 dd56d656 Thomas Schöpping
/* TIMING                                                                     */
59 e545e620 Thomas Schöpping
/*============================================================================*/
60
61 dd56d656 Thomas Schöpping
#if (AMIROOS_CFG_DBG == true)
62
63
void apalSleep(apalTime_t us)
64 e545e620 Thomas Schöpping
{
65
  // check if the specified time can be represented by the system
66 1f94ac64 Thomas Schöpping
  apalDbgAssert(us <= chTimeI2US(TIME_INFINITE));
67 e545e620 Thomas Schöpping
68 3940ba8a Thomas Schöpping
  const sysinterval_t interval = chTimeUS2I(us);
69 e545e620 Thomas Schöpping
  // TIME_IMMEDIATE makes no sense and would even cause system halt
70 3940ba8a Thomas Schöpping
  if (interval != TIME_IMMEDIATE) {
71
    chThdSleep(interval);
72 e545e620 Thomas Schöpping
  }
73 dd56d656 Thomas Schöpping
74 e545e620 Thomas Schöpping
  return;
75
}
76
77 dd56d656 Thomas Schöpping
#endif /* (AMIROOS_CFG_DBG == true) */
78
79 e545e620 Thomas Schöpping
/*============================================================================*/
80
/* GPIO                                                                       */
81
/*============================================================================*/
82
83 dd56d656 Thomas Schöpping
#if (HAL_USE_PAL == TRUE)
84
85
apalExitStatus_t apalGpioRead(apalGpio_t* gpio, apalGpioState_t* const val)
86 e545e620 Thomas Schöpping
{
87 1f94ac64 Thomas Schöpping
  apalDbgAssert(gpio != NULL);
88
  apalDbgAssert(val != NULL);
89 e545e620 Thomas Schöpping
90 3106e8cc Thomas Schöpping
  *val = (palReadLine(gpio->line) == PAL_HIGH) ? APAL_GPIO_HIGH : APAL_GPIO_LOW;
91 dd56d656 Thomas Schöpping
92 e545e620 Thomas Schöpping
  return APAL_STATUS_OK;
93
}
94
95 dd56d656 Thomas Schöpping
apalExitStatus_t apalGpioWrite(apalGpio_t* gpio, const apalGpioState_t val)
96 e545e620 Thomas Schöpping
{
97 1f94ac64 Thomas Schöpping
  apalDbgAssert(gpio != NULL);
98 e545e620 Thomas Schöpping
99 3106e8cc Thomas Schöpping
  // palWriteLine() is not guaranteed to be atomic, thus the scheduler is locked.
100 e545e620 Thomas Schöpping
  syssts_t sysstatus = chSysGetStatusAndLockX();
101 3106e8cc Thomas Schöpping
  palWriteLine(gpio->line, (val == APAL_GPIO_HIGH) ? PAL_HIGH : PAL_LOW);
102 e545e620 Thomas Schöpping
  chSysRestoreStatusX(sysstatus);
103 dd56d656 Thomas Schöpping
104 e545e620 Thomas Schöpping
  return APAL_STATUS_OK;
105
}
106
107 dd56d656 Thomas Schöpping
apalExitStatus_t apalGpioToggle(apalGpio_t* gpio)
108 e545e620 Thomas Schöpping
{
109 1f94ac64 Thomas Schöpping
  apalDbgAssert(gpio != NULL);
110 e545e620 Thomas Schöpping
111 3106e8cc Thomas Schöpping
  // palWriteLine() is not guaranteed to be atomic, thus the scheduler is locked.
112 e545e620 Thomas Schöpping
  syssts_t sysstatus = chSysGetStatusAndLockX();
113 3106e8cc Thomas Schöpping
  palWriteLine(gpio->line, (palReadLine(gpio->line) == PAL_HIGH) ? PAL_LOW : PAL_HIGH);
114 e545e620 Thomas Schöpping
  chSysRestoreStatusX(sysstatus);
115 dd56d656 Thomas Schöpping
116 e545e620 Thomas Schöpping
  return APAL_STATUS_OK;
117
}
118
119 dd56d656 Thomas Schöpping
apalExitStatus_t apalGpioIsInterruptEnabled(apalGpio_t* gpio, bool* const enabled)
120 232ccea6 Thomas Schöpping
{
121
  apalDbgAssert(gpio != NULL);
122
  apalDbgAssert(enabled != NULL);
123
124
  *enabled = palIsLineEventEnabledX(gpio->line);
125 dd56d656 Thomas Schöpping
126 232ccea6 Thomas Schöpping
  return APAL_STATUS_OK;
127
}
128
129 dd56d656 Thomas Schöpping
apalExitStatus_t apalControlGpioGet(const apalControlGpio_t* const cgpio, apalControlGpioState_t* const val)
130 e545e620 Thomas Schöpping
{
131 1f94ac64 Thomas Schöpping
  apalDbgAssert(cgpio != NULL);
132
  apalDbgAssert(cgpio->gpio != NULL);
133
  apalDbgAssert(val != NULL);
134 e545e620 Thomas Schöpping
135 3106e8cc Thomas Schöpping
  *val = ((palReadLine(cgpio->gpio->line) == PAL_HIGH) ^ (cgpio->meta.active == APAL_GPIO_ACTIVE_HIGH)) ? APAL_GPIO_OFF : APAL_GPIO_ON;
136 dd56d656 Thomas Schöpping
137 e545e620 Thomas Schöpping
  return APAL_STATUS_OK;
138
}
139
140 dd56d656 Thomas Schöpping
apalExitStatus_t apalControlGpioSet(const apalControlGpio_t* const cgpio, const apalControlGpioState_t val)
141 e545e620 Thomas Schöpping
{
142 1f94ac64 Thomas Schöpping
  apalDbgAssert(cgpio != NULL);
143
  apalDbgAssert(cgpio->gpio != NULL);
144
  apalDbgAssert(cgpio->meta.direction == APAL_GPIO_DIRECTION_OUTPUT || cgpio->meta.direction == APAL_GPIO_DIRECTION_BIDIRECTIONAL);
145 e545e620 Thomas Schöpping
146 3106e8cc Thomas Schöpping
  // palWriteLine() is not guaranteed to be atomic, thus the scheduler is locked.
147 e545e620 Thomas Schöpping
  syssts_t sysstatus = chSysGetStatusAndLockX();
148 3106e8cc Thomas Schöpping
  palWriteLine(cgpio->gpio->line, ((cgpio->meta.active == APAL_GPIO_ACTIVE_HIGH) ^ (val == APAL_GPIO_ON)) ? PAL_LOW : PAL_HIGH);
149 e545e620 Thomas Schöpping
  chSysRestoreStatusX(sysstatus);
150 dd56d656 Thomas Schöpping
151 e545e620 Thomas Schöpping
  return APAL_STATUS_OK;
152
}
153
154 dd56d656 Thomas Schöpping
apalExitStatus_t apalControlGpioSetInterrupt(const apalControlGpio_t* const cgpio, const bool enable)
155 232ccea6 Thomas Schöpping
{
156
  apalDbgAssert(cgpio != NULL);
157
  apalDbgAssert(cgpio->gpio != NULL);
158
159
  if (enable) {
160
    apalDbgAssert(pal_lld_get_line_event(cgpio->gpio->line) != NULL);
161
    palEnableLineEvent(cgpio->gpio->line, APAL2CH_EDGE(cgpio->meta.edge));
162
  } else {
163
    palDisableLineEvent(cgpio->gpio->line);
164
  }
165
166
  return APAL_STATUS_OK;
167
}
168
169 7de0cc90 Thomas Schöpping
#endif /* (HAL_USE_PAL == TRUE) */
170 e545e620 Thomas Schöpping
171
/*============================================================================*/
172
/* PWM                                                                        */
173
/*============================================================================*/
174
175 dd56d656 Thomas Schöpping
#if (HAL_USE_PWM == TRUE)
176
177
apalExitStatus_t apalPWMSet(apalPWMDriver_t* pwm, const apalPWMchannel_t channel, const apalPWMwidth_t width)
178 e545e620 Thomas Schöpping
{
179 1f94ac64 Thomas Schöpping
  apalDbgAssert(pwm != NULL);
180 e545e620 Thomas Schöpping
181
  pwmEnableChannel(pwm, (pwmchannel_t)channel, pwm->period * ((float)width / (float)APAL_PWM_WIDTH_MAX) + 0.5f);
182 dd56d656 Thomas Schöpping
183 e545e620 Thomas Schöpping
  return APAL_STATUS_OK;
184
}
185
186 dd56d656 Thomas Schöpping
apalExitStatus_t apalPWMGetFrequency(apalPWMDriver_t* pwm, apalPWMfrequency_t* const frequency)
187 e545e620 Thomas Schöpping
{
188 1f94ac64 Thomas Schöpping
  apalDbgAssert(pwm != NULL);
189
  apalDbgAssert(frequency != NULL);
190 e545e620 Thomas Schöpping
191
  *frequency = pwm->config->frequency;
192 dd56d656 Thomas Schöpping
193 e545e620 Thomas Schöpping
  return APAL_STATUS_OK;
194
}
195
196 dd56d656 Thomas Schöpping
apalExitStatus_t apalPWMGetPeriod(apalPWMDriver_t* pwm, apalPWMperiod_t* const period)
197 e545e620 Thomas Schöpping
{
198 1f94ac64 Thomas Schöpping
  apalDbgAssert(pwm != NULL);
199
  apalDbgAssert(period != NULL);
200 e545e620 Thomas Schöpping
201
  *period = pwm->period;
202 dd56d656 Thomas Schöpping
203 e545e620 Thomas Schöpping
  return APAL_STATUS_OK;
204
}
205
206 7de0cc90 Thomas Schöpping
#endif /* (HAL_USE_PWM == TRUE) */
207 e545e620 Thomas Schöpping
208
/*============================================================================*/
209
/* QEI                                                                        */
210
/*============================================================================*/
211
212 dd56d656 Thomas Schöpping
#if (HAL_USE_QEI == TRUE)
213
214
apalExitStatus_t apalQEIGetDirection(apalQEIDriver_t* qei, apalQEIDirection_t* const direction)
215 e545e620 Thomas Schöpping
{
216 1f94ac64 Thomas Schöpping
  apalDbgAssert(qei != NULL);
217
  apalDbgAssert(direction != NULL);
218 e545e620 Thomas Schöpping
219
  *direction = (qei_lld_get_direction(qei)) ? APAL_QEI_DIRECTION_DOWN : APAL_QEI_DIRECTION_UP;
220
221
  return APAL_STATUS_OK;
222
}
223
224 dd56d656 Thomas Schöpping
apalExitStatus_t apalQEIGetPosition(apalQEIDriver_t* qei, apalQEICount_t* const position)
225 e545e620 Thomas Schöpping
{
226 1f94ac64 Thomas Schöpping
  apalDbgAssert(qei != NULL);
227
  apalDbgAssert(position != NULL);
228 e545e620 Thomas Schöpping
229
  *position = qei_lld_get_position(qei);
230
231
  return APAL_STATUS_OK;
232
}
233
234 dd56d656 Thomas Schöpping
apalExitStatus_t apalQEIGetRange(apalQEIDriver_t* qei, apalQEICount_t* const range)
235 e545e620 Thomas Schöpping
{
236 1f94ac64 Thomas Schöpping
  apalDbgAssert(qei != NULL);
237
  apalDbgAssert(range != NULL);
238 e545e620 Thomas Schöpping
239
  *range = qei_lld_get_range(qei);
240
241
  return APAL_STATUS_OK;
242
}
243
244 7de0cc90 Thomas Schöpping
#endif /* (HAL_USE_QEI == TRUE) */
245 e545e620 Thomas Schöpping
246
/*============================================================================*/
247
/* I2C                                                                        */
248
/*============================================================================*/
249
250 7de0cc90 Thomas Schöpping
#if (HAL_USE_I2C == TRUE) || defined(__DOXYGEN__)
251 e545e620 Thomas Schöpping
252 dd56d656 Thomas Schöpping
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)
253 e545e620 Thomas Schöpping
{
254 1f94ac64 Thomas Schöpping
  apalDbgAssert(i2cd != NULL);
255 e545e620 Thomas Schöpping
256
#if (I2C_USE_MUTUAL_EXCLUSION == TRUE)
257 5ab6a6a4 Thomas Schöpping
  // check whether the I2C driver was locked externally
258
  const bool i2cd_locked_external = i2cd->mutex.owner == currp;
259
  if (!i2cd_locked_external) {
260
    i2cAcquireBus(i2cd);
261
  }
262 7de0cc90 Thomas Schöpping
#endif /* (I2C_USE_MUTUAL_EXCLUSION == TRUE) */
263 e545e620 Thomas Schöpping
264 1e5f7648 Thomas Schöpping
#pragma GCC diagnostic push
265
#pragma GCC diagnostic ignored "-Wtype-limits"
266 e545e620 Thomas Schöpping
#if defined(STM32F1XX_I2C)
267
  // Due to a hardware limitation, for STM32F1 platform the minimum number of bytes that can be received is two.
268
  msg_t status = MSG_OK;
269
  if (rxbytes == 1) {
270
    uint8_t buffer[2];
271 0128be0f Marc Rothmann
    status = i2cMasterTransmitTimeout(i2cd, addr, txbuf, txbytes, buffer, 2, ((timeout >= TIME_INFINITE) ? TIME_INFINITE : TIME_US2I(timeout)) );
272 e545e620 Thomas Schöpping
    rxbuf[0] = buffer[0];
273
  } else {
274 0128be0f Marc Rothmann
    status = i2cMasterTransmitTimeout(i2cd, addr, txbuf, txbytes, rxbuf, rxbytes, ((timeout >= TIME_INFINITE) ? TIME_INFINITE : TIME_US2I(timeout)) );
275 e545e620 Thomas Schöpping
  }
276 7de0cc90 Thomas Schöpping
#else /* defined(STM32F1XX_I2C) */
277 0128be0f Marc Rothmann
  const msg_t status = i2cMasterTransmitTimeout(i2cd, addr, txbuf, txbytes, rxbuf, rxbytes, ((timeout >= TIME_INFINITE) ? TIME_INFINITE : TIME_US2I(timeout)) );
278 7de0cc90 Thomas Schöpping
#endif /* defined(STM32F1XX_I2C) */
279 1e5f7648 Thomas Schöpping
#pragma GCC diagnostic pop
280 e545e620 Thomas Schöpping
281
#if (I2C_USE_MUTUAL_EXCLUSION == TRUE)
282 5ab6a6a4 Thomas Schöpping
  if (!i2cd_locked_external) {
283
    i2cReleaseBus(i2cd);
284
  }
285 7de0cc90 Thomas Schöpping
#endif /* (I2C_USE_MUTUAL_EXCLUSION == TRUE) */
286 e545e620 Thomas Schöpping
287
  switch (status)
288
  {
289
    case MSG_OK:
290
#if defined(STM32F1XX_I2C)
291
      return (rxbytes != 1) ? APAL_STATUS_OK : APAL_STATUS_WARNING;
292 7de0cc90 Thomas Schöpping
#else /* defined(STM32F1XX_I2C) */
293 e545e620 Thomas Schöpping
      return APAL_STATUS_OK;
294 7de0cc90 Thomas Schöpping
#endif /* defined(STM32F1XX_I2C) */
295 e545e620 Thomas Schöpping
    case MSG_TIMEOUT:
296
      return APAL_STATUS_TIMEOUT;
297
    case MSG_RESET:
298
    default:
299
      return APAL_STATUS_ERROR;
300
  }
301
}
302
303 dd56d656 Thomas Schöpping
apalExitStatus_t apalI2CMasterReceive(apalI2CDriver_t* i2cd, const apalI2Caddr_t addr, uint8_t* const rxbuf, const size_t rxbytes, const apalTime_t timeout)
304 e545e620 Thomas Schöpping
{
305 1f94ac64 Thomas Schöpping
  apalDbgAssert(i2cd != NULL);
306 e545e620 Thomas Schöpping
307
#if (I2C_USE_MUTUAL_EXCLUSION == TRUE)
308 5ab6a6a4 Thomas Schöpping
  // check whether the I2C driver was locked externally
309
  const bool i2cd_locked_external = i2cd->mutex.owner == currp;
310
  if (!i2cd_locked_external) {
311
    i2cAcquireBus(i2cd);
312
  }
313 7de0cc90 Thomas Schöpping
#endif /* (I2C_USE_MUTUAL_EXCLUSION == TRUE) */
314 e545e620 Thomas Schöpping
315 1e5f7648 Thomas Schöpping
#pragma GCC diagnostic push
316
#pragma GCC diagnostic ignored "-Wtype-limits"
317 e545e620 Thomas Schöpping
#if defined(STM32F1XX_I2C)
318
  // Due to a hardware limitation, for STM32F1 platform the minimum number of bytes that can be received is two.
319
  msg_t status = MSG_OK;
320
  if (rxbytes == 1) {
321
    uint8_t buffer[2];
322 0128be0f Marc Rothmann
    status = i2cMasterReceiveTimeout(i2cd, addr, buffer, 2, ((timeout >= TIME_INFINITE) ? TIME_INFINITE : TIME_US2I(timeout)) );
323 e545e620 Thomas Schöpping
    rxbuf[0] = buffer[0];
324
  } else {
325 0128be0f Marc Rothmann
    status = i2cMasterReceiveTimeout(i2cd, addr, rxbuf, rxbytes, ((timeout >= TIME_INFINITE) ? TIME_INFINITE : TIME_US2I(timeout)) );
326 e545e620 Thomas Schöpping
  }
327 7de0cc90 Thomas Schöpping
#else /* defined(STM32F1XX_I2C) */
328 0128be0f Marc Rothmann
  const msg_t status = i2cMasterReceiveTimeout(i2cd, addr, rxbuf, rxbytes, ((timeout >= TIME_INFINITE) ? TIME_INFINITE : TIME_US2I(timeout)) );
329 7de0cc90 Thomas Schöpping
#endif /* defined(STM32F1XX_I2C) */
330 1e5f7648 Thomas Schöpping
#pragma GCC diagnostic pop
331 e545e620 Thomas Schöpping
332
#if (I2C_USE_MUTUAL_EXCLUSION == TRUE)
333 5ab6a6a4 Thomas Schöpping
  if (!i2cd_locked_external) {
334
    i2cReleaseBus(i2cd);
335
  }
336 7de0cc90 Thomas Schöpping
#endif /* (I2C_USE_MUTUAL_EXCLUSION == TRUE) */
337 e545e620 Thomas Schöpping
338
  switch (status)
339
  {
340
    case MSG_OK:
341
#if defined(STM32F1XX_I2C)
342
      return (rxbytes != 1) ? APAL_STATUS_OK : APAL_STATUS_WARNING;
343 7de0cc90 Thomas Schöpping
#else /* defined(STM32F1XX_I2C) */
344 e545e620 Thomas Schöpping
      return APAL_STATUS_OK;
345 7de0cc90 Thomas Schöpping
#endif /* defined(STM32F1XX_I2C) */
346 e545e620 Thomas Schöpping
    case MSG_TIMEOUT:
347
      return APAL_STATUS_TIMEOUT;
348
    case MSG_RESET:
349
    default:
350
      return APAL_STATUS_ERROR;
351
  }
352
}
353
354 7de0cc90 Thomas Schöpping
#endif /* (HAL_USE_I2C == TRUE) */
355 e545e620 Thomas Schöpping
356
/*============================================================================*/
357
/* SPI                                                                        */
358
/*============================================================================*/
359
360 7de0cc90 Thomas Schöpping
#if (HAL_USE_SPI == TRUE) || defined(__DOXYGEN__)
361 e545e620 Thomas Schöpping
362 dd56d656 Thomas Schöpping
apalExitStatus_t apalSPITransmit(apalSPIDriver_t* spid, const uint8_t* const data, const size_t length)
363 70dd091e Thomas Schöpping
{
364
  apalDbgAssert(spid != NULL);
365
366
#if (SPI_USE_MUTUAL_EXCLUSION == TRUE)
367
  // check whether the SPI driver was locked externally
368
  const bool spid_locked_external = spid->mutex.owner == currp;
369
  if (!spid_locked_external) {
370
    spiAcquireBus(spid);
371
  }
372
#endif /* (SPI_USE_MUTUAL_EXCLUSION == TRUE) */
373
374 dd56d656 Thomas Schöpping
  spiSelect(spid);
375
  spiSend(spid, length, data);
376
  spiUnselect(spid);
377 70dd091e Thomas Schöpping
378
#if (SPI_USE_MUTUAL_EXCLUSION == TRUE)
379
  if (!spid_locked_external) {
380
    spiReleaseBus(spid);
381
  }
382
#endif /* (SPI_USE_MUTUAL_EXCLUSION == TRUE) */
383
384
  return APAL_STATUS_OK;
385
}
386
387 dd56d656 Thomas Schöpping
apalExitStatus_t apalSPIReceive(apalSPIDriver_t* spid, uint8_t* const data, const size_t length)
388 e545e620 Thomas Schöpping
{
389 1f94ac64 Thomas Schöpping
  apalDbgAssert(spid != NULL);
390 e545e620 Thomas Schöpping
391 7de0cc90 Thomas Schöpping
#if (SPI_USE_MUTUAL_EXCLUSION == TRUE)
392 5ab6a6a4 Thomas Schöpping
  // check whether the SPI driver was locked externally
393
  const bool spid_locked_external = spid->mutex.owner == currp;
394
  if (!spid_locked_external) {
395
    spiAcquireBus(spid);
396
  }
397 7de0cc90 Thomas Schöpping
#endif /* (SPI_USE_MUTUAL_EXCLUSION == TRUE) */
398 5ab6a6a4 Thomas Schöpping
399 e545e620 Thomas Schöpping
  spiSelect(spid);
400 dd56d656 Thomas Schöpping
  spiReceive(spid, length, data);
401 e545e620 Thomas Schöpping
  spiUnselect(spid);
402 5ab6a6a4 Thomas Schöpping
403 7de0cc90 Thomas Schöpping
#if (SPI_USE_MUTUAL_EXCLUSION == TRUE)
404 5ab6a6a4 Thomas Schöpping
  if (!spid_locked_external) {
405
    spiReleaseBus(spid);
406
  }
407 7de0cc90 Thomas Schöpping
#endif /* (SPI_USE_MUTUAL_EXCLUSION == TRUE) */
408 e545e620 Thomas Schöpping
409
  return APAL_STATUS_OK;
410
}
411
412 dd56d656 Thomas Schöpping
apalExitStatus_t apalSPITransmitAndReceive(apalSPIDriver_t* spid, const uint8_t* const txData , uint8_t* const rxData, const size_t txLength, const size_t rxLength)
413 e545e620 Thomas Schöpping
{
414 1f94ac64 Thomas Schöpping
  apalDbgAssert(spid != NULL);
415 e545e620 Thomas Schöpping
416 7de0cc90 Thomas Schöpping
#if (SPI_USE_MUTUAL_EXCLUSION == TRUE)
417 5ab6a6a4 Thomas Schöpping
  // check whether the SPI driver was locked externally
418
  const bool spid_locked_external = spid->mutex.owner == currp;
419
  if (!spid_locked_external) {
420
    spiAcquireBus(spid);
421
  }
422 7de0cc90 Thomas Schöpping
#endif /* (SPI_USE_MUTUAL_EXCLUSION == TRUE) */
423 5ab6a6a4 Thomas Schöpping
424 e545e620 Thomas Schöpping
  spiSelect(spid);
425 dd56d656 Thomas Schöpping
  spiSend(spid, txLength, txData);
426
  spiReceive(spid, rxLength, rxData);
427 e545e620 Thomas Schöpping
  spiUnselect(spid);
428 5ab6a6a4 Thomas Schöpping
429 7de0cc90 Thomas Schöpping
#if (SPI_USE_MUTUAL_EXCLUSION == TRUE)
430 5ab6a6a4 Thomas Schöpping
  if (!spid_locked_external) {
431
    spiReleaseBus(spid);
432
  }
433 7de0cc90 Thomas Schöpping
#endif /* (SPI_USE_MUTUAL_EXCLUSION == TRUE) */
434 e545e620 Thomas Schöpping
435
  return APAL_STATUS_OK;
436
}
437
438 dd56d656 Thomas Schöpping
apalExitStatus_t apalSPIExchange(apalSPIDriver_t* spid, const uint8_t* const txData , uint8_t* const rxData, const size_t length)
439 e545e620 Thomas Schöpping
{
440 1f94ac64 Thomas Schöpping
  apalDbgAssert(spid != NULL);
441 e545e620 Thomas Schöpping
442 7de0cc90 Thomas Schöpping
#if (SPI_USE_MUTUAL_EXCLUSION == TRUE)
443 5ab6a6a4 Thomas Schöpping
  // check whether the SPI driver was locked externally
444
  const bool spid_locked_external = spid->mutex.owner == currp;
445
  if (!spid_locked_external) {
446
    spiAcquireBus(spid);
447
  }
448 7de0cc90 Thomas Schöpping
#endif /* (SPI_USE_MUTUAL_EXCLUSION == TRUE) */
449 5ab6a6a4 Thomas Schöpping
450 e545e620 Thomas Schöpping
  spiSelect(spid);
451 dd56d656 Thomas Schöpping
  spiExchange(spid, length, txData, rxData);
452 e545e620 Thomas Schöpping
  spiUnselect(spid);
453 5ab6a6a4 Thomas Schöpping
454 7de0cc90 Thomas Schöpping
#if (SPI_USE_MUTUAL_EXCLUSION == TRUE)
455 5ab6a6a4 Thomas Schöpping
  if (!spid_locked_external) {
456
    spiReleaseBus(spid);
457
  }
458 7de0cc90 Thomas Schöpping
#endif /* (SPI_USE_MUTUAL_EXCLUSION == TRUE) */
459 e545e620 Thomas Schöpping
460
  return APAL_STATUS_OK;
461
}
462
463 dd56d656 Thomas Schöpping
apalExitStatus_t apalSPIReconfigure(apalSPIDriver_t* spid, const apalSPIConfig_t* config)
464 e251c4e6 Robin Ewers
{
465 1f94ac64 Thomas Schöpping
  apalDbgAssert(spid != NULL);
466 dd56d656 Thomas Schöpping
  apalDbgAssert(config != NULL);
467 e251c4e6 Robin Ewers
468 7de0cc90 Thomas Schöpping
#if (SPI_USE_MUTUAL_EXCLUSION == TRUE)
469 5ab6a6a4 Thomas Schöpping
  // check whether the SPI driver was locked externally
470
  const bool spid_locked_external = spid->mutex.owner == currp;
471
  if (!spid_locked_external) {
472
    spiAcquireBus(spid);
473
  }
474 7de0cc90 Thomas Schöpping
#endif /* (SPI_USE_MUTUAL_EXCLUSION == TRUE) */
475 5ab6a6a4 Thomas Schöpping
476 dd56d656 Thomas Schöpping
  spiStop(spid);
477
  spiStart(spid, config);
478 5ab6a6a4 Thomas Schöpping
479 7de0cc90 Thomas Schöpping
#if (SPI_USE_MUTUAL_EXCLUSION == TRUE)
480 5ab6a6a4 Thomas Schöpping
  if (!spid_locked_external) {
481
    spiReleaseBus(spid);
482
  }
483 7de0cc90 Thomas Schöpping
#endif /* (SPI_USE_MUTUAL_EXCLUSION == TRUE) */
484 e545e620 Thomas Schöpping
485
  return APAL_STATUS_OK;
486
}
487
488 7de0cc90 Thomas Schöpping
#endif /* (HAL_USE_SPI == TRUE) */