text: import logging
  import time
  from threading import Timer
  
  import cflib.crtp  # noqa
  from cflib.crazyflie import Crazyflie
  from cflib.crazyflie.log import LogConfig
  
  file = open('dat00.csv', 'w')
  
  # Only output errors from the logging framework
  logging.basicConfig(level=logging.ERROR)
  class LoggingExample:
      """
      Simple logging example class that logs the Stabilizer from a supplied
      link uri and disconnects after 5s.
      """
  
      def __init__(self, link_uri):
          """ Initialize and run the example with the specified link_uri """
  
          self._cf = Crazyflie(rw_cache='./cache')
  
          # Connect some callbacks from the Crazyflie API
          self._cf.connected.add_callback(self._connected)
          self._cf.disconnected.add_callback(self._disconnected)
          self._cf.connection_failed.add_callback(self._connection_failed)
          self._cf.connection_lost.add_callback(self._connection_lost)
  
          print('Connecting to %s' % link_uri)
  
          # Try to connect to the Crazyflie
          self._cf.open_link(link_uri)
  
          # Variable used to keep main loop occupied until disconnect
          self.is_connected = True
  
      def _connected(self, link_uri):
          """ This callback is called form the Crazyflie API when a Crazyflie
          has been connected and the TOCs have been downloaded."""
          print('Connected to %s' % link_uri)
  
          # The definition of the logconfig can be made before connecting
          self._lg_stab = LogConfig(name='ranging', period_in_ms=10)
          self._lg_stab.add_variable('ranging.distance1', 'float')
          self._lg_stab.add_variable('ranging.distance2', 'float')
          self._lg_stab.add_variable('ranging.distance3', 'float')
  
          # Adding the configuration cannot be done until a Crazyflie is
          # connected, since we need to check that the variables we
          # would like to log are in the TOC.
          try:
              self._cf.log.add_config(self._lg_stab)
              # This callback will receive the data
              self._lg_stab.data_received_cb.add_callback(self._stab_log_data)
              # This callback will be called on errors
              self._lg_stab.error_cb.add_callback(self._stab_log_error)
              # Start the logging
              self._lg_stab.start()
          except KeyError as e:
              print('Could not start log configuration,'
                    '{} not found in TOC'.format(str(e)))
          except AttributeError:
              print('Could not add Stabilizer log config, bad configuration.')
  
          # Start a timer to disconnect in 10s
          t = Timer(120, self._cf.close_link)
          t.start()
  
      def _stab_log_error(self, logconf, msg):
          """Callback from the log API when an error occurs"""
          print('Error when logging %s: %s' % (logconf.name, msg))
  
      def _stab_log_data(self, timestamp, data, logconf):
          """Callback froma the log API when data arrives"""
          print("relaX01:%1.2f, relaY01:%1.2f, relaYaw01:%2.2f" % (data['ranging.distance1'], data['ranging.distance2'], data['ranging.distance3']))
          file.write('{},  {}, {}\n'.format(data['ranging.distance1'], data['ranging.distance2'], data['ranging.distance3']))
  
  
      def _connection_failed(self, link_uri, msg):
          """Callback when connection initial connection fails (i.e no Crazyflie
          at the speficied address)"""
          print('Connection to %s failed: %s' % (link_uri, msg))
          self.is_connected = False
  
      def _connection_lost(self, link_uri, msg):
          """Callback when disconnected after a connection has been made (i.e
          Crazyflie moves out of range)"""
          print('Connection to %s lost: %s' % (link_uri, msg))
  
      def _disconnected(self, link_uri):
          """Callback when the Crazyflie is disconnected (called in all cases)"""
          print('Disconnected from %s' % link_uri)
          self.is_connected = False
  
  
  if __name__ == '__main__':
      # Initialize the low-level drivers (don't list the debug drivers)
      cflib.crtp.init_drivers(enable_debug_driver=False)
      le = LoggingExample('radio://0/50/2M/E7E7E7E7E5')
      # The Crazyflie lib doesn't contain anything to keep the application alive,
      # so this is where your application should do something. In our case we
      # are just waiting until we are disconnected.
      while le.is_connected:
          time.sleep(1)
      file.close()
  