void GDClass::wr16(unsigned int addr, unsigned int v)
{
__wstart(addr);
SPI.transfer(lowByte(v));
SPI.transfer(highByte(v));
__end();
}
void GDClass::xhide()
{
SPI.transfer(lowByte(400));
SPI.transfer(highByte(400));
SPI.transfer(lowByte(400));
SPI.transfer(highByte(400));
spr++;
}
void GDClass::voice(int v, byte wave, unsigned int freq, byte lamp, byte ramp)
{
__wstart(VOICES + (v << 2));
SPI.transfer(lowByte(freq));
SPI.transfer(highByte(freq) | (wave << 7));
SPI.transfer(lamp);
SPI.transfer(ramp);
__end();
}
void GDClass::sprite(int spr, int x, int y, byte image, byte palette, byte rot, byte jk)
{
__wstart(RAM_SPR + (spr << 2));
SPI.transfer(lowByte(x));
SPI.transfer((palette << 4) | (rot << 1) | (highByte(x) & 1));
SPI.transfer(lowByte(y));
SPI.transfer((jk << 7) | (image << 1) | (highByte(y) & 1));
__end();
}
unsigned int GDClass::rd16(unsigned int addr)
{
unsigned int r;
__start(addr);
r = SPI.transfer(0);
r |= (SPI.transfer(0) << 8);
__end();
return r;
}
void GDClass::fill(int addr, byte v, unsigned int count)
{
__wstart(addr);
while (count--)
SPI.transfer(v);
__end();
}
void Element_GFX::sendFrame()
{
int pixnum = 0;
int idx = 0;
uint16 data[3];
// generate and write out data
while (pixnum < ELEMENT_LEDS)
{
idx = 3 * ((ELEMENT_LEDS - 1) - pixnum);
data[0] = gamma_table[framebuffer[idx + 0]];
data[1] = gamma_table[framebuffer[idx + 1]];
data[2] = gamma_table[framebuffer[idx + 2]];
// sending out data on SPI - Teensy
// one transfer for each byte
led_spi.write((byte*)data, 6); // sending out data on SPI
++pixnum;
}
// toggle latch pin
delay(1);
digitalWrite(ELEMENT_LATCH, HIGH);
delay(1);
digitalWrite(ELEMENT_LATCH, LOW);
}
void loop() {
/* Send message */
digitalWrite(NSS, LOW);
spi1.write(buf, sizeof buf);
digitalWrite(NSS, HIGH);
delay(1000);
}
byte GDClass::rd(unsigned int addr)
{
__start(addr);
byte r = SPI.transfer(0);
__end();
return r;
}
void GDClass::putstr(int x, int y, const char *s)
{
GD.__wstart((y << 6) + x);
while (*s)
SPI.transfer(*s++);
GD.__end();
}
void GDClass::copy(unsigned int addr, PROGMEM prog_uchar *src, int count)
{
__wstart(addr);
while (count--) {
SPI.transfer(pgm_read_byte_near(src));
src++;
}
__end();
}
void GDClass::copy(unsigned int addr, uint_farptr_t src, int count)
{
__wstart(addr);
while (count--) {
SPI.transfer(pgm_read_byte_far(src));
src++;
}
__end();
}
void GDClass::xsprite(int ox, int oy, char x, char y, byte image, byte palette, byte rot, byte jk)
{
if (rot & 2)
x = -16-x;
if (rot & 4)
y = -16-y;
if (rot & 1) {
int s;
s = x; x = y; y = s;
}
ox += x;
oy += y;
SPI.transfer(lowByte(ox));
SPI.transfer((palette << 4) | (rot << 1) | (highByte(ox) & 1));
SPI.transfer(lowByte(oy));
SPI.transfer((jk << 7) | (image << 1) | (highByte(oy) & 1));
spr++;
}
void setup() {
/* Set up chip select as output */
pinMode(NSS, OUTPUT);
/* NSS is usually active LOW, so initialize it HIGH */
digitalWrite(NSS, HIGH);
/* Initialize SPI */
spi1.begin(SPI_4_5MHZ, LSBFIRST, 0);
}
void Element_GFX::constructor()
{
// set the pin for output:
pinMode(ELEMENT_LATCH, OUTPUT);
digitalWrite(ELEMENT_LATCH, LOW);
led_spi.begin(SPI_4_5MHZ, MSBFIRST, SPI_MODE_0);
Adafruit_GFX::constructor(ELEMENT_W, ELEMENT_H);
}
Mrf24w::Mrf24w(HardwareSPI &spi, uint8_t csPin, uint8_t intPin) : m_csPin(csPin), m_intPin(intPin), m_processEventFn(NULL) {
const stm32_pin_info *csPinInfo = &PIN_MAP[csPin];
g_mrf24wInstance = this;
m_securityType = WF_SECURITY_OPEN;
m_wirelessMode = WF_INFRASTRUCTURE;
wf_spi = spi.c_dev();
wf_cs_port = csPinInfo->gpio_device;
wf_cs_bit = csPinInfo->gpio_bit;
}
void GDClass::begin()
{
delay(250); // give Gameduino time to boot
pinMode(SS_PIN, OUTPUT);
#ifdef BOARD_maple
SPI.begin(SPI_4_5MHZ, MSBFIRST, 0);
#else
SPI.begin();
SPI.setClockDivider(SPI_CLOCK_DIV2);
SPI.setBitOrder(MSBFIRST);
SPI.setDataMode(SPI_MODE0);
SPSR = (1 << SPI2X);
#endif
digitalWrite(SS_PIN, HIGH);
GD.wr(J1_RESET, 1); // HALT coprocessor
__wstart(RAM_SPR); // Hide all sprites
for (int i = 0; i < 512; i++)
GD.xhide();
__end();
fill(RAM_PIC, 0, 1024 * 10); // Zero all character RAM
fill(RAM_SPRPAL, 0, 2048); // Sprite palletes black
fill(RAM_SPRIMG, 0, 64 * 256); // Clear all sprite data
fill(VOICES, 0, 256); // Silence
fill(PALETTE16A, 0, 128); // Black 16-, 4-palletes and COMM
GD.wr16(SCROLL_X, 0);
GD.wr16(SCROLL_Y, 0);
GD.wr(JK_MODE, 0);
GD.wr(SPR_DISABLE, 0);
GD.wr(SPR_PAGE, 0);
GD.wr(IOMODE, 0);
GD.wr16(BG_COLOR, 0);
GD.wr16(SAMPLE_L, 0);
GD.wr16(SAMPLE_R, 0);
GD.wr16(SCREENSHOT_Y, 0);
GD.wr(MODULATOR, 64);
}
void hardwareSetup(void) {
spi.begin(SPI_281_250KHZ, MSBFIRST, 0); // move to sdcard init?
pinMode(YEL_LED, OUTPUT);
pinMode(GRN_LED, OUTPUT);
pinMode(BLU_LED, OUTPUT);
digitalWrite(YEL_LED, HIGH);
digitalWrite(BLU_LED, LOW);
digitalWrite(GRN_LED, HIGH);
SerialUSB.begin();
#ifdef LOGGING_SERIAL_DEVICE
Serial1.begin(9600);
#endif
Serial2.begin(9600);
// probably should initialize the monitor.
sdCardStatus=sdCardInit();
}
void RHHardwareSPI::begin()
{
#if defined(SPI_HAS_TRANSACTION)
// Perhaps this is a uniform interface for SPI?
// Currently Teensy and ESP32 only
uint32_t frequency;
if (_frequency == Frequency16MHz)
frequency = 16000000;
else if (_frequency == Frequency8MHz)
frequency = 8000000;
else if (_frequency == Frequency4MHz)
frequency = 4000000;
else if (_frequency == Frequency2MHz)
frequency = 2000000;
else
frequency = 1000000;
#if ((RH_PLATFORM == RH_PLATFORM_ARDUINO) && defined (__arm__) && (defined(ARDUINO_SAM_DUE) || defined(ARDUINO_ARCH_SAMD))) || defined(ARDUINO_ARCH_NRF52) || defined(ARDUINO_ARCH_STM32F1) || defined(ARDUINO_ARCH_STM32F4)
// Arduino Due in 1.5.5 has its own BitOrder :-(
// So too does Arduino Zero
// So too does rogerclarkmelbourne/Arduino_STM32
::BitOrder bitOrder;
#else
uint8_t bitOrder;
#endif
if (_bitOrder == BitOrderLSBFirst)
bitOrder = LSBFIRST;
else
bitOrder = MSBFIRST;
uint8_t dataMode;
if (_dataMode == DataMode0)
dataMode = SPI_MODE0;
else if (_dataMode == DataMode1)
dataMode = SPI_MODE1;
else if (_dataMode == DataMode2)
dataMode = SPI_MODE2;
else if (_dataMode == DataMode3)
dataMode = SPI_MODE3;
else
dataMode = SPI_MODE0;
// Save the settings for use in transactions
_settings = SPISettings(frequency, bitOrder, dataMode);
SPI.begin();
#else // SPI_HAS_TRANSACTION
// Sigh: there are no common symbols for some of these SPI options across all platforms
#if (RH_PLATFORM == RH_PLATFORM_ARDUINO) || (RH_PLATFORM == RH_PLATFORM_UNO32) || (RH_PLATFORM == RH_PLATFORM_CHIPKIT_CORE || RH_PLATFORM == RH_PLATFORM_NRF52)
uint8_t dataMode;
if (_dataMode == DataMode0)
dataMode = SPI_MODE0;
else if (_dataMode == DataMode1)
dataMode = SPI_MODE1;
else if (_dataMode == DataMode2)
dataMode = SPI_MODE2;
else if (_dataMode == DataMode3)
dataMode = SPI_MODE3;
else
dataMode = SPI_MODE0;
#if (RH_PLATFORM == RH_PLATFORM_ARDUINO) && defined(__arm__) && defined(CORE_TEENSY)
// Temporary work-around due to problem where avr_emulation.h does not work properly for the setDataMode() cal
SPCR &= ~SPI_MODE_MASK;
#else
#if ((RH_PLATFORM == RH_PLATFORM_ARDUINO) && defined (__arm__) && defined(ARDUINO_ARCH_SAMD)) || defined(ARDUINO_ARCH_NRF52)
// Zero requires begin() before anything else :-)
SPI.begin();
#endif
SPI.setDataMode(dataMode);
#endif
#if ((RH_PLATFORM == RH_PLATFORM_ARDUINO) && defined (__arm__) && (defined(ARDUINO_SAM_DUE) || defined(ARDUINO_ARCH_SAMD))) || defined(ARDUINO_ARCH_NRF52) || defined (ARDUINO_ARCH_STM32F1) || defined(ARDUINO_ARCH_STM32F4)
// Arduino Due in 1.5.5 has its own BitOrder :-(
// So too does Arduino Zero
// So too does rogerclarkmelbourne/Arduino_STM32
::BitOrder bitOrder;
#else
uint8_t bitOrder;
#endif
if (_bitOrder == BitOrderLSBFirst)
bitOrder = LSBFIRST;
else
bitOrder = MSBFIRST;
SPI.setBitOrder(bitOrder);
uint8_t divider;
switch (_frequency)
{
case Frequency1MHz:
default:
#if F_CPU == 8000000
divider = SPI_CLOCK_DIV8;
#else
divider = SPI_CLOCK_DIV16;
#endif
break;
case Frequency2MHz:
#if F_CPU == 8000000
divider = SPI_CLOCK_DIV4;
#else
divider = SPI_CLOCK_DIV8;
#endif
break;
case Frequency4MHz:
#if F_CPU == 8000000
divider = SPI_CLOCK_DIV2;
#else
divider = SPI_CLOCK_DIV4;
#endif
break;
case Frequency8MHz:
divider = SPI_CLOCK_DIV2; // 4MHz on an 8MHz Arduino
break;
case Frequency16MHz:
divider = SPI_CLOCK_DIV2; // Not really 16MHz, only 8MHz. 4MHz on an 8MHz Arduino
break;
}
SPI.setClockDivider(divider);
SPI.begin();
// Teensy requires it to be set _after_ begin()
SPI.setClockDivider(divider);
#elif (RH_PLATFORM == RH_PLATFORM_STM32) // Maple etc
spi_mode dataMode;
// Hmmm, if we do this as a switch, GCC on maple gets v confused!
if (_dataMode == DataMode0)
dataMode = SPI_MODE_0;
else if (_dataMode == DataMode1)
dataMode = SPI_MODE_1;
else if (_dataMode == DataMode2)
dataMode = SPI_MODE_2;
else if (_dataMode == DataMode3)
dataMode = SPI_MODE_3;
else
dataMode = SPI_MODE_0;
uint32 bitOrder;
if (_bitOrder == BitOrderLSBFirst)
bitOrder = LSBFIRST;
else
bitOrder = MSBFIRST;
SPIFrequency frequency; // Yes, I know these are not exact equivalents.
switch (_frequency)
{
case Frequency1MHz:
default:
frequency = SPI_1_125MHZ;
break;
case Frequency2MHz:
frequency = SPI_2_25MHZ;
break;
case Frequency4MHz:
frequency = SPI_4_5MHZ;
break;
case Frequency8MHz:
frequency = SPI_9MHZ;
break;
case Frequency16MHz:
frequency = SPI_18MHZ;
break;
}
SPI.begin(frequency, bitOrder, dataMode);
#elif (RH_PLATFORM == RH_PLATFORM_STM32STD) // STM32F4 discovery
uint8_t dataMode;
if (_dataMode == DataMode0)
dataMode = SPI_MODE0;
else if (_dataMode == DataMode1)
dataMode = SPI_MODE1;
else if (_dataMode == DataMode2)
dataMode = SPI_MODE2;
else if (_dataMode == DataMode3)
dataMode = SPI_MODE3;
else
dataMode = SPI_MODE0;
uint32_t bitOrder;
if (_bitOrder == BitOrderLSBFirst)
bitOrder = LSBFIRST;
else
bitOrder = MSBFIRST;
SPIFrequency frequency; // Yes, I know these are not exact equivalents.
switch (_frequency)
{
case Frequency1MHz:
default:
frequency = SPI_1_3125MHZ;
break;
case Frequency2MHz:
frequency = SPI_2_625MHZ;
break;
case Frequency4MHz:
frequency = SPI_5_25MHZ;
break;
case Frequency8MHz:
frequency = SPI_10_5MHZ;
break;
case Frequency16MHz:
frequency = SPI_21_0MHZ;
break;
}
SPI.begin(frequency, bitOrder, dataMode);
#elif (RH_PLATFORM == RH_PLATFORM_STM32F2) // Photon
uint8_t dataMode;
if (_dataMode == DataMode0)
dataMode = SPI_MODE0;
else if (_dataMode == DataMode1)
dataMode = SPI_MODE1;
else if (_dataMode == DataMode2)
dataMode = SPI_MODE2;
else if (_dataMode == DataMode3)
dataMode = SPI_MODE3;
else
dataMode = SPI_MODE0;
SPI.setDataMode(dataMode);
if (_bitOrder == BitOrderLSBFirst)
SPI.setBitOrder(LSBFIRST);
else
SPI.setBitOrder(MSBFIRST);
switch (_frequency)
{
case Frequency1MHz:
default:
SPI.setClockSpeed(1, MHZ);
break;
case Frequency2MHz:
SPI.setClockSpeed(2, MHZ);
break;
case Frequency4MHz:
SPI.setClockSpeed(4, MHZ);
break;
case Frequency8MHz:
SPI.setClockSpeed(8, MHZ);
break;
case Frequency16MHz:
SPI.setClockSpeed(16, MHZ);
break;
}
// SPI.setClockDivider(SPI_CLOCK_DIV4); // 72MHz / 4MHz = 18MHz
// SPI.setClockSpeed(1, MHZ);
SPI.begin();
#elif (RH_PLATFORM == RH_PLATFORM_ESP8266)
// Requires SPI driver for ESP8266 from https://github.com/esp8266/Arduino/tree/master/libraries/SPI
// Which ppears to be in Arduino Board Manager ESP8266 Community version 2.1.0
// Contributed by David Skinner
// begin comes first
SPI.begin();
// datamode
switch ( _dataMode )
{
case DataMode1:
SPI.setDataMode ( SPI_MODE1 );
break;
case DataMode2:
SPI.setDataMode ( SPI_MODE2 );
break;
case DataMode3:
SPI.setDataMode ( SPI_MODE3 );
break;
case DataMode0:
default:
SPI.setDataMode ( SPI_MODE0 );
break;
}
// bitorder
SPI.setBitOrder(_bitOrder == BitOrderLSBFirst ? LSBFIRST : MSBFIRST);
// frequency (this sets the divider)
switch (_frequency)
{
case Frequency1MHz:
default:
SPI.setFrequency(1000000);
break;
case Frequency2MHz:
SPI.setFrequency(2000000);
break;
case Frequency4MHz:
SPI.setFrequency(4000000);
break;
case Frequency8MHz:
SPI.setFrequency(8000000);
break;
case Frequency16MHz:
SPI.setFrequency(16000000);
break;
}
#elif (RH_PLATFORM == RH_PLATFORM_RASPI) // Raspberry PI
uint8_t dataMode;
if (_dataMode == DataMode0)
dataMode = BCM2835_SPI_MODE0;
else if (_dataMode == DataMode1)
dataMode = BCM2835_SPI_MODE1;
else if (_dataMode == DataMode2)
dataMode = BCM2835_SPI_MODE2;
else if (_dataMode == DataMode3)
dataMode = BCM2835_SPI_MODE3;
uint8_t bitOrder;
if (_bitOrder == BitOrderLSBFirst)
bitOrder = BCM2835_SPI_BIT_ORDER_LSBFIRST;
else
bitOrder = BCM2835_SPI_BIT_ORDER_MSBFIRST;
uint32_t divider;
switch (_frequency)
{
case Frequency1MHz:
default:
divider = BCM2835_SPI_CLOCK_DIVIDER_256;
break;
case Frequency2MHz:
divider = BCM2835_SPI_CLOCK_DIVIDER_128;
break;
case Frequency4MHz:
divider = BCM2835_SPI_CLOCK_DIVIDER_64;
break;
case Frequency8MHz:
divider = BCM2835_SPI_CLOCK_DIVIDER_32;
break;
case Frequency16MHz:
divider = BCM2835_SPI_CLOCK_DIVIDER_16;
break;
}
SPI.begin(divider, bitOrder, dataMode);
#else
#warning RHHardwareSPI does not support this platform yet. Consider adding it and contributing a patch.
#endif
#endif // SPI_HAS_TRANSACTION
}
void RHHardwareSPI::usingInterrupt(uint8_t interrupt)
{
#if defined(SPI_HAS_TRANSACTION)
SPI.usingInterrupt(interrupt);
#endif
}
void RHHardwareSPI::detachInterrupt()
{
#if (RH_PLATFORM == RH_PLATFORM_ARDUINO || RH_PLATFORM == RH_PLATFORM_NRF52)
SPI.detachInterrupt();
#endif
}
void RHHardwareSPI::beginTransaction()
{
#if defined(SPI_HAS_TRANSACTION)
SPI.beginTransaction(_settings);
#endif
}
void RHHardwareSPI::endTransaction()
{
#if defined(SPI_HAS_TRANSACTION)
SPI.endTransaction();
#endif
}
uint8_t RHHardwareSPI::transfer(uint8_t data)
{
return SPI.transfer(data);
}
void RHHardwareSPI::end()
{
return SPI.end();
}
void RHHardwareSPI::begin()
{
// Sigh: there are no common symbols for some of these SPI options across all platforms
#if (RH_PLATFORM == RH_PLATFORM_ARDUINO) || (RH_PLATFORM == RH_PLATFORM_UNO32)
uint8_t dataMode;
if (_dataMode == DataMode0)
dataMode = SPI_MODE0;
else if (_dataMode == DataMode1)
dataMode = SPI_MODE1;
else if (_dataMode == DataMode2)
dataMode = SPI_MODE2;
else if (_dataMode == DataMode3)
dataMode = SPI_MODE3;
else
dataMode = SPI_MODE0;
#if (RH_PLATFORM == RH_PLATFORM_ARDUINO) && defined(__arm__) && defined(CORE_TEENSY)
// Temporary work-around due to problem where avr_emulation.h does not work properly for the setDataMode() cal
SPCR &= ~SPI_MODE_MASK;
#else
SPI.setDataMode(dataMode);
#endif
#if (RH_PLATFORM == RH_PLATFORM_ARDUINO) && defined(SPI_HAS_TRANSACTION)
uint32_t frequency32;
if (_frequency == Frequency16MHz) {
frequency32 = 16000000;
} else if (_frequency == Frequency8MHz) {
frequency32 = 8000000;
} else if (_frequency == Frequency4MHz) {
frequency32 = 4000000;
} else if (_frequency == Frequency2MHz) {
frequency32 = 2000000;
} else {
frequency32 = 1000000;
}
uint8_t bOrder;
if (_bitOrder == BitOrderLSBFirst) {
bOrder = LSBFIRST;
} else {
bOrder = MSBFIRST;
}
_settings = SPISettings(frequency32, bOrder, dataMode);
#endif
#if (RH_PLATFORM == RH_PLATFORM_ARDUINO) && defined (__arm__) && !defined(CORE_TEENSY)
// Arduino Due in 1.5.5 has its own BitOrder :-(
::BitOrder bitOrder;
#else
uint8_t bitOrder;
#endif
if (_bitOrder == BitOrderLSBFirst)
bitOrder = LSBFIRST;
else
bitOrder = MSBFIRST;
SPI.setBitOrder(bitOrder);
uint8_t divider;
switch (_frequency)
{
case Frequency1MHz:
default:
#if F_CPU == 8000000
divider = SPI_CLOCK_DIV8;
#else
divider = SPI_CLOCK_DIV16;
#endif
break;
case Frequency2MHz:
#if F_CPU == 8000000
divider = SPI_CLOCK_DIV4;
#else
divider = SPI_CLOCK_DIV8;
#endif
break;
case Frequency4MHz:
#if F_CPU == 8000000
divider = SPI_CLOCK_DIV2;
#else
divider = SPI_CLOCK_DIV4;
#endif
break;
case Frequency8MHz:
divider = SPI_CLOCK_DIV2; // 4MHz on an 8MHz Arduino
break;
case Frequency16MHz:
divider = SPI_CLOCK_DIV2; // Not really 16MHz, only 8MHz. 4MHz on an 8MHz Arduino
break;
}
SPI.setClockDivider(divider);
SPI.begin();
#elif (RH_PLATFORM == RH_PLATFORM_STM32) // Maple etc
spi_mode dataMode;
// Hmmm, if we do this as a switch, GCC on maple gets v confused!
if (_dataMode == DataMode0)
dataMode = SPI_MODE_0;
else if (_dataMode == DataMode1)
dataMode = SPI_MODE_1;
else if (_dataMode == DataMode2)
dataMode = SPI_MODE_2;
else if (_dataMode == DataMode3)
dataMode = SPI_MODE_3;
else
dataMode = SPI_MODE_0;
uint32 bitOrder;
if (_bitOrder == BitOrderLSBFirst)
bitOrder = LSBFIRST;
else
bitOrder = MSBFIRST;
SPIFrequency frequency; // Yes, I know these are not exact equivalents.
switch (_frequency)
{
case Frequency1MHz:
default:
frequency = SPI_1_125MHZ;
break;
case Frequency2MHz:
frequency = SPI_2_25MHZ;
break;
case Frequency4MHz:
frequency = SPI_4_5MHZ;
break;
case Frequency8MHz:
frequency = SPI_9MHZ;
break;
case Frequency16MHz:
frequency = SPI_18MHZ;
break;
}
SPI.begin(frequency, bitOrder, dataMode);
#elif (RH_PLATFORM == RH_PLATFORM_STM32STD) // STM32F4 discovery
uint8_t dataMode;
if (_dataMode == DataMode0)
dataMode = SPI_MODE0;
else if (_dataMode == DataMode1)
dataMode = SPI_MODE1;
else if (_dataMode == DataMode2)
dataMode = SPI_MODE2;
else if (_dataMode == DataMode3)
dataMode = SPI_MODE3;
else
dataMode = SPI_MODE0;
uint32_t bitOrder;
if (_bitOrder == BitOrderLSBFirst)
bitOrder = LSBFIRST;
else
bitOrder = MSBFIRST;
SPIFrequency frequency; // Yes, I know these are not exact equivalents.
switch (_frequency)
{
case Frequency1MHz:
default:
frequency = SPI_1_3125MHZ;
break;
case Frequency2MHz:
frequency = SPI_2_625MHZ;
break;
case Frequency4MHz:
frequency = SPI_5_25MHZ;
break;
case Frequency8MHz:
frequency = SPI_10_5MHZ;
break;
case Frequency16MHz:
frequency = SPI_21_0MHZ;
break;
}
SPI.begin(frequency, bitOrder, dataMode);
#else
#warning RHHardwareSPI does not support this platform yet. Consider adding it and contributing a patch.
#endif
}
void RHHardwareSPI::attachInterrupt()
{
#if (RH_PLATFORM == RH_PLATFORM_ARDUINO)
SPI.attachInterrupt();
#endif
}
void GDClass::__start(unsigned int addr) // start an SPI transaction to addr
{
digitalWrite(SS_PIN, LOW);
SPI.transfer(highByte(addr));
SPI.transfer(lowByte(addr));
}
void GDClass::wr(unsigned int addr, byte v)
{
__wstart(addr);
SPI.transfer(v);
__end();
}
void setup() {
int logNo;
char configLineBuffer[LINE_BUFFER_MAX];
spi.begin(SPI_281_250KHZ, MSBFIRST, 0);
pinMode(GRN_LED,OUTPUT);
pinMode(ORN_LED,OUTPUT);
pinMode(RED_LED,OUTPUT);
digitalWrite(GRN_LED,HIGH);
digitalWrite(ORN_LED,LOW);
digitalWrite(RED_LED,LOW);
iwdg_init(IWDG_PRE_256, WATCHDOG_TIMEOUT);
Watchdog_Reset();
if (!card.init(&spi)) {
//if (!card.init()) {
console.printf("FTL: card.init failed");
}
delay(100);
// initialize a FAT volume
if (!volume.init(&card)) {
console.printf("FTL: volume.init failed");
}
// open the root directory
if (!root.openRoot(&volume))
;//SerialUSB.println("FTL: openRoot failed");
for (logNo=0; (!logOpened) && logNo<512; logNo++) {
Watchdog_Reset();
//int snprintf(char *str, size_t size, const char *format, ...);
snprintf(logFileName,15,"LOG%03d.TXT",logNo);
if (file.open(&root, logFileName, O_READ)) {
//SerialUSB.print("DBG: Exists :"); SerialUSB.println(logFileName);
file.close();
} else if (file.open(&root, logFileName, O_CREAT|O_READ|O_WRITE)) {
//SerialUSB.print("DBG: New File:"); SerialUSB.println(logFileName);
logOpened=true;
file.sync();
file.close();
file.open(&root,logFileName,O_WRITE|O_READ);
while (file.read(configLineBuffer,LINE_BUFFER_MAX)) {
}
file.sync();
}
}
//if (!logOpened) SerialUSB.println("FTL: openRoot failed");
digitalWrite(GRN_LED,LOW);
digitalWrite(RED_LED,HIGH);
readSettings();
console.printf("LSV:" BOM_VERSION "\r\n");
console.printf("NST: %s\r\n",networkStatus()?"CONNECTED":"NOT CONNECTED");
digitalWrite(ORN_LED,HIGH);
digitalWrite(RED_LED,networkStatus()?HIGH:LOW);
}
