diff --git a/conf/telemetry/telemetry.dtd b/conf/telemetry/telemetry.dtd
index 2c7395c368..99e0bb35a1 100644
--- a/conf/telemetry/telemetry.dtd
+++ b/conf/telemetry/telemetry.dtd
@@ -7,6 +7,7 @@
 <!ATTLIST process
   name CDATA #REQUIRED
   channel CDATA "DefaultChannel"
+  device CDATA "DefaultDevice"
 >
 <!ATTLIST mode
   name CDATA #REQUIRED
diff --git a/sw/airborne/arch/sim/ivy_transport.h b/sw/airborne/arch/sim/ivy_transport.h
index 1926187d9e..e4b482bfd6 100644
--- a/sw/airborne/arch/sim/ivy_transport.h
+++ b/sw/airborne/arch/sim/ivy_transport.h
@@ -4,45 +4,45 @@
 extern char ivy_buf[];
 extern char* ivy_p;
 
-#define IvyTransportCheckFreeSpace(_) TRUE
+#define IvyTransportCheckFreeSpace(_dev,_) TRUE
 
 #define IvyTransportSizeOf(x) (x)
 
-#define IvyTransportHeader(len) ivy_p=ivy_buf;
+#define IvyTransportHeader(_dev,len) ivy_p=ivy_buf;
 
-#define IvyTransportTrailer() { *ivy_p = '\0'; IvySendMsg("%s",ivy_buf); }
+#define IvyTransportTrailer(_dev) { *ivy_p = '\0'; IvySendMsg("%s",ivy_buf); }
 
-#define IvyTransportPutUint8(x) { ivy_p += sprintf(ivy_p, "%u ", x); }
-#define IvyTransportPutNamedUint8(_name, _x) { ivy_p += sprintf(ivy_p, "%s ", _name); }
+#define IvyTransportPutUint8(_dev,x) { ivy_p += sprintf(ivy_p, "%u ", x); }
+#define IvyTransportPutNamedUint8(_dev,_name, _x) { ivy_p += sprintf(ivy_p, "%s ", _name); }
 
 #define Space() ivy_p += sprintf(ivy_p, " ");
 #define Comma() ivy_p += sprintf(ivy_p, ",");
 
-#define IvyTransportPutUintByAddr(x) ivy_p += sprintf(ivy_p, "%u", *x);
-#define IvyTransportPutUint8ByAddr(x) IvyTransportPutUintByAddr(x) Space()
-#define IvyTransportPutUint16ByAddr(x) IvyTransportPutUintByAddr(x) Space()
-#define IvyTransportPutUint32ByAddr(x) IvyTransportPutUintByAddr(x) Space()
+#define IvyTransportPutUintByAddr(_dev,x) ivy_p += sprintf(ivy_p, "%u", *x);
+#define IvyTransportPutUint8ByAddr(_dev,x) IvyTransportPutUintByAddr(_dev,x) Space()
+#define IvyTransportPutUint16ByAddr(_dev,x) IvyTransportPutUintByAddr(_dev,x) Space()
+#define IvyTransportPutUint32ByAddr(_dev,x) IvyTransportPutUintByAddr(_dev,x) Space()
 
-#define IvyTransportPutIntByAddr(x) ivy_p += sprintf(ivy_p, "%d", *x);
-#define IvyTransportPutInt8ByAddr(x) IvyTransportPutIntByAddr(x) Space()
-#define IvyTransportPutInt16ByAddr(x) IvyTransportPutIntByAddr(x) Space()
-#define IvyTransportPutInt32ByAddr(x) IvyTransportPutIntByAddr(x) Space()
+#define IvyTransportPutIntByAddr(_dev,x) ivy_p += sprintf(ivy_p, "%d", *x);
+#define IvyTransportPutInt8ByAddr(_dev,x) IvyTransportPutIntByAddr(_dev,x) Space()
+#define IvyTransportPutInt16ByAddr(_dev,x) IvyTransportPutIntByAddr(_dev,x) Space()
+#define IvyTransportPutInt32ByAddr(_dev,x) IvyTransportPutIntByAddr(_dev,x) Space()
 
-#define IvyTransportPutOneFloatByAddr(x) ivy_p += sprintf(ivy_p, "%f", *x);
-#define IvyTransportPutFloatByAddr(x) IvyTransportPutOneFloatByAddr(x) Space()
-#define IvyTransportPutDoubleByAddr(x) IvyTransportPutOneFloatByAddr(x) Space()
+#define IvyTransportPutOneFloatByAddr(_dev,x) ivy_p += sprintf(ivy_p, "%f", *x);
+#define IvyTransportPutFloatByAddr(_dev,x) IvyTransportPutOneFloatByAddr(_dev,x) Space()
+#define IvyTransportPutDoubleByAddr(_dev,x) IvyTransportPutOneFloatByAddr(_dev,x) Space()
 
-#define IvyTransportPutArray(_put, _n, _x) { \
+#define IvyTransportPutArray(_dev,_put, _n, _x) { \
   int __i; \
   for(__i = 0; __i < _n; __i++) { \
-    _put(&_x[__i]); \
+    _put(_dev,&_x[__i]); \
     Comma(); \
   } \
 }
 
