Skip to content

Commit f0e76f9

Browse files
cmagliecmaglie
committed
SPI: fix indent
1 parent eca1341 commit f0e76f9

File tree

2 files changed

+102
-98
lines changed

2 files changed

+102
-98
lines changed

‎libraries/SPI/SPI.cpp

Lines changed: 46 additions & 46 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,6 @@
11
/*
22
* SPI Master library for arduino.
33
* Copyright (c) 2014 Arduino.
4-
* based on Copyright (c) 2011 Cristian Maglie <[email protected]>.
54
*
65
* This file is free software; you can redistribute it and/or modify
76
* it under the terms of either the GNU General Public License version 2
@@ -16,8 +15,8 @@
1615

1716
SPIClass::SPIClass(SERCOM *p_sercom, uint8_t uc_pinMISO, uint8_t uc_pinSCK, uint8_t uc_pinMOSI)
1817
{
19-
assert(p_sercom != NULL );
20-
_p_sercom = p_sercom;
18+
assert(p_sercom != NULL);
19+
_p_sercom = p_sercom;
2120

2221
_uc_pinMiso = uc_pinMISO;
2322
_uc_pinSCK = uc_pinSCK;
@@ -31,68 +30,69 @@ void SPIClass::begin()
3130
pinPeripheral(_uc_pinSCK, g_APinDescription[_uc_pinSCK].ulPinType);
3231
pinPeripheral(_uc_pinMosi, g_APinDescription[_uc_pinMosi].ulPinType);
3332

34-
// Default speed set to 4Mhz, SPI mode set to MODE 0 and Bit order set to MSB first.
35-
_p_sercom->initSPI(SPI_PAD_2_SCK_3, SERCOM_RX_PAD_0, SPI_CHAR_SIZE_8_BITS, MSB_FIRST);
36-
_p_sercom->initSPIClock(SERCOM_SPI_MODE_0, 4000000);
33+
// Default speed set to 4Mhz, SPI mode set to MODE 0 and Bit order set to MSB first.
34+
_p_sercom->initSPI(SPI_PAD_2_SCK_3, SERCOM_RX_PAD_0, SPI_CHAR_SIZE_8_BITS, MSB_FIRST);
35+
_p_sercom->initSPIClock(SERCOM_SPI_MODE_0, 4000000);
3736

38-
_p_sercom->enableSPI();
37+
_p_sercom->enableSPI();
3938
}
4039

4140
void SPIClass::end()
4241
{
43-
_p_sercom->resetSPI();
42+
_p_sercom->resetSPI();
4443
}
4544

4645

4746
void SPIClass::usingInterrupt(uint8_t interruptNumber)
4847
{
49-
// XXX: TODO
48+
// XXX: TODO
5049
}
5150

5251
void SPIClass::beginTransaction(SPISettings settings)
5352
{
54-
// XXX: TODO
55-
setBitOrder(settings.bitOrder);
56-
setClockDivider(settings.clockDiv);
57-
setDataMode(settings.dataMode);
53+
// XXX: TODO
54+
setBitOrder(settings.bitOrder);
55+
setClockDivider(settings.clockDiv);
56+
setDataMode(settings.dataMode);
5857
}
5958

6059
void SPIClass::endTransaction(void)
6160
{
62-
// XXX: TODO
61+
// XXX: TODO
6362
}
6463

6564
void SPIClass::setBitOrder(BitOrder order)
6665
{
67-
if(order == LSBFIRST)
68-
_p_sercom->setDataOrderSPI(LSB_FIRST);
69-
else
70-
_p_sercom->setDataOrderSPI(MSB_FIRST);
66+
if (order == LSBFIRST) {
67+
_p_sercom->setDataOrderSPI(LSB_FIRST);
68+
} else {
69+
_p_sercom->setDataOrderSPI(MSB_FIRST);
70+
}
7171
}
7272

7373
void SPIClass::setDataMode(uint8_t mode)
7474
{
75-
switch(mode)
76-
{
77-
case SPI_MODE0:
78-
_p_sercom->setClockModeSPI(SERCOM_SPI_MODE_0);
79-
break;
80-
81-
case SPI_MODE1:
82-
_p_sercom->setClockModeSPI(SERCOM_SPI_MODE_1);
83-
break;
84-
85-
case SPI_MODE2:
86-
_p_sercom->setClockModeSPI(SERCOM_SPI_MODE_2);
87-
break;
88-
89-
case SPI_MODE3:
90-
_p_sercom->setClockModeSPI(SERCOM_SPI_MODE_3);
91-
break;
92-
93-
default:
94-
break;
95-
}
75+
switch (mode)
76+
{
77+
case SPI_MODE0:
78+
_p_sercom->setClockModeSPI(SERCOM_SPI_MODE_0);
79+
break;
80+
81+
case SPI_MODE1:
82+
_p_sercom->setClockModeSPI(SERCOM_SPI_MODE_1);
83+
break;
84+
85+
case SPI_MODE2:
86+
_p_sercom->setClockModeSPI(SERCOM_SPI_MODE_2);
87+
break;
88+
89+
case SPI_MODE3:
90+
_p_sercom->setClockModeSPI(SERCOM_SPI_MODE_3);
91+
break;
92+
93+
default:
94+
break;
95+
}
9696
}
9797

9898
void SPIClass::setClockDivider(uint8_t div)
@@ -106,19 +106,19 @@ void SPIClass::setClockDivider(uint8_t div)
106106

107107
byte SPIClass::transfer(uint8_t data)
108108
{
109-
//Writing the data
110-
_p_sercom->writeDataSPI(data);
109+
// Writing the data
110+
_p_sercom->writeDataSPI(data);
111111

112-
//Read data
113-
return _p_sercom->readDataSPI();
112+
// Read data
113+
return _p_sercom->readDataSPI();
114114
}
115115

116116
void SPIClass::attachInterrupt() {
117-
// Should be enableInterrupt()
117+
// Should be enableInterrupt()
118118
}
119119

120120
void SPIClass::detachInterrupt() {
121-
// Should be disableInterrupt()
121+
// Should be disableInterrupt()
122122
}
123123

124-
SPIClass SPI( &sercom4, PIN_SPI_MISO, PIN_SPI_SCK, PIN_SPI_MOSI ) ;
124+
SPIClass SPI( &sercom4, PIN_SPI_MISO, PIN_SPI_SCK, PIN_SPI_MOSI );

‎libraries/SPI/SPI.h

Lines changed: 56 additions & 52 deletions
Original file line numberDiff line numberDiff line change
@@ -30,73 +30,77 @@
3030

3131
class SPISettings {
3232
public:
33-
SPISettings(uint32_t clock, BitOrder bitOrder, uint8_t dataMode) {
34-
if (__builtin_constant_p(clock)) {
35-
init_AlwaysInline(clock, bitOrder, dataMode);
36-
} else {
37-
init_MightInline(clock, bitOrder, dataMode);
38-
}
39-
}
40-
SPISettings() { init_AlwaysInline(4000000, MSBFIRST, SPI_MODE0); }
41-
private:
42-
void init_MightInline(uint32_t clock, BitOrder bitOrder, uint8_t dataMode) {
43-
init_AlwaysInline(clock, bitOrder, dataMode);
44-
}
45-
void init_AlwaysInline(uint32_t clock, BitOrder bitOrder, uint8_t dataMode) __attribute__((__always_inline__)) {
46-
uint8_t div;
47-
if (clock < (F_CPU / 255)) {
48-
div = 255;
49-
} else if (clock >= (F_CPU / SPI_MIN_CLOCK_DIVIDER)) {
50-
div = SPI_MIN_CLOCK_DIVIDER;
51-
} else {
52-
div = (F_CPU / (clock + 1)) + 1;
53-
}
54-
this->clockDiv = div;
55-
this->dataMode = dataMode;
56-
this->bitOrder = bitOrder;
57-
}
58-
uint8_t clockDiv, dataMode;
59-
BitOrder bitOrder;
60-
friend class SPIClass;
33+
SPISettings(uint32_t clock, BitOrder bitOrder, uint8_t dataMode) {
34+
if (__builtin_constant_p(clock)) {
35+
init_AlwaysInline(clock, bitOrder, dataMode);
36+
} else {
37+
init_MightInline(clock, bitOrder, dataMode);
38+
}
39+
}
40+
41+
SPISettings() { init_AlwaysInline(4000000, MSBFIRST, SPI_MODE0); }
6142

43+
private:
44+
void init_MightInline(uint32_t clock, BitOrder bitOrder, uint8_t dataMode) {
45+
init_AlwaysInline(clock, bitOrder, dataMode);
46+
}
47+
48+
void init_AlwaysInline(uint32_t clock, BitOrder bitOrder, uint8_t dataMode) __attribute__((__always_inline__)) {
49+
uint8_t div;
50+
if (clock < (F_CPU / 255)) {
51+
div = 255;
52+
} else if (clock >= (F_CPU / SPI_MIN_CLOCK_DIVIDER)) {
53+
div = SPI_MIN_CLOCK_DIVIDER;
54+
} else {
55+
div = (F_CPU / (clock + 1)) + 1;
56+
}
57+
this->clockDiv = div;
58+
this->dataMode = dataMode;
59+
this->bitOrder = bitOrder;
60+
}
61+
62+
uint8_t clockDiv, dataMode;
63+
BitOrder bitOrder;
64+
65+
friend class SPIClass;
6266
};
6367

6468
class SPIClass {
6569
public:
66-
SPIClass(SERCOM *p_sercom, uint8_t uc_pinMISO, uint8_t uc_pinSCK, uint8_t uc_pinMOSI);
70+
SPIClass(SERCOM *p_sercom, uint8_t uc_pinMISO, uint8_t uc_pinSCK, uint8_t uc_pinMOSI);
71+
72+
byte transfer(uint8_t data);
73+
inline void transfer(void *buf, size_t count);
6774

68-
byte transfer(uint8_t data);
69-
inline void transfer(void *buf, size_t count);
75+
// Transaction Functions
76+
void usingInterrupt(uint8_t interruptNumber);
77+
void beginTransaction(SPISettings settings);
78+
void endTransaction(void);
7079

71-
// Transaction Functions
72-
void usingInterrupt(uint8_t interruptNumber);
73-
void beginTransaction(SPISettings settings);
74-
void endTransaction(void);
80+
// SPI Configuration methods
81+
void attachInterrupt();
82+
void detachInterrupt();
7583

76-
// SPI Configuration methods
77-
void attachInterrupt();
78-
void detachInterrupt();
84+
void begin();
85+
void end();
7986

80-
void begin();
81-
void end();
82-
83-
void setBitOrder(BitOrder order);
84-
void setDataMode(uint8_t uc_mode);
85-
void setClockDivider(uint8_t uc_div);
87+
void setBitOrder(BitOrder order);
88+
void setDataMode(uint8_t uc_mode);
89+
void setClockDivider(uint8_t uc_div);
8690

8791
private:
88-
SERCOM *_p_sercom;
89-
uint8_t _uc_pinMiso;
90-
uint8_t _uc_pinMosi;
91-
uint8_t _uc_pinSCK;
92+
SERCOM *_p_sercom;
93+
uint8_t _uc_pinMiso;
94+
uint8_t _uc_pinMosi;
95+
uint8_t _uc_pinSCK;
9296
};
9397

9498
void SPIClass::transfer(void *buf, size_t count)
9599
{
96-
// TODO: Optimize for faster block-transfer
97-
uint8_t *buffer = reinterpret_cast<uint8_t *>(buf);
98-
for (size_t i=0; i<count; i++)
99-
buffer[i] = transfer(buffer[i]);
100+
// TODO: Optimize for faster block-transfer
101+
uint8_t *buffer = reinterpret_cast<uint8_t *>(buf);
102+
for (size_t i=0; i<count; i++)
103+
buffer[i] = transfer(buffer[i]);
100104
}
101105

102106
#if SPI_INTERFACES_COUNT > 0

0 commit comments

Comments
 (0)