tello 0.0.0 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7dc54292a6a3a3a5be22cae58d0df97def47d614858be4f5b055064671d9f128
-  data.tar.gz: fb2ce868969e81c51292ca55d95e4cc31a6c5f48cb862efd52b7874e6e34e2cc
+  metadata.gz: 4ca4867953dcdcba813f0d05d3733334bff4ed3360906c3e3222232c117a8119
+  data.tar.gz: 36945de880740202f27d70012d00871e8110c94a1312afbcf81190f000c8341d
 SHA512:
-  metadata.gz: 59f1da6e31abdfb071654f552b065b60a4f74a059445b97ef3445e2959db01fd81efc83cfe49dd4b2e3d65ee5481f78974fba57b7cc53ff4313a719232d5c074
-  data.tar.gz: 4b69ec75eed445a7716bf4e68febc3caed4f28972253d4800db6bebf99f5972e59e8209313681a59acc7d4018b0b223407ee7848770406e1899418598b5eac96
+  metadata.gz: 36023abd6a254c66336196be4735e2f34df08703f21f079fcb5c72a827844f76d0608d87d20405fb00801c53e604f27d4ca439c10d92017dbc999b38b4a148cc
+  data.tar.gz: 3b1b9f4dbe32a9f0d8a1e411b4abd8159969e7cc04328a20dfd3f8555a1b0914ef74db3d9f7fa2214176fb7322cb300b994d77fd837bf7a619830c3caff11ddd

data/bin/tello

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+require 'tello/colorize'
+require 'tello/version'
+
+# Check Command-line Arguments #################################################
+
+usage = "Fly the Tello drone with Ruby!".bold + "\n
+Usage: tello <command> <options>
+             [-v|--version]
+
+Summary of commands and options:
+  console       Open an interactive Tello console
+    --test        Start the console in test mode
+  server        Start the test server
+  -v|--version  Prints the installed version\n\n"
+
+if ARGV.delete '--test' then $tello_testing = true end
+
+case ARGV[0]
+when 'console'
+  require 'tello/cli/console'
+when 'server'
+  require 'tello/cli/server'
+when '-v', '--version'
+  puts Tello::VERSION
+else
+  puts usage
+end

data/lib/tello.rb

@@ -0,0 +1,29 @@
+# Tello module and requires
+
+module Tello
+  # Flag for testing
+  attr_accessor :testing, :os, :ip, :port
+
+  def self.testing; @testing end
+  def self.testing=(t); @testing=(t) end
+  def self.os; @os end
+
+  # Set the operating system
+  case RUBY_PLATFORM
+  when /darwin/
+    @os = :macos
+  when /linux/
+    @os = :linux
+  when /mingw/
+    @os = :windows
+  end
+end
+
+require 'tello/colorize'
+require 'tello/state'
+require 'tello/wifi'
+require 'tello/client'
+require 'tello/dsl'
+
+# Add DSL
+extend Tello::DSL

data/lib/tello/cli/console.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+if $tello_testing
+  puts "⚠️  Test mode enabled"
+  r_module = 'tello/cli/testing'
+else
+  r_module = 'tello'
+end
+
+puts "Ready to receive Tello commands. Type \"exit\" to quit."
+
+if system('pry -v &>/dev/null')
+  system("pry -r #{r_module}")
+else
+  system("irb -r #{r_module}")
+end

data/lib/tello/cli/server.rb

@@ -0,0 +1,58 @@
+# A simple UDP server
+require 'tello/colorize'
+require 'socket'
+
+PORT = 8889
+
+server = UDPSocket.new
+server.bind('localhost', PORT)
+
+puts "Starting Tello test server...".bold, "Listening on udp://localhost:#{PORT}"
+
+loop do
+  msg, addr = server.recvfrom(100)
+  puts "#{"==>".green} Received: \"#{msg}\", from #{addr[3]}:#{addr[1]}"
+
+  case msg
+  when 'speed?'
+    #=> 1-100 cm/s
+    res = "#{rand(1..100).to_f}\r\n"
+  when 'battery?'
+    #=> 0-100 %
+    res = "#{rand(0..100)}\r\n"
+  when 'time?'
+    #=> time
+    res = "#{rand(0..100)}s\r\n"
+  when 'height?'
+    #=> 0-3000 cm
+    res = "#{rand(0..3000)}dm\r\n"
+  when 'temp?'
+    #=> 0-90 °C
+    res = "83~86C\r\n"
+  when 'attitude?'
+    #=> pitch roll yaw
+    res = "pitch:-8;roll:3;yaw:2;\r\n"
+  when 'baro?'
+    #=> m
+    res = "-80.791573\r\n"
+  when 'acceleration?'
+    #=> x y z
+    res = "agx:-138.00;agy:-51.00;agz:-989.00;\r\n"
+  when 'tof?'
+    #=> 30-1000 cm
+    res = "#{rand(30..1000)}mm\r\n"
+  when 'wifi?'
+    #=> snr
+    res = "90\r\n"
+  when 'whatever'
+    res = "unknown command: whatever"
+  else
+    #=> 'ok' or 'error'
+    res = 'ok'
+  end
+
+  bytes = server.send(res.to_s, 0, addr[3], addr[1])
+  puts "#{"<==".blue} Sent: #{res.inspect}, #{bytes} bytes"
+end
+
+server.close

