diff --git a/dynamixel_base/include/dynamixel.h b/dynamixel_base/include/dynamixel.h
index 263e03d87a06c2a24572d46605b96be38eb7da85..7be750a114b663b580e27b06116e6b6a39990309 100755
--- a/dynamixel_base/include/dynamixel.h
+++ b/dynamixel_base/include/dynamixel.h
@@ -49,7 +49,7 @@ void dyn_init_action_packet(unsigned char *packet);
 /* reset instruction */
 void dyn_init_reset_packet(unsigned char *packet,unsigned char id);
 /* sync write instruction */
-void dyn_init_sync_write_packet(unsigned char *packet,unsigned char num_servos,unsigned char *servo_ids,unsigned char address,unsigned char length,TWriteData *data);
+void dyn_init_sync_write_packet(unsigned char *packet,unsigned char num_servos,unsigned char *servo_ids,unsigned char address,unsigned char length,unsigned char * const data[]);
 unsigned char dyn_sync_write_id_present(unsigned char *packet,unsigned char id,unsigned char *address,unsigned char *length,unsigned char *data);
 /* bulk read instruction */
 void dyn_init_bulk_read_packet(unsigned char *packet,unsigned char num_servos,unsigned char *servo_ids,unsigned char *address,unsigned char *length);
diff --git a/dynamixel_base/include/dynamixel2.h b/dynamixel_base/include/dynamixel2.h
index a2d8e30392d74b6429393f8a3d280532fbd99755..94b3fd79cd4bdaa279bbb02dc92dabf702dc2857 100644
--- a/dynamixel_base/include/dynamixel2.h
+++ b/dynamixel_base/include/dynamixel2.h
@@ -11,7 +11,6 @@
 #define     DYN2_ERROR_OFF       8
 #define     DYN2_DATA_OFF        8
 
-
 void dyn2_copy_packet(unsigned char *source, unsigned char *destination);
 inline unsigned char dyn2_get_id(unsigned char *packet);
 inline unsigned short int dyn2_get_length(unsigned char *packet);
@@ -51,7 +50,7 @@ void dyn2_init_action_packet(unsigned char *packet);
 /* reset instruction */
 void dyn2_init_reset_packet(unsigned char *packet,unsigned char id,unsigned char mode);
 /* sync write instruction */
-void dyn2_init_sync_write_packet(unsigned char *packet,unsigned char num_servos,unsigned char *servo_ids,unsigned short int address,unsigned short int length,TWriteData *data);
+void dyn2_init_sync_write_packet(unsigned char *packet,unsigned char num_servos,unsigned char *servo_ids,unsigned short int address,unsigned short int length,unsigned char * const data[]);
 unsigned char dyn2_sync_write_id_present(unsigned char *packet,unsigned char id,unsigned short int *address,unsigned short int *length,unsigned char *data);
 /* sync read instruction */
 void dyn2_init_sync_read_packet(unsigned char *packet,unsigned char num_servos,unsigned char *servo_ids,unsigned short int address,unsigned short int length);
