Merge branch 'release/0.1.0'

Author: stylesuxx

.gitignore

@@ -1,3 +1,4 @@
+*.hex
 .pio
 .vscode/.browse.c_cpp.db*
 .vscode/c_cpp_properties.json

README.md

@@ -23,7 +23,7 @@ The Dshot value sent by default is **0**. Via serial console other values (up to
 ## How does it work?
 A timer triggers sending of the DShot frame via interrupt then the following things happen:
 
-1. B8 is set as output
+1. D8 is set as output
 2. Dshot frame is sent
 3. D8 is set as input
 4. Input capture on timer 1 is used to capture the time between falling and rising endges
@@ -34,11 +34,31 @@ A timer triggers sending of the DShot frame via interrupt then the following thi
 ## Usage
 I recommend you use Visual Studio Code with the platform IO plugin. A **platformio.ini** is included in the repository with a working serial monitor configuration.
 
+## C2 Interface
+This sketch also includes a C2 interface for your convenience, allowing to read, write and erase an EFM8 MCU. This will require you to install the EFM8 python client. Also by default the Arduino will start in DShot mode, to enable the C2 interface, pull pin 13 low and reset the arduino.
+
+To switch back to DShot mode, remove the jumper to low form pin 13 and reset the arduino.
+
+### Installing python EFM8 client
+use pipenv to create an virtual env, install dependencies and enter the env:
+```
+pipenv install
+pipenv shell
+```
+
+then run the client like so:
+
+```
+python efm8.py read /dev/ttyUSB0 output.hex
+python efm8.py write /dev/ttyUSB0 input.hex
+python efm8.py erase
+```
+
 ## Compatibility
 This should work on any Arduino Uno or clone running at 16MHz. If you are using a different Arduino board, make sure you are using (and setting) the pin which has the "Input Capture" functionality.
 
 ## Resources
 * [DShot - the missing handbook](https://brushlesswhoop.com/dshot-and-bidirectional-dshot/)
 
 ## Contributions
-Contributions are very welcome. Feel free to submit a PR against the develop branch. If you have any questions or feature requests, feel free to [open an issue](https://github.com/bird-sanctuary/arduino-bi-directional-dshot/issues).
+Contributions are very welcome. Feel free to submit a PR against the develop branch. If you have any questions or feature requests, feel free to [open an issue](https://github.com/bird-sanctuary/arduino-bi-directional-dshot/issues).

client/Pipfile

@@ -0,0 +1,12 @@
+[[source]]
+url = "https://pypi.org/simple"
+verify_ssl = true
+name = "pypi"
+
+[packages]
+pyserial = "*"
+
+[dev-packages]
+
+[requires]
+python_version = "3.7"

client/Pipfile.lock

@@ -0,0 +1,144 @@
+from hashlib import new
+import serial
+import time
+import sys
+import argparse
+from tokenize import String
+
+class ProgrammingInterface:
+  def __init__(self, port, baudrate = 1000000):
+    self.serial = serial.Serial(port, baudrate, timeout = 1)
+
+    # Give Arduino some time
+    time.sleep(2)
+
+  def initialize(self):
+    done = False
+    while not done:
+      try:
+        self.serial.write(b"\x01\x00")
+        result = self.serial.read(1)
+        assert result == b"\x81"
+        done = True
+      except:
+        print("Error: Could not establish connection - try resetting your Arduino")
+        sys.exit(1)
+
+    print("Connected to interface")
+
+  def read(self, file, start=0x00, size=0x3FFF, chunksize=0x10):
+    for address in range(start, start + size, chunksize):
+      request = [
+          0x05, 0x05,
+          chunksize,
+          (address >> 16) & 0xFF,
+          (address >> 8) & 0xFF,
+          address & 0xFF,
+          0x00,
+      ]
+
+      self.serial.write(request)
+      response = self.serial.read(chunksize + 1)
+      body = response[1:]
+
+      if len(response) > 0 and len(body) > 0:
+        print("===============================================")
+        print("address: %s" % hex(address))
+        print("request: %s" % bytes(request).hex())
+        print("response code: %s" % hex(response[0]))
+        print("response body: %s" % body.hex())
+
+        line = bytearray([chunksize, (address >> 8) & 0xFF, address & 0xFF, 0x00]) + body
+        crc = 0
+        for nextbyte in line:
+            crc = crc + nextbyte
+
+        crc = (~crc + 1) & 0xFF
+        line.append(crc)
+        file.write(":%s\n" % line.hex())
+
+      else:
+        break
+
+  def erase(self):
+    self.serial.write(b"\x04\x00")
+    assert self.serial.read(1) == b"\x84"
+    print("Device erased")
+
+  def reset(self):
+    self.serial.write(b"\x02\x00")
+    assert self.serial.read(1) == b"\x82"
+
+  def write(self, file):
+    lines = file.readlines()
+    for line in lines:
+      assert line[0] == ":"
+      if line[7:9] != "00":
+        continue
+
+      length = int(line[1:3], 16)
+      assert length + 4 < 256
+
+      addressHi = int(line[3:5], 16)
+      addressLo = int(line[5:7], 16)
+      data = bytearray.fromhex(line[9 : 9 + length * 2])
+      assert len(data) == length
+      crc = addressHi + addressLo
+      for i in range(len(data)):
+        crc += data[i]
+      crc = crc & 0xFF
+      print(
+        "0x{:04X}, Bytes: {:02X}, Data: {}".format(
+          (addressLo + (addressHi << 8)), len(data), data.hex()
+        )
+      )
+      self.serial.write([0x3, len(data) + 5, len(data), 0, addressHi, addressLo, crc])
+      self.serial.write(data)
+      response = self.serial.read(1)
+      if response != b"\x83":
+          print("Error: Failed writing data")
+          return None
+
+    self.reset()
+
+parser = argparse.ArgumentParser(description='Interact with the Arduino based EFM8 C2 interface')
+parser.add_argument('action', metavar='ACTION', type=str,
+                    help='Action to perform: read, write or erase',
+                    choices=['read', 'write', 'erase'],)
+parser.add_argument('port', metavar='PORT', type=str,
+                    help='Port to use')
+parser.add_argument('destination', metavar='DESTINATION', type=str, nargs='?', default=None,
+                    help='Destination to write to or read from')
+
+args = parser.parse_args()
+interface = ProgrammingInterface(args.port)
+interface.initialize()
+
+if args.action == 'read':
+  if not args.destination:
+    parser.print_usage()
+    parser.exit()
+
+  file = open(args.destination, "w")
+
+  # Fetch the flash segment
+  interface.read(file, 0, 0x3FFF)
+
+  # Fetch the bootloader
+  # TODO: this could be passed via a parameter
+  #interface.read(file, 0xF000, 0x07FF)
+
+  file.write(":00000001FF\n")
+
+if args.action == 'erase':
+  interface.erase()
+
+if args.action == 'write':
+  if not args.destination:
+    parser.print_usage()
+    parser.exit()
+
+  file = open(args.destination, "r")
+
+  interface.erase()
+  interface.write(file)