int SpiFlash::write(byte* _buf, long _addr, uint16_t _length)
{
// Below if statement checks that device is ready, _address is within device memory, and there won't be a page overflow writing data
if (!checkWriteInProgress() && _length <= PAGE_SIZE && check_address(_addr, _length) && checkPageOverflow(_addr, _length))
{
digitalWriteFast(SS, LOW);
send(PAGE_PROGRAM);
send(_addr >> 16);
send(_addr >> 8);
send(_addr);
#ifdef DEBUG
Serial.println("Writing Data. . .");
#endif
for (int i = 0; i < _length; i++)
{
send(*_buf);
#ifdef DEBUG
//Serial.println(*_buf, BIN);
#endif
_buf++;
}
digitalWriteFast(SS, HIGH);
writeEnable();
return 1; // returns 1 if ok
}
int AccSensor::setEnable(int32_t handle, int enabled)
{ int err = 0;
uint32_t newState = enabled;
if (mEnabled != newState) {
if (newState && !mEnabled)
err = writeEnable(1);
else if (!newState)
err = writeEnable(0);
ALOGI("change G sensor state \"%d -> %d\"", mEnabled, newState);
ALOGE_IF(err, "Could not change sensor state \"%d -> %d\" (%s).", mEnabled, newState, strerror(-err));
if (!err) {
mEnabled = newState;
setDelay(NULL, mDelay);
}
}
return err;
}
//------------------------------------------------------------------------------
// initialize SPI pins
void SpiFlash::begin(uint8_t _SS, uint8_t sckDivisor) {
SS = _SS;
pinMode(SS, OUTPUT);
digitalWriteFast(SS, HIGH);
SIM_SCGC6 |= SIM_SCGC6_SPI0;
uint32_t ctar, ctar0, ctar1;
if (sckDivisor <= 2) {
// 1/2 speed
ctar = SPI_CTAR_DBR | SPI_CTAR_BR(0) | SPI_CTAR_CSSCK(0);
} else if (sckDivisor <= 4) {
// 1/4 speed
ctar = SPI_CTAR_BR(0) | SPI_CTAR_CSSCK(0);
} else if (sckDivisor <= 8) {
// 1/8 speed
ctar = SPI_CTAR_BR(1) | SPI_CTAR_CSSCK(1);
} else if (sckDivisor <= 12) {
// 1/12 speed
ctar = SPI_CTAR_BR(2) | SPI_CTAR_CSSCK(2);
} else if (sckDivisor <= 16) {
// 1/16 speed
ctar = SPI_CTAR_BR(3) | SPI_CTAR_CSSCK(3);
} else if (sckDivisor <= 32) {
// 1/32 speed
ctar = SPI_CTAR_PBR(1) | SPI_CTAR_BR(4) | SPI_CTAR_CSSCK(4);
} else if (sckDivisor <= 64) {
// 1/64 speed
ctar = SPI_CTAR_PBR(1) | SPI_CTAR_BR(5) | SPI_CTAR_CSSCK(5);
} else {
// 1/128 speed
ctar = SPI_CTAR_PBR(1) | SPI_CTAR_BR(6) | SPI_CTAR_CSSCK(6);
}
// CTAR0 - 8 bit transfer
ctar0 = ctar | SPI_CTAR_FMSZ(7);
// CTAR1 - 16 bit transfer
ctar1 = ctar | SPI_CTAR_FMSZ(15);
if (SPI0_CTAR0 != ctar0 || SPI0_CTAR1 != ctar1) {
SPI0_MCR = SPI_MCR_MSTR | SPI_MCR_MDIS | SPI_MCR_HALT;
SPI0_CTAR0 = ctar0;
SPI0_CTAR1 = ctar1;
}
SPI0_MCR = SPI_MCR_MSTR;
CORE_PIN11_CONFIG = PORT_PCR_DSE | PORT_PCR_MUX(2);
CORE_PIN12_CONFIG = PORT_PCR_MUX(2);
CORE_PIN13_CONFIG = PORT_PCR_DSE | PORT_PCR_MUX(2);
readID();
writeEnable();
}
bool spi_erasePage(int addr) {
uint8_t cmd[4];
if(!unWriteProtect())
{ printf("Write protected.\n"); return false; }
if(!writeEnable())
return false;
cmd[0]=CMD_PAGEERASE;
cmd[1]=addr>>16;
cmd[2]=addr>>8;
cmd[3]=addr;
if(!dev_spiWrite(cmd, 4, 1, 0))
return false;
return writeWait(50);
}
static bool unWriteProtect() {
static uint8_t cmd[]={CMD_WRITESTATUS,0};
uint8_t status;
if(!readStatus(&status))
return false;
if(!(status & 0x1c)) //already unlocked
return true;
if(!writeEnable())
return false;
if(!dev_spiWrite(cmd,2,1,0))
return false;
return writeWait(50);
}
int PressTempSensor::enable(int32_t handle, int en, int type)
{
int err = 0;
int what = -1;
static int enabled = 0;
what = getWhatFromHandle(handle);
if (what < 0)
return what;
if(en) {
if(mEnabled == 0) {
enabled = 1;
err = writeEnable(SENSORS_PRESSURE_HANDLE, 1);
}
if(err >= 0) {
mEnabled |= (1<<what);
err = 0;
enabled = 0;
}
} else {
int tmp = mEnabled;
mEnabled &= ~(1<<what);
if((mEnabled == 0) && (tmp != 0))
err = writeEnable(SENSORS_PRESSURE_HANDLE, 0);
if(err < 0)
mEnabled |= (1<<what);
else
err = 0;
}
if(enabled == 1)
setInitialState();
return err;
}
//write single page
static bool pageWrite(uint32_t addr, uint8_t *buf, int size) {
uint8_t cmd[PAGESIZE+4];
if(((addr&(PAGESIZE-1))+size)>PAGESIZE)
{ printf("Page write overflow.\n"); return false; }
if(!writeEnable())
return false;
cmd[0]=CMD_PAGEWRITE;
cmd[1]=addr>>16;
cmd[2]=addr>>8;
cmd[3]=addr;
memcpy(cmd+4, buf, size);
size+=4;
uint8_t *p=cmd;
for(;size>0;size-=SPI_WRITEMAX) {
if(!dev_spiWrite(p, size>SPI_WRITEMAX? SPI_WRITEMAX: size, p==cmd, size>SPI_WRITEMAX))
return false;
p+=SPI_WRITEMAX;
}
return writeWait(50);
}
int PressSensor::disable_sensor() {
return writeEnable(0);
}
int PressSensor::enable_sensor() {
return writeEnable(1);
}
int AccelSensor::disable_sensor() {
return writeEnable(0);
}
int AccelSensor::enable_sensor() {
return writeEnable(1);
}
void writeSystemEEPROM(void)
{
uint16_t byteCount;
uint8_t pageIndex;
uint8_t* start = (uint8_t*)(&systemConfig);
uint8_t* end = (uint8_t*)(&systemConfig + 1);
///////////////////////////////////
// there's no reason to write these values to EEPROM, they'll just be noise
zeroPIDstates();
if (systemConfig.CRCFlags & CRC_HistoryBad)
evrPush(EVR_ConfigBadSystemHistory,0);
systemConfig.CRCAtEnd[0] = crc32B((uint32_t*)(&systemConfig), // CRC32B[systemConfig]
(uint32_t*)(&systemConfig.CRCAtEnd));
///////////////////////////////////
setSPIdivisor(EEPROM_SPI, 2); // 18 MHz SPI clock
systemConfigaddr.value = SYSTEM_EEPROM_ADDR;
///////////////////////////////////
// Sector Erase
writeEnable();
ENABLE_EEPROM;
spiTransfer(EEPROM_SPI, SECTOR_ERASE_64KB);
spiTransfer(EEPROM_SPI, systemConfigaddr.bytes[2]);
spiTransfer(EEPROM_SPI, systemConfigaddr.bytes[1]);
spiTransfer(EEPROM_SPI, systemConfigaddr.bytes[0]);
DISABLE_EEPROM;
delayMicroseconds(2);
eepromBusy();
///////////////////////////////////
// Program Page(s)
for (pageIndex = 0; pageIndex < ((sizeof(systemConfig) / 256) + 1); pageIndex++)
{
writeEnable();
ENABLE_EEPROM;
spiTransfer(EEPROM_SPI, PAGE_PROGRAM_256_BYTES);
spiTransfer(EEPROM_SPI, systemConfigaddr.bytes[2]);
spiTransfer(EEPROM_SPI, systemConfigaddr.bytes[1]);
spiTransfer(EEPROM_SPI, systemConfigaddr.bytes[0]);
for (byteCount = 0; byteCount < 256; byteCount++)
{
spiTransfer(EEPROM_SPI, *start++);
if (start >= end)
break;
}
DISABLE_EEPROM;
delayMicroseconds(2);
eepromBusy();
systemConfigaddr.value += 0x0100;
}
readSystemEEPROM();
}
void writeSensorEEPROM(void)
{
uint16_t byteCount;
uint8_t pageIndex;
uint8_t* start = (uint8_t*)(&sensorConfig);
uint8_t* end = (uint8_t*)(&sensorConfig + 1);
///////////////////////////////////
if (sensorConfig.CRCFlags & CRC_HistoryBad)
evrPush(EVR_ConfigBadSensorHistory,0);
sensorConfig.CRCAtEnd[0] = crc32B((uint32_t*)(&sensorConfig), // CRC32B[sensorConfig]
(uint32_t*)(&sensorConfig.CRCAtEnd));
///////////////////////////////////
setSPIdivisor(EEPROM_SPI, 2); // 18 MHz SPI clock
sensorConfigAddr.value = SENSOR_EEPROM_ADDR;
///////////////////////////////////
// Sector Erase
writeEnable();
ENABLE_EEPROM;
spiTransfer(EEPROM_SPI, SECTOR_ERASE_64KB);
spiTransfer(EEPROM_SPI, sensorConfigAddr.bytes[2]);
spiTransfer(EEPROM_SPI, sensorConfigAddr.bytes[1]);
spiTransfer(EEPROM_SPI, sensorConfigAddr.bytes[0]);
DISABLE_EEPROM;
delayMicroseconds(2);
eepromBusy();
///////////////////////////////////
// Program Page(s)
for (pageIndex = 0; pageIndex < ((sizeof(sensorConfig) / 256) + 1); pageIndex++)
{
writeEnable();
ENABLE_EEPROM;
spiTransfer(EEPROM_SPI, PAGE_PROGRAM_256_BYTES);
spiTransfer(EEPROM_SPI, sensorConfigAddr.bytes[2]);
spiTransfer(EEPROM_SPI, sensorConfigAddr.bytes[1]);
spiTransfer(EEPROM_SPI, sensorConfigAddr.bytes[0]);
for (byteCount = 0; byteCount < 256; byteCount++)
{
spiTransfer(EEPROM_SPI, *start++);
if (start >= end)
break;
}
DISABLE_EEPROM;
delayMicroseconds(2);
eepromBusy();
sensorConfigAddr.value += 0x0100;
}
readSensorEEPROM();
}
