void ADXL345::clearSettings(void)
{
setRange(ADXL345_RANGE_2G);
setDataRate(ADXL345_DATARATE_100HZ);
writeRegister8(ADXL345_REG_THRESH_TAP, 0x00);
writeRegister8(ADXL345_REG_DUR, 0x00);
writeRegister8(ADXL345_REG_LATENT, 0x00);
writeRegister8(ADXL345_REG_WINDOW, 0x00);
writeRegister8(ADXL345_REG_THRESH_ACT, 0x00);
writeRegister8(ADXL345_REG_THRESH_INACT, 0x00);
writeRegister8(ADXL345_REG_TIME_INACT, 0x00);
writeRegister8(ADXL345_REG_THRESH_FF, 0x00);
writeRegister8(ADXL345_REG_TIME_FF, 0x00);
uint8_t value;
value = readRegister8(ADXL345_REG_ACT_INACT_CTL);
value &= 0b10001000;
writeRegister8(ADXL345_REG_ACT_INACT_CTL, value);
value = readRegister8(ADXL345_REG_TAP_AXES);
value &= 0b11111000;
writeRegister8(ADXL345_REG_TAP_AXES, value);
}
boolean Adafruit_DRV2605::init() {
_wire->begin();
uint8_t id = readRegister8(DRV2605_REG_STATUS);
//Serial.print("Status 0x"); Serial.println(id, HEX);
writeRegister8(DRV2605_REG_MODE, 0x00); // out of standby
writeRegister8(DRV2605_REG_RTPIN, 0x00); // no real-time-playback
writeRegister8(DRV2605_REG_WAVESEQ1, 1); // strong click
writeRegister8(DRV2605_REG_WAVESEQ2, 0); // end sequence
writeRegister8(DRV2605_REG_OVERDRIVE, 0); // no overdrive
writeRegister8(DRV2605_REG_SUSTAINPOS, 0);
writeRegister8(DRV2605_REG_SUSTAINNEG, 0);
writeRegister8(DRV2605_REG_BREAK, 0);
writeRegister8(DRV2605_REG_AUDIOMAX, 0x64);
// ERM open loop
// turn off N_ERM_LRA
writeRegister8(DRV2605_REG_FEEDBACK, readRegister8(DRV2605_REG_FEEDBACK) & 0x7F);
// turn on ERM_OPEN_LOOP
writeRegister8(DRV2605_REG_CONTROL3, readRegister8(DRV2605_REG_CONTROL3) | 0x20);
return true;
}
boolean DRV2605::begin() {
// moved outside - other libs may used the Wire
// Wire.begin();
uint8_t id = readRegister8(DRV2605_REG_STATUS);
writeRegister8(DRV2605_REG_MODE, 0x00); // out of standby
writeRegister8(DRV2605_REG_RTPIN, 0x00); // no real-time-playback
writeRegister8(DRV2605_REG_WAVESEQ1, 1); // strong click
writeRegister8(DRV2605_REG_WAVESEQ2, 0);
writeRegister8(DRV2605_REG_OVERDRIVE, 0); // no overdrive
writeRegister8(DRV2605_REG_SUSTAINPOS, 0);
writeRegister8(DRV2605_REG_SUSTAINNEG, 0);
writeRegister8(DRV2605_REG_BREAK, 0);
writeRegister8(DRV2605_REG_AUDIOMAX, 0x64);
// ERM open loop
// turn off N_ERM_LRA
writeRegister8(DRV2605_REG_FEEDBACK, readRegister8(DRV2605_REG_FEEDBACK) & 0x7F);
// turn on ERM_OPEN_LOOP
writeRegister8(DRV2605_REG_CONTROL3, readRegister8(DRV2605_REG_CONTROL3) | 0x20);
return true;
}
bool Adafruit_LIS3DH::begin(uint8_t i2caddr) {
_i2caddr = i2caddr;
if (_cs == -1) {
// i2c
Wire.begin();
} else {
digitalWrite(_cs, HIGH);
pinMode(_cs, OUTPUT);
if (_sck == -1) {
// hardware SPI
SPI.begin();
} else {
// software SPI
pinMode(_sck, OUTPUT);
pinMode(_mosi, OUTPUT);
pinMode(_miso, INPUT);
}
}
/* Check connection */
uint8_t deviceid = readRegister8(LIS3DH_REG_WHOAMI);
if (deviceid != 0x33)
{
/* No LIS3DH detected ... return false */
//Serial.println(deviceid, HEX);
return false;
}
// enable all axes, normal mode
writeRegister8(LIS3DH_REG_CTRL1, 0x07);
// 400Hz rate
setDataRate(LIS3DH_DATARATE_400_HZ);
// High res enabled
writeRegister8(LIS3DH_REG_CTRL4, 0x08);
// DRDY on INT1
writeRegister8(LIS3DH_REG_CTRL3, 0x10);
// Turn on orientation config
//writeRegister8(LIS3DH_REG_PL_CFG, 0x40);
// enable adc & temp sensor
writeRegister8(LIS3DH_REG_TEMPCFG, 0xC0);
for (uint8_t i=0; i<0x30; i++) {
Serial.print("$");
Serial.print(i, HEX); Serial.print(" = 0x");
Serial.println(readRegister8(i), HEX);
}
return true;
}
uint16_t Adafruit_STMPE610::getVersion() {
uint16_t v;
//Serial.print("get version");
v = readRegister8(0);
v <<= 8;
v |= readRegister8(1);
//Serial.print("Version: 0x"); Serial.println(v, HEX);
return v;
}
void DS3231::forceConversion(void)
{
uint8_t value;
value = readRegister8(DS3231_REG_CONTROL);
value |= 0b00100000;
writeRegister8(DS3231_REG_CONTROL, value);
do {} while ((readRegister8(DS3231_REG_CONTROL) & 0b00100000) != 0);
}
void Adafruit_MMA8451::setRange(mma8451_range_t range)
{
uint8_t reg1 = readRegister8(MMA8451_REG_CTRL_REG1);
writeRegister8(MMA8451_REG_CTRL_REG1, 0x00); // deactivate
writeRegister8(MMA8451_REG_XYZ_DATA_CFG, range & 0x3);
writeRegister8(MMA8451_REG_CTRL_REG1, reg1 | 0x01); // activate
}
void Adafruit_LIS3DH::setInertialInt(bool state, float thresh, uint8_t timelimit, uint8_t options) {
if (!state) {
//disable int
uint8_t r = readRegister8(LIS3DH_REG_CTRL3);
r &= ~(0x40); // turn off IA1
writeRegister8(LIS3DH_REG_CTRL3, r);
return;
}
// else...
writeRegister8(LIS3DH_REG_CTRL3, 0x40); // turn on int1
writeRegister8(LIS3DH_REG_CTRL5, 0x08); // latch interrupt on int1
uint8_t range = (2 << getRange());
if (thresh < 0) thresh = thresh * -1;
if (thresh > range) thresh = range;
thresh = (thresh * 127 / range);
uint8_t th = (int) thresh;
writeRegister8(LIS3DH_REG_INT1THS, (th & 0x7f)); // arbitrary
writeRegister8(LIS3DH_REG_INT1DUR, (timelimit & 0x7f)); // arbitrary
writeRegister8(LIS3DH_REG_INT1CFG, options); // arbitrary
}
bool DS3231::isArmed1(void)
{
uint8_t value;
value = readRegister8(DS3231_REG_CONTROL);
value &= 0b00000001;
return value;
}
void Adafruit_LIS3DH::setClick(uint8_t c, uint8_t clickthresh, uint8_t timelimit, uint8_t timelatency, uint8_t timewindow) {
if (!c) {
//disable int
uint8_t r = readRegister8(LIS3DH_REG_CTRL3);
r &= ~(0x80); // turn off I1_CLICK
writeRegister8(LIS3DH_REG_CTRL3, r);
writeRegister8(LIS3DH_REG_CLICKCFG, 0);
return;
}
// else...
writeRegister8(LIS3DH_REG_CTRL3, 0x80); // turn on int1 click
writeRegister8(LIS3DH_REG_CTRL5, 0x08); // latch interrupt on int1
if (c == 1)
writeRegister8(LIS3DH_REG_CLICKCFG, 0x15); // turn on all axes & singletap
if (c == 2)
writeRegister8(LIS3DH_REG_CLICKCFG, 0x2A); // turn on all axes & doubletap
writeRegister8(LIS3DH_REG_CLICKTHS, clickthresh); // arbitrary
writeRegister8(LIS3DH_REG_TIMELIMIT, timelimit); // arbitrary
writeRegister8(LIS3DH_REG_TIMELATENCY, timelatency); // arbitrary
writeRegister8(LIS3DH_REG_TIMEWINDOW, timewindow); // arbitrary
}
void Adafruit_LIS3DH::setRange(lis3dh_range_t range)
{
uint8_t r = readRegister8(LIS3DH_REG_CTRL4);
r &= ~(0x30);
r |= range << 4;
writeRegister8(LIS3DH_REG_CTRL4, r);
}
void Adafruit_LIS3DH::setDataRate(lis3dh_dataRate_t dataRate)
{
uint8_t ctl1 = readRegister8(LIS3DH_REG_CTRL1);
ctl1 &= ~(0xF0); // mask off bits
ctl1 |= (dataRate << 4);
writeRegister8(LIS3DH_REG_CTRL1, ctl1);
}
void Adafruit_MMA8451::setDataRate(mma8451_dataRate_t dataRate)
{
uint8_t ctl1 = readRegister8(MMA8451_REG_CTRL_REG1);
writeRegister8(MMA8451_REG_CTRL_REG1, 0x00); // deactivate
ctl1 &= ~(MMA8451_DATARATE_MASK << 3); // mask off bits
ctl1 |= (dataRate << 3);
writeRegister8(MMA8451_REG_CTRL_REG1, ctl1 | 0x01); // activate
}
hmc5883l_mode_t HMC5883L::getMeasurementMode(void)
{
uint8_t value;
value = readRegister8(HMC5883L_REG_MODE);
value &= 0b00000011;
return (hmc5883l_mode_t)value;
}
void DS3231::clearAlarm2(void)
{
uint8_t value;
value = readRegister8(DS3231_REG_STATUS);
value &= 0b11111101;
writeRegister8(DS3231_REG_STATUS, value);
}
bool Adafruit_MMA8451::begin(uint8_t i2caddr) {
Wire.begin();
_i2caddr = i2caddr;
/* Check connection */
uint8_t deviceid = readRegister8(MMA8451_REG_WHOAMI);
if (deviceid != 0x1A)
{
/* No MMA8451 detected ... return false */
//Serial.println(deviceid, HEX);
return false;
}
writeRegister8(MMA8451_REG_CTRL_REG2, 0x40); // reset
while (readRegister8(MMA8451_REG_CTRL_REG2) & 0x40);
// enable 4G range
writeRegister8(MMA8451_REG_XYZ_DATA_CFG, MMA8451_RANGE_4_G);
// High res
writeRegister8(MMA8451_REG_CTRL_REG2, 0x02);
// Low noise!
writeRegister8(MMA8451_REG_CTRL_REG1, 0x04);
// DRDY on INT1
writeRegister8(MMA8451_REG_CTRL_REG4, 0x01);
writeRegister8(MMA8451_REG_CTRL_REG5, 0x01);
// Turn on orientation config
writeRegister8(MMA8451_REG_PL_CFG, 0x40);
// Activate!
writeRegister8(MMA8451_REG_CTRL_REG1, 0x01); // active, max rate
/*
for (uint8_t i=0; i<0x30; i++) {
Serial.print("$");
Serial.print(i, HEX); Serial.print(" = 0x");
Serial.println(readRegister8(i), HEX);
}
*/
return true;
}
hmc5883l_samples_t HMC5883L::getSamples(void)
{
uint8_t value;
value = readRegister8(HMC5883L_REG_CONFIG_A);
value &= 0b01100000;
value >>= 5;
return (hmc5883l_samples_t)value;
}
void HMC5883L::setSamples(hmc5883l_samples_t samples)
{
uint8_t value;
value = readRegister8(HMC5883L_REG_CONFIG_A);
value &= 0b10011111;
value |= (samples << 5);
writeRegister8(HMC5883L_REG_CONFIG_A, value);
}
hmc5883l_dataRate_t HMC5883L::getDataRate(void)
{
uint8_t value;
value = readRegister8(HMC5883L_REG_CONFIG_A);
value &= 0b00011100;
value >>= 2;
return (hmc5883l_dataRate_t)value;
}
void HMC5883L::setMeasurementMode(hmc5883l_mode_t mode)
{
uint8_t value;
value = readRegister8(HMC5883L_REG_MODE);
value &= 0b11111100;
value |= mode;
writeRegister8(HMC5883L_REG_MODE, value);
}
void HMC5883L::setDataRate(hmc5883l_dataRate_t dataRate)
{
uint8_t value;
value = readRegister8(HMC5883L_REG_CONFIG_A);
value &= 0b11100011;
value |= (dataRate << 2);
writeRegister8(HMC5883L_REG_CONFIG_A, value);
}
bool DS3231::isOutput(void)
{
uint8_t value;
value = readRegister8(DS3231_REG_CONTROL);
value &= 0b00000100;
value >>= 2;
return !value;
}
boolean Adafruit_STMPE610::begin() {
// hardware SPI
InitTransaction();
// SPI = mraa_spi_init(0); // which buss? will experment here...
SPI = mraa_spi_init_software_cs(0); // which buss? will experment here...
mraa_spi_frequency(SPI, 1000000);
mraa_spi_lsbmode(SPI, false);
mraa_spi_mode(SPI, MRAA_SPI_MODE0);
m_spiMode = MRAA_SPI_MODE0;
_gpioCS = mraa_gpio_init(_cs);
mraa_gpio_dir(_gpioCS, MRAA_GPIO_OUT);
CSHigh();
mraa_spi_write(SPI, 0x00);
// try mode0
if (getVersion() != 0x811) {
//Serial.println("try MODE1");
mraa_spi_frequency(SPI, 1000000);
mraa_spi_lsbmode(SPI, false);
mraa_spi_mode(SPI, MRAA_SPI_MODE1);
m_spiMode = MRAA_SPI_MODE1;
if (getVersion() != 0x811) {
return false;
}
}
writeRegister8(STMPE_SYS_CTRL1, STMPE_SYS_CTRL1_RESET);
delay(10);
for (uint8_t i=0; i<65; i++) {
readRegister8(i);
}
writeRegister8(STMPE_SYS_CTRL2, 0x0); // turn on clocks!
writeRegister8(STMPE_TSC_CTRL, STMPE_TSC_CTRL_XYZ | STMPE_TSC_CTRL_EN); // XYZ and enable!
//Serial.println(readRegister8(STMPE_TSC_CTRL), HEX);
writeRegister8(STMPE_INT_EN, STMPE_INT_EN_TOUCHDET);
writeRegister8(STMPE_ADC_CTRL1, STMPE_ADC_CTRL1_10BIT | (0x6 << 4)); // 96 clocks per conversion
writeRegister8(STMPE_ADC_CTRL2, STMPE_ADC_CTRL2_6_5MHZ);
writeRegister8(STMPE_TSC_CFG, STMPE_TSC_CFG_4SAMPLE | STMPE_TSC_CFG_DELAY_1MS | STMPE_TSC_CFG_SETTLE_5MS);
writeRegister8(STMPE_TSC_FRACTION_Z, 0x6);
writeRegister8(STMPE_FIFO_TH, 1);
writeRegister8(STMPE_FIFO_STA, STMPE_FIFO_STA_RESET);
writeRegister8(STMPE_FIFO_STA, 0); // unreset
writeRegister8(STMPE_TSC_I_DRIVE, STMPE_TSC_I_DRIVE_50MA);
writeRegister8(STMPE_INT_STA, 0xFF); // reset all ints
writeRegister8(STMPE_INT_CTRL, STMPE_INT_CTRL_POL_HIGH | STMPE_INT_CTRL_ENABLE);
return true;
}
DS3231_sqw_t DS3231::getOutput(void)
{
uint8_t value;
value = readRegister8(DS3231_REG_CONTROL);
value &= 0b00011000;
value >>= 3;
return (DS3231_sqw_t)value;
}
void DS3231::setOutput(DS3231_sqw_t mode)
{
uint8_t value;
value = readRegister8(DS3231_REG_CONTROL);
value &= 0b11100111;
value |= (mode << 3);
writeRegister8(DS3231_REG_CONTROL, value);
}
void DS3231::enable32kHz(bool enabled)
{
uint8_t value;
value = readRegister8(DS3231_REG_STATUS);
value &= 0b11110111;
value |= (enabled << 3);
writeRegister8(DS3231_REG_STATUS, value);
}
bool DS3231::is32kHz(void)
{
uint8_t value;
value = readRegister8(DS3231_REG_STATUS);
value &= 0b00001000;
value >>= 3;
return value;
}
void DS3231::enableOutput(bool enabled)
{
uint8_t value;
value = readRegister8(DS3231_REG_CONTROL);
value &= 0b11111011;
value |= (!enabled << 2);
writeRegister8(DS3231_REG_CONTROL, value);
}
void DW1000::sendFrame(uint8_t* message, uint16_t length) {
if (length >= 125) length = 125; // check for maximim length a frame can have with 127 Byte frames
writeRegister(DW1000_TX_BUFFER, 0, message, length); // fill buffer
uint8_t backup = readRegister8(DW1000_TX_FCTRL, 1); // put length of frame
length += 2; // including 2 CRC Bytes
length = ((backup & 0xFC) << 8) | (length & 0x03FF);
writeRegister16(DW1000_TX_FCTRL, 0, length);
stopTRX(); // stop receiving
writeRegister8(DW1000_SYS_CTRL, 0, 0x02); // trigger sending process by setting the TXSTRT bit
startRX(); // enable receiver again
}
boolean Adafruit_MPR121::begin(uint8_t i2caddr) {
Wire.begin();
_i2caddr = i2caddr;
// soft reset
writeRegister(MPR121_SOFTRESET, 0x63);
delay(1);
for (uint8_t i=0; i<0x7F; i++) {
// Serial.print("$"); Serial.print(i, HEX);
// Serial.print(": 0x"); Serial.println(readRegister8(i));
}
writeRegister(MPR121_ECR, 0x0);
uint8_t c = readRegister8(MPR121_CONFIG2);
if (c != 0x24) return false;
setThreshholds(48,6); //(12, 6); // ylh: THIS IS THE THRESHOLDS FOR ALL KEYS
writeRegister(MPR121_MHDR, 0x01);
writeRegister(MPR121_NHDR, 0x01);
writeRegister(MPR121_NCLR, 0x0E);
writeRegister(MPR121_FDLR, 0x00);
writeRegister(MPR121_MHDF, 0x01);
writeRegister(MPR121_NHDF, 0x05);
writeRegister(MPR121_NCLF, 0x01);
writeRegister(MPR121_FDLF, 0x00);
writeRegister(MPR121_NHDT, 0x00);
writeRegister(MPR121_NCLT, 0x00);
writeRegister(MPR121_FDLT, 0x00);
writeRegister(MPR121_DEBOUNCE, 0);
writeRegister(MPR121_CONFIG1, 0x10); // default, 16uA charge current
writeRegister(MPR121_CONFIG2, 0x20); // 0.5uS encoding, 1ms period
// writeRegister(MPR121_AUTOCONFIG0, 0x8F);
// writeRegister(MPR121_UPLIMIT, 150);
// writeRegister(MPR121_TARGETLIMIT, 100); // should be ~400 (100 shifted)
// writeRegister(MPR121_LOWLIMIT, 50);
// enable all electrodes
writeRegister(MPR121_ECR, 0x8F); // start with first 5 bits of baseline tracking
return true;
}
