diff --git a/examples/SX127x_ChannelActivityDetection/SX127x_ChannelActivityDetection.ino b/examples/SX127x_ChannelActivityDetection/SX127x_ChannelActivityDetection.ino
index 34f010b2..fb809b9b 100644
--- a/examples/SX127x_ChannelActivityDetection/SX127x_ChannelActivityDetection.ino
+++ b/examples/SX127x_ChannelActivityDetection/SX127x_ChannelActivityDetection.ino
@@ -1,18 +1,18 @@
 /*
- * KiteLib SX127x Channel Activity Detection Example
- * 
- * This example scans the current LoRa channel using SX1278 LoRa radio module 
- * and detects valid LoRa preambles. Preamble is the first part of LoRa transmission, 
- * so this can be used to check if the LoRa channel is free, 
- * or if you should start receiving a message.
- * 
- * Other modules from SX127x family can also be used.
- * SX1272 lora = Kite.ModuleA;
- * SX1273 lora = Kite.ModuleA;
- * SX1276 lora = Kite.ModuleA;
- * SX1277 lora = Kite.ModuleA;
- * SX1279 lora = Kite.ModuleA;
- */
+   KiteLib SX127x Channel Activity Detection Example
+
+   This example scans the current LoRa channel using SX1278 LoRa radio module
+   and detects valid LoRa preambles. Preamble is the first part of LoRa transmission,
+   so this can be used to check if the LoRa channel is free,
+   or if you should start receiving a message.
+
+   Other modules from SX127x family can also be used.
+   SX1272 lora = Kite.ModuleA;
+   SX1273 lora = Kite.ModuleA;
+   SX1276 lora = Kite.ModuleA;
+   SX1277 lora = Kite.ModuleA;
+   SX1279 lora = Kite.ModuleA;
+*/
 
 // include the library
 #include <KiteLib.h>