@@ -60,7 +59,7 @@ unsigned char dyn2_sync_read_id_present(unsigned char *packet,unsigned char id,u
 void dyn2_init_bulk_read_packet(unsigned char *packet,unsigned char num_servos,unsigned char *servo_ids,unsigned short int *address,unsigned short int *length);
 unsigned char dyn2_bulk_read_id_present(unsigned char *packet,unsigned char id,unsigned short int *address,unsigned short int *length);
 /* bulk write instruction */
-void dyn2_init_bulk_write_packet(unsigned char *packet,unsigned char num_servos,unsigned char *servo_ids,unsigned short int *address,unsigned short int *length,TWriteData *data);
+void dyn2_init_bulk_write_packet(unsigned char *packet,unsigned char num_servos,unsigned char *servo_ids,unsigned short int *address,unsigned short int *length,unsigned char * const data[]);
 unsigned char dyn2_bulk_write_id_present(unsigned char *packet,unsigned char id,unsigned short int *address,unsigned short int *length,unsigned char *data);
 
 // status packet
diff --git a/dynamixel_base/include/dynamixel_common.h b/dynamixel_base/include/dynamixel_common.h
index 7090a876973b125ccfa0017e4b694cadf6ed7e8f..97f44b15e91d70caa343715c0a756f1b08614857 100644
--- a/dynamixel_base/include/dynamixel_common.h
+++ b/dynamixel_base/include/dynamixel_common.h
@@ -13,10 +13,6 @@
 #define     DYN_COMM_ERROR      4
 #define     DYN_BUSY            5
 
-typedef struct{
-  unsigned char *data_addr;
-}TWriteData;
-
 typedef enum{no_return=0x00,
              return_only_read=0x01,
              return_all=0x02} return_level_t;
diff --git a/dynamixel_base/include/dynamixel_master.h b/dynamixel_base/include/dynamixel_master.h
index 44bd9237401c30dc4bae3a597ad7806fe998ad38..cdadf096faf39dc2fd2cd60943f9aa7e5eb98072 100644
--- a/dynamixel_base/include/dynamixel_master.h
+++ b/dynamixel_base/include/dynamixel_master.h
@@ -33,7 +33,7 @@ typedef struct
 
 /* public functions */
 void dyn_master_init(TDynamixelMaster *master,TComm *dev,TDynVersion version);
-void dyn_master_set_rx_timeout(TDynamixelMaster *master,unsigned short int timeout_ms);
+inline void dyn_master_set_rx_timeout(TDynamixelMaster *master,unsigned short int timeout_ms);
 inline void dyn_master_set_return_level(TDynamixelMaster *master,return_level_t level);
 inline return_level_t dyn_master_get_return_level(TDynamixelMaster *master);
 void dyn_master_scan(TDynamixelMaster *master,unsigned char *num,unsigned char *ids);
@@ -43,13 +43,13 @@ unsigned char dyn_master_read_word(TDynamixelMaster *master,unsigned char id,uns
 unsigned char dyn_master_read_table(TDynamixelMaster *master,unsigned char id,unsigned short int address,unsigned short int length,unsigned char *data);
 unsigned char dyn_master_write_byte(TDynamixelMaster *master,unsigned char id, unsigned short int address, unsigned char data);
 unsigned char dyn_master_write_word(TDynamixelMaster *master,unsigned char id, unsigned short int address, unsigned short int data);
-unsigned char dyn_master_write_table(TDynamixelMaster *master,unsigned char id, unsigned short int address, unsigned short int length, unsigned char *data);
-unsigned char dyn_master_reg_write(TDynamixelMaster *master,unsigned char id, unsigned short int address, unsigned short int length, unsigned char *data);
+unsigned char dyn_master_write_table(TDynamixelMaster *master,unsigned char id, unsigned short int address, unsigned short int length,unsigned char *data);
+unsigned char dyn_master_reg_write(TDynamixelMaster *master,unsigned char id, unsigned short int address, unsigned short int length,unsigned char *data);
 unsigned char dyn_master_action(TDynamixelMaster *master);
-unsigned char dyn_master_sync_write(TDynamixelMaster *master,unsigned char num,unsigned char *ids,unsigned short int address, unsigned short int length, TWriteData *data);
-unsigned char dyn_master_sync_read(TDynamixelMaster *master,unsigned char num,unsigned char *ids,unsigned short int address, unsigned short int length, TWriteData *data);
-unsigned char dyn_master_bulk_read(TDynamixelMaster *master,unsigned char num,unsigned char *ids,unsigned short int *address, unsigned short int *length, TWriteData *data);
-unsigned char dyn_master_bulk_write(TDynamixelMaster *master,unsigned char num,unsigned char *ids,unsigned short int *address, unsigned short int *length, TWriteData *data);
+unsigned char dyn_master_sync_write(TDynamixelMaster *master,unsigned char num,unsigned char *ids,unsigned short int address, unsigned short int length, unsigned char * const data[]);
+unsigned char dyn_master_sync_read(TDynamixelMaster *master,unsigned char num,unsigned char *ids,unsigned short int address, unsigned short int length, unsigned char * const data[]);
+unsigned char dyn_master_bulk_read(TDynamixelMaster *master,unsigned char num,unsigned char *ids,unsigned short int *address, unsigned short int *length, unsigned char * const data[]);
+unsigned char dyn_master_bulk_write(TDynamixelMaster *master,unsigned char num,unsigned char *ids,unsigned short int *address, unsigned short int *length, unsigned char * const data[]);
 unsigned char dyn_master_relay(TDynamixelMaster *master,unsigned char *inst_pkt,unsigned char *status_pkt);
 
 #endif
diff --git a/dynamixel_base/include/dynamixel_slave.h b/dynamixel_base/include/dynamixel_slave.h
index d281ad1135479ddf58ba2c00edc85145a50f2013..0d1e51492bad1096687da25e2eee01632110b805 100644
--- a/dynamixel_base/include/dynamixel_slave.h
+++ b/dynamixel_base/include/dynamixel_slave.h
@@ -49,7 +49,7 @@ typedef struct
 
 /* public functions */
 void dyn_slave_init(TDynamixelSlave *slave,TComm *dev,unsigned char address,TDynVersion version);
-void dyn_slave_set_rx_timeout(TDynamixelSlave *slave,unsigned short int timeout_ms);
+inline void dyn_slave_set_rx_timeout(TDynamixelSlave *slave,unsigned short int timeout_ms);
 inline void dyn_slave_set_address(TDynamixelSlave *slave,unsigned char address);
 inline unsigned char dyn_slave_get_address(TDynamixelSlave *slave);
 inline void dyn_slave_set_return_delay(TDynamixelSlave *slave,unsigned char delay);
diff --git a/dynamixel_base/src/dynamixel.c b/dynamixel_base/src/dynamixel.c
index 659c3cdbd93c7c5ac5f4e8a8791c58adb4d58c7e..2f67ebe2db95c447d76a088349061dea2b316529 100755
--- a/dynamixel_base/src/dynamixel.c
+++ b/dynamixel_base/src/dynamixel.c
@@ -204,7 +204,7 @@ void dyn_init_reset_packet(unsigned char *packet,unsigned char id)
 }
 
 /* sync write instruction */
-void dyn_init_sync_write_packet(unsigned char *packet,unsigned char num_servos,unsigned char *servo_ids,unsigned char address,unsigned char length,TWriteData *data)
+void dyn_init_sync_write_packet(unsigned char *packet,unsigned char num_servos,unsigned char *servo_ids,unsigned char address,unsigned char length,unsigned char * const data[])
 {
   unsigned char i,j;
 
@@ -219,7 +219,7 @@ void dyn_init_sync_write_packet(unsigned char *packet,unsigned char num_servos,u
   {
     packet[DYN_DATA_OFF+2+(length+1)*i]=servo_ids[i];
     for(j=0;j<length;j++)
-      packet[DYN_DATA_OFF+2+(length+1)*i+j+1]=data[i].data_addr[j];
+      packet[DYN_DATA_OFF+2+(length+1)*i+j+1]=data[i][j];
   }
   dyn_set_checksum(packet);
 }
diff --git a/dynamixel_base/src/dynamixel2.c b/dynamixel_base/src/dynamixel2.c
index 72748eff9ecf0218e23bf0b78b5e320ccc7cc578..e9e134ab5dffd14d60b407fa4bdffef26fe7b525 100644
--- a/dynamixel_base/src/dynamixel2.c
+++ b/dynamixel_base/src/dynamixel2.c
@@ -259,7 +259,7 @@ void dyn2_init_reset_packet(unsigned char *packet,unsigned char id,unsigned char
 }
 
 /* sync write instruction */
-void dyn2_init_sync_write_packet(unsigned char *packet,unsigned char num_servos,unsigned char *servo_ids,unsigned short int address,unsigned short int length,TWriteData *data)
+void dyn2_init_sync_write_packet(unsigned char *packet,unsigned char num_servos,unsigned char *servo_ids,unsigned short int address,unsigned short int length,unsigned char * const data[])
 {
   unsigned char i;
   unsigned short int j;
@@ -277,7 +277,7 @@ void dyn2_init_sync_write_packet(unsigned char *packet,unsigned char num_servos,
   {
     packet[DYN2_DATA_OFF+4+(length+1)*i]=servo_ids[i];
     for(j=0;j<length;j++)
-      packet[DYN2_DATA_OFF+4+(length+1)*i+j+1]=data[i].data_addr[j];
+      packet[DYN2_DATA_OFF+4+(length+1)*i+j+1]=data[i][j];
   }
   dyn2_set_checksum(packet);
 }
@@ -380,7 +380,7 @@ unsigned char dyn2_bulk_read_id_present(unsigned char *packet,unsigned char id,u
 }
 
 /* bulk write instruction */
-void dyn2_init_bulk_write_packet(unsigned char *packet,unsigned char num_servos,unsigned char *servo_ids,unsigned short int *address,unsigned short int *length,TWriteData *data)
+void dyn2_init_bulk_write_packet(unsigned char *packet,unsigned char num_servos,unsigned char *servo_ids,unsigned short int *address,unsigned short int *length,unsigned char * const data[])
 {
   unsigned char i;
   unsigned short int total_length=0,j;
@@ -402,7 +402,7 @@ void dyn2_init_bulk_write_packet(unsigned char *packet,unsigned char num_servos,
     *((unsigned short int *)&packet[DYN2_DATA_OFF+total_length+3])=length[i];
     packet[DYN2_DATA_OFF+total_length+4]=(length[i]>>8)&0x00FF;
     for(j=0;j<length[i];j++)
-      packet[DYN2_DATA_OFF+total_length+5+j]=data[i].data_addr[j];
+      packet[DYN2_DATA_OFF+total_length+5+j]=data[i][j];
     total_length+=length[i]+5;
   }
   dyn2_set_checksum(packet);
diff --git a/dynamixel_base/src/dynamixel_master.c b/dynamixel_base/src/dynamixel_master.c
index cfeb073cfbbfdce3f57a719c8efebf0beea2dd13..48edf5d94d7796b9c18ee981d07ac85fed4567a6 100644
--- a/dynamixel_base/src/dynamixel_master.c
+++ b/dynamixel_base/src/dynamixel_master.c
@@ -1,111 +1,114 @@
 #include "dynamixel_master.h"
 
 /* private functions */
-unsigned char dyn_master_irq_receive_cb(void *dyn_master,unsigned char byte)
+unsigned char dyn_master_irq_receive_cb(TDynamixelMaster *dyn_master,unsigned char byte)
 {
-  TDynamixelMaster *dyn=(TDynamixelMaster *)dyn_master;
-
-  if(dyn->comm_dev->time!=0x00000000)
-    time_set_timeout(dyn->comm_dev->time,dyn->rx_timeout_ms*1000);
-  switch(dyn->received_bytes)
+  if(dyn_master!=0x00000000)
   {
-    case 0: if(byte==0xFF)
-            {
-              dyn->rx_buffer[dyn->received_bytes]=byte;
-              dyn->received_bytes++;
-            }
-            break;
-    case 1: if(byte==0xFF)
-            {
-              dyn->rx_buffer[dyn->received_bytes]=byte;
-              dyn->received_bytes++;
-            }
-            else
-              dyn->received_bytes--;
-            break;
-    case 2: if(byte==0xFD)// version 2 header
-            {
-              if(dyn->version==DYN_VER2)// the module is configured for version 2
+    if(dyn_master->comm_dev->time!=0x00000000)
+      time_set_timeout(dyn_master->comm_dev->time,dyn_master->rx_timeout_ms*1000);
+    switch(dyn_master->received_bytes)
+    {
+      case 0: if(byte==0xFF)
               {
-                dyn->rx_buffer[dyn->received_bytes]=byte;
-                dyn->received_bytes++;
+                dyn_master->rx_buffer[dyn_master->received_bytes]=byte;
+                dyn_master->received_bytes++;
+              }
+              break;
+      case 1: if(byte==0xFF)
+              {
+                dyn_master->rx_buffer[dyn_master->received_bytes]=byte;
+                dyn_master->received_bytes++;
               }
               else
-                dyn->received_bytes=0;// ignore packet and restart synchronization
-            }
-            else if(byte!=0xFF)
-            {
-              dyn->rx_buffer[dyn->received_bytes]=byte;
-              dyn->received_bytes++;
-            }
-            break;
-    case 3: dyn->rx_buffer[dyn->received_bytes]=byte;
-            if(dyn->version==DYN_VER1)
-            {
-              dyn->op_length=byte;
-              dyn->received_bytes=0;
+                dyn_master->received_bytes--;
+              break;
+      case 2: if(byte==0xFD)// version 2 header
+              {
+                if(dyn_master->version==DYN_VER2)// the module is configured for version 2
+                {
+                  dyn_master->rx_buffer[dyn_master->received_bytes]=byte;
+                  dyn_master->received_bytes++;
+                }
+                else
+                  dyn_master->received_bytes=0;// ignore packet and restart synchronization
+              }
+              else if(byte!=0xFF)
+              {
+                dyn_master->rx_buffer[dyn_master->received_bytes]=byte;
+                dyn_master->received_bytes++;
+              }
+              break;
+      case 3: dyn_master->rx_buffer[dyn_master->received_bytes]=byte;
+              if(dyn_master->version==DYN_VER1)
+              {
+                dyn_master->op_length=byte;
+                dyn_master->received_bytes=0;
+                /* finish reception by IRQ */
+                comm_cancel_irq_receive(dyn_master->comm_dev);
+                /* enable dma RX */
+                comm_receive_dma(dyn_master->comm_dev,&dyn_master->rx_buffer[4],dyn_master->op_length);
+              }
+              else
+                dyn_master->received_bytes++;
+              break;
+      case 4: dyn_master->rx_buffer[dyn_master->received_bytes]=byte;
+              dyn_master->received_bytes++;
+              break;
+      case 5: dyn_master->rx_buffer[dyn_master->received_bytes]=byte;
+              dyn_master->received_bytes++;
+              dyn_master->op_length=byte;
+              break;
+      case 6: dyn_master->rx_buffer[dyn_master->received_bytes]=byte;
+              dyn_master->received_bytes++;
+              dyn_master->op_length+=(byte<<8);
+              dyn_master->received_bytes=0;
               /* finish reception by IRQ */
-              comm_cancel_irq_receive(dyn->comm_dev);
+              comm_cancel_irq_receive(dyn_master->comm_dev);
               /* enable dma RX */
-              comm_receive_dma(dyn->comm_dev,&dyn->rx_buffer[4],dyn->op_length);
-            }
-            else
-              dyn->received_bytes++;
-            break;
-    case 4: dyn->rx_buffer[dyn->received_bytes]=byte;
-            dyn->received_bytes++;
-            break;
-    case 5: dyn->rx_buffer[dyn->received_bytes]=byte;
-            dyn->received_bytes++;
-            dyn->op_length=byte;
-            break;
-    case 6: dyn->rx_buffer[dyn->received_bytes]=byte;
-            dyn->received_bytes++;
-            dyn->op_length+=(byte<<8);
-            dyn->received_bytes=0;
-            /* finish reception by IRQ */
-            comm_cancel_irq_receive(dyn->comm_dev);
-            /* enable dma RX */
-            comm_receive_dma(dyn->comm_dev,&dyn->rx_buffer[7],dyn->op_length);
-            break;
-    default: break;
+              comm_receive_dma(dyn_master->comm_dev,&dyn_master->rx_buffer[7],dyn_master->op_length);
+              break;
+      default: break;
+    }
   }
 
   return 0x00;
 }
 
-unsigned char dyn_master_dma_send_cb(void *dyn_master)
+unsigned char dyn_master_dma_send_cb(TDynamixelMaster *dyn_master)
 {
-  TDynamixelMaster *dyn=(TDynamixelMaster *)dyn_master;
-
-  dyn->set_rx_mode();
-  if(dyn->rx_no_answer)
-    dyn->rx_no_answer=0x00;
-  else
+  if(dyn_master!=0x00000000)
   {
-    /* enable RX interrupts */
-    comm_receive_irq(dyn->comm_dev,0);
+    dyn_master->set_rx_mode();
+    if(dyn_master->rx_no_answer)
+      dyn_master->rx_no_answer=0x00;
+    else
+    {
+      /* enable RX interrupts */
+      comm_receive_irq(dyn_master->comm_dev,0);
+    }
   }
 
   return 0x00;
 }
 
-unsigned char dyn_master_dma_receive_cb(void *dyn_master)
+unsigned char dyn_master_dma_receive_cb(TDynamixelMaster *dyn_master)
 {
-  TDynamixelMaster *dyn=(TDynamixelMaster *)dyn_master;
-
-  dyn->rx_num_packets--;
-  if(dyn->rx_num_packets==0x00)
-  {
-    if(dyn->comm_dev->time!=0x00000000)
-      time_cancel_timeout(dyn->comm_dev->time);
-    dyn->packet_ready=0x01;
-  }
-  else
+  if(dyn_master!=0x00000000)
   {
-    /* enable RX interrupts */
-    comm_receive_irq(dyn->comm_dev,0);
-    dyn->packet_ready=0x01;
+    dyn_master->rx_num_packets--;
+    if(dyn_master->rx_num_packets==0x00)
+    {
+      if(dyn_master->comm_dev->time!=0x00000000)
+        time_cancel_timeout(dyn_master->comm_dev->time);
+      dyn_master->packet_ready=0x01;
+    }
+    else
+    {
+      /* enable RX interrupts */
+      comm_receive_irq(dyn_master->comm_dev,0);
+      dyn_master->packet_ready=0x01;
+    }
   }
 
   return 0x00;
@@ -125,11 +128,17 @@ unsigned char dyn_master_wait_transmission(TDynamixelMaster *master)
 {
   unsigned char error;
 
-  while((error=comm_is_send_done(master->comm_dev))==COMM_BUSY);
+  if(master!=0x00000000)
+  {
+    while((error=comm_is_send_done(master->comm_dev))==COMM_BUSY);
   
-  if(error==COMM_SUCCESS)
-    return DYN_SUCCESS;
-  else
+    if(error==COMM_SUCCESS)
+      return DYN_SUCCESS;
+    else
+      return DYN_COMM_ERROR;
+  }
+  
+  else 
     return DYN_COMM_ERROR;
 }
 
@@ -137,185 +146,213 @@ unsigned char dyn_master_is_transmission_done(TDynamixelMaster *master)
 {
   unsigned char error;
 
-  error=comm_is_send_done(master->comm_dev);
-  if(error==COMM_BUSY)
-    return DYN_BUSY;
-  else if(error==COMM_SUCCESS)
+  if(master!=0x00000000)
   {
-    if(master->comm_dev->time!=0x00000000)
+    error=comm_is_send_done(master->comm_dev);
+    if(error==COMM_BUSY)
+      return DYN_BUSY;
+    else if(error==COMM_SUCCESS)
     {
-      // start the new timeout
-      time_set_timeout(master->comm_dev->time,master->rx_timeout_ms*1000);
+      if(master->comm_dev->time!=0x00000000)
+      {
+        // start the new timeout
+        time_set_timeout(master->comm_dev->time,master->rx_timeout_ms*1000);
+      }
+      return DYN_SUCCESS;
+    }
+    else
+    {
+      master->set_rx_mode();
+      return DYN_COMM_ERROR;
     }
-    return DYN_SUCCESS;
   }
   else
-  {
-    master->set_rx_mode();
     return DYN_COMM_ERROR;
-  }
 }
 
 unsigned char dyn_master_send(TDynamixelMaster *master)
 {
   unsigned char error;
 
-  // wait until any previous transmission ends
-  if((error=dyn_master_wait_transmission(master))!=DYN_SUCCESS)
-    return error;
-  // set the DMA transfer
-  if(master->version==DYN_VER1)
+  if(master!=0x00000000)
   {
-    comm_send_dma(master->comm_dev,master->tx_buffer,dyn_get_length(master->tx_buffer)+4);
-    return DYN_SUCCESS;
+    // wait until any previous transmission ends
+    if((error=dyn_master_wait_transmission(master))!=DYN_SUCCESS)
+      return error;
+    // set the DMA transfer
+    if(master->version==DYN_VER1)
+    {
+      comm_send_dma(master->comm_dev,master->tx_buffer,dyn_get_length(master->tx_buffer)+4);
+      return DYN_SUCCESS;
+    }
+    else
+    {
+      comm_send_dma(master->comm_dev,master->tx_buffer,dyn2_get_length(master->tx_buffer)+7);
+      return DYN_SUCCESS;
+    }
   }
   else
-  {
-    comm_send_dma(master->comm_dev,master->tx_buffer,dyn2_get_length(master->tx_buffer)+7);
-    return DYN_SUCCESS;
-  }
+    return DYN_COMM_ERROR;
 } 
 
 unsigned char dyn_master_wait_reception(TDynamixelMaster *master)
 {
-  if(master->comm_dev->time!=0x00000000)
-  {
-    // start the new timeout
-    time_set_timeout(master->comm_dev->time,master->rx_timeout_ms*1000);
-  }
-  // wait for the status packet
-  while(!master->packet_ready)
+  if(master!=0x00000000)
   {
     if(master->comm_dev->time!=0x00000000)
     {
-      if(time_is_timeout(master->comm_dev->time))
+      // start the new timeout
+      time_set_timeout(master->comm_dev->time,master->rx_timeout_ms*1000);
+    }
+    // wait for the status packet
+    while(!master->packet_ready)
+    {
+      if(master->comm_dev->time!=0x00000000)
       {
-        comm_cancel_irq_receive(master->comm_dev);
-        comm_cancel_dma_receive(master->comm_dev);
-        master->received_bytes=0x00;
-        return DYN_TIMEOUT;
+        if(time_is_timeout(master->comm_dev->time))
+        {
+          comm_cancel_irq_receive(master->comm_dev);
+          comm_cancel_dma_receive(master->comm_dev);
+          master->received_bytes=0x00;
+          return DYN_TIMEOUT;
+        }
       }
     }
-  }
-  master->packet_ready=0x00;
-  // check the input packet checksum
-  if(master->version==DYN_VER1)
-  {
-    if(dyn_check_checksum(master->rx_buffer)==0xFF)
-      return dyn_get_status_error(master->rx_buffer);
+    master->packet_ready=0x00;
+    // check the input packet checksum
+    if(master->version==DYN_VER1)
+    {
+      if(dyn_check_checksum(master->rx_buffer)==0xFF)
+        return dyn_get_status_error(master->rx_buffer);
+      else
+        return DYN_CHECKSUM_ERROR;
+    }
     else
-      return DYN_CHECKSUM_ERROR;
+    {
+      if(dyn2_check_checksum(master->rx_buffer)==0x01)
+        return dyn2_get_status_error(master->rx_buffer);
+      else
+        return DYN_CHECKSUM_ERROR;
+    }
   }
   else
-  {
-    if(dyn2_check_checksum(master->rx_buffer)==0x01)
-      return dyn2_get_status_error(master->rx_buffer);
-    else
-      return DYN_CHECKSUM_ERROR;
-  }
+    return DYN_COMM_ERROR;
 }
 
 unsigned char dyn_master_is_reception_done(TDynamixelMaster *master)
 {
-  if(!master->packet_ready)
+  if(master!=0x00000000)
   {
-    if(master->comm_dev->time!=0x00000000)
+    if(!master->packet_ready)
     {
-      if(time_is_timeout(master->comm_dev->time))
+      if(master->comm_dev->time!=0x00000000)
       {
-        comm_cancel_irq_receive(master->comm_dev);
-        comm_cancel_dma_receive(master->comm_dev);
-        master->received_bytes=0x00;
-        return DYN_TIMEOUT;
+        if(time_is_timeout(master->comm_dev->time))
+        {
+          comm_cancel_irq_receive(master->comm_dev);
+          comm_cancel_dma_receive(master->comm_dev);
+          master->received_bytes=0x00;
+          return DYN_TIMEOUT;
+        }
+        else
+          return DYN_BUSY;
       }
       else
         return DYN_BUSY;
     }
     else
-      return DYN_BUSY;
+    {
+      master->packet_ready=0x00;
+      return DYN_SUCCESS;
+    }
   }
   else
-  {
-    master->packet_ready=0x00;
-    return DYN_SUCCESS;
-  }
+    return DYN_COMM_ERROR;
 }
 
 unsigned char dyn_master_start_read_table(TDynamixelMaster *master,unsigned char id,unsigned short int address,unsigned short int length,unsigned char *data)
 {
-  unsigned char error;
+  unsigned char error=DYN_COMM_ERROR;
 
-  // generate the read packet for the desired device
-  if(master->version==DYN_VER1)
-    dyn_init_read_packet(master->tx_buffer,id,address,length);
-  else
-    dyn2_init_read_packet(master->tx_buffer,id,address,length);
-  master->rx_num_packets=0x01;
-  if(master->return_level==no_return || id==DYN_BROADCAST_ID)
-    master->rx_no_answer=0x01;
-  else
-    master->rx_no_answer=0x00;
-  // enable transmission
-  master->set_tx_mode();
-  // send the data
-  if((error=dyn_master_send(master))!=DYN_SUCCESS)
-    master->set_rx_mode();
+  if(master!=0x00000000)
+  {
+    // generate the read packet for the desired device
+    if(master->version==DYN_VER1)
+      dyn_init_read_packet(master->tx_buffer,id,address,length);
+    else
+      dyn2_init_read_packet(master->tx_buffer,id,address,length);
+    master->rx_num_packets=0x01;
+    if(master->return_level==no_return || id==DYN_BROADCAST_ID)
+      master->rx_no_answer=0x01;
+    else
+      master->rx_no_answer=0x00;
+    // enable transmission
+    master->set_tx_mode();
+    // send the data
+    if((error=dyn_master_send(master))!=DYN_SUCCESS)
+      master->set_rx_mode();
+  } 
 
   return error;
 }
 
 unsigned char dyn_master_is_read_table_done(TDynamixelMaster *master,unsigned char id,unsigned short int address,unsigned short int length,unsigned char *data)
 {
-  unsigned char error;
+  unsigned char error=DYN_COMM_ERROR;
 
-  if((error=dyn_master_is_transmission_done(master))==DYN_SUCCESS)
+  if(master!=0x00000000)
   {
-    // wait for the replay within the given timeout
-    if(master->return_level!=no_return && id!=DYN_BROADCAST_ID)
+    if((error=dyn_master_is_transmission_done(master))==DYN_SUCCESS)
     {
-      if((error=dyn_master_is_reception_done(master))==DYN_SUCCESS)
+      // wait for the replay within the given timeout
+      if(master->return_level!=no_return && id!=DYN_BROADCAST_ID)
       {
-        // check the input packet checksum
-        if(master->version==DYN_VER1)
+        if((error=dyn_master_is_reception_done(master))==DYN_SUCCESS)
         {
-          if(dyn_check_checksum(master->rx_buffer)==0xFF)
+          // check the input packet checksum
+          if(master->version==DYN_VER1)
           {
-            if((error=dyn_get_status_error(master->rx_buffer))==DYN_SUCCESS)
+            if(dyn_check_checksum(master->rx_buffer)==0xFF)
             {
-              if(dyn_get_read_status_data(master->rx_buffer,data)!=length)// not enough data
-                return DYN_INST_ERROR;
-              else
-                return DYN_SUCCESS;
+              if((error=dyn_get_status_error(master->rx_buffer))==DYN_SUCCESS)
+              {
+                if(dyn_get_read_status_data(master->rx_buffer,data)!=length)// not enough data
+                  return DYN_INST_ERROR;
+                else
+                  return DYN_SUCCESS;
+              }
+              else 
+                return error;
             }
-            else 
-              return error;
+            else
+              return DYN_CHECKSUM_ERROR;
           }
           else
-            return DYN_CHECKSUM_ERROR;
-        }
-        else
-        {
-          if(dyn2_check_checksum(master->rx_buffer)==0x01)
           {
-            if((error=dyn2_get_status_error(master->rx_buffer))==DYN_SUCCESS)
+            if(dyn2_check_checksum(master->rx_buffer)==0x01)
             {
-              if(dyn2_get_read_status_data(master->rx_buffer,data)!=length)// not enough data
-                return DYN_INST_ERROR;
+              if((error=dyn2_get_status_error(master->rx_buffer))==DYN_SUCCESS)
+              {
+                if(dyn2_get_read_status_data(master->rx_buffer,data)!=length)// not enough data
+                  return DYN_INST_ERROR;
+                else
+                  return DYN_SUCCESS;
+              }
               else
-                return DYN_SUCCESS;
+                return error;
             }
             else
-              return error;
+              return DYN_CHECKSUM_ERROR;
           }
-          else
-            return DYN_CHECKSUM_ERROR;
         }
+        else
+          return error;
       }
       else
-        return error;
+        return DYN_SUCCESS;
     }
     else
-      return DYN_SUCCESS;
+      return error;
   }
   else
     return error;
@@ -323,318 +360,362 @@ unsigned char dyn_master_is_read_table_done(TDynamixelMaster *master,unsigned ch
 
 unsigned char dyn_master_start_write_table(TDynamixelMaster *master,unsigned char id,unsigned short int address,unsigned short int length,unsigned char *data)
 {
-  unsigned char error;
+  unsigned char error=DYN_COMM_ERROR;
 
-  // generate the read packet for the desired device
-  if(master->version==DYN_VER1)
-    dyn_init_write_packet(master->tx_buffer,id,address,length,data);
-  else
-    dyn2_init_write_packet(master->tx_buffer,id,address,length,data);
-  master->rx_num_packets=0x01;
-  if(master->return_level==return_all && id!=DYN_BROADCAST_ID)
-    master->rx_no_answer=0x00;
-  else
-    master->rx_no_answer=0x01;
-  // enable transmission
-  master->set_tx_mode();
-  // send the data
-  if((error=dyn_master_send(master))!=DYN_SUCCESS)
-    master->set_rx_mode();
+  if(master!=0x00000000)
+  {
+    // generate the read packet for the desired device
+    if(master->version==DYN_VER1)
+      dyn_init_write_packet(master->tx_buffer,id,address,length,data);
+    else
+      dyn2_init_write_packet(master->tx_buffer,id,address,length,data);
+    master->rx_num_packets=0x01;
+    if(master->return_level==return_all && id!=DYN_BROADCAST_ID)
+      master->rx_no_answer=0x00;
+    else
+      master->rx_no_answer=0x01;
+    // enable transmission
+    master->set_tx_mode();
+    // send the data
+    if((error=dyn_master_send(master))!=DYN_SUCCESS)
+      master->set_rx_mode();
+  }
 
   return error;
 }
 
 unsigned char dyn_master_is_write_table_done(TDynamixelMaster *master,unsigned char id,unsigned short int address,unsigned short int length,unsigned char *data)
 {
-  unsigned char error;
+  unsigned char error=DYN_COMM_ERROR;
 
-  if((error=dyn_master_is_transmission_done(master))==DYN_SUCCESS)
+  if(master!=0x00000000)
   {
-    // wait for the replay within the given timeout
-    if(master->return_level==return_all && id!=DYN_BROADCAST_ID)
+    if((error=dyn_master_is_transmission_done(master))==DYN_SUCCESS)
     {
-      if((error=dyn_master_is_reception_done(master))==DYN_SUCCESS)
+      // wait for the replay within the given timeout
+      if(master->return_level==return_all && id!=DYN_BROADCAST_ID)
       {
-        // check the input packet checksum
-        if(master->version==DYN_VER1)
+        if((error=dyn_master_is_reception_done(master))==DYN_SUCCESS)
         {
-          if(dyn_check_checksum(master->rx_buffer)==0xFF)
-            return dyn_get_status_error(master->rx_buffer);
+          // check the input packet checksum
+          if(master->version==DYN_VER1)
+          {
+            if(dyn_check_checksum(master->rx_buffer)==0xFF)
+              return dyn_get_status_error(master->rx_buffer);
+            else
+              return DYN_CHECKSUM_ERROR;
+          }
           else
-            return DYN_CHECKSUM_ERROR;
+          {
+            if(dyn2_check_checksum(master->rx_buffer)==0x01)
+              return dyn2_get_status_error(master->rx_buffer);
+            else
+              return DYN_CHECKSUM_ERROR;
+          }
         }
         else
-        {
-          if(dyn2_check_checksum(master->rx_buffer)==0x01)
-            return dyn2_get_status_error(master->rx_buffer);
-          else
-            return DYN_CHECKSUM_ERROR;
-        }
+          return error;
       }
       else
-        return error;
+        return DYN_SUCCESS;
     }
     else
-      return DYN_SUCCESS;
+      return error;
   }
   else
     return error;
 }
 
-unsigned char dyn_master_start_sync_write(TDynamixelMaster *master,unsigned char num,unsigned char *ids,unsigned short int address, unsigned short int length, TWriteData *data)
-{
-  unsigned char error;
-
-  // generate the read packet for the desired device
-  if(master->version==DYN_VER1)
-    dyn_init_sync_write_packet(master->tx_buffer,num,ids,address,length,data);
-  else
-    dyn2_init_sync_write_packet(master->tx_buffer,num,ids,address,length,data);
-  master->rx_num_packets=0x01;
-  master->rx_no_answer=0x00;
-  // enable transmission
-  master->set_tx_mode();
-  // send the data
-  if((error=dyn_master_send(master))!=DYN_SUCCESS)
-    master->set_rx_mode();
-
-  return error;
-}
-
-unsigned char dyn_master_is_sync_write_done(TDynamixelMaster *master,unsigned char num,unsigned char *ids,unsigned short int address, unsigned short int length, TWriteData *data)
-{
-  unsigned char error;
-
-  error=comm_is_send_done(master->comm_dev);
-  if(error==COMM_BUSY)
-    return DYN_BUSY;
-  else if(error==COMM_SUCCESS)
-    return DYN_SUCCESS;
-  else
-  {
-    master->set_rx_mode();
-    return DYN_COMM_ERROR;
-  }
-}
-
-unsigned char dyn_master_start_sync_read(TDynamixelMaster *master,unsigned char num,unsigned char *ids,unsigned short int address, unsigned short int length, TWriteData *data)
+unsigned char dyn_master_start_sync_write(TDynamixelMaster *master,unsigned char num,unsigned char *ids,unsigned short int address, unsigned short int length, unsigned char * const data[])
 {
-  unsigned char error;
+  unsigned char error=DYN_COMM_ERROR;
 
-  // generate the read packet for the desired device
-  if(master->version==DYN_VER2)
+  if(master!=0x00000000) 
   {
-    dyn2_init_sync_read_packet(master->tx_buffer,num,ids,address,length);
-    master->rx_num_packets=num;
-    if(master->return_level==no_return)
-      master->rx_no_answer=0x01;
+    // generate the read packet for the desired device
+    if(master->version==DYN_VER1)
+      dyn_init_sync_write_packet(master->tx_buffer,num,ids,address,length,data);
     else
-      master->rx_no_answer=0x00;
+      dyn2_init_sync_write_packet(master->tx_buffer,num,ids,address,length,data);
+    master->rx_num_packets=0x01;
+    master->rx_no_answer=0x00;
     // enable transmission
     master->set_tx_mode();
     // send the data
     if((error=dyn_master_send(master))!=DYN_SUCCESS)
       master->set_rx_mode();
-
-    return error;
   }
-  else
-    return DYN_INST_ERROR;
+
+  return error;
 }
 
-unsigned char dyn_master_is_sync_read_done(TDynamixelMaster *master,unsigned char num,unsigned char *ids,unsigned short int address, unsigned short int length, TWriteData *data)
+unsigned char dyn_master_is_sync_write_done(TDynamixelMaster *master,unsigned char num,unsigned char *ids,unsigned short int address, unsigned short int length,unsigned char * const data[])
 {
-  static unsigned char num_dev_done=0;
-  unsigned char error;
+  unsigned char error=DYN_COMM_ERROR;
 
-  // generate the read packet for the desired device
-  if(master->version==DYN_VER2)
+  if(master!=0x00000000)
   {
-    if((error=dyn_master_is_transmission_done(master))==DYN_SUCCESS)
+    error=comm_is_send_done(master->comm_dev);
+    if(error==COMM_BUSY)
+      return DYN_BUSY;
+    else if(error==COMM_SUCCESS)
+      return DYN_SUCCESS;
+    else
     {
-      // wait for the replay within the given timeout
-      if(master->return_level!=no_return)
-      {
-        if(num_dev_done<num)
+      master->set_rx_mode();
+      return DYN_COMM_ERROR;
+    }
+  }
+  else
+    return error;
+}
+
+unsigned char dyn_master_start_sync_read(TDynamixelMaster *master,unsigned char num,unsigned char *ids,unsigned short int address, unsigned short int length, unsigned char * const data[])
+{
+  unsigned char error=DYN_COMM_ERROR;
+
+  if(master!=0x00000000)
+  {
+    // generate the read packet for the desired device
+    if(master->version==DYN_VER2)
+    { 
+      dyn2_init_sync_read_packet(master->tx_buffer,num,ids,address,length);
+      master->rx_num_packets=num;
+      if(master->return_level==no_return)
+        master->rx_no_answer=0x01;
+      else
+        master->rx_no_answer=0x00;
+      // enable transmission
+      master->set_tx_mode();
+      // send the data
+      if((error=dyn_master_send(master))!=DYN_SUCCESS)
+        master->set_rx_mode();
+
+      return error;
+    }
+    else
+      return DYN_INST_ERROR;
+  }
+  else
+    return error;
+}
+
+unsigned char dyn_master_is_sync_read_done(TDynamixelMaster *master,unsigned char num,unsigned char *ids,unsigned short int address, unsigned short int length, unsigned char * const data[])
+{
+  static unsigned char num_dev_done=0;
+  unsigned char error=DYN_COMM_ERROR;
+
+  if(master!=0x00000000)
+  {
+    // generate the read packet for the desired device
+    if(master->version==DYN_VER2)
+    {
+      if((error=dyn_master_is_transmission_done(master))==DYN_SUCCESS)
+      {
+        // wait for the replay within the given timeout
+        if(master->return_level!=no_return)
         {
-          if((error=dyn_master_is_reception_done(master))==DYN_SUCCESS)
+          if(num_dev_done<num)
           {
-            if(dyn2_check_checksum(master->rx_buffer)==0x01)
+            if((error=dyn_master_is_reception_done(master))==DYN_SUCCESS)
             {
-              if((error=dyn2_get_status_error(master->rx_buffer))==DYN_SUCCESS)
+              if(dyn2_check_checksum(master->rx_buffer)==0x01)
               {
-                while(dyn2_get_read_status_id(master->rx_buffer)!=ids[num_dev_done]) num_dev_done++;
-                if(dyn2_get_read_status_data(master->rx_buffer,data[num_dev_done].data_addr)!=length)// not enough data
-                  return DYN_INST_ERROR;
-                else
+                if((error=dyn2_get_status_error(master->rx_buffer))==DYN_SUCCESS)
                 {
-                  num_dev_done++;
-                  return DYN_BUSY;
+                  while(dyn2_get_read_status_id(master->rx_buffer)!=ids[num_dev_done]) num_dev_done++;
+                  if(dyn2_get_read_status_data(master->rx_buffer,(unsigned char *)data[num_dev_done])!=length)// not enough data
+                    return DYN_INST_ERROR;
+                  else
+                  {
+                    num_dev_done++;
+                    return DYN_BUSY;
+                  }
                 }
+                else
+                  return error;
               }
               else
-                return error;
+                return DYN_CHECKSUM_ERROR;
             }
             else
-              return DYN_CHECKSUM_ERROR;
+              return error;
           }
-          else
-            return error;
+          else 
+            return DYN_SUCCESS;
         }
-        else 
+        else
           return DYN_SUCCESS;
       }
       else
-        return DYN_SUCCESS;
+        return error;
     }
     else
-      return error;
+      return DYN_INST_ERROR;
   }
-  else
-    return DYN_INST_ERROR;
+  else 
+    return error;
 }
 
-unsigned char dyn_master_start_bulk_write(TDynamixelMaster *master,unsigned char num,unsigned char *ids,unsigned short int *address, unsigned short int *length, TWriteData *data)
+unsigned char dyn_master_start_bulk_write(TDynamixelMaster *master,unsigned char num,unsigned char *ids,unsigned short int *address, unsigned short int *length, unsigned char * const data[])
 {
-  unsigned char error;
+  unsigned char error=DYN_COMM_ERROR;
 
-  // generate the read packet for the desired device
-  if(master->version==DYN_VER2)
+  if(master!=0x00000000)
   {
-    dyn2_init_bulk_write_packet(master->tx_buffer,num,ids,address,length,data);
-    master->rx_num_packets=0x01;
-    master->rx_no_answer=0x00;
-    // enable transmission
-    master->set_tx_mode();
-    // send the data
-    if((error=dyn_master_send(master))!=DYN_SUCCESS)
-      master->set_rx_mode();
-
-    return error;
+    // generate the read packet for the desired device
+    if(master->version==DYN_VER2)
+    {
+      dyn2_init_bulk_write_packet(master->tx_buffer,num,ids,address,length,data);
+      master->rx_num_packets=0x01;
+      master->rx_no_answer=0x00;
+      // enable transmission
+      master->set_tx_mode();
+      // send the data
+      if((error=dyn_master_send(master))!=DYN_SUCCESS)
+        master->set_rx_mode();
+ 
+      return error;
+    }
+    else
+      return DYN_INST_ERROR;
   }
   else
-    return DYN_INST_ERROR;
+    return error;
 }
 
-unsigned char dyn_master_is_bulk_write_done(TDynamixelMaster *master,unsigned char num,unsigned char *ids,unsigned short int *address, unsigned short int *length, TWriteData *data)
+unsigned char dyn_master_is_bulk_write_done(TDynamixelMaster *master,unsigned char num,unsigned char *ids,unsigned short int *address, unsigned short int *length, unsigned char * const data[])
 {
-  unsigned char error;
+  unsigned char error=DYN_COMM_ERROR;
 
-  if(master->version==DYN_VER2)
+  if(master!=0x00000000)
   {
-    error=comm_is_send_done(master->comm_dev);
-    if(error==COMM_BUSY)
-      return DYN_BUSY;
-    else if(error==COMM_SUCCESS)
-      return DYN_SUCCESS;
-    else
+    if(master->version==DYN_VER2)
     {
-      master->set_rx_mode();
-      return DYN_COMM_ERROR;
+      error=comm_is_send_done(master->comm_dev);
+      if(error==COMM_BUSY)
+        return DYN_BUSY;
+      else if(error==COMM_SUCCESS)
+        return DYN_SUCCESS;
+      else
+      {
+        master->set_rx_mode();
+        return DYN_COMM_ERROR;
+      }
     }
+    else
+      return DYN_INST_ERROR;
   }
-  else
-    return DYN_INST_ERROR;
+  else 
+    return error;
 }
 
-unsigned char dyn_master_start_bulk_read(TDynamixelMaster *master,unsigned char num,unsigned char *ids,unsigned short int *address, unsigned short int *length, TWriteData *data)
+unsigned char dyn_master_start_bulk_read(TDynamixelMaster *master,unsigned char num,unsigned char *ids,unsigned short int *address, unsigned short int *length, unsigned char * const data[])
 {
-  unsigned char error,i,ver1_address[255],ver1_length[255];
+  unsigned char error=DYN_COMM_ERROR,i,ver1_address[255],ver1_length[255];
 
-  // generate the read packet for the desired device
-  if(master->version==DYN_VER1)
+  if(master!=0x00000000)
   {
-    for(i=0;i<num;i++)
+    // generate the read packet for the desired device
+    if(master->version==DYN_VER1)
     {
-      ver1_address[i]=address[i];
-      ver1_length[i]=length[i];
+      for(i=0;i<num;i++)
+      {
+        ver1_address[i]=address[i];
+        ver1_length[i]=length[i];
+      }
+      dyn_init_bulk_read_packet(master->tx_buffer,num,ids,ver1_address,ver1_length);
     }
-    dyn_init_bulk_read_packet(master->tx_buffer,num,ids,ver1_address,ver1_length);
+    else
+      dyn2_init_bulk_read_packet(master->tx_buffer,num,ids,address,length);
+    master->rx_num_packets=num;
+    if(master->return_level==no_return)
+      master->rx_no_answer=0x01;
+    else
+      master->rx_no_answer=0x00;
+    // enable transmission
+    master->set_tx_mode();
+    // send the data
+    if((error=dyn_master_send(master))!=DYN_SUCCESS)
+      master->set_rx_mode();
   }
-  else
-    dyn2_init_bulk_read_packet(master->tx_buffer,num,ids,address,length);
-  master->rx_num_packets=num;
-  if(master->return_level==no_return)
-    master->rx_no_answer=0x01;
-  else
-    master->rx_no_answer=0x00;
-  // enable transmission
-  master->set_tx_mode();
-  // send the data
-  if((error=dyn_master_send(master))!=DYN_SUCCESS)
-    master->set_rx_mode();
 
   return error;
 }
 
-unsigned char dyn_master_is_bulk_read_done(TDynamixelMaster *master,unsigned char num,unsigned char *ids,unsigned short int *address, unsigned short int *length, TWriteData *data)
+unsigned char dyn_master_is_bulk_read_done(TDynamixelMaster *master,unsigned char num,unsigned char *ids,unsigned short int *address, unsigned short int *length, unsigned char * const data[])
 {
   static unsigned char num_dev_done=0;
-  unsigned char error;
+  unsigned char error=DYN_COMM_ERROR;
 
-  if((error=dyn_master_is_transmission_done(master))==DYN_SUCCESS)
+  if(master!=0x00000000)
   {
-    // wait for the replay within the given timeout
-    if(master->return_level!=no_return)
+    if((error=dyn_master_is_transmission_done(master))==DYN_SUCCESS)
     {
-      if(num_dev_done<num)
+      // wait for the replay within the given timeout
+      if(master->return_level!=no_return)
       {
-        if((error=dyn_master_is_reception_done(master))==DYN_SUCCESS)
+        if(num_dev_done<num)
         {
-          // check the input packet checksum
-          if(master->version==DYN_VER1)
+          if((error=dyn_master_is_reception_done(master))==DYN_SUCCESS)
           {
-            if(dyn_check_checksum(master->rx_buffer)==0xFF)
+            // check the input packet checksum
+            if(master->version==DYN_VER1)
             {
-              if((error=dyn_get_status_error(master->rx_buffer))==DYN_SUCCESS)
+              if(dyn_check_checksum(master->rx_buffer)==0xFF)
               {
-                while(dyn_get_read_status_id(master->rx_buffer)!=ids[num_dev_done]) num_dev_done++;
-                if(dyn_get_read_status_data(master->rx_buffer,data[num_dev_done].data_addr)!=length[num_dev_done])// not enough data
-                  return DYN_INST_ERROR;
-                else
+                if((error=dyn_get_status_error(master->rx_buffer))==DYN_SUCCESS)
                 {
-                  num_dev_done++;
-                  return DYN_BUSY;
+                  while(dyn_get_read_status_id(master->rx_buffer)!=ids[num_dev_done]) num_dev_done++;
+                  if(dyn_get_read_status_data(master->rx_buffer,(unsigned char *)data[num_dev_done])!=length[num_dev_done])// not enough data
+                    return DYN_INST_ERROR;
+                  else
+                  {
+                    num_dev_done++;
+                    return DYN_BUSY;
+                  }
                 }
+                else
+                  return error;
               }
               else
-                return error;
+                return DYN_CHECKSUM_ERROR;
             }
             else
-              return DYN_CHECKSUM_ERROR;
-          }
-          else
-          {
-            if(dyn2_check_checksum(master->rx_buffer)==0x01)
             {
-              if((error=dyn2_get_status_error(master->rx_buffer))==DYN_SUCCESS)
+              if(dyn2_check_checksum(master->rx_buffer)==0x01)
               {
-                while(dyn2_get_read_status_id(master->rx_buffer)!=ids[num_dev_done]) num_dev_done++;
-                if(dyn2_get_read_status_data(master->rx_buffer,data[num_dev_done].data_addr)!=length[num_dev_done])// not enough data
-                  return DYN_INST_ERROR;
-                else
+                if((error=dyn2_get_status_error(master->rx_buffer))==DYN_SUCCESS)
                 {
-                  num_dev_done++;
-                  return DYN_BUSY;
+                  while(dyn2_get_read_status_id(master->rx_buffer)!=ids[num_dev_done]) num_dev_done++;
+                  if(dyn2_get_read_status_data(master->rx_buffer,(unsigned char *)data[num_dev_done])!=length[num_dev_done])// not enough data
+                    return DYN_INST_ERROR;
+                  else
+                  {
+                    num_dev_done++;
+                    return DYN_BUSY;
+                  }
                 }
+                else
+                  return error;
               }
               else
-                return error;
+                return DYN_CHECKSUM_ERROR;
             }
-            else
-              return DYN_CHECKSUM_ERROR;
           }
+          else
+            return error;
         }
         else
-          return error;
+          return DYN_SUCCESS;
       }
       else
         return DYN_SUCCESS;
     }
     else
-      return DYN_SUCCESS;
+      return error; 
   }
-  else
+  else 
     return error;
 }
 
@@ -642,9 +723,9 @@ unsigned char dyn_master_is_bulk_read_done(TDynamixelMaster *master,unsigned cha
 void dyn_master_init(TDynamixelMaster *master,TComm *dev,TDynVersion version)
 {
   /* assign communication functions */
-  dev->irq_receive_cb=dyn_master_irq_receive_cb;
-  dev->dma_send_cb=dyn_master_dma_send_cb;
-  dev->dma_receive_cb=dyn_master_dma_receive_cb;
+  dev->irq_receive_cb=(unsigned char (*)(void *,unsigned char))dyn_master_irq_receive_cb;
+  dev->dma_send_cb=(unsigned char (*)(void *))dyn_master_dma_send_cb;
+  dev->dma_receive_cb=(unsigned char (*)(void *))dyn_master_dma_receive_cb;
   master->comm_dev=dev;
   master->version=version;
   dev->data=master;
@@ -662,19 +743,24 @@ void dyn_master_init(TDynamixelMaster *master,TComm *dev,TDynVersion version)
   master->set_rx_mode();
 }
 
-void dyn_master_set_rx_timeout(TDynamixelMaster *master,unsigned short int timeout_ms)
+inline void dyn_master_set_rx_timeout(TDynamixelMaster *master,unsigned short int timeout_ms)
 {
-  master->rx_timeout_ms=timeout_ms;
+  if(master!=0x00000000)
+    master->rx_timeout_ms=timeout_ms;
 }
 
 inline void dyn_master_set_return_level(TDynamixelMaster *master,return_level_t level)
 {
-  master->return_level=level;
+  if(master!=0x00000000)
+    master->return_level=level;
 }
 
 inline return_level_t dyn_master_get_return_level(TDynamixelMaster *master)
 {
-  return master->return_level;
+  if(master!=0x00000000)
+    return master->return_level;
+  else 
+    return return_all; 
 }
 
 void dyn_master_scan(TDynamixelMaster *master,unsigned char *num,unsigned char *ids)
@@ -682,48 +768,54 @@ void dyn_master_scan(TDynamixelMaster *master,unsigned char *num,unsigned char *
   unsigned char i;
 
   *num=0;
-  for(i=0;i<254;i++)
+  if(master!=0x00000000)
   {
-    if(dyn_master_ping(master,i)==DYN_SUCCESS)// the device exists
+    for(i=0;i<254;i++)
     {
-      ids[*num]=i;
-      (*num)++;
+      if(dyn_master_ping(master,i)==DYN_SUCCESS)// the device exists
+      {
+        ids[*num]=i;
+        (*num)++;
+      }
     }
   }
 }
 
 unsigned char dyn_master_ping(TDynamixelMaster *master,unsigned char id)
 {
-  unsigned char error;
+  unsigned char error=DYN_COMM_ERROR;
 
-  // generate the ping packet for the desired device
-  if(master->version==DYN_VER1)
-    dyn_init_ping_packet(master->tx_buffer,id);
-  else
-    dyn2_init_ping_packet(master->tx_buffer,id);
-  master->rx_num_packets=0x01;
-  master->rx_no_answer=0x00;
-  // enable transmission
-  master->set_tx_mode();
-  // send the data
-  if((error=dyn_master_send(master))!=DYN_SUCCESS)
-  {
-    master->set_rx_mode();
-    return error;
-  }
-  // wait for the transmission to end
-  if((error=dyn_master_wait_transmission(master))!=DYN_SUCCESS)
+  if(master!=0x00000000)
   {
-    master->set_rx_mode();
-    return error;
+    // generate the ping packet for the desired device
+    if(master->version==DYN_VER1)
+      dyn_init_ping_packet(master->tx_buffer,id);
+    else
+      dyn2_init_ping_packet(master->tx_buffer,id);
+    master->rx_num_packets=0x01;
+    master->rx_no_answer=0x00;
+    // enable transmission
+    master->set_tx_mode();
+    // send the data
+    if((error=dyn_master_send(master))!=DYN_SUCCESS)
+    {
+      master->set_rx_mode();
+      return error;
+    }
+    // wait for the transmission to end
+    if((error=dyn_master_wait_transmission(master))!=DYN_SUCCESS)
+    {
+      master->set_rx_mode();
+      return error;
+    }
+    // wait for the replay within the given timeout
+    error=dyn_master_wait_reception(master);
   }
-  // wait for the replay within the given timeout
-  error=dyn_master_wait_reception(master);
 
   return error;
 }
 
-unsigned char dyn_master_read_byte(TDynamixelMaster *master,unsigned char id,unsigned short int address,unsigned char *data)
+inline unsigned char dyn_master_read_byte(TDynamixelMaster *master,unsigned char id,unsigned short int address,unsigned char *data)
 {
   return dyn_master_read_table(master,id,address,1,data);
 }
@@ -742,54 +834,57 @@ unsigned char dyn_master_read_word(TDynamixelMaster *master,unsigned char id,uns
 
 unsigned char dyn_master_read_table(TDynamixelMaster *master,unsigned char id,unsigned short int address,unsigned short int length,unsigned char *data)
 {
-  unsigned char error;
+  unsigned char error=DYN_COMM_ERROR;
 
-  // generate the read packet for the desired device
-  if(master->version==DYN_VER1)
-    dyn_init_read_packet(master->tx_buffer,id,address,length);
-  else
-    dyn2_init_read_packet(master->tx_buffer,id,address,length);
-  master->rx_num_packets=0x01;
-  if(master->return_level==no_return || id==DYN_BROADCAST_ID)
-    master->rx_no_answer=0x01;
-  else
-    master->rx_no_answer=0x00;
-  // enable transmission
-  master->set_tx_mode();
-  // send the data
-  if((error=dyn_master_send(master))!=DYN_SUCCESS)
+  if(master!=0x00000000)
   {
-    master->set_rx_mode();
-    return error;
-  }
-  // wait for the transmission to end
-  if((error=dyn_master_wait_transmission(master))!=DYN_SUCCESS)
-  {
-    master->set_rx_mode();
-    return error;
-  }
-  // wait for the replay within the given timeout
-  if(master->return_level!=no_return && id!=DYN_BROADCAST_ID)
-  {
-    if((error=dyn_master_wait_reception(master))==DYN_SUCCESS)
+    // generate the read packet for the desired device
+    if(master->version==DYN_VER1)
+      dyn_init_read_packet(master->tx_buffer,id,address,length);
+    else
+      dyn2_init_read_packet(master->tx_buffer,id,address,length);
+    master->rx_num_packets=0x01;
+    if(master->return_level==no_return || id==DYN_BROADCAST_ID)
+      master->rx_no_answer=0x01;
+    else
+      master->rx_no_answer=0x00;
+    // enable transmission
+    master->set_tx_mode();
+    // send the data
+    if((error=dyn_master_send(master))!=DYN_SUCCESS)
+    { 
+      master->set_rx_mode();
+      return error;
+    }
+    // wait for the transmission to end
+    if((error=dyn_master_wait_transmission(master))!=DYN_SUCCESS)
     {
-      if(master->version==DYN_VER1)
-      {
-        if(dyn_get_read_status_data(master->rx_buffer,data)!=length)// not enough data
-          error=DYN_INST_ERROR;
-      }
-      else
+      master->set_rx_mode();
+      return error;
+    }
+    // wait for the replay within the given timeout
+    if(master->return_level!=no_return && id!=DYN_BROADCAST_ID)
+    {
+      if((error=dyn_master_wait_reception(master))==DYN_SUCCESS)
       {
-        if(dyn2_get_read_status_data(master->rx_buffer,data)!=length)// not enough data
-          error=DYN_INST_ERROR;
+        if(master->version==DYN_VER1)
+        {
+          if(dyn_get_read_status_data(master->rx_buffer,data)!=length)// not enough data
+            error=DYN_INST_ERROR;
+        }
+        else
+        {
+          if(dyn2_get_read_status_data(master->rx_buffer,data)!=length)// not enough data
+            error=DYN_INST_ERROR;
+        }
       }
-    }
-  } 
+    } 
+  }
 
   return error;
 }
 
-unsigned char dyn_master_write_byte(TDynamixelMaster *master,unsigned char id, unsigned short int address, unsigned char data)
+inline unsigned char dyn_master_write_byte(TDynamixelMaster *master,unsigned char id, unsigned short int address, unsigned char data)
 {
   return dyn_master_write_table(master,id,address,1,&data);
 }
@@ -805,140 +900,210 @@ unsigned char dyn_master_write_word(TDynamixelMaster *master,unsigned char id, u
 
 unsigned char dyn_master_write_table(TDynamixelMaster *master,unsigned char id, unsigned short int address, unsigned short int length, unsigned char *data)
 {
-  unsigned char error;
+  unsigned char error=DYN_COMM_ERROR;
 
-  // generate the write packet for the desired device
-  if(master->version==DYN_VER1)
-    dyn_init_write_packet(master->tx_buffer,id,address,length,data);
-  else
-    dyn2_init_write_packet(master->tx_buffer,id,address,length,data);
-  master->rx_num_packets=0x01;
-  if(master->return_level==return_all && id!=DYN_BROADCAST_ID)
-    master->rx_no_answer=0x00;
-  else
-    master->rx_no_answer=0x01;
-  // enable transmission
-  master->set_tx_mode();
-  // send the data
-  if((error=dyn_master_send(master))!=DYN_SUCCESS)
-  {
-    master->set_rx_mode();
-    return error;
-  }
-  // wait for the transmission to end
-  if((error=dyn_master_wait_transmission(master))!=DYN_SUCCESS)
+  if(master!=0x00000000)
   {
-    master->set_rx_mode();
-    return error;
+    // generate the write packet for the desired device
+    if(master->version==DYN_VER1)
+      dyn_init_write_packet(master->tx_buffer,id,address,length,data);
+    else
+      dyn2_init_write_packet(master->tx_buffer,id,address,length,data);
+    master->rx_num_packets=0x01;
+    if(master->return_level==return_all && id!=DYN_BROADCAST_ID)
+      master->rx_no_answer=0x00;
+    else
+      master->rx_no_answer=0x01;
+    // enable transmission
+    master->set_tx_mode();
+    // send the data
+    if((error=dyn_master_send(master))!=DYN_SUCCESS)
+    {
+      master->set_rx_mode();
+      return error;
+    }
+    // wait for the transmission to end
+    if((error=dyn_master_wait_transmission(master))!=DYN_SUCCESS)
+    {
+      master->set_rx_mode();
+      return error;
+    }
+    // wait for the replay within the given timeout
+    if(master->return_level==return_all && id!=DYN_BROADCAST_ID)
+      error=dyn_master_wait_reception(master);
   }
-  // wait for the replay within the given timeout
-  if(master->return_level==return_all && id!=DYN_BROADCAST_ID)
-    error=dyn_master_wait_reception(master);
 
   return error;
 }
 
 unsigned char dyn_master_reg_write(TDynamixelMaster *master,unsigned char id, unsigned short int address, unsigned short int length, unsigned char *data)
 {
-  unsigned char error;
+  unsigned char error=DYN_COMM_ERROR;
 
-  // generate the registered write packet for the desired device
-  if(master->version==DYN_VER1)
-    dyn_init_reg_write_packet(master->tx_buffer,id,address,length,data);
-  else
-    dyn2_init_reg_write_packet(master->tx_buffer,id,address,length,data);
-  master->rx_num_packets=0x01;
-  if(master->return_level==return_all && id!=DYN_BROADCAST_ID)
-    master->rx_no_answer=0x00;
-  else
-    master->rx_no_answer=0x01;
-  // enable transmission
-  master->set_tx_mode();
-  // send the data
-  if((error=dyn_master_send(master))!=DYN_SUCCESS)
-  {
-    master->set_rx_mode();
-    return error;
-  }
-  // wait for the transmission to end
-  if((error=dyn_master_wait_transmission(master))!=DYN_SUCCESS)
+  if(master!=0x00000000)
   {
-    master->set_rx_mode();
-    return error;
+    // generate the registered write packet for the desired device
+    if(master->version==DYN_VER1)
+      dyn_init_reg_write_packet(master->tx_buffer,id,address,length,data);
+    else
+      dyn2_init_reg_write_packet(master->tx_buffer,id,address,length,data);
+    master->rx_num_packets=0x01;
+    if(master->return_level==return_all && id!=DYN_BROADCAST_ID)
+      master->rx_no_answer=0x00;
+    else
+      master->rx_no_answer=0x01;
+    // enable transmission
+    master->set_tx_mode();
+    // send the data
+    if((error=dyn_master_send(master))!=DYN_SUCCESS)
+    {
+      master->set_rx_mode();
+      return error;
+    }
+    // wait for the transmission to end
+    if((error=dyn_master_wait_transmission(master))!=DYN_SUCCESS)
+    {
+      master->set_rx_mode();
+      return error;
+    }
+    // wait for the replay within the given timeout
+    if(master->return_level==return_all && id!=DYN_BROADCAST_ID)
+      error=dyn_master_wait_reception(master);
   }
-  // wait for the replay within the given timeout
-  if(master->return_level==return_all && id!=DYN_BROADCAST_ID)
-    error=dyn_master_wait_reception(master);
 
   return error;
 }
 
 unsigned char dyn_master_action(TDynamixelMaster *master)
 {
-  unsigned char error;
+  unsigned char error=DYN_COMM_ERROR;
 
-  // generate the action packet for the desired device
-  if(master->version==DYN_VER1)
-    dyn_init_action_packet(master->tx_buffer);
-  else
-    dyn2_init_action_packet(master->tx_buffer);
-  master->rx_num_packets=0x01;
-  master->rx_no_answer=0x01;
-  // enable transmission
-  master->set_tx_mode();
-  // send the data
-  if((error=dyn_master_send(master))!=DYN_SUCCESS)
-  {
-    master->set_rx_mode();
-    return error;
-  }
-  // wait for the transmission to end
-  if((error=dyn_master_wait_transmission(master))!=DYN_SUCCESS)
+  if(master!=0x00000000)
   {
-    master->set_rx_mode();
-    return error;
+    // generate the action packet for the desired device
+    if(master->version==DYN_VER1)
+      dyn_init_action_packet(master->tx_buffer);
+    else
+      dyn2_init_action_packet(master->tx_buffer);
+    master->rx_num_packets=0x01;
+    master->rx_no_answer=0x01;
+    // enable transmission
+    master->set_tx_mode();
+    // send the data
+    if((error=dyn_master_send(master))!=DYN_SUCCESS)
+    {
+      master->set_rx_mode();
+      return error;
+    }
+    // wait for the transmission to end
+    if((error=dyn_master_wait_transmission(master))!=DYN_SUCCESS)
+    {
+      master->set_rx_mode();
+      return error;
+    }
   }
 
   return error;
 }
 
-unsigned char dyn_master_sync_write(TDynamixelMaster *master,unsigned char num,unsigned char *ids,unsigned short int address, unsigned short int length, TWriteData *data)
+unsigned char dyn_master_sync_write(TDynamixelMaster *master,unsigned char num,unsigned char *ids,unsigned short int address, unsigned short int length, unsigned char * const data[])
 {
-  unsigned char error;
+  unsigned char error=DYN_COMM_ERROR;
 
-  // generate the write packet for the desired device
-  if(master->version==DYN_VER1)
-    dyn_init_sync_write_packet(master->tx_buffer,num,ids,address,length,data);
-  else
-    dyn2_init_sync_write_packet(master->tx_buffer,num,ids,address,length,data);
-  master->rx_num_packets=0x01;
-  master->rx_no_answer=0x01;
-  // enable transmission
-  master->set_tx_mode();
-  // send the data
-  if((error=dyn_master_send(master))!=DYN_SUCCESS)
+  if(master!=0x00000000)
   {
-    master->set_rx_mode();
-    return error;
+    // generate the write packet for the desired device
+    if(master->version==DYN_VER1)
+      dyn_init_sync_write_packet(master->tx_buffer,num,ids,address,length,data);
+    else
+      dyn2_init_sync_write_packet(master->tx_buffer,num,ids,address,length,data);
+    master->rx_num_packets=0x01;
+    master->rx_no_answer=0x01;
+    // enable transmission
+    master->set_tx_mode();
+    // send the data
+    if((error=dyn_master_send(master))!=DYN_SUCCESS)
+    {
+      master->set_rx_mode();
+      return error;
+    }
+    // wait for the transmission to end
+    if((error=dyn_master_wait_transmission(master))!=DYN_SUCCESS)
+    {
+      master->set_rx_mode();
+      return error;
+    }
   }
-  // wait for the transmission to end
-  if((error=dyn_master_wait_transmission(master))!=DYN_SUCCESS)
+
+  return error;
+}
+
+unsigned char dyn_master_sync_read(TDynamixelMaster *master,unsigned char num,unsigned char *ids,unsigned short int address, unsigned short int length, unsigned char * const data[])
+{
+  unsigned char error=DYN_SUCCESS,i;
+
+  if(master!=0x00000000)
   {
-    master->set_rx_mode();
-    return error;
+    // generate the read packet for the desired device
+    if(master->version==DYN_VER2)
+    {
+      dyn2_init_sync_read_packet(master->tx_buffer,num,ids,address,length);
+      master->rx_num_packets=num;
+      if(master->return_level==no_return)
+        master->rx_no_answer=0x01;
+      else
+        master->rx_no_answer=0x00;
+      // enable transmission
+      master->set_tx_mode();
+      // send the data
+      if((error=dyn_master_send(master))!=DYN_SUCCESS)
+      {
+        master->set_rx_mode();
+        return error;
+      }
+      // wait for the transmission to end
+      if((error=dyn_master_wait_transmission(master))!=DYN_SUCCESS)
+      {
+        master->set_rx_mode();
+        return error;
+      }
+      // wait for the replay within the given timeout
+      if(master->return_level!=no_return)
+      {
+        for(i=0;i<num;i++)
+        {
+          if((error=dyn_master_wait_reception(master))==DYN_SUCCESS)
+          {
+            while(dyn2_get_read_status_id(master->rx_buffer)!=ids[i]) i++;
+            if(dyn2_get_read_status_data(master->rx_buffer,(unsigned char *)data[i])!=length)// not enough data
+              error=DYN_INST_ERROR;
+          }
+        }
+      }
+    }
   }
 
   return error;
 }
 
-unsigned char dyn_master_sync_read(TDynamixelMaster *master,unsigned char num,unsigned char *ids,unsigned short int address, unsigned short int length, TWriteData *data)
+unsigned char dyn_master_bulk_read(TDynamixelMaster *master,unsigned char num,unsigned char *ids,unsigned short int *address, unsigned short int *length, unsigned char * const data[])
 {
-  unsigned char error=DYN_SUCCESS,i;
+  unsigned char error=DYN_COMM_ERROR,i,ver1_address[255],ver1_length[255];
 
-  // generate the read packet for the desired device
-  if(master->version==DYN_VER2)
+  if(master!=0x00000000)
   {
-    dyn2_init_sync_read_packet(master->tx_buffer,num,ids,address,length);
+    // generate the read packet for the desired device
+    if(master->version==DYN_VER1)
+    {
+      for(i=0;i<num;i++)
+      {
+        ver1_address[i]=address[i];
+        ver1_length[i]=length[i];
+      }
+      dyn_init_bulk_read_packet(master->tx_buffer,num,ids,ver1_address,ver1_length);
+    }
+    else
+      dyn2_init_bulk_read_packet(master->tx_buffer,num,ids,address,length);
     master->rx_num_packets=num;
     if(master->return_level==no_return)
       master->rx_no_answer=0x01;
@@ -965,9 +1130,18 @@ unsigned char dyn_master_sync_read(TDynamixelMaster *master,unsigned char num,un
       {
         if((error=dyn_master_wait_reception(master))==DYN_SUCCESS)
         {
-          while(dyn2_get_read_status_id(master->rx_buffer)!=ids[i]) i++;
-          if(dyn2_get_read_status_data(master->rx_buffer,data[i].data_addr)!=length)// not enough data
-            error=DYN_INST_ERROR;
+          if(master->version==DYN_VER1)
+          {
+            while(dyn_get_read_status_id(master->rx_buffer)!=ids[i]) i++;
+            if(dyn_get_read_status_data(master->rx_buffer,(unsigned char *)data[i])!=length[i])// not enough data
+              error=DYN_INST_ERROR;
+          }
+          else
+          {
+            while(dyn2_get_read_status_id(master->rx_buffer)!=ids[i]) i++;
+            if(dyn2_get_read_status_data(master->rx_buffer,(unsigned char *)data[i])!=length[i])// not enough data
+              error=DYN_INST_ERROR;
+          }
         }
       }
     }
@@ -976,60 +1150,31 @@ unsigned char dyn_master_sync_read(TDynamixelMaster *master,unsigned char num,un
   return error;
 }
 
-unsigned char dyn_master_bulk_read(TDynamixelMaster *master,unsigned char num,unsigned char *ids,unsigned short int *address, unsigned short int *length, TWriteData *data)
+unsigned char dyn_master_bulk_write(TDynamixelMaster *master,unsigned char num,unsigned char *ids,unsigned short int *address, unsigned short int *length, unsigned char * const data[])
 {
-  unsigned char error,i,ver1_address[255],ver1_length[255];
+  unsigned char error=DYN_SUCCESS;
 
-  // generate the read packet for the desired device
-  if(master->version==DYN_VER1)
+  if(master!=0x00000000)
   {
-    for(i=0;i<num;i++)
+    // generate the write packet for the desired device
+    if(master->version==DYN_VER2)
     {
-      ver1_address[i]=address[i];
-      ver1_length[i]=length[i];
-    }
-    dyn_init_bulk_read_packet(master->tx_buffer,num,ids,ver1_address,ver1_length);
-  }
-  else
-    dyn2_init_bulk_read_packet(master->tx_buffer,num,ids,address,length);
-  master->rx_num_packets=num;
-  if(master->return_level==no_return)
-    master->rx_no_answer=0x01;
-  else
-    master->rx_no_answer=0x00;
-  // enable transmission
-  master->set_tx_mode();
-  // send the data
-  if((error=dyn_master_send(master))!=DYN_SUCCESS)
-  {
-    master->set_rx_mode();
-    return error;
-  }
-  // wait for the transmission to end
-  if((error=dyn_master_wait_transmission(master))!=DYN_SUCCESS)
-  {
-    master->set_rx_mode();
-    return error;
-  }
-  // wait for the replay within the given timeout
-  if(master->return_level!=no_return)
-  {
-    for(i=0;i<num;i++)
-    {
-      if((error=dyn_master_wait_reception(master))==DYN_SUCCESS)
+      dyn2_init_bulk_write_packet(master->tx_buffer,num,ids,address,length,data);
+      master->rx_num_packets=0x01;
+      master->rx_no_answer=0x01;
+      // enable transmission
+      master->set_tx_mode();
+      // send the data
+      if((error=dyn_master_send(master))!=DYN_SUCCESS)
       {
-        if(master->version==DYN_VER1)
-        {
-          while(dyn_get_read_status_id(master->rx_buffer)!=ids[i]) i++;
-          if(dyn_get_read_status_data(master->rx_buffer,data[i].data_addr)!=length[i])// not enough data
-            error=DYN_INST_ERROR;
-        }
-        else
-        {
-          while(dyn2_get_read_status_id(master->rx_buffer)!=ids[i]) i++;
-          if(dyn2_get_read_status_data(master->rx_buffer,data[i].data_addr)!=length[i])// not enough data
-            error=DYN_INST_ERROR;
-        }
+        master->set_rx_mode();
+        return error;
+      }
+      // wait for the transmission to end
+      if((error=dyn_master_wait_transmission(master))!=DYN_SUCCESS)
+      {
+        master->set_rx_mode();
+        return error;
       }
     }
   }
@@ -1037,16 +1182,15 @@ unsigned char dyn_master_bulk_read(TDynamixelMaster *master,unsigned char num,un
   return error;
 }
 
-unsigned char dyn_master_bulk_write(TDynamixelMaster *master,unsigned char num,unsigned char *ids,unsigned short int *address, unsigned short int *length, TWriteData *data)
+unsigned char dyn_master_relay(TDynamixelMaster *master,unsigned char *inst_pkt,unsigned char *status_pkt)
 {
-  unsigned char error=DYN_SUCCESS;
+  unsigned char error=DYN_COMM_ERROR;
 
-  // generate the write packet for the desired device
-  if(master->version==DYN_VER2)
+  if(master!=0x00000000)
   {
-    dyn2_init_bulk_write_packet(master->tx_buffer,num,ids,address,length,data);
+    dyn2_copy_packet(inst_pkt,master->tx_buffer);
     master->rx_num_packets=0x01;
-    master->rx_no_answer=0x01;
+    master->rx_no_answer=0x00;
     // enable transmission
     master->set_tx_mode();
     // send the data
@@ -1061,35 +1205,10 @@ unsigned char dyn_master_bulk_write(TDynamixelMaster *master,unsigned char num,u
       master->set_rx_mode();
       return error;
     }
+    // wait for the replay within the given timeout
+    error=dyn_master_wait_reception(master);
+    dyn2_copy_packet(master->rx_buffer,status_pkt);
   }
 
   return error;
 }
-
-unsigned char dyn_master_relay(TDynamixelMaster *master,unsigned char *inst_pkt,unsigned char *status_pkt)
-{
-  unsigned char error;
-
-  dyn2_copy_packet(inst_pkt,master->tx_buffer);
-  master->rx_num_packets=0x01;
-  master->rx_no_answer=0x00;
-  // enable transmission
-  master->set_tx_mode();
-  // send the data
-  if((error=dyn_master_send(master))!=DYN_SUCCESS)
-  {
-    master->set_rx_mode();
-    return error;
-  }
-  // wait for the transmission to end
-  if((error=dyn_master_wait_transmission(master))!=DYN_SUCCESS)
-  {
-    master->set_rx_mode();
-    return error;
-  }
-  // wait for the replay within the given timeout
-  error=dyn_master_wait_reception(master);
-  dyn2_copy_packet(master->rx_buffer,status_pkt);
-
-  return error;
-}
diff --git a/dynamixel_base/src/dynamixel_slave.c b/dynamixel_base/src/dynamixel_slave.c
index 269316c0ea34837531c5fa7521797df94fc47f32..9f92c1cccbd2ef85cf46b0c09cbcdaf8782d1f04 100644
--- a/dynamixel_base/src/dynamixel_slave.c
+++ b/dynamixel_base/src/dynamixel_slave.c
@@ -1,97 +1,100 @@
 #include "dynamixel_slave.h"
 
 /* private functions */
-unsigned char dyn_slave_irq_receive_cb(void *dyn_slave,unsigned char byte)
+unsigned char dyn_slave_irq_receive_cb(TDynamixelSlave *dyn_slave,unsigned char byte)
 {
-  TDynamixelSlave *dyn=(TDynamixelSlave *)dyn_slave;
-
-  if(dyn->comm_dev->time!=0x00000000)
-    time_set_timeout(dyn->comm_dev->time,dyn->rx_timeout_ms*1000);
-  switch(dyn->received_bytes)
+  if(dyn_slave!=0x00000000)
   {
-    case 0: if(byte==0xFF)
-            {
-              dyn->rx_buffer[dyn->received_bytes]=byte;
-	      dyn->received_bytes++;
-            }
-	    break;
-    case 1: if(byte==0xFF)
-            {
-              dyn->rx_buffer[dyn->received_bytes]=byte;
-	      dyn->received_bytes++;
-            }
-	    else 
-              dyn->received_bytes--;
-	    break;
-    case 2: if(byte==0xFD)// version 2 header
-            {
-              if(dyn->version==DYN_VER2)// the module is configured for version 2
+    if(dyn_slave->comm_dev->time!=0x00000000)
+      time_set_timeout(dyn_slave->comm_dev->time,dyn_slave->rx_timeout_ms*1000);
+    switch(dyn_slave->received_bytes)
+    {
+      case 0: if(byte==0xFF)
+              {
+                dyn_slave->rx_buffer[dyn_slave->received_bytes]=byte;
+	        dyn_slave->received_bytes++;
+              }
+              break;
+      case 1: if(byte==0xFF)
+              {
+                dyn_slave->rx_buffer[dyn_slave->received_bytes]=byte;
+	        dyn_slave->received_bytes++;
+              }
+              else 
+                dyn_slave->received_bytes--;
+	      break;
+      case 2: if(byte==0xFD)// version 2 header
+              {
+                if(dyn_slave->version==DYN_VER2)// the module is configured for version 2
+                {
+                  dyn_slave->rx_buffer[dyn_slave->received_bytes]=byte;
+                  dyn_slave->received_bytes++;
+                }
+                else
+                  dyn_slave->received_bytes=0;// ignore packet and restart synchronization
+              } 
+              else if(byte!=0xFF)
               {
-                dyn->rx_buffer[dyn->received_bytes]=byte;
-                dyn->received_bytes++;
+                dyn_slave->rx_buffer[dyn_slave->received_bytes]=byte;
+	        dyn_slave->received_bytes++;
+              }
+	      break;
+      case 3: dyn_slave->rx_buffer[dyn_slave->received_bytes]=byte;
+              if(dyn_slave->version==DYN_VER1)
+              {
+                dyn_slave->op_length=byte;
+                dyn_slave->received_bytes=0;
+                /* finish reception by IRQ */
+                comm_cancel_irq_receive(dyn_slave->comm_dev);
+                /* enable dma RX */
+                comm_receive_dma(dyn_slave->comm_dev,&dyn_slave->rx_buffer[4],dyn_slave->op_length);
               }
               else
-                dyn->received_bytes=0;// ignore packet and restart synchronization
-            }
-            else if(byte!=0xFF)
-            {
-              dyn->rx_buffer[dyn->received_bytes]=byte;
-	      dyn->received_bytes++;
-            }
-	    break;
-    case 3: dyn->rx_buffer[dyn->received_bytes]=byte;
-            if(dyn->version==DYN_VER1)
-            {
-              dyn->op_length=byte;
-              dyn->received_bytes=0;
+                dyn_slave->received_bytes++;
+	      break;
+      case 4: dyn_slave->rx_buffer[dyn_slave->received_bytes]=byte;
+              dyn_slave->received_bytes++;
+              break;
+      case 5: dyn_slave->rx_buffer[dyn_slave->received_bytes]=byte;
+              dyn_slave->received_bytes++;
+              dyn_slave->op_length=byte;
+              break;
+      case 6: dyn_slave->rx_buffer[dyn_slave->received_bytes]=byte;
+              dyn_slave->received_bytes++;
+              dyn_slave->op_length+=(byte<<8);
+              dyn_slave->received_bytes=0;
               /* finish reception by IRQ */
-              comm_cancel_irq_receive(dyn->comm_dev);
+              comm_cancel_irq_receive(dyn_slave->comm_dev);
               /* enable dma RX */
-              comm_receive_dma(dyn->comm_dev,&dyn->rx_buffer[4],dyn->op_length);
-            }
-            else
-              dyn->received_bytes++;
-	    break;
-    case 4: dyn->rx_buffer[dyn->received_bytes]=byte;
-            dyn->received_bytes++;
-            break;
-    case 5: dyn->rx_buffer[dyn->received_bytes]=byte;
-            dyn->received_bytes++;
-            dyn->op_length=byte;
-            break;
-    case 6: dyn->rx_buffer[dyn->received_bytes]=byte;
-            dyn->received_bytes++;
-            dyn->op_length+=(byte<<8);
-            dyn->received_bytes=0;
-            /* finish reception by IRQ */
-            comm_cancel_irq_receive(dyn->comm_dev);
-            /* enable dma RX */
-            comm_receive_dma(dyn->comm_dev,&dyn->rx_buffer[7],dyn->op_length);
-            break;
-    default: break;
+              comm_receive_dma(dyn_slave->comm_dev,&dyn_slave->rx_buffer[7],dyn_slave->op_length);
+              break;
+      default: break;
+    }
   }
 
   return 0x00;
 }
 
-unsigned char dyn_slave_dma_send_cb(void *dyn_slave)
+unsigned char dyn_slave_dma_send_cb(TDynamixelSlave *dyn_slave)
 {
-  TDynamixelSlave *dyn=(TDynamixelSlave *)dyn_slave;
-
-  // enable tx interrupts
-  dyn->set_rx_mode();  
+  if(dyn_slave!=0x00000000)
+  {
+    // enable tx interrupts
+    dyn_slave->set_rx_mode();  
+  }
 
   return 0x00;
 }
 
-unsigned char dyn_slave_dma_receive_cb(void *dyn_slave)
+unsigned char dyn_slave_dma_receive_cb(TDynamixelSlave *dyn_slave)
 {
-  TDynamixelSlave *dyn=(TDynamixelSlave *)dyn_slave;
-
-  comm_receive_irq(dyn->comm_dev,0);// reenable reception by IRQ
-  if(dyn->comm_dev->time!=0x00000000)
-    time_cancel_timeout(dyn->comm_dev->time);
-  dyn->packet_ready=0x01;
+  if(dyn_slave!=0x00000000)
+  {
+    comm_receive_irq(dyn_slave->comm_dev,0);// reenable reception by IRQ
+    if(dyn_slave->comm_dev->time!=0x00000000)
+      time_cancel_timeout(dyn_slave->comm_dev->time);
+    dyn_slave->packet_ready=0x01;
+  }
 
   return 0x00;
 }
@@ -134,28 +137,31 @@ unsigned char dummy_dyn_slave_on_relay(TDynVersion version,unsigned char *inst_p
 
 void dyn_slave_send_status_packet(TDynamixelSlave *slave,unsigned char error,unsigned short int length, unsigned char *data)
 {
-  // wait until the previous transmission has ended (if any)
-  while(comm_is_send_done(slave->comm_dev)==COMM_BUSY);
-  if(slave->return_delay>0)
-    if(slave->comm_dev->time!=0x00000000)
-      time_delay_us(slave->comm_dev->time,slave->return_delay<<1);
-  if(slave->version==DYN_VER1)
-  {
-    // create the status packet
-    dyn_init_status_packet(slave->tx_buffer,slave->address,error,length,data);
-    // set the tx mode, if necessary
-    slave->set_tx_mode();
-    // start transmission by DMA
-    comm_send_dma(slave->comm_dev,slave->tx_buffer,dyn_get_length(slave->tx_buffer)+4);
-  }
-  else
+  if(slave!=0x00000000)
   {
-    // create the status packet
-    dyn2_init_status_packet(slave->tx_buffer,slave->address,error,length,data);
-    // set the tx mode, if necessary
-    slave->set_tx_mode();
-    // start transmission by DMA
-    comm_send_dma(slave->comm_dev,slave->tx_buffer,dyn2_get_length(slave->tx_buffer)+7);
+    // wait until the previous transmission has ended (if any)
+    while(comm_is_send_done(slave->comm_dev)==COMM_BUSY);
+    if(slave->return_delay>0)
+      if(slave->comm_dev->time!=0x00000000)
+        time_delay_us(slave->comm_dev->time,slave->return_delay<<1);
+    if(slave->version==DYN_VER1)
+    {
+      // create the status packet
+      dyn_init_status_packet(slave->tx_buffer,slave->address,error,length,data);
+      // set the tx mode, if necessary
+      slave->set_tx_mode();
+      // start transmission by DMA
+      comm_send_dma(slave->comm_dev,slave->tx_buffer,dyn_get_length(slave->tx_buffer)+4);
+    }
+    else
+    {
+      // create the status packet
+      dyn2_init_status_packet(slave->tx_buffer,slave->address,error,length,data);
+      // set the tx mode, if necessary
+      slave->set_tx_mode();
+      // start transmission by DMA
+      comm_send_dma(slave->comm_dev,slave->tx_buffer,dyn2_get_length(slave->tx_buffer)+7);
+    }
   }
 }
 
@@ -163,114 +169,117 @@ void dyn_v1_slave_loop(TDynamixelSlave *slave)
 {
   static unsigned char data[MAX_DYN_SLAVE_TX_BUFFER_LEN],error,length,address,prev_id,id;
 
-  id=dyn_get_id(slave->rx_buffer);
-  if(id==slave->address || id==DYN_BROADCAST_ID)// the packet is addressed to this device or it is a broadcast
+  if(slave!=0x000000000)
   {
-    // check the packet checksum
-    if(dyn_check_checksum(slave->rx_buffer)==0xFF)// the incomming packet is okay
+    id=dyn_get_id(slave->rx_buffer);
+    if(id==slave->address || id==DYN_BROADCAST_ID)// the packet is addressed to this device or it is a broadcast
     {
-      // process the packet
-      switch(dyn_get_instruction(slave->rx_buffer))
+      // check the packet checksum
+      if(dyn_check_checksum(slave->rx_buffer)==0xFF)// the incomming packet is okay
       {
-        case DYN_PING: slave->on_ping();
-                       if(id!=DYN_BROADCAST_ID)
-                         dyn_slave_send_status_packet(slave,DYN_NO_ERROR,0,data);
-                       break;
-        case DYN_READ: error=slave->on_read(dyn_get_read_address(slave->rx_buffer),dyn_get_read_length(slave->rx_buffer),data);
-                       if(slave->return_level!=no_return && id!=DYN_BROADCAST_ID)
-                       {
-                         if(error==DYN_NO_ERROR)
-                           dyn_slave_send_status_packet(slave,DYN_NO_ERROR,dyn_get_read_length(slave->rx_buffer),data);
-                         else
-                           dyn_slave_send_status_packet(slave,DYN_INST_ERROR,0,data);
-                       }
-                       break;
-        case DYN_WRITE: length=dyn_get_write_data(slave->rx_buffer,data);
-                        error=slave->on_write(dyn_get_write_address(slave->rx_buffer),length,data);
-                        if(slave->return_level==return_all && id!=DYN_BROADCAST_ID)
-                        {
-                          if(error==DYN_NO_ERROR)
-                            dyn_slave_send_status_packet(slave,DYN_NO_ERROR,0,data);
-                          else
-                            dyn_slave_send_status_packet(slave,DYN_INST_ERROR,0,data);
-                        }
-                        break;
-        case DYN_REG_WRITE: slave->reg_length=dyn_get_reg_write_data(slave->rx_buffer,slave->reg_buffer);
-                            slave->reg_address=dyn_get_reg_write_address(slave->rx_buffer);
-                            if(slave->return_level==return_all && id!=DYN_BROADCAST_ID)
-                              dyn_slave_send_status_packet(slave,DYN_NO_ERROR,0,data);
-                            break;
-        case DYN_ACTION: if(slave->reg_address!=0xFFFF)
+        // process the packet
+        switch(dyn_get_instruction(slave->rx_buffer))
+        {
+          case DYN_PING: slave->on_ping();
+                         if(id!=DYN_BROADCAST_ID)
+                           dyn_slave_send_status_packet(slave,DYN_NO_ERROR,0,data);
+                         break;
+          case DYN_READ: error=slave->on_read(dyn_get_read_address(slave->rx_buffer),dyn_get_read_length(slave->rx_buffer),data);
+                         if(slave->return_level!=no_return && id!=DYN_BROADCAST_ID)
                          {
-                           error=slave->on_write(slave->reg_address,slave->reg_length,slave->reg_buffer);
-                           slave->reg_address=0xFFFF;
-                         }
-                         else
-                           if(slave->return_level==return_all && id!=DYN_BROADCAST_ID)
+                           if(error==DYN_NO_ERROR)
+                             dyn_slave_send_status_packet(slave,DYN_NO_ERROR,dyn_get_read_length(slave->rx_buffer),data);
+                           else
                              dyn_slave_send_status_packet(slave,DYN_INST_ERROR,0,data);
+                         }
                          break;
-        case DYN_RESET:
-                        break;
-        case DYN_SYNC_READ: dyn_slave_send_status_packet(slave,DYN_INST_ERROR,0,data);
-                            break;
-        case DYN_SYNC_WRITE: if(dyn_sync_write_id_present(slave->rx_buffer,slave->address,&address,&length,data))// the device is addressed
-                               error=slave->on_write(address,length,data);
-                             break;
-        case DYN_BULK_READ: prev_id=dyn_bulk_read_id_present(slave->rx_buffer,slave->address,&address,&length);
-                            if(prev_id!=0xFF)
-                            {
-                              if(prev_id==0x00)// first device to answer
-                              {
-                                error=slave->on_read(address,length,data);
-                                if(error==DYN_NO_ERROR)
-                                  dyn_slave_send_status_packet(slave,DYN_NO_ERROR,length,data);
-                                else
-                                  dyn_slave_send_status_packet(slave,DYN_INST_ERROR,0,data);
-                              }
-                              else// wait for the previous device in the sequence to send its data
+          case DYN_WRITE: length=dyn_get_write_data(slave->rx_buffer,data);
+                          error=slave->on_write(dyn_get_write_address(slave->rx_buffer),length,data);
+                          if(slave->return_level==return_all && id!=DYN_BROADCAST_ID)
+                          {
+                            if(error==DYN_NO_ERROR)
+                              dyn_slave_send_status_packet(slave,DYN_NO_ERROR,0,data);
+                            else
+                              dyn_slave_send_status_packet(slave,DYN_INST_ERROR,0,data);
+                          }
+                          break;
+          case DYN_REG_WRITE: slave->reg_length=dyn_get_reg_write_data(slave->rx_buffer,slave->reg_buffer);
+                              slave->reg_address=dyn_get_reg_write_address(slave->rx_buffer);
+                              if(slave->return_level==return_all && id!=DYN_BROADCAST_ID)
+                                dyn_slave_send_status_packet(slave,DYN_NO_ERROR,0,data);
+                              break;
+          case DYN_ACTION: if(slave->reg_address!=0xFFFF)
+                           {
+                             error=slave->on_write(slave->reg_address,slave->reg_length,slave->reg_buffer);
+                             slave->reg_address=0xFFFF;
+                           }
+                           else
+                             if(slave->return_level==return_all && id!=DYN_BROADCAST_ID)
+                               dyn_slave_send_status_packet(slave,DYN_INST_ERROR,0,data);
+                           break;
+          case DYN_RESET:
+                          break;
+          case DYN_SYNC_READ: dyn_slave_send_status_packet(slave,DYN_INST_ERROR,0,data);
+                              break;
+          case DYN_SYNC_WRITE: if(dyn_sync_write_id_present(slave->rx_buffer,slave->address,&address,&length,data))// the device is addressed
+                                 error=slave->on_write(address,length,data);
+                               break;
+          case DYN_BULK_READ: prev_id=dyn_bulk_read_id_present(slave->rx_buffer,slave->address,&address,&length);
+                              if(prev_id!=0xFF)
                               {
-                                slave->sync_bulk_address=address;
-                                slave->sync_bulk_length=length;
-                                slave->sync_bulk_prev_id=prev_id;
-                                slave->bulk_read_pending=0x01;       
+                                if(prev_id==0x00)// first device to answer
+                                {
+                                  error=slave->on_read(address,length,data);
+                                  if(error==DYN_NO_ERROR)
+                                    dyn_slave_send_status_packet(slave,DYN_NO_ERROR,length,data);
+                                  else
+                                    dyn_slave_send_status_packet(slave,DYN_INST_ERROR,0,data);
+                                }
+                                else// wait for the previous device in the sequence to send its data
+                                {
+                                  slave->sync_bulk_address=address;
+                                  slave->sync_bulk_length=length;
+                                  slave->sync_bulk_prev_id=prev_id;
+                                  slave->bulk_read_pending=0x01;       
+                                }
                               }
-                            }
-                            break;
-        case DYN_BULK_WRITE: dyn_slave_send_status_packet(slave,DYN_INST_ERROR,0,data);
-                             break;
-        default:
-                 break;
+                              break;
+          case DYN_BULK_WRITE: dyn_slave_send_status_packet(slave,DYN_INST_ERROR,0,data);
+                               break;
+          default:
+                   break;
+        }
+      }
+      else
+      {
+        // send a checksum error answer
+        if(dyn_get_id(slave->rx_buffer)!=DYN_BROADCAST_ID)
+          dyn_slave_send_status_packet(slave,DYN_CHECKSUM_ERROR,0,0x00);
       }
     }
     else
     {
-      // send a checksum error answer
-      if(dyn_get_id(slave->rx_buffer)!=DYN_BROADCAST_ID)
-        dyn_slave_send_status_packet(slave,DYN_CHECKSUM_ERROR,0,0x00);
-    }
-  }
-  else
-  {
-    if(slave->bulk_read_pending)
-    {
-      if(id==slave->sync_bulk_prev_id)
+      if(slave->bulk_read_pending)
       {
-        slave->bulk_read_pending=0x00;
-        error=slave->on_read(slave->sync_bulk_address,slave->sync_bulk_length,data);
-        if(error==DYN_NO_ERROR)
-          dyn_slave_send_status_packet(slave,DYN_NO_ERROR,slave->sync_bulk_length,data);
-        else
-          dyn_slave_send_status_packet(slave,DYN_INST_ERROR,0,data);
+        if(id==slave->sync_bulk_prev_id)
+        {
+          slave->bulk_read_pending=0x00;
+          error=slave->on_read(slave->sync_bulk_address,slave->sync_bulk_length,data);
+          if(error==DYN_NO_ERROR)
+            dyn_slave_send_status_packet(slave,DYN_NO_ERROR,slave->sync_bulk_length,data);
+          else
+            dyn_slave_send_status_packet(slave,DYN_INST_ERROR,0,data);
+        }
       }
-    }
-    else// the packet is addressed to another device, so relay it
-    {
-      if(slave->on_relay(slave->version,slave->rx_buffer,slave->tx_buffer)==DYN_SUCCESS)
+      else// the packet is addressed to another device, so relay it
       {
-        // set the tx mode, if necessary
-        slave->set_tx_mode();
-        // start transmission by DMA
-        comm_send_dma(slave->comm_dev,slave->tx_buffer,dyn_get_length(slave->tx_buffer)+4);
+        if(slave->on_relay(slave->version,slave->rx_buffer,slave->tx_buffer)==DYN_SUCCESS)
+        {
+          // set the tx mode, if necessary
+          slave->set_tx_mode();
+          // start transmission by DMA
+          comm_send_dma(slave->comm_dev,slave->tx_buffer,dyn_get_length(slave->tx_buffer)+4);
+        }
       }
     }
   }
@@ -281,145 +290,148 @@ void dyn_v2_slave_loop(TDynamixelSlave *slave)
   static unsigned char data[MAX_DYN_SLAVE_TX_BUFFER_LEN],error,prev_id,id;
   static unsigned short int length,address;
 
-  id=dyn2_get_id(slave->rx_buffer);
-  if(id==slave->address || id==DYN_BROADCAST_ID)// the packet is addressed to this device or it is a broadcast
+  if(slave!=0x00000000)
   {
-    // check the packet checksum
-    if(dyn2_check_checksum(slave->rx_buffer)==0x01)// the incomming packet is okay
+    id=dyn2_get_id(slave->rx_buffer);
+    if(id==slave->address || id==DYN_BROADCAST_ID)// the packet is addressed to this device or it is a broadcast
     {
-      // process the packet
-      switch(dyn2_get_instruction(slave->rx_buffer))
+      // check the packet checksum
+      if(dyn2_check_checksum(slave->rx_buffer)==0x01)// the incomming packet is okay
       {
-        case DYN_PING: slave->on_ping();
-                       if(id!=DYN_BROADCAST_ID)
-                         dyn_slave_send_status_packet(slave,DYN_NO_ERROR,0,data);
-                       break;
-        case DYN_READ: error=slave->on_read(dyn2_get_read_address(slave->rx_buffer),dyn2_get_read_length(slave->rx_buffer),data);
-                       if(slave->return_level!=no_return && id!=DYN_BROADCAST_ID)
-                       {
-                         if(error==DYN_NO_ERROR)
-                           dyn_slave_send_status_packet(slave,DYN_NO_ERROR,dyn2_get_read_length(slave->rx_buffer),data);
-                         else
-                           dyn_slave_send_status_packet(slave,DYN_INST_ERROR,0,data);
-                       }
-                       break;
-        case DYN_WRITE: length=dyn2_get_write_data(slave->rx_buffer,data);
-                        error=slave->on_write(dyn2_get_write_address(slave->rx_buffer),length,data);
-                        if(slave->return_level==return_all && id!=DYN_BROADCAST_ID)
-                        {
-                          if(error==DYN_NO_ERROR)
-                            dyn_slave_send_status_packet(slave,DYN_NO_ERROR,0,data);
-                          else
-                            dyn_slave_send_status_packet(slave,DYN_INST_ERROR,0,data);
-                        }
-                        break;
-        case DYN_REG_WRITE: slave->reg_length=dyn2_get_reg_write_data(slave->rx_buffer,slave->reg_buffer);
-                            slave->reg_address=dyn2_get_reg_write_address(slave->rx_buffer);
-                            if(slave->return_level==return_all && id!=DYN_BROADCAST_ID)
-                              dyn_slave_send_status_packet(slave,DYN_NO_ERROR,0,data);
-                            break;
-        case DYN_ACTION: if(slave->reg_address!=0xFFFF)
+        // process the packet
+        switch(dyn2_get_instruction(slave->rx_buffer))
+        {
+          case DYN_PING: slave->on_ping();
+                         if(id!=DYN_BROADCAST_ID)
+                           dyn_slave_send_status_packet(slave,DYN_NO_ERROR,0,data);
+                         break;
+          case DYN_READ: error=slave->on_read(dyn2_get_read_address(slave->rx_buffer),dyn2_get_read_length(slave->rx_buffer),data);
+                         if(slave->return_level!=no_return && id!=DYN_BROADCAST_ID)
                          {
-                           error=slave->on_write(slave->reg_address,slave->reg_length,slave->reg_buffer);
-                           slave->reg_address=0xFFFF;
-                         }
-                         else
-                           if(slave->return_level==return_all && id!=DYN_BROADCAST_ID)
+                           if(error==DYN_NO_ERROR)
+                             dyn_slave_send_status_packet(slave,DYN_NO_ERROR,dyn2_get_read_length(slave->rx_buffer),data);
+                           else
                              dyn_slave_send_status_packet(slave,DYN_INST_ERROR,0,data);
+                         }
                          break;
-        case DYN_RESET:
-                        break;
-        case DYN_SYNC_READ: prev_id=dyn2_sync_read_id_present(slave->rx_buffer,slave->address,&address,&length);
-                            if(prev_id!=0xFF)
-                            {
-                              if(prev_id==0x00)// first device to answer
-                              {
-                                error=slave->on_read(address,length,data);
-                                if(error==DYN_NO_ERROR)
-                                  dyn_slave_send_status_packet(slave,DYN_NO_ERROR,length,data);
-                                else
-                                  dyn_slave_send_status_packet(slave,DYN_INST_ERROR,0,data);
-                              }
-                              else// wait for the previous device in the sequence to send its data
-                              {
-                                slave->sync_bulk_address=address;
-                                slave->sync_bulk_length=length;
-                                slave->sync_bulk_prev_id=prev_id;
-                                slave->sync_read_pending=0x01;
-                              }
-                            }
-                            break;
-        case DYN_SYNC_WRITE: if(dyn2_sync_write_id_present(slave->rx_buffer,slave->address,&address,&length,data))// the device is addressed
-                               error=slave->on_write(address,length,data);
-                             break;
-        case DYN_BULK_READ: prev_id=dyn2_bulk_read_id_present(slave->rx_buffer,slave->address,&address,&length);
-                            if(prev_id!=0xFF)
-                            {
-                              if(prev_id==0x00)// first device to answer
+          case DYN_WRITE: length=dyn2_get_write_data(slave->rx_buffer,data);
+                          error=slave->on_write(dyn2_get_write_address(slave->rx_buffer),length,data);
+                          if(slave->return_level==return_all && id!=DYN_BROADCAST_ID)
+                          {
+                            if(error==DYN_NO_ERROR)
+                              dyn_slave_send_status_packet(slave,DYN_NO_ERROR,0,data);
+                            else
+                              dyn_slave_send_status_packet(slave,DYN_INST_ERROR,0,data);
+                          }
+                          break;
+          case DYN_REG_WRITE: slave->reg_length=dyn2_get_reg_write_data(slave->rx_buffer,slave->reg_buffer);
+                              slave->reg_address=dyn2_get_reg_write_address(slave->rx_buffer);
+                              if(slave->return_level==return_all && id!=DYN_BROADCAST_ID)
+                                dyn_slave_send_status_packet(slave,DYN_NO_ERROR,0,data);
+                              break;
+          case DYN_ACTION: if(slave->reg_address!=0xFFFF)
+                           {
+                             error=slave->on_write(slave->reg_address,slave->reg_length,slave->reg_buffer);
+                             slave->reg_address=0xFFFF;
+                           }
+                           else
+                             if(slave->return_level==return_all && id!=DYN_BROADCAST_ID)
+                               dyn_slave_send_status_packet(slave,DYN_INST_ERROR,0,data);
+                           break;
+          case DYN_RESET:
+                          break;
+          case DYN_SYNC_READ: prev_id=dyn2_sync_read_id_present(slave->rx_buffer,slave->address,&address,&length);
+                              if(prev_id!=0xFF)
                               {
-                                error=slave->on_read(address,length,data);
-                                if(error==DYN_NO_ERROR)
-                                  dyn_slave_send_status_packet(slave,DYN_NO_ERROR,length,data);
-                                else
-                                  dyn_slave_send_status_packet(slave,DYN_INST_ERROR,0,data);
+                                if(prev_id==0x00)// first device to answer
+                                {
+                                  error=slave->on_read(address,length,data);
+                                  if(error==DYN_NO_ERROR)
+                                    dyn_slave_send_status_packet(slave,DYN_NO_ERROR,length,data);
+                                  else
+                                    dyn_slave_send_status_packet(slave,DYN_INST_ERROR,0,data);
+                                }
+                                else// wait for the previous device in the sequence to send its data
+                                {
+                                  slave->sync_bulk_address=address;
+                                  slave->sync_bulk_length=length;
+                                  slave->sync_bulk_prev_id=prev_id;
+                                  slave->sync_read_pending=0x01;
+                                }
                               }
-                              else// wait for the previous device in the sequence to send its data
+                              break;
+          case DYN_SYNC_WRITE: if(dyn2_sync_write_id_present(slave->rx_buffer,slave->address,&address,&length,data))// the device is addressed
+                                 error=slave->on_write(address,length,data);
+                               break;
+          case DYN_BULK_READ: prev_id=dyn2_bulk_read_id_present(slave->rx_buffer,slave->address,&address,&length);
+                              if(prev_id!=0xFF)
                               {
-                                slave->sync_bulk_address=address;
-                                slave->sync_bulk_length=length;
-                                slave->sync_bulk_prev_id=prev_id;
-                                slave->bulk_read_pending=0x01;       
+                                if(prev_id==0x00)// first device to answer
+                                {
+                                  error=slave->on_read(address,length,data);
+                                  if(error==DYN_NO_ERROR)
+                                    dyn_slave_send_status_packet(slave,DYN_NO_ERROR,length,data);
+                                  else
+                                    dyn_slave_send_status_packet(slave,DYN_INST_ERROR,0,data);
+                                }
+                                else// wait for the previous device in the sequence to send its data
+                                {
+                                  slave->sync_bulk_address=address;
+                                  slave->sync_bulk_length=length;
+                                  slave->sync_bulk_prev_id=prev_id;
+                                  slave->bulk_read_pending=0x01;       
+                                }
                               }
-                            }
-                            break;
-        case DYN_BULK_WRITE: if(dyn2_bulk_write_id_present(slave->rx_buffer,slave->address,&address,&length,data))
-                               error=slave->on_write(address,length,data);
-                             break;
-        default:
-                 break;
+                              break;
+          case DYN_BULK_WRITE: if(dyn2_bulk_write_id_present(slave->rx_buffer,slave->address,&address,&length,data))
+                                 error=slave->on_write(address,length,data);
+                               break;
+          default:
+                   break;
+        }
+      }
+      else
+      {
+        // send a checksum error answer
+        if(dyn_get_id(slave->rx_buffer)!=DYN_BROADCAST_ID)
+          dyn_slave_send_status_packet(slave,DYN_CHECKSUM_ERROR,0,0x00);
       }
     }
     else
     {
-      // send a checksum error answer
-      if(dyn_get_id(slave->rx_buffer)!=DYN_BROADCAST_ID)
-        dyn_slave_send_status_packet(slave,DYN_CHECKSUM_ERROR,0,0x00);
-    }
-  }
-  else
-  {
-    if(slave->bulk_read_pending)
-    {
-      if(id==slave->sync_bulk_prev_id)
+      if(slave->bulk_read_pending)
       {
-        slave->bulk_read_pending=0x00;
-        error=slave->on_read(slave->sync_bulk_address,slave->sync_bulk_length,data);
-        if(error==DYN_NO_ERROR)
-          dyn_slave_send_status_packet(slave,DYN_NO_ERROR,slave->sync_bulk_length,data);
-        else
-          dyn_slave_send_status_packet(slave,DYN_INST_ERROR,0,data);
+        if(id==slave->sync_bulk_prev_id)
+        {
+          slave->bulk_read_pending=0x00;
+          error=slave->on_read(slave->sync_bulk_address,slave->sync_bulk_length,data);
+          if(error==DYN_NO_ERROR)
+            dyn_slave_send_status_packet(slave,DYN_NO_ERROR,slave->sync_bulk_length,data);
+          else
+            dyn_slave_send_status_packet(slave,DYN_INST_ERROR,0,data);
+        }
       }
-    }
-    else if(slave->sync_read_pending)
-    {
-      if(id==slave->sync_bulk_prev_id)
+      else if(slave->sync_read_pending)
       {
-        slave->sync_read_pending=0x00;
-        error=slave->on_read(slave->sync_bulk_address,slave->sync_bulk_length,data);
-        if(error==DYN_NO_ERROR)
-          dyn_slave_send_status_packet(slave,DYN_NO_ERROR,slave->sync_bulk_length,data);
-        else
-          dyn_slave_send_status_packet(slave,DYN_INST_ERROR,0,data);
+        if(id==slave->sync_bulk_prev_id)
+        {
+          slave->sync_read_pending=0x00;
+          error=slave->on_read(slave->sync_bulk_address,slave->sync_bulk_length,data);
+          if(error==DYN_NO_ERROR)
+            dyn_slave_send_status_packet(slave,DYN_NO_ERROR,slave->sync_bulk_length,data);
+          else
+            dyn_slave_send_status_packet(slave,DYN_INST_ERROR,0,data);
+        }
       }
-    }
-    else// the packet is addressed to another device, so relay it
-    {
-      if(slave->on_relay(slave->version,slave->rx_buffer,slave->tx_buffer)==DYN_SUCCESS)
+      else// the packet is addressed to another device, so relay it
       {
-        // set the tx mode, if necessary
-        slave->set_tx_mode();
-        // start transmission by DMA
-        comm_send_dma(slave->comm_dev,slave->tx_buffer,dyn2_get_length(slave->tx_buffer)+8);
+        if(slave->on_relay(slave->version,slave->rx_buffer,slave->tx_buffer)==DYN_SUCCESS)
+        {
+          // set the tx mode, if necessary
+          slave->set_tx_mode();
+          // start transmission by DMA
+          comm_send_dma(slave->comm_dev,slave->tx_buffer,dyn2_get_length(slave->tx_buffer)+8);
+        }
       }
     }
   }
@@ -429,9 +441,9 @@ void dyn_v2_slave_loop(TDynamixelSlave *slave)
 void dyn_slave_init(TDynamixelSlave *slave,TComm *dev,unsigned char address,TDynVersion version)
 {
   /* assign communication functions */
-  dev->irq_receive_cb=dyn_slave_irq_receive_cb;
-  dev->dma_send_cb=dyn_slave_dma_send_cb;
-  dev->dma_receive_cb=dyn_slave_dma_receive_cb;
+  dev->irq_receive_cb=(unsigned char (*)(void *,unsigned char))dyn_slave_irq_receive_cb;
+  dev->dma_send_cb=(unsigned char (*)(void *))dyn_slave_dma_send_cb;
+  dev->dma_receive_cb=(unsigned char (*)(void *))dyn_slave_dma_receive_cb;
   slave->comm_dev=dev;
   slave->version=version;
   dev->data=slave;
@@ -463,69 +475,88 @@ void dyn_slave_init(TDynamixelSlave *slave,TComm *dev,unsigned char address,TDyn
   comm_receive_irq(slave->comm_dev,0);
 }
 
-void dyn_slave_set_rx_timeout(TDynamixelSlave *slave,unsigned short int timeout_ms)
+inline void dyn_slave_set_rx_timeout(TDynamixelSlave *slave,unsigned short int timeout_ms)
 {
-  slave->rx_timeout_ms=timeout_ms;
+  if(slave!=0x00000000)
+    slave->rx_timeout_ms=timeout_ms;
 }
 
 inline void dyn_slave_set_address(TDynamixelSlave *slave,unsigned char address)
 {
-  slave->address=address;
+  if(slave!=0x00000000)
+    slave->address=address;
 }
 
 inline unsigned char dyn_slave_get_address(TDynamixelSlave *slave)
 {
-  return slave->address;
+  if(slave!=0x00000000)
+    return slave->address;
+  else
+    return 0xFF;
 }
 
 inline void dyn_slave_set_return_delay(TDynamixelSlave *slave,unsigned char delay)
 {
-  slave->return_delay=delay;
+  if(slave!=0x00000000)
+    slave->return_delay=delay;
 }
 
 inline unsigned char dyn_slave_get_return_delay(TDynamixelSlave *slave)
 {
-  return slave->return_delay;
+  if(slave!=0x00000000)
+    return slave->return_delay;
+  else
+    return 0xFF;
 }
 
 inline void dyn_slave_set_return_level(TDynamixelSlave *slave,return_level_t level)
 {
-  slave->return_level=level;
+  if(slave!=0x00000000)
+    slave->return_level=level;
 }
 
 inline return_level_t dyn_slave_get_return_level(TDynamixelSlave *slave)
 {
-  return slave->return_level;
+  if(slave!=0x00000000)
+    return slave->return_level;
+  else
+    return return_all;
 }
 
 inline TDynVersion dyn_slave_get_version(TDynamixelSlave *slave)
 {
-  return slave->version;
+  if(slave!=0x00000000)
+    return slave->version;
+  else
+    return DYN_VER1;
 }
 
 void dyn_slave_loop(TDynamixelSlave *slave)
 {
-  if(slave->packet_ready)// check if a new instruction packet has been received
+  if(slave!=0x00000000)
   {
-    slave->packet_ready=0x00;
-    // check address
-    if(slave->version==DYN_VER1)
-      dyn_v1_slave_loop(slave);
+    if(slave->packet_ready)// check if a new instruction packet has been received
+    {
+      slave->packet_ready=0x00;
+      // check address
+      if(slave->version==DYN_VER1)
+        dyn_v1_slave_loop(slave);
+      else
+        dyn_v2_slave_loop(slave);
+    }
     else
-      dyn_v2_slave_loop(slave);
-  }
-  else
-  {
-    if(slave->comm_dev->time!=0x00000000)
     {
-      if(time_is_timeout(slave->comm_dev->time))
-      { 
-        /* cancel any IRQ or DMA reception */
-        comm_cancel_irq_receive(slave->comm_dev);
-        comm_cancel_dma_receive(slave->comm_dev);
-        slave->received_bytes=0;
-        /* enable reception by IRQ */
-        comm_receive_irq(slave->comm_dev,0);
+      if(slave->comm_dev->time!=0x00000000)
+      {
+        if(time_is_timeout(slave->comm_dev->time))
+        { 
+          /* cancel any IRQ or DMA reception */
+          comm_cancel_irq_receive(slave->comm_dev);
+          comm_cancel_dma_receive(slave->comm_dev);
+          slave->received_bytes=0;
+          /* enable reception by IRQ */
+          comm_receive_irq(slave->comm_dev,0);
+        }
       }
     }
   }