Point Labs / RadioHeadLite

This driver is a stripped down version of the Radiohead 1.45 driver, and covers fewer radios. Threading and an event queue have been added to make the ISR's more stable across architectures. Specifically The STM32L4 parts

Dependents:   Threaded_LoRa_Modem

RHHardwareSPI.cpp@1:dfeb5e8b199a, 2021-04-30 (annotated)

Committer:
rlanders73
Date:
Fri Apr 30 15:16:24 2021 +0000
Revision:
1:dfeb5e8b199a
Parent:
0:ab4e012489ef
Child:
2:403a13ad43e6
making this work for Geneva;

Who changed what in which revision?

UserRevisionLine numberNew contents of line
davidr99 0:ab4e012489ef 1 // RHHardwareSPI.h
davidr99 0:ab4e012489ef 2 // Author: Mike McCauley (mikem@airspayce.com)
davidr99 0:ab4e012489ef 3 // Copyright (C) 2011 Mike McCauley
davidr99 0:ab4e012489ef 4 // Contributed by Joanna Rutkowska
davidr99 0:ab4e012489ef 5 // $Id: RHHardwareSPI.cpp,v 1.12 2015/07/01 00:46:05 mikem Exp $
davidr99 0:ab4e012489ef 6
davidr99 0:ab4e012489ef 7 #include <RHHardwareSPI.h>
davidr99 0:ab4e012489ef 8
davidr99 0:ab4e012489ef 9 // Declare a single default instance of the hardware SPI interface class
davidr99 0:ab4e012489ef 10 RHHardwareSPI hardware_spi;
davidr99 0:ab4e012489ef 11
davidr99 0:ab4e012489ef 12 #ifdef RH_HAVE_HARDWARE_SPI
davidr99 0:ab4e012489ef 13
davidr99 0:ab4e012489ef 14 #if (RH_PLATFORM == RH_PLATFORM_STM32) // Maple etc
davidr99 0:ab4e012489ef 15 // Declare an SPI interface to use
davidr99 0:ab4e012489ef 16 HardwareSPI _SPI(1);
davidr99 0:ab4e012489ef 17 #elif (RH_PLATFORM == RH_PLATFORM_STM32STD) // STM32F4 Discovery
davidr99 0:ab4e012489ef 18 // Declare an SPI interface to use
davidr99 0:ab4e012489ef 19 HardwareSPI _SPI(1);
davidr99 0:ab4e012489ef 20 #elif (RH_PLATFORM == RH_PLATFORM_MBED) // MBed
rlanders73 1:dfeb5e8b199a 21 // grab config from mbed_app.json
rlanders73 1:dfeb5e8b199a 22 #include "board.h" // This is a hack, and needs to be picked up in a mbed_lib.json file
rlanders73 1:dfeb5e8b199a 23 SPI _SPI(nvm_mosi, nvm_miso, nvm_sclk);
davidr99 0:ab4e012489ef 24
davidr99 0:ab4e012489ef 25 #define REVERSE_BITS(byte) (((reverse_lookup[(byte & 0x0F)]) << 4) + reverse_lookup[((byte & 0xF0) >> 4)])
davidr99 0:ab4e012489ef 26
davidr99 0:ab4e012489ef 27 static const uint8_t reverse_lookup[] = { 0, 8, 4, 12, 2, 10, 6, 14,1, 9, 5, 13,3, 11, 7, 15 };
davidr99 0:ab4e012489ef 28
davidr99 0:ab4e012489ef 29 #endif
davidr99 0:ab4e012489ef 30
davidr99 0:ab4e012489ef 31 // Arduino Due has default SPI pins on central SPI headers, and not on 10, 11, 12, 13
davidr99 0:ab4e012489ef 32 // as per otherArduinos
davidr99 0:ab4e012489ef 33 // http://21stdigitalhome.blogspot.com.au/2013/02/arduino-due-hardware-SPI.html
davidr99 0:ab4e012489ef 34 #if defined (__arm__) && !defined(CORE_TEENSY)
davidr99 0:ab4e012489ef 35 // Arduino Due in 1.5.5 has no definitions for SPI dividers
davidr99 0:ab4e012489ef 36 // SPI clock divider is based on MCK of 84MHz
davidr99 0:ab4e012489ef 37 #define SPI_CLOCK_DIV16 (VARIANT_MCK/84000000) // 1MHz
davidr99 0:ab4e012489ef 38 #define SPI_CLOCK_DIV8 (VARIANT_MCK/42000000) // 2MHz
davidr99 0:ab4e012489ef 39 #define SPI_CLOCK_DIV4 (VARIANT_MCK/21000000) // 4MHz
davidr99 0:ab4e012489ef 40 #define SPI_CLOCK_DIV2 (VARIANT_MCK/10500000) // 8MHz
davidr99 0:ab4e012489ef 41 #define SPI_CLOCK_DIV1 (VARIANT_MCK/5250000) // 16MHz
davidr99 0:ab4e012489ef 42 #endif
davidr99 0:ab4e012489ef 43
davidr99 0:ab4e012489ef 44 RHHardwareSPI::RHHardwareSPI(Frequency frequency, BitOrder bitOrder, DataMode dataMode)
davidr99 0:ab4e012489ef 45 :
davidr99 0:ab4e012489ef 46 RHGenericSPI(frequency, bitOrder, dataMode)
davidr99 0:ab4e012489ef 47 {
davidr99 0:ab4e012489ef 48 }
davidr99 0:ab4e012489ef 49
davidr99 0:ab4e012489ef 50 uint8_t RHHardwareSPI::transfer(uint8_t data)
davidr99 0:ab4e012489ef 51 {
davidr99 0:ab4e012489ef 52 #if (RH_PLATFORM == RH_PLATFORM_MBED)
davidr99 0:ab4e012489ef 53 if (_bitOrder == BitOrderLSBFirst)
davidr99 0:ab4e012489ef 54 data = REVERSE_BITS(data);
davidr99 0:ab4e012489ef 55
davidr99 0:ab4e012489ef 56 return _SPI.write(data);
davidr99 0:ab4e012489ef 57 #else
davidr99 0:ab4e012489ef 58 return _SPI.transfer(data);
davidr99 0:ab4e012489ef 59 #endif
davidr99 0:ab4e012489ef 60 }
davidr99 0:ab4e012489ef 61
davidr99 0:ab4e012489ef 62 void RHHardwareSPI::attachInterrupt()
davidr99 0:ab4e012489ef 63 {
davidr99 0:ab4e012489ef 64 #if (RH_PLATFORM == RH_PLATFORM_ARDUINO)
davidr99 0:ab4e012489ef 65 _SPI.attachInterrupt();
davidr99 0:ab4e012489ef 66 #endif
davidr99 0:ab4e012489ef 67 }
davidr99 0:ab4e012489ef 68
davidr99 0:ab4e012489ef 69 void RHHardwareSPI::detachInterrupt()
davidr99 0:ab4e012489ef 70 {
davidr99 0:ab4e012489ef 71 #if (RH_PLATFORM == RH_PLATFORM_ARDUINO)
davidr99 0:ab4e012489ef 72 _SPI.detachInterrupt();
davidr99 0:ab4e012489ef 73 #endif
davidr99 0:ab4e012489ef 74 }
davidr99 0:ab4e012489ef 75
davidr99 0:ab4e012489ef 76 void RHHardwareSPI::begin()
davidr99 0:ab4e012489ef 77 {
davidr99 0:ab4e012489ef 78 // Sigh: there are no common symbols for some of these SPI options across all platforms
davidr99 0:ab4e012489ef 79 #if (RH_PLATFORM == RH_PLATFORM_ARDUINO) || (RH_PLATFORM == RH_PLATFORM_UNO32)
davidr99 0:ab4e012489ef 80 uint8_t dataMode;
davidr99 0:ab4e012489ef 81 if (_dataMode == DataMode0)
davidr99 0:ab4e012489ef 82 dataMode = SPI_MODE0;
davidr99 0:ab4e012489ef 83 else if (_dataMode == DataMode1)
davidr99 0:ab4e012489ef 84 dataMode = SPI_MODE1;
davidr99 0:ab4e012489ef 85 else if (_dataMode == DataMode2)
davidr99 0:ab4e012489ef 86 dataMode = SPI_MODE2;
davidr99 0:ab4e012489ef 87 else if (_dataMode == DataMode3)
davidr99 0:ab4e012489ef 88 dataMode = SPI_MODE3;
davidr99 0:ab4e012489ef 89 else
davidr99 0:ab4e012489ef 90 dataMode = SPI_MODE0;
davidr99 0:ab4e012489ef 91 #if (RH_PLATFORM == RH_PLATFORM_ARDUINO) && defined(__arm__) && defined(CORE_TEENSY)
davidr99 0:ab4e012489ef 92 // Temporary work-around due to problem where avr_emulation.h does not work properly for the setDataMode() cal
davidr99 0:ab4e012489ef 93 SPCR &= ~SPI_MODE_MASK;
davidr99 0:ab4e012489ef 94 #else
davidr99 0:ab4e012489ef 95 _SPI.setDataMode(dataMode);
davidr99 0:ab4e012489ef 96 #endif
davidr99 0:ab4e012489ef 97
davidr99 0:ab4e012489ef 98 #if (RH_PLATFORM == RH_PLATFORM_ARDUINO) && defined (__arm__) && !defined(CORE_TEENSY)
davidr99 0:ab4e012489ef 99 // Arduino Due in 1.5.5 has its own BitOrder :-(
davidr99 0:ab4e012489ef 100 ::BitOrder bitOrder;
davidr99 0:ab4e012489ef 101 #else
davidr99 0:ab4e012489ef 102 uint8_t bitOrder;
davidr99 0:ab4e012489ef 103 #endif
davidr99 0:ab4e012489ef 104 if (_bitOrder == BitOrderLSBFirst)
davidr99 0:ab4e012489ef 105 bitOrder = LSBFIRST;
davidr99 0:ab4e012489ef 106 else
davidr99 0:ab4e012489ef 107 bitOrder = MSBFIRST;
davidr99 0:ab4e012489ef 108 _SPI.setBitOrder(bitOrder);
davidr99 0:ab4e012489ef 109
davidr99 0:ab4e012489ef 110 uint8_t divider;
davidr99 0:ab4e012489ef 111 switch (_frequency)
davidr99 0:ab4e012489ef 112 {
davidr99 0:ab4e012489ef 113 case Frequency1MHz:
davidr99 0:ab4e012489ef 114 default:
davidr99 0:ab4e012489ef 115 #if F_CPU == 8000000
davidr99 0:ab4e012489ef 116 divider = SPI_CLOCK_DIV8;
davidr99 0:ab4e012489ef 117 #else
davidr99 0:ab4e012489ef 118 divider = SPI_CLOCK_DIV16;
davidr99 0:ab4e012489ef 119 #endif
davidr99 0:ab4e012489ef 120 break;
davidr99 0:ab4e012489ef 121
davidr99 0:ab4e012489ef 122 case Frequency2MHz:
davidr99 0:ab4e012489ef 123 #if F_CPU == 8000000
davidr99 0:ab4e012489ef 124 divider = SPI_CLOCK_DIV4;
davidr99 0:ab4e012489ef 125 #else
davidr99 0:ab4e012489ef 126 divider = SPI_CLOCK_DIV8;
davidr99 0:ab4e012489ef 127 #endif
davidr99 0:ab4e012489ef 128 break;
davidr99 0:ab4e012489ef 129
davidr99 0:ab4e012489ef 130 case Frequency4MHz:
davidr99 0:ab4e012489ef 131 #if F_CPU == 8000000
davidr99 0:ab4e012489ef 132 divider = SPI_CLOCK_DIV2;
davidr99 0:ab4e012489ef 133 #else
davidr99 0:ab4e012489ef 134 divider = SPI_CLOCK_DIV4;
davidr99 0:ab4e012489ef 135 #endif
davidr99 0:ab4e012489ef 136 break;
davidr99 0:ab4e012489ef 137
davidr99 0:ab4e012489ef 138 case Frequency8MHz:
davidr99 0:ab4e012489ef 139 divider = SPI_CLOCK_DIV2; // 4MHz on an 8MHz Arduino
davidr99 0:ab4e012489ef 140 break;
davidr99 0:ab4e012489ef 141
davidr99 0:ab4e012489ef 142 case Frequency16MHz:
davidr99 0:ab4e012489ef 143 divider = SPI_CLOCK_DIV2; // Not really 16MHz, only 8MHz. 4MHz on an 8MHz Arduino
davidr99 0:ab4e012489ef 144 break;
davidr99 0:ab4e012489ef 145
davidr99 0:ab4e012489ef 146 }
davidr99 0:ab4e012489ef 147 _SPI.setClockDivider(divider);
davidr99 0:ab4e012489ef 148 _SPI.begin();
davidr99 0:ab4e012489ef 149
davidr99 0:ab4e012489ef 150 #elif (RH_PLATFORM == RH_PLATFORM_STM32) // Maple etc
davidr99 0:ab4e012489ef 151 spi_mode dataMode;
davidr99 0:ab4e012489ef 152 // Hmmm, if we do this as a switch, GCC on maple gets v confused!
davidr99 0:ab4e012489ef 153 if (_dataMode == DataMode0)
davidr99 0:ab4e012489ef 154 dataMode = SPI_MODE_0;
davidr99 0:ab4e012489ef 155 else if (_dataMode == DataMode1)
davidr99 0:ab4e012489ef 156 dataMode = SPI_MODE_1;
davidr99 0:ab4e012489ef 157 else if (_dataMode == DataMode2)
davidr99 0:ab4e012489ef 158 dataMode = SPI_MODE_2;
davidr99 0:ab4e012489ef 159 else if (_dataMode == DataMode3)
davidr99 0:ab4e012489ef 160 dataMode = SPI_MODE_3;
davidr99 0:ab4e012489ef 161 else
davidr99 0:ab4e012489ef 162 dataMode = SPI_MODE_0;
davidr99 0:ab4e012489ef 163
davidr99 0:ab4e012489ef 164 uint32 bitOrder;
davidr99 0:ab4e012489ef 165 if (_bitOrder == BitOrderLSBFirst)
davidr99 0:ab4e012489ef 166 bitOrder = LSBFIRST;
davidr99 0:ab4e012489ef 167 else
davidr99 0:ab4e012489ef 168 bitOrder = MSBFIRST;
davidr99 0:ab4e012489ef 169
davidr99 0:ab4e012489ef 170 SPIFrequency frequency; // Yes, I know these are not exact equivalents.
davidr99 0:ab4e012489ef 171 switch (_frequency)
davidr99 0:ab4e012489ef 172 {
davidr99 0:ab4e012489ef 173 case Frequency1MHz:
davidr99 0:ab4e012489ef 174 default:
davidr99 0:ab4e012489ef 175 frequency = SPI_1_125MHZ;
davidr99 0:ab4e012489ef 176 break;
davidr99 0:ab4e012489ef 177
davidr99 0:ab4e012489ef 178 case Frequency2MHz:
davidr99 0:ab4e012489ef 179 frequency = SPI_2_25MHZ;
davidr99 0:ab4e012489ef 180 break;
davidr99 0:ab4e012489ef 181
davidr99 0:ab4e012489ef 182 case Frequency4MHz:
davidr99 0:ab4e012489ef 183 frequency = SPI_4_5MHZ;
davidr99 0:ab4e012489ef 184 break;
davidr99 0:ab4e012489ef 185
davidr99 0:ab4e012489ef 186 case Frequency8MHz:
davidr99 0:ab4e012489ef 187 frequency = SPI_9MHZ;
davidr99 0:ab4e012489ef 188 break;
davidr99 0:ab4e012489ef 189
davidr99 0:ab4e012489ef 190 case Frequency16MHz:
davidr99 0:ab4e012489ef 191 frequency = SPI_18MHZ;
davidr99 0:ab4e012489ef 192 break;
davidr99 0:ab4e012489ef 193
davidr99 0:ab4e012489ef 194 }
davidr99 0:ab4e012489ef 195 _SPI.begin(frequency, bitOrder, dataMode);
davidr99 0:ab4e012489ef 196
davidr99 0:ab4e012489ef 197 #elif (RH_PLATFORM == RH_PLATFORM_STM32STD) // STM32F4 discovery
davidr99 0:ab4e012489ef 198 uint8_t dataMode;
davidr99 0:ab4e012489ef 199 if (_dataMode == DataMode0)
davidr99 0:ab4e012489ef 200 dataMode = SPI_MODE0;
davidr99 0:ab4e012489ef 201 else if (_dataMode == DataMode1)
davidr99 0:ab4e012489ef 202 dataMode = SPI_MODE1;
davidr99 0:ab4e012489ef 203 else if (_dataMode == DataMode2)
davidr99 0:ab4e012489ef 204 dataMode = SPI_MODE2;
davidr99 0:ab4e012489ef 205 else if (_dataMode == DataMode3)
davidr99 0:ab4e012489ef 206 dataMode = SPI_MODE3;
davidr99 0:ab4e012489ef 207 else
davidr99 0:ab4e012489ef 208 dataMode = SPI_MODE0;
davidr99 0:ab4e012489ef 209
davidr99 0:ab4e012489ef 210 uint32_t bitOrder;
davidr99 0:ab4e012489ef 211 if (_bitOrder == BitOrderLSBFirst)
davidr99 0:ab4e012489ef 212 bitOrder = LSBFIRST;
davidr99 0:ab4e012489ef 213 else
davidr99 0:ab4e012489ef 214 bitOrder = MSBFIRST;
davidr99 0:ab4e012489ef 215
davidr99 0:ab4e012489ef 216 SPIFrequency frequency; // Yes, I know these are not exact equivalents.
davidr99 0:ab4e012489ef 217 switch (_frequency)
davidr99 0:ab4e012489ef 218 {
davidr99 0:ab4e012489ef 219 case Frequency1MHz:
davidr99 0:ab4e012489ef 220 default:
davidr99 0:ab4e012489ef 221 frequency = SPI_1_3125MHZ;
davidr99 0:ab4e012489ef 222 break;
davidr99 0:ab4e012489ef 223
davidr99 0:ab4e012489ef 224 case Frequency2MHz:
davidr99 0:ab4e012489ef 225 frequency = SPI_2_625MHZ;
davidr99 0:ab4e012489ef 226 break;
davidr99 0:ab4e012489ef 227
davidr99 0:ab4e012489ef 228 case Frequency4MHz:
davidr99 0:ab4e012489ef 229 frequency = SPI_5_25MHZ;
davidr99 0:ab4e012489ef 230 break;
davidr99 0:ab4e012489ef 231
davidr99 0:ab4e012489ef 232 case Frequency8MHz:
davidr99 0:ab4e012489ef 233 frequency = SPI_10_5MHZ;
davidr99 0:ab4e012489ef 234 break;
davidr99 0:ab4e012489ef 235
davidr99 0:ab4e012489ef 236 case Frequency16MHz:
davidr99 0:ab4e012489ef 237 frequency = SPI_21_0MHZ;
davidr99 0:ab4e012489ef 238 break;
davidr99 0:ab4e012489ef 239
davidr99 0:ab4e012489ef 240 }
davidr99 0:ab4e012489ef 241 _SPI.begin(frequency, bitOrder, dataMode);
davidr99 0:ab4e012489ef 242 #elif (RH_PLATFORM == RH_PLATFORM_RASPI) // Raspberry PI
davidr99 0:ab4e012489ef 243 uint8_t dataMode;
davidr99 0:ab4e012489ef 244 if (_dataMode == DataMode0)
davidr99 0:ab4e012489ef 245 dataMode = BCM2835_SPI_MODE0;
davidr99 0:ab4e012489ef 246 else if (_dataMode == DataMode1)
davidr99 0:ab4e012489ef 247 dataMode = BCM2835_SPI_MODE1;
davidr99 0:ab4e012489ef 248 else if (_dataMode == DataMode2)
davidr99 0:ab4e012489ef 249 dataMode = BCM2835_SPI_MODE2;
davidr99 0:ab4e012489ef 250 else if (_dataMode == DataMode3)
davidr99 0:ab4e012489ef 251 dataMode = BCM2835_SPI_MODE3;
davidr99 0:ab4e012489ef 252
davidr99 0:ab4e012489ef 253 uint8_t bitOrder;
davidr99 0:ab4e012489ef 254 if (_bitOrder == BitOrderLSBFirst)
davidr99 0:ab4e012489ef 255 bitOrder = BCM2835_SPI_BIT_ORDER_LSBFIRST;
davidr99 0:ab4e012489ef 256 else
davidr99 0:ab4e012489ef 257 bitOrder = BCM2835_SPI_BIT_ORDER_MSBFIRST;
davidr99 0:ab4e012489ef 258
davidr99 0:ab4e012489ef 259 uint32_t divider;
davidr99 0:ab4e012489ef 260 switch (_frequency)
davidr99 0:ab4e012489ef 261 {
davidr99 0:ab4e012489ef 262 case Frequency1MHz:
davidr99 0:ab4e012489ef 263 default:
davidr99 0:ab4e012489ef 264 divider = BCM2835_SPI_CLOCK_DIVIDER_256;
davidr99 0:ab4e012489ef 265 break;
davidr99 0:ab4e012489ef 266 case Frequency2MHz:
davidr99 0:ab4e012489ef 267 divider = BCM2835_SPI_CLOCK_DIVIDER_128;
davidr99 0:ab4e012489ef 268 break;
davidr99 0:ab4e012489ef 269 case Frequency4MHz:
davidr99 0:ab4e012489ef 270 divider = BCM2835_SPI_CLOCK_DIVIDER_64;
davidr99 0:ab4e012489ef 271 break;
davidr99 0:ab4e012489ef 272 case Frequency8MHz:
davidr99 0:ab4e012489ef 273 divider = BCM2835_SPI_CLOCK_DIVIDER_32;
davidr99 0:ab4e012489ef 274 break;
davidr99 0:ab4e012489ef 275 case Frequency16MHz:
davidr99 0:ab4e012489ef 276 divider = BCM2835_SPI_CLOCK_DIVIDER_16;
davidr99 0:ab4e012489ef 277 break;
davidr99 0:ab4e012489ef 278 }
davidr99 0:ab4e012489ef 279 _SPI.begin(divider, bitOrder, dataMode);
davidr99 0:ab4e012489ef 280 #elif (RH_PLATFORM == RH_PLATFORM_MBED) // MBed
rlanders73 1:dfeb5e8b199a 281
davidr99 0:ab4e012489ef 282 uint8_t dataMode;
davidr99 0:ab4e012489ef 283 if (_dataMode == DataMode0)
davidr99 0:ab4e012489ef 284 dataMode = 0;
davidr99 0:ab4e012489ef 285 else if (_dataMode == DataMode1)
davidr99 0:ab4e012489ef 286 dataMode = 1;
davidr99 0:ab4e012489ef 287 else if (_dataMode == DataMode2)
davidr99 0:ab4e012489ef 288 dataMode = 2;
davidr99 0:ab4e012489ef 289 else if (_dataMode == DataMode3)
davidr99 0:ab4e012489ef 290 dataMode = 3;
rlanders73 1:dfeb5e8b199a 291 printf("mode %d\n", dataMode);
davidr99 0:ab4e012489ef 292 _SPI.format(8, dataMode);
davidr99 0:ab4e012489ef 293
davidr99 0:ab4e012489ef 294 int frequency;
davidr99 0:ab4e012489ef 295 switch (_frequency)
davidr99 0:ab4e012489ef 296 {
davidr99 0:ab4e012489ef 297 case Frequency1MHz:
davidr99 0:ab4e012489ef 298 default:
davidr99 0:ab4e012489ef 299 frequency = 1000000;
davidr99 0:ab4e012489ef 300 break;
davidr99 0:ab4e012489ef 301
davidr99 0:ab4e012489ef 302 case Frequency2MHz:
davidr99 0:ab4e012489ef 303 frequency = 2000000;
davidr99 0:ab4e012489ef 304 break;
davidr99 0:ab4e012489ef 305
davidr99 0:ab4e012489ef 306 case Frequency4MHz:
davidr99 0:ab4e012489ef 307 frequency = 4000000;
davidr99 0:ab4e012489ef 308 break;
davidr99 0:ab4e012489ef 309
davidr99 0:ab4e012489ef 310 case Frequency8MHz:
davidr99 0:ab4e012489ef 311 frequency = 8000000;
davidr99 0:ab4e012489ef 312 break;
davidr99 0:ab4e012489ef 313
davidr99 0:ab4e012489ef 314 case Frequency16MHz:
davidr99 0:ab4e012489ef 315 frequency = 16000000;
davidr99 0:ab4e012489ef 316 break;
davidr99 0:ab4e012489ef 317 }
rlanders73 1:dfeb5e8b199a 318 printf("@%dHz\n",frequency);
davidr99 0:ab4e012489ef 319 _SPI.frequency(frequency);
davidr99 0:ab4e012489ef 320 #else
davidr99 0:ab4e012489ef 321 #warning RHHardwareSPI does not support this platform yet. Consider adding it and contributing a patch.
davidr99 0:ab4e012489ef 322 #endif
davidr99 0:ab4e012489ef 323 }
davidr99 0:ab4e012489ef 324
davidr99 0:ab4e012489ef 325 void RHHardwareSPI::end()
davidr99 0:ab4e012489ef 326 {
davidr99 0:ab4e012489ef 327 #if (RH_PLATFORM == RH_PLATFORM_MBED)
davidr99 0:ab4e012489ef 328 // no end for SPI
davidr99 0:ab4e012489ef 329 #else
davidr99 0:ab4e012489ef 330 return _SPI.end();
davidr99 0:ab4e012489ef 331 #endif
davidr99 0:ab4e012489ef 332 }
davidr99 0:ab4e012489ef 333
davidr99 0:ab4e012489ef 334 #endif
davidr99 0:ab4e012489ef 335