fix formatting, comments

HamShield.cpp

@@ -121,16 +121,22 @@ volatile long bouncer = 0;
 HamShield::HamShield() {
     devAddr = A1846S_DEV_ADDR_SENLOW;
     sHamShield = this;
+	
+    pinMode(A1, OUTPUT);
+    digitalWrite(A1, LOW);
 }
 
 /** Specific address constructor.
- * @param address I2C address
+ * @param address the I2C address of the HamShield
  * @see A1846S_DEFAULT_ADDRESS
  * @see A1846S_ADDRESS_AD0_LOW
  * @see A1846S_ADDRESS_AD0_HIGH
  */
 HamShield::HamShield(uint8_t address) {
     devAddr = address;
+
+    pinMode(A1, OUTPUT);
+    digitalWrite(A1, LOW);
 }
 
 /** Power on and prepare for general usage.
@@ -150,129 +156,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 +289,7 @@ void HamShield::initialize() {
 	setRfPower(0);
     setSQLoThresh(80);
     setSQOn();
+	*/
 }
 
 /** Verify the I2C connection.
@@ -289,7 +297,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 +324,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 +342,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 +351,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 +393,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 +406,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 +420,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 +436,7 @@ void HamShield::setTX(bool on_noff){
 		rx_active = false;
 		setRX(false);
 		
+		
 		if((radio_frequency >= 134000) && (radio_frequency <= 174000)) { 
 			setTxBand2m();
 		}
@@ -437,14 +446,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,28 +467,35 @@ 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);
 }
 
 void HamShield::setModeTransmit(){
     // check to see if we should allow them to do this
     if(restrictions == true) { 
-       if((radio_frequency > 139999) & (radio_frequency < 148001)) { setRX(false); } 
-       if((radio_frequency > 218999) & (radio_frequency < 225001)) { setRX(false); } 
-       if((radio_frequency > 419999) & (radio_frequency < 450001)) { setRX(false); }                     
-    } else { 
-		setTX(true);
-	}
+       if(((radio_frequency > 139999) & (radio_frequency < 148001)) || 
+          ((radio_frequency > 218999) & (radio_frequency < 225001)) || 
+          ((radio_frequency > 419999) & (radio_frequency < 450001)))
+		{ // we're good, so just drop down to the rest of this function
+		} else {
+			setRX(false);
+			return;
+		}			
+    }
+	setTX(true);
 } 
 void HamShield::setModeReceive(){
 	// turn on rx, turn off tx
@@ -483,7 +503,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 +522,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 +540,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 +555,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 +587,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 +613,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 +624,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 +675,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 +709,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);
-	oct_code = (radio_i2c_buf[0] << 16);
-	I2Cdev::readWord(devAddr, A1846S_CDCSS_CODE_LO_REG, radio_i2c_buf);
+	HSreadWord(devAddr, A1846S_CDCSS_CODE_HI_REG, radio_i2c_buf);
+	oct_code = ((uint32_t)radio_i2c_buf[0] << 16);
+	HSreadWord(devAddr, A1846S_CDCSS_CODE_LO_REG, radio_i2c_buf);
 	oct_code += radio_i2c_buf[0];
 	
 	oct_code = oct_code >> 12;
@@ -712,89 +732,91 @@ 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);
+void HamShield::setSQHiThresh(int16_t sq_hi_threshold){
+	// Sq detect high th, rssi_cmp will be 1 when rssi>th_h_sq, unit 1dB
+	uint16_t sq = 137 + sq_hi_threshold;
+	HSwriteWord(devAddr, A1846S_SQ_OPEN_THRESH_REG, sq);
 } 
-uint16_t HamShield::getSQHiThresh(){
-	I2Cdev::readWord(devAddr, A1846S_SQ_OPEN_THRESH_REG, radio_i2c_buf);
+int16_t HamShield::getSQHiThresh(){
+	HSreadWord(devAddr, A1846S_SQ_OPEN_THRESH_REG, radio_i2c_buf);
 	
-	return radio_i2c_buf[0];
+	return radio_i2c_buf[0] - 137;
 }
-void HamShield::setSQLoThresh(uint16_t sq_lo_threshold){
-	// Sq detect low th, rssi_cmp will be 0 when rssi<th_l_sq && time delay meet, unit 1/8 dB
-	I2Cdev::writeWord(devAddr, A1846S_SQ_SHUT_THRESH_REG, sq_lo_threshold);
+void HamShield::setSQLoThresh(int16_t sq_lo_threshold){
+	// Sq detect low th, rssi_cmp will be 0 when rssi<th_l_sq && time delay meet, unit 1 dB
+	uint16_t sq = 137 + sq_lo_threshold;
+	HSwriteWord(devAddr, A1846S_SQ_SHUT_THRESH_REG, sq);
 }
-uint16_t HamShield::getSQLoThresh(){
-	I2Cdev::readWord(devAddr, A1846S_SQ_SHUT_THRESH_REG, radio_i2c_buf);
+int16_t HamShield::getSQLoThresh(){
+	HSreadWord(devAddr, A1846S_SQ_SHUT_THRESH_REG, radio_i2c_buf);
 	
-	return radio_i2c_buf[0];
+	return radio_i2c_buf[0] - 137;
 }
 
 // SQ out select
 void HamShield::setSQOutSel(){
-    I2Cdev::writeBitW(devAddr, A1846S_SQ_OUT_SEL_REG, A1846S_SQ_OUT_SEL_BIT, 1);
+    HSwriteBitW(devAddr, A1846S_SQ_OUT_SEL_REG, A1846S_SQ_OUT_SEL_BIT, 1);
 }
 void HamShield::clearSQOutSel(){
-    I2Cdev::writeBitW(devAddr, A1846S_SQ_OUT_SEL_REG, A1846S_SQ_OUT_SEL_BIT, 0);
+    HSwriteBitW(devAddr, A1846S_SQ_OUT_SEL_REG, A1846S_SQ_OUT_SEL_BIT, 0);
 }
 bool HamShield::getSQOutSel(){
-    I2Cdev::readBitW(devAddr, A1846S_SQ_OUT_SEL_REG, A1846S_SQ_OUT_SEL_BIT, radio_i2c_buf);
+    HSreadBitW(devAddr, A1846S_SQ_OUT_SEL_REG, A1846S_SQ_OUT_SEL_BIT, radio_i2c_buf);
     return (radio_i2c_buf[0] != 0);
 }
 
 // VOX
 void HamShield::setVoxOn(){
-    I2Cdev::writeBitW(devAddr, A1846S_CTL_REG, A1846S_VOX_ON_BIT, 1);
+    HSwriteBitW(devAddr, A1846S_CTL_REG, A1846S_VOX_ON_BIT, 1);
 }
 void HamShield::setVoxOff(){
-    I2Cdev::writeBitW(devAddr, A1846S_CTL_REG, A1846S_VOX_ON_BIT, 0);
+    HSwriteBitW(devAddr, A1846S_CTL_REG, A1846S_VOX_ON_BIT, 0);
 }
 bool HamShield::getVoxOn(){
-    I2Cdev::readBitW(devAddr, A1846S_CTL_REG, A1846S_VOX_ON_BIT, radio_i2c_buf);
+    HSreadBitW(devAddr, A1846S_CTL_REG, A1846S_VOX_ON_BIT, radio_i2c_buf);
     return (radio_i2c_buf[0] != 0);
 }
 
 // Vox Threshold
 void HamShield::setVoxOpenThresh(uint16_t vox_open_thresh){
 	// When vssi > 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 +827,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 +929,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 +947,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 +988,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;
+    int16_t rssi = (radio_i2c_buf[0] & 0xFF) - 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 +1020,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 +1032,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);

HamShield.h

@@ -8,8 +8,7 @@
 #ifndef _HAMSHIELD_H_
 #define _HAMSHIELD_H_
 
-//#include "I2Cdev_rda.h"
-#include "I2Cdev.h"
+#include "HamShield_comms.h"
 #include "SimpleFIFO.h"
 #include "AFSK.h"
 #include "DDS.h"
@@ -187,7 +186,7 @@
 #define A1846S_VOX_FLAG_BIT        0  // vox out from dsp
 
 // Bitfields for A1846S_RSSI_REG
-#define A1846S_RSSI_BIT            15  // RSSI readings <9:0>
+#define A1846S_RSSI_BIT            15  // RSSI readings <7:0>
 #define A1846S_RSSI_LENGTH         8
 
 // Bitfields for A1846S_VSSI_REG
@@ -241,7 +240,7 @@
 
 
 #define ROBOT8BW 2
-#define SC2-180 55
+#define SC2_180 55
 #define MARTIN1 44
 
 // RTTY Frequencies
@@ -374,10 +373,10 @@ class HamShield {
 		bool getSQState();
 		
 		// SQ threshold
-		void setSQHiThresh(uint16_t sq_hi_threshold); // Sq detect high th, rssi_cmp will be 1 when rssi>th_h_sq, unit 1/8dB
-		uint16_t getSQHiThresh();
-		void setSQLoThresh(uint16_t sq_lo_threshold); // Sq detect low th, rssi_cmp will be 0 when rssi<th_l_sq && time delay meet, unit 1/8 dB
-		uint16_t getSQLoThresh();
+		void setSQHiThresh(int16_t sq_hi_threshold); // Sq detect high th, rssi_cmp will be 1 when rssi>th_h_sq, unit 1dB
+		int16_t getSQHiThresh();
+		void setSQLoThresh(int16_t sq_lo_threshold); // Sq detect low th, rssi_cmp will be 0 when rssi<th_l_sq && time delay meet, unit 1dB
+		int16_t getSQLoThresh();
 		
 		// SQ out select
 		void setSQOutSel();

HamShield_comms.cpp

@@ -0,0 +1,97 @@
+/*
+ * Based loosely on I2Cdev by Jeff Rowberg
+ */
+
+#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)
+{
+
+    int8_t count = 0;
+    uint32_t t1 = millis();
+	uint8_t timeout = 1000;
+
+	Wire.beginTransmission(devAddr);
+    Wire.write(regAddr);
+    Wire.endTransmission(false);
+    Wire.requestFrom((int)devAddr, 2); // length=words, this wants bytes
+        
+    bool msb = true; // starts with MSB, then LSB
+    for (; Wire.available() && count < 1 && (timeout == 0 || millis() - t1 < timeout);) {
+        if (msb) {
+            // first byte is bits 15-8 (MSb=15)
+            data[0] = Wire.read() << 8;
+        } else {
+            // second byte is bits 7-0 (LSb=0)
+            data[0] |= Wire.read();
+            count++;
+        }
+        msb = !msb;
+    }
+        
+    Wire.endTransmission();
+
+    if (timeout > 0 && millis() - t1 >= timeout && count < 1) count = -1; // timeout
+    
+    return count;
+
+}
+
+
+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)
+{
+    uint8_t status = 0;
+
+	Wire.beginTransmission(devAddr);
+    Wire.write(regAddr); // send address
+
+    Wire.write((uint8_t)(data >> 8));    // send MSB
+    Wire.write((uint8_t)data);         // send LSB
+  
+    status = Wire.endTransmission();
+    return status == 0;
+}

