diff --git a/.gitignore b/.gitignore
index c795b054e5ade51b7031abab1581a5b7e2d2f5ba..6901b4fd978475c00951ffdc04d6d4172ed25576 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1 +1,3 @@
-build
\ No newline at end of file
+build
+pinePhoneBuild
+pinePhoneBuild~
\ No newline at end of file
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index ddefb32a31db6c402f366bb5c975d45a705c29da..9d90d2739d546c9c44808dfe2169a13a725ce5ef 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -2,18 +2,31 @@ project(pinedio-lora-driver CXX)
 set(CMAKE_BUILD_TYPE Debug)
 set(THREADS_PREFER_PTHREAD_FLAG ON)
 set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC")
-add_subdirectory(usb-adapter)
+option(PP "Compile for the PinePhone Backcover")
 
+if(PP)
+	add_subdirectory(pinephone)
+	add_compile_definitions(PP)
+else()
+	add_subdirectory(usb-adapter)
+endif(PP)
 find_package(Threads REQUIRED)
 
 add_library(pinedio-lora-driver SHARED
     PinedioLoraRadio.h
     Exceptions.h
     ../libs/sx126x_driver/SX126x.hpp
-    UsbAdapter.h
     PinedioLoraRadio.cpp
     )
 
-target_link_libraries(pinedio-lora-driver PUBLIC
-    sx126x_driver pinedio-lora-driver-usb "pthread" ${CMAKE_THREAD_LIBS_INIT}
-    )
\ No newline at end of file
+if(PP)
+	target_link_libraries(pinedio-lora-driver PUBLIC
+		sx126x_driver pinedio-lora-driver-pinephone "pthread" ${CMAKE_THREAD_LIBS_INIT}
+	)
+else()
+	target_link_libraries(pinedio-lora-driver PUBLIC
+		sx126x_driver pinedio-lora-driver-usb "pthread" ${CMAKE_THREAD_LIBS_INIT}
+	)
+endif(PP)
+
+unset(PP CACHE)
diff --git a/src/PinedioLoraRadio.cpp b/src/PinedioLoraRadio.cpp
index 05c595bc39d1c903428e7010cf875ba25f25d1db..0204b665f2e1a80222ee5ac0dd7cc8b5545f915c 100644
--- a/src/PinedioLoraRadio.cpp
+++ b/src/PinedioLoraRadio.cpp
@@ -1,5 +1,9 @@
 #include "PinedioLoraRadio.h"
+#ifdef PP
+#include "PinephoneBackplate.h"
+#else
 #include "UsbAdapter.h"
+#endif
 
 #include <queue>
 #include <sx126x_driver/SX126x.hpp>
@@ -11,9 +15,14 @@
 #include <memory>
 #include "mutexed_queue.class.cpp"
 #include <functional>
+#include <stdio.h>
+#include <time.h>
+#include <stdint.h>
 
 using namespace PineDio::LoRa;
 
+#define CONTINUOUS_RX_BUFFER 4
+
 std::unique_ptr<SX126x> radio;
 SX126x::ModulationParams_t modulationParams; //WON'T be modifyable during runtime
 SX126x::PacketParams_t packetParams; //WON'T be modifyable during runtime
@@ -22,9 +31,17 @@ mutexed_queue<std::vector<uint8_t>> transmitBuffer;
 std::atomic<bool> stop(true);
 std::atomic<bool> txInProgress(false);
 std::thread loop;
-std::function<void(std::vector<uint8_t>)> appRxCallback; //will be called from another thread
+time_t lastRx=0;
+
+typedef struct {
+	std::vector<uint8_t> data;
+	int8_t RssiPkt;
+	int8_t SnrPkt;
+	int8_t SignalRssiPkt;
+} rxPkg;
+std::function<void(std::vector<uint8_t>, int8_t, int8_t, int8_t)> appRxCallback; //will be called from another thread
 std::thread RxConsumerThread;