-#define IvyTransportPutUint8Array(_n, _x) IvyTransportPutArray(IvyTransportPutUintByAddr, _n, _x)
-#define IvyTransportPutInt16Array(_n, _x) IvyTransportPutArray(IvyTransportPutIntByAddr, _n, _x)
-#define IvyTransportPutUint16Array(_n, _x) IvyTransportPutArray(IvyTransportPutUintByAddr, _n, _x)
-#define IvyTransportPutUint32Array(_n, _x) IvyTransportPutArray(IvyTransportPutUintByAddr, _n, _x)
-#define IvyTransportPutFloatArray(_n, _x) IvyTransportPutArray(IvyTransportPutOneFloatByAddr, _n, _x)
-#define IvyTransportPutDoubleArray(_n, _x) IvyTransportPutFloatArray(_n, _x)
+#define IvyTransportPutUint8Array(_dev,_n, _x) IvyTransportPutArray(_dev,IvyTransportPutUintByAddr, _n, _x)
+#define IvyTransportPutInt16Array(_dev,_n, _x) IvyTransportPutArray(_dev,IvyTransportPutIntByAddr, _n, _x)
+#define IvyTransportPutUint16Array(_dev,_n, _x) IvyTransportPutArray(_dev,IvyTransportPutUintByAddr, _n, _x)
+#define IvyTransportPutUint32Array(_dev,_n, _x) IvyTransportPutArray(_dev,IvyTransportPutUintByAddr, _n, _x)
+#define IvyTransportPutFloatArray(_dev,_n, _x) IvyTransportPutArray(_dev,IvyTransportPutOneFloatByAddr, _n, _x)
+#define IvyTransportPutDoubleArray(_dev,_n, _x) IvyTransportPutFloatArray(_dev,_n, _x)
diff --git a/sw/airborne/arch/sim/jsbsim_transport.c b/sw/airborne/arch/sim/jsbsim_transport.c
index 9e8bf97d86..24137fec0d 100644
--- a/sw/airborne/arch/sim/jsbsim_transport.c
+++ b/sw/airborne/arch/sim/jsbsim_transport.c
@@ -9,7 +9,7 @@
 #define MOfCm(_x) (((float)(_x))/100.)
 
 void parse_dl_ping(char* argv[] __attribute__ ((unused))) {
-  DOWNLINK_SEND_PONG(DefaultChannel);
+  DOWNLINK_SEND_PONG(DefaultChannel, DefaultDevice);
 }
 
 void parse_dl_acinfo(char* argv[] __attribute__ ((unused))) {
@@ -30,13 +30,13 @@ void parse_dl_setting(char* argv[]) {
   uint8_t index = atoi(argv[2]);
   float value = atof(argv[3]);
   DlSetting(index, value);
-  DOWNLINK_SEND_DL_VALUE(DefaultChannel,&index, &value);
+  DOWNLINK_SEND_DL_VALUE(DefaultChannel, DefaultDevice,&index, &value);
 }
 
 void parse_dl_get_setting(char* argv[]) {
   uint8_t index = atoi(argv[2]);
   float value = settings_get_value(index);
-  DOWNLINK_SEND_DL_VALUE(DefaultChannel,&index, &value);
+  DOWNLINK_SEND_DL_VALUE(DefaultChannel, DefaultDevice,&index, &value);
 }
 
 void parse_dl_block(char* argv[]) {
@@ -61,6 +61,6 @@ void parse_dl_move_wp(char* argv[]) {
      coordinates */
   utm.east = waypoints[wp_id].x + nav_utm_east0;
   utm.north = waypoints[wp_id].y + nav_utm_north0;
-  DOWNLINK_SEND_WP_MOVED(DefaultChannel, &wp_id, &utm.east, &utm.north, &a, &nav_utm_zone0);
+  DOWNLINK_SEND_WP_MOVED(DefaultChannel, DefaultDevice, &wp_id, &utm.east, &utm.north, &a, &nav_utm_zone0);
 }
 
diff --git a/sw/airborne/boards/booz/test_baro.c b/sw/airborne/boards/booz/test_baro.c
index 51fc4716b0..73d5127258 100644
--- a/sw/airborne/boards/booz/test_baro.c
+++ b/sw/airborne/boards/booz/test_baro.c
@@ -68,7 +68,7 @@ static inline void main_init( void ) {
 static inline void main_periodic_task( void ) {
 
   RunOnceEvery(2, {baro_periodic();});
-  RunOnceEvery(256, {DOWNLINK_SEND_ALIVE(DefaultChannel, 16, MD5SUM);});
+  RunOnceEvery(256, {DOWNLINK_SEND_ALIVE(DefaultChannel, DefaultDevice, 16, MD5SUM);});
   LED_PERIODIC();
 
 }
@@ -85,5 +85,5 @@ static inline void main_on_baro_diff(void) {
 }
 
 static inline void main_on_baro_abs(void) {
-  RunOnceEvery(5,{DOWNLINK_SEND_BARO_RAW(DefaultChannel, &baro.absolute, &baro.differential);});
+  RunOnceEvery(5,{DOWNLINK_SEND_BARO_RAW(DefaultChannel, DefaultDevice, &baro.absolute, &baro.differential);});
 }
diff --git a/sw/airborne/boards/lisa_l/test_baro.c b/sw/airborne/boards/lisa_l/test_baro.c
index 0010ad56bb..43b97d3c7a 100644
--- a/sw/airborne/boards/lisa_l/test_baro.c
+++ b/sw/airborne/boards/lisa_l/test_baro.c
@@ -75,10 +75,10 @@ static inline void main_periodic_task( void ) {
 
   RunOnceEvery(2, {baro_periodic();});
   LED_PERIODIC();
-  RunOnceEvery(256, {DOWNLINK_SEND_ALIVE(DefaultChannel, 16, MD5SUM);});
+  RunOnceEvery(256, {DOWNLINK_SEND_ALIVE(DefaultChannel, DefaultDevice, 16, MD5SUM);});
   RunOnceEvery(256,
     {
-      DOWNLINK_SEND_I2C_ERRORS(DefaultChannel,
+      DOWNLINK_SEND_I2C_ERRORS(DefaultChannel, DefaultDevice,
 			       &i2c2_errors.ack_fail_cnt,
 			       &i2c2_errors.miss_start_stop_cnt,
 			       &i2c2_errors.arb_lost_cnt,
@@ -104,5 +104,5 @@ static inline void main_on_baro_diff(void) {
 }
 
 static inline void main_on_baro_abs(void) {
-  RunOnceEvery(5,{DOWNLINK_SEND_BARO_RAW(DefaultChannel, &baro.absolute, &baro.differential);});
+  RunOnceEvery(5,{DOWNLINK_SEND_BARO_RAW(DefaultChannel, DefaultDevice, &baro.absolute, &baro.differential);});
 }
diff --git a/sw/airborne/boards/lisa_m/test_baro.c b/sw/airborne/boards/lisa_m/test_baro.c
index 0010ad56bb..43b97d3c7a 100644
--- a/sw/airborne/boards/lisa_m/test_baro.c
+++ b/sw/airborne/boards/lisa_m/test_baro.c
@@ -75,10 +75,10 @@ static inline void main_periodic_task( void ) {
 
   RunOnceEvery(2, {baro_periodic();});
   LED_PERIODIC();
-  RunOnceEvery(256, {DOWNLINK_SEND_ALIVE(DefaultChannel, 16, MD5SUM);});
+  RunOnceEvery(256, {DOWNLINK_SEND_ALIVE(DefaultChannel, DefaultDevice, 16, MD5SUM);});
   RunOnceEvery(256,
     {
-      DOWNLINK_SEND_I2C_ERRORS(DefaultChannel,
+      DOWNLINK_SEND_I2C_ERRORS(DefaultChannel, DefaultDevice,
 			       &i2c2_errors.ack_fail_cnt,
 			       &i2c2_errors.miss_start_stop_cnt,
 			       &i2c2_errors.arb_lost_cnt,
@@ -104,5 +104,5 @@ static inline void main_on_baro_diff(void) {
 }
 
 static inline void main_on_baro_abs(void) {
-  RunOnceEvery(5,{DOWNLINK_SEND_BARO_RAW(DefaultChannel, &baro.absolute, &baro.differential);});
+  RunOnceEvery(5,{DOWNLINK_SEND_BARO_RAW(DefaultChannel, DefaultDevice, &baro.absolute, &baro.differential);});
 }
diff --git a/sw/airborne/boards/navgo/imu_navgo.c b/sw/airborne/boards/navgo/imu_navgo.c
index edada4575b..78be53e4a5 100644
--- a/sw/airborne/boards/navgo/imu_navgo.c
+++ b/sw/airborne/boards/navgo/imu_navgo.c
@@ -91,9 +91,9 @@ void imu_periodic( void )
 
 void imu_navgo_downlink_raw( void )
 {
-  DOWNLINK_SEND_IMU_GYRO_RAW(DefaultChannel,&imu.gyro_unscaled.p,&imu.gyro_unscaled.q,&imu.gyro_unscaled.r);
-  DOWNLINK_SEND_IMU_ACCEL_RAW(DefaultChannel,&imu.accel_unscaled.x,&imu.accel_unscaled.y,&imu.accel_unscaled.z);
-  DOWNLINK_SEND_IMU_MAG_RAW(DefaultChannel,&imu.mag_unscaled.x,&imu.mag_unscaled.y,&imu.mag_unscaled.z);
+  DOWNLINK_SEND_IMU_GYRO_RAW(DefaultChannel, DefaultDevice,&imu.gyro_unscaled.p,&imu.gyro_unscaled.q,&imu.gyro_unscaled.r);
+  DOWNLINK_SEND_IMU_ACCEL_RAW(DefaultChannel, DefaultDevice,&imu.accel_unscaled.x,&imu.accel_unscaled.y,&imu.accel_unscaled.z);
+  DOWNLINK_SEND_IMU_MAG_RAW(DefaultChannel, DefaultDevice,&imu.mag_unscaled.x,&imu.mag_unscaled.y,&imu.mag_unscaled.z);
 }
 
 
diff --git a/sw/airborne/boards/umarim/baro_board.c b/sw/airborne/boards/umarim/baro_board.c
index 87545deb09..c9ec41c645 100644
--- a/sw/airborne/boards/umarim/baro_board.c
+++ b/sw/airborne/boards/umarim/baro_board.c
@@ -80,6 +80,6 @@ void baro_periodic( void ) {
 
 void baro_downlink_raw( void )
 {
-  DOWNLINK_SEND_BARO_RAW(DefaultChannel,&baro.absolute,&baro.differential);
+  DOWNLINK_SEND_BARO_RAW(DefaultChannel, DefaultDevice,&baro.absolute,&baro.differential);
 }
 
diff --git a/sw/airborne/boards/umarim/imu_umarim.c b/sw/airborne/boards/umarim/imu_umarim.c
index 7301f9c88b..0ff9f8bc30 100644
--- a/sw/airborne/boards/umarim/imu_umarim.c
+++ b/sw/airborne/boards/umarim/imu_umarim.c
@@ -80,8 +80,8 @@ void imu_periodic( void )
 
 void imu_umarim_downlink_raw( void )
 {
-  DOWNLINK_SEND_IMU_GYRO_RAW(DefaultChannel,&imu.gyro_unscaled.p,&imu.gyro_unscaled.q,&imu.gyro_unscaled.r);
-  DOWNLINK_SEND_IMU_ACCEL_RAW(DefaultChannel,&imu.accel_unscaled.x,&imu.accel_unscaled.y,&imu.accel_unscaled.z);
+  DOWNLINK_SEND_IMU_GYRO_RAW(DefaultChannel, DefaultDevice,&imu.gyro_unscaled.p,&imu.gyro_unscaled.q,&imu.gyro_unscaled.r);
+  DOWNLINK_SEND_IMU_ACCEL_RAW(DefaultChannel, DefaultDevice,&imu.accel_unscaled.x,&imu.accel_unscaled.y,&imu.accel_unscaled.z);
 }
 
 
diff --git a/sw/airborne/booz/test/booz2_test_buss_bldc_hexa.c b/sw/airborne/booz/test/booz2_test_buss_bldc_hexa.c
index 51dd1c623d..516e9aad0e 100644
--- a/sw/airborne/booz/test/booz2_test_buss_bldc_hexa.c
+++ b/sw/airborne/booz/test/booz2_test_buss_bldc_hexa.c
@@ -68,7 +68,7 @@ static inline void main_periodic_task( void ) {
   i2c0_buf[0] = thrust;
   i2c0_transmit(motor_addr[motor], 1, &i2c_done);
 
-  RunOnceEvery(128, { DOWNLINK_SEND_ALIVE(DefaultChannel, 16, MD5SUM);});
+  RunOnceEvery(128, { DOWNLINK_SEND_ALIVE(DefaultChannel, DefaultDevice, 16, MD5SUM);});
 
 }
 
diff --git a/sw/airborne/booz/test/booz2_test_gps.c b/sw/airborne/booz/test/booz2_test_gps.c
index b574327ce3..aa633866d9 100644
--- a/sw/airborne/booz/test/booz2_test_gps.c
+++ b/sw/airborne/booz/test/booz2_test_gps.c
@@ -56,7 +56,7 @@ static inline void main_init( void ) {
 
 static inline void main_periodic_task( void ) {
 
-  RunOnceEvery(128, { DOWNLINK_SEND_ALIVE(DefaultChannel, 16, MD5SUM);});
+  RunOnceEvery(128, { DOWNLINK_SEND_ALIVE(DefaultChannel, DefaultDevice, 16, MD5SUM);});
   RunOnceEvery(128, { LED_PERIODIC();});
 }
 
@@ -67,7 +67,7 @@ static inline void main_event_task( void ) {
 
 static void on_gps_sol(void) {
 
-  DOWNLINK_SEND_GPS_INT( DefaultChannel,
+  DOWNLINK_SEND_GPS_INT( DefaultChannel, DefaultDevice,
 			   &gps.ecef_pos.x,
 			   &gps.ecef_pos.y,
 			   &gps.ecef_pos.z,
diff --git a/sw/airborne/booz/test/booz2_test_max1168.c b/sw/airborne/booz/test/booz2_test_max1168.c
index fd737e1b02..7565673cb9 100644
--- a/sw/airborne/booz/test/booz2_test_max1168.c
+++ b/sw/airborne/booz/test/booz2_test_max1168.c
@@ -73,9 +73,9 @@ static inline void main_periodic_task( void ) {
 static inline void main_event_task( void ) {
   if (max1168_status == STA_MAX1168_DATA_AVAILABLE) {
     RunOnceEvery(10, {
-	DOWNLINK_SEND_IMU_GYRO_RAW(DefaultChannel, &max1168_values[0], &max1168_values[1], &max1168_values[2]);
-	DOWNLINK_SEND_IMU_ACCEL_RAW(DefaultChannel, &max1168_values[3], &max1168_values[4], &max1168_values[6]);
-	DOWNLINK_SEND_BOOT(DefaultChannel, &max1168_values[7]); });
+	DOWNLINK_SEND_IMU_GYRO_RAW(DefaultChannel, DefaultDevice, &max1168_values[0], &max1168_values[1], &max1168_values[2]);
+	DOWNLINK_SEND_IMU_ACCEL_RAW(DefaultChannel, DefaultDevice, &max1168_values[3], &max1168_values[4], &max1168_values[6]);
+	DOWNLINK_SEND_BOOT(DefaultChannel, DefaultDevice, &max1168_values[7]); });
     max1168_status = STA_MAX1168_IDLE;
   }
 }
diff --git a/sw/airborne/booz/test/booz2_test_radio_control.c b/sw/airborne/booz/test/booz2_test_radio_control.c
index 96251653a2..bf95dd2248 100644
--- a/sw/airborne/booz/test/booz2_test_radio_control.c
+++ b/sw/airborne/booz/test/booz2_test_radio_control.c
@@ -62,14 +62,14 @@ static inline void main_periodic_task( void ) {
   RunOnceEvery(51, {
     /*LED_TOGGLE(2);*/
     uint32_t blaaa= cpu_time_sec;
-    DOWNLINK_SEND_TIME(DefaultChannel, &blaaa);
+    DOWNLINK_SEND_TIME(DefaultChannel, DefaultDevice, &blaaa);
   });
 
   RunOnceEvery(10, {radio_control_periodic_task();});
 
   int16_t foo = 0;//RC_PPM_SIGNED_TICS_OF_USEC(2050-1500);
   RunOnceEvery(10,
-    {DOWNLINK_SEND_BOOZ2_RADIO_CONTROL(DefaultChannel,	\
+    {DOWNLINK_SEND_BOOZ2_RADIO_CONTROL(DefaultChannel, DefaultDevice,	\
 				       &radio_control.values[RADIO_ROLL], \
 				       &radio_control.values[RADIO_PITCH], \
 				       &radio_control.values[RADIO_YAW], \
@@ -79,7 +79,7 @@ static inline void main_periodic_task( void ) {
 				       &radio_control.status);});
 #ifdef RADIO_CONTROL_TYPE_PPM
   RunOnceEvery(10,
-	       {uint8_t blaa = 0; DOWNLINK_SEND_PPM(DefaultChannel,&blaa, 8, booz_radio_control_ppm_pulses);});
+	       {uint8_t blaa = 0; DOWNLINK_SEND_PPM(DefaultChannel, DefaultDevice,&blaa, 8, booz_radio_control_ppm_pulses);});
 #endif
 
   LED_PERIODIC();
diff --git a/sw/airborne/booz/test/booz_test_imu.c b/sw/airborne/booz/test/booz_test_imu.c
index 160d1b3e9c..a22e5a29ec 100644
--- a/sw/airborne/booz/test/booz_test_imu.c
+++ b/sw/airborne/booz/test/booz_test_imu.c
@@ -78,11 +78,11 @@ static inline void led_toggle ( void ) {
 static inline void main_periodic_task( void ) {
   RunOnceEvery(100, {
       led_toggle();
-      DOWNLINK_SEND_ALIVE(DefaultChannel, 16, MD5SUM);
+      DOWNLINK_SEND_ALIVE(DefaultChannel, DefaultDevice, 16, MD5SUM);
     });
 #ifdef USE_I2C2
   RunOnceEvery(111, {
-      DOWNLINK_SEND_I2C_ERRORS(DefaultChannel,
+      DOWNLINK_SEND_I2C_ERRORS(DefaultChannel, DefaultDevice,
                    &i2c2_errors.ack_fail_cnt,
                    &i2c2_errors.miss_start_stop_cnt,
                    &i2c2_errors.arb_lost_cnt,
@@ -112,13 +112,13 @@ static inline void on_accel_event(void) {
   cnt++;
   if (cnt > 15) cnt = 0;
   if (cnt == 0) {
-    DOWNLINK_SEND_IMU_ACCEL_RAW(DefaultChannel,
+    DOWNLINK_SEND_IMU_ACCEL_RAW(DefaultChannel, DefaultDevice,
                 &imu.accel_unscaled.x,
                 &imu.accel_unscaled.y,
                 &imu.accel_unscaled.z);
   }
   else if (cnt == 7) {
-    DOWNLINK_SEND_IMU_ACCEL_SCALED(DefaultChannel,
+    DOWNLINK_SEND_IMU_ACCEL_SCALED(DefaultChannel, DefaultDevice,
                   &imu.accel.x,
                   &imu.accel.y,
                   &imu.accel.z);
@@ -134,13 +134,13 @@ static inline void on_gyro_accel_event(void) {
   if (cnt > 15) cnt = 0;
 
   if (cnt == 0) {
-    DOWNLINK_SEND_IMU_GYRO_RAW(DefaultChannel,
+    DOWNLINK_SEND_IMU_GYRO_RAW(DefaultChannel, DefaultDevice,
                    &imu.gyro_unscaled.p,
                    &imu.gyro_unscaled.q,
                    &imu.gyro_unscaled.r);
   }
   else if (cnt == 7) {
-    DOWNLINK_SEND_IMU_GYRO_SCALED(DefaultChannel,
+    DOWNLINK_SEND_IMU_GYRO_SCALED(DefaultChannel, DefaultDevice,
                  &imu.gyro.p,
                  &imu.gyro.q,
                  &imu.gyro.r);
@@ -155,13 +155,13 @@ static inline void on_mag_event(void) {
   if (cnt > 10) cnt = 0;
 
   if (cnt == 0) {
-    DOWNLINK_SEND_IMU_MAG_SCALED(DefaultChannel,
+    DOWNLINK_SEND_IMU_MAG_SCALED(DefaultChannel, DefaultDevice,
                 &imu.mag.x,
                 &imu.mag.y,
                 &imu.mag.z);
   }
   else if (cnt == 5) {
-    DOWNLINK_SEND_IMU_MAG_RAW(DefaultChannel,
+    DOWNLINK_SEND_IMU_MAG_RAW(DefaultChannel, DefaultDevice,
                   &imu.mag_unscaled.x,
                   &imu.mag_unscaled.y,
                   &imu.mag_unscaled.z);
diff --git a/sw/airborne/booz/test/booz_test_telemetry.c b/sw/airborne/booz/test/booz_test_telemetry.c
index 4d52ee11e1..0485b08dc8 100644
--- a/sw/airborne/booz/test/booz_test_telemetry.c
+++ b/sw/airborne/booz/test/booz_test_telemetry.c
@@ -52,7 +52,7 @@ static inline void main_init( void ) {
 
 static inline void main_periodic_task( void ) {
   LED_TOGGLE(2);
-  DOWNLINK_SEND_TIME(DefaultChannel, &cpu_time_sec);
+  DOWNLINK_SEND_TIME(DefaultChannel, DefaultDevice, &cpu_time_sec);
 }
 
 static inline void main_event_task( void ) {
diff --git a/sw/airborne/firmwares/fixedwing/ap_downlink.h b/sw/airborne/firmwares/fixedwing/ap_downlink.h
index c97aaa3608..f9797831a9 100644
--- a/sw/airborne/firmwares/fixedwing/ap_downlink.h
+++ b/sw/airborne/firmwares/fixedwing/ap_downlink.h
@@ -60,12 +60,12 @@
 extern uint8_t telemetry_mode_Ap_DefaultChannel;
 #endif
 
-#define PERIODIC_SEND_ALIVE(_chan)  DOWNLINK_SEND_ALIVE(_chan, 16, MD5SUM);
+#define PERIODIC_SEND_ALIVE(_trans, _dev)  DOWNLINK_SEND_ALIVE(_trans, _dev, 16, MD5SUM);
 
-#define PERIODIC_SEND_BAT(_chan) {                      \
+#define PERIODIC_SEND_BAT(_trans, _dev) {                      \
     int16_t amps = (int16_t) (current/10);				\
     Downlink({ int16_t e = energy;                      \
-        DOWNLINK_SEND_BAT(_chan,                        \
+        DOWNLINK_SEND_BAT(_trans, _dev,                        \
                           &v_ctl_throttle_slewed,       \
                           &vsupply,                     \
                           &amps,                        \
@@ -78,180 +78,180 @@ extern uint8_t telemetry_mode_Ap_DefaultChannel;
   }
 
 #ifdef MCU_SPI_LINK
-#define PERIODIC_SEND_DEBUG_MCU_LINK(_chan) DOWNLINK_SEND_DEBUG_MCU_LINK(_chan, &link_mcu_nb_err, &link_mcu_fbw_nb_err, &mcu1_ppm_cpt);
+#define PERIODIC_SEND_DEBUG_MCU_LINK(_trans, _dev) DOWNLINK_SEND_DEBUG_MCU_LINK(_trans, _dev, &link_mcu_nb_err, &link_mcu_fbw_nb_err, &mcu1_ppm_cpt);
 #else
-#define PERIODIC_SEND_DEBUG_MCU_LINK(_chan) {}
+#define PERIODIC_SEND_DEBUG_MCU_LINK(_trans, _dev) {}
 #endif
 
 
-#define PERIODIC_SEND_DOWNLINK(_chan) { \
+#define PERIODIC_SEND_DOWNLINK(_trans, _dev) { \
   static uint16_t last; \
   uint16_t rate = (downlink_nb_bytes - last) / PERIOD_DOWNLINK_Ap_DefaultChannel_0; \
   last = downlink_nb_bytes; \
-  DOWNLINK_SEND_DOWNLINK(_chan, &downlink_nb_ovrn, &rate, &downlink_nb_msgs); \
+  DOWNLINK_SEND_DOWNLINK(_trans, _dev, &downlink_nb_ovrn, &rate, &downlink_nb_msgs); \
 }
 
 
-#define PERIODIC_SEND_ATTITUDE(_chan) Downlink({ \
-      DOWNLINK_SEND_ATTITUDE(_chan, &estimator_phi, &estimator_psi, &estimator_theta); \
+#define PERIODIC_SEND_ATTITUDE(_trans, _dev) Downlink({ \
+      DOWNLINK_SEND_ATTITUDE(_trans, _dev, &estimator_phi, &estimator_psi, &estimator_theta); \
 })
 
-#define PERIODIC_SEND_PPRZ_MODE(_chan) DOWNLINK_SEND_PPRZ_MODE(_chan, &pprz_mode, &v_ctl_mode, &lateral_mode, &horizontal_mode, &rc_settings_mode, &mcu1_status);
-#define PERIODIC_SEND_DESIRED(_chan) DOWNLINK_SEND_DESIRED(_chan, &h_ctl_roll_setpoint, &h_ctl_pitch_loop_setpoint, &h_ctl_course_setpoint, &desired_x, &desired_y, &v_ctl_altitude_setpoint, &v_ctl_climb_setpoint);
+#define PERIODIC_SEND_PPRZ_MODE(_trans, _dev) DOWNLINK_SEND_PPRZ_MODE(_trans, _dev, &pprz_mode, &v_ctl_mode, &lateral_mode, &horizontal_mode, &rc_settings_mode, &mcu1_status);
+#define PERIODIC_SEND_DESIRED(_trans, _dev) DOWNLINK_SEND_DESIRED(_trans, _dev, &h_ctl_roll_setpoint, &h_ctl_pitch_loop_setpoint, &h_ctl_course_setpoint, &desired_x, &desired_y, &v_ctl_altitude_setpoint, &v_ctl_climb_setpoint);
 
 #ifdef USE_INFRARED
-#define PERIODIC_SEND_STATE_FILTER_STATUS(_chan) { uint16_t contrast = abs(infrared.roll) + abs(infrared.pitch) + abs(infrared.top); uint8_t mde = 3; if (contrast < 50) mde = 7; DOWNLINK_SEND_STATE_FILTER_STATUS(_chan, &mde, &contrast); }
+#define PERIODIC_SEND_STATE_FILTER_STATUS(_trans, _dev) { uint16_t contrast = abs(infrared.roll) + abs(infrared.pitch) + abs(infrared.top); uint8_t mde = 3; if (contrast < 50) mde = 7; DOWNLINK_SEND_STATE_FILTER_STATUS(_trans, _dev, &mde, &contrast); }
 #elif defined USE_IMU && defined USE_AHRS
-#define PERIODIC_SEND_STATE_FILTER_STATUS(_chan) { uint8_t mde = 3; if (ahrs.status == AHRS_UNINIT) mde = 2; if (ahrs_timeout_counter > 10) mde = 5; uint16_t val = 0; DOWNLINK_SEND_STATE_FILTER_STATUS(_chan, &mde, &val); }
+#define PERIODIC_SEND_STATE_FILTER_STATUS(_trans, _dev) { uint8_t mde = 3; if (ahrs.status == AHRS_UNINIT) mde = 2; if (ahrs_timeout_counter > 10) mde = 5; uint16_t val = 0; DOWNLINK_SEND_STATE_FILTER_STATUS(_trans, _dev, &mde, &val); }
 #else
-#define PERIODIC_SEND_STATE_FILTER_STATUS(_chan) {}
+#define PERIODIC_SEND_STATE_FILTER_STATUS(_trans, _dev) {}
 #endif
 
-#define PERIODIC_SEND_NAVIGATION_REF(_chan)  DOWNLINK_SEND_NAVIGATION_REF(_chan, &nav_utm_east0, &nav_utm_north0, &nav_utm_zone0);
+#define PERIODIC_SEND_NAVIGATION_REF(_trans, _dev)  DOWNLINK_SEND_NAVIGATION_REF(_trans, _dev, &nav_utm_east0, &nav_utm_north0, &nav_utm_zone0);
 
 
-#define DownlinkSendWp(_chan, i) {	     \
+#define DownlinkSendWp(_trans, _dev, i) {	     \
   float x = nav_utm_east0 +  waypoints[i].x; \
   float y = nav_utm_north0 + waypoints[i].y; \
-  DOWNLINK_SEND_WP_MOVED(_chan, &i, &x, &y, &(waypoints[i].a),&nav_utm_zone0); \
+  DOWNLINK_SEND_WP_MOVED(_trans, _dev, &i, &x, &y, &(waypoints[i].a),&nav_utm_zone0); \
 }
 
 
-#define PERIODIC_SEND_WP_MOVED(_chan) { \
+#define PERIODIC_SEND_WP_MOVED(_trans, _dev) { \
   static uint8_t i; \
   i++; if (i >= nb_waypoint) i = 0; \
-  DownlinkSendWp(_chan, i);	    \
+  DownlinkSendWp(_trans, _dev, i);	    \
 }
 
 #ifdef RADIO_CONTROL_SETTINGS
-#define PERIODIC_SEND_SETTINGS(_chan) if (!RcSettingsOff()) DOWNLINK_SEND_SETTINGS(_chan, &slider_1_val, &slider_2_val);
+#define PERIODIC_SEND_SETTINGS(_trans, _dev) if (!RcSettingsOff()) DOWNLINK_SEND_SETTINGS(_trans, _dev, &slider_1_val, &slider_2_val);
 #else
-#define PERIODIC_SEND_SETTINGS(_chan) {}
+#define PERIODIC_SEND_SETTINGS(_trans, _dev) {}
 #endif
 
 #if defined USE_INFRARED || USE_INFRARED_TELEMETRY
 #include "subsystems/sensors/infrared.h"
-#define PERIODIC_SEND_IR_SENSORS(_chan) DOWNLINK_SEND_IR_SENSORS(_chan, &infrared.value.ir1, &infrared.value.ir2, &infrared.pitch, &infrared.roll, &infrared.top);
+#define PERIODIC_SEND_IR_SENSORS(_trans, _dev) DOWNLINK_SEND_IR_SENSORS(_trans, _dev, &infrared.value.ir1, &infrared.value.ir2, &infrared.pitch, &infrared.roll, &infrared.top);
 #else
-#define PERIODIC_SEND_IR_SENSORS(_chan) ;
+#define PERIODIC_SEND_IR_SENSORS(_trans, _dev) ;
 #endif
 
-#define PERIODIC_SEND_ADC(_chan) {}
+#define PERIODIC_SEND_ADC(_trans, _dev) {}
 
 
-#define PERIODIC_SEND_CALIBRATION(_chan) DOWNLINK_SEND_CALIBRATION(_chan, &v_ctl_auto_throttle_sum_err, &v_ctl_auto_throttle_submode)
+#define PERIODIC_SEND_CALIBRATION(_trans, _dev) DOWNLINK_SEND_CALIBRATION(_trans, _dev, &v_ctl_auto_throttle_sum_err, &v_ctl_auto_throttle_submode)
 
-#define PERIODIC_SEND_CIRCLE(_chan) if (nav_in_circle) { DOWNLINK_SEND_CIRCLE(_chan, &nav_circle_x, &nav_circle_y, &nav_circle_radius); }
+#define PERIODIC_SEND_CIRCLE(_trans, _dev) if (nav_in_circle) { DOWNLINK_SEND_CIRCLE(_trans, _dev, &nav_circle_x, &nav_circle_y, &nav_circle_radius); }
 
-#define PERIODIC_SEND_SEGMENT(_chan) if (nav_in_segment) { DOWNLINK_SEND_SEGMENT(_chan, &nav_segment_x_1, &nav_segment_y_1, &nav_segment_x_2, &nav_segment_y_2); }
+#define PERIODIC_SEND_SEGMENT(_trans, _dev) if (nav_in_segment) { DOWNLINK_SEND_SEGMENT(_trans, _dev, &nav_segment_x_1, &nav_segment_y_1, &nav_segment_x_2, &nav_segment_y_2); }
 
 #ifdef IMU_TYPE_H
 #  ifdef INS_MODULE_H
 #  include "modules/ins/ins_module.h"
-#    define PERIODIC_SEND_IMU_ACCEL_RAW(_chan) {}
-#    define PERIODIC_SEND_IMU_GYRO_RAW(_chan) {}
-#    define PERIODIC_SEND_IMU_MAG_RAW(_chan) {}
-#    define PERIODIC_SEND_IMU_GYRO(_chan) { DOWNLINK_SEND_IMU_GYRO(_chan, &ins_p, &ins_q, &ins_r)}
-#    define PERIODIC_SEND_IMU_ACCEL(_chan) { DOWNLINK_SEND_IMU_ACCEL(_chan, &ins_ax, &ins_ay, &ins_az)}
-#    define PERIODIC_SEND_IMU_MAG(_chan) { DOWNLINK_SEND_IMU_MAG(_chan, &ins_mx, &ins_my, &ins_mz)}
+#    define PERIODIC_SEND_IMU_ACCEL_RAW(_trans, _dev) {}
+#    define PERIODIC_SEND_IMU_GYRO_RAW(_trans, _dev) {}
+#    define PERIODIC_SEND_IMU_MAG_RAW(_trans, _dev) {}
+#    define PERIODIC_SEND_IMU_GYRO(_trans, _dev) { DOWNLINK_SEND_IMU_GYRO(_trans, _dev, &ins_p, &ins_q, &ins_r)}
+#    define PERIODIC_SEND_IMU_ACCEL(_trans, _dev) { DOWNLINK_SEND_IMU_ACCEL(_trans, _dev, &ins_ax, &ins_ay, &ins_az)}
+#    define PERIODIC_SEND_IMU_MAG(_trans, _dev) { DOWNLINK_SEND_IMU_MAG(_trans, _dev, &ins_mx, &ins_my, &ins_mz)}
 #  else
 #    include "subsystems/imu.h"
-#    define PERIODIC_SEND_IMU_ACCEL_RAW(_chan) { DOWNLINK_SEND_IMU_ACCEL_RAW(_chan, &imu.accel_unscaled.x, &imu.accel_unscaled.y, &imu.accel_unscaled.z)}
-#    define PERIODIC_SEND_IMU_GYRO_RAW(_chan) { DOWNLINK_SEND_IMU_GYRO_RAW(_chan, &imu.gyro_unscaled.p, &imu.gyro_unscaled.q, &imu.gyro_unscaled.r)}
-#    define PERIODIC_SEND_IMU_MAG_RAW(_chan) { DOWNLINK_SEND_IMU_MAG_RAW(_chan, &imu.mag_unscaled.x, &imu.mag_unscaled.y, &imu.mag_unscaled.z)}
-#    define PERIODIC_SEND_IMU_ACCEL(_chan) { struct FloatVect3 accel_float; ACCELS_FLOAT_OF_BFP(accel_float, imu.accel); DOWNLINK_SEND_IMU_ACCEL(_chan, &accel_float.x, &accel_float.y, &accel_float.z)}
-#    define PERIODIC_SEND_IMU_GYRO(_chan) { struct FloatRates gyro_float; RATES_FLOAT_OF_BFP(gyro_float, imu.gyro); DOWNLINK_SEND_IMU_GYRO(_chan, &gyro_float.p, &gyro_float.q, &gyro_float.r)}
+#    define PERIODIC_SEND_IMU_ACCEL_RAW(_trans, _dev) { DOWNLINK_SEND_IMU_ACCEL_RAW(_trans, _dev, &imu.accel_unscaled.x, &imu.accel_unscaled.y, &imu.accel_unscaled.z)}
+#    define PERIODIC_SEND_IMU_GYRO_RAW(_trans, _dev) { DOWNLINK_SEND_IMU_GYRO_RAW(_trans, _dev, &imu.gyro_unscaled.p, &imu.gyro_unscaled.q, &imu.gyro_unscaled.r)}
+#    define PERIODIC_SEND_IMU_MAG_RAW(_trans, _dev) { DOWNLINK_SEND_IMU_MAG_RAW(_trans, _dev, &imu.mag_unscaled.x, &imu.mag_unscaled.y, &imu.mag_unscaled.z)}
+#    define PERIODIC_SEND_IMU_ACCEL(_trans, _dev) { struct FloatVect3 accel_float; ACCELS_FLOAT_OF_BFP(accel_float, imu.accel); DOWNLINK_SEND_IMU_ACCEL(_trans, _dev, &accel_float.x, &accel_float.y, &accel_float.z)}
+#    define PERIODIC_SEND_IMU_GYRO(_trans, _dev) { struct FloatRates gyro_float; RATES_FLOAT_OF_BFP(gyro_float, imu.gyro); DOWNLINK_SEND_IMU_GYRO(_trans, _dev, &gyro_float.p, &gyro_float.q, &gyro_float.r)}
 #    ifdef USE_MAGNETOMETER
-#      define PERIODIC_SEND_IMU_MAG(_chan) { struct FloatVect3 mag_float; MAGS_FLOAT_OF_BFP(mag_float, imu.mag); DOWNLINK_SEND_IMU_MAG(_chan, &mag_float.x, &mag_float.y, &mag_float.z)}
+#      define PERIODIC_SEND_IMU_MAG(_trans, _dev) { struct FloatVect3 mag_float; MAGS_FLOAT_OF_BFP(mag_float, imu.mag); DOWNLINK_SEND_IMU_MAG(_trans, _dev, &mag_float.x, &mag_float.y, &mag_float.z)}
 #    else
-#      define PERIODIC_SEND_IMU_MAG(_chan) {}
+#      define PERIODIC_SEND_IMU_MAG(_trans, _dev) {}
 #    endif
 #  endif
 #else
-#    define PERIODIC_SEND_IMU_ACCEL_RAW(_chan) {}
-#    define PERIODIC_SEND_IMU_GYRO_RAW(_chan) {}
-#    define PERIODIC_SEND_IMU_MAG_RAW(_chan) {}
-#    define PERIODIC_SEND_IMU_ACCEL(_chan) {}
-#    define PERIODIC_SEND_IMU_GYRO(_chan) {}
-#    define PERIODIC_SEND_IMU_MAG(_chan) {}
+#    define PERIODIC_SEND_IMU_ACCEL_RAW(_trans, _dev) {}
+#    define PERIODIC_SEND_IMU_GYRO_RAW(_trans, _dev) {}
+#    define PERIODIC_SEND_IMU_MAG_RAW(_trans, _dev) {}
+#    define PERIODIC_SEND_IMU_ACCEL(_trans, _dev) {}
+#    define PERIODIC_SEND_IMU_GYRO(_trans, _dev) {}
+#    define PERIODIC_SEND_IMU_MAG(_trans, _dev) {}
 #endif
 
 #ifdef IMU_ANALOG
-#define PERIODIC_SEND_IMU(_chan) { int16_t dummy = 42; DOWNLINK_SEND_IMU(_chan, &(from_fbw.euler_dot[0]), &(from_fbw.euler_dot[1]), &(from_fbw.euler_dot[2]), &dummy, &dummy, &dummy); }
+#define PERIODIC_SEND_IMU(_trans, _dev) { int16_t dummy = 42; DOWNLINK_SEND_IMU(_trans, _dev, &(from_fbw.euler_dot[0]), &(from_fbw.euler_dot[1]), &(from_fbw.euler_dot[2]), &dummy, &dummy, &dummy); }
 #else
-#define PERIODIC_SEND_IMU(_chan) {}
+#define PERIODIC_SEND_IMU(_trans, _dev) {}
 #endif
 
-#define PERIODIC_SEND_ESTIMATOR(_chan) DOWNLINK_SEND_ESTIMATOR(_chan, &estimator_z, &estimator_z_dot)
+#define PERIODIC_SEND_ESTIMATOR(_trans, _dev) DOWNLINK_SEND_ESTIMATOR(_trans, _dev, &estimator_z, &estimator_z_dot)
 
-#define SEND_NAVIGATION(_chan) Downlink({ uint8_t _circle_count = NavCircleCount(); DOWNLINK_SEND_NAVIGATION(_chan, &nav_block, &nav_stage, &estimator_x, &estimator_y, &dist2_to_wp, &dist2_to_home, &_circle_count, &nav_oval_count);})
+#define SEND_NAVIGATION(_trans, _dev) Downlink({ uint8_t _circle_count = NavCircleCount(); DOWNLINK_SEND_NAVIGATION(_trans, _dev, &nav_block, &nav_stage, &estimator_x, &estimator_y, &dist2_to_wp, &dist2_to_home, &_circle_count, &nav_oval_count);})
 
-#define PERIODIC_SEND_NAVIGATION(_chan) SEND_NAVIGATION(_chan)
+#define PERIODIC_SEND_NAVIGATION(_trans, _dev) SEND_NAVIGATION(_trans, _dev)
 
 
 #if defined CAM || defined MOBILE_CAM
-#define SEND_CAM(_chan) Downlink({ int16_t x = cam_target_x; int16_t y = cam_target_y; int16_t phi = DegOfRad(cam_phi_c); int16_t theta = DegOfRad(cam_theta_c); DOWNLINK_SEND_CAM(_chan, &phi, &theta, &x, &y);})
-#define PERIODIC_SEND_CAM_POINT(_chan) DOWNLINK_SEND_CAM_POINT(_chan, &cam_point_distance_from_home, &cam_point_lat, &cam_point_lon)
+#define SEND_CAM(_trans, _dev) Downlink({ int16_t x = cam_target_x; int16_t y = cam_target_y; int16_t phi = DegOfRad(cam_phi_c); int16_t theta = DegOfRad(cam_theta_c); DOWNLINK_SEND_CAM(_trans, _dev, &phi, &theta, &x, &y);})
+#define PERIODIC_SEND_CAM_POINT(_trans, _dev) DOWNLINK_SEND_CAM_POINT(_trans, _dev, &cam_point_distance_from_home, &cam_point_lat, &cam_point_lon)
 #else
-#define SEND_CAM(_chan) {}
-#define PERIODIC_SEND_CAM_POINT(_chan) {}
+#define SEND_CAM(_trans, _dev) {}
+#define PERIODIC_SEND_CAM_POINT(_trans, _dev) {}
 #endif
 
-#define PERIODIC_SEND_DL_VALUE(_chan) PeriodicSendDlValue(_chan) /** generated from the xml settings config in conf/settings */
+#define PERIODIC_SEND_DL_VALUE(_trans, _dev) PeriodicSendDlValue(_trans, _dev) /** generated from the xml settings config in conf/settings */
 
-#define PERIODIC_SEND_SURVEY(_chan) { \
+#define PERIODIC_SEND_SURVEY(_trans, _dev) { \
   if (nav_survey_active) \
-    DOWNLINK_SEND_SURVEY(_chan, &nav_survey_east, &nav_survey_north, &nav_survey_west, &nav_survey_south); \
+    DOWNLINK_SEND_SURVEY(_trans, _dev, &nav_survey_east, &nav_survey_north, &nav_survey_west, &nav_survey_south); \
   }
 
-#define PERIODIC_SEND_RANGEFINDER(_chan) DOWNLINK_SEND_RANGEFINDER(_chan, &rangemeter, &ctl_grz_z_dot, &ctl_grz_z_dot_sum_err, &ctl_grz_z_dot_setpoint, &ctl_grz_z_sum_err, &ctl_grz_z_setpoint, &flying)
+#define PERIODIC_SEND_RANGEFINDER(_trans, _dev) DOWNLINK_SEND_RANGEFINDER(_trans, _dev, &rangemeter, &ctl_grz_z_dot, &ctl_grz_z_dot_sum_err, &ctl_grz_z_dot_setpoint, &ctl_grz_z_sum_err, &ctl_grz_z_setpoint, &flying)
 
-#define PERIODIC_SEND_TUNE_ROLL(_chan) DOWNLINK_SEND_TUNE_ROLL(_chan, &estimator_p,&estimator_phi, &h_ctl_roll_setpoint);
+#define PERIODIC_SEND_TUNE_ROLL(_trans, _dev) DOWNLINK_SEND_TUNE_ROLL(_trans, _dev, &estimator_p,&estimator_phi, &h_ctl_roll_setpoint);
 
 #if defined USE_GPS || defined SITL || defined USE_GPS_XSENS
-#define PERIODIC_SEND_GPS_SOL(_chan) DOWNLINK_SEND_GPS_SOL(_chan, &gps.pacc, &gps.sacc, &gps.pdop, &gps.num_sv)
+#define PERIODIC_SEND_GPS_SOL(_trans, _dev) DOWNLINK_SEND_GPS_SOL(_trans, _dev, &gps.pacc, &gps.sacc, &gps.pdop, &gps.num_sv)
 #endif
 
-#define PERIODIC_SEND_GPS(_chan) {                                      \
+#define PERIODIC_SEND_GPS(_trans, _dev) {                                      \
     static uint8_t i;                                                   \
     int16_t climb = -gps.ned_vel.z;                                     \
     int16_t course = (DegOfRad(gps.course)/((int32_t)1e6));             \
-    DOWNLINK_SEND_GPS(DefaultChannel, &gps.fix, &gps.utm_pos.east, &gps.utm_pos.north, &course, &gps.hmsl, &gps.gspeed, &climb, &gps.week, &gps.tow, &gps.utm_pos.zone, &i); \
+    DOWNLINK_SEND_GPS(_trans, _dev, &gps.fix, &gps.utm_pos.east, &gps.utm_pos.north, &course, &gps.hmsl, &gps.gspeed, &climb, &gps.week, &gps.tow, &gps.utm_pos.zone, &i); \
     if ((gps.fix != GPS_FIX_3D) && (i >= gps.nb_channels)) i = 0;                                    \
     if (i >= gps.nb_channels * 2) i = 0;                                    \
     if (i < gps.nb_channels && gps.svinfos[i].cno > 0) { \
-      DOWNLINK_SEND_SVINFO(DefaultChannel, &i, &gps.svinfos[i].svid, &gps.svinfos[i].flags, &gps.svinfos[i].qi, &gps.svinfos[i].cno, &gps.svinfos[i].elev, &gps.svinfos[i].azim); \
+      DOWNLINK_SEND_SVINFO(_trans, _dev, &i, &gps.svinfos[i].svid, &gps.svinfos[i].flags, &gps.svinfos[i].qi, &gps.svinfos[i].cno, &gps.svinfos[i].elev, &gps.svinfos[i].azim); \
     }                                                                   \
     i++;                                                                \
 }
 
 #ifdef USE_BARO_MS5534A
 //#include "baro_MS5534A.h"
-#define PERIODIC_SEND_BARO_MS5534A(_chan) DOWNLINK_SEND_BARO_MS5534A(_chan, &baro_MS5534A_pressure, &baro_MS5534A_temp, &baro_MS5534A_z)
+#define PERIODIC_SEND_BARO_MS5534A(_trans, _dev) DOWNLINK_SEND_BARO_MS5534A(_trans, _dev, &baro_MS5534A_pressure, &baro_MS5534A_temp, &baro_MS5534A_z)
 #else
-#define PERIODIC_SEND_BARO_MS5534A(_chan) {}
+#define PERIODIC_SEND_BARO_MS5534A(_trans, _dev) {}
 #endif
 
 #ifdef USE_BARO_SCP
 #include "baro_scp.h"
-#define PERIODIC_SEND_SCP_STATUS(_chan) DOWNLINK_SEND_SCP_STATUS(_chan, &baro_scp_pressure, &baro_scp_temperature)
+#define PERIODIC_SEND_SCP_STATUS(_trans, _dev) DOWNLINK_SEND_SCP_STATUS(_trans, _dev, &baro_scp_pressure, &baro_scp_temperature)
 #else
-#define PERIODIC_SEND_SCP_STATUS(_chan) {}
+#define PERIODIC_SEND_SCP_STATUS(_trans, _dev) {}
 #endif
 
 #ifdef MEASURE_AIRSPEED
-#define PERIODIC_SEND_AIRSPEED(_chan) DOWNLINK_SEND_AIRSPEED (_chan, &estimator_airspeed, &estimator_airspeed, &estimator_airspeed, &estimator_airspeed)
+#define PERIODIC_SEND_AIRSPEED(_trans, _dev) DOWNLINK_SEND_AIRSPEED (_trans, _dev, &estimator_airspeed, &estimator_airspeed, &estimator_airspeed, &estimator_airspeed)
 #elif defined USE_AIRSPEED
-#define PERIODIC_SEND_AIRSPEED(_chan) DOWNLINK_SEND_AIRSPEED (_chan, &estimator_airspeed, &v_ctl_auto_airspeed_setpoint, &v_ctl_auto_airspeed_controlled, &v_ctl_auto_groundspeed_setpoint)
+#define PERIODIC_SEND_AIRSPEED(_trans, _dev) DOWNLINK_SEND_AIRSPEED (_trans, _dev, &estimator_airspeed, &v_ctl_auto_airspeed_setpoint, &v_ctl_auto_airspeed_controlled, &v_ctl_auto_groundspeed_setpoint)
 #else
-#define PERIODIC_SEND_AIRSPEED(_chan) {}
+#define PERIODIC_SEND_AIRSPEED(_trans, _dev) {}
 #endif
 
-#define PERIODIC_SEND_ENERGY(_chan) Downlink({ const int16_t e = energy; const float vsup = ((float)vsupply) / 10.0f; const float curs = ((float) current)/1000.0f;  const float power = vsup * curs; DOWNLINK_SEND_ENERGY(_chan, &vsup, &curs, &e, &power); })
+#define PERIODIC_SEND_ENERGY(_trans, _dev) Downlink({ const int16_t e = energy; const float vsup = ((float)vsupply) / 10.0f; const float curs = ((float) current)/1000.0f;  const float power = vsup * curs; DOWNLINK_SEND_ENERGY(_trans, _dev, &vsup, &curs, &e, &power); })
 
 
 #include "firmwares/fixedwing/stabilization/stabilization_adaptive.h"
-#define PERIODIC_SEND_H_CTL_A(_chan) DOWNLINK_SEND_H_CTL_A(_chan, &h_ctl_roll_sum_err, &h_ctl_ref_roll_angle, &h_ctl_pitch_sum_err, &h_ctl_ref_pitch_angle)
+#define PERIODIC_SEND_H_CTL_A(_trans, _dev) DOWNLINK_SEND_H_CTL_A(_trans, _dev, &h_ctl_roll_sum_err, &h_ctl_ref_roll_angle, &h_ctl_pitch_sum_err, &h_ctl_ref_pitch_angle)
 
 
 #endif /* AP_DOWNLINK_H */
diff --git a/sw/airborne/firmwares/fixedwing/datalink.c b/sw/airborne/firmwares/fixedwing/datalink.c
index f7c8b9da7e..1706420de3 100644
--- a/sw/airborne/firmwares/fixedwing/datalink.c
+++ b/sw/airborne/firmwares/fixedwing/datalink.c
@@ -93,7 +93,7 @@ void dl_parse_msg(void) {
 #endif
 
   if (msg_id == DL_PING) {
-    DOWNLINK_SEND_PONG(DefaultChannel);
+    DOWNLINK_SEND_PONG(DefaultChannel, DefaultDevice)
   } else
 #ifdef TRAFFIC_INFO
   if (msg_id == DL_ACINFO && DL_ACINFO_ac_id(dl_buffer) != AC_ID) {
@@ -126,10 +126,10 @@ void dl_parse_msg(void) {
        coordinates */
     utm.east = waypoints[wp_id].x + nav_utm_east0;
     utm.north = waypoints[wp_id].y + nav_utm_north0;
-    DOWNLINK_SEND_WP_MOVED(DefaultChannel, &wp_id, &utm.east, &utm.north, &a, &nav_utm_zone0);
+    DOWNLINK_SEND_WP_MOVED(DefaultChannel, DefaultDevice, &wp_id, &utm.east, &utm.north, &a, &nav_utm_zone0);
   } else if (msg_id == DL_BLOCK && DL_BLOCK_ac_id(dl_buffer) == AC_ID) {
     nav_goto_block(DL_BLOCK_block_id(dl_buffer));
-    SEND_NAVIGATION(DefaultChannel);
+    SEND_NAVIGATION(DefaultChannel, DefaultDevice);
   } else
 #endif /** NAV */
 #ifdef WIND_INFO
@@ -140,7 +140,7 @@ void dl_parse_msg(void) {
     estimator_airspeed = DL_WIND_INFO_airspeed(dl_buffer);
 #endif
 #ifdef WIND_INFO_RET
-    DOWNLINK_SEND_WIND_INFO_RET(DefaultChannel, &wind_east, &wind_north, &estimator_airspeed);
+    DOWNLINK_SEND_WIND_INFO_RET(DefaultChannel, DefaultDevice, &wind_east, &wind_north, &estimator_airspeed);
 #endif
   } else
 #endif /** WIND_INFO */
@@ -171,11 +171,11 @@ void dl_parse_msg(void) {
     uint8_t i = DL_SETTING_index(dl_buffer);
     float val = DL_SETTING_value(dl_buffer);
     DlSetting(i, val);
-    DOWNLINK_SEND_DL_VALUE(DefaultChannel, &i, &val);
+    DOWNLINK_SEND_DL_VALUE(DefaultChannel, DefaultDevice, &i, &val);
   } else if (msg_id == DL_GET_SETTING && DL_GET_SETTING_ac_id(dl_buffer) == AC_ID) {
     uint8_t i = DL_GET_SETTING_index(dl_buffer);
     float val = settings_get_value(i);
-    DOWNLINK_SEND_DL_VALUE(DefaultChannel, &i, &val);
+    DOWNLINK_SEND_DL_VALUE(DefaultChannel, DefaultDevice, &i, &val);
   } else
 #endif /** Else there is no dl_settings section in the flight plan */
 #ifdef USE_JOYSTICK
diff --git a/sw/airborne/firmwares/fixedwing/fbw_downlink.h b/sw/airborne/firmwares/fixedwing/fbw_downlink.h
index 994ff03ca1..7dc51984d7 100644
--- a/sw/airborne/firmwares/fixedwing/fbw_downlink.h
+++ b/sw/airborne/firmwares/fixedwing/fbw_downlink.h
@@ -58,41 +58,41 @@
 extern uint8_t telemetry_mode_Fbw_DefaultChannel;
 #endif
 
-#define PERIODIC_SEND_COMMANDS(_chan) DOWNLINK_SEND_COMMANDS(_chan, COMMANDS_NB, commands)
+#define PERIODIC_SEND_COMMANDS(_trans, _dev) DOWNLINK_SEND_COMMANDS(_trans, _dev, COMMANDS_NB, commands)
 
 #ifdef RADIO_CONTROL
-#define PERIODIC_SEND_FBW_STATUS(_chan) DOWNLINK_SEND_FBW_STATUS(_chan, &(radio_control.status), &(radio_control.frame_rate), &fbw_mode, &electrical.vsupply, &electrical.current)
+#define PERIODIC_SEND_FBW_STATUS(_trans, _dev) DOWNLINK_SEND_FBW_STATUS(_trans, _dev, &(radio_control.status), &(radio_control.frame_rate), &fbw_mode, &electrical.vsupply, &electrical.current)
 #ifdef RADIO_CONTROL_TYPE_PPM
-#define PERIODIC_SEND_PPM(_chan) DOWNLINK_SEND_PPM(_chan, &(radio_control.frame_rate), PPM_NB_CHANNEL, ppm_pulses)
+#define PERIODIC_SEND_PPM(_trans, _dev) DOWNLINK_SEND_PPM(_trans, _dev, &(radio_control.frame_rate), PPM_NB_CHANNEL, ppm_pulses)
 #else
-#define PERIODIC_SEND_PPM(_chan) {}
+#define PERIODIC_SEND_PPM(_trans, _dev) {}
 #endif
-#define PERIODIC_SEND_RC(_chan) DOWNLINK_SEND_RC(_chan, RADIO_CONTROL_NB_CHANNEL, radio_control.values)
+#define PERIODIC_SEND_RC(_trans, _dev) DOWNLINK_SEND_RC(_trans, _dev, RADIO_CONTROL_NB_CHANNEL, radio_control.values)
 #else // RADIO_CONTROL
-#define PERIODIC_SEND_FBW_STATUS(_chan) { uint8_t dummy = 0; DOWNLINK_SEND_FBW_STATUS(_chan, &dummy, &dummy, &fbw_mode, &electrical.vsupply, &electrical.current); }
-#define PERIODIC_SEND_PPM(_chan) {}
-#define PERIODIC_SEND_RC(_chan) {}
+#define PERIODIC_SEND_FBW_STATUS(_trans, _dev) { uint8_t dummy = 0; DOWNLINK_SEND_FBW_STATUS(_trans, _dev, &dummy, &dummy, &fbw_mode, &electrical.vsupply, &electrical.current); }
+#define PERIODIC_SEND_PPM(_trans, _dev) {}
+#define PERIODIC_SEND_RC(_trans, _dev) {}
 #endif // RADIO_CONTROL
 
 #ifdef ACTUATORS
-#define PERIODIC_SEND_ACTUATORS(_chan) DOWNLINK_SEND_ACTUATORS(_chan, SERVOS_NB, actuators)
+#define PERIODIC_SEND_ACTUATORS(_trans, _dev) DOWNLINK_SEND_ACTUATORS(_trans, _dev, SERVOS_NB, actuators)
 #else
-#define PERIODIC_SEND_ACTUATORS(_chan) {}
+#define PERIODIC_SEND_ACTUATORS(_trans, _dev) {}
 #endif
 
 #ifdef BRICOLAGE_ADC
 extern uint16_t adc0_val[];
 
-#define PERIODIC_SEND_ADC(_chan) {			\
+#define PERIODIC_SEND_ADC(_trans, _dev) {			\
     static const uint8_t mcu = 0;			\
-    DOWNLINK_SEND_ADC(_chan, &mcu, 8, adc0_val);	\
+    DOWNLINK_SEND_ADC(_trans, _dev, &mcu, 8, adc0_val);	\
   }
 #else
-#define PERIODIC_SEND_ADC(_chan) {}
+#define PERIODIC_SEND_ADC(_trans, _dev) {}
 #endif
 
 static inline void fbw_downlink_periodic_task(void) {
-  PeriodicSendFbw(DefaultChannel)
+  PeriodicSendFbw(DefaultChannel,DefaultDevice)
 }
 
 
diff --git a/sw/airborne/firmwares/fixedwing/main_ap.c b/sw/airborne/firmwares/fixedwing/main_ap.c
index 109ea0c5cc..f66ef7202c 100644
--- a/sw/airborne/firmwares/fixedwing/main_ap.c
+++ b/sw/airborne/firmwares/fixedwing/main_ap.c
@@ -196,12 +196,12 @@ static inline void reporting_task( void ) {
 
   /** initialisation phase during boot */
   if (boot) {
-    DOWNLINK_SEND_BOOT(DefaultChannel, &version);
+    DOWNLINK_SEND_BOOT(DefaultChannel, DefaultDevice, &version);
     boot = FALSE;
   }
   /** then report periodicly */
   else {
-    PeriodicSendAp(DefaultChannel);
+    PeriodicSendAp(DefaultChannel, DefaultDevice);
   }
 }
 
@@ -236,7 +236,7 @@ static inline void telecommand_task( void ) {
   }
   mode_changed |= mcu1_status_update();
   if ( mode_changed )
-    PERIODIC_SEND_PPRZ_MODE(DefaultChannel);
+    PERIODIC_SEND_PPRZ_MODE(DefaultChannel, DefaultDevice);
 
 #if defined RADIO_CONTROL || defined RADIO_CONTROL_AUTO1
   /** In AUTO1 mode, compute roll setpoint and pitch setpoint from
@@ -293,7 +293,7 @@ static void navigation_task( void ) {
       if (pprz_mode == PPRZ_MODE_AUTO2 || pprz_mode == PPRZ_MODE_HOME) {
         last_pprz_mode = pprz_mode;
         pprz_mode = PPRZ_MODE_GPS_OUT_OF_ORDER;
-        PERIODIC_SEND_PPRZ_MODE(DefaultChannel);
+        PERIODIC_SEND_PPRZ_MODE(DefaultChannel, DefaultDevice);
         gps_lost = TRUE;
       }
     } else if (gps_lost) { /* GPS is ok */
@@ -301,7 +301,7 @@ static void navigation_task( void ) {
       pprz_mode = last_pprz_mode;
       gps_lost = FALSE;
 
-      PERIODIC_SEND_PPRZ_MODE(DefaultChannel);
+      PERIODIC_SEND_PPRZ_MODE(DefaultChannel, DefaultDevice);
     }
   }
 #endif /* GPS && FAILSAFE_DELAY_WITHOUT_GPS */
@@ -319,10 +319,10 @@ static void navigation_task( void ) {
 #endif
 
 #ifndef PERIOD_NAVIGATION_DefaultChannel_0 // If not sent periodically (in default 0 mode)
-  SEND_NAVIGATION(DefaultChannel);
+  SEND_NAVIGATION(DefaultChannel, DefaultDevice);
 #endif
 
-  SEND_CAM(DefaultChannel);
+  SEND_CAM(DefaultChannel, DefaultDevice);
 
   /* The nav task computes only nav_altitude. However, we are interested
      by desired_altitude (= nav_alt+alt_shift) in any case.
@@ -478,9 +478,6 @@ void periodic_task_ap( void ) {
   switch(_4Hz) {
   case 0:
     estimator_propagate_state();
-#ifdef EXTRA_DOWNLINK_DEVICE
-    DOWNLINK_SEND_ATTITUDE(ExtraPprzTransport,&estimator_phi,&estimator_psi,&estimator_theta);
-#endif
     navigation_task();
     break;
   case 1:
@@ -488,7 +485,7 @@ void periodic_task_ap( void ) {
         estimator_hspeed_mod > MIN_SPEED_FOR_TAKEOFF) {
       estimator_flight_time = 1;
       launch = TRUE; /* Not set in non auto launch */
-      DOWNLINK_SEND_TAKEOFF(DefaultChannel, &cpu_time_sec);
+      DOWNLINK_SEND_TAKEOFF(DefaultChannel, DefaultDevice, &cpu_time_sec);
   default:
     break;
     }
diff --git a/sw/airborne/firmwares/motor_bench/main_motor_bench.c b/sw/airborne/firmwares/motor_bench/main_motor_bench.c
index 013f661632..814bb443e0 100644
--- a/sw/airborne/firmwares/motor_bench/main_motor_bench.c
+++ b/sw/airborne/firmwares/motor_bench/main_motor_bench.c
@@ -80,10 +80,10 @@ static inline void main_periodic_task( void ) {
 
 
   RunOnceEvery(125, {
-      DOWNLINK_SEND_ALIVE(DefaultChannel, 16, MD5SUM);
+      DOWNLINK_SEND_ALIVE(DefaultChannel, DefaultDevice, 16, MD5SUM);
       PeriodicSendDlValue(DefaultChannel);
     });
-  DOWNLINK_SEND_MOTOR_BENCH_STATUS(DefaultChannel, &cpu_time_ticks, &throttle, &rpm, &amps , &thrust, &torque, &cpu_time_sec, &mb_modes_mode);
+  DOWNLINK_SEND_MOTOR_BENCH_STATUS(DefaultChannel, DefaultDevice, &cpu_time_ticks, &throttle, &rpm, &amps , &thrust, &torque, &cpu_time_sec, &mb_modes_mode);
 
 
 
@@ -120,6 +120,6 @@ static inline void main_dl_parse_msg(void) {
     uint8_t i = DL_SETTING_index(dl_buffer);
     float var = DL_SETTING_value(dl_buffer);
     DlSetting(i, var);
-    DOWNLINK_SEND_DL_VALUE(DefaultChannel, &i, &var);
+    DOWNLINK_SEND_DL_VALUE(DefaultChannel, DefaultDevice, &i, &var);
   }
 }
diff --git a/sw/airborne/firmwares/motor_bench/main_turntable.c b/sw/airborne/firmwares/motor_bench/main_turntable.c
index a6570ef8c2..2e00fd91cd 100644
--- a/sw/airborne/firmwares/motor_bench/main_turntable.c
+++ b/sw/airborne/firmwares/motor_bench/main_turntable.c
@@ -46,11 +46,11 @@ static inline void main_periodic( void ) {
   RunOnceEvery(50, {
       const float tach_to_rpm = 15000000.*2*M_PI/(float)NB_STEP;
       omega_rad = tach_to_rpm / lp_pulse;
-      DOWNLINK_SEND_IMU_TURNTABLE(DefaultChannel, &omega_rad);}
+      DOWNLINK_SEND_IMU_TURNTABLE(DefaultChannel, DefaultDevice, &omega_rad);}
       //      float foo = nb_pulse;
-      //      DOWNLINK_SEND_IMU_TURNTABLE(DefaultChannel, &foo);}
+      //      DOWNLINK_SEND_IMU_TURNTABLE(DefaultChannel, DefaultDevice, &foo);}
     );
-  RunOnceEvery(100, {DOWNLINK_SEND_ALIVE(DefaultChannel,  16, MD5SUM);});
+  RunOnceEvery(100, {DOWNLINK_SEND_ALIVE(DefaultChannel, DefaultDevice,  16, MD5SUM);});
 
 }
 
diff --git a/sw/airborne/firmwares/rotorcraft/datalink.c b/sw/airborne/firmwares/rotorcraft/datalink.c
index 22cce600a3..931663c427 100644
--- a/sw/airborne/firmwares/rotorcraft/datalink.c
+++ b/sw/airborne/firmwares/rotorcraft/datalink.c
@@ -54,7 +54,7 @@ void dl_parse_msg(void) {
 
   case  DL_PING:
     {
-      DOWNLINK_SEND_PONG(DefaultChannel);
+      DOWNLINK_SEND_PONG(DefaultChannel, DefaultDevice);
     }
     break;
 
@@ -64,7 +64,7 @@ void dl_parse_msg(void) {
       uint8_t i = DL_SETTING_index(dl_buffer);
       float var = DL_SETTING_value(dl_buffer);
       DlSetting(i, var);
-      DOWNLINK_SEND_DL_VALUE(DefaultChannel, &i, &var);
+      DOWNLINK_SEND_DL_VALUE(DefaultChannel, DefaultDevice, &i, &var);
     }
     break;
 
@@ -73,7 +73,7 @@ void dl_parse_msg(void) {
       if (DL_GET_SETTING_ac_id(dl_buffer) != AC_ID) break;
       uint8_t i = DL_GET_SETTING_index(dl_buffer);
       float val = settings_get_value(i);
-      DOWNLINK_SEND_DL_VALUE(DefaultChannel, &i, &val);
+      DOWNLINK_SEND_DL_VALUE(DefaultChannel, DefaultDevice, &i, &val);
     }
     break;
 
@@ -101,7 +101,7 @@ void dl_parse_msg(void) {
       enu.y = POS_BFP_OF_REAL(enu.y)/100;
       enu.z = POS_BFP_OF_REAL(enu.z)/100;
       VECT3_ASSIGN(waypoints[wp_id], enu.x, enu.y, enu.z);
-      DOWNLINK_SEND_WP_MOVED_ENU(DefaultChannel, &wp_id, &enu.x, &enu.y, &enu.z);
+      DOWNLINK_SEND_WP_MOVED_ENU(DefaultChannel, DefaultDevice, &wp_id, &enu.x, &enu.y, &enu.z);
     }
     break;
 #endif /* USE_NAVIGATION */
diff --git a/sw/airborne/firmwares/rotorcraft/navigation.c b/sw/airborne/firmwares/rotorcraft/navigation.c
index 7286260d91..580b03f462 100644
--- a/sw/airborne/firmwares/rotorcraft/navigation.c
+++ b/sw/airborne/firmwares/rotorcraft/navigation.c
@@ -289,7 +289,7 @@ void nav_periodic_task() {
 void nav_move_waypoint(uint8_t wp_id, struct EnuCoor_i * new_pos) {
   if (wp_id < nb_waypoint) {
     INT32_VECT3_COPY(waypoints[wp_id],(*new_pos));
-    DOWNLINK_SEND_WP_MOVED_ENU(DefaultChannel, &wp_id, &(new_pos->x), &(new_pos->y), &(new_pos->z));
+    DOWNLINK_SEND_WP_MOVED_ENU(DefaultChannel, DefaultDevice, &wp_id, &(new_pos->x), &(new_pos->y), &(new_pos->z));
   }
 }
 
@@ -310,7 +310,7 @@ void navigation_update_wp_from_speed(uint8_t wp, struct Int16Vect3 speed_sp, int
   nav_heading += delta_heading;
 
   INT32_COURSE_NORMALIZE(nav_heading);
-  RunOnceEvery(10,DOWNLINK_SEND_WP_MOVED_ENU(DefaultChannel, &wp, &(waypoints[wp].x), &(waypoints[wp].y), &(waypoints[wp].z)));
+  RunOnceEvery(10,DOWNLINK_SEND_WP_MOVED_ENU(DefaultChannel, DefaultDevice, &wp, &(waypoints[wp].x), &(waypoints[wp].y), &(waypoints[wp].z)));
 }
 
 bool_t nav_detect_ground(void) {
diff --git a/sw/airborne/firmwares/rotorcraft/telemetry.h b/sw/airborne/firmwares/rotorcraft/telemetry.h
index c37d025452..2347d2acd0 100644
--- a/sw/airborne/firmwares/rotorcraft/telemetry.h
+++ b/sw/airborne/firmwares/rotorcraft/telemetry.h
@@ -682,7 +682,7 @@ extern uint8_t telemetry_mode_Main_DefaultChannel;
     static uint8_t last_cnos[GPS_NB_CHANNELS];      \
     if (i == gps.nb_channels) i = 0;                \
     if (i < gps.nb_channels && gps.svinfos[i].cno > 0 && gps.svinfos[i].cno != last_cnos[i]) { \
-      DOWNLINK_SEND_SVINFO(DefaultChannel, &i, &gps.svinfos[i].svid, &gps.svinfos[i].flags, &gps.svinfos[i].qi, &gps.svinfos[i].cno, &gps.svinfos[i].elev, &gps.svinfos[i].azim); \
+      DOWNLINK_SEND_SVINFO(DefaultChannel, DefaultDevice, &i, &gps.svinfos[i].svid, &gps.svinfos[i].flags, &gps.svinfos[i].qi, &gps.svinfos[i].cno, &gps.svinfos[i].elev, &gps.svinfos[i].azim); \
       last_cnos[i] = gps.svinfos[i].cno;                                \
     }                                                                   \
     i++;                                                                \
diff --git a/sw/airborne/firmwares/setup/setup_actuators.c b/sw/airborne/firmwares/setup/setup_actuators.c
index b4aa95af75..0d73eb8007 100644
--- a/sw/airborne/firmwares/setup/setup_actuators.c
+++ b/sw/airborne/firmwares/setup/setup_actuators.c
@@ -35,11 +35,11 @@ void dl_parse_msg( void ) {
     for (int j=0 ; j<8 ; j++) {
       SetServo(j,actuators[j]);
     }
-    DOWNLINK_SEND_DL_VALUE(DefaultChannel, &i, &val);
+    DOWNLINK_SEND_DL_VALUE(DefaultChannel, DefaultDevice, &i, &val);
   } else if (msg_id == DL_GET_SETTING && DL_GET_SETTING_ac_id(dl_buffer) == AC_ID) {
     uint8_t i = DL_GET_SETTING_index(dl_buffer);
     float val = settings_get_value(i);
-    DOWNLINK_SEND_DL_VALUE(DefaultChannel, &i, &val);
+    DOWNLINK_SEND_DL_VALUE(DefaultChannel, DefaultDevice, &i, &val);
   }
 #endif
 }
@@ -71,8 +71,8 @@ void periodic_task_fbw(void) {
    /* uint16_t servo_value = 1500+ 500*sin(t); */
    /* SetServo(SERVO_THROTTLE, servo_value); */
 
-  RunOnceEvery(300, DOWNLINK_SEND_ALIVE(DefaultChannel, 16, MD5SUM));
-  RunOnceEvery(300, DOWNLINK_SEND_ACTUATORS(DefaultChannel, SERVOS_NB, actuators ));
+  RunOnceEvery(300, DOWNLINK_SEND_ALIVE(DefaultChannel, DefaultDevice, 16, MD5SUM));
+  RunOnceEvery(300, DOWNLINK_SEND_ACTUATORS(DefaultChannel, DefaultDevice, SERVOS_NB, actuators ));
 }
 
 void event_task_fbw(void) {
diff --git a/sw/airborne/lisa/lisa_stm_passthrough_main.c b/sw/airborne/lisa/lisa_stm_passthrough_main.c
index cc92c44777..0b2ead0157 100644
--- a/sw/airborne/lisa/lisa_stm_passthrough_main.c
+++ b/sw/airborne/lisa/lisa_stm_passthrough_main.c
@@ -165,10 +165,10 @@ static inline void main_periodic(void) {
 
 	RunOnceEvery(10, {
 			LED_PERIODIC();
-			DOWNLINK_SEND_ALIVE(DefaultChannel, 16, MD5SUM);
+			DOWNLINK_SEND_ALIVE(DefaultChannel, DefaultDevice, 16, MD5SUM);
 			radio_control_periodic();
 			check_radio_lost();
-			DOWNLINK_SEND_BARO_RAW(DefaultChannel, &baro.absolute, &baro.differential);
+			DOWNLINK_SEND_BARO_RAW(DefaultChannel, DefaultDevice, &baro.absolute, &baro.differential);
 		});
 
 	RunOnceEvery(2, {baro_periodic();});
@@ -179,7 +179,7 @@ static inline void main_periodic(void) {
 		v1 = adc0_buf.sum / adc0_buf.av_nb_sample;
 		v2 = adc1_buf.values[0];
 
-		RunOnceEvery(10, { DOWNLINK_SEND_ADC_GENERIC(DefaultChannel, &v1, &v2) });
+		RunOnceEvery(10, { DOWNLINK_SEND_ADC_GENERIC(DefaultChannel, DefaultDevice, &v1, &v2) });
 	}
 }
 
@@ -318,7 +318,7 @@ static inline void on_mag_event(void) {
 static inline void on_vane_msg(void *data) {
 	new_vane = TRUE;
 	int zero = 0;
-	DOWNLINK_SEND_VANE_SENSOR(DefaultChannel,
+	DOWNLINK_SEND_VANE_SENSOR(DefaultChannel, DefaultDevice,
 				&(csc_vane_msg.vane_angle1),
 				&zero,
 				&zero,
diff --git a/sw/airborne/lisa/test/hs_gyro.c b/sw/airborne/lisa/test/hs_gyro.c
index a678b56710..81edad1f59 100644
--- a/sw/airborne/lisa/test/hs_gyro.c
+++ b/sw/airborne/lisa/test/hs_gyro.c
@@ -70,7 +70,7 @@ static inline void main_init( void ) {
 static inline void main_periodic_task( void ) {
   RunOnceEvery(100, {
       LED_TOGGLE(3);
-      DOWNLINK_SEND_ALIVE(DefaultChannel, 16, MD5SUM);
+      DOWNLINK_SEND_ALIVE(DefaultChannel, DefaultDevice, 16, MD5SUM);
     });
   imu_periodic();
   RunOnceEvery(10, { LED_PERIODIC();});
@@ -101,11 +101,11 @@ static inline void on_gyro_accel_event(void) {
   if (cnt > NB_SAMPLES) cnt = 0;
   samples[cnt] = imu.MEASURED_SENSOR;
   if (cnt == NB_SAMPLES-1) {
-    DOWNLINK_SEND_IMU_HS_GYRO(DefaultChannel, &axis, NB_SAMPLES, samples);
+    DOWNLINK_SEND_IMU_HS_GYRO(DefaultChannel, DefaultDevice, &axis, NB_SAMPLES, samples);
   }
 
   if (cnt == 10) {
-    DOWNLINK_SEND_IMU_GYRO_RAW(DefaultChannel,
+    DOWNLINK_SEND_IMU_GYRO_RAW(DefaultChannel, DefaultDevice,
 			       &imu.gyro_unscaled.p,
 			       &imu.gyro_unscaled.q,
 			       &imu.gyro_unscaled.r);
diff --git a/sw/airborne/lisa/test/lisa_test_actuators_mkk.c b/sw/airborne/lisa/test/lisa_test_actuators_mkk.c
index 5ff088262b..54fe479a4f 100644
--- a/sw/airborne/lisa/test/lisa_test_actuators_mkk.c
+++ b/sw/airborne/lisa/test/lisa_test_actuators_mkk.c
@@ -62,7 +62,7 @@ static inline void main_periodic_task( void ) {
 
   RunOnceEvery(100, {
       LED_TOGGLE(3);
-      DOWNLINK_SEND_ALIVE(DefaultChannel, 16, MD5SUM);
+      DOWNLINK_SEND_ALIVE(DefaultChannel, DefaultDevice, 16, MD5SUM);
     });
 
 
diff --git a/sw/airborne/lisa/test/lisa_test_adxl345.c b/sw/airborne/lisa/test/lisa_test_adxl345.c
index 58848df507..b76739b778 100644
--- a/sw/airborne/lisa/test/lisa_test_adxl345.c
+++ b/sw/airborne/lisa/test/lisa_test_adxl345.c
@@ -148,7 +148,7 @@ static inline void main_periodic_task( void ) {
 
   RunOnceEvery(10,
     {
-      DOWNLINK_SEND_ALIVE(DefaultChannel, 16, MD5SUM);
+      DOWNLINK_SEND_ALIVE(DefaultChannel, DefaultDevice, 16, MD5SUM);
       LED_PERIODIC();
     });
 
@@ -197,7 +197,7 @@ static inline void main_event_task( void ) {
     int32_t iax = *((int16_t*)&values[0]);
     int32_t iay = *((int16_t*)&values[2]);
     int32_t iaz = *((int16_t*)&values[4]);
-    RunOnceEvery(10, {DOWNLINK_SEND_IMU_ACCEL_RAW(DefaultChannel, &iax, &iay, &iaz);});
+    RunOnceEvery(10, {DOWNLINK_SEND_IMU_ACCEL_RAW(DefaultChannel, DefaultDevice, &iax, &iay, &iaz);});
   }
 
 }
diff --git a/sw/airborne/lisa/test/lisa_test_adxl345_dma.c b/sw/airborne/lisa/test/lisa_test_adxl345_dma.c
index 011d7a4020..002e6f776b 100644
--- a/sw/airborne/lisa/test/lisa_test_adxl345_dma.c
+++ b/sw/airborne/lisa/test/lisa_test_adxl345_dma.c
@@ -161,7 +161,7 @@ static inline void main_periodic_task( void ) {
 
   RunOnceEvery(10,
     {
-      DOWNLINK_SEND_ALIVE(DefaultChannel, 16, MD5SUM);
+      DOWNLINK_SEND_ALIVE(DefaultChannel, DefaultDevice, 16, MD5SUM);
       LED_PERIODIC();
     });
 
@@ -197,7 +197,7 @@ static inline void main_event_task( void ) {
     int32_t iax = ax;
     int32_t iay = ay;
     int32_t iaz = az;
-    RunOnceEvery(10, {DOWNLINK_SEND_IMU_ACCEL_RAW(DefaultChannel, &iax, &iay, &iaz);});
+    RunOnceEvery(10, {DOWNLINK_SEND_IMU_ACCEL_RAW(DefaultChannel, DefaultDevice, &iax, &iay, &iaz);});
   }
 
 }
diff --git a/sw/airborne/lisa/test/lisa_test_aspirin.c b/sw/airborne/lisa/test/lisa_test_aspirin.c
index a71e9b57f5..e845219576 100644
--- a/sw/airborne/lisa/test/lisa_test_aspirin.c
+++ b/sw/airborne/lisa/test/lisa_test_aspirin.c
@@ -80,7 +80,7 @@ static inline void main_periodic_task( void ) {
   //  LED_TOGGLE(6);
   RunOnceEvery(10,
 	       {
-		 DOWNLINK_SEND_ALIVE(DefaultChannel, 16, MD5SUM);
+		 DOWNLINK_SEND_ALIVE(DefaultChannel, DefaultDevice, 16, MD5SUM);
 		 LED_PERIODIC();
 	       });
 
diff --git a/sw/airborne/lisa/test/lisa_test_hmc5843.c b/sw/airborne/lisa/test/lisa_test_hmc5843.c
index 3eb7c65fef..959e42aece 100644
--- a/sw/airborne/lisa/test/lisa_test_hmc5843.c
+++ b/sw/airborne/lisa/test/lisa_test_hmc5843.c
@@ -84,12 +84,12 @@ static inline void main_periodic_task( void ) {
   //  LED_TOGGLE(6);
   RunOnceEvery(10,
   {
-    DOWNLINK_SEND_ALIVE(DefaultChannel, 16, MD5SUM);
+    DOWNLINK_SEND_ALIVE(DefaultChannel, DefaultDevice, 16, MD5SUM);
     LED_PERIODIC();
   });
   RunOnceEvery(256,
     {
-      DOWNLINK_SEND_I2C_ERRORS(DefaultChannel,
+      DOWNLINK_SEND_I2C_ERRORS(DefaultChannel, DefaultDevice,
 			       &i2c2_errors.ack_fail_cnt,
 			       &i2c2_errors.miss_start_stop_cnt,
 			       &i2c2_errors.arb_lost_cnt,
@@ -165,10 +165,10 @@ static inline void main_event_task( void ) {
       int16_t mz   = i2c_trans.buf[4]<<8 | i2c_trans.buf[5];
       struct Int32Vect3 m;
       VECT3_ASSIGN(m, mx, my, mz);
-      DOWNLINK_SEND_IMU_MAG_RAW(DefaultChannel, &m.x, &m.y, &m.z);
+      DOWNLINK_SEND_IMU_MAG_RAW(DefaultChannel, DefaultDevice, &m.x, &m.y, &m.z);
       //      uint8_t tmp[8];
       //      memcpy(tmp, i2c2.buf, 8);
-      //      DOWNLINK_SEND_DEBUG(DefaultChannel, 8, tmp);
+      //      DOWNLINK_SEND_DEBUG(DefaultChannel, DefaultDevice, 8, tmp);
     }
 		 );
     reading_mag = FALSE;
diff --git a/sw/airborne/lisa/test/lisa_test_itg3200.c b/sw/airborne/lisa/test/lisa_test_itg3200.c
index 75c0ef9e1e..bc6138507f 100644
--- a/sw/airborne/lisa/test/lisa_test_itg3200.c
+++ b/sw/airborne/lisa/test/lisa_test_itg3200.c
@@ -82,11 +82,11 @@ static inline void main_periodic_task( void ) {
   //  LED_TOGGLE(6);
   RunOnceEvery(10,
   {
-    DOWNLINK_SEND_ALIVE(DefaultChannel, 16, MD5SUM);
+    DOWNLINK_SEND_ALIVE(DefaultChannel, DefaultDevice, 16, MD5SUM);
     LED_PERIODIC();
   });
   RunOnceEvery(256, {
-   DOWNLINK_SEND_I2C_ERRORS(DefaultChannel,
+   DOWNLINK_SEND_I2C_ERRORS(DefaultChannel, DefaultDevice,
 			    &i2c2_errors.ack_fail_cnt,
 			    &i2c2_errors.miss_start_stop_cnt,
 			    &i2c2_errors.arb_lost_cnt,
@@ -205,11 +205,11 @@ static inline void main_event_task( void ) {
     RATES_ASSIGN(g, tgp, tgq, tgr);
     RunOnceEvery(10,
     {
-      DOWNLINK_SEND_IMU_GYRO_RAW(DefaultChannel, &g.p, &g.q, &g.r);
+      DOWNLINK_SEND_IMU_GYRO_RAW(DefaultChannel, DefaultDevice, &g.p, &g.q, &g.r);
 
       uint8_t tmp[8];
       memcpy(tmp, i2c_trans.buf, 8);
-      DOWNLINK_SEND_DEBUG(DefaultChannel, 8, tmp);
+      DOWNLINK_SEND_DEBUG(DefaultChannel, DefaultDevice, 8, tmp);
 
 
     });
diff --git a/sw/airborne/lisa/test/lisa_test_max1168.c b/sw/airborne/lisa/test/lisa_test_max1168.c
index 186892f1b5..82b2d161dc 100644
--- a/sw/airborne/lisa/test/lisa_test_max1168.c
+++ b/sw/airborne/lisa/test/lisa_test_max1168.c
@@ -65,7 +65,7 @@ static inline void main_periodic_task( void ) {
   max1168_read();
   RunOnceEvery(10,
 	       {
-		 DOWNLINK_SEND_BOOT(DefaultChannel, &cpu_time_sec);
+		 DOWNLINK_SEND_BOOT(DefaultChannel, DefaultDevice, &cpu_time_sec);
 		 LED_PERIODIC();
 	       });
 
@@ -74,9 +74,9 @@ static inline void main_periodic_task( void ) {
 static inline void main_event_task( void ) {
   if (max1168_status == STA_MAX1168_DATA_AVAILABLE) {
     RunOnceEvery(10, {
-	DOWNLINK_SEND_IMU_GYRO_RAW(DefaultChannel, &max1168_values[0], &max1168_values[1], &max1168_values[2]);
-	DOWNLINK_SEND_IMU_ACCEL_RAW(DefaultChannel, &max1168_values[3], &max1168_values[4], &max1168_values[6]);
-	//	DOWNLINK_SEND_BOOT(DefaultChannel, &max1168_values[7]); });
+	DOWNLINK_SEND_IMU_GYRO_RAW(DefaultChannel, DefaultDevice, &max1168_values[0], &max1168_values[1], &max1168_values[2]);
+	DOWNLINK_SEND_IMU_ACCEL_RAW(DefaultChannel, DefaultDevice, &max1168_values[3], &max1168_values[4], &max1168_values[6]);
+	//	DOWNLINK_SEND_BOOT(DefaultChannel, DefaultDevice, &max1168_values[7]); });
       });
     max1168_status = STA_MAX1168_IDLE;
   }
diff --git a/sw/airborne/lisa/test/lisa_test_ms2100.c b/sw/airborne/lisa/test/lisa_test_ms2100.c
index 43329cf892..7e3089be96 100644
--- a/sw/airborne/lisa/test/lisa_test_ms2100.c
+++ b/sw/airborne/lisa/test/lisa_test_ms2100.c
@@ -63,7 +63,7 @@ static inline void main_init( void ) {
 static inline void main_periodic_task( void ) {
   RunOnceEvery(10,
 	       {
-		 DOWNLINK_SEND_BOOT(DefaultChannel, &cpu_time_sec);
+		 DOWNLINK_SEND_BOOT(DefaultChannel, DefaultDevice, &cpu_time_sec);
 		 LED_PERIODIC();
 	       });
 
@@ -82,7 +82,7 @@ static inline void main_periodic_task( void ) {
 static inline void main_event_task( void ) {
   if (ms2100_status == MS2100_DATA_AVAILABLE) {
     RunOnceEvery(10, {
-	DOWNLINK_SEND_IMU_MAG_RAW(DefaultChannel,
+	DOWNLINK_SEND_IMU_MAG_RAW(DefaultChannel, DefaultDevice,
 				  &ms2100_values[0],
 				  &ms2100_values[1],
 				  &ms2100_values[2]);
diff --git a/sw/airborne/lisa/test/lisa_test_sc18is600.c b/sw/airborne/lisa/test/lisa_test_sc18is600.c
index 2943831401..385b3cc792 100644
--- a/sw/airborne/lisa/test/lisa_test_sc18is600.c
+++ b/sw/airborne/lisa/test/lisa_test_sc18is600.c
@@ -61,7 +61,7 @@ static inline void main_periodic_task( void ) {
   //  LED_TOGGLE(6);
   RunOnceEvery(10,
 	       {
-		 DOWNLINK_SEND_ALIVE(DefaultChannel, 16, MD5SUM);
+		 DOWNLINK_SEND_ALIVE(DefaultChannel, DefaultDevice, 16, MD5SUM);
 		 LED_PERIODIC();
 	       });
 
diff --git a/sw/airborne/lisa/test/test_board.c b/sw/airborne/lisa/test/test_board.c
index a697cae7b2..32ac998173 100644
--- a/sw/airborne/lisa/test/test_board.c
+++ b/sw/airborne/lisa/test/test_board.c
@@ -113,7 +113,7 @@ static inline void main_init( void ) {
 static inline void main_periodic_task( void ) {
 
   LED_PERIODIC();
-  RunOnceEvery(256, {DOWNLINK_SEND_ALIVE(DefaultChannel, 16, MD5SUM);});
+  RunOnceEvery(256, {DOWNLINK_SEND_ALIVE(DefaultChannel, DefaultDevice, 16, MD5SUM);});
 
   tests[cur_test]._periodic();
 
@@ -156,7 +156,7 @@ static void test_baro_start(void) {all_led_green();}
 static void test_baro_periodic(void) {
   RunOnceEvery(2, {baro_periodic();});
   RunOnceEvery(100,{
-      DOWNLINK_SEND_I2C_ERRORS(DefaultChannel,
+      DOWNLINK_SEND_I2C_ERRORS(DefaultChannel, DefaultDevice,
                    &i2c2_errors.ack_fail_cnt,
                    &i2c2_errors.miss_start_stop_cnt,
                    &i2c2_errors.arb_lost_cnt,
@@ -170,10 +170,10 @@ static void test_baro_periodic(void) {
 }
 static void test_baro_event(void) {BaroEvent(test_baro_on_baro_abs, test_baro_on_baro_diff);}
 static inline void test_baro_on_baro_abs(void) {
-  RunOnceEvery(5,{DOWNLINK_SEND_BOOZ_BARO2_RAW(DefaultChannel, &baro.abs_raw, &baro.diff_raw);});
+  RunOnceEvery(5,{DOWNLINK_SEND_BOOZ_BARO2_RAW(DefaultChannel, DefaultDevice, &baro.abs_raw, &baro.diff_raw);});
 }
 static inline void test_baro_on_baro_diff(void) {
-  RunOnceEvery(5,{DOWNLINK_SEND_BOOZ_BARO2_RAW(DefaultChannel, &baro.abs_raw, &baro.diff_raw);});
+  RunOnceEvery(5,{DOWNLINK_SEND_BOOZ_BARO2_RAW(DefaultChannel, DefaultDevice, &baro.abs_raw, &baro.diff_raw);});
 }
 
 
@@ -190,7 +190,7 @@ static void test_bldc_periodic(void) {
   i2c1_transmit(0x58, 1, NULL);
 
   RunOnceEvery(100,{
-      DOWNLINK_SEND_I2C_ERRORS(DefaultChannel,
+      DOWNLINK_SEND_I2C_ERRORS(DefaultChannel, DefaultDevice,
                    &i2c1_errors.ack_fail_cnt,
                    &i2c1_errors.miss_start_stop_cnt,
                    &i2c1_errors.arb_lost_cnt,
@@ -260,7 +260,7 @@ static void test_uart_event(void) {
   if (Uart3ChAvailable()) {
     buf_dest[idx_rx] = Uart3Getch();
     if (idx_rx<sizeof(buf_src)) {
-      DOWNLINK_SEND_DEBUG(DefaultChannel, sizeof(buf_src), buf_dest);
+      DOWNLINK_SEND_DEBUG(DefaultChannel, DefaultDevice, sizeof(buf_src), buf_dest);
       idx_rx++;
       if (idx_rx == sizeof(buf_src)) {
     if ( memcmp(buf_dest, buf_src, sizeof(buf_src)) ) {
@@ -278,7 +278,7 @@ static void test_uart_event(void) {
   if (Uart1ChAvailable()) {
     buf_dest[idx_rx] = Uart1Getch();
     if (idx_rx<sizeof(buf_src)) {
-      DOWNLINK_SEND_DEBUG(DefaultChannel, sizeof(buf_src), buf_dest);
+      DOWNLINK_SEND_DEBUG(DefaultChannel, DefaultDevice, sizeof(buf_src), buf_dest);
       idx_rx++;
       if (idx_rx == sizeof(buf_src)) {
     if ( memcmp(buf_dest, buf_src, sizeof(buf_src)) ) {
@@ -330,7 +330,7 @@ void dl_parse_msg(void) {
 
   case  DL_PING:
     {
-      DOWNLINK_SEND_PONG(DefaultChannel);
+      DOWNLINK_SEND_PONG(DefaultChannel, DefaultDevice);
     }
     break;
 
@@ -340,7 +340,7 @@ void dl_parse_msg(void) {
       uint8_t i = DL_SETTING_index(dl_buffer);
       float var = DL_SETTING_value(dl_buffer);
       DlSetting(i, var);
-      DOWNLINK_SEND_DL_VALUE(DefaultChannel, &i, &var);
+      DOWNLINK_SEND_DL_VALUE(DefaultChannel, DefaultDevice, &i, &var);
     }
     break;
 
diff --git a/sw/airborne/lisa/test/test_mc_asctec_v1_simple.c b/sw/airborne/lisa/test/test_mc_asctec_v1_simple.c
index 0a5a650792..f8dad77388 100644
--- a/sw/airborne/lisa/test/test_mc_asctec_v1_simple.c
+++ b/sw/airborne/lisa/test/test_mc_asctec_v1_simple.c
@@ -60,10 +60,10 @@ static inline void main_init( void ) {
 static inline void main_periodic_task( void ) {
 
 
-  RunOnceEvery(256, {DOWNLINK_SEND_ALIVE(DefaultChannel, 16, MD5SUM);});
+  RunOnceEvery(256, {DOWNLINK_SEND_ALIVE(DefaultChannel, DefaultDevice, 16, MD5SUM);});
   RunOnceEvery(256,
     {
-      DOWNLINK_SEND_I2C_ERRORS(DefaultChannel,
+      DOWNLINK_SEND_I2C_ERRORS(DefaultChannel, DefaultDevice,
 			       &i2c1_errors.ack_fail_cnt,
 			       &i2c1_errors.miss_start_stop_cnt,
 			       &i2c1_errors.arb_lost_cnt,
diff --git a/sw/airborne/lisa/test_adc.c b/sw/airborne/lisa/test_adc.c
index f62021ab24..f7299bd9e5 100644
--- a/sw/airborne/lisa/test_adc.c
+++ b/sw/airborne/lisa/test_adc.c
@@ -68,8 +68,8 @@ int main( void ) {
 }
 
 static inline void main_periodic_task( void ) {
-  RunOnceEvery(100, {DOWNLINK_SEND_ALIVE(DefaultChannel, 16, MD5SUM);});
-  RunOnceEvery(100, {/*LED_TOGGLE(7);*/ DOWNLINK_SEND_TIME(DefaultChannel, &cpu_time_sec);});
+  RunOnceEvery(100, {DOWNLINK_SEND_ALIVE(DefaultChannel, DefaultDevice, 16, MD5SUM);});
+  RunOnceEvery(100, {/*LED_TOGGLE(7);*/ DOWNLINK_SEND_TIME(DefaultChannel, DefaultDevice, &cpu_time_sec);});
   LED_PERIODIC();
 }
 
@@ -82,7 +82,7 @@ static inline void main_event_task( void ) {
     //    v1 = (((adc0_buf.values[0])));
     v1 = adc0_buf.sum/adc0_buf.av_nb_sample;
     v2 = (((adc3_buf.values[0])));
-    RunOnceEvery(100, {DOWNLINK_SEND_ADC_GENERIC(DefaultChannel, &v1, &v2)});
+    RunOnceEvery(100, {DOWNLINK_SEND_ADC_GENERIC(DefaultChannel, DefaultDevice, &v1, &v2)});
   }
 
 }
diff --git a/sw/airborne/lisa/test_csc_servo.c b/sw/airborne/lisa/test_csc_servo.c
index 689deec23f..b3ce9d55ca 100644
--- a/sw/airborne/lisa/test_csc_servo.c
+++ b/sw/airborne/lisa/test_csc_servo.c
@@ -92,7 +92,7 @@ static inline void main_periodic_task( void ) {
 	cscp_transmit(0, 0, (uint8_t *)servos, 8);
 
 	LED_PERIODIC();
-	DOWNLINK_SEND_ALIVE(DefaultChannel, 16, MD5SUM);
+	DOWNLINK_SEND_ALIVE(DefaultChannel, DefaultDevice, 16, MD5SUM);
 }
 
 
@@ -105,17 +105,17 @@ static inline void main_event_task( void ) {
 	LED_OFF(2);
 	LED_OFF(3);
 
-//	DOWNLINK_SEND_ALIVE(DefaultChannel, 16, MD5SUM);
+//	DOWNLINK_SEND_ALIVE(DefaultChannel, DefaultDevice, 16, MD5SUM);
 }
 
 void main_on_vane_msg(void *data)
 {
 	int zero = 0;
 
-//	DOWNLINK_SEND_PONG(DefaultChannel);
+//	DOWNLINK_SEND_PONG(DefaultChannel, DefaultDevice);
 
 //	RunOnceEvery(10, {
-			DOWNLINK_SEND_VANE_SENSOR(DefaultChannel,
+			DOWNLINK_SEND_VANE_SENSOR(DefaultChannel, DefaultDevice,
 																&(csc_vane_msg.vane_angle1),
 																&zero,
 																&zero,
diff --git a/sw/airborne/lisa/test_datalink.c b/sw/airborne/lisa/test_datalink.c
index 606627bc07..92e321d7c1 100644
--- a/sw/airborne/lisa/test_datalink.c
+++ b/sw/airborne/lisa/test_datalink.c
@@ -52,7 +52,7 @@ static inline void main_init( void ) {
 }
 
 static inline void main_periodic( void ) {
-  RunOnceEvery(100, {DOWNLINK_SEND_ALIVE(DefaultChannel,  16, MD5SUM);});
+  RunOnceEvery(100, {DOWNLINK_SEND_ALIVE(DefaultChannel, DefaultDevice,  16, MD5SUM);});
 }
 
 static inline void main_event( void ) {
@@ -67,7 +67,7 @@ void dl_parse_msg(void) {
 
   case  DL_PING:
     {
-      DOWNLINK_SEND_PONG(DefaultChannel);
+      DOWNLINK_SEND_PONG(DefaultChannel, DefaultDevice);
     }
     break;
   }
diff --git a/sw/airborne/lisa/test_float.c b/sw/airborne/lisa/test_float.c
index 48c662d727..9e60970686 100644
--- a/sw/airborne/lisa/test_float.c
+++ b/sw/airborne/lisa/test_float.c
@@ -58,11 +58,11 @@ static inline void main_periodic( void ) {
   float i = sqrt(f);  // ok
   //float i = powf(f1, f1); // nok
   //float i = atan2(f, f); // ok
-  RunOnceEvery(10, {DOWNLINK_SEND_TEST_FORMAT(DefaultChannel, &d1, &i);});
+  RunOnceEvery(10, {DOWNLINK_SEND_TEST_FORMAT(DefaultChannel, DefaultDevice, &d1, &i);});
 
   uint16_t  blaaa = f+d;
 
-  RunOnceEvery(10, {DOWNLINK_SEND_BOOT(DefaultChannel, &blaaa);});
+  RunOnceEvery(10, {DOWNLINK_SEND_BOOT(DefaultChannel, DefaultDevice, &blaaa);});
   LED_PERIODIC();
 }
 
diff --git a/sw/airborne/lisa/test_spi_slave.c b/sw/airborne/lisa/test_spi_slave.c
index 526e7025c8..4c5ef4c3b8 100644
--- a/sw/airborne/lisa/test_spi_slave.c
+++ b/sw/airborne/lisa/test_spi_slave.c
@@ -65,7 +65,7 @@ static inline void main_periodic_task( void ) {
     GPIOC->BSRR = GPIO_Pin_4;
   foo = !foo;
 #endif
-  RunOnceEvery(10, {DOWNLINK_SEND_BOOT(DefaultChannel, &cpu_time_sec);});
+  RunOnceEvery(10, {DOWNLINK_SEND_BOOT(DefaultChannel, DefaultDevice, &cpu_time_sec);});
   LED_PERIODIC();
 }
 
@@ -129,7 +129,7 @@ void spi1_irq_handler(void) {
   SPI_I2S_SendData(SPI1, cnt);
   cnt++;
   LED_TOGGLE(3);
-  DOWNLINK_SEND_DEBUG_MCU_LINK(DefaultChannel, &foo, &foo, &cnt);
+  DOWNLINK_SEND_DEBUG_MCU_LINK(DefaultChannel, DefaultDevice, &foo, &foo, &cnt);
 
 
 }
diff --git a/sw/airborne/lisa/test_spi_slave2.c b/sw/airborne/lisa/test_spi_slave2.c
index cfdafbc48f..4ff988259a 100644
--- a/sw/airborne/lisa/test_spi_slave2.c
+++ b/sw/airborne/lisa/test_spi_slave2.c
@@ -67,7 +67,7 @@ static inline void main_init( void ) {
 static inline void main_periodic_task( void ) {
   RunOnceEvery(10,
 	       {
-		 DOWNLINK_SEND_BOOT(DefaultChannel, &cpu_time_sec);
+		 DOWNLINK_SEND_BOOT(DefaultChannel, DefaultDevice, &cpu_time_sec);
 		 LED_PERIODIC();
 	       });
 
@@ -78,7 +78,7 @@ static inline void main_event_task( void ) {
 #ifdef USE_DMA
   if (DMA_GetFlagStatus(DMA1_FLAG_TC2)) {
     LED_TOGGLE(3);
-    RunOnceEvery(10, {DOWNLINK_SEND_DEBUG_MCU_LINK(DefaultChannel, &SPI_SLAVE_Buffer_Rx[0],
+    RunOnceEvery(10, {DOWNLINK_SEND_DEBUG_MCU_LINK(DefaultChannel, DefaultDevice, &SPI_SLAVE_Buffer_Rx[0],
 						    &SPI_SLAVE_Buffer_Rx[1], &SPI_SLAVE_Buffer_Rx[2]);});
     memcpy(SPI_SLAVE_Buffer_Tx, SPI_SLAVE_Buffer_Rx, BufferSize);
     main_setup_dma();
diff --git a/sw/airborne/modules/MPPT/MPPT.c b/sw/airborne/modules/MPPT/MPPT.c
index 953520da1b..9eeabf29bb 100644
--- a/sw/airborne/modules/MPPT/MPPT.c
+++ b/sw/airborne/modules/MPPT/MPPT.c
@@ -83,7 +83,7 @@ static void MPPT_ask( void ) {
     fbw_current_milliamp = MPPT_data[MPPT_IBAT_INDEX];
 
     MPPT_data[MPPT_ITOTAL_INDEX] = MPPT_data[MPPT_IBAT_INDEX] + MPPT_data[MPPT_ICONV_INDEX];
-    DOWNLINK_SEND_MPPT(DefaultChannel, NB_DATA, MPPT_data);
+    DOWNLINK_SEND_MPPT(DefaultChannel, DefaultDevice, NB_DATA, MPPT_data);
     data_index = 0;
   }
 
diff --git a/sw/airborne/modules/MPPT/sim_MPPT.c b/sw/airborne/modules/MPPT/sim_MPPT.c
index f9762202a1..f8e3485361 100644
--- a/sw/airborne/modules/MPPT/sim_MPPT.c
+++ b/sw/airborne/modules/MPPT/sim_MPPT.c
@@ -46,5 +46,5 @@ void MPPT_init( void ) {
 void MPPT_periodic( void ) {
   MPPT_data[MPPT_ITOTAL_INDEX] = MPPT_data[MPPT_IBAT_INDEX] + MPPT_data[MPPT_ICONV_INDEX];
 
-  RunOnceEvery(8, DOWNLINK_SEND_MPPT(DefaultChannel, NB_DATA, MPPT_data));
+  RunOnceEvery(8, DOWNLINK_SEND_MPPT(DefaultChannel, DefaultDevice, NB_DATA, MPPT_data));
 }
diff --git a/sw/airborne/modules/adcs/adc_generic.c b/sw/airborne/modules/adcs/adc_generic.c
index 59827aa577..327c894056 100644
--- a/sw/airborne/modules/adcs/adc_generic.c
+++ b/sw/airborne/modules/adcs/adc_generic.c
@@ -47,6 +47,6 @@ void adc_generic_periodic( void ) {
   adc_generic_val2 = buf_generic2.sum / buf_generic2.av_nb_sample;
 #endif
 
-  DOWNLINK_SEND_ADC_GENERIC(DefaultChannel, &adc_generic_val1, &adc_generic_val2);
+  DOWNLINK_SEND_ADC_GENERIC(DefaultChannel, DefaultDevice, &adc_generic_val1, &adc_generic_val2);
 }
 
diff --git a/sw/airborne/modules/adcs/max11040.c b/sw/airborne/modules/adcs/max11040.c
index 2b89402fe5..a867c191e6 100644
--- a/sw/airborne/modules/adcs/max11040.c
+++ b/sw/airborne/modules/adcs/max11040.c
@@ -66,7 +66,7 @@ void max11040_periodic(void) {
     }
 
     DOWNLINK_SEND_TURB_PRESSURE_VOLTAGE(
-        DefaultChannel,
+        DefaultChannel, DefaultDevice,
         &max11040_values_f[0],
         &max11040_values_f[1],
         &max11040_values_f[2],
diff --git a/sw/airborne/modules/benchmark/flight_benchmark.c b/sw/airborne/modules/benchmark/flight_benchmark.c
index 12685308b8..ba2dc86f5b 100644
--- a/sw/airborne/modules/benchmark/flight_benchmark.c
+++ b/sw/airborne/modules/benchmark/flight_benchmark.c
@@ -113,7 +113,7 @@ void flight_benchmark_periodic( void ) {
 	#endif
 	}
 
-	DOWNLINK_SEND_FLIGHT_BENCHMARK(DefaultChannel, &SquareSumErr_airspeed, &SquareSumErr_altitude, &SquareSumErr_position, &Err_airspeed, &Err_altitude, &Err_position)
+	DOWNLINK_SEND_FLIGHT_BENCHMARK(DefaultChannel, DefaultDevice, &SquareSumErr_airspeed, &SquareSumErr_altitude, &SquareSumErr_position, &Err_airspeed, &Err_altitude, &Err_position)
 
 }
 
diff --git a/sw/airborne/modules/cam_control/cam_track.c b/sw/airborne/modules/cam_control/cam_track.c
index 0126fc6adf..c3507ea23a 100644
--- a/sw/airborne/modules/cam_control/cam_track.c
+++ b/sw/airborne/modules/cam_control/cam_track.c
@@ -115,7 +115,7 @@ void track_periodic_task(void) {
   for (i = 0; i < c; i++) {
     CamUartSend1(cmd_msg[i]);
   }
-  //DOWNLINK_SEND_DEBUG(DefaultChannel,c,cmd_msg);
+  //DOWNLINK_SEND_DEBUG(DefaultChannel, DefaultDevice,c,cmd_msg);
 
 }
 
@@ -188,13 +188,13 @@ void parse_cam_msg( void ) {
   ptr++;
   *ptr = cam_data_buf[11];
 
-  //DOWNLINK_SEND_DEBUG(DefaultChannel,12,cam_data_buf);
+  //DOWNLINK_SEND_DEBUG(DefaultChannel, DefaultDevice,12,cam_data_buf);
 }
 
 void parse_cam_buffer( uint8_t c ) {
   char bla[1];
   bla[1] = c;
-  //DOWNLINK_SEND_DEBUG(DefaultChannel,1,bla);
+  //DOWNLINK_SEND_DEBUG(DefaultChannel, DefaultDevice,1,bla);
   switch (cam_status) {
   case UNINIT:
     if (c != CAM_START_1)
diff --git a/sw/airborne/modules/cartography/cartography.c b/sw/airborne/modules/cartography/cartography.c
index e6e52b1ace..37edf863be 100644
--- a/sw/airborne/modules/cartography/cartography.c
+++ b/sw/airborne/modules/cartography/cartography.c
@@ -152,7 +152,7 @@ void init_carto(void) {
 }
 
 void periodic_downlink_carto(void) {
-	DOWNLINK_SEND_CAMERA_SNAPSHOT(DefaultChannel,&camera_snapshot_image_number);
+	DOWNLINK_SEND_CAMERA_SNAPSHOT(DefaultChannel, DefaultDevice,&camera_snapshot_image_number);
 }
 
 void start_carto(void) {
diff --git a/sw/airborne/modules/core/extra_pprz_dl.h b/sw/airborne/modules/core/extra_pprz_dl.h
index bd16122590..0888c6e6ea 100644
--- a/sw/airborne/modules/core/extra_pprz_dl.h
+++ b/sw/airborne/modules/core/extra_pprz_dl.h
@@ -146,7 +146,7 @@ static inline void parse_extra_pprz( uint8_t c ) {
   static uint8_t _ck_a, _ck_b, payload_idx;
 
   //uint8_t tab[] = { c };
-  //DOWNLINK_SEND_DEBUG(DefaultChannel,1,tab);
+  //DOWNLINK_SEND_DEBUG(DefaultChannel, DefaultDevice,1,tab);
   switch (pprz_status) {
   case UNINIT:
     if (c == STX)
diff --git a/sw/airborne/modules/core/sys_mon.c b/sw/airborne/modules/core/sys_mon.c
index 118aa9cc41..f76ac7efe8 100644
--- a/sw/airborne/modules/core/sys_mon.c
+++ b/sw/airborne/modules/core/sys_mon.c
@@ -72,7 +72,7 @@ void periodic_report_sysmon(void) {
     cpu_load = 100 * periodic_cycle / periodic_time;
     event_number = sum_n_event / n_periodic;
 
-    DOWNLINK_SEND_SYS_MON(DefaultChannel,&periodic_time,&periodic_cycle,&periodic_cycle_min,&periodic_cycle_max,&event_number,&cpu_load);
+    DOWNLINK_SEND_SYS_MON(DefaultChannel, DefaultDevice,&periodic_time,&periodic_cycle,&periodic_cycle_min,&periodic_cycle_max,&event_number,&cpu_load);
   }
 
   n_periodic = 0;
diff --git a/sw/airborne/modules/datalink/xtend_rssi.c b/sw/airborne/modules/datalink/xtend_rssi.c
index a3549bb34d..69478e5928 100644
--- a/sw/airborne/modules/datalink/xtend_rssi.c
+++ b/sw/airborne/modules/datalink/xtend_rssi.c
@@ -63,7 +63,7 @@ void xtend_rssi_periodic( void ) {
       rssi_dB_fade_margin = (2 * duty_percent + 10) / 3; //not sure if this is right, datasheet isn't very informative
       pwm_input_duty_valid[XTEND_RSSI_PWM_ARRAY_INDEX] = FALSE;
   }
-  DOWNLINK_SEND_XTEND_RSSI(DefaultChannel,
+  DOWNLINK_SEND_XTEND_RSSI(DefaultChannel, DefaultDevice,
             &datalink_time,
             &rssi_dB_fade_margin,
             &duty_percent );
diff --git a/sw/airborne/modules/digital_cam/atmega_i2c_cam_ctrl.c b/sw/airborne/modules/digital_cam/atmega_i2c_cam_ctrl.c
index b74792cd86..144f636a37 100644
--- a/sw/airborne/modules/digital_cam/atmega_i2c_cam_ctrl.c
+++ b/sw/airborne/modules/digital_cam/atmega_i2c_cam_ctrl.c
@@ -95,7 +95,7 @@ void atmega_i2c_cam_ctrl_event( void )
   {
     unsigned char cam_ret[1];
     cam_ret[0] = atmega_i2c_cam_ctrl_trans.buf[0];
-    RunOnceEvery(6,DOWNLINK_SEND_PAYLOAD(DefaultChannel, 1, cam_ret ));
+    RunOnceEvery(6,DOWNLINK_SEND_PAYLOAD(DefaultChannel, DefaultDevice, 1, cam_ret ));
     atmega_i2c_cam_ctrl_trans.status = I2CTransDone;
   }
 }
diff --git a/sw/airborne/modules/digital_cam/dc.c b/sw/airborne/modules/digital_cam/dc.c
index 4a8f090eda..da3573b257 100644
--- a/sw/airborne/modules/digital_cam/dc.c
+++ b/sw/airborne/modules/digital_cam/dc.c
@@ -72,7 +72,7 @@ void dc_send_shot_position(void)
     photo_nr = dc_photo_nr;
   }
 
-  DOWNLINK_SEND_DC_SHOT(DefaultChannel,
+  DOWNLINK_SEND_DC_SHOT(DefaultChannel, DefaultDevice,
                         &photo_nr,
                         &gps.utm_pos.east,
                         &gps.utm_pos.north,
@@ -89,7 +89,7 @@ void dc_send_shot_position(void)
 uint8_t dc_info(void) {
 #ifdef DOWNLINK_SEND_DC_INFO
   float course = DegOfRad(estimator_psi);
-  DOWNLINK_SEND_DC_INFO(DefaultChannel,
+  DOWNLINK_SEND_DC_INFO(DefaultChannel, DefaultDevice,
                         &dc_autoshoot,
                         &estimator_x,
                         &estimator_y,
diff --git a/sw/airborne/modules/digital_cam/sim_i2c_cam_ctrl.c b/sw/airborne/modules/digital_cam/sim_i2c_cam_ctrl.c
index 46d7d900d0..d577dfb4b1 100644
--- a/sw/airborne/modules/digital_cam/sim_i2c_cam_ctrl.c
+++ b/sw/airborne/modules/digital_cam/sim_i2c_cam_ctrl.c
@@ -80,7 +80,7 @@ void atmega_i2c_cam_ctrl_send(uint8_t cmd)
   }
 
   cam_ret[0] = mode + zoom * 0x20;
-  RunOnceEvery(6,DOWNLINK_SEND_PAYLOAD(DefaultChannel, 1, cam_ret ));
+  RunOnceEvery(6,DOWNLINK_SEND_PAYLOAD(DefaultChannel, DefaultDevice, 1, cam_ret ));
 
 }
 
diff --git a/sw/airborne/modules/enose/enose.c b/sw/airborne/modules/enose/enose.c
index 7da2222061..20e878b692 100644
--- a/sw/airborne/modules/enose/enose.c
+++ b/sw/airborne/modules/enose/enose.c
@@ -87,5 +87,5 @@ void enose_periodic( void ) {
       enose_status = ENOSE_IDLE;
     }
   }
-  DOWNLINK_SEND_ENOSE_STATUS(DefaultChannel,&enose_val[0], &enose_val[1], &enose_val[2], &enose_PID_val, 3, enose_heat);
+  DOWNLINK_SEND_ENOSE_STATUS(DefaultChannel, DefaultDevice,&enose_val[0], &enose_val[1], &enose_val[2], &enose_PID_val, 3, enose_heat);
 }
diff --git a/sw/airborne/modules/gps/gps_ubx_ucenter.c b/sw/airborne/modules/gps/gps_ubx_ucenter.c
index dedd952b7f..1688915b47 100644
--- a/sw/airborne/modules/gps/gps_ubx_ucenter.c
+++ b/sw/airborne/modules/gps/gps_ubx_ucenter.c
@@ -352,7 +352,7 @@ static bool_t gps_ubx_ucenter_configure(uint8_t nr)
     gps_ubx_ucenter.replies[3] = gps_ubx_ucenter.sw_ver_l;
     gps_ubx_ucenter.replies[4] = gps_ubx_ucenter.hw_ver_h;
     gps_ubx_ucenter.replies[5] = gps_ubx_ucenter.hw_ver_l;
-    DOWNLINK_SEND_DEBUG(DefaultChannel,6,gps_ubx_ucenter.replies);
+    DOWNLINK_SEND_DEBUG(DefaultChannel, DefaultDevice,6,gps_ubx_ucenter.replies);
 
     //////////////////////////////////
     // Actual configuration start
@@ -397,7 +397,7 @@ static bool_t gps_ubx_ucenter_configure(uint8_t nr)
     break;
   case 16:
     // Debug Downlink the result of all configuration steps: see messages
-    DOWNLINK_SEND_DEBUG(DefaultChannel,GPS_UBX_UCENTER_CONFIG_STEPS,gps_ubx_ucenter.replies);
+    DOWNLINK_SEND_DEBUG(DefaultChannel, DefaultDevice,GPS_UBX_UCENTER_CONFIG_STEPS,gps_ubx_ucenter.replies);
     return FALSE;
   default:
     break;
diff --git a/sw/airborne/modules/gsm/gsm.c b/sw/airborne/modules/gsm/gsm.c
index 043a4d986a..5f2c10212f 100644
--- a/sw/airborne/modules/gsm/gsm.c
+++ b/sw/airborne/modules/gsm/gsm.c
@@ -190,11 +190,11 @@ void gsm_event(void) {
   }
 
   if (gsm_line_received) {
-    if (gsm_buf_len > 0) DOWNLINK_SEND_DEBUG_GSM_RECEIVE(DefaultChannel, gsm_buf_len, gsm_buf);
+    if (gsm_buf_len > 0) DOWNLINK_SEND_DEBUG_GSM_RECEIVE(DefaultChannel, DefaultDevice, gsm_buf_len, gsm_buf);
     gsm_got_line();
     gsm_line_received = false;
   } else if (prompt_received) {
-    DOWNLINK_SEND_DEBUG_GSM_RECEIVE(DefaultChannel, 1, ">");
+    DOWNLINK_SEND_DEBUG_GSM_RECEIVE(DefaultChannel, DefaultDevice, 1, ">");
     gsm_got_prompt();
     prompt_received = false;
   }
@@ -509,7 +509,7 @@ static void Send(const char string[])
     GSMTransmit(string[i++]);
   GSMTransmit(GSM_CMD_LINE_TERMINATION);
 
-  DOWNLINK_SEND_DEBUG_GSM_SEND(DefaultChannel, i, string);
+  DOWNLINK_SEND_DEBUG_GSM_SEND(DefaultChannel, DefaultDevice, i, string);
 }
 
 /* Returns a pointer to the first occurrence of the character c in the firtn
diff --git a/sw/airborne/modules/ins/alt_filter.c b/sw/airborne/modules/ins/alt_filter.c
index a23f500e9b..def8795654 100644
--- a/sw/airborne/modules/ins/alt_filter.c
+++ b/sw/airborne/modules/ins/alt_filter.c
@@ -75,7 +75,7 @@ void alt_filter_periodic(void) {
     last_gps_alt = ga;
   }
 
-  RunOnceEvery(6,DOWNLINK_SEND_VFF(DefaultChannel, &baro_ets_altitude,
+  RunOnceEvery(6,DOWNLINK_SEND_VFF(DefaultChannel, DefaultDevice, &baro_ets_altitude,
         &(alt_filter.X[0]), &(alt_filter.X[1]), &(alt_filter.X[2]),
         &(alt_filter.P[0][0]), &(alt_filter.P[1][1]), &(alt_filter.P[2][2])));
 
diff --git a/sw/airborne/modules/ins/fw_ins_vn100.c b/sw/airborne/modules/ins/fw_ins_vn100.c
index 5385fb569c..c5f01c08d3 100644
--- a/sw/airborne/modules/ins/fw_ins_vn100.c
+++ b/sw/airborne/modules/ins/fw_ins_vn100.c
@@ -116,7 +116,7 @@ void ins_event_task( void ) {
     EstimatorSetAtt((ins_eulers.phi - ins_roll_neutral), ins_eulers.psi, (ins_eulers.theta - ins_pitch_neutral));
 #endif
     //uint8_t s = 4+VN100_REG_QMR_SIZE;
-    //DOWNLINK_SEND_DEBUG(DefaultChannel,s,spi_buffer_input);
+    //DOWNLINK_SEND_DEBUG(DefaultChannel, DefaultDevice,s,spi_buffer_input);
   }
 }
 
diff --git a/sw/airborne/modules/ins/ins_arduimu.c b/sw/airborne/modules/ins/ins_arduimu.c
index 7936326e91..5f574befd2 100644
--- a/sw/airborne/modules/ins/ins_arduimu.c
+++ b/sw/airborne/modules/ins/ins_arduimu.c
@@ -162,7 +162,7 @@ void ArduIMU_periodicGPS( void ) {
       messageNr = 0;
     }
 
-        //DOWNLINK_SEND_DEBUG_ZHAW(DefaultChannel, &gps_mode , &gps_numSV ,&gps_alt , &gps_hmsl , &gps.tow, &gps_speed_3d);
+        //DOWNLINK_SEND_DEBUG_ZHAW(DefaultChannel, DefaultDevice, &gps_mode , &gps_numSV ,&gps_alt , &gps_hmsl , &gps.tow, &gps_speed_3d);
 }
 
 void ArduIMU_periodic( void ) {
@@ -186,9 +186,9 @@ void ArduIMU_periodic( void ) {
 
 
     //Nachricht zum GCS senden
-    // DOWNLINK_SEND_ArduIMU(DefaultChannel, &ArduIMU_data[0], &ArduIMU_data[1], &ArduIMU_data[2], &ArduIMU_data[3], &ArduIMU_data[4], &ArduIMU_data[5]);
+    // DOWNLINK_SEND_ArduIMU(DefaultChannel, DefaultDevice, &ArduIMU_data[0], &ArduIMU_data[1], &ArduIMU_data[2], &ArduIMU_data[3], &ArduIMU_data[4], &ArduIMU_data[5]);
 
-    //    DOWNLINK_SEND_DEBUG_ZHAW(DefaultChannel, &airspeed_mode , &altitude_mode ,&amsys_baro, &amsys_baro, &amsys_airspeed_scaliert, &amsys_baro_scaliert);
+    //    DOWNLINK_SEND_DEBUG_ZHAW(DefaultChannel, DefaultDevice, &airspeed_mode , &altitude_mode ,&amsys_baro, &amsys_baro, &amsys_airspeed_scaliert, &amsys_baro_scaliert);
 }
 
 void IMU_Daten_verarbeiten( void ) {
@@ -215,6 +215,6 @@ void IMU_Daten_verarbeiten( void ) {
 
     {
     float psi=0;
-    RunOnceEvery(15, DOWNLINK_SEND_AHRS_EULER(DefaultChannel, &estimator_phi, &estimator_theta, &psi));
+    RunOnceEvery(15, DOWNLINK_SEND_AHRS_EULER(DefaultChannel, DefaultDevice, &estimator_phi, &estimator_theta, &psi));
     }
 }
diff --git a/sw/airborne/modules/ins/ins_arduimu_basic.c b/sw/airborne/modules/ins/ins_arduimu_basic.c
index 859dda5931..170c12cea8 100644
--- a/sw/airborne/modules/ins/ins_arduimu_basic.c
+++ b/sw/airborne/modules/ins/ins_arduimu_basic.c
@@ -193,9 +193,9 @@ void ArduIMU_event( void ) {
     ardu_ins_trans.status = I2CTransDone;
 
 #ifdef ARDUIMU_SYNC_SEND
-    //RunOnceEvery(15, DOWNLINK_SEND_AHRS_EULER(DefaultChannel, &arduimu_eulers.phi, &arduimu_eulers.theta, &arduimu_eulers.psi));
-    RunOnceEvery(15, DOWNLINK_SEND_IMU_GYRO(DefaultChannel, &arduimu_rates.p, &arduimu_rates.q, &arduimu_rates.r));
-    RunOnceEvery(15, DOWNLINK_SEND_IMU_ACCEL(DefaultChannel, &arduimu_accel.x, &arduimu_accel.y, &arduimu_accel.z));
+    //RunOnceEvery(15, DOWNLINK_SEND_AHRS_EULER(DefaultChannel, DefaultDevice, &arduimu_eulers.phi, &arduimu_eulers.theta, &arduimu_eulers.psi));
+    RunOnceEvery(15, DOWNLINK_SEND_IMU_GYRO(DefaultChannel, DefaultDevice, &arduimu_rates.p, &arduimu_rates.q, &arduimu_rates.r));
+    RunOnceEvery(15, DOWNLINK_SEND_IMU_ACCEL(DefaultChannel, DefaultDevice, &arduimu_accel.x, &arduimu_accel.y, &arduimu_accel.z));
 #endif
   }
   else if (ardu_ins_trans.status == I2CTransFailed) {
diff --git a/sw/airborne/modules/ins/ins_chimu_spi.c b/sw/airborne/modules/ins/ins_chimu_spi.c
index 92129e8d89..01d441fcab 100644
--- a/sw/airborne/modules/ins/ins_chimu_spi.c
+++ b/sw/airborne/modules/ins/ins_chimu_spi.c
@@ -92,7 +92,7 @@ void parse_ins_msg( void )
       else if(CHIMU_DATA.m_MsgID==0x02)
       {
 
-    RunOnceEvery(25,DOWNLINK_SEND_AHRS_EULER(DefaultChannel, &CHIMU_DATA.m_sensor.rate[0], &CHIMU_DATA.m_sensor.rate[1], &CHIMU_DATA.m_sensor.rate[2]));
+    RunOnceEvery(25,DOWNLINK_SEND_AHRS_EULER(DefaultChannel, DefaultDevice, &CHIMU_DATA.m_sensor.rate[0], &CHIMU_DATA.m_sensor.rate[1], &CHIMU_DATA.m_sensor.rate[2]));
 
       }
     }
diff --git a/sw/airborne/modules/ins/ins_chimu_uart.c b/sw/airborne/modules/ins/ins_chimu_uart.c
index c749ed7019..44cc695f7b 100644
--- a/sw/airborne/modules/ins/ins_chimu_uart.c
+++ b/sw/airborne/modules/ins/ins_chimu_uart.c
@@ -90,7 +90,7 @@ void parse_ins_msg( void )
 	EstimatorSetAtt(CHIMU_DATA.m_attitude.euler.phi, CHIMU_DATA.m_attitude.euler.psi, CHIMU_DATA.m_attitude.euler.theta);
 	//EstimatorSetRate(ins_p,ins_q,ins_r);
 
-	DOWNLINK_SEND_AHRS_EULER(DefaultChannel, &CHIMU_DATA.m_attitude.euler.phi, &CHIMU_DATA.m_attitude.euler.theta, &CHIMU_DATA.m_attitude.euler.psi);
+	DOWNLINK_SEND_AHRS_EULER(DefaultChannel, DefaultDevice, &CHIMU_DATA.m_attitude.euler.phi, &CHIMU_DATA.m_attitude.euler.theta, &CHIMU_DATA.m_attitude.euler.psi);
 
       }
     }
diff --git a/sw/airborne/modules/ins/ins_vn100.c b/sw/airborne/modules/ins/ins_vn100.c
index 88a06abd5c..c595d49676 100644
--- a/sw/airborne/modules/ins/ins_vn100.c
+++ b/sw/airborne/modules/ins/ins_vn100.c
@@ -189,7 +189,7 @@ void parse_ins_msg( void ) {
 #include "subsystems/datalink/downlink.h"
 
 extern void ins_report_task( void ) {
-  DOWNLINK_SEND_AHRS_LKF(DefaultChannel,
+  DOWNLINK_SEND_AHRS_LKF(DefaultChannel, DefaultDevice,
       &ins_eulers.phi, &ins_eulers.theta, &ins_eulers.psi,
       &ins_quat.qi, &ins_quat.qx, &ins_quat.qy, &ins_quat.qz,
       &ins_rates.p, &ins_rates.q, &ins_rates.r,
diff --git a/sw/airborne/modules/ins/ins_xsens.c b/sw/airborne/modules/ins/ins_xsens.c
index d7b4228356..10fc98992e 100644
--- a/sw/airborne/modules/ins/ins_xsens.c
+++ b/sw/airborne/modules/ins/ins_xsens.c
@@ -353,14 +353,14 @@ void parse_ins_msg( void ) {
   else if (xsens_id == XSENS_ReqMagneticDeclinationAck_ID) {
     xsens_declination = DegOfRad (XSENS_ReqMagneticDeclinationAck_declination(xsens_msg_buf) );
 
-    DOWNLINK_SEND_IMU_MAG_SETTINGS(DefaultChannel,&xsens_declination,&xsens_declination,&xsens_gps_arm_x,&xsens_gps_arm_y,&xsens_gps_arm_z);
+    DOWNLINK_SEND_IMU_MAG_SETTINGS(DefaultChannel, DefaultDevice,&xsens_declination,&xsens_declination,&xsens_gps_arm_x,&xsens_gps_arm_y,&xsens_gps_arm_z);
   }
   else if (xsens_id == XSENS_ReqLeverArmGpsAck_ID) {
     xsens_gps_arm_x = XSENS_ReqLeverArmGpsAck_x(xsens_msg_buf);
     xsens_gps_arm_y = XSENS_ReqLeverArmGpsAck_y(xsens_msg_buf);
     xsens_gps_arm_z = XSENS_ReqLeverArmGpsAck_z(xsens_msg_buf);
 
-    DOWNLINK_SEND_IMU_MAG_SETTINGS(DefaultChannel,&xsens_declination,&xsens_declination,&xsens_gps_arm_x,&xsens_gps_arm_y,&xsens_gps_arm_z);
+    DOWNLINK_SEND_IMU_MAG_SETTINGS(DefaultChannel, DefaultDevice,&xsens_declination,&xsens_declination,&xsens_gps_arm_x,&xsens_gps_arm_y,&xsens_gps_arm_z);
   }
   else if (xsens_id == XSENS_Error_ID) {
     xsens_errorcode = XSENS_Error_errorcode(xsens_msg_buf);
diff --git a/sw/airborne/modules/max3100/max3100_hw.c b/sw/airborne/modules/max3100/max3100_hw.c
index af85b690cb..27b25ea0da 100644
--- a/sw/airborne/modules/max3100/max3100_hw.c
+++ b/sw/airborne/modules/max3100/max3100_hw.c
@@ -161,5 +161,5 @@ void SPI1_ISR(void) {
 }
 
 void max3100_debug(void) {
-  /***     DOWNLINK_SEND_DEBUG(DefaultChannel, 16, max3100_rx_buf); ***/
+  /***     DOWNLINK_SEND_DEBUG(DefaultChannel, DefaultDevice, 16, max3100_rx_buf); ***/
 }
diff --git a/sw/airborne/modules/meteo/charge_sens.c b/sw/airborne/modules/meteo/charge_sens.c
index aef1b1f51e..39f47afb7b 100644
--- a/sw/airborne/modules/meteo/charge_sens.c
+++ b/sw/airborne/modules/meteo/charge_sens.c
@@ -64,7 +64,7 @@ void charge_sens_event( void ) {
     charge_trans.status = I2CTransDone;
 
     if (++charge_cnt >= CHARGE_NB) {
-      DOWNLINK_SEND_ATMOSPHERE_CHARGE(DefaultChannel,
+      DOWNLINK_SEND_ATMOSPHERE_CHARGE(DefaultChannel, DefaultDevice,
           &charge[0], &charge[1], &charge[2], &charge[3], &charge[4],
           &charge[5], &charge[6], &charge[7], &charge[8], &charge[9]);
       charge_cnt = 0;
diff --git a/sw/airborne/modules/meteo/dust_gp2y.c b/sw/airborne/modules/meteo/dust_gp2y.c
index 4c77d288d0..114e0e67dd 100644
--- a/sw/airborne/modules/meteo/dust_gp2y.c
+++ b/sw/airborne/modules/meteo/dust_gp2y.c
@@ -77,7 +77,7 @@ void dust_gp2y_event( void ) {
     if (dust_gp2y_density_f < 0)
       dust_gp2y_density_f = 0;
 
-    DOWNLINK_SEND_GP2Y_STATUS(DefaultChannel, &dust_gp2y_density, &dust_gp2y_density_f);
+    DOWNLINK_SEND_GP2Y_STATUS(DefaultChannel, DefaultDevice, &dust_gp2y_density, &dust_gp2y_density_f);
 
     gp2y_trans.status = I2CTransDone;
   }
diff --git a/sw/airborne/modules/meteo/geiger_counter.c b/sw/airborne/modules/meteo/geiger_counter.c
index ad5d813cce..ca3aba01cf 100644
--- a/sw/airborne/modules/meteo/geiger_counter.c
+++ b/sw/airborne/modules/meteo/geiger_counter.c
@@ -70,7 +70,7 @@ void geiger_counter_event( void ) {
 
     if (volt_geiger & 0x8000) {
       volt_geiger &= 0x7FFF;
-      DOWNLINK_SEND_GEIGER_COUNTER(DefaultChannel,
+      DOWNLINK_SEND_GEIGER_COUNTER(DefaultChannel, DefaultDevice,
           &count_geiger_1, &count_geiger_2, &volt_geiger);
     }
   }
diff --git a/sw/airborne/modules/meteo/humid_dpicco.c b/sw/airborne/modules/meteo/humid_dpicco.c
index d76cfb58e8..85187d385c 100644
--- a/sw/airborne/modules/meteo/humid_dpicco.c
+++ b/sw/airborne/modules/meteo/humid_dpicco.c
@@ -51,7 +51,7 @@ void dpicco_event( void ) {
     dpicco_humid = (dpicco_val[0] * DPICCO_HUMID_RANGE) / DPICCO_HUMID_MAX;
     dpicco_temp = ((dpicco_val[1] * DPICCO_TEMP_RANGE) / DPICCO_TEMP_MAX) + DPICCO_TEMP_OFFS;
 
-    DOWNLINK_SEND_DPICCO_STATUS(DefaultChannel, &dpicco_val[0], &dpicco_val[1], &dpicco_humid, &dpicco_temp);
+    DOWNLINK_SEND_DPICCO_STATUS(DefaultChannel, DefaultDevice, &dpicco_val[0], &dpicco_val[1], &dpicco_humid, &dpicco_temp);
     dpicco_trans.status = I2CTransDone;
   }
 }
diff --git a/sw/airborne/modules/meteo/humid_hih.c b/sw/airborne/modules/meteo/humid_hih.c
index 8bba049e99..b901ae2c32 100644
--- a/sw/airborne/modules/meteo/humid_hih.c
+++ b/sw/airborne/modules/meteo/humid_hih.c
@@ -77,6 +77,6 @@ void humid_hih_periodic( void ) {
   /* temperature compensation */
   fhih_humid = fhih_humid/(1.0546 - (0.00216 * fhih_temp));
 
-  DOWNLINK_SEND_HIH_STATUS(DefaultChannel, &adc_humid_hih, &fhih_humid, &fhih_temp);
+  DOWNLINK_SEND_HIH_STATUS(DefaultChannel, DefaultDevice, &adc_humid_hih, &fhih_humid, &fhih_temp);
 }
 
diff --git a/sw/airborne/modules/meteo/humid_htm_b71.c b/sw/airborne/modules/meteo/humid_htm_b71.c
index 0428145a1f..aa011ca74f 100644
--- a/sw/airborne/modules/meteo/humid_htm_b71.c
+++ b/sw/airborne/modules/meteo/humid_htm_b71.c
@@ -93,7 +93,7 @@ void humid_htm_event( void ) {
         /* temperature */
         temphtm = (htm_trans.buf[2] << 6) | (htm_trans.buf[3] >> 2);
         ftemphtm = -40.00 + 0.01 * temphtm;
-        DOWNLINK_SEND_HTM_STATUS(DefaultChannel, &humidhtm, &temphtm, &fhumidhtm, &ftemphtm);
+        DOWNLINK_SEND_HTM_STATUS(DefaultChannel, DefaultDevice, &humidhtm, &temphtm, &fhumidhtm, &ftemphtm);
       }
       htm_trans.status = I2CTransDone;
       break;
diff --git a/sw/airborne/modules/meteo/humid_pcap01.c b/sw/airborne/modules/meteo/humid_pcap01.c
index f71015a0e6..29fb221dc8 100644
--- a/sw/airborne/modules/meteo/humid_pcap01.c
+++ b/sw/airborne/modules/meteo/humid_pcap01.c
@@ -246,7 +246,7 @@ void pcap01_event(void)
 	 	pcap01Value.R_ratio |= pcap01_trans.buf[2];
 		humidity = pcap01Value.C_ratio * (-0.0023959245437) + 516.4124438673063;
 		temperature = pcap01Value.R_ratio * 61.927 - 259.74;
-		DOWNLINK_SEND_PCAP01_STATUS(DefaultChannel,
+		DOWNLINK_SEND_PCAP01_STATUS(DefaultChannel, DefaultDevice,
 				&pcap01Value.C_ratio,
 				&pcap01Value.R_ratio,
 				&humidity,
diff --git a/sw/airborne/modules/meteo/humid_sht.c b/sw/airborne/modules/meteo/humid_sht.c
index 8a78b4827e..2de7164e4d 100644
--- a/sw/airborne/modules/meteo/humid_sht.c
+++ b/sw/airborne/modules/meteo/humid_sht.c
@@ -320,7 +320,7 @@ void humid_sht_periodic(void) {
       s_connectionreset();
       s_start_measure(HUMI);
       humid_sht_status = SHT_MEASURING_HUMID;
-      DOWNLINK_SEND_SHT_STATUS(DefaultChannel, &humidsht, &tempsht, &fhumidsht, &ftempsht);
+      DOWNLINK_SEND_SHT_STATUS(DefaultChannel, DefaultDevice, &humidsht, &tempsht, &fhumidsht, &ftempsht);
       humid_sht_available = FALSE;
     }
   }
diff --git a/sw/airborne/modules/meteo/humid_sht_i2c.c b/sw/airborne/modules/meteo/humid_sht_i2c.c
index b2da45e725..5f498c2c13 100644
--- a/sw/airborne/modules/meteo/humid_sht_i2c.c
+++ b/sw/airborne/modules/meteo/humid_sht_i2c.c
@@ -102,7 +102,7 @@ void humid_sht_periodic_i2c( void ) {
     sht_status = SHT2_TRIG_TEMP;
     I2CTransmit(SHT_I2C_DEV, sht_trans, SHT_SLAVE_ADDR, 1);
     /* send serial number every 30 seconds */
-    RunOnceEvery((4*30), DOWNLINK_SEND_SHT_I2C_SERIAL(DefaultChannel, &sht_serial1, &sht_serial2));
+    RunOnceEvery((4*30), DOWNLINK_SEND_SHT_I2C_SERIAL(DefaultChannel, DefaultDevice, &sht_serial1, &sht_serial2));
     break;
   }
 }
@@ -167,7 +167,7 @@ void humid_sht_event_i2c( void ) {
       sht_trans.status = I2CTransDone;
 
       if (humid_sht_crc(sht_trans.buf) == 0) {
-        DOWNLINK_SEND_SHT_I2C_STATUS(DefaultChannel, &humidsht_i2c, &tempsht_i2c, &fhumidsht_i2c, &ftempsht_i2c);
+        DOWNLINK_SEND_SHT_I2C_STATUS(DefaultChannel, DefaultDevice, &humidsht_i2c, &tempsht_i2c, &fhumidsht_i2c, &ftempsht_i2c);
       }
       break;
 
@@ -197,7 +197,7 @@ void humid_sht_event_i2c( void ) {
       sht_serial[6] = sht_trans.buf[4];
       sht_serial1=sht_serial[7]<<24|sht_serial[6]<<16|sht_serial[5]<<8|sht_serial[4];
       sht_serial2=sht_serial[3]<<24|sht_serial[2]<<16|sht_serial[1]<<8|sht_serial[0];
-      DOWNLINK_SEND_SHT_I2C_SERIAL(DefaultChannel, &sht_serial1, &sht_serial2);
+      DOWNLINK_SEND_SHT_I2C_SERIAL(DefaultChannel, DefaultDevice, &sht_serial1, &sht_serial2);
       sht_status = SHT2_IDLE;
       sht_trans.status = I2CTransDone;
       break;
diff --git a/sw/airborne/modules/meteo/ir_mlx.c b/sw/airborne/modules/meteo/ir_mlx.c
index 40f9739549..d11e3eb3f8 100644
--- a/sw/airborne/modules/meteo/ir_mlx.c
+++ b/sw/airborne/modules/meteo/ir_mlx.c
@@ -76,7 +76,7 @@ void ir_mlx_periodic( void ) {
       I2CTransceive(MLX_I2C_DEV, mlx_trans, MLX90614_ADDR, 1, 2);
       ir_mlx_status = IR_MLX_RD_CASE_TEMP;
       /* send serial number every 30 seconds */
-      RunOnceEvery((8*30), DOWNLINK_SEND_MLX_SERIAL(DefaultChannel, &ir_mlx_id_01, &ir_mlx_id_23));
+      RunOnceEvery((8*30), DOWNLINK_SEND_MLX_SERIAL(DefaultChannel, DefaultDevice, &ir_mlx_id_01, &ir_mlx_id_23));
     } else if (ir_mlx_status == IR_MLX_UNINIT) {
       /* start two byte ID 0 */
       mlx_trans.buf[0] = MLX90614_ID_0;
@@ -126,7 +126,7 @@ void ir_mlx_event( void ) {
       ir_mlx_id_23 |= mlx_trans.buf[1] << 24;
       ir_mlx_status = IR_MLX_IDLE;
       mlx_trans.status = I2CTransDone;
-      DOWNLINK_SEND_MLX_SERIAL(DefaultChannel, &ir_mlx_id_01, &ir_mlx_id_23);
+      DOWNLINK_SEND_MLX_SERIAL(DefaultChannel, DefaultDevice, &ir_mlx_id_01, &ir_mlx_id_23);
       break;
 
     case IR_MLX_RD_CASE_TEMP:
@@ -148,7 +148,7 @@ void ir_mlx_event( void ) {
       ir_mlx_temp_obj = ir_mlx_itemp_obj*0.02 - 273.15;
       mlx_trans.status = I2CTransDone;
 
-      DOWNLINK_SEND_MLX_STATUS(DefaultChannel,
+      DOWNLINK_SEND_MLX_STATUS(DefaultChannel, DefaultDevice,
                               &ir_mlx_itemp_case,
                               &ir_mlx_temp_case,
                               &ir_mlx_itemp_obj,
diff --git a/sw/airborne/modules/meteo/light_solar.c b/sw/airborne/modules/meteo/light_solar.c
index 43f1e0735c..72f28005fa 100644
--- a/sw/airborne/modules/meteo/light_solar.c
+++ b/sw/airborne/modules/meteo/light_solar.c
@@ -70,7 +70,7 @@ void light_solar_periodic( void ) {
   /* 10k/10k voltage divider, 10 bits adc, 3.3V max */
 
   if (++light_cnt >= LIGHT_NB) {
-    DOWNLINK_SEND_SOLAR_RADIATION(DefaultChannel,
+    DOWNLINK_SEND_SOLAR_RADIATION(DefaultChannel, DefaultDevice,
           &up[0], &dn[0], &up[1], &dn[1], &up[2], &dn[2], &up[3], &dn[3],
           &up[4], &dn[4], &up[5], &dn[5], &up[6], &dn[6], &up[7], &dn[7],
           &up[8], &dn[8], &up[9], &dn[9]);
diff --git a/sw/airborne/modules/meteo/light_temt.c b/sw/airborne/modules/meteo/light_temt.c
index 518af5f637..0f94b70a1b 100644
--- a/sw/airborne/modules/meteo/light_temt.c
+++ b/sw/airborne/modules/meteo/light_temt.c
@@ -63,6 +63,6 @@ void light_temt_periodic( void ) {
   /* 3.6k/6.8k voltage divider, 10 bits adc */
   f_light_temt = (adc_light_temt / 1024.) * 100.;
 
-  DOWNLINK_SEND_TEMT_STATUS(DefaultChannel, &adc_light_temt, &f_light_temt);
+  DOWNLINK_SEND_TEMT_STATUS(DefaultChannel, DefaultDevice, &adc_light_temt, &f_light_temt);
 }
 
diff --git a/sw/airborne/modules/meteo/temp_lm75.c b/sw/airborne/modules/meteo/temp_lm75.c
index 3f8ade169b..c66b775b52 100644
--- a/sw/airborne/modules/meteo/temp_lm75.c
+++ b/sw/airborne/modules/meteo/temp_lm75.c
@@ -77,7 +77,7 @@ void lm75_event( void ) {
 
     flm75_temperature = ((int16_t) lm75_temperature) / 2.;
 
-    DOWNLINK_SEND_TMP_STATUS(DefaultChannel, &lm75_temperature, &flm75_temperature);
+    DOWNLINK_SEND_TMP_STATUS(DefaultChannel, DefaultDevice, &lm75_temperature, &flm75_temperature);
     lm75_trans.status = I2CTransDone;
   }
 }
diff --git a/sw/airborne/modules/meteo/temp_tcouple_adc.c b/sw/airborne/modules/meteo/temp_tcouple_adc.c
index 9703883b83..1005874ec2 100644
--- a/sw/airborne/modules/meteo/temp_tcouple_adc.c
+++ b/sw/airborne/modules/meteo/temp_tcouple_adc.c
@@ -80,7 +80,7 @@ void temp_tcouple_adc_periodic( void ) {
                      * 100. - 13.;
 
   if (++temp_cnt >= TCOUPLE_NB) {
-    DOWNLINK_SEND_TEMP_TCOUPLE(DefaultChannel,
+    DOWNLINK_SEND_TEMP_TCOUPLE(DefaultChannel, DefaultDevice,
           &fval[0], &fval[1], &fval[2], &fval[3],
           &fref[0], &fref[1], &fref[2], &fref[3],
           &val[0], &val[1], &val[2], &val[3],
diff --git a/sw/airborne/modules/meteo/temp_temod.c b/sw/airborne/modules/meteo/temp_temod.c
index 8115a62295..67fb01362d 100644
--- a/sw/airborne/modules/meteo/temp_temod.c
+++ b/sw/airborne/modules/meteo/temp_temod.c
@@ -72,7 +72,7 @@ void temod_event( void ) {
 
       ftmd_temperature = (tmd_temperature / TEMOD_TYPE) - 32.;
 
-      DOWNLINK_SEND_TMP_STATUS(DefaultChannel, &tmd_temperature, &ftmd_temperature);
+      DOWNLINK_SEND_TMP_STATUS(DefaultChannel, DefaultDevice, &tmd_temperature, &ftmd_temperature);
       tmd_trans.status = I2CTransDone;
   }
 }
diff --git a/sw/airborne/modules/meteo/temp_tmp102.c b/sw/airborne/modules/meteo/temp_tmp102.c
index 5507e46398..d1856fa6ec 100644
--- a/sw/airborne/modules/meteo/temp_tmp102.c
+++ b/sw/airborne/modules/meteo/temp_tmp102.c
@@ -95,7 +95,7 @@ void tmp102_event( void ) {
 
       ftmp_temperature = ((int16_t) tmp_temperature) / 16.;
 
-      DOWNLINK_SEND_TMP_STATUS(DefaultChannel, &tmp_temperature, &ftmp_temperature);
+      DOWNLINK_SEND_TMP_STATUS(DefaultChannel, DefaultDevice, &tmp_temperature, &ftmp_temperature);
       tmp_trans.status = I2CTransDone;
   }
 }
diff --git a/sw/airborne/modules/meteo/wind_gfi.c b/sw/airborne/modules/meteo/wind_gfi.c
index 3b23ed0744..75b0f19c55 100644
--- a/sw/airborne/modules/meteo/wind_gfi.c
+++ b/sw/airborne/modules/meteo/wind_gfi.c
@@ -105,7 +105,7 @@ void wind_gfi_event( void ) {
       /* 2048 digits per 360 degrees */
       fpcf_direction = fmod((pcf_direction * (360./2048.)) + ZERO_OFFSET_DEGREES, 360.);
 
-      DOWNLINK_SEND_TMP_STATUS(DefaultChannel, &pcf_direction, &fpcf_direction);
+      DOWNLINK_SEND_TMP_STATUS(DefaultChannel, DefaultDevice, &pcf_direction, &fpcf_direction);
     }
     else if (pcf_status == PCF_IDLE) {
       pcf_trans.status = I2CTransDone;
diff --git a/sw/airborne/modules/meteo/windturbine.c b/sw/airborne/modules/meteo/windturbine.c
index 9d1293115a..5b81a6b847 100644
--- a/sw/airborne/modules/meteo/windturbine.c
+++ b/sw/airborne/modules/meteo/windturbine.c
@@ -52,7 +52,7 @@ void windturbine_periodic( void ) {
     sync_itow = gps_tow_from_ticks(trigger_t0);
     cycle_time = MSEC_OF_SYS_TICS(trigger_delta_t0);
 
-    DOWNLINK_SEND_WINDTURBINE_STATUS_(DefaultChannel,
+    DOWNLINK_SEND_WINDTURBINE_STATUS_(DefaultChannel, DefaultDevice,
                 &ac_id,
                 &turb_id,
                 &sync_itow,
diff --git a/sw/airborne/modules/multi/formation.c b/sw/airborne/modules/multi/formation.c
index 433886b68f..0377137ffd 100644
--- a/sw/airborne/modules/multi/formation.c
+++ b/sw/airborne/modules/multi/formation.c
@@ -85,7 +85,7 @@ int formation_init(void) {
 
 int add_slot(uint8_t _id, float slot_e, float slot_n, float slot_a) {
   if (_id != AC_ID && the_acs_id[_id] == 0) return FALSE; // no info for this AC
-  DOWNLINK_SEND_FORMATION_SLOT_TM(DefaultChannel,&_id, &form_mode, &slot_e, &slot_n, &slot_a);
+  DOWNLINK_SEND_FORMATION_SLOT_TM(DefaultChannel, DefaultDevice,&_id, &form_mode, &slot_e, &slot_n, &slot_a);
   formation[the_acs_id[_id]].status = IDLE;
   formation[the_acs_id[_id]].east = slot_e;
   formation[the_acs_id[_id]].north = slot_n;
@@ -100,7 +100,7 @@ int start_formation(void) {
     if (formation[i].status == IDLE) formation[i].status = ACTIVE;
   }
   enum slot_status active = ACTIVE;
-  DOWNLINK_SEND_FORMATION_STATUS_TM(DefaultChannel,&ac_id,&leader_id,&active);
+  DOWNLINK_SEND_FORMATION_STATUS_TM(DefaultChannel, DefaultDevice,&ac_id,&leader_id,&active);
   // store current cruise and alt
   old_cruise = v_ctl_auto_throttle_cruise_throttle;
   old_alt = nav_altitude;
@@ -114,7 +114,7 @@ int stop_formation(void) {
     if (formation[i].status == ACTIVE) formation[i].status = IDLE;
   }
   enum slot_status idle = IDLE;
-  DOWNLINK_SEND_FORMATION_STATUS_TM(DefaultChannel,&ac_id,&leader_id,&idle);
+  DOWNLINK_SEND_FORMATION_STATUS_TM(DefaultChannel, DefaultDevice,&ac_id,&leader_id,&idle);
   // restore cruise and alt
   v_ctl_auto_throttle_cruise_throttle = old_cruise;
   old_cruise = V_CTL_AUTO_THROTTLE_NOMINAL_CRUISE_THROTTLE;
@@ -147,10 +147,10 @@ int formation_flight(void) {
   // broadcast info
   uint8_t ac_id = AC_ID;
   enum slot_status status = formation[the_acs_id[AC_ID]].status;
-  DOWNLINK_SEND_FORMATION_STATUS_TM(DefaultChannel,&ac_id,&leader_id,&status);
+  DOWNLINK_SEND_FORMATION_STATUS_TM(DefaultChannel, DefaultDevice,&ac_id,&leader_id,&status);
   if (++_1Hz>=4) {
     _1Hz=0;
-    DOWNLINK_SEND_FORMATION_SLOT_TM(DefaultChannel,&ac_id, &form_mode,
+    DOWNLINK_SEND_FORMATION_SLOT_TM(DefaultChannel, DefaultDevice,&ac_id, &form_mode,
         &formation[the_acs_id[AC_ID]].east,
         &formation[the_acs_id[AC_ID]].north,
         &formation[the_acs_id[AC_ID]].alt);
diff --git a/sw/airborne/modules/multi/potential.c b/sw/airborne/modules/multi/potential.c
index e618cf55ed..fe82759935 100644
--- a/sw/airborne/modules/multi/potential.c
+++ b/sw/airborne/modules/multi/potential.c
@@ -124,7 +124,7 @@ int potential_task(void) {
   BoundAbs(potential_force.climb, V_CTL_ALTITUDE_MAX_CLIMB);
   NavVerticalClimbMode(potential_force.climb);
 
-  DOWNLINK_SEND_POTENTIAL(DefaultChannel,&potential_force.east,&potential_force.north,&potential_force.alt,&potential_force.speed,&potential_force.climb);
+  DOWNLINK_SEND_POTENTIAL(DefaultChannel, DefaultDevice,&potential_force.east,&potential_force.north,&potential_force.alt,&potential_force.speed,&potential_force.climb);
 
   return TRUE;
 }
diff --git a/sw/airborne/modules/multi/tcas.c b/sw/airborne/modules/multi/tcas.c
index 4ed5c01101..518d1c4c02 100644
--- a/sw/airborne/modules/multi/tcas.c
+++ b/sw/airborne/modules/multi/tcas.c
@@ -140,7 +140,7 @@ void tcas_periodic_task_1Hz( void ) {
         if (tau >= TCAS_HUGE_TAU && !inside) {
           tcas_acs_status[i].status = TCAS_NO_ALARM; // conflict is now resolved
           tcas_acs_status[i].resolve = RA_NONE;
-          DOWNLINK_SEND_TCAS_RESOLVED(DefaultChannel,&(the_acs[i].ac_id));
+          DOWNLINK_SEND_TCAS_RESOLVED(DefaultChannel, DefaultDevice,&(the_acs[i].ac_id));
         }
         break;
       case TCAS_TA:
@@ -148,25 +148,25 @@ void tcas_periodic_task_1Hz( void ) {
           tcas_acs_status[i].status = TCAS_RA; // TA -> RA
           // Downlink alert
           //test_dir = tcas_test_direction(the_acs[i].ac_id);
-          //DOWNLINK_SEND_TCAS_RA(DefaultChannel,&(the_acs[i].ac_id),&test_dir);// FIXME only one closest AC ???
+          //DOWNLINK_SEND_TCAS_RA(DefaultChannel, DefaultDevice,&(the_acs[i].ac_id),&test_dir);// FIXME only one closest AC ???
           break;
         }
         if (tau > tcas_tau_ta && !inside)
           tcas_acs_status[i].status = TCAS_NO_ALARM; // conflict is now resolved
           tcas_acs_status[i].resolve = RA_NONE;
-          DOWNLINK_SEND_TCAS_RESOLVED(DefaultChannel,&(the_acs[i].ac_id));
+          DOWNLINK_SEND_TCAS_RESOLVED(DefaultChannel, DefaultDevice,&(the_acs[i].ac_id));
         break;
       case TCAS_NO_ALARM:
         if (tau < tcas_tau_ta || inside) {
           tcas_acs_status[i].status = TCAS_TA; // NO_ALARM -> TA
           // Downlink warning
-          DOWNLINK_SEND_TCAS_TA(DefaultChannel,&(the_acs[i].ac_id));
+          DOWNLINK_SEND_TCAS_TA(DefaultChannel, DefaultDevice,&(the_acs[i].ac_id));
         }
         if (tau < tcas_tau_ra || inside) {
           tcas_acs_status[i].status = TCAS_RA; // NO_ALARM -> RA = big problem ?
           // Downlink alert
           //test_dir = tcas_test_direction(the_acs[i].ac_id);
-          //DOWNLINK_SEND_TCAS_RA(DefaultChannel,&(the_acs[i].ac_id),&test_dir);
+          //DOWNLINK_SEND_TCAS_RA(DefaultChannel, DefaultDevice,&(the_acs[i].ac_id),&test_dir);
         }
         break;
     }
@@ -207,11 +207,11 @@ void tcas_periodic_task_1Hz( void ) {
       }
     }
     // Downlink alert
-    DOWNLINK_SEND_TCAS_RA(DefaultChannel,&tcas_ac_RA,&tcas_resolve);
+    DOWNLINK_SEND_TCAS_RA(DefaultChannel, DefaultDevice,&tcas_ac_RA,&tcas_resolve);
   }
   else tcas_ac_RA = AC_ID; // no conflict
 #ifdef TCAS_DEBUG
-  if (tcas_status == TCAS_RA) DOWNLINK_SEND_TCAS_DEBUG(DefaultChannel,&ac_id_close,&tau_min);
+  if (tcas_status == TCAS_RA) DOWNLINK_SEND_TCAS_DEBUG(DefaultChannel, DefaultDevice,&ac_id_close,&tau_min);
 #endif
 }
 
diff --git a/sw/airborne/modules/sensors/AOA_adc.c b/sw/airborne/modules/sensors/AOA_adc.c
index 6eca31afaf..38b38e583f 100644
--- a/sw/airborne/modules/sensors/AOA_adc.c
+++ b/sw/airborne/modules/sensors/AOA_adc.c
@@ -75,7 +75,7 @@ void AOA_adc_update( void ) {
 	AOA = AOA_filter * AOA_old + (1 - AOA_filter) * (adc_AOA_val*(2*M_PI)/1024-M_PI+AOA_offset);
 	AOA_old = AOA;
 #endif
-	RunOnceEvery(30, DOWNLINK_SEND_AOA_adc(DefaultChannel, &adc_AOA_val, &AOA));
+	RunOnceEvery(30, DOWNLINK_SEND_AOA_adc(DefaultChannel, DefaultDevice, &adc_AOA_val, &AOA));
 
 #ifdef USE_AOA
 	EstimatorSetAOA(AOA);
diff --git a/sw/airborne/modules/sensors/airspeed_amsys.c b/sw/airborne/modules/sensors/airspeed_amsys.c
index 2929eae61f..93d981115f 100755
--- a/sw/airborne/modules/sensors/airspeed_amsys.c
+++ b/sw/airborne/modules/sensors/airspeed_amsys.c
@@ -149,9 +149,9 @@ void airspeed_amsys_read_event( void ) {
 		EstimatorSetAirspeed(airspeed_amsys);
 #endif
 #ifdef SENSOR_SYNC_SEND
-		DOWNLINK_SEND_AMSYS_AIRSPEED(DefaultChannel, &airspeed_amsys_raw, &pressure_amsys, &airspeed_tmp, &airspeed_amsys, &airspeed_temperature);
+		DOWNLINK_SEND_AMSYS_AIRSPEED(DefaultChannel, DefaultDevice, &airspeed_amsys_raw, &pressure_amsys, &airspeed_tmp, &airspeed_amsys, &airspeed_temperature);
 #else
-		RunOnceEvery(10, DOWNLINK_SEND_AMSYS_AIRSPEED(DefaultChannel, &airspeed_amsys_raw, &pressure_amsys, &airspeed_tmp, &airspeed_amsys, &airspeed_temperature));
+		RunOnceEvery(10, DOWNLINK_SEND_AMSYS_AIRSPEED(DefaultChannel, DefaultDevice, &airspeed_amsys_raw, &pressure_amsys, &airspeed_tmp, &airspeed_amsys, &airspeed_temperature));
 #endif
 	}
 
diff --git a/sw/airborne/modules/sensors/airspeed_ets.c b/sw/airborne/modules/sensors/airspeed_ets.c
index ef804c9455..1d416941b6 100644
--- a/sw/airborne/modules/sensors/airspeed_ets.c
+++ b/sw/airborne/modules/sensors/airspeed_ets.c
@@ -170,7 +170,7 @@ void airspeed_ets_read_event( void ) {
     EstimatorSetAirspeed(airspeed_ets);
 #endif
 #ifdef SENSOR_SYNC_SEND
-    DOWNLINK_SEND_AIRSPEED_ETS(DefaultChannel, &airspeed_ets_raw, &airspeed_ets_offset, &airspeed_ets);
+    DOWNLINK_SEND_AIRSPEED_ETS(DefaultChannel, DefaultDevice, &airspeed_ets_raw, &airspeed_ets_offset, &airspeed_ets);
 #endif
   } else {
     airspeed_ets = 0.0;
diff --git a/sw/airborne/modules/sensors/alt_srf08.c b/sw/airborne/modules/sensors/alt_srf08.c
index 6c16b24dd1..3b3b091efa 100644
--- a/sw/airborne/modules/sensors/alt_srf08.c
+++ b/sw/airborne/modules/sensors/alt_srf08.c
@@ -148,7 +148,7 @@ void srf08_event(void)
     else if (srf08_got) {
       srf08_got = FALSE;
       srf08_copy();
-      DOWNLINK_SEND_RANGEFINDER(DefaultChannel, &srf08_range, &f, &f, &f, &f, &f, &i);
+      DOWNLINK_SEND_RANGEFINDER(DefaultChannel, DefaultDevice, &srf08_range, &f, &f, &f, &f, &f, &i);
     }
   }
 }
diff --git a/sw/airborne/modules/sensors/baro_MS5534A.c b/sw/airborne/modules/sensors/baro_MS5534A.c
index ecd698bbed..e89f8519ea 100644
--- a/sw/airborne/modules/sensors/baro_MS5534A.c
+++ b/sw/airborne/modules/sensors/baro_MS5534A.c
@@ -209,7 +209,7 @@ static void calibration( void ) {
   ut1 = (c5 << 3) + 20224;
 
 #ifndef BARO_NO_DOWNLINK
-  DOWNLINK_SEND_BARO_WORDS(DefaultChannel, &words[0], &words[1], &words[2], &words[3]);
+  DOWNLINK_SEND_BARO_WORDS(DefaultChannel, DefaultDevice, &words[0], &words[1], &words[2], &words[3]);
 #endif
 }
 
diff --git a/sw/airborne/modules/sensors/baro_amsys.c b/sw/airborne/modules/sensors/baro_amsys.c
index 5f57af0dee..8e244f37e6 100755
--- a/sw/airborne/modules/sensors/baro_amsys.c
+++ b/sw/airborne/modules/sensors/baro_amsys.c
@@ -194,9 +194,9 @@ void baro_amsys_read_event( void ) {
 	// Transaction has been read
 	baro_amsys_i2c_trans.status = I2CTransDone;
 #ifdef SENSOR_SYNC_SEND
-	DOWNLINK_SEND_AMSYS_BARO(DefaultChannel, &pBaroRaw, &baro_amsys_p, &baro_amsys_offset, &ref_alt_init, &baro_amsys_abs_altitude, &baro_amsys_altitude, &baro_amsys_temp)
+	DOWNLINK_SEND_AMSYS_BARO(DefaultChannel, DefaultDevice, &pBaroRaw, &baro_amsys_p, &baro_amsys_offset, &ref_alt_init, &baro_amsys_abs_altitude, &baro_amsys_altitude, &baro_amsys_temp)
 #else
-	RunOnceEvery(10, DOWNLINK_SEND_AMSYS_BARO(DefaultChannel, &pBaroRaw, &baro_amsys_p, &baro_amsys_offset, &ref_alt_init, &baro_amsys_abs_altitude, &baro_amsys_altitude, &baro_amsys_temp));
+	RunOnceEvery(10, DOWNLINK_SEND_AMSYS_BARO(DefaultChannel, DefaultDevice, &pBaroRaw, &baro_amsys_p, &baro_amsys_offset, &ref_alt_init, &baro_amsys_abs_altitude, &baro_amsys_altitude, &baro_amsys_temp));
 #endif
 
 }
diff --git a/sw/airborne/modules/sensors/baro_bmp.c b/sw/airborne/modules/sensors/baro_bmp.c
index fdfff416b4..e6e424e5bc 100644
--- a/sw/airborne/modules/sensors/baro_bmp.c
+++ b/sw/airborne/modules/sensors/baro_bmp.c
@@ -166,7 +166,7 @@ void baro_bmp_event( void ) {
       baro_bmp_temperature = bmp_t;
       baro_bmp_pressure = bmp_p;
 #ifdef SENSOR_SYNC_SEND
-      DOWNLINK_SEND_BMP_STATUS(DefaultChannel, &bmp_up, &bmp_ut, &bmp_p, &bmp_t);
+      DOWNLINK_SEND_BMP_STATUS(DefaultChannel, DefaultDevice, &bmp_up, &bmp_ut, &bmp_p, &bmp_t);
 #endif
     }
   }
diff --git a/sw/airborne/modules/sensors/baro_ets.c b/sw/airborne/modules/sensors/baro_ets.c
index e8edfdbea6..4f9a355c0c 100644
--- a/sw/airborne/modules/sensors/baro_ets.c
+++ b/sw/airborne/modules/sensors/baro_ets.c
@@ -151,7 +151,7 @@ void baro_ets_read_event( void ) {
       // New value available
       EstimatorSetAlt(baro_ets_altitude);
 #ifdef BARO_ETS_TELEMETRY
-      DOWNLINK_SEND_BARO_ETS(DefaultChannel, &baro_ets_adc, &baro_ets_offset, &baro_ets_altitude);
+      DOWNLINK_SEND_BARO_ETS(DefaultChannel, DefaultDevice, &baro_ets_adc, &baro_ets_offset, &baro_ets_altitude);
 #endif
     } else {
       baro_ets_altitude = 0.0;
diff --git a/sw/airborne/modules/sensors/baro_ms5611_i2c.c b/sw/airborne/modules/sensors/baro_ms5611_i2c.c
index a60e7604f9..cab44e00fb 100644
--- a/sw/airborne/modules/sensors/baro_ms5611_i2c.c
+++ b/sw/airborne/modules/sensors/baro_ms5611_i2c.c
@@ -89,7 +89,7 @@ void baro_ms5611_periodic( void ) {
       ms5611_status = MS5611_CONV_D1;
       ms5611_trans.buf[0] = MS5611_START_CONV_D1;
       I2CTransmit(MS5611_I2C_DEV, ms5611_trans, MS5611_SLAVE_ADDR, 1);
-      RunOnceEvery((4*30), DOWNLINK_SEND_MS5611_COEFF(DefaultChannel,
+      RunOnceEvery((4*30), DOWNLINK_SEND_MS5611_COEFF(DefaultChannel, DefaultDevice,
           &ms5611_c[0], &ms5611_c[1], &ms5611_c[2], &ms5611_c[3],
           &ms5611_c[4], &ms5611_c[5], &ms5611_c[6], &ms5611_c[7]));
     }
@@ -152,7 +152,7 @@ void baro_ms5611_event( void ) {
         ms5611_trans.status = I2CTransDone;
         /* check prom crc */
         if (baro_ms5611_crc(ms5611_c) == 0) {
-          DOWNLINK_SEND_MS5611_COEFF(DefaultChannel,
+          DOWNLINK_SEND_MS5611_COEFF(DefaultChannel, DefaultDevice,
               &ms5611_c[0], &ms5611_c[1], &ms5611_c[2], &ms5611_c[3],
               &ms5611_c[4], &ms5611_c[5], &ms5611_c[6], &ms5611_c[7]);
           ms5611_status = MS5611_IDLE;
@@ -220,7 +220,7 @@ void baro_ms5611_event( void ) {
 #ifdef SENSOR_SYNC_SEND
       ftempms = tempms / 100.;
       fbaroms = baroms / 100.;
-      DOWNLINK_SEND_BARO_MS5611(DefaultChannel,
+      DOWNLINK_SEND_BARO_MS5611(DefaultChannel, DefaultDevice,
                                 &ms5611_d1, &ms5611_d2, &fbaroms, &ftempms);
 #endif
       break;
diff --git a/sw/airborne/modules/sensors/baro_scp.c b/sw/airborne/modules/sensors/baro_scp.c
index 4b974b367e..bc5d8286cd 100644
--- a/sw/airborne/modules/sensors/baro_scp.c
+++ b/sw/airborne/modules/sensors/baro_scp.c
@@ -179,7 +179,7 @@ static void baro_scp_read(void) {
 void baro_scp_event( void ) {
   if (baro_scp_available == TRUE) {
 #ifdef SENSOR_SYNC_SEND
-    DOWNLINK_SEND_SCP_STATUS(DefaultChannel, &baro_scp_pressure, &baro_scp_temperature);
+    DOWNLINK_SEND_SCP_STATUS(DefaultChannel, DefaultDevice, &baro_scp_pressure, &baro_scp_temperature);
 #endif
     baro_scp_available = FALSE;
   }
diff --git a/sw/airborne/modules/sensors/baro_scp_i2c.c b/sw/airborne/modules/sensors/baro_scp_i2c.c
index 6e78c63b9a..bed1c9899f 100644
--- a/sw/airborne/modules/sensors/baro_scp_i2c.c
+++ b/sw/airborne/modules/sensors/baro_scp_i2c.c
@@ -100,7 +100,7 @@ void baro_scp_event( void ) {
       baro_scp_pressure *= 25;
 
 #ifdef SENSOR_SYNC_SEND
-      DOWNLINK_SEND_SCP_STATUS(DefaultChannel, &baro_scp_pressure, &baro_scp_temperature);
+      DOWNLINK_SEND_SCP_STATUS(DefaultChannel, DefaultDevice, &baro_scp_pressure, &baro_scp_temperature);
 #endif
 
       baro_scp_status = BARO_SCP_IDLE;
diff --git a/sw/airborne/modules/sensors/imu_ppzuav.c b/sw/airborne/modules/sensors/imu_ppzuav.c
index 731f6da31f..b2371ae4e1 100644
--- a/sw/airborne/modules/sensors/imu_ppzuav.c
+++ b/sw/airborne/modules/sensors/imu_ppzuav.c
@@ -200,9 +200,9 @@ void imu_periodic( void )
 
 void ppzuavimu_module_downlink_raw( void )
 {
-  DOWNLINK_SEND_IMU_GYRO_RAW(DefaultChannel,&imu.gyro_unscaled.p,&imu.gyro_unscaled.q,&imu.gyro_unscaled.r);
-  DOWNLINK_SEND_IMU_ACCEL_RAW(DefaultChannel,&imu.accel_unscaled.x,&imu.accel_unscaled.y,&imu.accel_unscaled.z);
-  DOWNLINK_SEND_IMU_MAG_RAW(DefaultChannel,&imu.mag_unscaled.x,&imu.mag_unscaled.y,&imu.mag_unscaled.z);
+  DOWNLINK_SEND_IMU_GYRO_RAW(DefaultChannel, DefaultDevice,&imu.gyro_unscaled.p,&imu.gyro_unscaled.q,&imu.gyro_unscaled.r);
+  DOWNLINK_SEND_IMU_ACCEL_RAW(DefaultChannel, DefaultDevice,&imu.accel_unscaled.x,&imu.accel_unscaled.y,&imu.accel_unscaled.z);
+  DOWNLINK_SEND_IMU_MAG_RAW(DefaultChannel, DefaultDevice,&imu.mag_unscaled.x,&imu.mag_unscaled.y,&imu.mag_unscaled.z);
 }
 
 void ppzuavimu_module_event( void )
diff --git a/sw/airborne/modules/sensors/mag_hmc5843.c b/sw/airborne/modules/sensors/mag_hmc5843.c
index 75cdfe1feb..07a7b8e5d7 100644
--- a/sw/airborne/modules/sensors/mag_hmc5843.c
+++ b/sw/airborne/modules/sensors/mag_hmc5843.c
@@ -46,7 +46,7 @@ void hmc5843_module_periodic ( void )
   mag_x = hmc5843.data.value[0];
   mag_y = hmc5843.data.value[1];
   mag_z = hmc5843.data.value[2];
-  RunOnceEvery(30,DOWNLINK_SEND_IMU_MAG_RAW(DefaultChannel,&mag_x,&mag_y,&mag_z));
+  RunOnceEvery(30,DOWNLINK_SEND_IMU_MAG_RAW(DefaultChannel, DefaultDevice,&mag_x,&mag_y,&mag_z));
 }
 
 void hmc5843_module_event( void )
diff --git a/sw/airborne/modules/sensors/mag_hmc58xx.c b/sw/airborne/modules/sensors/mag_hmc58xx.c
index 2ae1bfd5df..e719d49191 100644
--- a/sw/airborne/modules/sensors/mag_hmc58xx.c
+++ b/sw/airborne/modules/sensors/mag_hmc58xx.c
@@ -30,6 +30,6 @@
 
 void mag_hmc58xx_report( void )
 {
-  DOWNLINK_SEND_IMU_MAG_RAW(DefaultChannel,&hmc58xx_data.x,&hmc58xx_data.y,&hmc58xx_data.z);
+  DOWNLINK_SEND_IMU_MAG_RAW(DefaultChannel, DefaultDevice,&hmc58xx_data.x,&hmc58xx_data.y,&hmc58xx_data.z);
 }
 
diff --git a/sw/airborne/modules/sensors/mag_micromag_fw.c b/sw/airborne/modules/sensors/mag_micromag_fw.c
index 92a7a7e168..33d7356c60 100644
--- a/sw/airborne/modules/sensors/mag_micromag_fw.c
+++ b/sw/airborne/modules/sensors/mag_micromag_fw.c
@@ -39,7 +39,7 @@ void micromag_event( void ) {
   int32_t mz=micromag_values[2];
 
   if (micromag_status == MM_DATA_AVAILABLE) {
-    DOWNLINK_SEND_IMU_MAG_RAW(DefaultChannel,
+    DOWNLINK_SEND_IMU_MAG_RAW(DefaultChannel, DefaultDevice,
                 &mx,
                 &my,
                 &mz );
diff --git a/sw/airborne/modules/sensors/pressure_board_navarro.h b/sw/airborne/modules/sensors/pressure_board_navarro.h
index 5b1fe68bff..f5e78f2a2f 100644
--- a/sw/airborne/modules/sensors/pressure_board_navarro.h
+++ b/sw/airborne/modules/sensors/pressure_board_navarro.h
@@ -54,6 +54,6 @@ extern void pbn_read_event( void );
 
 #define PbnEvent() { if (pbn_trans.status == I2CTransSuccess) pbn_read_event(); }
 
-#define PERIODIC_SEND_PBN(_chan) DOWNLINK_SEND_PBN(DefaultChannel,&airspeed_adc,&altitude_adc,&pbn_airspeed,&pbn_altitude,&airspeed_offset,&altitude_offset);
+#define PERIODIC_SEND_PBN(_chan) DOWNLINK_SEND_PBN(DefaultChannel, DefaultDevice,&airspeed_adc,&altitude_adc,&pbn_airspeed,&pbn_altitude,&airspeed_offset,&altitude_offset);
 
 #endif // PRESSURE_BOARD_NAVARRO_H
diff --git a/sw/airborne/modules/sensors/trigger_ext.c b/sw/airborne/modules/sensors/trigger_ext.c
index 066d173603..35ee19e9e3 100644
--- a/sw/airborne/modules/sensors/trigger_ext.c
+++ b/sw/airborne/modules/sensors/trigger_ext.c
@@ -52,7 +52,7 @@ void trigger_ext_periodic( void ) {
     sync_itow = gps_tow_from_ticks(trigger_t0);
     cycle_time =  MSEC_OF_SYS_TICS(delta_t0);
 
-    DOWNLINK_SEND_WINDTURBINE_STATUS_(DefaultChannel,
+    DOWNLINK_SEND_WINDTURBINE_STATUS_(DefaultChannel, DefaultDevice,
                 &ac_id,
                 &turb_id,
                 &sync_itow,
diff --git a/sw/airborne/peripherals/mcp355x.c b/sw/airborne/peripherals/mcp355x.c
index 807f60f069..7cf0892807 100644
--- a/sw/airborne/peripherals/mcp355x.c
+++ b/sw/airborne/peripherals/mcp355x.c
@@ -65,8 +65,8 @@ void mcp355x_event(void) {
           ((uint32_t)mcp355x_spi_buf[2]<<1) |
           (mcp355x_spi_buf[3]>>7));
       filtered = (5*filtered + mcp355x_data) / (6);
-      DOWNLINK_SEND_DEBUG(DefaultChannel,4,mcp355x_spi_buf);
-      DOWNLINK_SEND_BARO_RAW(DefaultChannel,&mcp355x_data,&filtered);
+      DOWNLINK_SEND_DEBUG(DefaultChannel, DefaultDevice,4,mcp355x_spi_buf);
+      DOWNLINK_SEND_BARO_RAW(DefaultChannel, DefaultDevice,&mcp355x_data,&filtered);
     }
   }
 }
diff --git a/sw/airborne/subsystems/ahrs/ahrs_float_dcm.c b/sw/airborne/subsystems/ahrs/ahrs_float_dcm.c
index e9ddafc2be..fa8a5775f9 100644
--- a/sw/airborne/subsystems/ahrs/ahrs_float_dcm.c
+++ b/sw/airborne/subsystems/ahrs/ahrs_float_dcm.c
@@ -144,7 +144,7 @@ void ahrs_update_fw_estimator( void )
   estimator_q = ahrs_float.body_rate.q;
   estimator_r = ahrs_float.body_rate.r;
 /*
-  RunOnceEvery(6,DOWNLINK_SEND_RMAT_DEBUG(DefaultChannel,
+  RunOnceEvery(6,DOWNLINK_SEND_RMAT_DEBUG(DefaultChannel, DefaultDevice,
     &(DCM_Matrix[0][0]),
     &(DCM_Matrix[0][1]),
     &(DCM_Matrix[0][2]),
@@ -318,7 +318,7 @@ void ahrs_update_mag(void)
   ltp_mag.y = MAG_Heading_Y;
 
   // Downlink
-  RunOnceEvery(10,DOWNLINK_SEND_IMU_MAG(DefaultChannel, &ltp_mag.x, &ltp_mag.y, &ltp_mag.z));
+  RunOnceEvery(10,DOWNLINK_SEND_IMU_MAG(DefaultChannel, DefaultDevice, &ltp_mag.x, &ltp_mag.y, &ltp_mag.z));
 
   // Magnetic Heading
   // MAG_Heading = atan2(imu.mag.y, -imu.mag.x);
diff --git a/sw/airborne/subsystems/datalink/downlink.h b/sw/airborne/subsystems/datalink/downlink.h
index be2a1034ec..64fd1e067b 100644
--- a/sw/airborne/subsystems/datalink/downlink.h
+++ b/sw/airborne/subsystems/datalink/downlink.h
@@ -62,12 +62,40 @@
 #define DefaultChannel DOWNLINK_TRANSPORT
 #endif
 
+#ifndef DefaultDevice
+#define DefaultDevice DOWNLINK_DEVICE
+#endif
+
 /** Counter of messages not sent because of unavailibity of the output buffer*/
 extern uint8_t downlink_nb_ovrn;
 extern uint16_t downlink_nb_bytes;
 extern uint16_t downlink_nb_msgs;
 
+/* TransportOfDownlink and DeviceOfDownlink macros
+ *
+ * returns transport or device from a channel
+ *
+ * chan: (transport, device)
+ * TransOfDL(transport, device) returns transport
+ * DevOfDL(transport, device) returns device
+ */
+#define TransOfDL(_trans, _dev) _trans
+#define DevOfDL(_trans, _dev) _dev
 
+#define __TOD(_chan) TransOfDL##_chan
+#define _TOD(_chan) __TOD(_chan)
+//#define TransportOfDownlink(_chan) _TOD(_chan)
+#define TransportOfDownlink(_chan) TransOfDL(_chan)
+
+#define __DOD(_chan) DevOfDL##_chan
+#define _DOD(_chan) __DOD(_chan)
+//#define DeviceOfDownlink(_chan) _DOD(_chan)
+#define DeviceOfDownlink(_chan) DevOfDL(_chan)
+
+/* Transport macros
+ *
+ * call transport functions from channel
+ */
 #define __Transport(dev, _x) dev##_x
 #define _Transport(dev, _x) __Transport(dev, _x)
 #define Transport(_chan, _fun) _Transport(_chan, _fun)
@@ -75,41 +103,41 @@ extern uint16_t downlink_nb_msgs;
 
 /** Set of macros for generated code (messages.h) from messages.xml */
 /** 2 = ac_id + msg_id */
-#define DownlinkIDsSize(_chan, _x) (_x+2)
-#define DownlinkSizeOf(_chan, _x) Transport(_chan, SizeOf(DownlinkIDsSize(_chan, _x)))
+#define DownlinkIDsSize(_trans, _dev, _x) (_x+2)
+#define DownlinkSizeOf(_trans, _dev, _x) Transport(_trans, SizeOf(DownlinkIDsSize(_trans, _dev, _x)))
 
-#define DownlinkCheckFreeSpace(_chan, _x) Transport(_chan, CheckFreeSpace((uint8_t)(_x)))
+#define DownlinkCheckFreeSpace(_trans, _dev, _x) Transport(_trans, CheckFreeSpace(_dev, (uint8_t)(_x)))
 
-#define DownlinkPutUint8(_chan, _x) Transport(_chan, PutUint8(_x))
+#define DownlinkPutUint8(_trans, _dev, _x) Transport(_trans, PutUint8(_dev, _x))
 
-#define DownlinkPutInt8ByAddr(_chan, _x) Transport(_chan, PutInt8ByAddr(_x))
-#define DownlinkPutUint8ByAddr(_chan, _x) Transport(_chan, PutUint8ByAddr(_x))
-#define DownlinkPutInt16ByAddr(_chan, _x) Transport(_chan, PutInt16ByAddr(_x))
-#define DownlinkPutUint16ByAddr(_chan, _x) Transport(_chan, PutUint16ByAddr(_x))
-#define DownlinkPutInt32ByAddr(_chan, _x) Transport(_chan, PutInt32ByAddr(_x))
-#define DownlinkPutUint32ByAddr(_chan, _x) Transport(_chan, PutUint32ByAddr(_x))
-#define DownlinkPutFloatByAddr(_chan, _x) Transport(_chan, PutFloatByAddr(_x))
+#define DownlinkPutInt8ByAddr(_trans, _dev, _x) Transport(_trans, PutInt8ByAddr(_dev, _x))
+#define DownlinkPutUint8ByAddr(_trans, _dev, _x) Transport(_trans, PutUint8ByAddr(_dev, _x))
+#define DownlinkPutInt16ByAddr(_trans, _dev, _x) Transport(_trans, PutInt16ByAddr(_dev, _x))
+#define DownlinkPutUint16ByAddr(_trans, _dev, _x) Transport(_trans, PutUint16ByAddr(_dev, _x))
+#define DownlinkPutInt32ByAddr(_trans, _dev, _x) Transport(_trans, PutInt32ByAddr(_dev, _x))
+#define DownlinkPutUint32ByAddr(_trans, _dev, _x) Transport(_trans, PutUint32ByAddr(_dev, _x))
+#define DownlinkPutFloatByAddr(_trans, _dev, _x) Transport(_trans, PutFloatByAddr(_dev, _x))
 
-#define DownlinkPutDoubleByAddr(_chan, _x) Transport(_chan, PutDoubleByAddr(_x))
+#define DownlinkPutDoubleByAddr(_trans, _dev, _x) Transport(_trans, PutDoubleByAddr(_dev, _x))
 
-#define DownlinkPutFloatArray(_chan, _n, _x) Transport(_chan, PutFloatArray(_n, _x))
-#define DownlinkPutDoubleArray(_chan, _n, _x) Transport(_chan, PutDoubleArray(_n, _x))
-#define DownlinkPutInt16Array(_chan, _n, _x) Transport(_chan, PutInt16Array(_n, _x))
-#define DownlinkPutUint16Array(_chan, _n, _x) Transport(_chan, PutUint16Array(_n, _x))
-#define DownlinkPutInt32Array(_chan, _n, _x) Transport(_chan, PutInt32Array(_n, _x))
-#define DownlinkPutUint32Array(_chan, _n, _x) Transport(_chan, PutUint32Array(_n, _x))
-#define DownlinkPutUint8Array(_chan, _n, _x) Transport(_chan, PutUint8Array(_n, _x))
+#define DownlinkPutFloatArray(_trans, _dev, _n, _x) Transport(_trans, PutFloatArray(_dev, _n, _x))
+#define DownlinkPutDoubleArray(_trans, _dev, _n, _x) Transport(_trans, PutDoubleArray(_dev, _n, _x))
+#define DownlinkPutInt16Array(_trans, _dev, _n, _x) Transport(_trans, PutInt16Array(_dev, _n, _x))
+#define DownlinkPutUint16Array(_trans, _dev, _n, _x) Transport(_trans, PutUint16Array(_dev, _n, _x))
+#define DownlinkPutInt32Array(_trans, _dev, _n, _x) Transport(_trans, PutInt32Array(_dev, _n, _x))
+#define DownlinkPutUint32Array(_trans, _dev, _n, _x) Transport(_trans, PutUint32Array(_dev, _n, _x))
+#define DownlinkPutUint8Array(_trans, _dev, _n, _x) Transport(_trans, PutUint8Array(_dev, _n, _x))
 
-#define DownlinkOverrun(_chan) downlink_nb_ovrn++;
-#define DownlinkCountBytes(_chan, _n) downlink_nb_bytes += _n;
+#define DownlinkOverrun(_trans, _dev) downlink_nb_ovrn++;
+#define DownlinkCountBytes(_trans, _dev, _n) downlink_nb_bytes += _n;
 
-#define DownlinkStartMessage(_chan, _name, msg_id, payload_len) { \
+#define DownlinkStartMessage(_trans, _dev, _name, msg_id, payload_len) { \
   downlink_nb_msgs++; \
-  Transport(_chan, Header(DownlinkIDsSize(_chan, payload_len))); \
-  Transport(_chan, PutUint8(AC_ID)); \
-  Transport(_chan, PutNamedUint8(_name, msg_id)); \
+  Transport(_trans, Header(_dev, DownlinkIDsSize(_trans, _dev, payload_len))); \
+  Transport(_trans, PutUint8(_dev, AC_ID)); \
+  Transport(_trans, PutNamedUint8(_dev, _name, msg_id)); \
 }
 
-#define DownlinkEndMessage(_chan) Transport(_chan, Trailer())
+#define DownlinkEndMessage(_trans, _dev) Transport(_trans, Trailer(_dev))
 
 #endif /* DOWNLINK_H */
diff --git a/sw/airborne/subsystems/datalink/pprz_transport.h b/sw/airborne/subsystems/datalink/pprz_transport.h
index 4c284b4f18..ce6f1f5e35 100644
--- a/sw/airborne/subsystems/datalink/pprz_transport.h
+++ b/sw/airborne/subsystems/datalink/pprz_transport.h
@@ -51,88 +51,88 @@ extern uint8_t ck_a, ck_b;
 
 #define __Link(dev, _x) dev##_x
 #define _Link(dev, _x)  __Link(dev, _x)
-#define Link(_x) _Link(DOWNLINK_DEVICE, _x)
+#define Link(_dev, _x) _Link(_dev, _x)
 
-#define PprzTransportCheckFreeSpace(_x) Link(CheckFreeSpace(_x))
+#define PprzTransportCheckFreeSpace(_dev, _x) Link(_dev, CheckFreeSpace(_x))
 
-#define PprzTransportPut1Byte(_x) Link(Transmit(_x))
-#define PprzTransportSendMessage() Link(SendMessage())
+#define PprzTransportPut1Byte(_dev, _x) Link(_dev, Transmit(_x))
+#define PprzTransportSendMessage(_dev) Link(_dev, SendMessage())
 
-#define PprzTransportHeader(payload_len) { \
-  PprzTransportPut1Byte(STX);				\
+#define PprzTransportHeader(_dev, payload_len) { \
+  PprzTransportPut1Byte(_dev, STX);				\
   uint8_t msg_len = PprzTransportSizeOf(payload_len);	\
-  PprzTransportPut1Byte(msg_len);			\
+  PprzTransportPut1Byte(_dev, msg_len);			\
   ck_a = msg_len; ck_b = msg_len;			\
 }
 
-#define PprzTransportTrailer() { \
-  PprzTransportPut1Byte(ck_a);	\
-  PprzTransportPut1Byte(ck_b);	\
-  PprzTransportSendMessage() \
+#define PprzTransportTrailer(_dev) { \
+  PprzTransportPut1Byte(_dev, ck_a);	\
+  PprzTransportPut1Byte(_dev, ck_b);	\
+  PprzTransportSendMessage(_dev) \
 }
 
-#define PprzTransportPutUint8(_byte) { \
+#define PprzTransportPutUint8(_dev, _byte) { \
     ck_a += _byte;			  \
     ck_b += ck_a;			  \
-    PprzTransportPut1Byte(_byte);		  \
+    PprzTransportPut1Byte(_dev, _byte);		  \
  }
 
-#define PprzTransportPutNamedUint8(_name, _byte) PprzTransportPutUint8(_byte)
+#define PprzTransportPutNamedUint8(_dev, _name, _byte) PprzTransportPutUint8(_dev, _byte)
 
-#define PprzTransportPut1ByteByAddr(_byte) {	 \
+#define PprzTransportPut1ByteByAddr(_dev, _byte) {	 \
     uint8_t _x = *(_byte);		 \
-    PprzTransportPutUint8(_x);	 \
+    PprzTransportPutUint8(_dev, _x);	 \
   }
 
-#define PprzTransportPut2ByteByAddr(_byte) { \
-    PprzTransportPut1ByteByAddr(_byte);	\
-    PprzTransportPut1ByteByAddr((const uint8_t*)_byte+1);	\
+#define PprzTransportPut2ByteByAddr(_dev, _byte) { \
+    PprzTransportPut1ByteByAddr(_dev, _byte);	\
+    PprzTransportPut1ByteByAddr(_dev, (const uint8_t*)_byte+1);	\
   }
 
-#define PprzTransportPut4ByteByAddr(_byte) { \
-    PprzTransportPut2ByteByAddr(_byte);	\
-    PprzTransportPut2ByteByAddr((const uint8_t*)_byte+2);	\
+#define PprzTransportPut4ByteByAddr(_dev, _byte) { \
+    PprzTransportPut2ByteByAddr(_dev, _byte);	\
+    PprzTransportPut2ByteByAddr(_dev, (const uint8_t*)_byte+2);	\
   }
 
 #ifdef __IEEE_BIG_ENDIAN /* From machine/ieeefp.h */
-#define PprzTransportPutDoubleByAddr(_byte) { \
-    PprzTransportPut4ByteByAddr((const uint8_t*)_byte+4);	\
-    PprzTransportPut4ByteByAddr((const uint8_t*)_byte);	\
+#define PprzTransportPutDoubleByAddr(_dev, _byte) { \
+    PprzTransportPut4ByteByAddr(_dev, (const uint8_t*)_byte+4);	\
+    PprzTransportPut4ByteByAddr(_dev, (const uint8_t*)_byte);	\
   }
 #else
-#define PprzTransportPutDoubleByAddr(_byte) { \
-    PprzTransportPut4ByteByAddr((const uint8_t*)_byte);	\
-    PprzTransportPut4ByteByAddr((const uint8_t*)_byte+4);	\
+#define PprzTransportPutDoubleByAddr(_dev, _byte) { \
+    PprzTransportPut4ByteByAddr(_dev, (const uint8_t*)_byte);	\
+    PprzTransportPut4ByteByAddr(_dev, (const uint8_t*)_byte+4);	\
   }
 #endif
 
 
-#define PprzTransportPutInt8ByAddr(_x) PprzTransportPut1ByteByAddr(_x)
-#define PprzTransportPutUint8ByAddr(_x) PprzTransportPut1ByteByAddr((const uint8_t*)_x)
-#define PprzTransportPutInt16ByAddr(_x) PprzTransportPut2ByteByAddr((const uint8_t*)_x)
-#define PprzTransportPutUint16ByAddr(_x) PprzTransportPut2ByteByAddr((const uint8_t*)_x)
-#define PprzTransportPutInt32ByAddr(_x) PprzTransportPut4ByteByAddr((const uint8_t*)_x)
-#define PprzTransportPutUint32ByAddr(_x) PprzTransportPut4ByteByAddr((const uint8_t*)_x)
-#define PprzTransportPutFloatByAddr(_x) PprzTransportPut4ByteByAddr((const uint8_t*)_x)
+#define PprzTransportPutInt8ByAddr(_dev, _x) PprzTransportPut1ByteByAddr(_dev, _x)
+#define PprzTransportPutUint8ByAddr(_dev, _x) PprzTransportPut1ByteByAddr(_dev, (const uint8_t*)_x)
+#define PprzTransportPutInt16ByAddr(_dev, _x) PprzTransportPut2ByteByAddr(_dev, (const uint8_t*)_x)
+#define PprzTransportPutUint16ByAddr(_dev, _x) PprzTransportPut2ByteByAddr(_dev, (const uint8_t*)_x)
+#define PprzTransportPutInt32ByAddr(_dev, _x) PprzTransportPut4ByteByAddr(_dev, (const uint8_t*)_x)
+#define PprzTransportPutUint32ByAddr(_dev, _x) PprzTransportPut4ByteByAddr(_dev, (const uint8_t*)_x)
+#define PprzTransportPutFloatByAddr(_dev, _x) PprzTransportPut4ByteByAddr(_dev, (const uint8_t*)_x)
 
-#define PprzTransportPutArray(_put, _n, _x) { \
+#define PprzTransportPutArray(_dev, _put, _n, _x) { \
   uint8_t _i; \
-  PprzTransportPutUint8(_n); \
+  PprzTransportPutUint8(_dev, _n); \
   for(_i = 0; _i < _n; _i++) { \
-    _put(&_x[_i]); \
+    _put(_dev, &_x[_i]); \
   } \
 }
 
-#define PprzTransportPutFloatArray(_n, _x) PprzTransportPutArray(PprzTransportPutFloatByAddr, _n, _x)
-#define PprzTransportPutDoubleArray(_n, _x) PprzTransportPutArray(PprzTransportPutDoubleByAddr, _n, _x)
+#define PprzTransportPutFloatArray(_dev, _n, _x) PprzTransportPutArray(_dev, PprzTransportPutFloatByAddr, _n, _x)
+#define PprzTransportPutDoubleArray(_dev, _n, _x) PprzTransportPutArray(_dev, PprzTransportPutDoubleByAddr, _n, _x)
 
-#define PprzTransportPutInt16Array(_n, _x) PprzTransportPutArray(PprzTransportPutInt16ByAddr, _n, _x)
-#define PprzTransportPutUint16Array(_n, _x) PprzTransportPutArray(PprzTransportPutUint16ByAddr, _n, _x)
+#define PprzTransportPutInt16Array(_dev, _n, _x) PprzTransportPutArray(_dev, PprzTransportPutInt16ByAddr, _n, _x)
+#define PprzTransportPutUint16Array(_dev, _n, _x) PprzTransportPutArray(_dev, PprzTransportPutUint16ByAddr, _n, _x)
 
-#define PprzTransportPutInt32Array(_n, _x) PprzTransportPutArray(PprzTransportPutInt32ByAddr, _n, _x)
-#define PprzTransportPutUint32Array(_n, _x) PprzTransportPutArray(PprzTransportPutUint32ByAddr, _n, _x)
+#define PprzTransportPutInt32Array(_dev, _n, _x) PprzTransportPutArray(_dev, PprzTransportPutInt32ByAddr, _n, _x)
+#define PprzTransportPutUint32Array(_dev, _n, _x) PprzTransportPutArray(_dev, PprzTransportPutUint32ByAddr, _n, _x)
 
-#define PprzTransportPutUint8Array(_n, _x) PprzTransportPutArray(PprzTransportPutUint8ByAddr, _n, _x)
+#define PprzTransportPutUint8Array(_dev, _n, _x) PprzTransportPutArray(_dev, PprzTransportPutUint8ByAddr, _n, _x)
 
 
 /** Receiving pprz messages */
diff --git a/sw/airborne/subsystems/datalink/xbee.h b/sw/airborne/subsystems/datalink/xbee.h
index c5f8a9663e..540b922c7b 100644
--- a/sw/airborne/subsystems/datalink/xbee.h
+++ b/sw/airborne/subsystems/datalink/xbee.h
@@ -59,91 +59,91 @@ void xbee_init( void );
 
 #define __Link(dev, _x) dev##_x
 #define _Link(dev, _x)  __Link(dev, _x)
-#define Link(_x) _Link(DOWNLINK_DEVICE, _x)
+#define Link(_dev, _x) _Link(_dev, _x)
 
-#define XBeeTransportPut1Byte(x) Link(Transmit(x))
-#define XBeeTransportCheckFreeSpace(x) Link(CheckFreeSpace(x))
+#define XBeeTransportPut1Byte(_dev, x) Link(_dev, Transmit(x))
+#define XBeeTransportCheckFreeSpace(_dev, x) Link(_dev, CheckFreeSpace(x))
 /* 5 = Start + len_msb + len_lsb + API_id + checksum */
 #define XBeeAPISizeOf(_x) (_x+5)
-#define XBeeTransportSendMessage() Link(SendMessage())
+#define XBeeTransportSendMessage(_dev) Link(_dev, SendMessage())
 
-#define XBeeTransportPutUint8(_x) { \
+#define XBeeTransportPutUint8(_dev, _x) { \
   xbee_cs += _x; \
-  XBeeTransportPut1Byte(_x); \
+  XBeeTransportPut1Byte(_dev, _x); \
 }
 
-#define XBeeTransportPut1ByteByAddr(_byte) { \
+#define XBeeTransportPut1ByteByAddr(_dev, _byte) { \
   uint8_t _x = *(_byte);	\
-  XBeeTransportPutUint8(_x);	 \
+  XBeeTransportPutUint8(_dev, _x);	 \
  }
 
-#define XBeeTransportPut2Bytes(_x) { \
+#define XBeeTransportPut2Bytes(_dev, _x) { \
   uint16_t x16 = _x; \
-  XBeeTransportPut1Byte(x16>>8); \
-  XBeeTransportPut1Byte(x16 & 0xff); \
+  XBeeTransportPut1Byte(_dev, x16>>8); \
+  XBeeTransportPut1Byte(_dev, x16 & 0xff); \
 }
 
-#define XBeeTransportPut2ByteByAddr(_byte) { \
-    XBeeTransportPut1ByteByAddr(_byte);	\
-    XBeeTransportPut1ByteByAddr((const uint8_t*)_byte+1);	\
+#define XBeeTransportPut2ByteByAddr(_dev, _byte) { \
+    XBeeTransportPut1ByteByAddr(_dev, _byte);	\
+    XBeeTransportPut1ByteByAddr(_dev, (const uint8_t*)_byte+1);	\
   }
 
-#define XBeeTransportPut4ByteByAddr(_byte) { \
-    XBeeTransportPut2ByteByAddr(_byte);	\
-    XBeeTransportPut2ByteByAddr((const uint8_t*)_byte+2); \
+#define XBeeTransportPut4ByteByAddr(_dev, _byte) { \
+    XBeeTransportPut2ByteByAddr(_dev, _byte);	\
+    XBeeTransportPut2ByteByAddr(_dev, (const uint8_t*)_byte+2); \
   }
 
 #ifdef __IEEE_BIG_ENDIAN /* From machine/ieeefp.h */
-#define XBeeTransportPutDoubleByAddr(_byte) { \
-    XBeeTransportPut4ByteByAddr((const uint8_t*)_byte+4);	\
-    XBeeTransportPut4ByteByAddr((const uint8_t*)_byte);	\
+#define XBeeTransportPutDoubleByAddr(_dev, _byte) { \
+    XBeeTransportPut4ByteByAddr(_dev, (const uint8_t*)_byte+4);	\
+    XBeeTransportPut4ByteByAddr(_dev, (const uint8_t*)_byte);	\
   }
 #else
-#define XBeeTransportPutDoubleByAddr(_byte) { \
-    XBeeTransportPut4ByteByAddr((const uint8_t*)_byte);	\
-    XBeeTransportPut4ByteByAddr((const uint8_t*)_byte+4);	\
+#define XBeeTransportPutDoubleByAddr(_dev, _byte) { \
+    XBeeTransportPut4ByteByAddr(_dev, (const uint8_t*)_byte);	\
+    XBeeTransportPut4ByteByAddr(_dev, (const uint8_t*)_byte+4);	\
   }
 #endif
 
 
-#define XBeeTransportPutInt8ByAddr(_x) XBeeTransportPut1ByteByAddr(_x)
-#define XBeeTransportPutUint8ByAddr(_x) XBeeTransportPut1ByteByAddr((const uint8_t*)_x)
-#define XBeeTransportPutInt16ByAddr(_x) XBeeTransportPut2ByteByAddr((const uint8_t*)_x)
-#define XBeeTransportPutUint16ByAddr(_x) XBeeTransportPut2ByteByAddr((const uint8_t*)_x)
-#define XBeeTransportPutInt32ByAddr(_x) XBeeTransportPut4ByteByAddr((const uint8_t*)_x)
-#define XBeeTransportPutUint32ByAddr(_x) XBeeTransportPut4ByteByAddr((const uint8_t*)_x)
-#define XBeeTransportPutFloatByAddr(_x) XBeeTransportPut4ByteByAddr((const uint8_t*)_x)
-#define XBeeTransportPutNamedUint8(_name, _byte) XBeeTransportPutUint8(_byte)
+#define XBeeTransportPutInt8ByAddr(_dev, _x) XBeeTransportPut1ByteByAddr(_dev, _x)
+#define XBeeTransportPutUint8ByAddr(_dev, _x) XBeeTransportPut1ByteByAddr(_dev, (const uint8_t*)_x)
+#define XBeeTransportPutInt16ByAddr(_dev, _x) XBeeTransportPut2ByteByAddr(_dev, (const uint8_t*)_x)
+#define XBeeTransportPutUint16ByAddr(_dev, _x) XBeeTransportPut2ByteByAddr(_dev, (const uint8_t*)_x)
+#define XBeeTransportPutInt32ByAddr(_dev, _x) XBeeTransportPut4ByteByAddr(_dev, (const uint8_t*)_x)
+#define XBeeTransportPutUint32ByAddr(_dev, _x) XBeeTransportPut4ByteByAddr(_dev, (const uint8_t*)_x)
+#define XBeeTransportPutFloatByAddr(_dev, _x) XBeeTransportPut4ByteByAddr(_dev, (const uint8_t*)_x)
+#define XBeeTransportPutNamedUint8(_dev, _name, _byte) XBeeTransportPutUint8(_dev, _byte)
 
-#define XBeeTransportPutArray(_put, _n, _x) { \
+#define XBeeTransportPutArray(_dev, _put, _n, _x) { \
   uint8_t _i; \
-  XBeeTransportPutUint8(_n); \
+  XBeeTransportPutUint8(_dev, _n); \
   for(_i = 0; _i < _n; _i++) { \
-    _put(&_x[_i]); \
+    _put(_dev, &_x[_i]); \
   } \
 }
 
-#define XBeeTransportPutInt16Array(_n, _x) XBeeTransportPutArray(XBeeTransportPutInt16ByAddr, _n, _x)
+#define XBeeTransportPutInt16Array(_dev, _n, _x) XBeeTransportPutArray(_dev, XBeeTransportPutInt16ByAddr, _n, _x)
 
-#define XBeeTransportPutUint16Array(_n, _x) XBeeTransportPutArray(XBeeTransportPutUint16ByAddr, _n, _x)
-#define XBeeTransportPutUint8Array(_n, _x) XBeeTransportPutArray(XBeeTransportPutUint8ByAddr, _n, _x)
-#define XBeeTransportPutFloatArray(_n, _x) XBeeTransportPutArray(XBeeTransportPutFloatByAddr, _n, _x)
-#define XBeeTransportPutDoubleArray(_n, _x) XBeeTransportPutArray(XBeeTransportPutDoubleByAddr, _n, _x)
+#define XBeeTransportPutUint16Array(_dev, _n, _x) XBeeTransportPutArray(_dev, XBeeTransportPutUint16ByAddr, _n, _x)
+#define XBeeTransportPutUint8Array(_dev, _n, _x) XBeeTransportPutArray(_dev, XBeeTransportPutUint8ByAddr, _n, _x)
+#define XBeeTransportPutFloatArray(_dev, _n, _x) XBeeTransportPutArray(_dev, XBeeTransportPutFloatByAddr, _n, _x)
+#define XBeeTransportPutDoubleArray(_dev, _n, _x) XBeeTransportPutArray(_dev, XBeeTransportPutDoubleByAddr, _n, _x)
 
 
 
-#define XBeeTransportHeader(_len) { \
-  XBeeTransportPut1Byte(XBEE_START); \
+#define XBeeTransportHeader(_dev, _len) { \
+  XBeeTransportPut1Byte(_dev, XBEE_START); \
   uint8_t payload_len = XBeeAPISizeOf(_len); \
-  XBeeTransportPut2Bytes(payload_len); \
+  XBeeTransportPut2Bytes(_dev, payload_len); \
   xbee_cs = 0; \
-  XBeeTransportPutTXHeader(); \
+  XBeeTransportPutTXHeader(_dev); \
 }
 
-#define XBeeTransportTrailer() { \
+#define XBeeTransportTrailer(_dev) { \
   xbee_cs = 0xff - xbee_cs; \
-  XBeeTransportPut1Byte(xbee_cs); \
-  XBeeTransportSendMessage() \
+  XBeeTransportPut1Byte(_dev, xbee_cs); \
+  XBeeTransportSendMessage(_dev) \
 }
 
 
diff --git a/sw/airborne/subsystems/datalink/xbee24.h b/sw/airborne/subsystems/datalink/xbee24.h
index c217776f80..bf8befde50 100644
--- a/sw/airborne/subsystems/datalink/xbee24.h
+++ b/sw/airborne/subsystems/datalink/xbee24.h
@@ -31,12 +31,12 @@
 #define XBEE_RX_ID 0x81 /* 16 bits address */
 #define XBEE_RFDATA_OFFSET 5
 
-#define XBeeTransportPutTXHeader() { \
-  XBeeTransportPutUint8(XBEE_TX_ID); \
-  XBeeTransportPutUint8(NO_FRAME_ID); \
-  XBeeTransportPutUint8(GROUND_STATION_ADDR >> 8); \
-  XBeeTransportPutUint8(GROUND_STATION_ADDR & 0xff); \
-  XBeeTransportPutUint8(TX_OPTIONS); \
+#define XBeeTransportPutTXHeader(_dev) { \
+  XBeeTransportPutUint8(_dev, XBEE_TX_ID); \
+  XBeeTransportPutUint8(_dev, NO_FRAME_ID); \
+  XBeeTransportPutUint8(_dev, GROUND_STATION_ADDR >> 8); \
+  XBeeTransportPutUint8(_dev, GROUND_STATION_ADDR & 0xff); \
+  XBeeTransportPutUint8(_dev, TX_OPTIONS); \
 }
 
 /* 4 = frame_id + addr_msb + addr_lsb + options */
diff --git a/sw/airborne/subsystems/datalink/xbee868.h b/sw/airborne/subsystems/datalink/xbee868.h
index 4cf3ecb479..ba913a807e 100644
--- a/sw/airborne/subsystems/datalink/xbee868.h
+++ b/sw/airborne/subsystems/datalink/xbee868.h
@@ -31,21 +31,21 @@
 #define XBEE_RX_ID 0x90
 #define XBEE_RFDATA_OFFSET 12
 
-#define XBeeTransportPutTXHeader()  { \
-  XBeeTransportPutUint8(XBEE_TX_ID); \
-  XBeeTransportPutUint8(NO_FRAME_ID); \
-  XBeeTransportPutUint8(0x00); \
-  XBeeTransportPutUint8(0x00); \
-  XBeeTransportPutUint8(0x00); \
-  XBeeTransportPutUint8(0x00); \
-  XBeeTransportPutUint8(0x00); \
-  XBeeTransportPutUint8(0x00); \
-  XBeeTransportPutUint8(GROUND_STATION_ADDR >> 8); \
-  XBeeTransportPutUint8(GROUND_STATION_ADDR & 0xff); \
-  XBeeTransportPutUint8(0xff); \
-  XBeeTransportPutUint8(0xfe); \
-  XBeeTransportPutUint8(0x00); \
-  XBeeTransportPutUint8(TX_OPTIONS); \
+#define XBeeTransportPutTXHeader(_dev)  { \
+  XBeeTransportPutUint8(_dev, XBEE_TX_ID); \
+  XBeeTransportPutUint8(_dev, NO_FRAME_ID); \
+  XBeeTransportPutUint8(_dev, 0x00); \
+  XBeeTransportPutUint8(_dev, 0x00); \
+  XBeeTransportPutUint8(_dev, 0x00); \
+  XBeeTransportPutUint8(_dev, 0x00); \
+  XBeeTransportPutUint8(_dev, 0x00); \
+  XBeeTransportPutUint8(_dev, 0x00); \
+  XBeeTransportPutUint8(_dev, GROUND_STATION_ADDR >> 8); \
+  XBeeTransportPutUint8(_dev, GROUND_STATION_ADDR & 0xff); \
+  XBeeTransportPutUint8(_dev, 0xff); \
+  XBeeTransportPutUint8(_dev, 0xfe); \
+  XBeeTransportPutUint8(_dev, 0x00); \
+  XBeeTransportPutUint8(_dev, TX_OPTIONS); \
 }
 
 /* 13 = frame_id + addr==8 + 3 + options */
diff --git a/sw/airborne/subsystems/sensors/infrared_i2c.h b/sw/airborne/subsystems/sensors/infrared_i2c.h
index 855e186424..fec70ef777 100644
--- a/sw/airborne/subsystems/sensors/infrared_i2c.h
+++ b/sw/airborne/subsystems/sensors/infrared_i2c.h
@@ -49,7 +49,7 @@ extern void infrared_i2c_ver_event( void );
   if (irv_trans.status == I2CTransSuccess) infrared_i2c_ver_event(); \
 }
 
-#define infrared_i2cDownlink() DOWNLINK_SEND_DEBUG_IR_I2C(DefaultChannel, &ir_i2c.ir1, &ir_i2c.ir2, &ir_i2c.ir3)
+#define infrared_i2cDownlink() DOWNLINK_SEND_DEBUG_IR_I2C(DefaultChannel, DefaultDevice, &ir_i2c.ir1, &ir_i2c.ir2, &ir_i2c.ir3)
 
 #define infrared_i2c_SetConfWord(_v) { \
   ir_i2c_conf_hor_done = FALSE; \
diff --git a/sw/airborne/test/peripherals/test_ami601.c b/sw/airborne/test/peripherals/test_ami601.c
index d003b28e0c..1810ea3463 100644
--- a/sw/airborne/test/peripherals/test_ami601.c
+++ b/sw/airborne/test/peripherals/test_ami601.c
@@ -64,7 +64,7 @@ static inline void main_init( void ) {
 }
 
 static inline void main_periodic_task( void ) {
-  //  RunOnceEvery(100, {DOWNLINK_SEND_ALIVE(DefaultChannel, 16, MD5SUM);});
+  //  RunOnceEvery(100, {DOWNLINK_SEND_ALIVE(DefaultChannel, DefaultDevice, 16, MD5SUM);});
 
   RunOnceEvery(10, { ami601_read();});
 }
@@ -79,6 +79,6 @@ static inline void on_mag(void) {
   LED_TOGGLE(4);
   ami601_status = AMI601_IDLE;
   struct Int32Vect3 bla = {ami601_values[0], ami601_values[1], ami601_values[2]};
-  DOWNLINK_SEND_IMU_MAG_RAW(DefaultChannel, &bla.x, &bla.y, &bla.z);
+  DOWNLINK_SEND_IMU_MAG_RAW(DefaultChannel, DefaultDevice, &bla.x, &bla.y, &bla.z);
 
 }
diff --git a/sw/airborne/test/subsystems/test_ahrs.c b/sw/airborne/test/subsystems/test_ahrs.c
index 81cffad371..51eecaf327 100644
--- a/sw/airborne/test/subsystems/test_ahrs.c
+++ b/sw/airborne/test/subsystems/test_ahrs.c
@@ -118,49 +118,49 @@ static inline void main_report(void) {
 
   PeriodicPrescaleBy10(
 		       {
-			 DOWNLINK_SEND_IMU_ACCEL_RAW(DefaultChannel,
+			 DOWNLINK_SEND_IMU_ACCEL_RAW(DefaultChannel, DefaultDevice,
 						     &imu.accel_unscaled.x,
 						     &imu.accel_unscaled.y,
 						     &imu.accel_unscaled.z);
 		       },
 		       {
-			 DOWNLINK_SEND_IMU_GYRO_RAW(DefaultChannel,
+			 DOWNLINK_SEND_IMU_GYRO_RAW(DefaultChannel, DefaultDevice,
 						    &imu.gyro_unscaled.p,
 						    &imu.gyro_unscaled.q,
 						    &imu.gyro_unscaled.r);
 		       },
 		       {
-			 DOWNLINK_SEND_IMU_MAG_RAW(DefaultChannel,
+			 DOWNLINK_SEND_IMU_MAG_RAW(DefaultChannel, DefaultDevice,
 						   &imu.mag_unscaled.x,
 						   &imu.mag_unscaled.y,
 						   &imu.mag_unscaled.z);
 		       },
 		       {
-			 DOWNLINK_SEND_IMU_ACCEL_SCALED(DefaultChannel,
+			 DOWNLINK_SEND_IMU_ACCEL_SCALED(DefaultChannel, DefaultDevice,
 						   &imu.accel.x,
 						   &imu.accel.y,
 						   &imu.accel.z);
 		       },
 		       {
-			 DOWNLINK_SEND_IMU_GYRO_SCALED(DefaultChannel,
+			 DOWNLINK_SEND_IMU_GYRO_SCALED(DefaultChannel, DefaultDevice,
 						  &imu.gyro.p,
 						  &imu.gyro.q,
 						  &imu.gyro.r);
 		       },
 
 		       {
-			 DOWNLINK_SEND_IMU_MAG_SCALED(DefaultChannel,
+			 DOWNLINK_SEND_IMU_MAG_SCALED(DefaultChannel, DefaultDevice,
 						 &imu.mag.x,
 						 &imu.mag.y,
 						 &imu.mag.z);
 		       },
 
 		       {
-			 DOWNLINK_SEND_ALIVE(DefaultChannel, 16, MD5SUM);
+			 DOWNLINK_SEND_ALIVE(DefaultChannel, DefaultDevice, 16, MD5SUM);
 		       },
 		       {
 #ifdef USE_I2C2
-			 DOWNLINK_SEND_I2C_ERRORS(DefaultChannel,
+			 DOWNLINK_SEND_I2C_ERRORS(DefaultChannel, DefaultDevice,
 						  &i2c2_errors.ack_fail_cnt,
 						  &i2c2_errors.miss_start_stop_cnt,
 						  &i2c2_errors.arb_lost_cnt,
@@ -173,7 +173,7 @@ static inline void main_report(void) {
 #endif
 		       },
 		       {
-			 DOWNLINK_SEND_BOOZ2_AHRS_EULER(DefaultChannel,
+			 DOWNLINK_SEND_BOOZ2_AHRS_EULER(DefaultChannel, DefaultDevice,
 							&ahrs.ltp_to_imu_euler.phi,
 							&ahrs.ltp_to_imu_euler.theta,
 							&ahrs.ltp_to_imu_euler.psi,
@@ -182,7 +182,7 @@ static inline void main_report(void) {
 							&ahrs.ltp_to_body_euler.psi);
 		       },
 		       {
-			 DOWNLINK_SEND_BOOZ_AHRS_BIAS(DefaultChannel,
+			 DOWNLINK_SEND_BOOZ_AHRS_BIAS(DefaultChannel, DefaultDevice,
 						      &ahrs_impl.gyro_bias.p,
 						      &ahrs_impl.gyro_bias.q,
 						      &ahrs_impl.gyro_bias.r);
diff --git a/sw/airborne/test/subsystems/test_imu.c b/sw/airborne/test/subsystems/test_imu.c
index 0cefac6fbd..5e1dd683bc 100644
--- a/sw/airborne/test/subsystems/test_imu.c
+++ b/sw/airborne/test/subsystems/test_imu.c
@@ -69,11 +69,11 @@ static inline void main_init( void ) {
 static inline void main_periodic_task( void ) {
   RunOnceEvery(100, {
       //      LED_TOGGLE(3);
-      DOWNLINK_SEND_ALIVE(DefaultChannel, 16, MD5SUM);
+      DOWNLINK_SEND_ALIVE(DefaultChannel, DefaultDevice, 16, MD5SUM);
     });
 #ifdef USE_I2C2
   RunOnceEvery(111, {
-      DOWNLINK_SEND_I2C_ERRORS(DefaultChannel,
+      DOWNLINK_SEND_I2C_ERRORS(DefaultChannel, DefaultDevice,
                    &i2c2_errors.ack_fail_cnt,
                    &i2c2_errors.miss_start_stop_cnt,
                    &i2c2_errors.arb_lost_cnt,
@@ -102,13 +102,13 @@ static inline void on_accel_event(void) {
   cnt++;
   if (cnt > 15) cnt = 0;
   if (cnt == 0) {
-    DOWNLINK_SEND_IMU_ACCEL_RAW(DefaultChannel,
+    DOWNLINK_SEND_IMU_ACCEL_RAW(DefaultChannel, DefaultDevice,
                 &imu.accel_unscaled.x,
                 &imu.accel_unscaled.y,
                 &imu.accel_unscaled.z);
   }
   else if (cnt == 7) {
-    DOWNLINK_SEND_IMU_ACCEL_SCALED(DefaultChannel,
+    DOWNLINK_SEND_IMU_ACCEL_SCALED(DefaultChannel, DefaultDevice,
                   &imu.accel.x,
                   &imu.accel.y,
                   &imu.accel.z);
@@ -123,13 +123,13 @@ static inline void on_gyro_accel_event(void) {
   if (cnt > 15) cnt = 0;
 
   if (cnt == 0) {
-    DOWNLINK_SEND_IMU_GYRO_RAW(DefaultChannel,
+    DOWNLINK_SEND_IMU_GYRO_RAW(DefaultChannel, DefaultDevice,
                    &imu.gyro_unscaled.p,
                    &imu.gyro_unscaled.q,
                    &imu.gyro_unscaled.r);
   }
   else if (cnt == 7) {
-    DOWNLINK_SEND_IMU_GYRO_SCALED(DefaultChannel,
+    DOWNLINK_SEND_IMU_GYRO_SCALED(DefaultChannel, DefaultDevice,
                  &imu.gyro.p,
                  &imu.gyro.q,
                  &imu.gyro.r);
@@ -144,13 +144,13 @@ static inline void on_mag_event(void) {
   if (cnt > 10) cnt = 0;
 
   if (cnt == 0) {
-    DOWNLINK_SEND_IMU_MAG_SCALED(DefaultChannel,
+    DOWNLINK_SEND_IMU_MAG_SCALED(DefaultChannel, DefaultDevice,
                 &imu.mag.x,
                 &imu.mag.y,
                 &imu.mag.z);
   }
   else if (cnt == 5) {
-    DOWNLINK_SEND_IMU_MAG_RAW(DefaultChannel,
+    DOWNLINK_SEND_IMU_MAG_RAW(DefaultChannel, DefaultDevice,
                   &imu.mag_unscaled.x,
                   &imu.mag_unscaled.y,
                   &imu.mag_unscaled.z);
diff --git a/sw/airborne/test/subsystems/test_radio_control.c b/sw/airborne/test/subsystems/test_radio_control.c
index 96251653a2..bf95dd2248 100644
--- a/sw/airborne/test/subsystems/test_radio_control.c
+++ b/sw/airborne/test/subsystems/test_radio_control.c
@@ -62,14 +62,14 @@ static inline void main_periodic_task( void ) {
   RunOnceEvery(51, {
     /*LED_TOGGLE(2);*/
     uint32_t blaaa= cpu_time_sec;
-    DOWNLINK_SEND_TIME(DefaultChannel, &blaaa);
+    DOWNLINK_SEND_TIME(DefaultChannel, DefaultDevice, &blaaa);
   });
 
   RunOnceEvery(10, {radio_control_periodic_task();});
 
   int16_t foo = 0;//RC_PPM_SIGNED_TICS_OF_USEC(2050-1500);
   RunOnceEvery(10,
-    {DOWNLINK_SEND_BOOZ2_RADIO_CONTROL(DefaultChannel,	\
+    {DOWNLINK_SEND_BOOZ2_RADIO_CONTROL(DefaultChannel, DefaultDevice,	\
 				       &radio_control.values[RADIO_ROLL], \
 				       &radio_control.values[RADIO_PITCH], \
 				       &radio_control.values[RADIO_YAW], \
@@ -79,7 +79,7 @@ static inline void main_periodic_task( void ) {
 				       &radio_control.status);});
 #ifdef RADIO_CONTROL_TYPE_PPM
   RunOnceEvery(10,
-	       {uint8_t blaa = 0; DOWNLINK_SEND_PPM(DefaultChannel,&blaa, 8, booz_radio_control_ppm_pulses);});
+	       {uint8_t blaa = 0; DOWNLINK_SEND_PPM(DefaultChannel, DefaultDevice,&blaa, 8, booz_radio_control_ppm_pulses);});
 #endif
 
   LED_PERIODIC();
diff --git a/sw/airborne/test/subsystems/test_settings.c b/sw/airborne/test/subsystems/test_settings.c
index 9a84d4435d..9f9e496e9e 100644
--- a/sw/airborne/test/subsystems/test_settings.c
+++ b/sw/airborne/test/subsystems/test_settings.c
@@ -75,7 +75,7 @@ static inline void main_init( void ) {
 static inline void main_periodic( void ) {
 
   RunOnceEvery(100, {
-      DOWNLINK_SEND_ALIVE(DefaultChannel,  16, MD5SUM);
+      DOWNLINK_SEND_ALIVE(DefaultChannel, DefaultDevice,  16, MD5SUM);
       PeriodicSendDlValue(DefaultChannel);
     });
 
@@ -101,7 +101,7 @@ void dl_parse_msg(void) {
       uint8_t i = DL_SETTING_index(dl_buffer);
       float val = DL_SETTING_value(dl_buffer);
       DlSetting(i, val);
-      DOWNLINK_SEND_DL_VALUE(DefaultChannel, &i, &val);
+      DOWNLINK_SEND_DL_VALUE(DefaultChannel, DefaultDevice, &i, &val);
     }
     break;
   default:
diff --git a/sw/airborne/test/test_telemetry.c b/sw/airborne/test/test_telemetry.c
index 4ad33cc7f5..4f51dad0e4 100644
--- a/sw/airborne/test/test_telemetry.c
+++ b/sw/airborne/test/test_telemetry.c
@@ -48,7 +48,7 @@ static inline void main_init( void ) {
 }
 
 static inline void main_periodic( void ) {
-  RunOnceEvery(10, {DOWNLINK_SEND_ALIVE(DefaultChannel, 16, MD5SUM);});
+  RunOnceEvery(10, {DOWNLINK_SEND_ALIVE(DefaultChannel, DefaultDevice, 16, MD5SUM);});
   LED_PERIODIC();
 }
 
diff --git a/sw/tools/gen_messages.ml b/sw/tools/gen_messages.ml
index 86dde60a4f..3284b9bdb4 100644
--- a/sw/tools/gen_messages.ml
+++ b/sw/tools/gen_messages.ml
@@ -115,10 +115,10 @@ module Gen_onboard = struct
   let print_field = fun h (t, name, (_f: format option)) ->
     match t with
       Basic _ ->
-	fprintf h "\t  DownlinkPut%sByAddr(_chan, (%s)); \\\n" (Syntax.nameof t) name
+	fprintf h "\t  DownlinkPut%sByAddr(_trans, _dev, (%s)); \\\n" (Syntax.nameof t) name
     | Array (t, varname) ->
 	let _s = Syntax.sizeof (Basic t) in
-	fprintf h "\t  DownlinkPut%sArray(_chan, %s, %s); \\\n" (Syntax.nameof (Basic t)) (Syntax.length_name varname) name
+	fprintf h "\t  DownlinkPut%sArray(_trans, _dev, %s, %s); \\\n" (Syntax.nameof (Basic t)) (Syntax.length_name varname) name
 
   let print_parameter h = function
       (Array _, s, _) -> fprintf h "%s, %s" (Syntax.length_name s) s
@@ -148,26 +148,26 @@ module Gen_onboard = struct
 
   let print_downlink_macro = fun h {name=s; fields = fields} ->
     if List.length fields > 0 then begin
-      fprintf h "#define DOWNLINK_SEND_%s(_chan, " s;
+      fprintf h "#define DOWNLINK_SEND_%s(_trans, _dev, " s;
     end else
-       fprintf h "#define DOWNLINK_SEND_%s(_chan " s;
+       fprintf h "#define DOWNLINK_SEND_%s(_trans, _dev " s;
     print_macro_parameters h fields;
     fprintf h "){ \\\n";
     let size = (size_fields fields "0") in
-    fprintf h "\tif (DownlinkCheckFreeSpace(_chan, DownlinkSizeOf(_chan, %s))) {\\\n" size;
-    fprintf h "\t  DownlinkCountBytes(_chan, DownlinkSizeOf(_chan, %s)); \\\n" size;
-    fprintf h "\t  DownlinkStartMessage(_chan, \"%s\", DL_%s, %s) \\\n" s s size;
+    fprintf h "\tif (DownlinkCheckFreeSpace(_trans, _dev, DownlinkSizeOf(_trans, _dev, %s))) {\\\n" size;
+    fprintf h "\t  DownlinkCountBytes(_trans, _dev, DownlinkSizeOf(_trans, _dev, %s)); \\\n" size;
+    fprintf h "\t  DownlinkStartMessage(_trans, _dev, \"%s\", DL_%s, %s) \\\n" s s size;
     List.iter (print_field h) fields;
-    fprintf h "\t  DownlinkEndMessage(_chan ) \\\n";
+    fprintf h "\t  DownlinkEndMessage(_trans, _dev ) \\\n";
     fprintf h "\t} else \\\n";
-    fprintf h "\t  DownlinkOverrun(_chan ); \\\n";
+    fprintf h "\t  DownlinkOverrun(_trans, _dev ); \\\n";
     fprintf h "}\n\n"
 
   let print_null_downlink_macro = fun h {name=s; fields = fields} ->
     if List.length fields > 0 then begin
-      fprintf h "#define DOWNLINK_SEND_%s(_chan, " s;
+      fprintf h "#define DOWNLINK_SEND_%s(_trans, _dev, " s;
     end else
-      fprintf h "#define DOWNLINK_SEND_%s(_chan " s;
+      fprintf h "#define DOWNLINK_SEND_%s(_trans, _dev " s;
     print_macro_parameters h fields;
     fprintf h ") {}\n"
 
diff --git a/sw/tools/gen_periodic.ml b/sw/tools/gen_periodic.ml
index b0fe980800..28d28ba223 100644
--- a/sw/tools/gen_periodic.ml
+++ b/sw/tools/gen_periodic.ml
@@ -39,7 +39,7 @@ let lprintf = fun c f ->
   fprintf c "%s" (String.make !margin ' ');
   fprintf c f
 
-let output_modes = fun avr_h process_name channel_name modes freq modules ->
+let output_modes = fun avr_h process_name channel_name device_name modes freq modules ->
   let min_period = 1./.float freq in
   let max_period = 65536. /. float freq in
   (** For each mode in this process *)
@@ -84,7 +84,7 @@ let output_modes = fun avr_h process_name channel_name modes freq modules ->
           l := (p, !phase) :: !l;
           i := !i + freq/10;
           right ();
-          lprintf avr_h "PERIODIC_SEND_%s(%s);\\\n" message_name channel_name;
+          lprintf avr_h "PERIODIC_SEND_%s(%s,%s);\\\n" message_name channel_name device_name;
           left ();
           lprintf avr_h "} \\\n"
         )
@@ -118,10 +118,11 @@ let _ =
   (** For each process *)
   List.iter
     (fun process ->
-      let process_name = ExtXml.attrib process "name" and
-      channel_name =  ExtXml.attrib process "channel" in
+      let process_name = ExtXml.attrib process "name"
+      and channel_name =  ExtXml.attrib_or_default process "channel" "DefaultChannel"
+      and device_name = ExtXml.attrib_or_default process "device" "DefaultDevice" in
 
-      fprintf avr_h "\n/* Macros for %s process channel %s */\n" process_name channel_name;
+      fprintf avr_h "\n/* Macros for %s process channel %s with device %s */\n" process_name channel_name device_name;
 
       let modes = Xml.children process in
 
@@ -140,9 +141,9 @@ let _ =
         incr i)
         modes;
 
-      lprintf avr_h "#define PeriodicSend%s(%s) {  /* %dHz */ \\\n" process_name channel_name freq;
+      lprintf avr_h "#define PeriodicSend%s(%s,%s) {  /* %dHz */ \\\n" process_name channel_name device_name freq;
       right ();
-      output_modes avr_h process_name channel_name modes freq modules_name;
+      output_modes avr_h process_name channel_name device_name modes freq modules_name;
       left ();
       lprintf avr_h "}\n"
     )
diff --git a/sw/tools/gen_settings.ml b/sw/tools/gen_settings.ml
index d722e01f0a..d145e5ecf2 100644
--- a/sw/tools/gen_settings.ml
+++ b/sw/tools/gen_settings.ml
@@ -97,7 +97,7 @@ let print_dl_settings = fun settings ->
   let nb_values = !idx in
 
   (** Macro to call to downlink current values *)
-  lprintf "#define PeriodicSendDlValue(_chan) { \\\n";
+  lprintf "#define PeriodicSendDlValue(_trans, _dev) { \\\n";
   if nb_values > 0 then begin
     right ();
     lprintf "static uint8_t i;\\\n";
@@ -114,7 +114,7 @@ let print_dl_settings = fun settings ->
     lprintf "default: var = 0.; break;\\\n";
     left ();
     lprintf "}\\\n";
-    lprintf "DOWNLINK_SEND_DL_VALUE(_chan, &i, &var);\\\n";
+    lprintf "DOWNLINK_SEND_DL_VALUE(_trans, _dev, &i, &var);\\\n";
     lprintf "i++;\\\n";
     left ()
   end;