@@ -31,13 +31,13 @@ void setup() {
   // coding rate:                         7
   // sync word:                           0x12
   // output power:                        17 dBm
-  byte state = lora.begin();
-  if(state == ERR_NONE) {
+  int state = lora.begin();
+  if (state == ERR_NONE) {
     Serial.println(F("success!"));
   } else {
-    Serial.print(F("failed, code 0x"));
-    Serial.println(state, HEX);
-    while(true);
+    Serial.print(F("failed, code "));
+    Serial.println(state);
+    while (true);
   }
 }
 
@@ -45,16 +45,16 @@ void loop() {
   Serial.print(F("Scanning channel for LoRa preamble ... "));
 
   // start scanning current channel
-  uint8_t state = lora.scanChannel();
-  
-  if(state == PREAMBLE_DETECTED) {
+  int state = lora.scanChannel();
+
+  if (state == PREAMBLE_DETECTED) {
     // LoRa preamble was detected
     Serial.println(" detected preamble!");
-    
-  } else if(state == CHANNEL_FREE) {
+
+  } else if (state == CHANNEL_FREE) {
     // no preamble was detected, channel is free
     Serial.println(" channel is free!");
-    
+
   }
 
   // wait 100 ms before new scan
diff --git a/examples/SX127x_Receive/SX127x_Receive.ino b/examples/SX127x_Receive/SX127x_Receive.ino
index fb531ed0..e76cad0b 100644
--- a/examples/SX127x_Receive/SX127x_Receive.ino
+++ b/examples/SX127x_Receive/SX127x_Receive.ino
@@ -1,22 +1,22 @@
 /*
- * KiteLib SX127x Receive Example
- * 
- * This example listens for LoRa transmissions using SX127x Lora modules.
- * To successfully receive data, the following settings have to be the same
- * on both transmitter and receiver:
- *  - carrier frequency
- *  - bandwidth
- *  - spreading factor
- *  - coding rate
- *  - sync word
- * 
- * Other modules from SX127x family can also be used.
- * SX1272 lora = Kite.ModuleA;
- * SX1273 lora = Kite.ModuleA;
- * SX1276 lora = Kite.ModuleA;
- * SX1277 lora = Kite.ModuleA;
- * SX1279 lora = Kite.ModuleA;
- */
+   KiteLib SX127x Receive Example
+
+   This example listens for LoRa transmissions using SX127x Lora modules.
+   To successfully receive data, the following settings have to be the same
+   on both transmitter and receiver:
+    - carrier frequency
+    - bandwidth
+    - spreading factor
+    - coding rate
+    - sync word
+
+   Other modules from SX127x family can also be used.
+   SX1272 lora = Kite.ModuleA;
+   SX1273 lora = Kite.ModuleA;
+   SX1276 lora = Kite.ModuleA;
+   SX1277 lora = Kite.ModuleA;
+   SX1279 lora = Kite.ModuleA;
+*/
 
 // include the library
 #include <KiteLib.h>
@@ -35,13 +35,13 @@ void setup() {
   // coding rate:                         7
   // sync word:                           0x12
   // output power:                        17 dBm
-  byte state = lora.begin();
-  if(state == ERR_NONE) {
+  int state = lora.begin();
+  if (state == ERR_NONE) {
     Serial.println(F("success!"));
   } else {
-    Serial.print(F("failed, code 0x"));
-    Serial.println(state, HEX);
-    while(true);
+    Serial.print(F("failed, code "));
+    Serial.println(state);
+    while (true);
   }
 }
 
@@ -50,15 +50,15 @@ void loop() {
 
   // you can receive data as an Arduino String
   String str;
-  byte state = lora.receive(str);
+  int state = lora.receive(str);
 
   // you can also receive data as byte array
   /*
-  byte byteArr[8];
-  byte state = lora.receive(byteArr, 8);
+    byte byteArr[8];
+    int state = lora.receive(byteArr, 8);
   */
 
-  if(state == ERR_NONE) {
+  if (state == ERR_NONE) {
     // packet was successfully received
     Serial.println(F("success!"));
 
@@ -80,14 +80,14 @@ void loop() {
     Serial.print("[SX1278] SNR:\t\t");
     Serial.print(lora.lastPacketSNR);
     Serial.println(" dBm");
-    
-  } else if(state == ERR_RX_TIMEOUT) {
+
+  } else if (state == ERR_RX_TIMEOUT) {
     // timeout occurred while waiting for a packet
     Serial.println(F("timeout!"));
-    
-  } else if(state == ERR_CRC_MISMATCH) {
+
+  } else if (state == ERR_CRC_MISMATCH) {
     // packet was received, but is malformed
     Serial.println(F("CRC error!"));
-    
+
   }
 }
diff --git a/examples/SX127x_Settings/SX127x_Settings.ino b/examples/SX127x_Settings/SX127x_Settings.ino
index 8c582982..574b971f 100644
--- a/examples/SX127x_Settings/SX127x_Settings.ino
+++ b/examples/SX127x_Settings/SX127x_Settings.ino
@@ -1,16 +1,16 @@
 /*
- * KiteLib SX127x Settings Example
- * 
- * This example shows how to change all the properties of LoRa transmission.
- * KiteLib currently supports the following settings:
- *  - pins (SPI slave select, digital IO 0, digital IO 1)
- *  - carrier frequency
- *  - bandwidth
- *  - spreading factor
- *  - coding rate
- *  - sync word
- *  - output power during transmission
- */
+   KiteLib SX127x Settings Example
+
+   This example shows how to change all the properties of LoRa transmission.
+   KiteLib currently supports the following settings:
+    - pins (SPI slave select, digital IO 0, digital IO 1)
+    - carrier frequency
+    - bandwidth
+    - spreading factor
+    - coding rate
+    - sync word
+    - output power during transmission
+*/
 
 // include the library
 #include <KiteLib.h>
@@ -42,13 +42,13 @@ void setup() {
   // coding rate:                         7
   // sync word:                           0x12
   // output power:                        17 dBm
-  byte state = loraSX1278.begin();
-  if(state == ERR_NONE) {
+  int state = loraSX1278.begin();
+  if (state == ERR_NONE) {
     Serial.println(F("success!"));
   } else {
-    Serial.print(F("failed, code 0x"));
-    Serial.println(state, HEX);
-    while(true);
+    Serial.print(F("failed, code "));
+    Serial.println(state);
+    while (true);
   }
 
   // initialize the second LoRa instance with non-default settings
@@ -61,18 +61,18 @@ void setup() {
   // sync word:                           0x13
   // output power:                        17 dBm
   state = loraSX1276.begin(434.0, 7.8, 12, 8, 0x13);
-  if(state == ERR_NONE) {
+  if (state == ERR_NONE) {
     Serial.println(F("success!"));
   } else {
-    Serial.print(F("failed, code 0x"));
-    Serial.println(state, HEX);
-    while(true);
+    Serial.print(F("failed, code "));
+    Serial.println(state);
+    while (true);
   }
 
   // initialize the third LoRa instance with non-default settings
   // this LoRa link will have high data rate, but lower range
   // NOTE: when using spreading factor 6, the total packet length has to be known in advance!
-  //       it can be set using the length variable of your Packet instance 
+  //       it can be set using the length variable of your Packet instance
   //       Packet::length = x;
   //       where x is the total packet length including both addresses
   Serial.print(F("[SX1272] Initializing ... "));
@@ -83,55 +83,55 @@ void setup() {
   // sync word:                           0x14
   // output power:                        2 dBm
   state = loraSX1272.begin(915.0, 500.0, 6, 5, 0x14, 2);
-  if(state == ERR_NONE) {
+  if (state == ERR_NONE) {
     Serial.println(F("success!"));
   } else {
-    Serial.print(F("failed, code 0x"));
-    Serial.println(state, HEX);
-    while(true);
+    Serial.print(F("failed, code "));
+    Serial.println(state);
+    while (true);
   }
 
   // you can also change the settings at runtime
   // and check if the configuration was changed successfully
-  
+
   // different modules accept different parameters
   // see https://github.com/jgromes/LoRaLib/wiki/Supported-LoRa-modules
 
   // set carrier frequency to 433.5 MHz
-  if(loraSX1278.setFrequency(433.5) == ERR_INVALID_FREQUENCY) {
+  if (loraSX1278.setFrequency(433.5) == ERR_INVALID_FREQUENCY) {
     Serial.println("Selected frequency is invalid for this module!");
-    while(true);
+    while (true);
   }
-  
+
   // set bandwidth to 250 kHz
-  if(loraSX1278.setBandwidth(250.0) == ERR_INVALID_BANDWIDTH) {
+  if (loraSX1278.setBandwidth(250.0) == ERR_INVALID_BANDWIDTH) {
     Serial.println("Selected bandwidth is invalid for this module!");
-    while(true);
+    while (true);
   }
 
   // set spreading factor to 10
-  if(loraSX1278.setSpreadingFactor(10) == ERR_INVALID_SPREADING_FACTOR) {
+  if (loraSX1278.setSpreadingFactor(10) == ERR_INVALID_SPREADING_FACTOR) {
     Serial.println("Selected spreading factor is invalid for this module!");
-    while(true);
+    while (true);
   }
 
   // set coding rate to 6
-  if(loraSX1278.setCodingRate(6) == ERR_INVALID_CODING_RATE) {
+  if (loraSX1278.setCodingRate(6) == ERR_INVALID_CODING_RATE) {
     Serial.println("Selected coding rate is invalid for this module!");
-    while(true);
+    while (true);
   }
 
   // set LoRa sync word to 0x14
   // NOTE: value 0x34 is reserved for LoRaWAN networks and should not be used
-  if(loraSX1278.setSyncWord(0x14) != ERR_NONE) {
+  if (loraSX1278.setSyncWord(0x14) != ERR_NONE) {
     Serial.println("Unable to set sync word!");
-    while(true);
+    while (true);
   }
 
   // set output power to 10 dBm (accepted range is 2 - 17 dBm)
-  if(loraSX1278.setOutputPower(10) == ERR_INVALID_OUTPUT_POWER) {
+  if (loraSX1278.setOutputPower(10) == ERR_INVALID_OUTPUT_POWER) {
     Serial.println("Selected output power is invalid for this module!");
-    while(true);
+    while (true);
   }
 
   Serial.println("All settings succesfully changed!");
diff --git a/examples/SX127x_Transmit/SX127x_Transmit.ino b/examples/SX127x_Transmit/SX127x_Transmit.ino
index f8c884a6..179e8d54 100644
--- a/examples/SX127x_Transmit/SX127x_Transmit.ino
+++ b/examples/SX127x_Transmit/SX127x_Transmit.ino
@@ -1,19 +1,19 @@
 /*
- * KiteLib SX127x Transmit Example
- * 
- * This example transmits packets using SX1278 LoRa radio module.
- * Each packet contains up to 256 bytes of data, in the form of:
- *  - Arduino String
- *  - null-terminated char array (C-string)
- *  - arbitrary binary data (byte array)
- * 
- * Other modules from SX127x family can also be used.
- * SX1272 lora = Kite.ModuleA;
- * SX1273 lora = Kite.ModuleA;
- * SX1276 lora = Kite.ModuleA;
- * SX1277 lora = Kite.ModuleA;
- * SX1279 lora = Kite.ModuleA;
- */
+   KiteLib SX127x Transmit Example
+
+   This example transmits packets using SX1278 LoRa radio module.
+   Each packet contains up to 256 bytes of data, in the form of:
+    - Arduino String
+    - null-terminated char array (C-string)
+    - arbitrary binary data (byte array)
+
+   Other modules from SX127x family can also be used.
+   SX1272 lora = Kite.ModuleA;
+   SX1273 lora = Kite.ModuleA;
+   SX1276 lora = Kite.ModuleA;
+   SX1277 lora = Kite.ModuleA;
+   SX1279 lora = Kite.ModuleA;
+*/
 
 // include the library
 #include <KiteLib.h>
@@ -32,13 +32,13 @@ void setup() {
   // coding rate:                         7
   // sync word:                           0x12
   // output power:                        17 dBm
-  byte state = lora.begin();
-  if(state == ERR_NONE) {
+  int state = lora.begin();
+  if (state == ERR_NONE) {
     Serial.println(F("success!"));
   } else {
-    Serial.print(F("failed, code 0x"));
-    Serial.println(state, HEX);
-    while(true);
+    Serial.print(F("failed, code "));
+    Serial.println(state);
+    while (true);
   }
 }
 
@@ -46,26 +46,26 @@ void loop() {
   Serial.print(F("[SX1278] Transmitting packet ... "));
 
   // you can transmit C-string or Arduino string up to 256 characters long
-  byte state = lora.transmit("Hello World!");
+  int state = lora.transmit("Hello World!");
 
   // you can also transmit byte array up to 256 bytes long
   /*
-  byte byteArr[] = {0x01, 0x23, 0x45, 0x56, 0x78, 0xAB, 0xCD, 0xEF};
-  byte state = lora.transmit(byteArr, 8);
+    byte byteArr[] = {0x01, 0x23, 0x45, 0x56, 0x78, 0xAB, 0xCD, 0xEF};
+    int state = lora.transmit(byteArr, 8);
   */
-  
-  if(state == ERR_NONE) {
+
+  if (state == ERR_NONE) {
     // the packet was successfully transmitted
     Serial.println(" success!");
-    
-  } else if(state == ERR_PACKET_TOO_LONG) {
+
+  } else if (state == ERR_PACKET_TOO_LONG) {
     // the supplied packet was longer than 256 bytes
     Serial.println(" too long!");
-    
-  } else if(state == ERR_TX_TIMEOUT) {
+
+  } else if (state == ERR_TX_TIMEOUT) {
     // timeout occured while transmitting packet
     Serial.println(" timeout!");
-    
+
   }
 
   // wait for a second before transmitting again
diff --git a/src/modules/SX1272.cpp b/src/modules/SX1272.cpp
index c77a5243..7f4b859c 100644
--- a/src/modules/SX1272.cpp
+++ b/src/modules/SX1272.cpp
@@ -4,9 +4,9 @@ SX1272::SX1272(Module* mod) : SX127x(mod) {
   
 }
 
-uint8_t SX1272::begin(float freq, float bw, uint8_t sf, uint8_t cr, uint8_t syncWord, int8_t power) {
+int16_t SX1272::begin(float freq, float bw, uint8_t sf, uint8_t cr, uint8_t syncWord, int8_t power) {
   // execute common part
-  uint8_t state = SX127x::begin(SX1272_CHIP_VERSION, syncWord);
+  int16_t state = SX127x::begin(SX1272_CHIP_VERSION, syncWord);
   if(state != ERR_NONE) {
     return(state);
   }
@@ -46,7 +46,7 @@ uint8_t SX1272::begin(float freq, float bw, uint8_t sf, uint8_t cr, uint8_t sync
   return(ERR_NONE);
 }
 
-uint8_t SX1272::setFrequency(float freq) {
+int16_t SX1272::setFrequency(float freq) {
   // check frequency range
   if((freq < 860.0) || (freq > 1020.0)) {
     return(ERR_INVALID_FREQUENCY);
@@ -56,7 +56,7 @@ uint8_t SX1272::setFrequency(float freq) {
   return(SX127x::setFrequencyRaw(freq));
 }
 
-uint8_t SX1272::setBandwidth(float bw) {
+int16_t SX1272::setBandwidth(float bw) {
   uint8_t newBandwidth;
   
   // check alowed bandwidth values
@@ -71,7 +71,7 @@ uint8_t SX1272::setBandwidth(float bw) {
   }
   
   // set bandwidth and if successful, save the new setting
-  uint8_t state = SX1272::setBandwidthRaw(newBandwidth);
+  int16_t state = SX1272::setBandwidthRaw(newBandwidth);
   if(state == ERR_NONE) {
     SX127x::_bw = bw;
   }
@@ -79,7 +79,7 @@ uint8_t SX1272::setBandwidth(float bw) {
   return(state);
 }
 
-uint8_t SX1272::setSpreadingFactor(uint8_t sf) {
+int16_t SX1272::setSpreadingFactor(uint8_t sf) {
   uint8_t newSpreadingFactor;
   
   // check allowed spreading factor values
@@ -110,7 +110,7 @@ uint8_t SX1272::setSpreadingFactor(uint8_t sf) {
   }
   
   // set spreading factor and if successful, save the new setting
-  uint8_t state = SX1272::setSpreadingFactorRaw(newSpreadingFactor);
+  int16_t state = SX1272::setSpreadingFactorRaw(newSpreadingFactor);
   if(state == ERR_NONE) {
     SX127x::_sf = sf;
   }
@@ -118,7 +118,7 @@ uint8_t SX1272::setSpreadingFactor(uint8_t sf) {
   return(state);
 }
 
-uint8_t SX1272::setCodingRate(uint8_t cr) {
+int16_t SX1272::setCodingRate(uint8_t cr) {
   uint8_t newCodingRate;
   
   // check allowed coding rate values
@@ -140,7 +140,7 @@ uint8_t SX1272::setCodingRate(uint8_t cr) {
   }
   
   // set coding rate and if successful, save the new setting
-  uint8_t state = SX1272::setCodingRateRaw(newCodingRate);
+  int16_t state = SX1272::setCodingRateRaw(newCodingRate);
   if(state == ERR_NONE) {
     SX127x::_cr = cr;
   }
@@ -148,7 +148,7 @@ uint8_t SX1272::setCodingRate(uint8_t cr) {
   return(state);
 }
 
-uint8_t SX1272::setOutputPower(int8_t power) {
+int16_t SX1272::setOutputPower(int8_t power) {
   // check allowed power range
   if((power < -1) || (power > 20)) {
     return(ERR_INVALID_OUTPUT_POWER);
@@ -157,7 +157,7 @@ uint8_t SX1272::setOutputPower(int8_t power) {
   // set mode to standby
   SX127x::standby();
   
-  uint8_t state;
+  int16_t state;
   if(power < 15) {
     // power is less than 15 dBm, enable PA0 on RFIO
     state = _mod->SPIsetRegValue(SX127X_REG_PA_CONFIG, SX127X_PA_SELECT_RFO, 7, 7);
@@ -178,7 +178,7 @@ uint8_t SX1272::setOutputPower(int8_t power) {
   return(state);
 }
 
-uint8_t SX1272::setBandwidthRaw(uint8_t newBandwidth) {
+int16_t SX1272::setBandwidthRaw(uint8_t newBandwidth) {
   // set mode to standby
   SX127x::standby();
   
@@ -186,12 +186,12 @@ uint8_t SX1272::setBandwidthRaw(uint8_t newBandwidth) {
   return(_mod->SPIsetRegValue(SX127X_REG_MODEM_CONFIG_1, newBandwidth, 7, 6));
 }
 
-uint8_t SX1272::setSpreadingFactorRaw(uint8_t newSpreadingFactor) {
+int16_t SX1272::setSpreadingFactorRaw(uint8_t newSpreadingFactor) {
   // set mode to standby
   SX127x::standby();
   
   // write registers
-  uint8_t state = 0;
+  int16_t state = 0;
   if(newSpreadingFactor == SX127X_SF_6) {
     state |= _mod->SPIsetRegValue(SX127X_REG_MODEM_CONFIG_1, SX1272_HEADER_IMPL_MODE | SX1272_RX_CRC_MODE_OFF, 2, 1);
     state |= _mod->SPIsetRegValue(SX127X_REG_MODEM_CONFIG_2, SX127X_SF_6 | SX127X_TX_MODE_SINGLE, 7, 3);
@@ -207,7 +207,7 @@ uint8_t SX1272::setSpreadingFactorRaw(uint8_t newSpreadingFactor) {
   return(state);
 }
 
-uint8_t SX1272::setCodingRateRaw(uint8_t newCodingRate) {
+int16_t SX1272::setCodingRateRaw(uint8_t newCodingRate) {
   // set mode to standby
   SX127x::standby();
   
@@ -215,9 +215,9 @@ uint8_t SX1272::setCodingRateRaw(uint8_t newCodingRate) {
   return(_mod->SPIsetRegValue(SX127X_REG_MODEM_CONFIG_1, newCodingRate, 5, 3));
 }
 
-uint8_t SX1272::config() {
+int16_t SX1272::config() {
   // configure common registers
-  uint8_t state = SX127x::config();
+  int16_t state = SX127x::config();
   if(state != ERR_NONE) {
     return(state);
   }
diff --git a/src/modules/SX1272.h b/src/modules/SX1272.h
index 4be44d3c..5a4fe325 100644
--- a/src/modules/SX1272.h
+++ b/src/modules/SX1272.h
@@ -52,22 +52,22 @@ class SX1272: public SX127x {
     SX1272(Module* mod);
     
     // basic methods
-    uint8_t begin(float freq = 915.0, float bw = 125.0, uint8_t sf = 9, uint8_t cr = 7, uint8_t syncWord = SX127X_SYNC_WORD, int8_t power = 17);
+    int16_t begin(float freq = 915.0, float bw = 125.0, uint8_t sf = 9, uint8_t cr = 7, uint8_t syncWord = SX127X_SYNC_WORD, int8_t power = 17);
     
     // configuration methods
-    uint8_t setFrequency(float freq);
-    uint8_t setBandwidth(float bw);
-    uint8_t setSpreadingFactor(uint8_t sf);
-    uint8_t setCodingRate(uint8_t cr);
-    uint8_t setOutputPower(int8_t power);
+    int16_t setFrequency(float freq);
+    int16_t setBandwidth(float bw);
+    int16_t setSpreadingFactor(uint8_t sf);
+    int16_t setCodingRate(uint8_t cr);
+    int16_t setOutputPower(int8_t power);
   
   protected:
-    uint8_t setBandwidthRaw(uint8_t newBandwidth);
-    uint8_t setSpreadingFactorRaw(uint8_t newSpreadingFactor);
-    uint8_t setCodingRateRaw(uint8_t newCodingRate);
+    int16_t setBandwidthRaw(uint8_t newBandwidth);
+    int16_t setSpreadingFactorRaw(uint8_t newSpreadingFactor);
+    int16_t setCodingRateRaw(uint8_t newCodingRate);
 
   private:
-    uint8_t config();
+    int16_t config();
 };
 
 #endif
diff --git a/src/modules/SX1273.cpp b/src/modules/SX1273.cpp
index 9a55ce23..0eaca103 100644
--- a/src/modules/SX1273.cpp
+++ b/src/modules/SX1273.cpp
@@ -4,7 +4,7 @@ SX1273::SX1273(Module* mod) : SX1272(mod) {
   
 }
 
-uint8_t SX1273::setSpreadingFactor(uint8_t sf) {
+int16_t SX1273::setSpreadingFactor(uint8_t sf) {
   uint8_t newSpreadingFactor;
   
   // check allowed spreading factor values
@@ -26,7 +26,7 @@ uint8_t SX1273::setSpreadingFactor(uint8_t sf) {
   }
   
   // set spreading factor and if successful, save the new setting
-  uint8_t state = setSpreadingFactorRaw(newSpreadingFactor);
+  int16_t state = setSpreadingFactorRaw(newSpreadingFactor);
   if(state == ERR_NONE) {
     SX127x::_sf = sf;
   }
diff --git a/src/modules/SX1273.h b/src/modules/SX1273.h
index 080cba77..69fafd58 100644
--- a/src/modules/SX1273.h
+++ b/src/modules/SX1273.h
@@ -10,7 +10,7 @@ class SX1273: public SX1272 {
     SX1273(Module* mod);
     
     // configuration methods
-    uint8_t setSpreadingFactor(uint8_t sf);
+    int16_t setSpreadingFactor(uint8_t sf);
 };
 
 #endif
diff --git a/src/modules/SX1276.cpp b/src/modules/SX1276.cpp
index 4d735d87..3d615e32 100644
--- a/src/modules/SX1276.cpp
+++ b/src/modules/SX1276.cpp
@@ -4,7 +4,7 @@ SX1276::SX1276(Module* mod) : SX1278(mod) {
   
 }
 
-uint8_t SX1276::setFrequency(float freq) {
+int16_t SX1276::setFrequency(float freq) {
   // check frequency range
   if((freq < 137.0) || (freq > 1020.0)) {
     return(ERR_INVALID_FREQUENCY);
diff --git a/src/modules/SX1276.h b/src/modules/SX1276.h
index 7a1f2c2f..252981ec 100644
--- a/src/modules/SX1276.h
+++ b/src/modules/SX1276.h
@@ -10,7 +10,7 @@ class SX1276: public SX1278 {
     SX1276(Module* mod);
     
     // configuration methods
-    uint8_t setFrequency(float freq);
+    int16_t setFrequency(float freq);
 };
 
 #endif
diff --git a/src/modules/SX1277.cpp b/src/modules/SX1277.cpp
index 51f52d7b..bc02716b 100644
--- a/src/modules/SX1277.cpp
+++ b/src/modules/SX1277.cpp
@@ -4,7 +4,7 @@ SX1277::SX1277(Module* mod) : SX1278(mod) {
   
 }
 
-uint8_t SX1277::setFrequency(float freq) {
+int16_t SX1277::setFrequency(float freq) {
   // check frequency range
   if((freq < 137.0) || (freq > 1020.0)) {
     return(ERR_INVALID_FREQUENCY);
@@ -74,7 +74,7 @@ uint8_t SX1277::setFrequency(float freq) {
   return(SX127x::setFrequencyRaw(freq));
 }
 
-uint8_t SX1277::setSpreadingFactor(uint8_t sf) {
+int16_t SX1277::setSpreadingFactor(uint8_t sf) {
   uint8_t newSpreadingFactor;
   
   // check allowed spreading factor values
@@ -96,7 +96,7 @@ uint8_t SX1277::setSpreadingFactor(uint8_t sf) {
   }
   
   // set spreading factor and if successful, save the new setting
-  uint8_t state = SX1278::setSpreadingFactorRaw(newSpreadingFactor);
+  int16_t state = SX1278::setSpreadingFactorRaw(newSpreadingFactor);
   if(state == ERR_NONE) {
     SX127x::_sf = sf;
   }
diff --git a/src/modules/SX1277.h b/src/modules/SX1277.h
index fae60134..db085d8f 100644
--- a/src/modules/SX1277.h
+++ b/src/modules/SX1277.h
@@ -10,8 +10,8 @@ class SX1277: public SX1278 {
     SX1277(Module* mod);
     
     // configuration methods
-    uint8_t setFrequency(float freq);
-    uint8_t setSpreadingFactor(uint8_t sf);
+    int16_t setFrequency(float freq);
+    int16_t setSpreadingFactor(uint8_t sf);
 };
 
 #endif
diff --git a/src/modules/SX1278.cpp b/src/modules/SX1278.cpp
index 684b4791..8c9209f6 100644
--- a/src/modules/SX1278.cpp
+++ b/src/modules/SX1278.cpp
@@ -4,9 +4,9 @@ SX1278::SX1278(Module* mod) : SX127x(mod) {
   
 }
 
-uint8_t SX1278::begin(float freq, float bw, uint8_t sf, uint8_t cr, uint8_t syncWord, int8_t power) {
+int16_t SX1278::begin(float freq, float bw, uint8_t sf, uint8_t cr, uint8_t syncWord, int8_t power) {
   // execute common part
-  uint8_t state = SX127x::begin(SX1278_CHIP_VERSION, syncWord);
+  int16_t state = SX127x::begin(SX1278_CHIP_VERSION, syncWord);
   if(state != ERR_NONE) {
     return(state);
   }
@@ -46,7 +46,7 @@ uint8_t SX1278::begin(float freq, float bw, uint8_t sf, uint8_t cr, uint8_t sync
   return(ERR_NONE);
 }
 
-uint8_t SX1278::setFrequency(float freq) {
+int16_t SX1278::setFrequency(float freq) {
   // check frequency range
   if((freq < 137.0) || (freq > 525.0)) {
     return(ERR_INVALID_FREQUENCY);
@@ -116,7 +116,7 @@ uint8_t SX1278::setFrequency(float freq) {
   return(SX127x::setFrequencyRaw(freq));
 }
 
-uint8_t SX1278::setBandwidth(float bw) {
+int16_t SX1278::setBandwidth(float bw) {
   uint8_t newBandwidth;
   
   // check alowed bandwidth values
@@ -145,7 +145,7 @@ uint8_t SX1278::setBandwidth(float bw) {
   }
   
   // set bandwidth and if successful, save the new setting
-  uint8_t state = SX1278::setBandwidthRaw(newBandwidth);
+  int16_t state = SX1278::setBandwidthRaw(newBandwidth);
   if(state == ERR_NONE) {
     SX127x::_bw = bw;
   }
@@ -153,7 +153,7 @@ uint8_t SX1278::setBandwidth(float bw) {
   return(state);
 }
 
-uint8_t SX1278::setSpreadingFactor(uint8_t sf) {
+int16_t SX1278::setSpreadingFactor(uint8_t sf) {
   uint8_t newSpreadingFactor;
   
   // check allowed spreading factor values
@@ -184,7 +184,7 @@ uint8_t SX1278::setSpreadingFactor(uint8_t sf) {
   }
   
   // set spreading factor and if successful, save the new setting
-  uint8_t state = SX1278::setSpreadingFactorRaw(newSpreadingFactor);
+  int16_t state = SX1278::setSpreadingFactorRaw(newSpreadingFactor);
   if(state == ERR_NONE) {
     SX127x::_sf = sf;
   }
@@ -192,7 +192,7 @@ uint8_t SX1278::setSpreadingFactor(uint8_t sf) {
   return(state);
 }
 
-uint8_t SX1278::setCodingRate(uint8_t cr) {
+int16_t SX1278::setCodingRate(uint8_t cr) {
   uint8_t newCodingRate;
   
   // check allowed coding rate values
@@ -214,7 +214,7 @@ uint8_t SX1278::setCodingRate(uint8_t cr) {
   }
   
   // set coding rate and if successful, save the new setting
-  uint8_t state = SX1278::setCodingRateRaw(newCodingRate);
+  int16_t state = SX1278::setCodingRateRaw(newCodingRate);
   if(state == ERR_NONE) {
     SX127x::_cr = cr;
   }
@@ -222,7 +222,7 @@ uint8_t SX1278::setCodingRate(uint8_t cr) {
   return(state);
 }
 
-uint8_t SX1278::setOutputPower(int8_t power) {
+int16_t SX1278::setOutputPower(int8_t power) {
   if((power < -3) || (power > 20)) {
     return(ERR_INVALID_OUTPUT_POWER);
   }
@@ -230,7 +230,7 @@ uint8_t SX1278::setOutputPower(int8_t power) {
   // set mode to standby
   SX127x::standby();
   
-  uint8_t state;
+  int16_t state;
   if(power < 13) {
     // power is less than 12 dBm, enable PA on RFO
     state = _mod->SPIsetRegValue(SX127X_REG_PA_CONFIG, SX127X_PA_SELECT_RFO, 7, 7);
@@ -251,7 +251,7 @@ uint8_t SX1278::setOutputPower(int8_t power) {
   return(state);
 }
 
-uint8_t SX1278::setBandwidthRaw(uint8_t newBandwidth) {
+int16_t SX1278::setBandwidthRaw(uint8_t newBandwidth) {
   // set mode to standby
   SX127x::standby();
   
@@ -259,12 +259,12 @@ uint8_t SX1278::setBandwidthRaw(uint8_t newBandwidth) {
   return(_mod->SPIsetRegValue(SX127X_REG_MODEM_CONFIG_1, newBandwidth, 7, 4));
 }
 
-uint8_t SX1278::setSpreadingFactorRaw(uint8_t newSpreadingFactor) {
+int16_t SX1278::setSpreadingFactorRaw(uint8_t newSpreadingFactor) {
   // set mode to standby
   SX127x::standby();
   
   // write registers
-  uint8_t state = 0;
+  int16_t state = 0;
   if(newSpreadingFactor == SX127X_SF_6) {
     state |= _mod->SPIsetRegValue(SX127X_REG_MODEM_CONFIG_1, SX1278_HEADER_IMPL_MODE, 0, 0);
     state |= _mod->SPIsetRegValue(SX127X_REG_MODEM_CONFIG_2, SX127X_SF_6 | SX127X_TX_MODE_SINGLE | SX1278_RX_CRC_MODE_OFF, 7, 2);
@@ -280,7 +280,7 @@ uint8_t SX1278::setSpreadingFactorRaw(uint8_t newSpreadingFactor) {
   return(state);
 }
 
-uint8_t SX1278::setCodingRateRaw(uint8_t newCodingRate) {
+int16_t SX1278::setCodingRateRaw(uint8_t newCodingRate) {
   // set mode to standby
   SX127x::standby();
   
@@ -288,9 +288,9 @@ uint8_t SX1278::setCodingRateRaw(uint8_t newCodingRate) {
   return(_mod->SPIsetRegValue(SX127X_REG_MODEM_CONFIG_1, newCodingRate, 3, 1));
 }
 
-uint8_t SX1278::config() {
+int16_t SX1278::config() {
   // configure common registers
-  uint8_t state = SX127x::config();
+  int16_t state = SX127x::config();
   if(state != ERR_NONE) {
     return(state);
   }
diff --git a/src/modules/SX1278.h b/src/modules/SX1278.h
index b8f0bf4a..8f747fea 100644
--- a/src/modules/SX1278.h
+++ b/src/modules/SX1278.h
@@ -70,22 +70,22 @@ class SX1278: public SX127x {
     SX1278(Module* mod);
     
     // basic methods
-    uint8_t begin(float freq = 434.0, float bw = 125.0, uint8_t sf = 9, uint8_t cr = 7, uint8_t syncWord = SX127X_SYNC_WORD, int8_t power = 17);
+    int16_t begin(float freq = 434.0, float bw = 125.0, uint8_t sf = 9, uint8_t cr = 7, uint8_t syncWord = SX127X_SYNC_WORD, int8_t power = 17);
     
     // configuration methods
-    uint8_t setFrequency(float freq);
-    uint8_t setBandwidth(float bw);
-    uint8_t setSpreadingFactor(uint8_t sf);
-    uint8_t setCodingRate(uint8_t cr);
-    uint8_t setOutputPower(int8_t power);
+    int16_t setFrequency(float freq);
+    int16_t setBandwidth(float bw);
+    int16_t setSpreadingFactor(uint8_t sf);
+    int16_t setCodingRate(uint8_t cr);
+    int16_t setOutputPower(int8_t power);
   
   protected:
-    uint8_t setBandwidthRaw(uint8_t newBandwidth);
-    uint8_t setSpreadingFactorRaw(uint8_t newSpreadingFactor);
-    uint8_t setCodingRateRaw(uint8_t newCodingRate);
+    int16_t setBandwidthRaw(uint8_t newBandwidth);
+    int16_t setSpreadingFactorRaw(uint8_t newSpreadingFactor);
+    int16_t setCodingRateRaw(uint8_t newCodingRate);
     
   private:
-    uint8_t config();
+    int16_t config();
 };
 
 #endif
diff --git a/src/modules/SX1279.cpp b/src/modules/SX1279.cpp
index fab66acf..c493f534 100644
--- a/src/modules/SX1279.cpp
+++ b/src/modules/SX1279.cpp
@@ -4,7 +4,7 @@ SX1279::SX1279(Module* mod) : SX1278(mod) {
   
 }
 
-uint8_t SX1279::setFrequency(float freq) {
+int16_t SX1279::setFrequency(float freq) {
   // check frequency range
   if((freq < 137.0) || (freq > 960.0)) {
     return(ERR_INVALID_FREQUENCY);
diff --git a/src/modules/SX1279.h b/src/modules/SX1279.h
index f339b649..22db6d47 100644
--- a/src/modules/SX1279.h
+++ b/src/modules/SX1279.h
@@ -10,7 +10,7 @@ class SX1279: public SX1278 {
     SX1279(Module* mod);
     
     // configuration methods
-    uint8_t setFrequency(float freq);
+    int16_t setFrequency(float freq);
 };
 
 #endif
diff --git a/src/modules/SX127x.cpp b/src/modules/SX127x.cpp
index e35f129a..cd488e83 100644
--- a/src/modules/SX127x.cpp
+++ b/src/modules/SX127x.cpp
@@ -4,7 +4,7 @@ SX127x::SX127x(Module* mod) {
   _mod = mod;
 }
 
-uint8_t SX127x::begin(uint8_t chipVersion, uint8_t syncWord) {
+int16_t SX127x::begin(uint8_t chipVersion, uint8_t syncWord) {
   // set module properties
   _mod->init(USE_SPI, INT_BOTH);
   
@@ -12,18 +12,20 @@ uint8_t SX127x::begin(uint8_t chipVersion, uint8_t syncWord) {
   uint8_t i = 0;
   bool flagFound = false;
   while((i < 10) && !flagFound) {
-    uint8_t version = _mod->SPIreadRegister(SX127X_REG_VERSION);
+    int16_t version = _mod->SPIreadRegister(SX127X_REG_VERSION);
     if(version == chipVersion) {
       flagFound = true;
     } else {
       #ifdef KITELIB_DEBUG
-        Serial.print("SX127x not found! (");
+        Serial.print(F("SX127x not found! ("));
         Serial.print(i + 1);
-        Serial.print(" of 10 tries) SX127X_REG_VERSION == ");
+        Serial.print(F(" of 10 tries) SX127X_REG_VERSION == "));
         
-        char buffHex[5];
-        sprintf(buffHex, "0x%02X", version);
+        char buffHex[7];
+        sprintf(buffHex, "0x%04X", version);
         Serial.print(buffHex);
+        Serial.print(F(", expected 0x00"));
+        Serial.print(chipVersion, HEX);
         Serial.println();
       #endif
       delay(1000);
@@ -39,7 +41,7 @@ uint8_t SX127x::begin(uint8_t chipVersion, uint8_t syncWord) {
   }
   
   // set LoRa sync word
-  uint8_t state = SX127x::setSyncWord(syncWord);
+  int16_t state = SX127x::setSyncWord(syncWord);
   if(state != ERR_NONE) {
     return(state);
   }
@@ -47,7 +49,7 @@ uint8_t SX127x::begin(uint8_t chipVersion, uint8_t syncWord) {
   return(ERR_NONE);
 }
 
-uint8_t SX127x::transmit(uint8_t* data, size_t len) {
+int16_t SX127x::transmit(uint8_t* data, size_t len) {
   // check packet length
   if(len >= 256) {
     return(ERR_PACKET_TOO_LONG);
@@ -103,15 +105,15 @@ uint8_t SX127x::transmit(uint8_t* data, size_t len) {
   return(ERR_NONE);
 }
 
-uint8_t SX127x::transmit(const char* str) {
+int16_t SX127x::transmit(const char* str) {
   return(SX127x::transmit((uint8_t*)str, strlen(str)));
 }
 
-uint8_t SX127x::transmit(String& str) {
+int16_t SX127x::transmit(String& str) {
   return(SX127x::transmit(str.c_str()));
 }
 
-uint8_t SX127x::receive(uint8_t* data, size_t len) {
+int16_t SX127x::receive(uint8_t* data, size_t len) {
   // set mode to standby
   setMode(SX127X_STANDBY);
   
@@ -175,10 +177,10 @@ uint8_t SX127x::receive(uint8_t* data, size_t len) {
   return(ERR_NONE);
 }
 
-uint8_t SX127x::receive(String& str, size_t len) {
+int16_t SX127x::receive(String& str, size_t len) {
   // create temporary array to store received data
   char* data = new char[len];
-  uint8_t state = SX127x::receive((uint8_t*)data, len);
+  int16_t state = SX127x::receive((uint8_t*)data, len);
   
   // if packet was received successfully, copy data into String
   if(state == ERR_NONE) {
@@ -189,7 +191,7 @@ uint8_t SX127x::receive(String& str, size_t len) {
   return(state);
 }
 
-uint8_t SX127x::scanChannel() {
+int16_t SX127x::scanChannel() {
   // set mode to standby
   setMode(SX127X_STANDBY);
   
@@ -214,17 +216,17 @@ uint8_t SX127x::scanChannel() {
   return(CHANNEL_FREE);
 }
 
-uint8_t SX127x::sleep() {
+int16_t SX127x::sleep() {
   // set mode to sleep
   return(setMode(SX127X_SLEEP));
 }
 
-uint8_t SX127x::standby() {
+int16_t SX127x::standby() {
   // set mode to standby
   return(setMode(SX127X_STANDBY));
 }
 
-uint8_t SX127x::setSyncWord(uint8_t syncWord) {
+int16_t SX127x::setSyncWord(uint8_t syncWord) {
   // set mode to standby
   setMode(SX127X_STANDBY);
   
@@ -232,7 +234,7 @@ uint8_t SX127x::setSyncWord(uint8_t syncWord) {
   return(_mod->SPIsetRegValue(SX127X_REG_SYNC_WORD, syncWord));
 }
 
-uint8_t SX127x::setFrequencyRaw(float newFreq) {
+int16_t SX127x::setFrequencyRaw(float newFreq) {
   // set mode to standby
   setMode(SX127X_STANDBY);
   
@@ -241,16 +243,16 @@ uint8_t SX127x::setFrequencyRaw(float newFreq) {
   uint32_t FRF = (newFreq * (base << 19)) / 32.0;
   
   // write registers
-  uint8_t state = _mod->SPIsetRegValue(SX127X_REG_FRF_MSB, (FRF & 0xFF0000) >> 16);
+  int16_t state = _mod->SPIsetRegValue(SX127X_REG_FRF_MSB, (FRF & 0xFF0000) >> 16);
   state |= _mod->SPIsetRegValue(SX127X_REG_FRF_MID, (FRF & 0x00FF00) >> 8);
   state |= _mod->SPIsetRegValue(SX127X_REG_FRF_LSB, FRF & 0x0000FF);
   
   return(state);
 }
 
-uint8_t SX127x::config() {
+int16_t SX127x::config() {
   // set mode to SLEEP
-  uint8_t state = setMode(SX127X_SLEEP);
+  int16_t state = setMode(SX127X_SLEEP);
   if(state != ERR_NONE) {
     return(state);
   }
@@ -261,6 +263,12 @@ uint8_t SX127x::config() {
     return(state);
   }
   
+  // set mode to STANDBY
+  state = setMode(SX127X_STANDBY);
+  if(state != ERR_NONE) {
+    return(state);
+  }
+  
   // set overcurrent protection and LNA gain
   state = _mod->SPIsetRegValue(SX127X_REG_OCP, SX127X_OCP_ON | SX127X_OCP_TRIM, 5, 0);
   state |= _mod->SPIsetRegValue(SX127X_REG_LNA, SX127X_LNA_GAIN_1 | SX127X_LNA_BOOST_ON);
@@ -286,7 +294,7 @@ uint8_t SX127x::config() {
   return(state);
 }
 
-uint8_t SX127x::setMode(uint8_t mode) {
+int16_t SX127x::setMode(uint8_t mode) {
   _mod->SPIsetRegValue(SX127X_REG_OP_MODE, mode, 2, 0);
   return(ERR_NONE);
 }
diff --git a/src/modules/SX127x.h b/src/modules/SX127x.h
index 7318311e..b5c34421 100644
--- a/src/modules/SX127x.h
+++ b/src/modules/SX127x.h
@@ -173,18 +173,18 @@ class SX127x {
     float lastPacketSNR;
     
     // basic methods
-    uint8_t begin(uint8_t chipVersion, uint8_t syncWord);
-    uint8_t transmit(uint8_t* data, size_t len);
-    uint8_t transmit(const char* str);
-    uint8_t transmit(String& str);
-    uint8_t receive(uint8_t* data, size_t len);
-    uint8_t receive(String& str, size_t len = 0);
-    uint8_t scanChannel();
-    uint8_t sleep();
-    uint8_t standby();
+    int16_t begin(uint8_t chipVersion, uint8_t syncWord);
+    int16_t transmit(uint8_t* data, size_t len);
+    int16_t transmit(const char* str);
+    int16_t transmit(String& str);
+    int16_t receive(uint8_t* data, size_t len);
+    int16_t receive(String& str, size_t len = 0);
+    int16_t scanChannel();
+    int16_t sleep();
+    int16_t standby();
     
     // configuration methods
-    uint8_t setSyncWord(uint8_t syncWord);
+    int16_t setSyncWord(uint8_t syncWord);
   
   protected:
     Module* _mod;
@@ -193,13 +193,13 @@ class SX127x {
     uint8_t _sf;
     uint8_t _cr;
     
-    uint8_t tx(char* data, uint8_t length);
-    uint8_t rxSingle(char* data, uint8_t* length);
-    uint8_t setFrequencyRaw(float newFreq);
-    uint8_t config();
+    int16_t tx(char* data, uint8_t length);
+    int16_t rxSingle(char* data, uint8_t* length);
+    int16_t setFrequencyRaw(float newFreq);
+    int16_t config();
   
   private:
-    uint8_t setMode(uint8_t mode);
+    int16_t setMode(uint8_t mode);
     void clearIRQFlags();
 };