unsigned char CC2500xcvr::sendBurstCommand(unsigned char command, unsigned char* data, unsigned char length) { spiTransactionBegin(); // enable device // send command byte spiTransfer(command); // this is a burst command unsigned char result = 0; // send/recv data bytes for (int i=0; i<length; ++i) { result = spiTransfer(data[i]); // send data[i] = result; // receive into the same buffer } spiTransactionEnd(); // disable device return result; // return result }
bool mpu6000ReadRegister(uint8_t reg, uint8_t length, uint8_t *data) { ENABLE_MPU6000; spiTransferByte(MPU6000_SPI_INSTANCE, reg | 0x80); // read transaction spiTransfer(MPU6000_SPI_INSTANCE, data, NULL, length); DISABLE_MPU6000; return true; }
void readEepromPage(uint16_t address, uint16_t length) { // here again we have a word address for (uint16_t addr = address * 2, i = 0; i < length; i++) { uint8_t ee = spiTransfer(0xA0, addr++, 0xFF); Serial.write(ee); } Serial.write(STK_OK); }
void LedControl::setRow(int addr, int row, byte value) { int offset; if(addr<0 || addr>=maxDevices) return; if(row<0 || row>7) return; offset=addr*8; status[offset+row]=value; spiTransfer(addr, row+1,status[offset+row]); }
void writeEnable(void) { ENABLE_EEPROM; spiTransfer(EEPROM_SPI, WRITE_ENABLE); DISABLE_EEPROM; delayMicroseconds(2); }
void MAX7219::clearDisplay(int addr) { if (addr < 0 || addr >= maxDevices) return; int offset; offset = addr * 8; for (uint8_t i = 0; i < 8; i++) { status[offset + i] = 0; spiTransfer(addr, i + 1, status[offset + i]); } }
bool mpu9250SlowReadRegister(uint8_t reg, uint8_t length, uint8_t *data) { ENABLE_MPU9250; delayMicroseconds(1); spiTransferByte(MPU9250_SPI_INSTANCE, reg | 0x80); // read transaction spiTransfer(MPU9250_SPI_INSTANCE, data, NULL, length); DISABLE_MPU9250; delayMicroseconds(1); return true; }
void LedControl::clearDisplay(int addr) { int offset; if(addr<0 || addr>=maxDevices) return; offset=addr*8; for(int i=0;i<8;i++) { status[offset+i]=0; } if (anodeMode) { transposeData(addr); for(int i=0;i<8;i++) { spiTransfer(addr, i+1, statusTransposed[offset+i]); } } else { for(int i=0;i<8;i++) { spiTransfer(addr, i+1, status[offset+i]); } } }
void LedControl::clearDisplay(int addr) { int offset; if(addr<0 || addr>=maxDevices) return; offset=addr*8; for(int i=0;i<8;i++) { status[offset+i]=0; spiTransfer(addr, i+1,status[offset+i]); } }
void MAX7219::setDigit(int digit, uint8_t value, bool dp, int addr) { if (addr < 0 || addr >= maxDevices) return; if (digit < 0 || digit > 7 || value > 15) return; int offset = addr * 8; uint8_t v = charTable[value]; if (dp) { v |= 0b10000000; } status[offset + digit] = v; spiTransfer(addr, digit + 1, v); }
void m25p16_pageProgramBegin(uint32_t address) { uint8_t command[] = { M25P16_INSTRUCTION_PAGE_PROGRAM, (address >> 16) & 0xFF, (address >> 8) & 0xFF, address & 0xFF}; m25p16_waitForReady(DEFAULT_TIMEOUT_MILLIS); m25p16_writeEnable(); ENABLE_M25P16; spiTransfer(M25P16_SPI_INSTANCE, NULL, command, sizeof(command)); }
static bool spiTest(void) { uint8_t out[] = { 0x9F, 0, 0, 0 }; uint8_t in[4]; spiSelect(true); spiTransfer(in, out, sizeof(out)); spiSelect(false); if (in[1] == 0xEF) return true; return false; }
MAX7219::MAX7219(SPI* spi, int numDevices) { assert(spi != nullptr); this->spi = spi; if (numDevices <= 0 || numDevices > 8) { numDevices = 8; } maxDevices = numDevices; for (uint8_t i = 0; i < 64; i++) { status[i] = 0x00; } for (int i = 0; i < maxDevices; i++) { spiTransfer(i, OP_DISPLAYTEST, 0); //scanlimit is set to max on startup setScanLimit(7, i); //decode is done in source spiTransfer(i, OP_DECODEMODE, 0); clearDisplay(i); //we go into shutdown-mode on startup shutdown(true, i); } }
static uint8_t m25p16_readStatus() { uint8_t command[2] = { M25P16_INSTRUCTION_READ_STATUS_REG, 0 }; uint8_t in[2]; ENABLE_M25P16; spiTransfer(M25P16_SPI_INSTANCE, in, command, sizeof(command)); DISABLE_M25P16; return in[1]; }
void MAX7219::setChar(int digit, char value, bool dp, int addr) { if (addr < 0 || addr >= maxDevices) return; if (digit < 0 || digit > 7) return; int offset = addr * 8; uint8_t index = (uint8_t) value; if (index > 127) index = 32; // not defined beyond index 127, so we use the space char uint8_t v = charTable[index]; if (dp) { v |= 0b10000000; } status[offset + digit] = v; spiTransfer(addr, digit + 1, v); }
/** * Erase a sector full of bytes to all 1's at the given byte offset in the flash chip. */ void m25p16_eraseSector(uint32_t address) { uint8_t out[] = { M25P16_INSTRUCTION_SECTOR_ERASE, (address >> 16) & 0xFF, (address >> 8) & 0xFF, address & 0xFF}; m25p16_waitForReady(SECTOR_ERASE_TIMEOUT_MILLIS); m25p16_writeEnable(); ENABLE_M25P16; spiTransfer(M25P16_SPI_INSTANCE, NULL, out, sizeof(out)); DISABLE_M25P16; }
/** \brief SPI command. Setup DC and SS pins, then send command via SPI to SSD1306 controller. */ void MicroOLED::command(uint8_t c) { if (interface == MODE_SPI) { digitalWrite(dcPin, LOW); digitalWrite(csPin, LOW); spiTransfer(c); digitalWrite(csPin, HIGH); } else if (interface == MODE_I2C) { digitalWrite(dcPin, LOW); // DC pin LOW i2cWrite(I2C_ADDRESS_SA0_1, I2C_COMMAND, c); } }
void CC2500xcvr::reset() // REFERENCES: 19.1.2 "Manual Reset" in [1] { // enable device digitalWrite(m_pinCS_n, LOW); delayMicroseconds(1); // disable device and wait at least 40 microseconds digitalWrite(m_pinCS_n, HIGH); delayMicroseconds(41); spiTransactionBegin(); // enable device spiTransfer(0x30); // send reset command (SRES) spiTransactionEnd(); // disable device }
void writeFlash(uint16_t address, uint16_t length) { if (length > _param.flash_pagesize || length > BUFF_LENGTH) { _error = true; Serial.write(STK_FAILED); return; } fill(length); if (!receiveEop()) return; for (uint8_t *p = _buff, word_length = length >> 1, i = 0; i < word_length; i++) { spiTransfer(0x40, i, *p++); spiTransfer(0x48, i, *p++); } spiTransfer(0x4C, getPage(address), 0); Serial.write(STK_OK); }
/* * Class: io_silverspoon_bulldog_linux_jni_NativeSpi * Method: spiTransfer * Signature: (IJJIIII)I */ JNIEXPORT jint JNICALL Java_io_silverspoon_bulldog_linux_jni_NativeSpi_spiTransfer (JNIEnv * env , jclass clazz, jint fileDescriptor, jobject txBuffer, jobject rxBuffer, jint transferLength, jint delay, jint speed, jint bitsPerWord) { unsigned int* pTx = NULL; unsigned int* pRx = NULL; if(txBuffer != NULL) { pTx = (unsigned int*) (*env)->GetDirectBufferAddress(env, txBuffer); } if(rxBuffer != NULL) { pRx = (unsigned int*) (*env)->GetDirectBufferAddress(env, rxBuffer); } return spiTransfer((int)fileDescriptor, (unsigned int*)pTx, (unsigned int*)pTx, (int)transferLength, (int)delay, (int)speed, (int)bitsPerWord); }
/** \brief SPI data. Setup DC and SS pins, then send data via SPI to SSD1306 controller. */ void MicroOLED::data(uint8_t c) { if (interface == MODE_SPI) { digitalWrite(dcPin, HIGH); digitalWrite(csPin, LOW); spiTransfer(c); digitalWrite(csPin, HIGH); } else if (interface == MODE_I2C) { digitalWrite(dcPin, HIGH); // DC pin HIGH i2cWrite(I2C_ADDRESS_SA0_1, I2C_DATA, c); } }
void LedControl::setDigit(int addr, int digit, byte value, boolean dp) { int offset; byte v; if(addr<0 || addr>=maxDevices) return; if(digit<0 || digit>7 || value>15) return; offset=addr*8; v=charTable[value]; if(dp) v|=B10000000; status[offset+digit]=v; spiTransfer(addr, digit+1,v); }
void beginProgramming() { SPI.begin(); digitalWrite(RESET, HIGH); pinMode(RESET, OUTPUT); digitalWrite(SCK, LOW); digitalWrite(RESET, LOW); digitalWrite(RESET, HIGH); digitalWrite(RESET, LOW); delay(20); spiTransfer(0xAC, 0x53, 0x00, 0x00); _programming = true; }
int SpiDrv::waitResponse(uint8_t cmd, uint8_t* numParamRead, uint8_t** params, uint8_t maxNumParams) { char _data = 0; int i =0, ii = 0; char *index[WL_SSID_MAX_LENGTH]; for (i = 0 ; i < WL_NETWORKS_LIST_MAXNUM ; i++) index[i] = (char *)params + WL_SSID_MAX_LENGTH*i; IF_CHECK_START_CMD(_data) { CHECK_DATA(cmd | REPLY_FLAG, _data){}; uint8_t numParam = readChar(); if (numParam > maxNumParams) { numParam = maxNumParams; } *numParamRead = numParam; if (numParam != 0) { for (i=0; i<numParam; ++i) { uint8_t paramLen = readParamLen8(); for (ii=0; ii<paramLen; ++ii) { //ssid[ii] = spiTransfer(DUMMY_DATA); // Get Params data index[i][ii] = (uint8_t)spiTransfer(DUMMY_DATA); } index[i][ii]=0; } } else { WARN("Error numParams == 0"); readAndCheckChar(END_CMD, &_data); return 0; } readAndCheckChar(END_CMD, &_data); } return 1; }
uint8_t detectSpiDevice(void) { uint8_t out[] = { M25P16_INSTRUCTION_RDID, 0, 0, 0 }; uint8_t in[4]; uint32_t flash_id; // try autodetect flash chip delay(50); // short delay required after initialisation of SPI device instance. ENABLE_SPI_CS; spiTransfer(NAZE_SPI_INSTANCE, in, out, sizeof(out)); DISABLE_SPI_CS; flash_id = in[1] << 16 | in[2] << 8 | in[3]; if (flash_id == FLASH_M25P16_ID) return SPI_DEVICE_FLASH; return SPI_DEVICE_NONE; }
void LedControl::setLed(int addr, int row, int column, boolean state) { int offset; byte val=0x00; if(addr<0 || addr>=maxDevices) return; if(row<0 || row>7 || column<0 || column>7) return; offset=addr*8; val=B10000000 >> column; if(state) status[offset+row]=status[offset+row]|val; else { val=~val; status[offset+row]=status[offset+row]&val; } spiTransfer(addr, row+1,status[offset+row]); }
/** * \brief Transfer data full-duplex over SPI * * Transfer raw data full-duplex over a wire. * \param[in,out] buffer Data to send. Received data is returned here. * \param size Size of data to send. * \returns * Data is returned in the buffer. \n * return 0 always. */ int spiTransfer(char *buffer, int size) { // only a certain amount of byte can be written at a time. see below int bounded_size = (size > WRITE_MAX_BYTES ? WRITE_MAX_BYTES : size); struct timespec req = { 0, WRITE_CYCLE_U*1000L }; struct timespec rem; wiringPiSPIDataRW(0, (unsigned char*)buffer, bounded_size); // Wait for the write to cycle //usleep(WRITE_CYCLE_U); nanosleep(&req, &rem); if (size > WRITE_MAX_BYTES) { // Only a certain amount of bytes can be writeen at a time // If we go over that limit, break the write up into multiple // chunks spiTransfer(&buffer[WRITE_MAX_BYTES], size-WRITE_MAX_BYTES); } return 0; }
void MAX7219::setLed(int row, int column, bool state, int addr) { if (addr < 0 || addr >= maxDevices) return; int offset; uint8_t val = 0; if (row < 0 || row > 7 || column < 0 || column > 7) { return; } offset = addr * 8; val = 0b10000000 >> column; if (state) { status[offset + row] = status[offset + row] | val; } else { val = ~val; status[offset + row] = status[offset + row] & val; } spiTransfer(addr, row + 1, status[offset + row]); }
/** \brief Send the display a command byte Send a command via SPI, I2C or parallel to SSD1306 controller. For SPI we set the DC and CS pins here, and call spiTransfer(byte) to send the data. For I2C and Parallel we use the write functions defined in hardware.cpp to send the data. */ void MicroOLED::command(uint8_t c) { if (interface == MODE_SPI) { digitalWrite(dcPin, LOW);; // DC pin LOW for a command spiTransfer(c); // Transfer the command byte } else if (interface == MODE_I2C) { // Write to our address, make sure it knows we're sending a // command: i2cWrite(i2c_address, I2C_COMMAND, c); } else if (interface == MODE_PARALLEL) { // Write the byte to our parallel interface. Set DC LOW. parallelWrite(c, LOW); } }
/** \brief Send the display a data byte Send a data byte via SPI, I2C or parallel to SSD1306 controller. For SPI we set the DC and CS pins here, and call spiTransfer(byte) to send the data. For I2C and Parallel we use the write functions defined in hardware.cpp to send the data. */ void MicroOLED::data(uint8_t c) { if (interface == MODE_SPI) { digitalWrite(dcPin, HIGH); // DC HIGH for a data byte spiTransfer(c); // Transfer the data byte } else if (interface == MODE_I2C) { // Write to our address, make sure it knows we're sending a // data byte: i2cWrite(i2c_address, I2C_DATA, c); } else if (interface == MODE_PARALLEL) { // Write the byte to our parallel interface. Set DC HIGH. parallelWrite(c, HIGH); } }