-mutexed_queue<std::vector<uint8_t>> rxBuffer;
+mutexed_queue<rxPkg> rxBuffer;
 
 /*
 	I am doing something very crazy here: I don't quite understand the wait&notify-mechanism here, so I use a mutex. locking is waiting (the mutex stays locked during the whole execution and while waiting for the next execution), unlocking is wakeup. In my head I found no possible race condition ... Should probably be done properly for the final version
@@ -37,31 +54,35 @@ void RxConsumer() {
 		wakeupRxConsumer.lock(); //wait for wakeup
 
 		while(!rxBuffer.empty()) {
-			appRxCallback(rxBuffer.pop()); //handles all the code in the callback-function
+			rxPkg p = rxBuffer.pop();
+			appRxCallback(p.data, p.RssiPkt, p.SnrPkt, p.SignalRssiPkt); //handles all the code in the callback-function
 		}
 	}
 }
 
-void PinedioLoraRadioInitialize(std::function<void(std::vector<uint8_t>)> appRxCallback_) {
+void PinedioLoraRadioInitialize(std::function<void(std::vector<uint8_t>, int8_t, int8_t, int8_t)> appRxCallback_) {
 	std::cout << "[PinedioLoraRadio] Initialize()" << std::endl;
 
 	appRxCallback = appRxCallback_;
 
 	modulationParams.PacketType = SX126x::RadioPacketTypes_t::PACKET_TYPE_LORA;
-	modulationParams.Params.LoRa.LowDatarateOptimize = 0;
-	modulationParams.Params.LoRa.Bandwidth = SX126x::RadioLoRaBandwidths_t::LORA_BW_125;
-	modulationParams.Params.LoRa.CodingRate = SX126x::RadioLoRaCodingRates_t::LORA_CR_4_7;
-	modulationParams.Params.LoRa.SpreadingFactor = SX126x::RadioLoRaSpreadingFactors_t::LORA_SF9;
+	modulationParams.Params.LoRa.LowDatarateOptimize = 1;
+	modulationParams.Params.LoRa.Bandwidth = SX126x::RadioLoRaBandwidths_t::LORA_BW_500;
+	modulationParams.Params.LoRa.CodingRate = SX126x::RadioLoRaCodingRates_t::LORA_CR_4_8;
+	modulationParams.Params.LoRa.SpreadingFactor = SX126x::RadioLoRaSpreadingFactors_t::LORA_SF12;
 
 	packetParams.PacketType = SX126x::RadioPacketTypes_t::PACKET_TYPE_LORA;;
 	packetParams.Params.LoRa.HeaderType = SX126x::RadioLoRaPacketLengthsMode_t::LORA_PACKET_IMPLICIT;
-	packetParams.Params.LoRa.InvertIQ = SX126x::RadioLoRaIQModes_t::LORA_IQ_INVERTED;
+	packetParams.Params.LoRa.InvertIQ = SX126x::RadioLoRaIQModes_t::LORA_IQ_NORMAL;
 	packetParams.Params.LoRa.CrcMode = SX126x::RadioLoRaCrcModes_t::LORA_CRC_OFF;
 	packetParams.Params.LoRa.PayloadLength = 255; //only implemented for 255 at the moment - otherwise send and receive-Length needs to be alternated; 255 seems to be the max even though the buffer seems to be 256 Bytes big
 	packetParams.Params.LoRa.PreambleLength = 8;
 
-	//seems to be radio.reset(new pinephoneBackplate("/dev/i2c-2")); for the PInePhone - untested
+#ifdef PP
+	radio.reset(new PineDio::LoRa::PinephoneBackplate("/dev/i2c-2"));
+#else
 	radio.reset(new PineDio::LoRa::UsbAdapter());
+#endif
 
 	radio->SetDeviceType(SX126x::SX1262);
 	radio->Init();
@@ -70,7 +91,7 @@ void PinedioLoraRadioInitialize(std::function<void(std::vector<uint8_t>)> appRxC
 	radio->SetRegulatorMode(SX126x::RadioRegulatorMode_t::USE_DCDC);
 	radio->SetBufferBaseAddresses(0,0);
 
-	radio->SetTxParams(22, SX126x::RadioRampTimes_t::RADIO_RAMP_3400_US);
+	radio->SetTxParams(10, SX126x::RadioRampTimes_t::RADIO_RAMP_3400_US);
 	radio->SetDioIrqParams(0xffff, 0x0001, 0x0000, 0x0000);
 	radio->SetRfFrequency(433500000);
 
@@ -85,13 +106,18 @@ void PinedioLoraRadioInitialize(std::function<void(std::vector<uint8_t>)> appRxC
 	radio->SetRx(0xffffffff);
 
 	radio->callbacks.rxDone = [](){
-		uint8_t size = 255; //make it dfinitly big enough
+		uint8_t size = 255; //make it definitly big enough
+
+		SX126x::PacketStatus_t status;
+		radio->GetPacketStatus(&status);
 
-		std::vector<uint8_t> pkg(size); //a to big array isn't a problem :)
-		pkg.resize(size);
-		radio->GetPayload(&pkg[0], &size, size);
+		rxPkg pkg = {.data{size}, .RssiPkt = status.Params.LoRa.RssiPkt, .SnrPkt = status.Params.LoRa.SnrPkt, .SignalRssiPkt = status.Params.LoRa.SignalRssiPkt};
+		pkg.data.resize(size);
+		radio->GetPayload(&pkg.data[0], &size, size);
 		rxBuffer.push(pkg);
 
+		lastRx = time(NULL);
+
 		//I'm doing really hacky stuff here - see comment for wakeupRxConsumer
 		wakeupRxConsumer.try_lock(); //make sure the mutex is locked - it should be
 		wakeupRxConsumer.unlock(); //wakeup consumer
@@ -116,9 +142,9 @@ void PinedioLoraRadioInitialize(std::function<void(std::vector<uint8_t>)> appRxC
 	stop.store(false);
 }
 
-void PinedioLoraRadioInitialize(void (*appRxCallback_)(uint8_t[])) {
-	PinedioLoraRadioInitialize([appRxCallback_](std::vector<uint8_t> param){
-		appRxCallback_(param.data());
+void PinedioLoraRadioInitialize(void (*appRxCallback_)(uint8_t[], int8_t, int8_t, int8_t)) {
+	PinedioLoraRadioInitialize([appRxCallback_](std::vector<uint8_t> param, int8_t RssiPkt, int8_t SnrPkt, int8_t SignalRssiPkt){
+		appRxCallback_(param.data(), RssiPkt, SnrPkt, SignalRssiPkt);
 		//The content of param.data() will be deleted here
 	});
 }
@@ -148,7 +174,8 @@ void LoRaStateMachine() {
 		while(!stop.load()) {
 			radio->ProcessIrqs(); //calls received-callback if something is received
 
-			while(!txInProgress.load() && !transmitBuffer.empty()) {
+			//TODO: proper Channel-Activityy Detection - CAD - see https://lupyuen.github.io/articles/usb#cad-done  ; RadioLib SX126x::scanChannel()
+			while(!txInProgress.load() && (difftime(time(NULL), lastRx) > CONTINUOUS_RX_BUFFER) && !transmitBuffer.empty()) {
 				std::vector<uint8_t> pkg = transmitBuffer.pop(); //mutexed_queue::pop differs from STLs queue::pop
 				std::cout << "SEND " << std::to_string(pkg.size()) << std::endl;
 
@@ -166,4 +193,4 @@ void LoRaStateMachine() {
 void PinedioLoraRadioStart() {
 	loop = std::thread(LoRaStateMachine);
 	RxConsumerThread = std::thread(RxConsumer);
-}
\ No newline at end of file
+}
diff --git a/src/PinedioLoraRadio.h b/src/PinedioLoraRadio.h
index 5e321e16adf494d322959bd2dd706cc347e4a061..23d7f5410aeb84d6c5da078b14a5447c3d3eff15 100644
--- a/src/PinedioLoraRadio.h
+++ b/src/PinedioLoraRadio.h
@@ -12,7 +12,7 @@
 //void PinedioLoraRadioInitialize(std::function<void(std::vector<uint8_t>)> appRxCallback_);
 //void PinedioLoraRadioSend(const std::vector<uint8_t> data);
 extern "C" {
-    void PinedioLoraRadioInitialize(void (*appRxCallback_)(uint8_t[])); //callback: needs to be thread-safe and immideately deepcopy the byte array
+    void PinedioLoraRadioInitialize(void (*appRxCallback_)(uint8_t[], int8_t, int8_t, int8_t)); //callback: needs to be thread-safe and immideately deepcopy the byte array
     void PinedioLoraRadioSend(const uint8_t[]);
     void PinedioLoraRadioStart();
     void PinedioLoraRadioStop() __attribute__((destructor (9999)));
diff --git a/src/pinephone/CMakeLists.txt b/src/pinephone/CMakeLists.txt
index d32f0b8ddf268bb18e51368caf90be35363a4c4e..e7253b4820fabbd8d21bb4639882d366d98ffbe1 100644
--- a/src/pinephone/CMakeLists.txt
+++ b/src/pinephone/CMakeLists.txt
@@ -4,16 +4,10 @@ set(PINEDIO_LORA_DRIVER_SOURCE_FILES
     PinephoneBackplate.cpp
 )
 
-set(PINEDIO_LORA_DRIVER_PUBLIC_HEADERS
-    ../PinedioLoraRadio.h
-    ../PinephoneBackplate.h
-    )
-
 add_library(pinedio-lora-driver-pinephone
-    ${PINEDIO_LORA_DRIVER_PUBLIC_HEADERS}
     ${PINEDIO_LORA_DRIVER_SOURCE_FILES}
     )
 
 target_link_libraries(pinedio-lora-driver-pinephone PUBLIC
-    pinedio-lora-driver
+    sx126x_driver
     )
\ No newline at end of file
diff --git a/src/usb-adapter/CMakeLists.txt b/src/usb-adapter/CMakeLists.txt
index 2d63daf31016956e0a9610ab78a3c27934c77a8a..43342fb2bb5937153d6ae8ae8e9bc0653b58316a 100644
--- a/src/usb-adapter/CMakeLists.txt
+++ b/src/usb-adapter/CMakeLists.txt
@@ -5,7 +5,6 @@ set(PINEDIO_LORA_DRIVER_SOURCE_FILES
 )
 
 add_library(pinedio-lora-driver-usb
-    ${PINEDIO_LORA_DRIVER_PUBLIC_HEADERS}
     ${PINEDIO_LORA_DRIVER_SOURCE_FILES}
     )
 
diff --git a/testapp/CMakeLists.txt b/testapp/CMakeLists.txt
index 0a238ed4f822885389c6f3e558d5e615d136c8ba..877c00c13db9aa1e31b254e032e9f0d08b4bfd9c 100644
--- a/testapp/CMakeLists.txt
+++ b/testapp/CMakeLists.txt
@@ -8,6 +8,20 @@ set(THREADS_PREFER_PTHREAD_FLAG ON)
 add_executable(testapp
     main.cpp)
 
+add_executable(Rx
+    Rx.cpp)
+
+add_executable(Tx
+    Tx.cpp)
+
 target_link_libraries(testapp
+    "pthread"  ${CMAKE_DL_LIBS} ${CMAKE_THREAD_LIBS_INIT}
+    )
+
+target_link_libraries(Rx
+    "pthread"  ${CMAKE_DL_LIBS} ${CMAKE_THREAD_LIBS_INIT}
+    )
+
+target_link_libraries(Tx
     "pthread"  ${CMAKE_DL_LIBS} ${CMAKE_THREAD_LIBS_INIT}
     )
\ No newline at end of file
diff --git a/testapp/Tx.cpp b/testapp/Tx.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bebefcf80ab78240af38bcf635dd1cc549c9bb94
--- /dev/null
+++ b/testapp/Tx.cpp
@@ -0,0 +1,59 @@
+//#include "../src/UsbAdapter.h"
+//#include "../src/Exceptions.h"
+//#include "../src/PinedioLoraRadio.h"
+#include <iostream>
+#include <signal.h>
+#include <future>
+#include <algorithm>
+#include <atomic>
+#include <vector>
+#include <thread>
+#include <dlfcn.h>
+
+void (*PinedioLoraRadioInitialize)(void (*appRxCallback_)(uint8_t[], int8_t, int8_t, int8_t));
+void (*PinedioLoraRadioStart)();
+void (*PinedioLoraRadioSend)(const uint8_t[]);
+void (*PinedioLoraRadioStop)();
+
+int main() {
+  void* lib_handle = dlopen("libpinedio-lora-driver.so", RTLD_LAZY);
+  PinedioLoraRadioInitialize = (void (*)(void (*)(uint8_t[], int8_t, int8_t, int8_t)))dlsym(lib_handle, "PinedioLoraRadioInitialize");
+  PinedioLoraRadioStart = (void (*)())dlsym(lib_handle, "PinedioLoraRadioStart");
+  PinedioLoraRadioSend = (void (*)(const uint8_t[]))dlsym(lib_handle, "PinedioLoraRadioSend");
+  PinedioLoraRadioStop = (void (*)())dlsym(lib_handle, "PinedioLoraRadioStop");
+
+  PinedioLoraRadioInitialize([](uint8_t data[], int8_t RssiPkt, int8_t SnrPkt, int8_t SignalRssiPkt) {for(int i=0;i<255;i++)printf("%x",data[i]);});
+  PinedioLoraRadioStart();
+  std::vector<uint8_t> data({'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+                        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+                        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+                        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+                        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+                        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+                        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+                        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+                        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+                        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+                        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+                        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+                        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+                        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+                        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+                        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+                        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+                        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+                        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+                        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 
+                        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+                        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+                        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+                        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+                        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+                        '0', '1', '2', '3', '4'});
+  while(true) {
+    PinedioLoraRadioSend(data.data());
+    std::this_thread::sleep_for(std::chrono::milliseconds(2000));
+  }
+  PinedioLoraRadioStop();//*/
+  return 0;
+}
\ No newline at end of file
diff --git a/testapp/main.cpp b/testapp/main.cpp
index 9e07cebc0e41a8ee949c6c5a39859f5046ea9d29..f80b203be98158bd469d5a68911811d70753715d 100644
--- a/testapp/main.cpp
+++ b/testapp/main.cpp
@@ -10,19 +10,19 @@
 #include <thread>
 #include <dlfcn.h>
 