data/lib/tello/cli/testing.rb

@@ -0,0 +1,3 @@
+require 'tello'
+
+Tello.testing = true

data/lib/tello/client.rb

@@ -0,0 +1,152 @@
+# Tello::Client
+require 'socket'
+
+module Tello
+  module Client
+
+    attr_accessor :ip, :port, :connected, :ping, :state
+
+    class << self
+
+      # Create a Tello UDP connection
+      def connect(ssid = nil)
+
+        # Connect to Tello wifi
+        unless Tello::Wifi.connect(ssid)
+          puts "#{'Error:'.error} Could not connect to Tello 😢"
+          return false
+        end
+
+        # If already connected, disconnect
+        if @connected
+          puts "Reconnecting..."
+          disconnect
+        end
+
+        # Set IP and port numbers
+        @ip = Tello.testing ? 'localhost' : '192.168.10.1'
+        @port = 8889
+
+        # Create UDP client, bind to a previous source IP and port if availble
+        @client = UDPSocket.new unless @client
+        if @source_ip && @source_port
+          @client.bind(@source_ip, @source_port)
+        end
+
+        # Connect to destination, save IP and port assigned by the OS
+        @client.connect(@ip, @port)
+        @source_ip = @client.addr[3]
+        @source_port = @client.addr[1]
+
+        # Create server to get Tello state
+        unless @state_server
+          @state_server = UDPSocket.new
+          @state_server.bind('0.0.0.0', 8890)
+        end
+
+        # Check to see if test server is up
+        if Tello.testing
+          print "Connecting to test server..."
+          @client.send('command', 0)
+          sleep 0.5
+          unless read_nonblock
+            puts "\n#{'Error:'.error} Could not find Tello test server.",
+                 "Did you run `tello server` in another terminal window?"
+            return false
+          end
+          puts "connected!"
+        end
+
+        # Tello should be connected over wifi and UDP
+        @connected = true
+
+        # Threads for real Tello connection only
+        unless Tello.testing
+          # Create thread to keep Tello alive (must recieve command every 15 sec)
+          if @ping then @ping.exit end
+          @ping = Thread.new do
+            loop do
+              begin
+                @client.send('command', 0)
+              rescue Errno::EADDRNOTAVAIL
+                puts "#{'Error:'.error} No response from Tello! Try reconnecting."
+                @ping.exit
+              end
+              sleep 15
+            end
+          end
+
+          # Get Tello state
+          if @state then @state.exit end
+          @state = Thread.new do
+            loop do
+              Tello.store_state(@state_server.recv(256))
+            end
+          end
+        end
+
+        puts "Ready to fly! 🚁"; true
+      end
+
+      # Get Tello connection status
+      def connected?
+        if @connected
+          true
+        else
+          puts "Tello is not yet connected. Run `connect` first."
+          false
+        end
+      end
+
+      # Disconnect the Tello
+      def disconnect
+        return false unless @connected
+        unless Tello.testing
+          @state.exit
+          @ping.exit
+        end
+        @client.close
+        @client = nil
+        @connected = false
+        true
+      end
+
+      # Read the UDP response without blocking
+      def read_nonblock
+        begin
+          res = @client.recv_nonblock(256)
+        rescue IO::WaitReadable
+          res = nil
+        rescue Errno::ECONNREFUSED, Errno::EADDRNOTAVAIL
+          puts "#{'Error:'.error} Cannot communicate with Tello!"
+          @connected
+        end
+      end
+
+      # Send a native Tello command string
+      def send(cmd)
+        return false unless connected?
+        while read_nonblock do end  # flush previous response data
+        @client.send(cmd, 0)
+        @client.recv(256).strip
+      end
+
+      # Change 'ok' and 'error' to boolean response instead
+      def return_bool(res)
+        case res
+        when 'ok'
+          true
+        when 'error'
+          false
+        end
+      end
+
+      # Change string to number response instead
+      def return_num(res)
+        if res then res.to_i else res end
+      end
+
+    end
+
+  end
+end

