void TFT_ILI9163C::sleepMode(boolean mode) {
if (mode){
if (sleep == 1) return;//already sleeping
sleep = 1;
#if defined(__MK20DX128__) || defined(__MK20DX256__)
SPI.beginTransaction(SPISettings(SPICLOCK, MSBFIRST, SPI_MODE0));
writecommand_last(CMD_SLPIN);
endProc();
#else
writecommand(CMD_SLPIN);
#endif
delay(5);//needed
} else {
if (sleep == 0) return; //Already awake
sleep = 0;
#if defined(__MK20DX128__) || defined(__MK20DX256__)
SPI.beginTransaction(SPISettings(SPICLOCK, MSBFIRST, SPI_MODE0));
writecommand_last(CMD_SLPOUT);
endProc();
#else
writecommand(CMD_SLPOUT);
#endif
delay(120);//needed
}
}
/*
Init the GPIO chip. It also init SPI bus.
There's a lot of stuff running inside this function, it checks
for legal pins and SPI bus, can handle alternative SPI bus and pins,
init correctly SPI bus and only once (in case of multiple instances).
Parameters
avoidSpiInit: if you use this library after any other SPI devices
that already have SPI inited, you may use this option that will avoid SPI.begin().
Normally you better don't use at all this option...
*/
void gpio_MCP23SXX::begin(bool avoidSpiInit)
{
if (_chip == MCPNONE) return;//unknow chip
_readCmd = (_adrs << 1) | 1;
_writeCmd = _adrs << 1;
_gpioDirection = 0xFFFF;//all inputs
_gpioState = 0x0000;//bogus
gpio_MCP23SXX_instance += 1;//instance counter
if (gpio_MCP23SXX_instance > 1) avoidSpiInit = true;//do not init SPI again
#if defined(SPI_LEGACY_METHOD)
//using internal SPI methods
if (beginSpi(avoidSpiInit) != 0xFF) return;//if != 0xFF cannot continue
//set SPI speed...
#if defined(SPI_HAS_TRANSACTION)
setSpiSettings(SPISettings(_maxGpioSPIspeed, MSBFIRST, SPI_MODE0));
#else
//pre - SPI transaction era...
SPI.setClockDivider(SPI_CLOCK_DIV4);
SPI.setBitOrder(MSBFIRST);
SPI.setDataMode(SPI_MODE0);
#endif
#else
//using high speed external SPI libraries
#if (defined(__MK20DX128__) || defined(__MK20DX256__) || defined(__MK64FX512__) || defined(__MK66FX1M0__) || defined(__MKL26Z64__))
_spi.postInstance(_cs,255,_mosi,_sclk,_miso);
#elif (defined(__AVR__) || defined(ESP8266))
_spi.postInstance(_cs,255);
#endif
//begin SPI and set SPI speed...
#if defined(SPI_HAS_TRANSACTION)
_spi.begin(SPISettings(_maxGpioSPIspeed, MSBFIRST, SPI_MODE0),avoidSpiInit);
#else
_spi.begin(avoidSpiInit);
#endif
#endif
/*
The IOCON register!
7 6 5 4 3 2 1 0
MCP23S08 IOCON = NA NA SEQOP DISSLW HAEN ODR INTPOL NA
MCP23S09 IOCON = NA NA SEQOP NA NA ODR INTPOL INTCC
MCP23S17 IOCON = BANK MIRROR SEQOP DISSLW HAEN ODR INTPOL NA
MCP23S18 IOCON = BANK MIRROR SEQOP NA NA ODR INTPOL INTCC
*/
if (_chip == MCP23S09 || _chip == MCP23S18){
//these chip doesn't use HAEN
gpioSetup(_SEQOP | _INTCC);//enable INTCC always
} else {
_useHaen == 1 ? gpioSetup(_SEQOP | _HAEN) : gpioSetup(_SEQOP);
}
//as default, GPIO init as High-Impedance input
gpioPinMode(INPUT);
}
uint8_t Sd2Card::setSckRate(uint8_t sckRateID) {
if (sckRateID > 6) {
error(SD_CARD_ERROR_SCK_RATE);
return false;
}
#endif
#ifndef USE_SPI_LIB
// see avr processor datasheet for SPI register bit definitions
if ((sckRateID & 1) || sckRateID == 6) {
SPSR &= ~(1 << SPI2X);
} else {
SPSR |= (1 << SPI2X);
}
SPCR &= ~((1 <<SPR1) | (1 << SPR0));
SPCR |= (sckRateID & 4 ? (1 << SPR1) : 0)
| (sckRateID & 2 ? (1 << SPR0) : 0);
#else // USE_SPI_LIB
#ifdef ESP8266
settings = SPISettings(sckRateID, MSBFIRST, SPI_MODE0);
#else
switch (sckRateID) {
case 0: settings = SPISettings(25000000, MSBFIRST, SPI_MODE0); break;
case 1: settings = SPISettings(4000000, MSBFIRST, SPI_MODE0); break;
case 2: settings = SPISettings(2000000, MSBFIRST, SPI_MODE0); break;
case 3: settings = SPISettings(1000000, MSBFIRST, SPI_MODE0); break;
case 4: settings = SPISettings(500000, MSBFIRST, SPI_MODE0); break;
case 5: settings = SPISettings(250000, MSBFIRST, SPI_MODE0); break;
default: settings = SPISettings(125000, MSBFIRST, SPI_MODE0);
}
#endif
#endif // USE_SPI_LIB
return true;
}
LOCAL uint8_t RF24_spiMultiByteTransfer(const uint8_t cmd, uint8_t* buf, uint8_t len,
const bool aReadMode)
{
uint8_t status;
uint8_t* current = buf;
#if !defined(MY_SOFTSPI)
_SPI.beginTransaction(SPISettings(MY_RF24_SPI_MAX_SPEED, MY_RF24_SPI_DATA_ORDER,
MY_RF24_SPI_DATA_MODE));
#endif
RF24_csn(LOW);
// timing
delayMicroseconds(10);
#ifdef LINUX_SPI_BCM
uint8_t * prx = spi_rxbuff;
uint8_t * ptx = spi_txbuff;
uint8_t size = len + 1; // Add register value to transmit buffer
*ptx++ = cmd;
while ( len-- ) {
if (aReadMode) {
*ptx++ = RF24_NOP;
} else {
*ptx++ = *current++;
}
}
_SPI.transfernb( (char *) spi_txbuff, (char *) spi_rxbuff, size);
if (aReadMode) {
if (size == 2) {
status = *++prx; // result is 2nd byte of receive buffer
} else {
status = *prx++; // status is 1st byte of receive buffer
// decrement before to skip status byte
while (--size) {
*buf++ = *prx++;
}
}
} else {
status = *prx; // status is 1st byte of receive buffer
}
#else
status = _SPI.transfer(cmd);
while ( len-- ) {
if (aReadMode) {
status = _SPI.transfer(RF24_NOP);
if (buf != NULL) {
*current++ = status;
}
} else {
status = _SPI.transfer(*current++);
}
}
#endif
RF24_csn(HIGH);
#if !defined(MY_SOFTSPI)
_SPI.endTransaction();
#endif
// timing
delayMicroseconds(10);
return status;
}
// function to write a register value to the adc
// argumen: adress for the register to write into, value to write
void ads12xx::SetRegisterValue(uint8_t regAdress, uint8_t regValue) {
#ifdef ADS1248
if (regAdress == IDAC0) {
regValue = regValue | IDAC0_ID; // add non 0 non-write register value IDAC0_ID
}
#endif
uint8_t regValuePre = ads12xx::GetRegisterValue(regAdress);
if (regValue != regValuePre) {
delayMicroseconds(10);
waitforDRDY();
SPI.beginTransaction(SPISettings(SPI_SPEED, MSBFIRST, SPI_MODE1)); // initialize SPI with SPI_SPEED, MSB first, SPI Mode1
digitalWrite(_CS, LOW);
delayMicroseconds(10);
SPI.transfer(WREG | regAdress); // send 1st command byte, address of the register
SPI.transfer(0x00); // send 2nd command byte, write only one register
SPI.transfer(regValue); // write data (1 Byte) for the register
delayMicroseconds(10);
digitalWrite(_CS, HIGH);
if (regValue != ads12xx::GetRegisterValue(regAdress)) { //Check if write was succesfull
Serial.print("Write to Register 0x");
Serial.print(regAdress, HEX);
Serial.println(" failed!");
}
else
SPI.endTransaction();
}
}
uint8_t Adafruit_LIS3DH::readRegister8(uint8_t reg) {
uint8_t value;
if (_cs == -1) {
Wire.beginTransmission(_i2caddr);
Wire.write((uint8_t)reg);
Wire.endTransmission();
Wire.requestFrom(_i2caddr, 1);
value = Wire.read();
}
#ifndef __AVR_ATtiny85__
else {
if (_sck == -1)
SPI.beginTransaction(SPISettings(500000, MSBFIRST, SPI_MODE0));
digitalWrite(_cs, LOW);
spixfer(reg | 0x80); // read, bit 7 high
value = spixfer(0);
digitalWrite(_cs, HIGH);
if (_sck == -1)
SPI.endTransaction(); // release the SPI bus
}
#endif
return value;
}
int16_t Adafruit_LIS3DH::readADC(uint8_t adc) {
if ((adc < 1) || (adc > 3)) return 0;
uint16_t value;
adc--;
uint8_t reg = LIS3DH_REG_OUTADC1_L + adc*2;
if (_cs == -1) {
// i2c
Wire.beginTransmission(_i2caddr);
Wire.write(reg | 0x80); // 0x80 for autoincrement
Wire.endTransmission();
Wire.requestFrom(_i2caddr, 2);
value = Wire.read(); value |= ((uint16_t)Wire.read()) << 8;
} else {
if (_sck == -1)
SPI.beginTransaction(SPISettings(500000, MSBFIRST, SPI_MODE0));
digitalWrite(_cs, LOW);
spixfer(reg | 0x80 | 0x40); // read multiple, bit 7&6 high
value = spixfer(); value |= ((uint16_t)spixfer()) << 8;
digitalWrite(_cs, HIGH);
if (_sck == -1)
SPI.endTransaction(); // release the SPI bus
}
return value;
}
static inline void m_aci_reqn_enable (void)
{
#if defined(SPI_HAS_TRANSACTION) && !defined(__SAMD21G18A__)
SPI.beginTransaction(SPISettings(2000000, LSBFIRST, SPI_MODE0));
#endif
digitalWrite(a_pins_local_ptr->reqn_pin, 0);
}
void TFT_ILI9163C::setRotation(uint8_t m) {
rotation = m % 4; // can't be higher than 3
switch (rotation) {
case 0:
_Mactrl_Data = 0b00001000;
_width = _TFTWIDTH;
_height = _TFTHEIGHT;//-__OFFSET;
break;
case 1:
_Mactrl_Data = 0b01101000;
_width = _TFTHEIGHT;//-__OFFSET;
_height = _TFTWIDTH;
break;
case 2:
_Mactrl_Data = 0b11001000;
_width = _TFTWIDTH;
_height = _TFTHEIGHT;//-__OFFSET;
break;
case 3:
_Mactrl_Data = 0b10101000;
_width = _TFTWIDTH;
_height = _TFTHEIGHT;//-__OFFSET;
break;
}
colorSpace(_colorspaceData);
#if defined(__MK20DX128__) || defined(__MK20DX256__)
SPI.beginTransaction(SPISettings(SPICLOCK, MSBFIRST, SPI_MODE0));
writecommand_cont(CMD_MADCTL);
writedata8_last(_Mactrl_Data);
endProc();
#else
writecommand(CMD_MADCTL);
writedata(_Mactrl_Data);
#endif
}
void
sd_spi_begin_transaction(
uint32_t transfer_speed_hz
)
{
SPI.beginTransaction(SPISettings(transfer_speed_hz, MSBFIRST, SPI_MODE0));
}
void TFT_ILI9163C::setAddrWindow(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1) {
#if defined(__MK20DX128__) || defined(__MK20DX256__)
SPI.beginTransaction(SPISettings(SPICLOCK, MSBFIRST, SPI_MODE0));
_setAddrWindow(x0,y0,x1,y1);
SPI.endTransaction();
#else
writecommand(CMD_CLMADRS); // Column
if (rotation == 0 || rotation > 1){
writedata16(x0);
writedata16(x1);
} else {
writedata16(x0 + __OFFSET);
writedata16(x1 + __OFFSET);
}
writecommand(CMD_PGEADRS); // Page
if (rotation == 0){
writedata16(y0 + __OFFSET);
writedata16(y1 + __OFFSET);
} else {
writedata16(y0);
writedata16(y1);
}
writecommand(CMD_RAMWR); //Into RAM
#endif
}
void bareRFM69::writeRegister(uint8_t reg, uint8_t data){
SPI.beginTransaction(SPISettings(10000000, MSBFIRST, SPI_MODE0)); // gain control of SPI bus
this->chipSelect(true); // assert chip select
SPI.transfer(RFM69_WRITE_REG_MASK | (reg & RFM69_READ_REG_MASK));
SPI.transfer(data);
this->chipSelect(false);// deassert chip select
SPI.endTransaction(); // release the SPI bus
}
void TFT_ILI9163C::setAddr(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1){
#if defined(__MK20DX128__) || defined(__MK20DX256__)
SPI.beginTransaction(SPISettings(SPICLOCK, MSBFIRST, SPI_MODE0));
_setAddrWindow(x0,y0,x1,y1);
#else
setAddrWindow(x0,y0,x1,y1);
#endif
}
/**
* Set the SPI clock rate.
*
* \param[in] sckRateID A value in the range [0, 6].
*
* 0 = 8 MHz
* 1 = 4 MHz
* 2 = 2 MHz
* 3 = 1 MHz
* 4 = 500 kHz
* 5 = 125 kHz
* 6 = 63 kHz
*
* The SPI clock will be set to F_CPU/pow(2, 1 + sckRateID). The maximum
* SPI rate is F_CPU/2 for \a sckRateID = 0 and the minimum rate is F_CPU/128
* for \a scsRateID = 6.
*
* \return The value one, true, is returned for success and the value zero,
* false, is returned for an invalid value of \a sckRateID.
*/
uint8_t Sd2Card::setSckRate(uint8_t sckRateID) {
#ifdef USE_TEENSY3_SPI
spiInit(sckRateID);
return true;
#else
if (sckRateID > 6) sckRateID = 6;
// see avr processor datasheet for SPI register bit definitions
if ((sckRateID & 1) || sckRateID == 6) {
SPSR &= ~(1 << SPI2X);
} else {
SPSR |= (1 << SPI2X);
}
SPCR &= ~((1 <<SPR1) | (1 << SPR0));
SPCR |= (sckRateID & 4 ? (1 << SPR1) : 0)
| (sckRateID & 2 ? (1 << SPR0) : 0);
#ifdef SPI_HAS_TRANSACTION
switch (sckRateID) {
case 0: settings = SPISettings(8000000, MSBFIRST, SPI_MODE0); break;
case 1: settings = SPISettings(4000000, MSBFIRST, SPI_MODE0); break;
case 2: settings = SPISettings(2000000, MSBFIRST, SPI_MODE0); break;
case 3: settings = SPISettings(1000000, MSBFIRST, SPI_MODE0); break;
case 4: settings = SPISettings(500000, MSBFIRST, SPI_MODE0); break;
case 5: settings = SPISettings(250000, MSBFIRST, SPI_MODE0); break;
default: settings = SPISettings(125000, MSBFIRST, SPI_MODE0);
}
#endif
return true;
#endif
}
void TFT_ILI9163C::invertDisplay(boolean i) {
#if defined(__MK20DX128__) || defined(__MK20DX256__)
SPI.beginTransaction(SPISettings(SPICLOCK, MSBFIRST, SPI_MODE0));
writecommand_last(i ? CMD_DINVON : CMD_DINVOF);
SPI.endTransaction();
#else
writecommand(i ? CMD_DINVON : CMD_DINVOF);
#endif
}
void TFT_ILI9163C::drawRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color){
SPI.beginTransaction(SPISettings(SPICLOCK, MSBFIRST, SPI_MODE0));
HLine(x, y, w, color);
HLine(x, y+h-1, w, color);
VLine(x, y, h, color);
VLine(x+w-1, y, h, color);
writecommand_last(CMD_NOP);
SPI.endTransaction();
}
void TFT_ILI9163C::pushColor(uint16_t color) {
#if defined(__MK20DX128__) || defined(__MK20DX256__)
SPI.beginTransaction(SPISettings(SPICLOCK, MSBFIRST, SPI_MODE0));
writedata16_last(color);
endProc();
#else
writedata16(color);
#endif
}
uint8_t bareRFM69::readRegister(uint8_t reg){
uint8_t foo;
SPI.beginTransaction(SPISettings(10000000, MSBFIRST, SPI_MODE0)); // gain control of SPI bus
this->chipSelect(true); // assert chip select
SPI.transfer((reg % RFM69_READ_REG_MASK));
foo = SPI.transfer(0);
this->chipSelect(false);// deassert chip select
SPI.endTransaction(); // release the SPI bus
return foo;
}
void TFT_ILI9163C::display(boolean onOff) {
if (onOff){
#if defined(__MK20DX128__) || defined(__MK20DX256__)
SPI.beginTransaction(SPISettings(SPICLOCK, MSBFIRST, SPI_MODE0));
writecommand_last(CMD_DISPON);
endProc();
#else
writecommand(CMD_DISPON);
#endif
} else {
#if defined(__MK20DX128__) || defined(__MK20DX256__)
SPI.beginTransaction(SPISettings(SPICLOCK, MSBFIRST, SPI_MODE0));
writecommand_last(CMD_DISPOFF);
endProc();
#else
writecommand(CMD_DISPOFF);
#endif
}
}
/*
Sends a Command to the ADC
Like SELFCAL, GAIN, SYNC, WAKEUP
*/
void ads12xx::SendCMD(uint8_t cmd) {
waitforDRDY();
SPI.beginTransaction(SPISettings(SPI_SPEED, MSBFIRST, SPI_MODE1)); // initialize SPI with 4Mhz clock, MSB first, SPI Mode0
digitalWrite(_CS, LOW);
delayMicroseconds(10);
SPI.transfer(cmd);
delayMicroseconds(10);
digitalWrite(_CS, HIGH);
SPI.endTransaction();
}
/*
Return register content from bank A & B of a 16 bit GPIO chip,
combined in a 16 bit data. An 8 Bit chip will return always bank A.
Parameters
reg: a legal 8bit MCP23Sxx register.
*/
uint16_t gpio_MCP23SXX::gpioReadRegisterBoth(byte reg)
{
if (_ports < 16){
return gpioReadRegister(reg);
} else {
uint16_t result = 0;
#if defined(SPI_LEGACY_METHOD)
startTransaction();
writeByte_cont(_readCmd);
writeByte_cont(reg);
#if defined(SPI_HAS_TRANSACTION)
setSpiSettings(SPISettings(10000000, MSBFIRST, SPI_MODE0));
result = readWord_cont();
setSpiSettings(SPISettings(_maxGpioSPIspeed, MSBFIRST, SPI_MODE0));
#else
result = readWord_cont();
#endif
disableCS();
endTransaction();
#else
_spi.startTransaction();
_spi.writeByte_cont(_readCmd);
_spi.writeByte_cont(reg);
#if (defined(__MK20DX128__) || defined(__MK20DX256__) || defined(__MK64FX512__) || defined(__MK66FX1M0__))
_spi.waitTransmitComplete();
#endif
#if defined(SPI_HAS_TRANSACTION)
_spi.setSpiSettings(SPISettings(10000000, MSBFIRST, SPI_MODE0));
result = _spi.readWord_cont(false);//command mode
_spi.setSpiSettings(SPISettings(_maxGpioSPIspeed, MSBFIRST, SPI_MODE0));
#else
result = _spi.readWord_cont(false);//command mode
#endif
#if (defined(__MK20DX128__) || defined(__MK20DX256__) || defined(__MK64FX512__) || defined(__MK66FX1M0__))
_spi.writeByte_last(0xFF);//NOP?
#else
_spi.disableCS();
#endif
_spi.endTransaction();
#endif
return result;
}
}
bool RTIMUHal::HALOpen()
{
SPI.begin();
pinMode(m_SPISelect, OUTPUT);
SPI.setSCK(SPI_SCLK);
SPI.setMOSI(SPI_MOSI);
SPI.setMISO(SPI_MISO);
m_SPISettings = SPISettings(m_SPISpeed, MSBFIRST, SPI_MODE0);
return true;
}
bool RTIMUHal::HALOpen()
{
if (m_busIsI2C)
return true;
SPI.begin();
pinMode(m_SPISelect, OUTPUT);
m_SPISettings = SPISettings(m_SPISpeed, MSBFIRST, SPI_MODE0);
return true;
}
void TFT_ILI9163C::scroll(uint16_t adrs) {
#if defined(__MK20DX128__) || defined(__MK20DX256__)
SPI.beginTransaction(SPISettings(SPICLOCK, MSBFIRST, SPI_MODE0));
writecommand_cont(CMD_VSSTADRS);
writedata16_last(adrs);
endProc();
#else
writecommand(CMD_VSSTADRS);
writedata16(adrs);
#endif
}
// function to reset the adc
void ads12xx::Reset() {
SPI.beginTransaction(SPISettings(SPI_SPEED, MSBFIRST, SPI_MODE1)); // initialize SPI with clock, MSB first, SPI Mode1
digitalWrite(_CS, LOW);
delayMicroseconds(10);
SPI.transfer(RESET); //Reset
delay(2); //Minimum 0.6ms required for Reset to finish.
SPI.transfer(SDATAC); //Issue SDATAC
delayMicroseconds(100);
digitalWrite(_CS, HIGH);
SPI.endTransaction();
}
void bareRFM69::writeMultiple(uint8_t reg, void* data, uint8_t len){
SPI.beginTransaction(SPISettings(10000000, MSBFIRST, SPI_MODE0)); // gain control of SPI bus
this->chipSelect(true); // assert chip select
SPI.transfer(RFM69_WRITE_REG_MASK | (reg & RFM69_READ_REG_MASK));
uint8_t* r = reinterpret_cast<uint8_t*>(data);
for (uint8_t i=0; i < len ; i++){
SPI.transfer(r[len - i - 1]);
}
this->chipSelect(false);// deassert chip select
SPI.endTransaction(); // release the SPI bus
}
/* ------------------------------ Low Level ----------------*/
void mcp23s08::startSend(bool mode){
#if defined (SPI_HAS_TRANSACTION)
if (_spiTransactionsSpeed > 0) SPI.beginTransaction(SPISettings(_spiTransactionsSpeed, MSBFIRST, SPI_MODE0));
#endif
#if defined(__FASTWRITE)
digitalWriteFast(_cs, LOW);
#else
digitalWrite(_cs, LOW);
#endif
mode == 1 ? SPI.transfer(_readCmd) : SPI.transfer(_writeCmd);
}
// Writes SPI to particular register.
// registerInfo is a 2-element array which contains [register, number of bytes]
void AD9910::writeRegister(reg_t payload){
SPI.beginTransaction(SPISettings(CLOCKSPEED, MSBFIRST, SPI_MODE0));
digitalWrite(_ssPin, LOW);
SPI.transfer(payload.addr);
// MSB
for (int i = payload.bytes; i > 0; i--){
SPI.transfer(payload.data.bytes[i-1]);
}
digitalWrite(_ssPin, HIGH);
SPI.endTransaction();
}
void bareRFM69::writeFIFO(void* buffer, uint8_t len){
uint8_t* r = reinterpret_cast<uint8_t*>(buffer);
SPI.beginTransaction(SPISettings(10000000, MSBFIRST, SPI_MODE0)); // gain control of SPI bus
this->chipSelect(true); // assert chip select
SPI.transfer(RFM69_WRITE_REG_MASK | (RFM69_FIFO & RFM69_READ_REG_MASK));
for (uint8_t i=0; i < len ; i++){
// Serial.print("Writing to FIFO: "); Serial.println(r[i]);
SPI.transfer(r[i]);
}
this->chipSelect(false);// deassert chip select
SPI.endTransaction(); // release the SPI bus
}
void bareRFM69::readFIFO(void* buffer, uint8_t len){
uint8_t* r = reinterpret_cast<uint8_t*>(buffer);
SPI.beginTransaction(SPISettings(10000000, MSBFIRST, SPI_MODE0)); // gain control of SPI bus
this->chipSelect(true); // assert chip select
SPI.transfer((RFM69_FIFO % RFM69_READ_REG_MASK));
for (uint8_t i=0; i < len ; i++){
r[i] = SPI.transfer(0);
}
this->chipSelect(false);// deassert chip select
SPI.endTransaction(); // release the SPI bus
}