-void (*PinedioLoraRadioInitialize)(void (*appRxCallback_)(uint8_t[]));
+void (*PinedioLoraRadioInitialize)(void (*appRxCallback_)(uint8_t[], int8_t, int8_t, int8_t));
 void (*PinedioLoraRadioStart)();
 void (*PinedioLoraRadioSend)(const uint8_t[]);
 void (*PinedioLoraRadioStop)();
 
 int main() {
   void* lib_handle = dlopen("libpinedio-lora-driver.so", RTLD_LAZY);
-  PinedioLoraRadioInitialize = (void (*)(void (*)(uint8_t[])))dlsym(lib_handle, "PinedioLoraRadioInitialize");
+  PinedioLoraRadioInitialize = (void (*)(void (*)(uint8_t[], int8_t, int8_t, int8_t)))dlsym(lib_handle, "PinedioLoraRadioInitialize");
   PinedioLoraRadioStart = (void (*)())dlsym(lib_handle, "PinedioLoraRadioStart");
   PinedioLoraRadioSend = (void (*)(const uint8_t[]))dlsym(lib_handle, "PinedioLoraRadioSend");
   PinedioLoraRadioStop = (void (*)())dlsym(lib_handle, "PinedioLoraRadioStop");
 
-  PinedioLoraRadioInitialize([](uint8_t data[]) {for(int i=0;i<255;i++)printf("%x",data[i]);});
+  PinedioLoraRadioInitialize([](uint8_t data[], int8_t, int8_t, int8_t) {for(int i=0;i<255;i++)printf("%x",data[i]);});
   PinedioLoraRadioStart();
   std::vector<uint8_t> data({'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
                         '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',