data/lib/tello/colorize.rb

@@ -0,0 +1,10 @@
+# String#colorize
+
+# Extend `String` to include some fancy colors
+class String
+  def colorize(c); "\e[#{c}m#{self}\e[0m" end
+  def bold;  colorize('1')    end
+  def blue;  colorize('1;34') end
+  def green; colorize('1;32') end
+  def error; colorize('1;31') end
+end

data/lib/tello/dsl.rb

@@ -0,0 +1,207 @@
+# Tello::DSL
+# Define Tello domain-specific language
+
+module Tello
+  module DSL
+
+    # Warn Linux and Windows users to manually connect to Wi-Fi, for now
+    unless Tello.os == :macos
+      puts "Linux and Windows users:".bold,
+        "  Manually connect to Tello Wi-Fi before running the `connect` command"
+    end
+
+    # Connect to the drone
+    def connect
+      Tello::Client.connect
+    end
+
+    # Is the drone connected?
+    def connected?
+      Tello::Client.connected?
+    end
+
+    # Disconnect the drone
+    def disconnect
+      Tello::Client.disconnect
+    end
+
+    # Send a native Tello command to the drone
+    def send(s)
+      Tello::Client.send(s)
+    end
+
+    # Check if value is within the common movement range
+    def in_move_range?(v)
+      (20..500).include? v
+    end
+
+    # Takeoff and land
+    [:takeoff, :land].each do |cmd|
+      define_method cmd do
+        Tello::Client.return_bool send("#{cmd.to_s}")
+      end
+    end
+
+    # Move in a given direction
+    [:up, :down, :left, :right, :forward, :backward].each do |cmd|
+      define_method cmd do |x|
+        if in_move_range? x
+          Tello::Client.return_bool send("#{cmd.to_s} #{x}")
+        else
+          puts "Movement must be between 20..500 cm"
+        end
+      end
+    end
+
+    # Turn clockwise or counterclockwise
+    [:cw, :ccw].each do |cmd|
+      define_method cmd do |x|
+        if (1..3600).include? x
+          Tello::Client.return_bool send("#{cmd.to_s} #{x}")
+        else
+          puts "Rotation must be between 1..3600 degrees"
+        end
+      end
+    end
+
+    # Flip in a given direction
+    def flip(f)
+      case f
+      when :left, :l
+        Tello::Client.return_bool send('flip l')
+      when :right, :r
+        Tello::Client.return_bool send('flip r')
+      when :forward, :f
+        Tello::Client.return_bool send('flip f')
+      when :backward, :b
+        Tello::Client.return_bool send('flip b')
+      else
+        puts "Not a valid direction to flip"
+        false
+      end
+    end
+
+    # Get or set the flight speed
+    def speed(s = nil)
+      if s
+        if (10..100).include? s
+          Tello::Client.return_bool send("speed #{s}")
+        else
+          puts "Speed must be between 10..100 cm/s"
+        end
+      else
+        s = send('speed?')
+        s == false ? false : s.to_f
+      end
+    end
+
+    # Fly to a location in x/y/z coordinates and provided speed
+    def go(x, y, z, speed = 10)
+
+      # Check if coordinates are in range
+      unless in_move_range?(x) && in_move_range?(y) && in_move_range?(z)
+        puts "x/y/z coordinates must be between 20..500 cm"
+        return false
+      end
+
+      # Check if speed is in range
+      unless (10..100).include? speed
+        puts "Speed must be between 10..100 cm/s"
+        return false
+      end
+
+      Tello::Client.return_bool send("go #{x} #{y} #{z} #{speed}")
+    end
+
+    # Fly in a curve; If arc radius is not within 0.5..10 m, command responds false
+    def curve(x1, y1, z1, x2, y2, z2, speed = 10)
+
+      # Check if coordinates are in range
+      # TODO: x/y/z can't be between -20..20 at the same time
+      unless in_move_range?(x1) && in_move_range?(y1) && in_move_range?(z1) &&
+             in_move_range?(x2) && in_move_range?(y2) && in_move_range?(z2)
+        puts "x/y/z coordinates must be between 20..500 cm"
+        return false
+      end
+
+      # Check if speed is in range
+      unless (10..60).include? speed
+        puts "Speed must be between 10..60 cm/s"
+        return false
+      end
+
+      Tello::Client.return_bool send("curve #{x1} #{y1} #{z1} #{x2} #{y2} #{z2} #{speed}")
+    end
+
+    # Send RC control via four channels:
+    #   a: left/right, b: forward/backward, c: up/down, d: yaw
+    def rc(a, b, c, d)
+
+      # Check if channel values are in range
+      [a, b, c, d].each do |v|
+        unless (-100..100).include? v
+          puts "RC channel values must be between -100..100"
+          return false
+        end
+      end
+
+      Tello::Client.return_bool send("rc #{a} #{b} #{c} #{d}")
+    end
+
+    # Get the height of the drone
+    def height
+      Tello::Client.return_num send('height?')
+    end
+
+    # Get IMU attitude data
+    def attitude
+      send('attitude?')
+    end
+
+    # Get IMU angular acceleration data
+    def acceleration
+      send('acceleration?')
+    end
+
+    # Get barometer value
+    def baro
+      Tello::Client.return_num send('baro?')
+    end
+
+    # Get distance value from TOF
+    def tof
+      Tello::Client.return_num send('tof?')
+    end
+
+    # Get the flight time
+    def time
+      Tello::Client.return_num send('time?')
+    end
+
+    # Get the battery level
+    def battery
+      b = send('battery?')
+      b == false ? false : Tello::Client.return_num(b)
+    end
+
+    # Get the temperature of the drone
+    def temp
+      send('temp?')
+    end
+
+    # Get Wi-Fi signal-to-noise ratio (SNR); if parameters, set SSID and password
+    def wifi(ssid: nil, pass: nil)
+      if ssid && pass
+        Tello::Client.return_bool send("wifi #{ssid} #{pass}")
+      else
+        Tello::Client.return_num send('wifi?')
+      end
+    end
+
+    # Stop all motors immediately
+    def stop
+      Tello::Client.return_bool send('emergency')
+    end
+
+  end
+end

