From 3a209d8db421cc7d6fce0cf99956f6640eb452d9 Mon Sep 17 00:00:00 2001 From: morgan Date: Thu, 24 Mar 2016 20:31:17 -0700 Subject: [PATCH] updating files for HS09 --- HamShield.cpp | 334 ++++---- HamShield.h | 3 +- HamShield_comms.cpp | 168 ++++ HamShield_comms.h | 22 + I2Cdev.cpp | 1457 ---------------------------------- I2Cdev.h | 281 ------- examples/FoxHunt/FoxHunt.ino | 13 +- 7 files changed, 370 insertions(+), 1908 deletions(-) create mode 100644 HamShield_comms.cpp create mode 100644 HamShield_comms.h delete mode 100644 I2Cdev.cpp delete mode 100644 I2Cdev.h diff --git a/HamShield.cpp b/HamShield.cpp index ce1f4e4..e4ff898 100644 --- a/HamShield.cpp +++ b/HamShield.cpp @@ -150,129 +150,130 @@ void HamShield::initialize() { // set up GPIO voltage (want 3.3V) tx_data = 0x03AC; // default is 0x32C - I2Cdev::writeWord(devAddr, 0x09, tx_data); + HSwriteWord(devAddr, 0x09, tx_data); tx_data = 0x47E0; //0x43A0; // 0x7C20; // - I2Cdev::writeWord(devAddr, 0x0A, tx_data); // pga gain [10:6] + HSwriteWord(devAddr, 0x0A, tx_data); // pga gain [10:6] tx_data = 0xA100; - I2Cdev::writeWord(devAddr, 0x13, tx_data); + HSwriteWord(devAddr, 0x13, tx_data); tx_data = 0x5001; - I2Cdev::writeWord(devAddr, 0x1F, tx_data); // GPIO7->VOX, GPIO0->CTC/DCS + HSwriteWord(devAddr, 0x1F, tx_data); // GPIO7->VOX, GPIO0->CTC/DCS tx_data = 0x0031; - I2Cdev::writeWord(devAddr, 0x31, tx_data); + HSwriteWord(devAddr, 0x31, tx_data); tx_data = 0x0AF2; // - I2Cdev::writeWord(devAddr, 0x33, tx_data); // agc number + HSwriteWord(devAddr, 0x33, tx_data); // agc number // AGC table tx_data = 0x0001; - I2Cdev::writeWord(devAddr, 0x7F, tx_data); + HSwriteWord(devAddr, 0x7F, tx_data); tx_data = 0x000C; - I2Cdev::writeWord(devAddr, 0x05, tx_data); + HSwriteWord(devAddr, 0x05, tx_data); tx_data = 0x020C; - I2Cdev::writeWord(devAddr, 0x06, tx_data); + HSwriteWord(devAddr, 0x06, tx_data); tx_data = 0x030C; - I2Cdev::writeWord(devAddr, 0x07, tx_data); + HSwriteWord(devAddr, 0x07, tx_data); tx_data = 0x0324; - I2Cdev::writeWord(devAddr, 0x08, tx_data); + HSwriteWord(devAddr, 0x08, tx_data); tx_data = 0x1344; - I2Cdev::writeWord(devAddr, 0x09, tx_data); + HSwriteWord(devAddr, 0x09, tx_data); tx_data = 0x3F44; - I2Cdev::writeWord(devAddr, 0x0A, tx_data); + HSwriteWord(devAddr, 0x0A, tx_data); tx_data = 0x3F44; - I2Cdev::writeWord(devAddr, 0x0B, tx_data); + HSwriteWord(devAddr, 0x0B, tx_data); tx_data = 0x3F44; - I2Cdev::writeWord(devAddr, 0x0C, tx_data); + HSwriteWord(devAddr, 0x0C, tx_data); tx_data = 0x3F44; - I2Cdev::writeWord(devAddr, 0x0D, tx_data); + HSwriteWord(devAddr, 0x0D, tx_data); tx_data = 0x3F44; - I2Cdev::writeWord(devAddr, 0x0E, tx_data); + HSwriteWord(devAddr, 0x0E, tx_data); tx_data = 0x3F44; - I2Cdev::writeWord(devAddr, 0x0F, tx_data); + HSwriteWord(devAddr, 0x0F, tx_data); tx_data = 0xE0ED; - I2Cdev::writeWord(devAddr, 0x12, tx_data); + HSwriteWord(devAddr, 0x12, tx_data); tx_data = 0xF2FE; - I2Cdev::writeWord(devAddr, 0x13, tx_data); + HSwriteWord(devAddr, 0x13, tx_data); tx_data = 0x0A16; - I2Cdev::writeWord(devAddr, 0x14, tx_data); + HSwriteWord(devAddr, 0x14, tx_data); tx_data = 0x2424; - I2Cdev::writeWord(devAddr, 0x15, tx_data); + HSwriteWord(devAddr, 0x15, tx_data); tx_data = 0x2424; - I2Cdev::writeWord(devAddr, 0x16, tx_data); + HSwriteWord(devAddr, 0x16, tx_data); tx_data = 0x2424; - I2Cdev::writeWord(devAddr, 0x17, tx_data); + HSwriteWord(devAddr, 0x17, tx_data); tx_data = 0x0000; - I2Cdev::writeWord(devAddr, 0x7F, tx_data); + HSwriteWord(devAddr, 0x7F, tx_data); // end AGC table tx_data = 0x067F; //0x0601; //0x470F; - I2Cdev::writeWord(devAddr, 0x41, tx_data); // voice gain tx [6:0] + HSwriteWord(devAddr, 0x41, tx_data); // voice gain tx [6:0] tx_data = 0x02FF; // using 0x04FF to avoid tx voice delay - I2Cdev::writeWord(devAddr, 0x44, tx_data); // tx gain [11:8] + HSwriteWord(devAddr, 0x44, tx_data); // tx gain [11:8] tx_data = 0x7F2F; - I2Cdev::writeWord(devAddr, 0x47, tx_data); + HSwriteWord(devAddr, 0x47, tx_data); tx_data = 0x2C62; - I2Cdev::writeWord(devAddr, 0x4F, tx_data); + HSwriteWord(devAddr, 0x4F, tx_data); tx_data = 0x0094; - I2Cdev::writeWord(devAddr, 0x53, tx_data); // compressor update time (bits 6:0, 5.12ms per unit) + HSwriteWord(devAddr, 0x53, tx_data); // compressor update time (bits 6:0, 5.12ms per unit) tx_data = 0x2A18; - I2Cdev::writeWord(devAddr, 0x54, tx_data); + HSwriteWord(devAddr, 0x54, tx_data); tx_data = 0x0081; - I2Cdev::writeWord(devAddr, 0x55, tx_data); + HSwriteWord(devAddr, 0x55, tx_data); tx_data = 0x0B22; - I2Cdev::writeWord(devAddr, 0x56, tx_data); // sq detect time + HSwriteWord(devAddr, 0x56, tx_data); // sq detect time tx_data = 0x1C00; - I2Cdev::writeWord(devAddr, 0x57, tx_data); + HSwriteWord(devAddr, 0x57, tx_data); tx_data = 0x800D; - I2Cdev::writeWord(devAddr, 0x58, tx_data); + HSwriteWord(devAddr, 0x58, tx_data); tx_data = 0x0EDD; - I2Cdev::writeWord(devAddr, 0x5A, tx_data); // sq and noise detect times + HSwriteWord(devAddr, 0x5A, tx_data); // sq and noise detect times tx_data = 0x3FFF; - I2Cdev::writeWord(devAddr, 0x63, tx_data); // pre-emphasis bypass + HSwriteWord(devAddr, 0x63, tx_data); // pre-emphasis bypass // calibration tx_data = 0x00A4; - I2Cdev::writeWord(devAddr, 0x30, tx_data); + HSwriteWord(devAddr, 0x30, tx_data); delay(100); tx_data = 0x00A6; - I2Cdev::writeWord(devAddr, 0x30, tx_data); + HSwriteWord(devAddr, 0x30, tx_data); delay(100); tx_data = 0x0006; - I2Cdev::writeWord(devAddr, 0x30, tx_data); + HSwriteWord(devAddr, 0x30, tx_data); delay(100); // setup for 12.5kHz channel width tx_data = 0x3D37; - I2Cdev::writeWord(devAddr, 0x11, tx_data); + HSwriteWord(devAddr, 0x11, tx_data); tx_data = 0x0100; - I2Cdev::writeWord(devAddr, 0x12, tx_data); + HSwriteWord(devAddr, 0x12, tx_data); tx_data = 0x1100; - I2Cdev::writeWord(devAddr, 0x15, tx_data); + HSwriteWord(devAddr, 0x15, tx_data); tx_data = 0x4495; - I2Cdev::writeWord(devAddr, 0x32, tx_data); // agc target power [11:6] + HSwriteWord(devAddr, 0x32, tx_data); // agc target power [11:6] tx_data = 0x2B8E; - I2Cdev::writeWord(devAddr, 0x34, tx_data); + HSwriteWord(devAddr, 0x34, tx_data); tx_data = 0x40C3; - I2Cdev::writeWord(devAddr, 0x3A, tx_data); // modu_det_sel sq setting + HSwriteWord(devAddr, 0x3A, tx_data); // modu_det_sel sq setting tx_data = 0x0407; - I2Cdev::writeWord(devAddr, 0x3C, tx_data); // pk_det_th sq setting [8:7] + HSwriteWord(devAddr, 0x3C, tx_data); // pk_det_th sq setting [8:7] tx_data = 0x28D0; - I2Cdev::writeWord(devAddr, 0x3F, tx_data); // rssi3_th sq setting + HSwriteWord(devAddr, 0x3F, tx_data); // rssi3_th sq setting tx_data = 0x203E; - I2Cdev::writeWord(devAddr, 0x48, tx_data); + HSwriteWord(devAddr, 0x48, tx_data); tx_data = 0x1BB7; - I2Cdev::writeWord(devAddr, 0x60, tx_data); + HSwriteWord(devAddr, 0x60, tx_data); tx_data = 0x0A10; // use 0x1425 if there's an LNA - I2Cdev::writeWord(devAddr, 0x62, tx_data); + HSwriteWord(devAddr, 0x62, tx_data); tx_data = 0x2494; - I2Cdev::writeWord(devAddr, 0x65, tx_data); + HSwriteWord(devAddr, 0x65, tx_data); tx_data = 0xEB2E; - I2Cdev::writeWord(devAddr, 0x66, tx_data); + HSwriteWord(devAddr, 0x66, tx_data); delay(100); - + + /* // setup default values frequency(446000); //setVolume1(0xF); @@ -282,6 +283,7 @@ void HamShield::initialize() { setRfPower(0); setSQLoThresh(80); setSQOn(); + */ } /** Verify the I2C connection. @@ -289,7 +291,7 @@ void HamShield::initialize() { * @return True if connection is valid, false otherwise */ bool HamShield::testConnection() { - I2Cdev::readWord(devAddr, 0x00, radio_i2c_buf); + HSreadWord(devAddr, 0x00, radio_i2c_buf); return radio_i2c_buf[0] == 0x1846; } @@ -316,16 +318,16 @@ bool HamShield::testConnection() { */ uint16_t HamShield::readCtlReg() { - I2Cdev::readWord(devAddr, A1846S_CTL_REG, radio_i2c_buf); + HSreadWord(devAddr, A1846S_CTL_REG, radio_i2c_buf); return radio_i2c_buf[0]; } void HamShield::softReset() { uint16_t tx_data = 0x1; - I2Cdev::writeWord(devAddr, A1846S_CTL_REG, tx_data); + HSwriteWord(devAddr, A1846S_CTL_REG, tx_data); delay(100); // Note: see A1846S setup info for timing guidelines tx_data = 0x4; - I2Cdev::writeWord(devAddr, A1846S_CTL_REG, tx_data); + HSwriteWord(devAddr, A1846S_CTL_REG, tx_data); } @@ -334,7 +336,7 @@ void HamShield::setFrequency(uint32_t freq_khz) { uint32_t freq_raw = freq_khz << 4; // shift by 4 to multiply by 16 (was shift by 3 in old 1846 chip) // turn off tx/rx - I2Cdev::writeBitsW(devAddr, A1846S_CTL_REG, 6, 2, 0); + HSwriteBitsW(devAddr, A1846S_CTL_REG, 6, 2, 0); // if we're using a 12MHz crystal and the frequency is // 136.5M,409.5M and 455M, then we have to do special stuff @@ -343,19 +345,19 @@ void HamShield::setFrequency(uint32_t freq_khz) { radio_frequency == 455000) { // set up AU1846 for funky freq - I2Cdev::writeWord(devAddr, 0x05, 0x86D3); + HSwriteWord(devAddr, 0x05, 0x86D3); } else { // set up AU1846 for normal freq - I2Cdev::writeWord(devAddr, 0x05, 0x8763); + HSwriteWord(devAddr, 0x05, 0x8763); } // send top 16 bits to A1846S_FREQ_HI_REG uint16_t freq_half = (uint16_t) (0x3FFF & (freq_raw >> 16)); - I2Cdev::writeWord(devAddr, A1846S_FREQ_HI_REG, freq_half); + HSwriteWord(devAddr, A1846S_FREQ_HI_REG, freq_half); // send bottom 16 bits to A1846S_FREQ_LO_REG freq_half = (uint16_t) (freq_raw & 0xFFFF); - I2Cdev::writeWord(devAddr, A1846S_FREQ_LO_REG, freq_half); + HSwriteWord(devAddr, A1846S_FREQ_LO_REG, freq_half); if (rx_active) { setRX(true); @@ -385,7 +387,7 @@ void HamShield::setTxBand70cm() { uint16_t mode_len = 4; uint16_t bit = 11; - I2Cdev::writeBitsW(devAddr, A1846S_GPIO_MODE_REG, bit, mode_len, 0xF); + HSwriteBitsW(devAddr, A1846S_GPIO_MODE_REG, bit, mode_len, 0xF); } // clk mode @@ -398,10 +400,10 @@ void HamShield::setClkMode(bool LFClk){ tx_data = 0x0FD0; } - I2Cdev::writeWord(devAddr, A1846S_CLK_MODE_REG, tx_data); + HSwriteWord(devAddr, A1846S_CLK_MODE_REG, tx_data); } bool HamShield::getClkMode(){ - I2Cdev::readBitW(devAddr, A1846S_CLK_MODE_REG, A1846S_CLK_MODE_BIT, radio_i2c_buf); + HSreadBitW(devAddr, A1846S_CLK_MODE_REG, A1846S_CLK_MODE_BIT, radio_i2c_buf); return (radio_i2c_buf[0] != 0); } @@ -412,10 +414,10 @@ bool HamShield::getClkMode(){ // 00 - 12.5kHz channel // 10,01 - reserved void HamShield::setChanMode(uint16_t mode){ - I2Cdev::writeBitsW(devAddr, A1846S_CTL_REG, A1846S_CHAN_MODE_BIT, A1846S_CHAN_MODE_LENGTH, mode); + HSwriteBitsW(devAddr, A1846S_CTL_REG, A1846S_CHAN_MODE_BIT, A1846S_CHAN_MODE_LENGTH, mode); } uint16_t HamShield::getChanMode(){ - I2Cdev::readBitsW(devAddr, A1846S_CTL_REG, A1846S_CHAN_MODE_BIT, A1846S_CHAN_MODE_LENGTH, radio_i2c_buf); + HSreadBitsW(devAddr, A1846S_CTL_REG, A1846S_CHAN_MODE_BIT, A1846S_CHAN_MODE_LENGTH, radio_i2c_buf); return radio_i2c_buf[0]; } */ @@ -428,6 +430,7 @@ void HamShield::setTX(bool on_noff){ rx_active = false; setRX(false); + if((radio_frequency >= 134000) && (radio_frequency <= 174000)) { setTxBand2m(); } @@ -437,14 +440,18 @@ void HamShield::setTX(bool on_noff){ if((radio_frequency >= 400000) && (radio_frequency <= 520000)) { setTxBand70cm(); } + // FOR HS03 + //setGpioLow(5); // V2 + //setGpioHi(4); // V1 + delay(50); // delay required by AU1846 } - I2Cdev::writeBitW(devAddr, A1846S_CTL_REG, A1846S_TX_MODE_BIT, on_noff); + HSwriteBitW(devAddr, A1846S_CTL_REG, A1846S_TX_MODE_BIT, on_noff); } bool HamShield::getTX(){ - I2Cdev::readBitW(devAddr, A1846S_CTL_REG, A1846S_TX_MODE_BIT, radio_i2c_buf); + HSreadBitW(devAddr, A1846S_CTL_REG, A1846S_TX_MODE_BIT, radio_i2c_buf); return (radio_i2c_buf[0] != 0); } @@ -454,16 +461,19 @@ void HamShield::setRX(bool on_noff){ tx_active = false; rx_active = true; setTX(false); - + // FOR HS03 + //setGpioLow(4); // V1 + //setGpioHi(5); // V2 setGpioLow(4); // V1 setGpioLow(5); // V2 + delay(50); // delay required by AU1846 } - I2Cdev::writeBitW(devAddr, A1846S_CTL_REG, A1846S_RX_MODE_BIT, on_noff); + HSwriteBitW(devAddr, A1846S_CTL_REG, A1846S_RX_MODE_BIT, on_noff); } bool HamShield::getRX(){ - I2Cdev::readBitW(devAddr, A1846S_CTL_REG, A1846S_RX_MODE_BIT, radio_i2c_buf); + HSreadBitW(devAddr, A1846S_CTL_REG, A1846S_RX_MODE_BIT, radio_i2c_buf); return (radio_i2c_buf[0] != 0); } @@ -483,7 +493,7 @@ void HamShield::setModeReceive(){ } void HamShield::setModeOff(){ // turn off tx/rx - I2Cdev::writeBitsW(devAddr, A1846S_CTL_REG, 6, 2, 0); + HSwriteBitsW(devAddr, A1846S_CTL_REG, 6, 2, 0); // turn off amplifiers setGpioLow(4); // V1 @@ -502,7 +512,7 @@ void HamShield::setModeOff(){ // 011 - sine source from tone1 and tone2 // 100 - mic void HamShield::setTxSource(uint16_t tx_source){ - I2Cdev::writeBitsW(devAddr, A1846S_TX_VOICE_REG, A1846S_VOICE_SEL_BIT, A1846S_VOICE_SEL_LENGTH, tx_source); + HSwriteBitsW(devAddr, A1846S_TX_VOICE_REG, A1846S_VOICE_SEL_BIT, A1846S_VOICE_SEL_LENGTH, tx_source); } void HamShield::setTxSourceMic(){ setTxSource(4); @@ -520,7 +530,7 @@ void HamShield::setTxSourceNone(){ setTxSource(0); } uint16_t HamShield::getTxSource(){ - I2Cdev::readBitsW(devAddr, A1846S_TX_VOICE_REG, A1846S_VOICE_SEL_BIT, A1846S_VOICE_SEL_LENGTH, radio_i2c_buf); + HSreadBitsW(devAddr, A1846S_TX_VOICE_REG, A1846S_VOICE_SEL_BIT, A1846S_VOICE_SEL_LENGTH, radio_i2c_buf); return radio_i2c_buf[0]; } @@ -535,10 +545,10 @@ uint16_t HamShield::getTxSource(){ // 100000: 2.45V // 1111111:3.13V void HamShield::setPABiasVoltage(uint16_t voltage){ - I2Cdev::writeBitsW(devAddr, A1846S_PABIAS_REG, A1846S_PABIAS_BIT, A1846S_PABIAS_LENGTH, voltage); + HSwriteBitsW(devAddr, A1846S_PABIAS_REG, A1846S_PABIAS_BIT, A1846S_PABIAS_LENGTH, voltage); } uint16_t HamShield::getPABiasVoltage(){ - I2Cdev::readBitsW(devAddr, A1846S_PABIAS_REG, A1846S_PABIAS_BIT, A1846S_PABIAS_LENGTH, radio_i2c_buf); + HSreadBitsW(devAddr, A1846S_PABIAS_REG, A1846S_PABIAS_BIT, A1846S_PABIAS_LENGTH, radio_i2c_buf); return radio_i2c_buf[0]; } */ @@ -567,10 +577,10 @@ uint16_t HamShield::getPABiasVoltage(){ // 110=outer cdcss en // others =disable void HamShield::setCtcssCdcssMode(uint16_t mode){ - I2Cdev::writeBitsW(devAddr, A1846S_SUBAUDIO_REG, A1846S_C_MODE_BIT, A1846S_C_MODE_LENGTH, mode); + HSwriteBitsW(devAddr, A1846S_SUBAUDIO_REG, A1846S_C_MODE_BIT, A1846S_C_MODE_LENGTH, mode); } uint16_t HamShield::getCtcssCdcssMode(){ - I2Cdev::readBitsW(devAddr, A1846S_SUBAUDIO_REG, A1846S_C_MODE_BIT, A1846S_C_MODE_LENGTH, radio_i2c_buf); + HSreadBitsW(devAddr, A1846S_SUBAUDIO_REG, A1846S_C_MODE_BIT, A1846S_C_MODE_LENGTH, radio_i2c_buf); return radio_i2c_buf[0]; } void HamShield::setInnerCtcssMode(){ @@ -593,10 +603,10 @@ void HamShield::disableCtcssCdcss(){ // 1 = ctcss_cmp/cdcss_cmp out via gpio // 0 = ctcss/cdcss sdo out vio gpio void HamShield::setCtcssSel(bool cmp_nsdo){ - I2Cdev::writeBitW(devAddr, A1846S_SUBAUDIO_REG, A1846S_CTCSS_SEL_BIT, cmp_nsdo); + HSwriteBitW(devAddr, A1846S_SUBAUDIO_REG, A1846S_CTCSS_SEL_BIT, cmp_nsdo); } bool HamShield::getCtcssSel(){ - I2Cdev::readBitW(devAddr, A1846S_SUBAUDIO_REG, A1846S_CTCSS_SEL_BIT, radio_i2c_buf); + HSreadBitW(devAddr, A1846S_SUBAUDIO_REG, A1846S_CTCSS_SEL_BIT, radio_i2c_buf); return (radio_i2c_buf[0] != 0); } @@ -604,46 +614,46 @@ bool HamShield::getCtcssSel(){ // 1 = long (24 bit) code // 0 = short(23 bit) code void HamShield::setCdcssSel(bool long_nshort){ - I2Cdev::writeBitW(devAddr, A1846S_SUBAUDIO_REG, A1846S_CDCSS_SEL_BIT, long_nshort); + HSwriteBitW(devAddr, A1846S_SUBAUDIO_REG, A1846S_CDCSS_SEL_BIT, long_nshort); } bool HamShield::getCdcssSel(){ - I2Cdev::readBitW(devAddr, A1846S_SUBAUDIO_REG, A1846S_CDCSS_SEL_BIT, radio_i2c_buf); + HSreadBitW(devAddr, A1846S_SUBAUDIO_REG, A1846S_CDCSS_SEL_BIT, radio_i2c_buf); return (radio_i2c_buf[0] != 0); } // Cdcss neg_det_en void HamShield::enableCdcssNegDet(){ - I2Cdev::writeBitW(devAddr, A1846S_SUBAUDIO_REG, A1846S_NEG_DET_EN_BIT, 1); + HSwriteBitW(devAddr, A1846S_SUBAUDIO_REG, A1846S_NEG_DET_EN_BIT, 1); } void HamShield::disableCdcssNegDet(){ - I2Cdev::writeBitW(devAddr, A1846S_SUBAUDIO_REG, A1846S_NEG_DET_EN_BIT, 0); + HSwriteBitW(devAddr, A1846S_SUBAUDIO_REG, A1846S_NEG_DET_EN_BIT, 0); } bool HamShield::getCdcssNegDetEnabled(){ - I2Cdev::readBitW(devAddr, A1846S_SUBAUDIO_REG, A1846S_NEG_DET_EN_BIT, radio_i2c_buf); + HSreadBitW(devAddr, A1846S_SUBAUDIO_REG, A1846S_NEG_DET_EN_BIT, radio_i2c_buf); return (radio_i2c_buf[0] != 0); } // Cdcss pos_det_en void HamShield::enableCdcssPosDet(){ - I2Cdev::writeBitW(devAddr, A1846S_SUBAUDIO_REG, A1846S_POS_DET_EN_BIT, 1); + HSwriteBitW(devAddr, A1846S_SUBAUDIO_REG, A1846S_POS_DET_EN_BIT, 1); } void HamShield::disableCdcssPosDet(){ - I2Cdev::writeBitW(devAddr, A1846S_SUBAUDIO_REG, A1846S_POS_DET_EN_BIT, 0); + HSwriteBitW(devAddr, A1846S_SUBAUDIO_REG, A1846S_POS_DET_EN_BIT, 0); } bool HamShield::getCdcssPosDetEnabled(){ - I2Cdev::readBitW(devAddr, A1846S_SUBAUDIO_REG, A1846S_POS_DET_EN_BIT, radio_i2c_buf); + HSreadBitW(devAddr, A1846S_SUBAUDIO_REG, A1846S_POS_DET_EN_BIT, radio_i2c_buf); return (radio_i2c_buf[0] != 0); } // css_det_en void HamShield::enableCssDet(){ - I2Cdev::writeBitW(devAddr, A1846S_SUBAUDIO_REG, A1846S_CSS_DET_EN_BIT, 1); + HSwriteBitW(devAddr, A1846S_SUBAUDIO_REG, A1846S_CSS_DET_EN_BIT, 1); } void HamShield::disableCssDet(){ - I2Cdev::writeBitW(devAddr, A1846S_SUBAUDIO_REG, A1846S_CSS_DET_EN_BIT, 0); + HSwriteBitW(devAddr, A1846S_SUBAUDIO_REG, A1846S_CSS_DET_EN_BIT, 0); } bool HamShield::getCssDetEnabled(){ - I2Cdev::readBitW(devAddr, A1846S_SUBAUDIO_REG, A1846S_CSS_DET_EN_BIT, radio_i2c_buf); + HSreadBitW(devAddr, A1846S_SUBAUDIO_REG, A1846S_CSS_DET_EN_BIT, radio_i2c_buf); return (radio_i2c_buf[0] != 0); } @@ -655,10 +665,10 @@ void HamShield::setCtcss(float freq) { } void HamShield::setCtcssFreq(uint16_t freq){ - I2Cdev::writeWord(devAddr, A1846S_CTCSS_FREQ_REG, freq); + HSwriteWord(devAddr, A1846S_CTCSS_FREQ_REG, freq); } uint16_t HamShield::getCtcssFreq(){ - I2Cdev::readWord(devAddr, A1846S_CTCSS_FREQ_REG, radio_i2c_buf); + HSreadWord(devAddr, A1846S_CTCSS_FREQ_REG, radio_i2c_buf); return radio_i2c_buf[0]; } @@ -689,15 +699,15 @@ void HamShield::setCdcssCode(uint16_t code) { // set registers uint16_t temp_code = (uint16_t) cdcss_code; - I2Cdev::writeWord(devAddr, A1846S_CDCSS_CODE_HI_REG, temp_code); + HSwriteWord(devAddr, A1846S_CDCSS_CODE_HI_REG, temp_code); temp_code = (uint16_t) (cdcss_code >> 16); - I2Cdev::writeWord(devAddr, A1846S_CDCSS_CODE_LO_REG, temp_code); + HSwriteWord(devAddr, A1846S_CDCSS_CODE_LO_REG, temp_code); } uint16_t HamShield::getCdcssCode() { uint32_t oct_code; - I2Cdev::readWord(devAddr, A1846S_CDCSS_CODE_HI_REG, radio_i2c_buf); + HSreadWord(devAddr, A1846S_CDCSS_CODE_HI_REG, radio_i2c_buf); oct_code = (radio_i2c_buf[0] << 16); - I2Cdev::readWord(devAddr, A1846S_CDCSS_CODE_LO_REG, radio_i2c_buf); + HSreadWord(devAddr, A1846S_CDCSS_CODE_LO_REG, radio_i2c_buf); oct_code += radio_i2c_buf[0]; oct_code = oct_code >> 12; @@ -712,89 +722,89 @@ uint16_t HamShield::getCdcssCode() { // SQ void HamShield::setSQOn(){ - I2Cdev::writeBitW(devAddr, A1846S_CTL_REG, A1846S_SQ_ON_BIT, 1); + HSwriteBitW(devAddr, A1846S_CTL_REG, A1846S_SQ_ON_BIT, 1); } void HamShield::setSQOff(){ - I2Cdev::writeBitW(devAddr, A1846S_CTL_REG, A1846S_SQ_ON_BIT, 0); + HSwriteBitW(devAddr, A1846S_CTL_REG, A1846S_SQ_ON_BIT, 0); } bool HamShield::getSQState(){ - I2Cdev::readBitW(devAddr, A1846S_CTL_REG, A1846S_SQ_ON_BIT, radio_i2c_buf); + HSreadBitW(devAddr, A1846S_CTL_REG, A1846S_SQ_ON_BIT, radio_i2c_buf); return (radio_i2c_buf[0] != 0); } // SQ threshold void HamShield::setSQHiThresh(uint16_t sq_hi_threshold){ // Sq detect high th, rssi_cmp will be 1 when rssi>th_h_sq, unit 1/8dB - I2Cdev::writeWord(devAddr, A1846S_SQ_OPEN_THRESH_REG, sq_hi_threshold); + HSwriteWord(devAddr, A1846S_SQ_OPEN_THRESH_REG, sq_hi_threshold); } uint16_t HamShield::getSQHiThresh(){ - I2Cdev::readWord(devAddr, A1846S_SQ_OPEN_THRESH_REG, radio_i2c_buf); + HSreadWord(devAddr, A1846S_SQ_OPEN_THRESH_REG, radio_i2c_buf); return radio_i2c_buf[0]; } void HamShield::setSQLoThresh(uint16_t sq_lo_threshold){ // Sq detect low th, rssi_cmp will be 0 when rssi th_h_vox, then vox will be 1(unit mV ) - I2Cdev::writeWord(devAddr, A1846S_TH_H_VOX_REG, vox_open_thresh); + HSwriteWord(devAddr, A1846S_TH_H_VOX_REG, vox_open_thresh); } uint16_t HamShield::getVoxOpenThresh(){ - I2Cdev::readWord(devAddr, A1846S_TH_H_VOX_REG, radio_i2c_buf); + HSreadWord(devAddr, A1846S_TH_H_VOX_REG, radio_i2c_buf); return radio_i2c_buf[0]; } void HamShield::setVoxShutThresh(uint16_t vox_shut_thresh){ // When vssi < th_l_vox && time delay meet, then vox will be 0 (unit mV ) - I2Cdev::writeWord(devAddr, A1846S_TH_L_VOX_REG, vox_shut_thresh); + HSwriteWord(devAddr, A1846S_TH_L_VOX_REG, vox_shut_thresh); } uint16_t HamShield::getVoxShutThresh(){ - I2Cdev::readWord(devAddr, A1846S_TH_L_VOX_REG, radio_i2c_buf); + HSreadWord(devAddr, A1846S_TH_L_VOX_REG, radio_i2c_buf); return radio_i2c_buf[0]; } // Tail Noise void HamShield::enableTailNoiseElim(){ - I2Cdev::writeBitW(devAddr, A1846S_CTL_REG, A1846S_TAIL_ELIM_EN_BIT, 1); + HSwriteBitW(devAddr, A1846S_CTL_REG, A1846S_TAIL_ELIM_EN_BIT, 1); } void HamShield::disableTailNoiseElim(){ - I2Cdev::writeBitW(devAddr, A1846S_CTL_REG, A1846S_TAIL_ELIM_EN_BIT, 1); + HSwriteBitW(devAddr, A1846S_CTL_REG, A1846S_TAIL_ELIM_EN_BIT, 1); } bool HamShield::getTailNoiseElimEnabled(){ - I2Cdev::readBitW(devAddr, A1846S_CTL_REG, A1846S_TAIL_ELIM_EN_BIT, radio_i2c_buf); + HSreadBitW(devAddr, A1846S_CTL_REG, A1846S_TAIL_ELIM_EN_BIT, radio_i2c_buf); return (radio_i2c_buf[0] != 0); } @@ -805,100 +815,100 @@ bool HamShield::getTailNoiseElimEnabled(){ // 10 = 240 degree shift // 11 = reserved void HamShield::setShiftSelect(uint16_t shift_sel){ - I2Cdev::writeBitsW(devAddr, A1846S_SUBAUDIO_REG, A1846S_SHIFT_SEL_BIT, A1846S_SHIFT_SEL_LENGTH, shift_sel); + HSwriteBitsW(devAddr, A1846S_SUBAUDIO_REG, A1846S_SHIFT_SEL_BIT, A1846S_SHIFT_SEL_LENGTH, shift_sel); } uint16_t HamShield::getShiftSelect(){ - I2Cdev::readBitsW(devAddr, A1846S_SUBAUDIO_REG, A1846S_SHIFT_SEL_BIT, A1846S_SHIFT_SEL_LENGTH, radio_i2c_buf); + HSreadBitsW(devAddr, A1846S_SUBAUDIO_REG, A1846S_SHIFT_SEL_BIT, A1846S_SHIFT_SEL_LENGTH, radio_i2c_buf); return radio_i2c_buf[0]; } // DTMF void HamShield::setDTMFC0(uint16_t freq) { - I2Cdev::writeBitsW(devAddr, A1846S_DTMF_C01_REG, A1846S_DTMF_C0_BIT, A1846S_DTMF_C0_LENGTH, freq); + HSwriteBitsW(devAddr, A1846S_DTMF_C01_REG, A1846S_DTMF_C0_BIT, A1846S_DTMF_C0_LENGTH, freq); } uint16_t HamShield::getDTMFC0() { - I2Cdev::readBitsW(devAddr, A1846S_DTMF_C01_REG, A1846S_DTMF_C0_BIT, A1846S_DTMF_C0_LENGTH, radio_i2c_buf); + HSreadBitsW(devAddr, A1846S_DTMF_C01_REG, A1846S_DTMF_C0_BIT, A1846S_DTMF_C0_LENGTH, radio_i2c_buf); return radio_i2c_buf[0]; } void HamShield::setDTMFC1(uint16_t freq) { - I2Cdev::writeBitsW(devAddr, A1846S_DTMF_C01_REG, A1846S_DTMF_C1_BIT, A1846S_DTMF_C1_LENGTH, freq); + HSwriteBitsW(devAddr, A1846S_DTMF_C01_REG, A1846S_DTMF_C1_BIT, A1846S_DTMF_C1_LENGTH, freq); } uint16_t HamShield::getDTMFC1() { - I2Cdev::readBitsW(devAddr, A1846S_DTMF_C01_REG, A1846S_DTMF_C1_BIT, A1846S_DTMF_C1_LENGTH, radio_i2c_buf); + HSreadBitsW(devAddr, A1846S_DTMF_C01_REG, A1846S_DTMF_C1_BIT, A1846S_DTMF_C1_LENGTH, radio_i2c_buf); return radio_i2c_buf[0]; } void HamShield::setDTMFC2(uint16_t freq) { - I2Cdev::writeBitsW(devAddr, A1846S_DTMF_C23_REG, A1846S_DTMF_C2_BIT, A1846S_DTMF_C2_LENGTH, freq); + HSwriteBitsW(devAddr, A1846S_DTMF_C23_REG, A1846S_DTMF_C2_BIT, A1846S_DTMF_C2_LENGTH, freq); } uint16_t HamShield::getDTMFC2() { - I2Cdev::readBitsW(devAddr, A1846S_DTMF_C23_REG, A1846S_DTMF_C2_BIT, A1846S_DTMF_C2_LENGTH, radio_i2c_buf); + HSreadBitsW(devAddr, A1846S_DTMF_C23_REG, A1846S_DTMF_C2_BIT, A1846S_DTMF_C2_LENGTH, radio_i2c_buf); return radio_i2c_buf[0]; } void HamShield::setDTMFC3(uint16_t freq) { - I2Cdev::writeBitsW(devAddr, A1846S_DTMF_C23_REG, A1846S_DTMF_C3_BIT, A1846S_DTMF_C3_LENGTH, freq); + HSwriteBitsW(devAddr, A1846S_DTMF_C23_REG, A1846S_DTMF_C3_BIT, A1846S_DTMF_C3_LENGTH, freq); } uint16_t HamShield::getDTMFC3() { - I2Cdev::readBitsW(devAddr, A1846S_DTMF_C23_REG, A1846S_DTMF_C3_BIT, A1846S_DTMF_C3_LENGTH, radio_i2c_buf); + HSreadBitsW(devAddr, A1846S_DTMF_C23_REG, A1846S_DTMF_C3_BIT, A1846S_DTMF_C3_LENGTH, radio_i2c_buf); return radio_i2c_buf[0]; } void HamShield::setDTMFC4(uint16_t freq) { - I2Cdev::writeBitsW(devAddr, A1846S_DTMF_C45_REG, A1846S_DTMF_C4_BIT, A1846S_DTMF_C4_LENGTH, freq); + HSwriteBitsW(devAddr, A1846S_DTMF_C45_REG, A1846S_DTMF_C4_BIT, A1846S_DTMF_C4_LENGTH, freq); } uint16_t HamShield::getDTMFC4() { - I2Cdev::readBitsW(devAddr, A1846S_DTMF_C45_REG, A1846S_DTMF_C4_BIT, A1846S_DTMF_C4_LENGTH, radio_i2c_buf); + HSreadBitsW(devAddr, A1846S_DTMF_C45_REG, A1846S_DTMF_C4_BIT, A1846S_DTMF_C4_LENGTH, radio_i2c_buf); return radio_i2c_buf[0]; } void HamShield::setDTMFC5(uint16_t freq) { - I2Cdev::writeBitsW(devAddr, A1846S_DTMF_C45_REG, A1846S_DTMF_C5_BIT, A1846S_DTMF_C5_LENGTH, freq); + HSwriteBitsW(devAddr, A1846S_DTMF_C45_REG, A1846S_DTMF_C5_BIT, A1846S_DTMF_C5_LENGTH, freq); } uint16_t HamShield::getDTMFC5() { - I2Cdev::readBitsW(devAddr, A1846S_DTMF_C45_REG, A1846S_DTMF_C5_BIT, A1846S_DTMF_C5_LENGTH, radio_i2c_buf); + HSreadBitsW(devAddr, A1846S_DTMF_C45_REG, A1846S_DTMF_C5_BIT, A1846S_DTMF_C5_LENGTH, radio_i2c_buf); return radio_i2c_buf[0]; } void HamShield::setDTMFC6(uint16_t freq) { - I2Cdev::writeBitsW(devAddr, A1846S_DTMF_C67_REG, A1846S_DTMF_C6_BIT, A1846S_DTMF_C6_LENGTH, freq); + HSwriteBitsW(devAddr, A1846S_DTMF_C67_REG, A1846S_DTMF_C6_BIT, A1846S_DTMF_C6_LENGTH, freq); } uint16_t HamShield::getDTMFC6() { - I2Cdev::readBitsW(devAddr, A1846S_DTMF_C67_REG, A1846S_DTMF_C6_BIT, A1846S_DTMF_C6_LENGTH, radio_i2c_buf); + HSreadBitsW(devAddr, A1846S_DTMF_C67_REG, A1846S_DTMF_C6_BIT, A1846S_DTMF_C6_LENGTH, radio_i2c_buf); return radio_i2c_buf[0]; } void HamShield::setDTMFC7(uint16_t freq) { - I2Cdev::writeBitsW(devAddr, A1846S_DTMF_C67_REG, A1846S_DTMF_C7_BIT, A1846S_DTMF_C7_LENGTH, freq); + HSwriteBitsW(devAddr, A1846S_DTMF_C67_REG, A1846S_DTMF_C7_BIT, A1846S_DTMF_C7_LENGTH, freq); } uint16_t HamShield::getDTMFC7() { - I2Cdev::readBitsW(devAddr, A1846S_DTMF_C67_REG, A1846S_DTMF_C7_BIT, A1846S_DTMF_C7_LENGTH, radio_i2c_buf); + HSreadBitsW(devAddr, A1846S_DTMF_C67_REG, A1846S_DTMF_C7_BIT, A1846S_DTMF_C7_LENGTH, radio_i2c_buf); return radio_i2c_buf[0]; } // TX FM deviation void HamShield::setFMVoiceCssDeviation(uint16_t deviation){ - I2Cdev::writeBitsW(devAddr, A1846S_FM_DEV_REG, A1846S_FM_DEV_VOICE_BIT, A1846S_FM_DEV_VOICE_LENGTH, deviation); + HSwriteBitsW(devAddr, A1846S_FM_DEV_REG, A1846S_FM_DEV_VOICE_BIT, A1846S_FM_DEV_VOICE_LENGTH, deviation); } uint16_t HamShield::getFMVoiceCssDeviation(){ - I2Cdev::readBitsW(devAddr, A1846S_FM_DEV_REG, A1846S_FM_DEV_VOICE_BIT, A1846S_FM_DEV_VOICE_LENGTH, radio_i2c_buf); + HSreadBitsW(devAddr, A1846S_FM_DEV_REG, A1846S_FM_DEV_VOICE_BIT, A1846S_FM_DEV_VOICE_LENGTH, radio_i2c_buf); return radio_i2c_buf[0]; } void HamShield::setFMCssDeviation(uint16_t deviation){ - I2Cdev::writeBitsW(devAddr, A1846S_FM_DEV_REG, A1846S_FM_DEV_CSS_BIT, A1846S_FM_DEV_CSS_LENGTH, deviation); + HSwriteBitsW(devAddr, A1846S_FM_DEV_REG, A1846S_FM_DEV_CSS_BIT, A1846S_FM_DEV_CSS_LENGTH, deviation); } uint16_t HamShield::getFMCssDeviation(){ - I2Cdev::readBitsW(devAddr, A1846S_FM_DEV_REG, A1846S_FM_DEV_CSS_BIT, A1846S_FM_DEV_CSS_LENGTH, radio_i2c_buf); + HSreadBitsW(devAddr, A1846S_FM_DEV_REG, A1846S_FM_DEV_CSS_BIT, A1846S_FM_DEV_CSS_LENGTH, radio_i2c_buf); return radio_i2c_buf[0]; } // RX voice range void HamShield::setVolume1(uint16_t volume){ - I2Cdev::writeBitsW(devAddr, A1846S_RX_VOLUME_REG, A1846S_RX_VOL_1_BIT, A1846S_RX_VOL_1_LENGTH, volume); + HSwriteBitsW(devAddr, A1846S_RX_VOLUME_REG, A1846S_RX_VOL_1_BIT, A1846S_RX_VOL_1_LENGTH, volume); } uint16_t HamShield::getVolume1(){ - I2Cdev::readBitsW(devAddr, A1846S_RX_VOLUME_REG, A1846S_RX_VOL_1_BIT, A1846S_RX_VOL_1_LENGTH, radio_i2c_buf); + HSreadBitsW(devAddr, A1846S_RX_VOLUME_REG, A1846S_RX_VOL_1_BIT, A1846S_RX_VOL_1_LENGTH, radio_i2c_buf); return radio_i2c_buf[0]; } void HamShield::setVolume2(uint16_t volume){ - I2Cdev::writeBitsW(devAddr, A1846S_RX_VOLUME_REG, A1846S_RX_VOL_2_BIT, A1846S_RX_VOL_2_LENGTH, volume); + HSwriteBitsW(devAddr, A1846S_RX_VOLUME_REG, A1846S_RX_VOL_2_BIT, A1846S_RX_VOL_2_LENGTH, volume); } uint16_t HamShield::getVolume2(){ - I2Cdev::readBitsW(devAddr, A1846S_RX_VOLUME_REG, A1846S_RX_VOL_2_BIT, A1846S_RX_VOL_2_LENGTH, radio_i2c_buf); + HSreadBitsW(devAddr, A1846S_RX_VOLUME_REG, A1846S_RX_VOL_2_BIT, A1846S_RX_VOL_2_LENGTH, radio_i2c_buf); return radio_i2c_buf[0]; } @@ -907,7 +917,7 @@ void HamShield::setGpioMode(uint16_t gpio, uint16_t mode){ uint16_t mode_len = 2; uint16_t bit = gpio*2 + 1; - I2Cdev::writeBitsW(devAddr, A1846S_GPIO_MODE_REG, bit, mode_len, mode); + HSwriteBitsW(devAddr, A1846S_GPIO_MODE_REG, bit, mode_len, mode); } void HamShield::setGpioHiZ(uint16_t gpio){ setGpioMode(gpio, 0); @@ -925,33 +935,33 @@ uint16_t HamShield::getGpioMode(uint16_t gpio){ uint16_t mode_len = 2; uint16_t bit = gpio*2 + 1; - I2Cdev::readBitsW(devAddr, A1846S_GPIO_MODE_REG, bit, mode_len, radio_i2c_buf); + HSreadBitsW(devAddr, A1846S_GPIO_MODE_REG, bit, mode_len, radio_i2c_buf); return radio_i2c_buf[0]; } uint16_t HamShield::getGpios(){ - I2Cdev::readWord(devAddr, A1846S_GPIO_MODE_REG, radio_i2c_buf); + HSreadWord(devAddr, A1846S_GPIO_MODE_REG, radio_i2c_buf); return radio_i2c_buf[0]; } // Int void HamShield::enableInterrupt(uint16_t interrupt){ - I2Cdev::writeBitW(devAddr, A1846S_INT_MODE_REG, interrupt, 1); + HSwriteBitW(devAddr, A1846S_INT_MODE_REG, interrupt, 1); } void HamShield::disableInterrupt(uint16_t interrupt){ - I2Cdev::writeBitW(devAddr, A1846S_INT_MODE_REG, interrupt, 0); + HSwriteBitW(devAddr, A1846S_INT_MODE_REG, interrupt, 0); } bool HamShield::getInterruptEnabled(uint16_t interrupt){ - I2Cdev::readBitW(devAddr, A1846S_INT_MODE_REG, interrupt, radio_i2c_buf); + HSreadBitW(devAddr, A1846S_INT_MODE_REG, interrupt, radio_i2c_buf); return (radio_i2c_buf[0] != 0); } // ST mode void HamShield::setStMode(uint16_t mode){ - I2Cdev::writeBitsW(devAddr, A1846S_CTL_REG, A1846S_ST_MODE_BIT, A1846S_ST_MODE_LENGTH, mode); + HSwriteBitsW(devAddr, A1846S_CTL_REG, A1846S_ST_MODE_BIT, A1846S_ST_MODE_LENGTH, mode); } uint16_t HamShield::getStMode(){ - I2Cdev::readBitsW(devAddr, A1846S_CTL_REG, A1846S_ST_MODE_BIT, A1846S_ST_MODE_LENGTH, radio_i2c_buf); + HSreadBitsW(devAddr, A1846S_CTL_REG, A1846S_ST_MODE_BIT, A1846S_ST_MODE_LENGTH, radio_i2c_buf); return radio_i2c_buf[0]; } void HamShield::setStFullAuto(){ @@ -966,31 +976,31 @@ setStMode(0); // Pre-emphasis, De-emphasis filter void HamShield::bypassPreDeEmph(){ - I2Cdev::writeBitW(devAddr, A1846S_EMPH_FILTER_REG, A1846S_EMPH_FILTER_EN, 1); + HSwriteBitW(devAddr, A1846S_EMPH_FILTER_REG, A1846S_EMPH_FILTER_EN, 1); } void HamShield::usePreDeEmph(){ - I2Cdev::writeBitW(devAddr, A1846S_EMPH_FILTER_REG, A1846S_EMPH_FILTER_EN, 0); + HSwriteBitW(devAddr, A1846S_EMPH_FILTER_REG, A1846S_EMPH_FILTER_EN, 0); } bool HamShield::getPreDeEmphEnabled(){ - I2Cdev::readBitW(devAddr, A1846S_EMPH_FILTER_REG, A1846S_EMPH_FILTER_EN, radio_i2c_buf); + HSreadBitW(devAddr, A1846S_EMPH_FILTER_REG, A1846S_EMPH_FILTER_EN, radio_i2c_buf); return (radio_i2c_buf[0] != 0); } // Read Only Status Registers int16_t HamShield::readRSSI(){ - I2Cdev::readBitsW(devAddr, A1846S_RSSI_REG, A1846S_RSSI_BIT, A1846S_RSSI_LENGTH, radio_i2c_buf); + HSreadBitsW(devAddr, A1846S_RSSI_REG, A1846S_RSSI_BIT, A1846S_RSSI_LENGTH, radio_i2c_buf); int16_t rssi = (radio_i2c_buf[0] & 0x3FF) - 137; return rssi; } uint16_t HamShield::readVSSI(){ - I2Cdev::readWord(devAddr, A1846S_VSSI_REG, radio_i2c_buf); + HSreadWord(devAddr, A1846S_VSSI_REG, radio_i2c_buf); return radio_i2c_buf[0] & 0x7FF; // only need lowest 10 bits } uint16_t HamShield::readDTMFIndex(){ // TODO: may want to split this into two (index1 and index2) - I2Cdev::readBitsW(devAddr, A1846S_DTMF_RX_REG, A1846S_DTMF_INDEX_BIT, A1846S_DTMF_INDEX_LENGTH, radio_i2c_buf); + HSreadBitsW(devAddr, A1846S_DTMF_RX_REG, A1846S_DTMF_INDEX_BIT, A1846S_DTMF_INDEX_LENGTH, radio_i2c_buf); return radio_i2c_buf[0]; } uint16_t HamShield::readDTMFCode(){ @@ -998,7 +1008,7 @@ uint16_t HamShield::readDTMFCode(){ // 4:f1+f4, 5:f1+f5, 6:f1+f6, B:f1+f7, // 7:f2+f4, 8:f2+f5, 9:f2+f6, C:f2+f7, // E(*):f3+f4, 0:f3+f5, F(#):f3+f6, D:f3+f7 - I2Cdev::readBitsW(devAddr, A1846S_DTMF_RX_REG, A1846S_DTMF_CODE_BIT, A1846S_DTMF_CODE_LENGTH, radio_i2c_buf); + HSreadBitsW(devAddr, A1846S_DTMF_RX_REG, A1846S_DTMF_CODE_BIT, A1846S_DTMF_CODE_LENGTH, radio_i2c_buf); return radio_i2c_buf[0]; } @@ -1010,9 +1020,9 @@ void HamShield::setRfPower(uint8_t pwr) { } // turn off tx/rx - I2Cdev::writeBitsW(devAddr, A1846S_CTL_REG, 6, 2, 0); + HSwriteBitsW(devAddr, A1846S_CTL_REG, 6, 2, 0); - I2Cdev::writeBitsW(devAddr, A1846S_PABIAS_REG, A1846S_PADRV_BIT, A1846S_PADRV_LENGTH, pwr); + HSwriteBitsW(devAddr, A1846S_PABIAS_REG, A1846S_PADRV_BIT, A1846S_PADRV_LENGTH, pwr); if (rx_active) { setRX(true); diff --git a/HamShield.h b/HamShield.h index 26b3299..77366a3 100644 --- a/HamShield.h +++ b/HamShield.h @@ -9,7 +9,8 @@ #define _HAMSHIELD_H_ //#include "I2Cdev_rda.h" -#include "I2Cdev.h" +//#include "I2Cdev.h" +#include "HamShield_comms.h" #include "SimpleFIFO.h" #include "AFSK.h" #include "DDS.h" diff --git a/HamShield_comms.cpp b/HamShield_comms.cpp new file mode 100644 index 0000000..7b509f3 --- /dev/null +++ b/HamShield_comms.cpp @@ -0,0 +1,168 @@ +/* + * Based loosely on I2Cdev by Jeff Rowberg, except for all kludgy bit-banging + */ + +#include "HamShield_comms.h" + +int8_t HSreadBitW(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint16_t *data) +{ + uint16_t b; + uint8_t count = HSreadWord(devAddr, regAddr, &b); + *data = b & (1 << bitNum); + return count; +} + +int8_t HSreadBitsW(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint16_t *data) +{ + uint8_t count; + uint16_t w; + if ((count = HSreadWord(devAddr, regAddr, &w)) != 0) { + uint16_t mask = ((1 << length) - 1) << (bitStart - length + 1); + w &= mask; + w >>= (bitStart - length + 1); + *data = w; + } + return count; +} + +int8_t HSreadWord(uint8_t devAddr, uint8_t regAddr, uint16_t *data) +{ + //return I2Cdev::readWord(devAddr, regAddr, data); + + uint8_t temp; + uint16_t temp_dat; + // bitbang for great justice! + *data = 0; + cli(); + DDRC |= ((1<<5) | (1<<4)); // set direction to output + sei(); + regAddr = regAddr | (1 << 7); + + cli(); + PORTC &= ~(1<<1); //digitalWrite(nSEN, 0); + sei(); + for (int i = 0; i < 8; i++) { + temp = ((regAddr & (0x80 >> i)) != 0); + cli(); + PORTC &= ~(1<<5); //digitalWrite(CLK, 0); + sei(); + //digitalWrite(DAT, regAddr & (0x80 >> i)); + temp = (PORTC & ~(1<<4)) + (temp << 4); + cli(); + PORTC = temp; + sei(); + delayMicroseconds(9); + cli(); + PORTC |= (1<<5); //digitalWrite(CLK, 1); + sei(); + delayMicroseconds(9); + } + // change direction of DAT + cli(); + DDRC &= ~(1<<4); //pinMode(DAT, INPUT); + sei(); + for (int i = 15; i >= 0; i--) { + cli(); + PORTC &= ~(1<<5); //digitalWrite(CLK, 0); + sei(); + delayMicroseconds(9); + cli(); + PORTC |= (1<<5); //digitalWrite(CLK, 1); + sei(); + cli(); + temp_dat = ((PINC & (1<<4)) != 0); + sei(); + temp_dat = temp_dat << i; + *data |= temp_dat; // digitalRead(DAT); + delayMicroseconds(9); + } + cli(); + PORTC |= (1<<1);//digitalWrite(nSEN, 1); + + DDRC &= ~((1<<5) | (1<<4)); // set direction all input (for ADC) + sei(); + return 1; +} + + +bool HSwriteBitW(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint16_t data) +{ + uint16_t w; + HSreadWord(devAddr, regAddr, &w); + w = (data != 0) ? (w | (1 << bitNum)) : (w & ~(1 << bitNum)); + return HSwriteWord(devAddr, regAddr, w); +} + +bool HSwriteBitsW(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint16_t data) +{ +uint16_t w; + if (HSreadWord(devAddr, regAddr, &w) != 0) { + uint16_t mask = ((1 << length) - 1) << (bitStart - length + 1); + data <<= (bitStart - length + 1); // shift data into correct position + data &= mask; // zero all non-important bits in data + w &= ~(mask); // zero all important bits in existing word + w |= data; // combine data with existing word + return HSwriteWord(devAddr, regAddr, w); + } else { + return false; + } +} + +bool HSwriteWord(uint8_t devAddr, uint8_t regAddr, uint16_t data) +{ + //return I2Cdev::writeWord(devAddr, regAddr, data); + + uint8_t temp_reg; + uint16_t temp_dat; + + //digitalWrite(13, HIGH); + + // bitbang for great justice! + cli(); + DDRC |= ((1<<5) | (1<<4)); // set direction all output + //PORTC |= (1<<5) & (1<<4); + sei(); + regAddr = regAddr & ~(1 << 7); + + cli(); + PORTC &= ~(1<<1); //digitalWrite(nSEN, 0); + sei(); + for (int i = 0; i < 8; i++) { + temp_reg = ((regAddr & (0x80 >> i)) != 0); + cli(); + PORTC &= ~(1<<5); //digitalWrite(CLK, 0); + sei(); + //digitalWrite(DAT, regAddr & (0x80 >> i)); + temp_reg = (PORTC & ~(1<<4)) + (temp_reg << 4); + cli(); + PORTC = temp_reg; + sei(); + delayMicroseconds(8); + cli(); + PORTC |= (1<<5); //digitalWrite(CLK, 1); + sei(); + delayMicroseconds(10); + } + for (int i = 0; i < 16; i++) { + temp_dat = ((data & (0x8000 >> i)) != 0); + cli(); + PORTC &= ~(1<<5); //digitalWrite(CLK, 0); + sei(); + //digitalWrite(DAT, data & (0x80000 >> i)); + temp_reg = (PORTC & ~(1<<4)) + (temp_dat << 4); + cli(); + PORTC = temp_reg; + sei(); + delayMicroseconds(7); + cli(); + PORTC |= (1<<5); //digitalWrite(CLK, 1); + sei(); + delayMicroseconds(10); + } + cli(); + PORTC |= (1<<1); //digitalWrite(nSEN, 1); + + DDRC &= ~((1<<5) | (1<<4)); // set direction to input for ADC + sei(); + return true; +} \ No newline at end of file diff --git a/HamShield_comms.h b/HamShield_comms.h new file mode 100644 index 0000000..853153e --- /dev/null +++ b/HamShield_comms.h @@ -0,0 +1,22 @@ + + + +#ifndef _HAMSHIELD_COMMS_H_ +#define _HAMSHIELD_COMMS_H_ + +#include "Arduino.h" +//#include "I2Cdev.h" + +#define nSEN A1 +#define CLK A5 +#define DAT A4 + +int8_t HSreadBitW(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint16_t *data); +int8_t HSreadBitsW(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint16_t *data); +int8_t HSreadWord(uint8_t devAddr, uint8_t regAddr, uint16_t *data); + +bool HSwriteBitW(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint16_t data); +bool HSwriteBitsW(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint16_t data); +bool HSwriteWord(uint8_t devAddr, uint8_t regAddr, uint16_t data); + +#endif /* _HAMSHIELD_COMMS_H_ */ \ No newline at end of file diff --git a/I2Cdev.cpp b/I2Cdev.cpp deleted file mode 100644 index db173b5..0000000 --- a/I2Cdev.cpp +++ /dev/null @@ -1,1457 +0,0 @@ -// I2Cdev library collection - Main I2C device class -// Abstracts bit and byte I2C R/W functions into a convenient class -// 2013-06-05 by Jeff Rowberg -// -// Changelog: -// 2013-05-06 - add Francesco Ferrara's Fastwire v0.24 implementation with small modifications -// 2013-05-05 - fix issue with writing bit values to words (Sasquatch/Farzanegan) -// 2012-06-09 - fix major issue with reading > 32 bytes at a time with Arduino Wire -// - add compiler warnings when using outdated or IDE or limited I2Cdev implementation -// 2011-11-01 - fix write*Bits mask calculation (thanks sasquatch @ Arduino forums) -// 2011-10-03 - added automatic Arduino version detection for ease of use -// 2011-10-02 - added Gene Knight's NBWire TwoWire class implementation with small modifications -// 2011-08-31 - added support for Arduino 1.0 Wire library (methods are different from 0.x) -// 2011-08-03 - added optional timeout parameter to read* methods to easily change from default -// 2011-08-02 - added support for 16-bit registers -// - fixed incorrect Doxygen comments on some methods -// - added timeout value for read operations (thanks mem @ Arduino forums) -// 2011-07-30 - changed read/write function structures to return success or byte counts -// - made all methods static for multi-device memory savings -// 2011-07-28 - initial release - -/* ============================================ -I2Cdev device library code is placed under the MIT license -Copyright (c) 2013 Jeff Rowberg - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in -all copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -THE SOFTWARE. -=============================================== -*/ - -#include "I2Cdev.h" - -#if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE - - #ifdef I2CDEV_IMPLEMENTATION_WARNINGS - #if ARDUINO < 100 - #warning Using outdated Arduino IDE with Wire library is functionally limiting. - #warning Arduino IDE v1.6.5+ with I2Cdev Fastwire implementation is recommended. - #warning This I2Cdev implementation does not support: - #warning - Repeated starts conditions - #warning - Timeout detection (some Wire requests block forever) - #elif ARDUINO == 100 - #warning Using outdated Arduino IDE with Wire library is functionally limiting. - #warning Arduino IDE v1.6.5+ with I2Cdev Fastwire implementation is recommended. - #warning This I2Cdev implementation does not support: - #warning - Repeated starts conditions - #warning - Timeout detection (some Wire requests block forever) - #elif ARDUINO > 100 - /*#warning Using current Arduino IDE with Wire library is functionally limiting. - #warning Arduino IDE v1.6.5+ with I2CDEV_BUILTIN_FASTWIRE implementation is recommended. - #warning This I2Cdev implementation does not support: - #warning - Timeout detection (some Wire requests block forever)*/ - #endif - #endif - -#elif I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE - - //#error The I2CDEV_BUILTIN_FASTWIRE implementation is known to be broken right now. Patience, Iago! - -#elif I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_NBWIRE - - #ifdef I2CDEV_IMPLEMENTATION_WARNINGS - #warning Using I2CDEV_BUILTIN_NBWIRE implementation may adversely affect interrupt detection. - #warning This I2Cdev implementation does not support: - #warning - Repeated starts conditions - #endif - - // NBWire implementation based heavily on code by Gene Knight - // Originally posted on the Arduino forum at http://arduino.cc/forum/index.php/topic,70705.0.html - // Originally offered to the i2cdevlib project at http://arduino.cc/forum/index.php/topic,68210.30.html - TwoWire Wire; - -#endif - -/** Default constructor. - */ -I2Cdev::I2Cdev() { -} - -/** Read a single bit from an 8-bit device register. - * @param devAddr I2C slave device address - * @param regAddr Register regAddr to read from - * @param bitNum Bit position to read (0-7) - * @param data Container for single bit value - * @param timeout Optional read timeout in milliseconds (0 to disable, leave off to use default class value in I2Cdev::readTimeout) - * @return Status of read operation (true = success) - */ -int8_t I2Cdev::readBit(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint8_t *data, uint16_t timeout) { - uint8_t b; - uint8_t count = readByte(devAddr, regAddr, &b, timeout); - *data = b & (1 << bitNum); - return count; -} - -/** Read a single bit from a 16-bit device register. - * @param devAddr I2C slave device address - * @param regAddr Register regAddr to read from - * @param bitNum Bit position to read (0-15) - * @param data Container for single bit value - * @param timeout Optional read timeout in milliseconds (0 to disable, leave off to use default class value in I2Cdev::readTimeout) - * @return Status of read operation (true = success) - */ -int8_t I2Cdev::readBitW(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint16_t *data, uint16_t timeout) { - uint16_t b; - uint8_t count = readWord(devAddr, regAddr, &b, timeout); - *data = b & (1 << bitNum); - return count; -} - -/** Read multiple bits from an 8-bit device register. - * @param devAddr I2C slave device address - * @param regAddr Register regAddr to read from - * @param bitStart First bit position to read (0-7) - * @param length Number of bits to read (not more than 8) - * @param data Container for right-aligned value (i.e. '101' read from any bitStart position will equal 0x05) - * @param timeout Optional read timeout in milliseconds (0 to disable, leave off to use default class value in I2Cdev::readTimeout) - * @return Status of read operation (true = success) - */ -int8_t I2Cdev::readBits(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint8_t *data, uint16_t timeout) { - // 01101001 read byte - // 76543210 bit numbers - // xxx args: bitStart=4, length=3 - // 010 masked - // -> 010 shifted - uint8_t count, b; - if ((count = readByte(devAddr, regAddr, &b, timeout)) != 0) { - uint8_t mask = ((1 << length) - 1) << (bitStart - length + 1); - b &= mask; - b >>= (bitStart - length + 1); - *data = b; - } - return count; -} - -/** Read multiple bits from a 16-bit device register. - * @param devAddr I2C slave device address - * @param regAddr Register regAddr to read from - * @param bitStart First bit position to read (0-15) - * @param length Number of bits to read (not more than 16) - * @param data Container for right-aligned value (i.e. '101' read from any bitStart position will equal 0x05) - * @param timeout Optional read timeout in milliseconds (0 to disable, leave off to use default class value in I2Cdev::readTimeout) - * @return Status of read operation (1 = success, 0 = failure, -1 = timeout) - */ -int8_t I2Cdev::readBitsW(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint16_t *data, uint16_t timeout) { - // 1101011001101001 read byte - // fedcba9876543210 bit numbers - // xxx args: bitStart=12, length=3 - // 010 masked - // -> 010 shifted - uint8_t count; - uint16_t w; - if ((count = readWord(devAddr, regAddr, &w, timeout)) != 0) { - uint16_t mask = ((1 << length) - 1) << (bitStart - length + 1); - w &= mask; - w >>= (bitStart - length + 1); - *data = w; - } - return count; -} - -/** Read single byte from an 8-bit device register. - * @param devAddr I2C slave device address - * @param regAddr Register regAddr to read from - * @param data Container for byte value read from device - * @param timeout Optional read timeout in milliseconds (0 to disable, leave off to use default class value in I2Cdev::readTimeout) - * @return Status of read operation (true = success) - */ -int8_t I2Cdev::readByte(uint8_t devAddr, uint8_t regAddr, uint8_t *data, uint16_t timeout) { - return readBytes(devAddr, regAddr, 1, data, timeout); -} - -/** Read single word from a 16-bit device register. - * @param devAddr I2C slave device address - * @param regAddr Register regAddr to read from - * @param data Container for word value read from device - * @param timeout Optional read timeout in milliseconds (0 to disable, leave off to use default class value in I2Cdev::readTimeout) - * @return Status of read operation (true = success) - */ -int8_t I2Cdev::readWord(uint8_t devAddr, uint8_t regAddr, uint16_t *data, uint16_t timeout) { - return readWords(devAddr, regAddr, 1, data, timeout); -} - -/** Read multiple bytes from an 8-bit device register. - * @param devAddr I2C slave device address - * @param regAddr First register regAddr to read from - * @param length Number of bytes to read - * @param data Buffer to store read data in - * @param timeout Optional read timeout in milliseconds (0 to disable, leave off to use default class value in I2Cdev::readTimeout) - * @return Number of bytes read (-1 indicates failure) - */ -int8_t I2Cdev::readBytes(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint8_t *data, uint16_t timeout) { - #ifdef I2CDEV_SERIAL_DEBUG - Serial.print("I2C (0x"); - Serial.print(devAddr, HEX); - Serial.print(") reading "); - Serial.print(length, DEC); - Serial.print(" bytes from 0x"); - Serial.print(regAddr, HEX); - Serial.print("..."); - #endif - - int8_t count = 0; - uint32_t t1 = millis(); - - #if (I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE) - - #if (ARDUINO < 100) - // Arduino v00xx (before v1.0), Wire library - - // I2C/TWI subsystem uses internal buffer that breaks with large data requests - // so if user requests more than BUFFER_LENGTH bytes, we have to do it in - // smaller chunks instead of all at once - for (uint8_t k = 0; k < length; k += min(length, BUFFER_LENGTH)) { - Wire.beginTransmission(devAddr); - Wire.send(regAddr); - Wire.endTransmission(); - Wire.beginTransmission(devAddr); - Wire.requestFrom(devAddr, (uint8_t)min(length - k, BUFFER_LENGTH)); - - for (; Wire.available() && (timeout == 0 || millis() - t1 < timeout); count++) { - data[count] = Wire.receive(); - #ifdef I2CDEV_SERIAL_DEBUG - Serial.print(data[count], HEX); - if (count + 1 < length) Serial.print(" "); - #endif - } - - Wire.endTransmission(); - } - #elif (ARDUINO == 100) - // Arduino v1.0.0, Wire library - // Adds standardized write() and read() stream methods instead of send() and receive() - - // I2C/TWI subsystem uses internal buffer that breaks with large data requests - // so if user requests more than BUFFER_LENGTH bytes, we have to do it in - // smaller chunks instead of all at once - for (uint8_t k = 0; k < length; k += min(length, BUFFER_LENGTH)) { - Wire.beginTransmission(devAddr); - Wire.write(regAddr); - Wire.endTransmission(); - Wire.beginTransmission(devAddr); - Wire.requestFrom(devAddr, (uint8_t)min(length - k, BUFFER_LENGTH)); - - for (; Wire.available() && (timeout == 0 || millis() - t1 < timeout); count++) { - data[count] = Wire.read(); - #ifdef I2CDEV_SERIAL_DEBUG - Serial.print(data[count], HEX); - if (count + 1 < length) Serial.print(" "); - #endif - } - - Wire.endTransmission(); - } - #elif (ARDUINO > 100) - // Arduino v1.0.1+, Wire library - // Adds official support for repeated start condition, yay! - - // I2C/TWI subsystem uses internal buffer that breaks with large data requests - // so if user requests more than BUFFER_LENGTH bytes, we have to do it in - // smaller chunks instead of all at once - for (uint8_t k = 0; k < length; k += min(length, BUFFER_LENGTH)) { - Wire.beginTransmission(devAddr); - Wire.write(regAddr); - Wire.endTransmission(); - Wire.beginTransmission(devAddr); - Wire.requestFrom(devAddr, (uint8_t)min(length - k, BUFFER_LENGTH)); - - for (; Wire.available() && (timeout == 0 || millis() - t1 < timeout); count++) { - data[count] = Wire.read(); - #ifdef I2CDEV_SERIAL_DEBUG - Serial.print(data[count], HEX); - if (count + 1 < length) Serial.print(" "); - #endif - } - } - #endif - - #elif (I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE) - - // Fastwire library - // no loop required for fastwire - uint8_t status = Fastwire::readBuf(devAddr << 1, regAddr, data, length); - if (status == 0) { - count = length; // success - } else { - count = -1; // error - } - - #endif - - // check for timeout - if (timeout > 0 && millis() - t1 >= timeout && count < length) count = -1; // timeout - - #ifdef I2CDEV_SERIAL_DEBUG - Serial.print(". Done ("); - Serial.print(count, DEC); - Serial.println(" read)."); - #endif - - return count; -} - -/** Read multiple words from a 16-bit device register. - * @param devAddr I2C slave device address - * @param regAddr First register regAddr to read from - * @param length Number of words to read - * @param data Buffer to store read data in - * @param timeout Optional read timeout in milliseconds (0 to disable, leave off to use default class value in I2Cdev::readTimeout) - * @return Number of words read (-1 indicates failure) - */ -int8_t I2Cdev::readWords(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint16_t *data, uint16_t timeout) { - #ifdef I2CDEV_SERIAL_DEBUG - Serial.print("I2C (0x"); - Serial.print(devAddr, HEX); - Serial.print(") reading "); - Serial.print(length, DEC); - Serial.print(" words from 0x"); - Serial.print(regAddr, HEX); - Serial.print("..."); - #endif - - int8_t count = 0; - uint32_t t1 = millis(); - - #if (I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE) - - #if (ARDUINO < 100) - // Arduino v00xx (before v1.0), Wire library - - // I2C/TWI subsystem uses internal buffer that breaks with large data requests - // so if user requests more than BUFFER_LENGTH bytes, we have to do it in - // smaller chunks instead of all at once - for (uint8_t k = 0; k < length * 2; k += min(length * 2, BUFFER_LENGTH)) { - Wire.beginTransmission(devAddr); - Wire.send(regAddr); - Wire.endTransmission(); - Wire.beginTransmission(devAddr); - Wire.requestFrom(devAddr, (uint8_t)(length * 2)); // length=words, this wants bytes - - bool msb = true; // starts with MSB, then LSB - for (; Wire.available() && count < length && (timeout == 0 || millis() - t1 < timeout);) { - if (msb) { - // first byte is bits 15-8 (MSb=15) - data[count] = Wire.receive() << 8; - } else { - // second byte is bits 7-0 (LSb=0) - data[count] |= Wire.receive(); - #ifdef I2CDEV_SERIAL_DEBUG - Serial.print(data[count], HEX); - if (count + 1 < length) Serial.print(" "); - #endif - count++; - } - msb = !msb; - } - - Wire.endTransmission(); - } - #elif (ARDUINO == 100) - // Arduino v1.0.0, Wire library - // Adds standardized write() and read() stream methods instead of send() and receive() - - // I2C/TWI subsystem uses internal buffer that breaks with large data requests - // so if user requests more than BUFFER_LENGTH bytes, we have to do it in - // smaller chunks instead of all at once - for (uint8_t k = 0; k < length * 2; k += min(length * 2, BUFFER_LENGTH)) { - Wire.beginTransmission(devAddr); - Wire.write(regAddr); - Wire.endTransmission(); - Wire.beginTransmission(devAddr); - Wire.requestFrom(devAddr, (uint8_t)(length * 2)); // length=words, this wants bytes - - bool msb = true; // starts with MSB, then LSB - for (; Wire.available() && count < length && (timeout == 0 || millis() - t1 < timeout);) { - if (msb) { - // first byte is bits 15-8 (MSb=15) - data[count] = Wire.read() << 8; - } else { - // second byte is bits 7-0 (LSb=0) - data[count] |= Wire.read(); - #ifdef I2CDEV_SERIAL_DEBUG - Serial.print(data[count], HEX); - if (count + 1 < length) Serial.print(" "); - #endif - count++; - } - msb = !msb; - } - - Wire.endTransmission(); - } - #elif (ARDUINO > 100) - // Arduino v1.0.1+, Wire library - // Adds official support for repeated start condition, yay! - - // I2C/TWI subsystem uses internal buffer that breaks with large data requests - // so if user requests more than BUFFER_LENGTH bytes, we have to do it in - // smaller chunks instead of all at once - for (uint8_t k = 0; k < length * 2; k += min(length * 2, BUFFER_LENGTH)) { - Wire.beginTransmission(devAddr); - Wire.write(regAddr); - Wire.endTransmission(); - Wire.beginTransmission(devAddr); - Wire.requestFrom(devAddr, (uint8_t)(length * 2)); // length=words, this wants bytes - - bool msb = true; // starts with MSB, then LSB - for (; Wire.available() && count < length && (timeout == 0 || millis() - t1 < timeout);) { - if (msb) { - // first byte is bits 15-8 (MSb=15) - data[count] = Wire.read() << 8; - } else { - // second byte is bits 7-0 (LSb=0) - data[count] |= Wire.read(); - #ifdef I2CDEV_SERIAL_DEBUG - Serial.print(data[count], HEX); - if (count + 1 < length) Serial.print(" "); - #endif - count++; - } - msb = !msb; - } - - Wire.endTransmission(); - } - #endif - - #elif (I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE) - - // Fastwire library - // no loop required for fastwire - uint16_t intermediate[(uint8_t)length]; - uint8_t status = Fastwire::readBuf(devAddr << 1, regAddr, (uint8_t *)intermediate, (uint8_t)(length * 2)); - if (status == 0) { - count = length; // success - for (uint8_t i = 0; i < length; i++) { - data[i] = (intermediate[2*i] << 8) | intermediate[2*i + 1]; - } - } else { - count = -1; // error - } - - #endif - - if (timeout > 0 && millis() - t1 >= timeout && count < length) count = -1; // timeout - - #ifdef I2CDEV_SERIAL_DEBUG - Serial.print(". Done ("); - Serial.print(count, DEC); - Serial.println(" read)."); - #endif - - return count; -} - -/** write a single bit in an 8-bit device register. - * @param devAddr I2C slave device address - * @param regAddr Register regAddr to write to - * @param bitNum Bit position to write (0-7) - * @param value New bit value to write - * @return Status of operation (true = success) - */ -bool I2Cdev::writeBit(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint8_t data) { - uint8_t b; - readByte(devAddr, regAddr, &b); - b = (data != 0) ? (b | (1 << bitNum)) : (b & ~(1 << bitNum)); - return writeByte(devAddr, regAddr, b); -} - -/** write a single bit in a 16-bit device register. - * @param devAddr I2C slave device address - * @param regAddr Register regAddr to write to - * @param bitNum Bit position to write (0-15) - * @param value New bit value to write - * @return Status of operation (true = success) - */ -bool I2Cdev::writeBitW(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint16_t data) { - uint16_t w; - readWord(devAddr, regAddr, &w); - w = (data != 0) ? (w | (1 << bitNum)) : (w & ~(1 << bitNum)); - return writeWord(devAddr, regAddr, w); -} - -/** Write multiple bits in an 8-bit device register. - * @param devAddr I2C slave device address - * @param regAddr Register regAddr to write to - * @param bitStart First bit position to write (0-7) - * @param length Number of bits to write (not more than 8) - * @param data Right-aligned value to write - * @return Status of operation (true = success) - */ -bool I2Cdev::writeBits(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint8_t data) { - // 010 value to write - // 76543210 bit numbers - // xxx args: bitStart=4, length=3 - // 00011100 mask byte - // 10101111 original value (sample) - // 10100011 original & ~mask - // 10101011 masked | value - uint8_t b; - if (readByte(devAddr, regAddr, &b) != 0) { - uint8_t mask = ((1 << length) - 1) << (bitStart - length + 1); - data <<= (bitStart - length + 1); // shift data into correct position - data &= mask; // zero all non-important bits in data - b &= ~(mask); // zero all important bits in existing byte - b |= data; // combine data with existing byte - return writeByte(devAddr, regAddr, b); - } else { - return false; - } -} - -/** Write multiple bits in a 16-bit device register. - * @param devAddr I2C slave device address - * @param regAddr Register regAddr to write to - * @param bitStart First bit position to write (0-15) - * @param length Number of bits to write (not more than 16) - * @param data Right-aligned value to write - * @return Status of operation (true = success) - */ -bool I2Cdev::writeBitsW(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint16_t data) { - // 010 value to write - // fedcba9876543210 bit numbers - // xxx args: bitStart=12, length=3 - // 0001110000000000 mask word - // 1010111110010110 original value (sample) - // 1010001110010110 original & ~mask - // 1010101110010110 masked | value - uint16_t w; - if (readWord(devAddr, regAddr, &w) != 0) { - uint16_t mask = ((1 << length) - 1) << (bitStart - length + 1); - data <<= (bitStart - length + 1); // shift data into correct position - data &= mask; // zero all non-important bits in data - w &= ~(mask); // zero all important bits in existing word - w |= data; // combine data with existing word - return writeWord(devAddr, regAddr, w); - } else { - return false; - } -} - -/** Write single byte to an 8-bit device register. - * @param devAddr I2C slave device address - * @param regAddr Register address to write to - * @param data New byte value to write - * @return Status of operation (true = success) - */ -bool I2Cdev::writeByte(uint8_t devAddr, uint8_t regAddr, uint8_t data) { - return writeBytes(devAddr, regAddr, 1, &data); -} - -/** Write single word to a 16-bit device register. - * @param devAddr I2C slave device address - * @param regAddr Register address to write to - * @param data New word value to write - * @return Status of operation (true = success) - */ -bool I2Cdev::writeWord(uint8_t devAddr, uint8_t regAddr, uint16_t data) { - return writeWords(devAddr, regAddr, 1, &data); -} - -/** Write multiple bytes to an 8-bit device register. - * @param devAddr I2C slave device address - * @param regAddr First register address to write to - * @param length Number of bytes to write - * @param data Buffer to copy new data from - * @return Status of operation (true = success) - */ -bool I2Cdev::writeBytes(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint8_t* data) { - #ifdef I2CDEV_SERIAL_DEBUG - Serial.print("I2C (0x"); - Serial.print(devAddr, HEX); - Serial.print(") writing "); - Serial.print(length, DEC); - Serial.print(" bytes to 0x"); - Serial.print(regAddr, HEX); - Serial.print("..."); - #endif - uint8_t status = 0; - #if ((I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE && ARDUINO < 100) || I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_NBWIRE) - Wire.beginTransmission(devAddr); - Wire.send((uint8_t) regAddr); // send address - #elif (I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE && ARDUINO >= 100) - Wire.beginTransmission(devAddr); - Wire.write((uint8_t) regAddr); // send address - #elif (I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE) - Fastwire::beginTransmission(devAddr); - Fastwire::write(regAddr); - #endif - for (uint8_t i = 0; i < length; i++) { - #ifdef I2CDEV_SERIAL_DEBUG - Serial.print(data[i], HEX); - if (i + 1 < length) Serial.print(" "); - #endif - #if ((I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE && ARDUINO < 100) || I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_NBWIRE) - Wire.send((uint8_t) data[i]); - #elif (I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE && ARDUINO >= 100) - Wire.write((uint8_t) data[i]); - #elif (I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE) - Fastwire::write((uint8_t) data[i]); - #endif - } - #if ((I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE && ARDUINO < 100) || I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_NBWIRE) - Wire.endTransmission(); - #elif (I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE && ARDUINO >= 100) - status = Wire.endTransmission(); - #elif (I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE) - Fastwire::stop(); - //status = Fastwire::endTransmission(); - #endif - #ifdef I2CDEV_SERIAL_DEBUG - Serial.println(". Done."); - #endif - return status == 0; -} - -/** Write multiple words to a 16-bit device register. - * @param devAddr I2C slave device address - * @param regAddr First register address to write to - * @param length Number of words to write - * @param data Buffer to copy new data from - * @return Status of operation (true = success) - */ -bool I2Cdev::writeWords(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint16_t* data) { - #ifdef I2CDEV_SERIAL_DEBUG - Serial.print("I2C (0x"); - Serial.print(devAddr, HEX); - Serial.print(") writing "); - Serial.print(length, DEC); - Serial.print(" words to 0x"); - Serial.print(regAddr, HEX); - Serial.print("..."); - #endif - uint8_t status = 0; - #if ((I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE && ARDUINO < 100) || I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_NBWIRE) - Wire.beginTransmission(devAddr); - Wire.send(regAddr); // send address - #elif (I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE && ARDUINO >= 100) - Wire.beginTransmission(devAddr); - Wire.write(regAddr); // send address - #elif (I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE) - Fastwire::beginTransmission(devAddr); - Fastwire::write(regAddr); - #endif - for (uint8_t i = 0; i < length * 2; i++) { - #ifdef I2CDEV_SERIAL_DEBUG - Serial.print(data[i], HEX); - if (i + 1 < length) Serial.print(" "); - #endif - #if ((I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE && ARDUINO < 100) || I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_NBWIRE) - Wire.send((uint8_t)(data[i] >> 8)); // send MSB - Wire.send((uint8_t)data[i++]); // send LSB - #elif (I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE && ARDUINO >= 100) - Wire.write((uint8_t)(data[i] >> 8)); // send MSB - Wire.write((uint8_t)data[i++]); // send LSB - #elif (I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE) - Fastwire::write((uint8_t)(data[i] >> 8)); // send MSB - status = Fastwire::write((uint8_t)data[i++]); // send LSB - if (status != 0) break; - #endif - } - #if ((I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE && ARDUINO < 100) || I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_NBWIRE) - Wire.endTransmission(); - #elif (I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE && ARDUINO >= 100) - status = Wire.endTransmission(); - #elif (I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE) - Fastwire::stop(); - //status = Fastwire::endTransmission(); - #endif - #ifdef I2CDEV_SERIAL_DEBUG - Serial.println(". Done."); - #endif - return status == 0; -} - -/** Default timeout value for read operations. - * Set this to 0 to disable timeout detection. - */ -uint16_t I2Cdev::readTimeout = I2CDEV_DEFAULT_READ_TIMEOUT; - -#if I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE - // I2C library - ////////////////////// - // Copyright(C) 2012 - // Francesco Ferrara - // ferrara[at]libero[point]it - ////////////////////// - - /* - FastWire - - 0.24 added stop - - 0.23 added reset - - This is a library to help faster programs to read I2C devices. - Copyright(C) 2012 Francesco Ferrara - occhiobello at gmail dot com - [used by Jeff Rowberg for I2Cdevlib with permission] - */ - - boolean Fastwire::waitInt() { - int l = 250; - while (!(TWCR & (1 << TWINT)) && l-- > 0); - return l > 0; - } - - void Fastwire::setup(int khz, boolean pullup) { - TWCR = 0; - #if defined(__AVR_ATmega168__) || defined(__AVR_ATmega8__) || defined(__AVR_ATmega328P__) - // activate internal pull-ups for twi (PORTC bits 4 & 5) - // as per note from atmega8 manual pg167 - if (pullup) PORTC |= ((1 << 4) | (1 << 5)); - else PORTC &= ~((1 << 4) | (1 << 5)); - #elif defined(__AVR_ATmega644P__) || defined(__AVR_ATmega644__) - // activate internal pull-ups for twi (PORTC bits 0 & 1) - if (pullup) PORTC |= ((1 << 0) | (1 << 1)); - else PORTC &= ~((1 << 0) | (1 << 1)); - #else - // activate internal pull-ups for twi (PORTD bits 0 & 1) - // as per note from atmega128 manual pg204 - if (pullup) PORTD |= ((1 << 0) | (1 << 1)); - else PORTD &= ~((1 << 0) | (1 << 1)); - #endif - - TWSR = 0; // no prescaler => prescaler = 1 - TWBR = ((16000L / khz) - 16) / 2; // change the I2C clock rate - TWCR = 1 << TWEN; // enable twi module, no interrupt - } - - // added by Jeff Rowberg 2013-05-07: - // Arduino Wire-style "beginTransmission" function - // (takes 7-bit device address like the Wire method, NOT 8-bit: 0x68, not 0xD0/0xD1) - byte Fastwire::beginTransmission(byte device) { - byte twst, retry; - retry = 2; - do { - TWCR = (1 << TWINT) | (1 << TWEN) | (1 << TWSTO) | (1 << TWSTA); - if (!waitInt()) return 1; - twst = TWSR & 0xF8; - if (twst != TW_START && twst != TW_REP_START) return 2; - - //Serial.print(device, HEX); - //Serial.print(" "); - TWDR = device << 1; // send device address without read bit (1) - TWCR = (1 << TWINT) | (1 << TWEN); - if (!waitInt()) return 3; - twst = TWSR & 0xF8; - } while (twst == TW_MT_SLA_NACK && retry-- > 0); - if (twst != TW_MT_SLA_ACK) return 4; - return 0; - } - - byte Fastwire::writeBuf(byte device, byte address, byte *data, byte num) { - byte twst, retry; - - retry = 2; - do { - TWCR = (1 << TWINT) | (1 << TWEN) | (1 << TWSTO) | (1 << TWSTA); - if (!waitInt()) return 1; - twst = TWSR & 0xF8; - if (twst != TW_START && twst != TW_REP_START) return 2; - - //Serial.print(device, HEX); - //Serial.print(" "); - TWDR = device & 0xFE; // send device address without read bit (1) - TWCR = (1 << TWINT) | (1 << TWEN); - if (!waitInt()) return 3; - twst = TWSR & 0xF8; - } while (twst == TW_MT_SLA_NACK && retry-- > 0); - if (twst != TW_MT_SLA_ACK) return 4; - - //Serial.print(address, HEX); - //Serial.print(" "); - TWDR = address; // send data to the previously addressed device - TWCR = (1 << TWINT) | (1 << TWEN); - if (!waitInt()) return 5; - twst = TWSR & 0xF8; - if (twst != TW_MT_DATA_ACK) return 6; - - for (byte i = 0; i < num; i++) { - //Serial.print(data[i], HEX); - //Serial.print(" "); - TWDR = data[i]; // send data to the previously addressed device - TWCR = (1 << TWINT) | (1 << TWEN); - if (!waitInt()) return 7; - twst = TWSR & 0xF8; - if (twst != TW_MT_DATA_ACK) return 8; - } - //Serial.print("\n"); - - return 0; - } - - byte Fastwire::write(byte value) { - byte twst; - //Serial.println(value, HEX); - TWDR = value; // send data - TWCR = (1 << TWINT) | (1 << TWEN); - if (!waitInt()) return 1; - twst = TWSR & 0xF8; - if (twst != TW_MT_DATA_ACK) return 2; - return 0; - } - - byte Fastwire::readBuf(byte device, byte address, byte *data, byte num) { - byte twst, retry; - - retry = 2; - do { - TWCR = (1 << TWINT) | (1 << TWEN) | (1 << TWSTO) | (1 << TWSTA); - if (!waitInt()) return 16; - twst = TWSR & 0xF8; - if (twst != TW_START && twst != TW_REP_START) return 17; - - //Serial.print(device, HEX); - //Serial.print(" "); - TWDR = device & 0xfe; // send device address to write - TWCR = (1 << TWINT) | (1 << TWEN); - if (!waitInt()) return 18; - twst = TWSR & 0xF8; - } while (twst == TW_MT_SLA_NACK && retry-- > 0); - if (twst != TW_MT_SLA_ACK) return 19; - - //Serial.print(address, HEX); - //Serial.print(" "); - TWDR = address; // send data to the previously addressed device - TWCR = (1 << TWINT) | (1 << TWEN); - if (!waitInt()) return 20; - twst = TWSR & 0xF8; - if (twst != TW_MT_DATA_ACK) return 21; - - /***/ - - retry = 2; - do { - TWCR = (1 << TWINT) | (1 << TWEN) | (1 << TWSTO) | (1 << TWSTA); - if (!waitInt()) return 22; - twst = TWSR & 0xF8; - if (twst != TW_START && twst != TW_REP_START) return 23; - - //Serial.print(device, HEX); - //Serial.print(" "); - TWDR = device | 0x01; // send device address with the read bit (1) - TWCR = (1 << TWINT) | (1 << TWEN); - if (!waitInt()) return 24; - twst = TWSR & 0xF8; - } while (twst == TW_MR_SLA_NACK && retry-- > 0); - if (twst != TW_MR_SLA_ACK) return 25; - - for (uint8_t i = 0; i < num; i++) { - if (i == num - 1) - TWCR = (1 << TWINT) | (1 << TWEN); - else - TWCR = (1 << TWINT) | (1 << TWEN) | (1 << TWEA); - if (!waitInt()) return 26; - twst = TWSR & 0xF8; - if (twst != TW_MR_DATA_ACK && twst != TW_MR_DATA_NACK) return twst; - data[i] = TWDR; - //Serial.print(data[i], HEX); - //Serial.print(" "); - } - //Serial.print("\n"); - stop(); - - return 0; - } - - void Fastwire::reset() { - TWCR = 0; - } - - byte Fastwire::stop() { - TWCR = (1 << TWINT) | (1 << TWEN) | (1 << TWSTO); - if (!waitInt()) return 1; - return 0; - } -#endif - -#if I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_NBWIRE - // NBWire implementation based heavily on code by Gene Knight - // Originally posted on the Arduino forum at http://arduino.cc/forum/index.php/topic,70705.0.html - // Originally offered to the i2cdevlib project at http://arduino.cc/forum/index.php/topic,68210.30.html - - /* - call this version 1.0 - - Offhand, the only funky part that I can think of is in nbrequestFrom, where the buffer - length and index are set *before* the data is actually read. The problem is that these - are variables local to the TwoWire object, and by the time we actually have read the - data, and know what the length actually is, we have no simple access to the object's - variables. The actual bytes read *is* given to the callback function, though. - - The ISR code for a slave receiver is commented out. I don't have that setup, and can't - verify it at this time. Save it for 2.0! - - The handling of the read and write processes here is much like in the demo sketch code: - the process is broken down into sequential functions, where each registers the next as a - callback, essentially. - - For example, for the Read process, twi_read00 just returns if TWI is not yet in a - ready state. When there's another interrupt, and the interface *is* ready, then it - sets up the read, starts it, and registers twi_read01 as the function to call after - the *next* interrupt. twi_read01, then, just returns if the interface is still in a - "reading" state. When the reading is done, it copies the information to the buffer, - cleans up, and calls the user-requested callback function with the actual number of - bytes read. - - The writing is similar. - - Questions, comments and problems can go to Gene@Telobot.com. - - Thumbs Up! - Gene Knight - - */ - - uint8_t TwoWire::rxBuffer[NBWIRE_BUFFER_LENGTH]; - uint8_t TwoWire::rxBufferIndex = 0; - uint8_t TwoWire::rxBufferLength = 0; - - uint8_t TwoWire::txAddress = 0; - uint8_t TwoWire::txBuffer[NBWIRE_BUFFER_LENGTH]; - uint8_t TwoWire::txBufferIndex = 0; - uint8_t TwoWire::txBufferLength = 0; - - //uint8_t TwoWire::transmitting = 0; - void (*TwoWire::user_onRequest)(void); - void (*TwoWire::user_onReceive)(int); - - static volatile uint8_t twi_transmitting; - static volatile uint8_t twi_state; - static uint8_t twi_slarw; - static volatile uint8_t twi_error; - static uint8_t twi_masterBuffer[TWI_BUFFER_LENGTH]; - static volatile uint8_t twi_masterBufferIndex; - static uint8_t twi_masterBufferLength; - static uint8_t twi_rxBuffer[TWI_BUFFER_LENGTH]; - static volatile uint8_t twi_rxBufferIndex; - //static volatile uint8_t twi_Interrupt_Continue_Command; - static volatile uint8_t twi_Return_Value; - static volatile uint8_t twi_Done; - void (*twi_cbendTransmissionDone)(int); - void (*twi_cbreadFromDone)(int); - - void twi_init() { - // initialize state - twi_state = TWI_READY; - - // activate internal pull-ups for twi - // as per note from atmega8 manual pg167 - sbi(PORTC, 4); - sbi(PORTC, 5); - - // initialize twi prescaler and bit rate - cbi(TWSR, TWPS0); // TWI Status Register - Prescaler bits - cbi(TWSR, TWPS1); - - /* twi bit rate formula from atmega128 manual pg 204 - SCL Frequency = CPU Clock Frequency / (16 + (2 * TWBR)) - note: TWBR should be 10 or higher for master mode - It is 72 for a 16mhz Wiring board with 100kHz TWI */ - - TWBR = ((CPU_FREQ / TWI_FREQ) - 16) / 2; // bitrate register - // enable twi module, acks, and twi interrupt - - TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWEA); - - /* TWEN - TWI Enable Bit - TWIE - TWI Interrupt Enable - TWEA - TWI Enable Acknowledge Bit - TWINT - TWI Interrupt Flag - TWSTA - TWI Start Condition - */ - } - - typedef struct { - uint8_t address; - uint8_t* data; - uint8_t length; - uint8_t wait; - uint8_t i; - } twi_Write_Vars; - - twi_Write_Vars *ptwv = 0; - static void (*fNextInterruptFunction)(void) = 0; - - void twi_Finish(byte bRetVal) { - if (ptwv) { - free(ptwv); - ptwv = 0; - } - twi_Done = 0xFF; - twi_Return_Value = bRetVal; - fNextInterruptFunction = 0; - } - - uint8_t twii_WaitForDone(uint16_t timeout) { - uint32_t endMillis = millis() + timeout; - while (!twi_Done && (timeout == 0 || millis() < endMillis)) continue; - return twi_Return_Value; - } - - void twii_SetState(uint8_t ucState) { - twi_state = ucState; - } - - void twii_SetError(uint8_t ucError) { - twi_error = ucError ; - } - - void twii_InitBuffer(uint8_t ucPos, uint8_t ucLength) { - twi_masterBufferIndex = 0; - twi_masterBufferLength = ucLength; - } - - void twii_CopyToBuf(uint8_t* pData, uint8_t ucLength) { - uint8_t i; - for (i = 0; i < ucLength; ++i) { - twi_masterBuffer[i] = pData[i]; - } - } - - void twii_CopyFromBuf(uint8_t *pData, uint8_t ucLength) { - uint8_t i; - for (i = 0; i < ucLength; ++i) { - pData[i] = twi_masterBuffer[i]; - } - } - - void twii_SetSlaRW(uint8_t ucSlaRW) { - twi_slarw = ucSlaRW; - } - - void twii_SetStart() { - TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWEA) | _BV(TWINT) | _BV(TWSTA); - } - - void twi_write01() { - if (TWI_MTX == twi_state) return; // blocking test - twi_transmitting = 0 ; - if (twi_error == 0xFF) - twi_Finish (0); // success - else if (twi_error == TW_MT_SLA_NACK) - twi_Finish (2); // error: address send, nack received - else if (twi_error == TW_MT_DATA_NACK) - twi_Finish (3); // error: data send, nack received - else - twi_Finish (4); // other twi error - if (twi_cbendTransmissionDone) return twi_cbendTransmissionDone(twi_Return_Value); - return; - } - - - void twi_write00() { - if (TWI_READY != twi_state) return; // blocking test - if (TWI_BUFFER_LENGTH < ptwv -> length) { - twi_Finish(1); // end write with error 1 - return; - } - twi_Done = 0x00; // show as working - twii_SetState(TWI_MTX); // to transmitting - twii_SetError(0xFF); // to No Error - twii_InitBuffer(0, ptwv -> length); // pointer and length - twii_CopyToBuf(ptwv -> data, ptwv -> length); // get the data - twii_SetSlaRW((ptwv -> address << 1) | TW_WRITE); // write command - twii_SetStart(); // start the cycle - fNextInterruptFunction = twi_write01; // next routine - return twi_write01(); - } - - void twi_writeTo(uint8_t address, uint8_t* data, uint8_t length, uint8_t wait) { - uint8_t i; - ptwv = (twi_Write_Vars *)malloc(sizeof(twi_Write_Vars)); - ptwv -> address = address; - ptwv -> data = data; - ptwv -> length = length; - ptwv -> wait = wait; - fNextInterruptFunction = twi_write00; - return twi_write00(); - } - - void twi_read01() { - if (TWI_MRX == twi_state) return; // blocking test - if (twi_masterBufferIndex < ptwv -> length) ptwv -> length = twi_masterBufferIndex; - twii_CopyFromBuf(ptwv -> data, ptwv -> length); - twi_Finish(ptwv -> length); - if (twi_cbreadFromDone) return twi_cbreadFromDone(twi_Return_Value); - return; - } - - void twi_read00() { - if (TWI_READY != twi_state) return; // blocking test - if (TWI_BUFFER_LENGTH < ptwv -> length) twi_Finish(0); // error return - twi_Done = 0x00; // show as working - twii_SetState(TWI_MRX); // reading - twii_SetError(0xFF); // reset error - twii_InitBuffer(0, ptwv -> length - 1); // init to one less than length - twii_SetSlaRW((ptwv -> address << 1) | TW_READ); // read command - twii_SetStart(); // start cycle - fNextInterruptFunction = twi_read01; - return twi_read01(); - } - - void twi_readFrom(uint8_t address, uint8_t* data, uint8_t length) { - uint8_t i; - - ptwv = (twi_Write_Vars *)malloc(sizeof(twi_Write_Vars)); - ptwv -> address = address; - ptwv -> data = data; - ptwv -> length = length; - fNextInterruptFunction = twi_read00; - return twi_read00(); - } - - void twi_reply(uint8_t ack) { - // transmit master read ready signal, with or without ack - if (ack){ - TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWINT) | _BV(TWEA); - } else { - TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWINT); - } - } - - void twi_stop(void) { - // send stop condition - TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWEA) | _BV(TWINT) | _BV(TWSTO); - - // wait for stop condition to be exectued on bus - // TWINT is not set after a stop condition! - while (TWCR & _BV(TWSTO)) { - continue; - } - - // update twi state - twi_state = TWI_READY; - } - - void twi_releaseBus(void) { - // release bus - TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWEA) | _BV(TWINT); - - // update twi state - twi_state = TWI_READY; - } - - SIGNAL(TWI_vect) { - switch (TW_STATUS) { - // All Master - case TW_START: // sent start condition - case TW_REP_START: // sent repeated start condition - // copy device address and r/w bit to output register and ack - TWDR = twi_slarw; - twi_reply(1); - break; - - // Master Transmitter - case TW_MT_SLA_ACK: // slave receiver acked address - case TW_MT_DATA_ACK: // slave receiver acked data - // if there is data to send, send it, otherwise stop - if (twi_masterBufferIndex < twi_masterBufferLength) { - // copy data to output register and ack - TWDR = twi_masterBuffer[twi_masterBufferIndex++]; - twi_reply(1); - } else { - twi_stop(); - } - break; - - case TW_MT_SLA_NACK: // address sent, nack received - twi_error = TW_MT_SLA_NACK; - twi_stop(); - break; - - case TW_MT_DATA_NACK: // data sent, nack received - twi_error = TW_MT_DATA_NACK; - twi_stop(); - break; - - case TW_MT_ARB_LOST: // lost bus arbitration - twi_error = TW_MT_ARB_LOST; - twi_releaseBus(); - break; - - // Master Receiver - case TW_MR_DATA_ACK: // data received, ack sent - // put byte into buffer - twi_masterBuffer[twi_masterBufferIndex++] = TWDR; - - case TW_MR_SLA_ACK: // address sent, ack received - // ack if more bytes are expected, otherwise nack - if (twi_masterBufferIndex < twi_masterBufferLength) { - twi_reply(1); - } else { - twi_reply(0); - } - break; - - case TW_MR_DATA_NACK: // data received, nack sent - // put final byte into buffer - twi_masterBuffer[twi_masterBufferIndex++] = TWDR; - - case TW_MR_SLA_NACK: // address sent, nack received - twi_stop(); - break; - - // TW_MR_ARB_LOST handled by TW_MT_ARB_LOST case - - // Slave Receiver (NOT IMPLEMENTED YET) - /* - case TW_SR_SLA_ACK: // addressed, returned ack - case TW_SR_GCALL_ACK: // addressed generally, returned ack - case TW_SR_ARB_LOST_SLA_ACK: // lost arbitration, returned ack - case TW_SR_ARB_LOST_GCALL_ACK: // lost arbitration, returned ack - // enter slave receiver mode - twi_state = TWI_SRX; - - // indicate that rx buffer can be overwritten and ack - twi_rxBufferIndex = 0; - twi_reply(1); - break; - - case TW_SR_DATA_ACK: // data received, returned ack - case TW_SR_GCALL_DATA_ACK: // data received generally, returned ack - // if there is still room in the rx buffer - if (twi_rxBufferIndex < TWI_BUFFER_LENGTH) { - // put byte in buffer and ack - twi_rxBuffer[twi_rxBufferIndex++] = TWDR; - twi_reply(1); - } else { - // otherwise nack - twi_reply(0); - } - break; - - case TW_SR_STOP: // stop or repeated start condition received - // put a null char after data if there's room - if (twi_rxBufferIndex < TWI_BUFFER_LENGTH) { - twi_rxBuffer[twi_rxBufferIndex] = 0; - } - - // sends ack and stops interface for clock stretching - twi_stop(); - - // callback to user defined callback - twi_onSlaveReceive(twi_rxBuffer, twi_rxBufferIndex); - - // since we submit rx buffer to "wire" library, we can reset it - twi_rxBufferIndex = 0; - - // ack future responses and leave slave receiver state - twi_releaseBus(); - break; - - case TW_SR_DATA_NACK: // data received, returned nack - case TW_SR_GCALL_DATA_NACK: // data received generally, returned nack - // nack back at master - twi_reply(0); - break; - - // Slave Transmitter - case TW_ST_SLA_ACK: // addressed, returned ack - case TW_ST_ARB_LOST_SLA_ACK: // arbitration lost, returned ack - // enter slave transmitter mode - twi_state = TWI_STX; - - // ready the tx buffer index for iteration - twi_txBufferIndex = 0; - - // set tx buffer length to be zero, to verify if user changes it - twi_txBufferLength = 0; - - // request for txBuffer to be filled and length to be set - // note: user must call twi_transmit(bytes, length) to do this - twi_onSlaveTransmit(); - - // if they didn't change buffer & length, initialize it - if (0 == twi_txBufferLength) { - twi_txBufferLength = 1; - twi_txBuffer[0] = 0x00; - } - - // transmit first byte from buffer, fall through - - case TW_ST_DATA_ACK: // byte sent, ack returned - // copy data to output register - TWDR = twi_txBuffer[twi_txBufferIndex++]; - - // if there is more to send, ack, otherwise nack - if (twi_txBufferIndex < twi_txBufferLength) { - twi_reply(1); - } else { - twi_reply(0); - } - break; - - case TW_ST_DATA_NACK: // received nack, we are done - case TW_ST_LAST_DATA: // received ack, but we are done already! - // ack future responses - twi_reply(1); - // leave slave receiver state - twi_state = TWI_READY; - break; - */ - - // all - case TW_NO_INFO: // no state information - break; - - case TW_BUS_ERROR: // bus error, illegal stop/start - twi_error = TW_BUS_ERROR; - twi_stop(); - break; - } - - if (fNextInterruptFunction) return fNextInterruptFunction(); - } - - TwoWire::TwoWire() { } - - void TwoWire::begin(void) { - rxBufferIndex = 0; - rxBufferLength = 0; - - txBufferIndex = 0; - txBufferLength = 0; - - twi_init(); - } - - void TwoWire::beginTransmission(uint8_t address) { - //beginTransmission((uint8_t)address); - - // indicate that we are transmitting - twi_transmitting = 1; - - // set address of targeted slave - txAddress = address; - - // reset tx buffer iterator vars - txBufferIndex = 0; - txBufferLength = 0; - } - - uint8_t TwoWire::endTransmission(uint16_t timeout) { - // transmit buffer (blocking) - //int8_t ret = - twi_cbendTransmissionDone = NULL; - twi_writeTo(txAddress, txBuffer, txBufferLength, 1); - int8_t ret = twii_WaitForDone(timeout); - - // reset tx buffer iterator vars - txBufferIndex = 0; - txBufferLength = 0; - - // indicate that we are done transmitting - // twi_transmitting = 0; - return ret; - } - - void TwoWire::nbendTransmission(void (*function)(int)) { - twi_cbendTransmissionDone = function; - twi_writeTo(txAddress, txBuffer, txBufferLength, 1); - return; - } - - void TwoWire::send(uint8_t data) { - if (twi_transmitting) { - // in master transmitter mode - // don't bother if buffer is full - if (txBufferLength >= NBWIRE_BUFFER_LENGTH) { - return; - } - - // put byte in tx buffer - txBuffer[txBufferIndex] = data; - ++txBufferIndex; - - // update amount in buffer - txBufferLength = txBufferIndex; - } else { - // in slave send mode - // reply to master - //twi_transmit(&data, 1); - } - } - - uint8_t TwoWire::receive(void) { - // default to returning null char - // for people using with char strings - uint8_t value = 0; - - // get each successive byte on each call - if (rxBufferIndex < rxBufferLength) { - value = rxBuffer[rxBufferIndex]; - ++rxBufferIndex; - } - - return value; - } - - uint8_t TwoWire::requestFrom(uint8_t address, int quantity, uint16_t timeout) { - // clamp to buffer length - if (quantity > NBWIRE_BUFFER_LENGTH) { - quantity = NBWIRE_BUFFER_LENGTH; - } - - // perform blocking read into buffer - twi_cbreadFromDone = NULL; - twi_readFrom(address, rxBuffer, quantity); - uint8_t read = twii_WaitForDone(timeout); - - // set rx buffer iterator vars - rxBufferIndex = 0; - rxBufferLength = read; - - return read; - } - - void TwoWire::nbrequestFrom(uint8_t address, int quantity, void (*function)(int)) { - // clamp to buffer length - if (quantity > NBWIRE_BUFFER_LENGTH) { - quantity = NBWIRE_BUFFER_LENGTH; - } - - // perform blocking read into buffer - twi_cbreadFromDone = function; - twi_readFrom(address, rxBuffer, quantity); - //uint8_t read = twii_WaitForDone(); - - // set rx buffer iterator vars - //rxBufferIndex = 0; - //rxBufferLength = read; - - rxBufferIndex = 0; - rxBufferLength = quantity; // this is a hack - - return; //read; - } - - uint8_t TwoWire::available(void) { - return rxBufferLength - rxBufferIndex; - } - -#endif diff --git a/I2Cdev.h b/I2Cdev.h deleted file mode 100644 index 46cbcf0..0000000 --- a/I2Cdev.h +++ /dev/null @@ -1,281 +0,0 @@ -// I2Cdev library collection - Main I2C device class header file -// Abstracts bit and byte I2C R/W functions into a convenient class -// 2013-06-05 by Jeff Rowberg -// -// Changelog: -// 2015-10-30 - simondlevy : support i2c_t3 for Teensy3.1 -// 2013-05-06 - add Francesco Ferrara's Fastwire v0.24 implementation with small modifications -// 2013-05-05 - fix issue with writing bit values to words (Sasquatch/Farzanegan) -// 2012-06-09 - fix major issue with reading > 32 bytes at a time with Arduino Wire -// - add compiler warnings when using outdated or IDE or limited I2Cdev implementation -// 2011-11-01 - fix write*Bits mask calculation (thanks sasquatch @ Arduino forums) -// 2011-10-03 - added automatic Arduino version detection for ease of use -// 2011-10-02 - added Gene Knight's NBWire TwoWire class implementation with small modifications -// 2011-08-31 - added support for Arduino 1.0 Wire library (methods are different from 0.x) -// 2011-08-03 - added optional timeout parameter to read* methods to easily change from default -// 2011-08-02 - added support for 16-bit registers -// - fixed incorrect Doxygen comments on some methods -// - added timeout value for read operations (thanks mem @ Arduino forums) -// 2011-07-30 - changed read/write function structures to return success or byte counts -// - made all methods static for multi-device memory savings -// 2011-07-28 - initial release - -/* ============================================ -I2Cdev device library code is placed under the MIT license -Copyright (c) 2013 Jeff Rowberg - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in -all copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -THE SOFTWARE. -=============================================== -*/ - -#ifndef _I2CDEV_H_ -#define _I2CDEV_H_ - -// ----------------------------------------------------------------------------- -// I2C interface implementation setting -// ----------------------------------------------------------------------------- -#ifndef I2CDEV_IMPLEMENTATION -#define I2CDEV_IMPLEMENTATION I2CDEV_ARDUINO_WIRE -//#define I2CDEV_IMPLEMENTATION I2CDEV_BUILTIN_FASTWIRE -#endif // I2CDEV_IMPLEMENTATION - -// comment this out if you are using a non-optimal IDE/implementation setting -// but want the compiler to shut up about it -#define I2CDEV_IMPLEMENTATION_WARNINGS - -// ----------------------------------------------------------------------------- -// I2C interface implementation options -// ----------------------------------------------------------------------------- -#define I2CDEV_ARDUINO_WIRE 1 // Wire object from Arduino -#define I2CDEV_BUILTIN_NBWIRE 2 // Tweaked Wire object from Gene Knight's NBWire project - // ^^^ NBWire implementation is still buggy w/some interrupts! -#define I2CDEV_BUILTIN_FASTWIRE 3 // FastWire object from Francesco Ferrara's project -#define I2CDEV_I2CMASTER_LIBRARY 4 // I2C object from DSSCircuits I2C-Master Library at https://github.com/DSSCircuits/I2C-Master-Library - -// ----------------------------------------------------------------------------- -// Arduino-style "Serial.print" debug constant (uncomment to enable) -// ----------------------------------------------------------------------------- -//#define I2CDEV_SERIAL_DEBUG - -#ifdef ARDUINO - #if ARDUINO < 100 - #include "WProgram.h" - #else - #include "Arduino.h" - #endif - #if defined(CORE_TEENSY) && defined(__MK20DX256__) - #include - #define BUFFER_LENGTH 32 - #elif I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE - #include - #endif - #if I2CDEV_IMPLEMENTATION == I2CDEV_I2CMASTER_LIBRARY - #include - #endif -#endif - -#ifdef SPARK - #include - #define ARDUINO 101 -#endif - - -// 1000ms default read timeout (modify with "I2Cdev::readTimeout = [ms];") -#define I2CDEV_DEFAULT_READ_TIMEOUT 1000 - -class I2Cdev { - public: - I2Cdev(); - - static int8_t readBit(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint8_t *data, uint16_t timeout=I2Cdev::readTimeout); - static int8_t readBitW(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint16_t *data, uint16_t timeout=I2Cdev::readTimeout); - static int8_t readBits(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint8_t *data, uint16_t timeout=I2Cdev::readTimeout); - static int8_t readBitsW(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint16_t *data, uint16_t timeout=I2Cdev::readTimeout); - static int8_t readByte(uint8_t devAddr, uint8_t regAddr, uint8_t *data, uint16_t timeout=I2Cdev::readTimeout); - static int8_t readWord(uint8_t devAddr, uint8_t regAddr, uint16_t *data, uint16_t timeout=I2Cdev::readTimeout); - static int8_t readBytes(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint8_t *data, uint16_t timeout=I2Cdev::readTimeout); - static int8_t readWords(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint16_t *data, uint16_t timeout=I2Cdev::readTimeout); - - static bool writeBit(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint8_t data); - static bool writeBitW(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint16_t data); - static bool writeBits(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint8_t data); - static bool writeBitsW(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint16_t data); - static bool writeByte(uint8_t devAddr, uint8_t regAddr, uint8_t data); - static bool writeWord(uint8_t devAddr, uint8_t regAddr, uint16_t data); - static bool writeBytes(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint8_t *data); - static bool writeWords(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint16_t *data); - - static uint16_t readTimeout; -}; - -#if I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE - ////////////////////// - // FastWire 0.24 - // This is a library to help faster programs to read I2C devices. - // Copyright(C) 2012 - // Francesco Ferrara - ////////////////////// - - /* Master */ - #define TW_START 0x08 - #define TW_REP_START 0x10 - - /* Master Transmitter */ - #define TW_MT_SLA_ACK 0x18 - #define TW_MT_SLA_NACK 0x20 - #define TW_MT_DATA_ACK 0x28 - #define TW_MT_DATA_NACK 0x30 - #define TW_MT_ARB_LOST 0x38 - - /* Master Receiver */ - #define TW_MR_ARB_LOST 0x38 - #define TW_MR_SLA_ACK 0x40 - #define TW_MR_SLA_NACK 0x48 - #define TW_MR_DATA_ACK 0x50 - #define TW_MR_DATA_NACK 0x58 - - #define TW_OK 0 - #define TW_ERROR 1 - - class Fastwire { - private: - static boolean waitInt(); - - public: - static void setup(int khz, boolean pullup); - static byte beginTransmission(byte device); - static byte write(byte value); - static byte writeBuf(byte device, byte address, byte *data, byte num); - static byte readBuf(byte device, byte address, byte *data, byte num); - static void reset(); - static byte stop(); - }; -#endif - -#if I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_NBWIRE - // NBWire implementation based heavily on code by Gene Knight - // Originally posted on the Arduino forum at http://arduino.cc/forum/index.php/topic,70705.0.html - // Originally offered to the i2cdevlib project at http://arduino.cc/forum/index.php/topic,68210.30.html - - #define NBWIRE_BUFFER_LENGTH 32 - - class TwoWire { - private: - static uint8_t rxBuffer[]; - static uint8_t rxBufferIndex; - static uint8_t rxBufferLength; - - static uint8_t txAddress; - static uint8_t txBuffer[]; - static uint8_t txBufferIndex; - static uint8_t txBufferLength; - - // static uint8_t transmitting; - static void (*user_onRequest)(void); - static void (*user_onReceive)(int); - static void onRequestService(void); - static void onReceiveService(uint8_t*, int); - - public: - TwoWire(); - void begin(); - void begin(uint8_t); - void begin(int); - void beginTransmission(uint8_t); - //void beginTransmission(int); - uint8_t endTransmission(uint16_t timeout=0); - void nbendTransmission(void (*function)(int)) ; - uint8_t requestFrom(uint8_t, int, uint16_t timeout=0); - //uint8_t requestFrom(int, int); - void nbrequestFrom(uint8_t, int, void (*function)(int)); - void send(uint8_t); - void send(uint8_t*, uint8_t); - //void send(int); - void send(char*); - uint8_t available(void); - uint8_t receive(void); - void onReceive(void (*)(int)); - void onRequest(void (*)(void)); - }; - - #define TWI_READY 0 - #define TWI_MRX 1 - #define TWI_MTX 2 - #define TWI_SRX 3 - #define TWI_STX 4 - - #define TW_WRITE 0 - #define TW_READ 1 - - #define TW_MT_SLA_NACK 0x20 - #define TW_MT_DATA_NACK 0x30 - - #define CPU_FREQ 16000000L - #define TWI_FREQ 100000L - #define TWI_BUFFER_LENGTH 32 - - /* TWI Status is in TWSR, in the top 5 bits: TWS7 - TWS3 */ - - #define TW_STATUS_MASK (_BV(TWS7)|_BV(TWS6)|_BV(TWS5)|_BV(TWS4)|_BV(TWS3)) - #define TW_STATUS (TWSR & TW_STATUS_MASK) - #define TW_START 0x08 - #define TW_REP_START 0x10 - #define TW_MT_SLA_ACK 0x18 - #define TW_MT_SLA_NACK 0x20 - #define TW_MT_DATA_ACK 0x28 - #define TW_MT_DATA_NACK 0x30 - #define TW_MT_ARB_LOST 0x38 - #define TW_MR_ARB_LOST 0x38 - #define TW_MR_SLA_ACK 0x40 - #define TW_MR_SLA_NACK 0x48 - #define TW_MR_DATA_ACK 0x50 - #define TW_MR_DATA_NACK 0x58 - #define TW_ST_SLA_ACK 0xA8 - #define TW_ST_ARB_LOST_SLA_ACK 0xB0 - #define TW_ST_DATA_ACK 0xB8 - #define TW_ST_DATA_NACK 0xC0 - #define TW_ST_LAST_DATA 0xC8 - #define TW_SR_SLA_ACK 0x60 - #define TW_SR_ARB_LOST_SLA_ACK 0x68 - #define TW_SR_GCALL_ACK 0x70 - #define TW_SR_ARB_LOST_GCALL_ACK 0x78 - #define TW_SR_DATA_ACK 0x80 - #define TW_SR_DATA_NACK 0x88 - #define TW_SR_GCALL_DATA_ACK 0x90 - #define TW_SR_GCALL_DATA_NACK 0x98 - #define TW_SR_STOP 0xA0 - #define TW_NO_INFO 0xF8 - #define TW_BUS_ERROR 0x00 - - //#define _MMIO_BYTE(mem_addr) (*(volatile uint8_t *)(mem_addr)) - //#define _SFR_BYTE(sfr) _MMIO_BYTE(_SFR_ADDR(sfr)) - - #ifndef sbi // set bit - #define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit)) - #endif // sbi - - #ifndef cbi // clear bit - #define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit)) - #endif // cbi - - extern TwoWire Wire; - -#endif // I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_NBWIRE - -#endif /* _I2CDEV_H_ */ diff --git a/examples/FoxHunt/FoxHunt.ino b/examples/FoxHunt/FoxHunt.ino index 70fb926..dd2b906 100755 --- a/examples/FoxHunt/FoxHunt.ino +++ b/examples/FoxHunt/FoxHunt.ino @@ -1,7 +1,7 @@ /* Fox Hunt */ -#include -#include +#include +//#include #define PWM_PIN 3 #define RESET_PIN A3 @@ -13,7 +13,7 @@ #define INTERVAL 10 #define RANDOMCHANCE 3 -HAMShield radio; +HamShield radio; void setup() { // NOTE: if not using PWM out, it should be held low to avoid tx noise @@ -27,15 +27,15 @@ void setup() { pinMode(RESET_PIN, OUTPUT); digitalWrite(RESET_PIN, HIGH); - Wire.begin(); + //Wire.begin(); radio.initialize(); - radio.setFrequency(145510); + radio.frequency(145510); radio.setModeReceive(); } void loop() { waitMinute(INTERVAL + random(0,RANDOMCHANCE)); // wait before transmitting, randomly up to 3 minutes later - if(radio.waitForChannel(30000,2000)) { // wait for a clear channel, abort after 30 seconds, wait 2 seconds of dead air for breakers + if(radio.waitForChannel(30000,2000, -90)) { // wait for a clear channel, abort after 30 seconds, wait 2 seconds of dead air for breakers radio.setModeTransmit(); // turn on transmit mode tone(1000,11,TRANSMITLENGTH * 60 * 1000); // play a long solid tone radio.morseOut("1ZZ9ZZ/B FOXHUNT"); // identify the fox hunt transmitter @@ -49,4 +49,3 @@ void waitMinute(int period) { delay(period * 60 * 1000); } -