HamShield_comms.h

@@ -0,0 +1,18 @@
+
+
+
+#ifndef _HAMSHIELD_COMMS_H_
+#define _HAMSHIELD_COMMS_H_
+
+#include "Arduino.h"
+#include "Wire.h"
+
+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_ */

I2Cdev.h

@@ -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 <jeff@rowberg.net>
-//
-// 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 <i2c_t3.h>
-        #define BUFFER_LENGTH 32
-    #elif I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE
-        #include <Wire.h>
-    #endif
-    #if I2CDEV_IMPLEMENTATION == I2CDEV_I2CMASTER_LIBRARY
-        #include <I2C.h>
-    #endif
-#endif
-
-#ifdef SPARK
-    #include <spark_wiring_i2c.h>
-    #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 <Gene@Telobot.com>
-    // 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_ */

README.md

@@ -1,6 +1,26 @@
 # HamShield
 
-Use the HS04 branch for old (pre -09) versions of the hardware.
+Please note that I2C communications are not officially supported.
+
+The RF transciever on the HamShield has trouble driving large I2C bus capacitances (over 40pF). What this means is that it works well if the transciever is on the same physical PCB as the microcontroller (assuming good layout), but works poorly as a daughterboard.
+
+We recommend that you use the master branch, which uses a custom communications protocol. That custom protocol does not have the same bus capacitance limitation. You're welcome to play around with I2C if you want, but it may cause instability issues.
+
+## Hardware Changes Necessary
+
+The i2c-comms branch is not intended for use with a stock HamShield.
+
+To use i2c communications with a HamShield 09 or above, you must first make several hardware changes to the board.
+
+1. Remove R2
+2. Short the pads of R17 (either with a wire or a low value resistor).
+
+Then make sure that you pull the nCS pin correctly. Changing nCS changes the I2C address of the HamShield:
+
+- nCS is logic high: A1846S_DEV_ADDR_SENHIGH 0b0101110
+- nCS is logic low: A1846S_DEV_ADDR_SENLOW  0b1110001
+
+
 
 HamShield Arduino Library and Example Sketches
 