data/lib/tello/state.rb

@@ -0,0 +1,26 @@
+# Tello state
+
+module Tello
+
+  @state
+
+  class << self
+
+    # Take a Tello state string, parse to a hash, and store.
+    # String in the form:
+    #   "pitch:11;roll:-18;yaw:118;vgx:0;vgy:0;vgz:0;templ:78;temph:80;tof:10;\
+    #    h:0;bat:27;baro:-64.81;time:0;agx:242.00;agy:315.00;agz:-1057.00;\r\n"
+    def store_state(str)
+      str.strip!
+      @state = Hash[
+        str.split(';').map do |pair|
+          k, v = pair.split(':', 2)
+          [k.to_sym, v.to_i]
+        end
+      ]
+    end
+
+    def state; @state end
+
+  end
+end

data/lib/tello/version.rb

@@ -1,5 +1,5 @@
 # version.rb
 
 module Tello
-  VERSION = '0.0.0'
+  VERSION = '0.1.0'
 end

data/lib/tello/wifi.rb

@@ -0,0 +1,153 @@
+# Tello::Wifi
+
+module Tello
+  module Wifi
+
+    attr_accessor :tello_ssid, :macos_airport
+
+    # Initialize data
+    case Tello.os
+    when :macos
+      @macos_airport = '/System/Library/PrivateFrameworks/Apple80211.framework/Versions/A/Resources/airport'
+    end
+
+    class << self
+
+      # Find and connect to a Tello Wi-Fi
+      def connect(ssid = nil)
+
+        # Skip connecting to Wi-Fi if in test mode
+        if Tello.testing
+          puts "In test mode, skipping Wi-Fi setup..."
+          return true
+        end
+
+        # Assume Wi-Fi manually connected on Linux and Windows, for now
+        # TODO: Actually implement
+        unless Tello.os == :macos
+          return true
+        end
+
+        # If provided SSID, set it, else look for a Tello Wi-Fi
+        if ssid
+          @tello_ssid = ssid
+        else
+          # Look for a Tello over Wi-Fi
+          print "📶 Looking for Tello Wi-Fi..."
+
+          # Done if already connected
+          if wifi_connected?
+            puts "already connected!"
+            return true
+          end
+
+          # Search for a Tello Wi-Fi SSID (by default starting with "TELLO-")
+          @tello_ssid = get_tello_wifi
+
+          if @tello_ssid
+            puts "found!"
+          else
+            puts "nothing found"
+            return false
+          end
+        end
+
+        # Connect to the Tello Wi-Fi
+        print "🔗 Connecting to #{@tello_ssid}..."
+
+        if connect_tello_wifi
+          puts "done!"; true
+        else
+          puts "failed!"; false
+        end
+      end
+
+      # Check if already connected to a Tello Wi-Fi, e.g. "TELLO-A5983D"
+      def wifi_connected?
+        @connected = case Tello.os
+        when :macos
+          macos_wifi_connected?
+        when :linux
+          linux_wifi_connected?
+        when :windows
+          windows_wifi_connected?
+        end
+      end
+
+      # macOS `#wifi_connected?`
+      def macos_wifi_connected?
+        if `#{@macos_airport} -I`.match(/(tello-)\w+/i) then true else false end
+      end
+
+      # Linux `#wifi_connected?`
+      def linux_wifi_connected?
+        puts "`#linux_connected?` not implemented"; false
+      end
+
+      # Windows `#wifi_connected?`
+      def windows_wifi_connected?
+        puts "`#windows_connected?` not implemented"; false
+      end
+
+      # Look for a Tello Wi-Fi SSID starting with "TELLO-"
+      # Returns an SSID, e.g. "TELLO-B5889D", or `nil` if nothing found
+      def get_tello_wifi
+        case Tello.os
+        when :macos
+          macos_get_tello_wifi
+        when :linux
+          linux_get_tello_wifi
+        when :windows
+          windows_get_tello_wifi
+        end
+      end
+
+      # macOS `#get_tello_wifi`
+      def macos_get_tello_wifi
+        res = `#{@macos_airport} scan`.match(/(tello-)\w+/i)
+        res ? res[0] : nil
+      end
+
+      # Linux `#get_tello_wifi`
+      def linux_get_tello_wifi
+        puts "`#linux_get_tello_wifi` not implemented"; false
+      end
+
+      # Windows `#get_tello_wifi`
+      def windows_get_tello_wifi
+        puts "`#windows_get_tello_wifi` not implemented"; false
+      end
+
+      # Connect to an SSID stored in `@tello_ssid`
+      def connect_tello_wifi
+        case Tello.os
+        when :macos
+          macos_connect_tello_wifi
+        when :linux
+          linux_connect_tello_wifi
+        when :windows
+          windows_connect_tello_wifi
+        end
+      end
+
+      # macOS `#connect_tello_wifi`
+      def macos_connect_tello_wifi
+        # Assumes `en0` is wifi, might have to use this to confirm:
+        #   networksetup -listallhardwareports
+        res = `networksetup -setairportnetwork en0 #{@tello_ssid}`
+        res == '' ? true : false
+      end
+
+      # Linux `#connect_tello_wifi`
+      def linux_connect_tello_wifi
+        puts "`#linux_get_tello_wifi` not implemented"; false
+      end
+
+      # Windows `#connect_tello_wifi`
+      def windows_connect_tello_wifi
+        puts "`#windows_get_tello_wifi` not implemented"; false
+      end
+
+    end
+  end
+end

metadata

@@ -1,23 +1,33 @@
 --- !ruby/object:Gem::Specification
 name: tello
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.1.0
 platform: ruby
 authors:
 - Tom Black
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-07 00:00:00.000000000 Z
+date: 2018-11-21 00:00:00.000000000 Z
 dependencies: []
-description: Fly the Tello drone with Ruby.
+description: Fly the Tello drone with Ruby!
 email: tom@blacktm.com
-executables: []
+executables:
+- tello
 extensions: []
 extra_rdoc_files: []
 files:
+- bin/tello
 - lib/tello.rb
+- lib/tello/cli/console.rb
+- lib/tello/cli/server.rb
+- lib/tello/cli/testing.rb
+- lib/tello/client.rb
+- lib/tello/colorize.rb
+- lib/tello/dsl.rb
+- lib/tello/state.rb
 - lib/tello/version.rb
+- lib/tello/wifi.rb
 homepage: https://github.com/blacktm/tello
 licenses:
 - MIT
@@ -38,8 +48,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.7
+rubygems_version: 2.7.8
 signing_key: 
 specification_version: 4
-summary: Tello drone control
+summary: Tello
 test_files: []