examples/AFSK-PacketTester/AFSK-PacketTester.ino

@@ -8,10 +8,8 @@
 #define DDS_REFCLK_DEFAULT 9600
 
 #include <HamShield.h>
-#include <Wire.h>
 #include <avr/wdt.h> 
 
-//TODO: move these into library
 #define PWM_PIN 3
 #define RESET_PIN A3
 #define SWITCH_PIN 2
@@ -39,8 +37,6 @@ void setup() {
   digitalWrite(RESET_PIN, HIGH);
   
   Serial.begin(115200);
-  Wire.begin();
-
   
   radio.initialize();
   radio.frequency(144390);

examples/AFSK-SerialMessenger/AFSK-SerialMessenger.ino

@@ -8,7 +8,6 @@
 #define DDS_REFCLK_DEFAULT 9600
 
 #include <HamShield.h>
-#include <Wire.h>
 #include <avr/wdt.h> 
 
 #define PWM_PIN 3
@@ -37,7 +36,7 @@ void setup() {
   digitalWrite(RESET_PIN, HIGH);
   
   Serial.begin(115200);
-  Wire.begin();
+
   radio.initialize();
   radio.frequency(145570);
   radio.setRfPower(0);

examples/AFSKSend/AFSKSend.ino

@@ -1,5 +1,4 @@
 #include <HamShield.h>
-#include <Wire.h>
 
 HamShield radio;
 DDS dds;
@@ -13,7 +12,7 @@ DDS dds;
 
 void setup() {
   Serial.begin(9600);
-  Wire.begin();
+
   pinMode(4, OUTPUT);
   pinMode(5, OUTPUT);
   pinMode(6, OUTPUT);

examples/AX25Receive/AX25Receive.ino

@@ -1,5 +1,4 @@
 #include <HamShield.h>
-#include <Wire.h>
 
 #define PWM_PIN 3
 #define RESET_PIN A3
@@ -22,7 +21,7 @@ void setup() {
   digitalWrite(RESET_PIN, HIGH);
   
   Serial.begin(9600);
-  Wire.begin();
+
   Serial.println(F("Radio test connection"));
   Serial.println(radio.testConnection(), DEC);
   Serial.println(F("Initialize"));

examples/CrystalCalibration/CrystalCalibration.ino

@@ -3,7 +3,6 @@
 #define DDS_DEBUG_SERIAL
 
 #include <HamShield.h>
-#include <Wire.h>
 
 #define PWM_PIN 3
 #define RESET_PIN A3
@@ -26,7 +25,7 @@ void setup() {
   digitalWrite(RESET_PIN, HIGH);
   
   Serial.begin(9600);
-  Wire.begin();
+
   radio.initialize();
   radio.setRfPower(0);
   radio.setFrequency(145050);

examples/DDS/DDS.ino

@@ -1,6 +1,5 @@
 #define DDS_REFCLK_DEFAULT 9600
 #include <HamShield.h>
-#include <Wire.h>
 
 
 #define PWM_PIN 3
@@ -23,7 +22,6 @@ void setup() {
   // turn on radio
   digitalWrite(RESET_PIN, HIGH);
   
-  Wire.begin();
   radio.initialize();
   radio.setRfPower(0);
   radio.setFrequency(145060);

examples/FMBeacon/FMBeacon.ino

@@ -5,9 +5,8 @@ Test beacon will transmit and wait 30 seconds.
 Beacon will check to see if the channel is clear before it will transmit.
 */
 
-// Include the HamSheild and Wire (I2C) libraries
+// Include the HamSheild
 #include <HamShield.h>
-#include <Wire.h>
 
 #define PWM_PIN 3
 #define RESET_PIN A3
@@ -34,9 +33,6 @@ void setup() {
   
   // Send a quick serial string
   Serial.println("HamShield FM Beacon Example Sketch");
-  
-  // Start the Wire (I2C) library
-  Wire.begin();
 
   // Query the HamShield for status information
   Serial.print("Radio status: ");

examples/FoxHunt/FoxHunt.ino

@@ -1,7 +1,6 @@
 /* Fox Hunt */
 
-#include <HAMShield.h>
-#include <Wire.h>
+#include <HamShield.h>
 
 #define PWM_PIN 3
 #define RESET_PIN A3
@@ -13,7 +12,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 +26,14 @@ void setup() {
   pinMode(RESET_PIN, OUTPUT);
   digitalWrite(RESET_PIN, HIGH);
   
-  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 +47,3 @@ void waitMinute(int period) {
   delay(period * 60 * 1000);
 }
 
-

examples/FunctionalTest/FunctionalTest.ino

@@ -1,7 +1,6 @@
 /* HamShield Functional Test */
 
 #include <HamShield.h>
-#include <Wire.h>
 
 #define PWM_PIN 3
 #define RESET_PIN A3
@@ -21,7 +20,6 @@ void setup() {
   pinMode(RESET_PIN, OUTPUT);
   digitalWrite(RESET_PIN, HIGH);
   
-  Wire.begin();
   Serial.begin(9600);
   Serial.println("If the sketch freezes at radio status, there is something wrong with power or the shield");
   Serial.print("Radio status: ");

examples/Gauges/Gauges.ino

@@ -7,14 +7,13 @@ Simple gauges for the radio receiver.
 
 */
 
-#include <HAMShield.h>
-#include <Wire.h>
+#include <HamShield.h>
 
 #define PWM_PIN 3
 #define RESET_PIN A3
 #define SWITCH_PIN 2
 
-HAMShield radio;
+HamShield radio;
 
 void clr() { 
 /* Serial.write(27);
@@ -37,7 +36,7 @@ void setup() {
   
   analogReference(DEFAULT);
   Serial.begin(115200);
-  Wire.begin();
+
   Serial.print("Radio status: ");
   int result = radio.testConnection();
   Serial.println(result,DEC); 

examples/HAMBot/HAMBot.ino

@@ -1,15 +1,14 @@
 /* Simple DTMF controlled HAM Radio Robot */
 
 #include <ArduinoRobot.h> // include the robot library
-#include <HAMShield.h>
-#include <Wire.h>
+#include <HamShield.h>
 #include <SPI.h>
 
 #define PWM_PIN 3
 #define RESET_PIN A3
 #define SWITCH_PIN 2
 
-HAMShield radio;
+HamShield radio;
 
 void setup() {
   // NOTE: if not using PWM out, it should be held low to avoid tx noise
@@ -24,7 +23,7 @@ void setup() {
   digitalWrite(RESET_PIN, HIGH);
   
   Robot.begin();
-  Wire.begin();
+
   radio.initialize();
   radio.frequency(145510);
 }

examples/HandyTalkie/HandyTalkie.ino

@@ -1,9 +1,5 @@
 // Hamshield 
 
-// Arduino Wire library is required if I2Cdev I2CDEV_ARDUINO_WIRE implementation
-// is used in I2Cdev.h
-#include "Wire.h"
-
 #include <HamShield.h>
 
 // create object for radio
@@ -47,9 +43,6 @@ void setup() {
   digitalWrite(RESET_PIN, HIGH);
   
   Serial.println("beginning radio setup");
-  
-  // join I2C bus (I2Cdev library doesn't do this automatically)
-   Wire.begin();
 
   // verify connection
   Serial.println("Testing device connections...");

examples/Identifier/Identifier.ino

@@ -7,8 +7,7 @@ Arduino audio overlay example
 */
 
 
-#include <HAMShield.h>
-#include <Wire.h>
+#include <HamShield.h>
 
 #define DOT 100
 
@@ -16,7 +15,7 @@ Arduino audio overlay example
 #define RESET_PIN A3
 #define SWITCH_PIN 2
 
-HAMShield radio;
+HamShield radio;
 
 const char *bascii = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.,?'!/()&:;=+-_\"$@",
   *bitu[] = { ".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--..","-----",".----","..---","...--","....-",".....","-....","--...","---..","----.",".-.-.-","--..--","..--..",".----.","-.-.--","-..-.","-.--.","-.--.-",".-...","---...","-.-.-.","-...-",".-.-.","-....-","..--.-",".-..-.","...-..-",".--.-."
@@ -40,7 +39,7 @@ void setup() {
   
   Serial.begin(9600);
   Serial.println("starting up..");
-  Wire.begin();
+
   Serial.print("Radio status: ");
   int result = radio.testConnection();
   Serial.println(result,DEC);

examples/JustTransmit/JustTransmit.ino

@@ -1,7 +1,6 @@
 /* Just Transmit */
 
 #include <HamShield.h>
-#include <Wire.h>
 
 #define PWM_PIN 3
 #define RESET_PIN A3
@@ -21,7 +20,6 @@ void setup() {
   pinMode(RESET_PIN, OUTPUT);
   digitalWrite(RESET_PIN, HIGH);
   
-  Wire.begin();
   Serial.begin(9600);
   Serial.println("If the sketch freezes at radio status, there is something wrong with power or the shield");
   Serial.print("Radio status: ");

examples/KISS/KISS.ino

@@ -1,5 +1,4 @@
 #include <HamShield.h>
-#include <Wire.h>
 #include <KISS.h>
 
 HamShield radio;
@@ -30,10 +29,9 @@ void setup() {
   // let the AU ot of reset
   digitalWrite(RESET_PIN, HIGH);
   
-  Wire.begin();
   radio.initialize();
   radio.setSQOff();
-  radio.setFrequency(144390);
+  radio.frequency(144390);
   //I2Cdev::writeWord(A1846S_DEV_ADDR_SENLOW, 0x44, 0x05FF);
 
   dds.start();

examples/Parrot/Parrot.ino

@@ -6,8 +6,7 @@ A bit robotic and weird
 
 */
 
-#include <HAMShield.h>
-#include <Wire.h>
+#include <HamShield.h>
 
 #define PWM_PIN 3
 #define RESET_PIN A3
@@ -16,7 +15,7 @@ A bit robotic and weird
 #define RATE 500
 #define SIZE 1500
 
-HAMShield radio;
+HamShield radio;
 
 char sound[SIZE];
 unsigned int sample1;
@@ -36,7 +35,6 @@ void setup() {
   pinMode(RESET_PIN, OUTPUT);
   digitalWrite(RESET_PIN, HIGH);
   
-  Wire.begin();
   // int result = radio.testConnection();
   radio.initialize();
   radio.setFrequency(446000);

examples/SSTV/SSTV.ino

@@ -13,10 +13,9 @@ Sends an SSTV test pattern
 
 /* Standard libraries and variable init */
 
-#include <HAMShield.h>
-#include <Wire.h>
+#include <HamShield.h>
 
-HAMShield radio;
+HamShield radio;
 int16_t rssi;
 
 /* get our radio ready */
@@ -33,7 +32,6 @@ void setup() {
   pinMode(RESET_PIN, OUTPUT);
   digitalWrite(RESET_PIN, HIGH);
   
-  Wire.begin();
   Serial.begin(9600);
   Serial.print("Radio status: ");
   int result = radio.testConnection();

examples/SSTV_M1_Static/SSTV_M1_Static.ino

@@ -2,7 +2,6 @@
 #define DDS_REFCLK_DEFAULT (34965/2)
 
 #include <HamShield.h>
-#include <Wire.h>
 
 #define PWM_PIN 3
 #define RESET_PIN A3
@@ -31,8 +30,8 @@ void setup() {
   digitalWrite(RESET_PIN, HIGH);
   
   Serial.begin(9600);
-  Wire.begin();
-    // Query the HamShield for status information
+
+  // Query the HamShield for status information
   Serial.print("Radio status: ");
   int result = 0;
   result = radio.testConnection();

examples/SerialTransceiver/SerialTransceiver.ino

@@ -1,6 +1,6 @@
 /*
 
-SerialTransceiver is TTL Serial port "glue" to allow desktop or laptop control of the HAMShield
+SerialTransceiver is TTL Serial port "glue" to allow desktop or laptop control of the HamShield
 
 Commands:
 
@@ -46,7 +46,6 @@ Debug Msg    @<text>;   32 character debug message
 
 */
 
-#include "Wire.h"
 #include "HamShield.h"
 
 #define PWM_PIN 3
@@ -85,7 +84,7 @@ void setup() {
   
   Serial.begin(115200);
   Serial.print(";;;;;;;;;;;;;;;;;;;;;;;;;;");
-  Wire.begin();
+
   int result = radio.testConnection();
   Serial.print("*");
   Serial.print(result,DEC);

examples/SignalTest/SignalTest.ino

@@ -10,15 +10,14 @@ Plays back the current signal strength level and morses out it's call sign at th
 
 /* Standard libraries and variable init */
 
-#include <HAMShield.h>
-#include <Wire.h>
+#include <HamShield.h>
 #include <PCM.h>
 
 #define PWM_PIN 3
 #define RESET_PIN A3
 #define SWITCH_PIN 2
 
-HAMShield radio;
+HamShield radio;
 int16_t rssi;
 int peak = -150;
 char sig[8];
@@ -89,7 +88,6 @@ void setup() {
   pinMode(RESET_PIN, OUTPUT);
   digitalWrite(RESET_PIN, HIGH);
   
-  Wire.begin();
   Serial.begin(9600);
   Serial.print("Radio status: ");
   int result = radio.testConnection();