Add python script to DFU from a linux PC to the Pinetime
This commit is contained in:
parent
dca559aad5
commit
b41a856b9d
|
@ -41,10 +41,10 @@ Pack the image into a .zip file for the NRF DFU protocol:
|
|||
adafruit-nrfutil dfu genpkg --dev-type 0x0052 --application image.bin dfu.zip
|
||||
`
|
||||
|
||||
Use NRFConnect or dfu.py to upload the zip file to the device:
|
||||
Use NRFConnect or dfu.py (in <project root>/bootloader/ota-dfu-python) to upload the zip file to the device:
|
||||
|
||||
`
|
||||
sudo dfu.py -z /home/jf/nrf52/bootloader/dfu.zip -a <pinetime MAC address> --legacy
|
||||
`
|
||||
|
||||
**TODO** : dfu.py
|
||||
**Note** : dfu.py is a slightly modified version of [this repo](https://github.com/daniel-thompson/ota-dfu-python).
|
1
bootloader/ota-dfu-python/Fork.txt
Normal file
1
bootloader/ota-dfu-python/Fork.txt
Normal file
|
@ -0,0 +1 @@
|
|||
This directory contains source forked from https://github.com/daniel-thompson/ota-dfu-python.
|
201
bootloader/ota-dfu-python/LICENSE
Normal file
201
bootloader/ota-dfu-python/LICENSE
Normal file
|
@ -0,0 +1,201 @@
|
|||
Apache License
|
||||
Version 2.0, January 2004
|
||||
http://www.apache.org/licenses/
|
||||
|
||||
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
|
||||
|
||||
1. Definitions.
|
||||
|
||||
"License" shall mean the terms and conditions for use, reproduction,
|
||||
and distribution as defined by Sections 1 through 9 of this document.
|
||||
|
||||
"Licensor" shall mean the copyright owner or entity authorized by
|
||||
the copyright owner that is granting the License.
|
||||
|
||||
"Legal Entity" shall mean the union of the acting entity and all
|
||||
other entities that control, are controlled by, or are under common
|
||||
control with that entity. For the purposes of this definition,
|
||||
"control" means (i) the power, direct or indirect, to cause the
|
||||
direction or management of such entity, whether by contract or
|
||||
otherwise, or (ii) ownership of fifty percent (50%) or more of the
|
||||
outstanding shares, or (iii) beneficial ownership of such entity.
|
||||
|
||||
"You" (or "Your") shall mean an individual or Legal Entity
|
||||
exercising permissions granted by this License.
|
||||
|
||||
"Source" form shall mean the preferred form for making modifications,
|
||||
including but not limited to software source code, documentation
|
||||
source, and configuration files.
|
||||
|
||||
"Object" form shall mean any form resulting from mechanical
|
||||
transformation or translation of a Source form, including but
|
||||
not limited to compiled object code, generated documentation,
|
||||
and conversions to other media types.
|
||||
|
||||
"Work" shall mean the work of authorship, whether in Source or
|
||||
Object form, made available under the License, as indicated by a
|
||||
copyright notice that is included in or attached to the work
|
||||
(an example is provided in the Appendix below).
|
||||
|
||||
"Derivative Works" shall mean any work, whether in Source or Object
|
||||
form, that is based on (or derived from) the Work and for which the
|
||||
editorial revisions, annotations, elaborations, or other modifications
|
||||
represent, as a whole, an original work of authorship. For the purposes
|
||||
of this License, Derivative Works shall not include works that remain
|
||||
separable from, or merely link (or bind by name) to the interfaces of,
|
||||
the Work and Derivative Works thereof.
|
||||
|
||||
"Contribution" shall mean any work of authorship, including
|
||||
the original version of the Work and any modifications or additions
|
||||
to that Work or Derivative Works thereof, that is intentionally
|
||||
submitted to Licensor for inclusion in the Work by the copyright owner
|
||||
or by an individual or Legal Entity authorized to submit on behalf of
|
||||
the copyright owner. For the purposes of this definition, "submitted"
|
||||
means any form of electronic, verbal, or written communication sent
|
||||
to the Licensor or its representatives, including but not limited to
|
||||
communication on electronic mailing lists, source code control systems,
|
||||
and issue tracking systems that are managed by, or on behalf of, the
|
||||
Licensor for the purpose of discussing and improving the Work, but
|
||||
excluding communication that is conspicuously marked or otherwise
|
||||
designated in writing by the copyright owner as "Not a Contribution."
|
||||
|
||||
"Contributor" shall mean Licensor and any individual or Legal Entity
|
||||
on behalf of whom a Contribution has been received by Licensor and
|
||||
subsequently incorporated within the Work.
|
||||
|
||||
2. Grant of Copyright License. Subject to the terms and conditions of
|
||||
this License, each Contributor hereby grants to You a perpetual,
|
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
||||
copyright license to reproduce, prepare Derivative Works of,
|
||||
publicly display, publicly perform, sublicense, and distribute the
|
||||
Work and such Derivative Works in Source or Object form.
|
||||
|
||||
3. Grant of Patent License. Subject to the terms and conditions of
|
||||
this License, each Contributor hereby grants to You a perpetual,
|
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
||||
(except as stated in this section) patent license to make, have made,
|
||||
use, offer to sell, sell, import, and otherwise transfer the Work,
|
||||
where such license applies only to those patent claims licensable
|
||||
by such Contributor that are necessarily infringed by their
|
||||
Contribution(s) alone or by combination of their Contribution(s)
|
||||
with the Work to which such Contribution(s) was submitted. If You
|
||||
institute patent litigation against any entity (including a
|
||||
cross-claim or counterclaim in a lawsuit) alleging that the Work
|
||||
or a Contribution incorporated within the Work constitutes direct
|
||||
or contributory patent infringement, then any patent licenses
|
||||
granted to You under this License for that Work shall terminate
|
||||
as of the date such litigation is filed.
|
||||
|
||||
4. Redistribution. You may reproduce and distribute copies of the
|
||||
Work or Derivative Works thereof in any medium, with or without
|
||||
modifications, and in Source or Object form, provided that You
|
||||
meet the following conditions:
|
||||
|
||||
(a) You must give any other recipients of the Work or
|
||||
Derivative Works a copy of this License; and
|
||||
|
||||
(b) You must cause any modified files to carry prominent notices
|
||||
stating that You changed the files; and
|
||||
|
||||
(c) You must retain, in the Source form of any Derivative Works
|
||||
that You distribute, all copyright, patent, trademark, and
|
||||
attribution notices from the Source form of the Work,
|
||||
excluding those notices that do not pertain to any part of
|
||||
the Derivative Works; and
|
||||
|
||||
(d) If the Work includes a "NOTICE" text file as part of its
|
||||
distribution, then any Derivative Works that You distribute must
|
||||
include a readable copy of the attribution notices contained
|
||||
within such NOTICE file, excluding those notices that do not
|
||||
pertain to any part of the Derivative Works, in at least one
|
||||
of the following places: within a NOTICE text file distributed
|
||||
as part of the Derivative Works; within the Source form or
|
||||
documentation, if provided along with the Derivative Works; or,
|
||||
within a display generated by the Derivative Works, if and
|
||||
wherever such third-party notices normally appear. The contents
|
||||
of the NOTICE file are for informational purposes only and
|
||||
do not modify the License. You may add Your own attribution
|
||||
notices within Derivative Works that You distribute, alongside
|
||||
or as an addendum to the NOTICE text from the Work, provided
|
||||
that such additional attribution notices cannot be construed
|
||||
as modifying the License.
|
||||
|
||||
You may add Your own copyright statement to Your modifications and
|
||||
may provide additional or different license terms and conditions
|
||||
for use, reproduction, or distribution of Your modifications, or
|
||||
for any such Derivative Works as a whole, provided Your use,
|
||||
reproduction, and distribution of the Work otherwise complies with
|
||||
the conditions stated in this License.
|
||||
|
||||
5. Submission of Contributions. Unless You explicitly state otherwise,
|
||||
any Contribution intentionally submitted for inclusion in the Work
|
||||
by You to the Licensor shall be under the terms and conditions of
|
||||
this License, without any additional terms or conditions.
|
||||
Notwithstanding the above, nothing herein shall supersede or modify
|
||||
the terms of any separate license agreement you may have executed
|
||||
with Licensor regarding such Contributions.
|
||||
|
||||
6. Trademarks. This License does not grant permission to use the trade
|
||||
names, trademarks, service marks, or product names of the Licensor,
|
||||
except as required for reasonable and customary use in describing the
|
||||
origin of the Work and reproducing the content of the NOTICE file.
|
||||
|
||||
7. Disclaimer of Warranty. Unless required by applicable law or
|
||||
agreed to in writing, Licensor provides the Work (and each
|
||||
Contributor provides its Contributions) on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
||||
implied, including, without limitation, any warranties or conditions
|
||||
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
|
||||
PARTICULAR PURPOSE. You are solely responsible for determining the
|
||||
appropriateness of using or redistributing the Work and assume any
|
||||
risks associated with Your exercise of permissions under this License.
|
||||
|
||||
8. Limitation of Liability. In no event and under no legal theory,
|
||||
whether in tort (including negligence), contract, or otherwise,
|
||||
unless required by applicable law (such as deliberate and grossly
|
||||
negligent acts) or agreed to in writing, shall any Contributor be
|
||||
liable to You for damages, including any direct, indirect, special,
|
||||
incidental, or consequential damages of any character arising as a
|
||||
result of this License or out of the use or inability to use the
|
||||
Work (including but not limited to damages for loss of goodwill,
|
||||
work stoppage, computer failure or malfunction, or any and all
|
||||
other commercial damages or losses), even if such Contributor
|
||||
has been advised of the possibility of such damages.
|
||||
|
||||
9. Accepting Warranty or Additional Liability. While redistributing
|
||||
the Work or Derivative Works thereof, You may choose to offer,
|
||||
and charge a fee for, acceptance of support, warranty, indemnity,
|
||||
or other liability obligations and/or rights consistent with this
|
||||
License. However, in accepting such obligations, You may act only
|
||||
on Your own behalf and on Your sole responsibility, not on behalf
|
||||
of any other Contributor, and only if You agree to indemnify,
|
||||
defend, and hold each Contributor harmless for any liability
|
||||
incurred by, or claims asserted against, such Contributor by reason
|
||||
of your accepting any such warranty or additional liability.
|
||||
|
||||
END OF TERMS AND CONDITIONS
|
||||
|
||||
APPENDIX: How to apply the Apache License to your work.
|
||||
|
||||
To apply the Apache License to your work, attach the following
|
||||
boilerplate notice, with the fields enclosed by brackets "[]"
|
||||
replaced with your own identifying information. (Don't include
|
||||
the brackets!) The text should be enclosed in the appropriate
|
||||
comment syntax for the file format. We also recommend that a
|
||||
file or class name and description of purpose be included on the
|
||||
same "printed page" as the copyright notice for easier
|
||||
identification within third-party archives.
|
||||
|
||||
Copyright [yyyy] [name of copyright owner]
|
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License");
|
||||
you may not use this file except in compliance with the License.
|
||||
You may obtain a copy of the License at
|
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software
|
||||
distributed under the License is distributed on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
See the License for the specific language governing permissions and
|
||||
limitations under the License.
|
118
bootloader/ota-dfu-python/README.md
Normal file
118
bootloader/ota-dfu-python/README.md
Normal file
|
@ -0,0 +1,118 @@
|
|||
# Python nRF5 OTA DFU Controller
|
||||
|
||||
So... this is my fork of dingara's fork of astronomer80's fork of
|
||||
foldedtoad's Python OTA DFU utility.
|
||||
|
||||
My own contribution is little more than a brute force conversion to
|
||||
python3. It is sparsely tested so there are likely to be a few
|
||||
remaining bytes versus string bugs remaining in the places I didn't test
|
||||
. I used it primarily as part of
|
||||
[wasp-os](https://github.com/daniel-thompson/wasp-os) as a way to
|
||||
deliver OTA updates to nRF52-based smart watches, especially the
|
||||
[Pine64 PineTime](https://www.pine64.org/pinetime/).
|
||||
|
||||
## What does it do?
|
||||
|
||||
This is a Python program that uses `gatttool` (provided with the Linux BlueZ driver) to achieve Over The Air (OTA) Device Firmware Updates (DFU) to a Nordic Semiconductor nRF5 (either nRF51 or nRF52) device via Bluetooth Low Energy (BLE).
|
||||
|
||||
### Main features:
|
||||
|
||||
* Perform OTA DFU to an nRF5 peripheral without an external USB BLE dongle.
|
||||
* Ability to detect if the peripheral is running in application mode or bootloader, and automatically switch if needed (buttonless).
|
||||
* Support for both Legacy (SDK <= 11) and Secure (SDK >= 12) bootloader.
|
||||
|
||||
Before using this utility the nRF5 peripheral device needs to be programmed with a DFU bootloader (see Nordic Semiconductor documentation/examples for instructions on that).
|
||||
|
||||
## Prerequisites
|
||||
|
||||
* BlueZ 5.4 or above
|
||||
* Python 3.6
|
||||
* Python `pexpect` module (available via pip)
|
||||
* Python `intelhex` module (available via pip)
|
||||
|
||||
## Firmware Build Requirement
|
||||
|
||||
* Your nRF5 peripheral firmware build method will produce a firmware file ending with either `*.hex` or `*.bin`.
|
||||
* Your nRF5 firmware build method will produce an Init file ending with `.dat`.
|
||||
* The typical naming convention is `application.bin` and `application.dat`, but this utility will accept other names.
|
||||
|
||||
## Generating init files
|
||||
|
||||
### Legacy bootloader
|
||||
|
||||
Use the `gen_dat` application (you need to compile it with `gcc gen_dat.c -o gen_dat` on first run) to generate a `.dat` file from your `.bin` file. Example:
|
||||
|
||||
./gen_dat application.bin application.dat
|
||||
|
||||
Note: The `gen_dat` utility expects a `.bin` file input, so you'll get Cyclic Redundancy Check (CRC) errors during DFU using a `.dat` file generated from a `.hex` file.
|
||||
|
||||
An alternative is to use `nrfutil` from Nordic Semiconductor, but I've found this method to be easier. You may need to edit the `gen_dat` source to fit your specific application.
|
||||
|
||||
### Secure bootloader
|
||||
|
||||
You need to use `nrfutil` to generate firmware packages for the new secure bootloader (SDK > 12) as the package needs to be signed with a private/public key pair. Note that the bootloader will need to be programmed with the corresponding public key. See the [nrfutil repo](https://github.com/NordicSemiconductor/pc-nrfutil) for details.
|
||||
|
||||
Note: I've had problems with the pip version of `nrfutil`. I recommend [installing from source](https://github.com/NordicSemiconductor/pc-nrfutil#running-and-installing-from-source) instead.
|
||||
|
||||
## Usage
|
||||
|
||||
There are two ways to specify firmware files for this utility. Either by specifying both the `.hex` or `.bin` file with the `.dat` file, or more easily by the `.zip` file, which contains both the hex and dat files.
|
||||
|
||||
The new `.zip` file form is encouraged by Nordic, but the older hex/bin + dat file methods should still work.
|
||||
|
||||
## Usage Examples
|
||||
|
||||
> sudo ./dfu.py -f ~/application.hex -d ~/application.dat -a CD:E3:4A:47:1C:E4
|
||||
|
||||
or:
|
||||
|
||||
> sudo ./dfu.py -z ~/application.zip -a CD:E3:4A:47:1C:E4
|
||||
|
||||
You can use the `hcitool lescan` to figure out the address of a DFU target, for example:
|
||||
|
||||
$ sudo hcitool -i hci0 lescan
|
||||
LE Scan ...
|
||||
CD:E3:4A:47:1C:E4 <TARGET_NAME>
|
||||
CD:E3:4A:47:1C:E4 (unknown)
|
||||
|
||||
|
||||
## Example Output
|
||||
|
||||
================================
|
||||
== ==
|
||||
== DFU Server ==
|
||||
== ==
|
||||
================================
|
||||
|
||||
Sending file application.bin to CD:E3:4A:47:1C:E4
|
||||
bin array size: 60788
|
||||
Checking DFU State...
|
||||
Board needs to switch in DFU mode
|
||||
Switching to DFU mode
|
||||
Enable Notifications in DFU mode
|
||||
Sending hex file size
|
||||
Waiting for Image Size notification
|
||||
Waiting for INIT DFU notification
|
||||
Begin DFU
|
||||
Progress: |xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx| 100.0% Complete (60788 of 60788 bytes)
|
||||
|
||||
Upload complete in 0 minutes and 14 seconds
|
||||
segments sent: 3040
|
||||
Waiting for DFU complete notification
|
||||
Waiting for Firmware Validation notification
|
||||
Activate and reset
|
||||
DFU Server done
|
||||
|
||||
## TODO:
|
||||
|
||||
* Implement link-loss procedure for Legacy Controller.
|
||||
* Update example output in readme.
|
||||
* Add makefile examples.
|
||||
* More code cleanup.
|
||||
|
||||
## Info & References
|
||||
|
||||
* [Nordic Legacy DFU Service](http://infocenter.nordicsemi.com/topic/com.nordic.infocenter.sdk5.v11.0.0/bledfu_transport_bleservice.html?cp=4_0_3_4_3_1_4_1)
|
||||
* [Nordic Legacy DFU sequence diagrams](http://infocenter.nordicsemi.com/topic/com.nordic.infocenter.sdk5.v11.0.0/bledfu_transport_bleprofile.html?cp=4_0_3_4_3_1_4_0_1_6#ota_profile_pkt_rcpt_notif)
|
||||
* [Nordic Secure DFU bootloader](http://infocenter.nordicsemi.com/topic/com.nordic.infocenter.sdk5.v12.2.0/lib_dfu_transport_ble.html?cp=4_0_1_3_5_2_2)
|
||||
* [nrfutil](https://github.com/NordicSemiconductor/pc-nrfutil)
|
291
bootloader/ota-dfu-python/ble_legacy_dfu_controller.py
Normal file
291
bootloader/ota-dfu-python/ble_legacy_dfu_controller.py
Normal file
|
@ -0,0 +1,291 @@
|
|||
import math
|
||||
import pexpect
|
||||
import time
|
||||
|
||||
from array import array
|
||||
from util import *
|
||||
|
||||
from nrf_ble_dfu_controller import NrfBleDfuController
|
||||
|
||||
verbose = False
|
||||
|
||||
class Procedures:
|
||||
START_DFU = 1
|
||||
INITIALIZE_DFU = 2
|
||||
RECEIVE_FIRMWARE_IMAGE = 3
|
||||
VALIDATE_FIRMWARE = 4
|
||||
ACTIVATE_IMAGE_AND_RESET = 5
|
||||
RESET_SYSTEM = 6
|
||||
REPORT_RECEIVED_IMAGE_SIZE = 7
|
||||
PRN_REQUEST = 8
|
||||
RESPONSE = 16
|
||||
PACKET_RECEIPT_NOTIFICATION = 17
|
||||
|
||||
string_map = {
|
||||
START_DFU : "START_DFU",
|
||||
INITIALIZE_DFU : "INITIALIZE_DFU",
|
||||
RECEIVE_FIRMWARE_IMAGE : "RECEIVE_FIRMWARE_IMAGE",
|
||||
VALIDATE_FIRMWARE : "VALIDATE_FIRMWARE",
|
||||
ACTIVATE_IMAGE_AND_RESET : "ACTIVATE_IMAGE_AND_RESET",
|
||||
RESET_SYSTEM : "RESET_SYSTEM",
|
||||
REPORT_RECEIVED_IMAGE_SIZE : "REPORT_RECEIVED_IMAGE_SIZE",
|
||||
PRN_REQUEST : "PACKET_RECEIPT_NOTIFICATION_REQUEST",
|
||||
RESPONSE : "RESPONSE",
|
||||
PACKET_RECEIPT_NOTIFICATION : "PACKET_RECEIPT_NOTIFICATION",
|
||||
}
|
||||
|
||||
@staticmethod
|
||||
def to_string(proc):
|
||||
return Procedures.string_map[proc]
|
||||
|
||||
@staticmethod
|
||||
def from_string(proc_str):
|
||||
return int(proc_str, 16)
|
||||
|
||||
class Responses:
|
||||
SUCCESS = 1
|
||||
INVALID_STATE = 2
|
||||
NOT_SUPPORTED = 3
|
||||
DATA_SIZE_EXCEEDS_LIMITS = 4
|
||||
CRC_ERROR = 5
|
||||
OPERATION_FAILED = 6
|
||||
|
||||
string_map = {
|
||||
SUCCESS : "SUCCESS",
|
||||
INVALID_STATE : "INVALID_STATE",
|
||||
NOT_SUPPORTED : "NOT_SUPPORTED",
|
||||
DATA_SIZE_EXCEEDS_LIMITS : "DATA_SIZE_EXCEEDS_LIMITS",
|
||||
CRC_ERROR : "CRC_ERROR",
|
||||
OPERATION_FAILED : "OPERATION_FAILED",
|
||||
}
|
||||
|
||||
@staticmethod
|
||||
def to_string(res):
|
||||
return Responses.string_map[res]
|
||||
|
||||
@staticmethod
|
||||
def from_string(res_str):
|
||||
return int(res_str, 16)
|
||||
|
||||
|
||||
class BleDfuControllerLegacy(NrfBleDfuController):
|
||||
# Class constants
|
||||
UUID_CONTROL_POINT = "00001531-1212-efde-1523-785feabcd123"
|
||||
UUID_PACKET = "00001532-1212-efde-1523-785feabcd123"
|
||||
UUID_VERSION = "00001534-1212-efde-1523-785feabcd123"
|
||||
|
||||
# Constructor inherited from abstract base class
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# Start the firmware update process
|
||||
# --------------------------------------------------------------------------
|
||||
def start(self, verbose=False):
|
||||
(_, self.ctrlpt_handle, self.ctrlpt_cccd_handle) = self._get_handles(self.UUID_CONTROL_POINT)
|
||||
(_, self.data_handle, _) = self._get_handles(self.UUID_PACKET)
|
||||
|
||||
self.pkt_receipt_interval = 10
|
||||
|
||||
if verbose:
|
||||
print('Control Point Handle: 0x%04x, CCCD: 0x%04x' % (self.ctrlpt_handle, self.ctrlpt_cccd_handle))
|
||||
print('Packet handle: 0x%04x' % (self.data_handle))
|
||||
|
||||
# Subscribe to notifications from Control Point characteristic
|
||||
if verbose: print("Enabling notifications")
|
||||
self._enable_notifications(self.ctrlpt_cccd_handle)
|
||||
|
||||
# Send 'START DFU' + Application Command
|
||||
if verbose: print("Sending START_DFU")
|
||||
self._dfu_send_command(Procedures.START_DFU, [0x04])
|
||||
|
||||
# Transmit binary image size
|
||||
# Need to pad the byte array with eight zero bytes
|
||||
# (because that's what the bootloader is expecting...)
|
||||
hex_size_array_lsb = uint32_to_bytes_le(len(self.bin_array))
|
||||
zero_pad_array_le(hex_size_array_lsb, 8)
|
||||
self._dfu_send_data(hex_size_array_lsb)
|
||||
|
||||
# Wait for response to Image Size
|
||||
print("Waiting for Image Size notification")
|
||||
self._wait_and_parse_notify()
|
||||
|
||||
# Send 'INIT DFU' + Init Packet Command
|
||||
self._dfu_send_command(Procedures.INITIALIZE_DFU, [0x00])
|
||||
|
||||
# Transmit the Init image (DAT).
|
||||
self._dfu_send_init()
|
||||
|
||||
# Send 'INIT DFU' + Init Packet Complete Command
|
||||
self._dfu_send_command(Procedures.INITIALIZE_DFU, [0x01])
|
||||
|
||||
print("Waiting for INIT DFU notification")
|
||||
# Wait for INIT DFU notification (indicates flash erase completed)
|
||||
self._wait_and_parse_notify()
|
||||
|
||||
# Set the Packet Receipt Notification interval
|
||||
if verbose: print("Setting pkt receipt notification interval")
|
||||
prn = uint16_to_bytes_le(self.pkt_receipt_interval)
|
||||
self._dfu_send_command(Procedures.PRN_REQUEST, prn)
|
||||
|
||||
# Send 'RECEIVE FIRMWARE IMAGE' command to set DFU in firmware receive state.
|
||||
self._dfu_send_command(Procedures.RECEIVE_FIRMWARE_IMAGE)
|
||||
|
||||
# Send bin_array contents as as series of packets (burst mode).
|
||||
# Each segment is pkt_payload_size bytes long.
|
||||
# For every pkt_receipt_interval sends, wait for notification.
|
||||
segment_count = 0
|
||||
segment_total = int(math.ceil(self.image_size/float(self.pkt_payload_size)))
|
||||
time_start = time.time()
|
||||
last_send_time = time.time()
|
||||
print("Begin DFU")
|
||||
for i in range(0, self.image_size, self.pkt_payload_size):
|
||||
segment = self.bin_array[i:i + self.pkt_payload_size]
|
||||
self._dfu_send_data(segment)
|
||||
segment_count += 1
|
||||
|
||||
# print "segment #{} of {}, dt = {}".format(segment_count, segment_total, time.time() - last_send_time)
|
||||
# last_send_time = time.time()
|
||||
|
||||
if (segment_count == segment_total):
|
||||
print_progress(self.image_size, self.image_size, prefix = 'Progress:', suffix = 'Complete', barLength = 50)
|
||||
|
||||
duration = time.time() - time_start
|
||||
print("\nUpload complete in {} minutes and {} seconds".format(int(duration / 60), int(duration % 60)))
|
||||
if verbose: print("segments sent: {}".format(segment_count))
|
||||
|
||||
print("Waiting for DFU complete notification")
|
||||
# Wait for DFU complete notification
|
||||
self._wait_and_parse_notify()
|
||||
|
||||
elif (segment_count % self.pkt_receipt_interval) == 0:
|
||||
(proc, res, pkts) = self._wait_and_parse_notify()
|
||||
|
||||
# TODO: Check pkts == segment_count * pkt_payload_size
|
||||
|
||||
if res != Responses.SUCCESS:
|
||||
raise Exception("bad notification status: {}".format(Responses.to_string(res)))
|
||||
|
||||
print_progress(pkts, self.image_size, prefix = 'Progress:', suffix = 'Complete', barLength = 50)
|
||||
|
||||
# Send Validate Command
|
||||
self._dfu_send_command(Procedures.VALIDATE_FIRMWARE)
|
||||
|
||||
print("Waiting for Firmware Validation notification")
|
||||
# Wait for Firmware Validation notification
|
||||
self._wait_and_parse_notify()
|
||||
|
||||
# Wait a bit for copy on the peer to be finished
|
||||
time.sleep(1)
|
||||
|
||||
# Send Activate and Reset Command
|
||||
print("Activate and reset")
|
||||
self._dfu_send_command(Procedures.ACTIVATE_IMAGE_AND_RESET)
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# Check if the peripheral is running in bootloader (DFU) or application mode
|
||||
# Returns True if the peripheral is in DFU mode
|
||||
# --------------------------------------------------------------------------
|
||||
def check_DFU_mode(self):
|
||||
if verbose: print("Checking DFU State...")
|
||||
|
||||
cmd = 'char-read-uuid %s' % self.UUID_VERSION
|
||||
|
||||
if verbose: print(cmd)
|
||||
|
||||
self.ble_conn.sendline(cmd)
|
||||
|
||||
# Skip two rows
|
||||
try:
|
||||
res = self.ble_conn.expect('handle:.*', timeout=10)
|
||||
# res = self.ble_conn.expect('handle:', timeout=10)
|
||||
except pexpect.TIMEOUT as e:
|
||||
print("State timeout")
|
||||
except:
|
||||
pass
|
||||
|
||||
return self.ble_conn.after.find(b'value: 08 00')!=-1
|
||||
|
||||
def switch_to_dfu_mode(self):
|
||||
(_, bl_value_handle, bl_cccd_handle) = self._get_handles(self.UUID_CONTROL_POINT)
|
||||
|
||||
# Enable notifications
|
||||
cmd = 'char-write-req 0x%02x %02x' % (bl_cccd_handle, 1)
|
||||
if verbose: print(cmd)
|
||||
self.ble_conn.sendline(cmd)
|
||||
|
||||
# Reset the board in DFU mode. After reset the board will be disconnected
|
||||
cmd = 'char-write-req 0x%02x 0104' % (bl_value_handle)
|
||||
if verbose: print(cmd)
|
||||
self.ble_conn.sendline(cmd)
|
||||
|
||||
time.sleep(0.5)
|
||||
|
||||
#print "Send 'START DFU' + Application Command"
|
||||
#self._dfu_state_set(0x0104)
|
||||
|
||||
# Reconnect the board.
|
||||
#ret = self.scan_and_connect()
|
||||
#if verbose: print("Connected " + str(ret))
|
||||
|
||||
#return ret
|
||||
return 1
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# Parse notification status results
|
||||
# --------------------------------------------------------------------------
|
||||
def _dfu_parse_notify(self, notify):
|
||||
if len(notify) < 3:
|
||||
print("notify data length error")
|
||||
return None
|
||||
|
||||
if verbose: print(notify)
|
||||
|
||||
dfu_notify_opcode = Procedures.from_string(notify[0])
|
||||
|
||||
if dfu_notify_opcode == Procedures.RESPONSE:
|
||||
|
||||
dfu_procedure = Procedures.from_string(notify[1])
|
||||
dfu_response = Responses.from_string(notify[2])
|
||||
|
||||
procedure_str = Procedures.to_string(dfu_procedure)
|
||||
response_str = Responses.to_string(dfu_response)
|
||||
|
||||
if verbose: print("opcode: 0x%02x, proc: %s, res: %s" % (dfu_notify_opcode, procedure_str, response_str))
|
||||
|
||||
return (dfu_procedure, dfu_response)
|
||||
|
||||
if dfu_notify_opcode == Procedures.PACKET_RECEIPT_NOTIFICATION:
|
||||
receipt = bytes_to_uint32_le(notify[1:5])
|
||||
return (dfu_notify_opcode, Responses.SUCCESS, receipt)
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# Wait for a notification and parse the response
|
||||
# --------------------------------------------------------------------------
|
||||
def _wait_and_parse_notify(self):
|
||||
if verbose: print("Waiting for notification")
|
||||
notify = self._dfu_wait_for_notify()
|
||||
|
||||
if notify is None:
|
||||
raise Exception("No notification received")
|
||||
|
||||
if verbose: print("Parsing notification")
|
||||
|
||||
result = self._dfu_parse_notify(notify)
|
||||
if result[1] != Responses.SUCCESS:
|
||||
raise Exception("Error in {} procedure, reason: {}".format(
|
||||
Procedures.to_string(result[0]),
|
||||
Responses.to_string(result[1])))
|
||||
|
||||
return result
|
||||
|
||||
#--------------------------------------------------------------------------
|
||||
# Send the Init info (*.dat file contents) to peripheral device.
|
||||
#--------------------------------------------------------------------------
|
||||
def _dfu_send_init(self):
|
||||
if verbose: print("dfu_send_init")
|
||||
|
||||
# Open the DAT file and create array of its contents
|
||||
init_bin_array = array('B', open(self.datfile_path, 'rb').read())
|
||||
|
||||
# Transmit Init info
|
||||
self._dfu_send_data(init_bin_array)
|
323
bootloader/ota-dfu-python/ble_secure_dfu_controller.py
Normal file
323
bootloader/ota-dfu-python/ble_secure_dfu_controller.py
Normal file
|
@ -0,0 +1,323 @@
|
|||
import math
|
||||
import pexpect
|
||||
import time
|
||||
|
||||
from array import array
|
||||
from util import *
|
||||
|
||||
from nrf_ble_dfu_controller import NrfBleDfuController
|
||||
|
||||
verbose = False
|
||||
|
||||
class Procedures:
|
||||
CREATE = 0x01
|
||||
SET_PRN = 0x02
|
||||
CALC_CHECKSUM = 0x03
|
||||
EXECUTE = 0x04
|
||||
SELECT = 0x06
|
||||
RESPONSE = 0x60
|
||||
|
||||
PARAM_COMMAND = 0x01
|
||||
PARAM_DATA = 0x02
|
||||
|
||||
string_map = {
|
||||
CREATE : "CREATE",
|
||||
SET_PRN : "SET_PRN",
|
||||
CALC_CHECKSUM : "CALC_CHECKSUM",
|
||||
EXECUTE : "EXECUTE",
|
||||
SELECT : "SELECT",
|
||||
RESPONSE : "RESPONSE",
|
||||
}
|
||||
|
||||
@staticmethod
|
||||
def to_string(proc):
|
||||
return Procedures.string_map[proc]
|
||||
|
||||
@staticmethod
|
||||
def from_string(proc_str):
|
||||
return int(proc_str, 16)
|
||||
|
||||
class Results:
|
||||
INVALID_CODE = 0x00
|
||||
SUCCESS = 0x01
|
||||
OPCODE_NOT_SUPPORTED = 0x02
|
||||
INVALID_PARAMETER = 0x03
|
||||
INSUFF_RESOURCES = 0x04
|
||||
INVALID_OBJECT = 0x05
|
||||
UNSUPPORTED_TYPE = 0x07
|
||||
OPERATION_NOT_PERMITTED = 0x08
|
||||
OPERATION_FAILED = 0x0A
|
||||
|
||||
string_map = {
|
||||
INVALID_CODE : "INVALID_CODE",
|
||||
SUCCESS : "SUCCESS",
|
||||
OPCODE_NOT_SUPPORTED : "OPCODE_NOT_SUPPORTED",
|
||||
INVALID_PARAMETER : "INVALID_PARAMETER",
|
||||
INSUFF_RESOURCES : "INSUFFICIENT_RESOURCES",
|
||||
INVALID_OBJECT : "INVALID_OBJECT",
|
||||
UNSUPPORTED_TYPE : "UNSUPPORTED_TYPE",
|
||||
OPERATION_NOT_PERMITTED : "OPERATION_NOT_PERMITTED",
|
||||
OPERATION_FAILED : "OPERATION_FAILED",
|
||||
}
|
||||
|
||||
@staticmethod
|
||||
def to_string(res):
|
||||
return Results.string_map[res]
|
||||
|
||||
@staticmethod
|
||||
def from_string(res_str):
|
||||
return int(res_str, 16)
|
||||
|
||||
|
||||
class BleDfuControllerSecure(NrfBleDfuController):
|
||||
# Class constants
|
||||
UUID_BUTTONLESS = '8e400001-f315-4f60-9fb8-838830daea50'
|
||||
UUID_CONTROL_POINT = '8ec90001-f315-4f60-9fb8-838830daea50'
|
||||
UUID_PACKET = '8ec90002-f315-4f60-9fb8-838830daea50'
|
||||
|
||||
# Constructor inherited from abstract base class
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# Start the firmware update process
|
||||
# --------------------------------------------------------------------------
|
||||
def start(self):
|
||||
(_, self.ctrlpt_handle, self.ctrlpt_cccd_handle) = self._get_handles(self.UUID_CONTROL_POINT)
|
||||
(_, self.data_handle, _) = self._get_handles(self.UUID_PACKET)
|
||||
|
||||
if verbose:
|
||||
print('Control Point Handle: 0x%04x, CCCD: 0x%04x' % (self.ctrlpt_handle, self.ctrlpt_cccd_handle))
|
||||
print('Packet handle: 0x%04x' % (self.data_handle))
|
||||
|
||||
# Subscribe to notifications from Control Point characteristic
|
||||
self._enable_notifications(self.ctrlpt_cccd_handle)
|
||||
|
||||
# Set the Packet Receipt Notification interval
|
||||
prn = uint16_to_bytes_le(self.pkt_receipt_interval)
|
||||
self._dfu_send_command(Procedures.SET_PRN, prn)
|
||||
|
||||
self._dfu_send_init()
|
||||
|
||||
self._dfu_send_image()
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# Check if the peripheral is running in bootloader (DFU) or application mode
|
||||
# Returns True if the peripheral is in DFU mode
|
||||
# --------------------------------------------------------------------------
|
||||
def check_DFU_mode(self):
|
||||
print("Checking DFU State...")
|
||||
|
||||
self.ble_conn.sendline('characteristics')
|
||||
|
||||
dfu_mode = False
|
||||
|
||||
try:
|
||||
self.ble_conn.expect([self.UUID_BUTTONLESS], timeout=2)
|
||||
except pexpect.TIMEOUT as e:
|
||||
dfu_mode = True
|
||||
|
||||
return dfu_mode
|
||||
|
||||
def switch_to_dfu_mode(self):
|
||||
(_, bl_value_handle, bl_cccd_handle) = self._get_handles(self.UUID_BUTTONLESS)
|
||||
|
||||
self._enable_notifications(bl_cccd_handle)
|
||||
|
||||
# Reset the board in DFU mode. After reset the board will be disconnected
|
||||
cmd = 'char-write-req 0x%04x 01' % (bl_value_handle)
|
||||
self.ble_conn.sendline(cmd)
|
||||
|
||||
# Wait some time for board to reboot
|
||||
time.sleep(0.5)
|
||||
|
||||
# Increase the mac address by one and reconnect
|
||||
self.target_mac_increase(1)
|
||||
return self.scan_and_connect()
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# Parse notification status results
|
||||
# --------------------------------------------------------------------------
|
||||
def _dfu_parse_notify(self, notify):
|
||||
if len(notify) < 3:
|
||||
print("notify data length error")
|
||||
return None
|
||||
|
||||
if verbose: print(notify)
|
||||
|
||||
dfu_notify_opcode = Procedures.from_string(notify[0])
|
||||
if dfu_notify_opcode == Procedures.RESPONSE:
|
||||
|
||||
dfu_procedure = Procedures.from_string(notify[1])
|
||||
dfu_result = Results.from_string(notify[2])
|
||||
|
||||
procedure_str = Procedures.to_string(dfu_procedure)
|
||||
result_str = Results.to_string(dfu_result)
|
||||
|
||||
# if verbose: print "opcode: {0}, proc: {1}, res: {2}".format(dfu_notify_opcode, procedure_str, result_str)
|
||||
if verbose: print("opcode: 0x%02x, proc: %s, res: %s" % (dfu_notify_opcode, procedure_str, result_str))
|
||||
|
||||
# Packet Receipt notifications are sent in the exact same format
|
||||
# as responses to the CALC_CHECKSUM procedure.
|
||||
if(dfu_procedure == Procedures.CALC_CHECKSUM and dfu_result == Results.SUCCESS):
|
||||
offset = bytes_to_uint32_le(notify[3:7])
|
||||
crc32 = bytes_to_uint32_le(notify[7:11])
|
||||
|
||||
return (dfu_procedure, dfu_result, offset, crc32)
|
||||
|
||||
elif(dfu_procedure == Procedures.SELECT and dfu_result == Results.SUCCESS):
|
||||
max_size = bytes_to_uint32_le(notify[3:7])
|
||||
offset = bytes_to_uint32_le(notify[7:11])
|
||||
crc32 = bytes_to_uint32_le(notify[11:15])
|
||||
|
||||
return (dfu_procedure, dfu_result, max_size, offset, crc32)
|
||||
|
||||
else:
|
||||
return (dfu_procedure, dfu_result)
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# Wait for a notification and parse the response
|
||||
# --------------------------------------------------------------------------
|
||||
def _wait_and_parse_notify(self):
|
||||
if verbose: print("Waiting for notification")
|
||||
notify = self._dfu_wait_for_notify()
|
||||
|
||||
if notify is None:
|
||||
raise Exception("No notification received")
|
||||
|
||||
if verbose: print("Parsing notification")
|
||||
|
||||
result = self._dfu_parse_notify(notify)
|
||||
if result[1] != Results.SUCCESS:
|
||||
raise Exception("Error in {} procedure, reason: {}".format(
|
||||
Procedures.to_string(result[0]),
|
||||
Results.to_string(result[1])))
|
||||
|
||||
return result
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# Send the Init info (*.dat file contents) to peripheral device.
|
||||
# --------------------------------------------------------------------------
|
||||
def _dfu_send_init(self):
|
||||
if verbose: print("dfu_send_init")
|
||||
|
||||
# Open the DAT file and create array of its contents
|
||||
init_bin_array = array('B', open(self.datfile_path, 'rb').read())
|
||||
init_size = len(init_bin_array)
|
||||
init_crc = 0;
|
||||
|
||||
# Select command
|
||||
self._dfu_send_command(Procedures.SELECT, [Procedures.PARAM_COMMAND]);
|
||||
(proc, res, max_size, offset, crc32) = self._wait_and_parse_notify()
|
||||
|
||||
if offset != init_size or crc32 != init_crc:
|
||||
if offset == 0 or offset > init_size:
|
||||
# Create command
|
||||
self._dfu_send_command(Procedures.CREATE, [Procedures.PARAM_COMMAND] + uint32_to_bytes_le(init_size))
|
||||
res = self._wait_and_parse_notify()
|
||||
|
||||
segment_count = 0
|
||||
segment_total = int(math.ceil(init_size/float(self.pkt_payload_size)))
|
||||
|
||||
for i in range(0, init_size, self.pkt_payload_size):
|
||||
segment = init_bin_array[i:i + self.pkt_payload_size]
|
||||
self._dfu_send_data(segment)
|
||||
segment_count += 1
|
||||
|
||||
if (segment_count % self.pkt_receipt_interval) == 0:
|
||||
(proc, res, offset, crc32) = self._wait_and_parse_notify()
|
||||
|
||||
if res != Results.SUCCESS:
|
||||
raise Exception("bad notification status: {}".format(Results.to_string(res)))
|
||||
|
||||
# Calculate CRC
|
||||
self._dfu_send_command(Procedures.CALC_CHECKSUM)
|
||||
self._wait_and_parse_notify()
|
||||
|
||||
# Execute command
|
||||
self._dfu_send_command(Procedures.EXECUTE)
|
||||
self._wait_and_parse_notify()
|
||||
|
||||
print("Init packet successfully transfered")
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# Send the Firmware image to peripheral device.
|
||||
# --------------------------------------------------------------------------
|
||||
def _dfu_send_image(self):
|
||||
if verbose: print("dfu_send_image")
|
||||
|
||||
# Select Data Object
|
||||
self._dfu_send_command(Procedures.SELECT, [Procedures.PARAM_DATA])
|
||||
(proc, res, max_size, offset, crc32) = self._wait_and_parse_notify()
|
||||
|
||||
# Split the firmware into multiple objects
|
||||
num_objects = int(math.ceil(self.image_size / float(max_size)))
|
||||
print("Max object size: %d, num objects: %d, offset: %d, total size: %d" % (max_size, num_objects, offset, self.image_size))
|
||||
|
||||
time_start = time.time()
|
||||
last_send_time = time.time()
|
||||
|
||||
obj_offset = (offset/max_size)*max_size
|
||||
while(obj_offset < self.image_size):
|
||||
# print "\nSending object {} of {}".format(obj_offset/max_size+1, num_objects)
|
||||
obj_offset += self._dfu_send_object(obj_offset, max_size)
|
||||
|
||||
# Image uploaded successfully, update the progress bar
|
||||
print_progress(self.image_size, self.image_size, prefix = 'Progress:', suffix = 'Complete', barLength = 50)
|
||||
|
||||
duration = time.time() - time_start
|
||||
print("\nUpload complete in {} minutes and {} seconds".format(int(duration / 60), int(duration % 60)))
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# Send a single data object of given size and offset.
|
||||
# --------------------------------------------------------------------------
|
||||
def _dfu_send_object(self, offset, obj_max_size):
|
||||
if offset != self.image_size:
|
||||
if offset == 0 or offset >= obj_max_size or crc32 != crc32_unsigned(self.bin_array[0:offset]):
|
||||
# Create Data Object
|
||||
size = min(obj_max_size, self.image_size - offset)
|
||||
self._dfu_send_command(Procedures.CREATE, [Procedures.PARAM_DATA] + uint32_to_bytes_le(size))
|
||||
self._wait_and_parse_notify()
|
||||
|
||||
segment_count = 0
|
||||
segment_total = int(math.ceil(min(obj_max_size, self.image_size-offset)/float(self.pkt_payload_size)))
|
||||
|
||||
segment_begin = offset
|
||||
segment_end = min(offset+obj_max_size, self.image_size)
|
||||
|
||||
for i in range(segment_begin, segment_end, self.pkt_payload_size):
|
||||
num_bytes = min(self.pkt_payload_size, segment_end - i)
|
||||
segment = self.bin_array[i:i + num_bytes]
|
||||
self._dfu_send_data(segment)
|
||||
segment_count += 1
|
||||
|
||||
# print "j: {} i: {}, end: {}, bytes: {}, size: {} segment #{} of {}".format(
|
||||
# offset, i, segment_end, num_bytes, self.image_size, segment_count, segment_total)
|
||||
|
||||
if (segment_count % self.pkt_receipt_interval) == 0:
|
||||
try:
|
||||
(proc, res, offset, crc32) = self._wait_and_parse_notify()
|
||||
except e:
|
||||
# Likely no notification received, need to re-transmit object
|
||||
return 0
|
||||
|
||||
if res != Results.SUCCESS:
|
||||
raise Exception("bad notification status: {}".format(Results.to_string(res)))
|
||||
|
||||
if crc32 != crc32_unsigned(self.bin_array[0:offset]):
|
||||
# Something went wrong, need to re-transmit this object
|
||||
return 0
|
||||
|
||||
print_progress(offset, self.image_size, prefix = 'Progress:', suffix = 'Complete', barLength = 50)
|
||||
|
||||
# Calculate CRC
|
||||
self._dfu_send_command(Procedures.CALC_CHECKSUM)
|
||||
(proc, res, offset, crc32) = self._wait_and_parse_notify()
|
||||
if(crc32 != crc32_unsigned(self.bin_array[0:offset])):
|
||||
# Need to re-transmit object
|
||||
return 0
|
||||
|
||||
# Execute command
|
||||
self._dfu_send_command(Procedures.EXECUTE)
|
||||
self._wait_and_parse_notify()
|
||||
|
||||
# If everything executed correctly, return amount of bytes transfered
|
||||
return obj_max_size
|
188
bootloader/ota-dfu-python/dfu.py
Executable file
188
bootloader/ota-dfu-python/dfu.py
Executable file
|
@ -0,0 +1,188 @@
|
|||
#!/usr/bin/env python3
|
||||
"""
|
||||
------------------------------------------------------------------------------
|
||||
DFU Server for Nordic nRF51 based systems.
|
||||
Conforms to nRF51_SDK 11.0 BLE_DFU requirements.
|
||||
------------------------------------------------------------------------------
|
||||
"""
|
||||
import os, re
|
||||
import sys
|
||||
import optparse
|
||||
import time
|
||||
import math
|
||||
import traceback
|
||||
|
||||
from unpacker import Unpacker
|
||||
|
||||
from ble_secure_dfu_controller import BleDfuControllerSecure
|
||||
from ble_legacy_dfu_controller import BleDfuControllerLegacy
|
||||
|
||||
def main():
|
||||
|
||||
init_msg = """
|
||||
================================
|
||||
== ==
|
||||
== DFU Server ==
|
||||
== ==
|
||||
================================
|
||||
"""
|
||||
|
||||
# print "DFU Server start"
|
||||
print(init_msg)
|
||||
|
||||
try:
|
||||
parser = optparse.OptionParser(usage='%prog -f <hex_file> -a <dfu_target_address>\n\nExample:\n\tdfu.py -f application.hex -d application.dat -a cd:e3:4a:47:1c:e4',
|
||||
version='0.5')
|
||||
|
||||
parser.add_option('-a', '--address',
|
||||
action='store',
|
||||
dest="address",
|
||||
type="string",
|
||||
default=None,
|
||||
help='DFU target address.'
|
||||
)
|
||||
|
||||
parser.add_option('-f', '--file',
|
||||
action='store',
|
||||
dest="hexfile",
|
||||
type="string",
|
||||
default=None,
|
||||
help='hex file to be uploaded.'
|
||||
)
|
||||
|
||||
parser.add_option('-d', '--dat',
|
||||
action='store',
|
||||
dest="datfile",
|
||||
type="string",
|
||||
default=None,
|
||||
help='dat file to be uploaded.'
|
||||
)
|
||||
|
||||
parser.add_option('-z', '--zip',
|
||||
action='store',
|
||||
dest="zipfile",
|
||||
type="string",
|
||||
default=None,
|
||||
help='zip file to be used.'
|
||||
)
|
||||
|
||||
parser.add_option('--secure',
|
||||
action='store_true',
|
||||
dest='secure_dfu',
|
||||
default=True,
|
||||
help='Use secure bootloader (Nordic SDK > 12)'
|
||||
)
|
||||
|
||||
parser.add_option('--legacy',
|
||||
action='store_false',
|
||||
dest='secure_dfu',
|
||||
help='Use secure bootloader (Nordic SDK < 12)'
|
||||
)
|
||||
|
||||
options, args = parser.parse_args()
|
||||
|
||||
except Exception as e:
|
||||
print(e)
|
||||
print("For help use --help")
|
||||
sys.exit(2)
|
||||
|
||||
try:
|
||||
|
||||
''' Validate input parameters '''
|
||||
|
||||
if not options.address:
|
||||
parser.print_help()
|
||||
exit(2)
|
||||
|
||||
unpacker = None
|
||||
hexfile = None
|
||||
datfile = None
|
||||
|
||||
if options.zipfile != None:
|
||||
|
||||
if (options.hexfile != None) or (options.datfile != None):
|
||||
print("Conflicting input directives")
|
||||
exit(2)
|
||||
|
||||
unpacker = Unpacker()
|
||||
#print options.zipfile
|
||||
try:
|
||||
hexfile, datfile = unpacker.unpack_zipfile(options.zipfile)
|
||||
except Exception as e:
|
||||
print("ERR")
|
||||
print(e)
|
||||
pass
|
||||
|
||||
else:
|
||||
if (not options.hexfile) or (not options.datfile):
|
||||
parser.print_help()
|
||||
exit(2)
|
||||
|
||||
if not os.path.isfile(options.hexfile):
|
||||
print("Error: Hex file doesn't exist")
|
||||
exit(2)
|
||||
|
||||
if not os.path.isfile(options.datfile):
|
||||
print("Error: DAT file doesn't exist")
|
||||
exit(2)
|
||||
|
||||
hexfile = options.hexfile
|
||||
datfile = options.datfile
|
||||
|
||||
|
||||
''' Start of Device Firmware Update processing '''
|
||||
|
||||
if options.secure_dfu:
|
||||
ble_dfu = BleDfuControllerSecure(options.address.upper(), hexfile, datfile)
|
||||
else:
|
||||
ble_dfu = BleDfuControllerLegacy(options.address.upper(), hexfile, datfile)
|
||||
|
||||
# Initialize inputs
|
||||
ble_dfu.input_setup()
|
||||
|
||||
# Connect to peer device. Assume application mode.
|
||||
if ble_dfu.scan_and_connect():
|
||||
if not ble_dfu.check_DFU_mode():
|
||||
print("Need to switch to DFU mode")
|
||||
success = ble_dfu.switch_to_dfu_mode()
|
||||
if not success:
|
||||
print("Couldn't reconnect")
|
||||
else:
|
||||
# The device might already be in DFU mode (MAC + 1)
|
||||
ble_dfu.target_mac_increase(1)
|
||||
|
||||
# Try connection with new address
|
||||
print("Couldn't connect, will try DFU MAC")
|
||||
if not ble_dfu.scan_and_connect():
|
||||
raise Exception("Can't connect to device")
|
||||
|
||||
ble_dfu.start()
|
||||
|
||||
# Disconnect from peer device if not done already and clean up.
|
||||
ble_dfu.disconnect()
|
||||
|
||||
except Exception as e:
|
||||
# print traceback.format_exc()
|
||||
print("Exception at line {}: {}".format(sys.exc_info()[2].tb_lineno, e))
|
||||
pass
|
||||
|
||||
except:
|
||||
pass
|
||||
|
||||
# If Unpacker for zipfile used then delete Unpacker
|
||||
if unpacker != None:
|
||||
unpacker.delete()
|
||||
|
||||
print("DFU Server done")
|
||||
|
||||
"""
|
||||
------------------------------------------------------------------------------
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
"""
|
||||
if __name__ == '__main__':
|
||||
|
||||
# Do not litter the world with broken .pyc files.
|
||||
sys.dont_write_bytecode = True
|
||||
|
||||
main()
|
263
bootloader/ota-dfu-python/nrf_ble_dfu_controller.py
Normal file
263
bootloader/ota-dfu-python/nrf_ble_dfu_controller.py
Normal file
|
@ -0,0 +1,263 @@
|
|||
import os
|
||||
import pexpect
|
||||
import re
|
||||
|
||||
from abc import ABCMeta, abstractmethod
|
||||
from array import array
|
||||
from util import *
|
||||
|
||||
verbose = False
|
||||
|
||||
class NrfBleDfuController(object, metaclass=ABCMeta):
|
||||
ctrlpt_handle = 0
|
||||
ctrlpt_cccd_handle = 0
|
||||
data_handle = 0
|
||||
|
||||
pkt_receipt_interval = 10
|
||||
pkt_payload_size = 20
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# Start the firmware update process
|
||||
# --------------------------------------------------------------------------
|
||||
@abstractmethod
|
||||
def start(self):
|
||||
pass
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# Check if the peripheral is running in bootloader (DFU) or application mode
|
||||
# Returns True if the peripheral is in DFU mode
|
||||
# --------------------------------------------------------------------------
|
||||
@abstractmethod
|
||||
def check_DFU_mode(self):
|
||||
pass
|
||||
|
||||
@abstractmethod
|
||||
# --------------------------------------------------------------------------
|
||||
# Switch from application to bootloader (DFU)
|
||||
# --------------------------------------------------------------------------
|
||||
def switch_to_dfu_mode(self):
|
||||
pass
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# Parse notification status results
|
||||
# --------------------------------------------------------------------------
|
||||
@abstractmethod
|
||||
def _dfu_parse_notify(self, notify):
|
||||
pass
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# Wait for a notification and parse the response
|
||||
# --------------------------------------------------------------------------
|
||||
@abstractmethod
|
||||
def _wait_and_parse_notify(self):
|
||||
pass
|
||||
|
||||
def __init__(self, target_mac, firmware_path, datfile_path):
|
||||
self.target_mac = target_mac
|
||||
|
||||
self.firmware_path = firmware_path
|
||||
self.datfile_path = datfile_path
|
||||
|
||||
self.ble_conn = pexpect.spawn("gatttool -b '%s' -t random --interactive" % target_mac)
|
||||
self.ble_conn.delaybeforesend = 0
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# Start the firmware update process
|
||||
# --------------------------------------------------------------------------
|
||||
def start(self):
|
||||
(_, self.ctrlpt_handle, self.ctrlpt_cccd_handle) = self._get_handles(self.UUID_CONTROL_POINT)
|
||||
(_, self.data_handle, _) = self._get_handles(self.UUID_PACKET)
|
||||
|
||||
if verbose:
|
||||
print('Control Point Handle: 0x%04x, CCCD: 0x%04x' % (self.ctrlpt_handle, self.ctrlpt_cccd_handle))
|
||||
print('Packet handle: 0x%04x' % (self.data_handle))
|
||||
|
||||
# Subscribe to notifications from Control Point characteristic
|
||||
self._enable_notifications(self.ctrlpt_cccd_handle)
|
||||
|
||||
# Set the Packet Receipt Notification interval
|
||||
prn = uint16_to_bytes_le(self.pkt_receipt_interval)
|
||||
self._dfu_send_command(Procedures.SET_PRN, prn)
|
||||
|
||||
self._dfu_send_init()
|
||||
|
||||
self._dfu_send_image()
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# Initialize:
|
||||
# Hex: read and convert hexfile into bin_array
|
||||
# Bin: read binfile into bin_array
|
||||
# --------------------------------------------------------------------------
|
||||
def input_setup(self):
|
||||
print("Sending file " + os.path.split(self.firmware_path)[1] + " to " + self.target_mac)
|
||||
|
||||
if self.firmware_path == None:
|
||||
raise Exception("input invalid")
|
||||
|
||||
name, extent = os.path.splitext(self.firmware_path)
|
||||
|
||||
if extent == ".bin":
|
||||
self.bin_array = array('B', open(self.firmware_path, 'rb').read())
|
||||
|
||||
self.image_size = len(self.bin_array)
|
||||
print("Binary imge size: %d" % self.image_size)
|
||||
print("Binary CRC32: %d" % crc32_unsigned(array_to_hex_string(self.bin_array)))
|
||||
|
||||
return
|
||||
|
||||
if extent == ".hex":
|
||||
intelhex = IntelHex(self.firmware_path)
|
||||
self.bin_array = intelhex.tobinarray()
|
||||
self.image_size = len(self.bin_array)
|
||||
print("bin array size: ", self.image_size)
|
||||
return
|
||||
|
||||
raise Exception("input invalid")
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# Perform a scan and connect via gatttool.
|
||||
# Will return True if a connection was established, False otherwise
|
||||
# --------------------------------------------------------------------------
|
||||
def scan_and_connect(self, timeout=2):
|
||||
if verbose: print("scan_and_connect")
|
||||
|
||||
print("Connecting to %s" % (self.target_mac))
|
||||
|
||||
try:
|
||||
self.ble_conn.expect('\[LE\]>', timeout=timeout)
|
||||
except pexpect.TIMEOUT as e:
|
||||
return False
|
||||
|
||||
self.ble_conn.sendline('connect')
|
||||
|
||||
try:
|
||||
res = self.ble_conn.expect('.*Connection successful.*', timeout=timeout)
|
||||
except pexpect.TIMEOUT as e:
|
||||
return False
|
||||
|
||||
return True
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# Disconnect from the peripheral and close the gatttool connection
|
||||
# --------------------------------------------------------------------------
|
||||
def disconnect(self):
|
||||
self.ble_conn.sendline('exit')
|
||||
self.ble_conn.close()
|
||||
|
||||
def target_mac_increase(self, inc):
|
||||
self.target_mac = uint_to_mac_string(mac_string_to_uint(self.target_mac) + inc)
|
||||
|
||||
# Re-start gatttool with the new address
|
||||
self.disconnect()
|
||||
self.ble_conn = pexpect.spawn("gatttool -b '%s' -t random --interactive" % self.target_mac)
|
||||
self.ble_conn.delaybeforesend = 0
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# Fetch handles for a given UUID.
|
||||
# Will return a three-tuple: (char handle, value handle, CCCD handle)
|
||||
# Will raise an exception if the UUID is not found
|
||||
# --------------------------------------------------------------------------
|
||||
def _get_handles(self, uuid):
|
||||
self.ble_conn.before = ""
|
||||
self.ble_conn.sendline('characteristics')
|
||||
|
||||
try:
|
||||
self.ble_conn.expect([uuid], timeout=2)
|
||||
handles = re.findall(b'.*handle: (0x....),.*char value handle: (0x....)', self.ble_conn.before)
|
||||
(handle, value_handle) = handles[-1]
|
||||
except pexpect.TIMEOUT as e:
|
||||
raise Exception("UUID not found: {}".format(uuid))
|
||||
|
||||
return (int(handle, 16), int(value_handle, 16), int(value_handle, 16)+1)
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# Wait for notification to arrive.
|
||||
# Example format: "Notification handle = 0x0019 value: 10 01 01"
|
||||
# --------------------------------------------------------------------------
|
||||
def _dfu_wait_for_notify(self):
|
||||
while True:
|
||||
if verbose: print("dfu_wait_for_notify")
|
||||
|
||||
if not self.ble_conn.isalive():
|
||||
print("connection not alive")
|
||||
return None
|
||||
|
||||
try:
|
||||
index = self.ble_conn.expect('Notification handle = .*? \r\n', timeout=30)
|
||||
|
||||
except pexpect.TIMEOUT:
|
||||
#
|
||||
# The gatttool does not report link-lost directly.
|
||||
# The only way found to detect it is monitoring the prompt '[CON]'
|
||||
# and if it goes to '[ ]' this indicates the connection has
|
||||
# been broken.
|
||||
# In order to get a updated prompt string, issue an empty
|
||||
# sendline(''). If it contains the '[ ]' string, then
|
||||
# raise an exception. Otherwise, if not a link-lost condition,
|
||||
# continue to wait.
|
||||
#
|
||||
self.ble_conn.sendline('')
|
||||
string = self.ble_conn.before
|
||||
if '[ ]' in string:
|
||||
print('Connection lost! ')
|
||||
raise Exception('Connection Lost')
|
||||
return None
|
||||
|
||||
if index == 0:
|
||||
after = self.ble_conn.after
|
||||
hxstr = after.split()[3:]
|
||||
handle = int(float.fromhex(hxstr[0].decode('UTF-8')))
|
||||
return hxstr[2:]
|
||||
|
||||
else:
|
||||
print("unexpeced index: {0}".format(index))
|
||||
return None
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# Send a procedure + any parameters required
|
||||
# --------------------------------------------------------------------------
|
||||
def _dfu_send_command(self, procedure, params=[]):
|
||||
if verbose: print('_dfu_send_command')
|
||||
|
||||
cmd = 'char-write-req 0x%04x %02x' % (self.ctrlpt_handle, procedure)
|
||||
cmd += array_to_hex_string(params)
|
||||
|
||||
if verbose: print(cmd)
|
||||
|
||||
self.ble_conn.sendline(cmd)
|
||||
|
||||
# Verify that command was successfully written
|
||||
try:
|
||||
res = self.ble_conn.expect('Characteristic value was written successfully.*', timeout=10)
|
||||
except pexpect.TIMEOUT as e:
|
||||
print("State timeout")
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# Send an array of bytes
|
||||
# --------------------------------------------------------------------------
|
||||
def _dfu_send_data(self, data):
|
||||
cmd = 'char-write-cmd 0x%04x' % (self.data_handle)
|
||||
cmd += ' '
|
||||
cmd += array_to_hex_string(data)
|
||||
|
||||
if verbose: print(cmd)
|
||||
|
||||
self.ble_conn.sendline(cmd)
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# Enable notifications from the Control Point Handle
|
||||
# --------------------------------------------------------------------------
|
||||
def _enable_notifications(self, cccd_handle):
|
||||
if verbose: print('_enable_notifications')
|
||||
|
||||
cmd = 'char-write-req 0x%04x %s' % (cccd_handle, '0100')
|
||||
|
||||
if verbose: print(cmd)
|
||||
|
||||
self.ble_conn.sendline(cmd)
|
||||
|
||||
# Verify that command was successfully written
|
||||
try:
|
||||
res = self.ble_conn.expect('Characteristic value was written successfully.*', timeout=10)
|
||||
except pexpect.TIMEOUT as e:
|
||||
print("State timeout")
|
52
bootloader/ota-dfu-python/unpacker.py
Normal file
52
bootloader/ota-dfu-python/unpacker.py
Normal file
|
@ -0,0 +1,52 @@
|
|||
import os.path
|
||||
import zipfile
|
||||
import tempfile
|
||||
import random
|
||||
import string
|
||||
import shutil
|
||||
import re
|
||||
|
||||
from os.path import basename
|
||||
|
||||
class Unpacker(object):
|
||||
#--------------------------------------------------------------------------
|
||||
#
|
||||
#--------------------------------------------------------------------------
|
||||
def entropy(self, length):
|
||||
return ''.join(random.choice('abcdefghijklmnopqrstuvwxyz') for i in range (length))
|
||||
|
||||
#--------------------------------------------------------------------------
|
||||
#
|
||||
#--------------------------------------------------------------------------
|
||||
def unpack_zipfile(self, file):
|
||||
|
||||
if not os.path.isfile(file):
|
||||
raise Exception("Error: file, not found!")
|
||||
|
||||
# Create unique working direction into which the zip file is expanded
|
||||
self.unzip_dir = "{0}/{1}_{2}".format(tempfile.gettempdir(), os.path.splitext(basename(file))[0], self.entropy(6))
|
||||
|
||||
datfilename = ""
|
||||
binfilename = ""
|
||||
|
||||
with zipfile.ZipFile(file, 'r') as zip:
|
||||
files = [item.filename for item in zip.infolist()]
|
||||
datfilename = [m.group(0) for f in files for m in [re.search('.*\.dat', f)] if m].pop()
|
||||
binfilename = [m.group(0) for f in files for m in [re.search('.*\.bin', f)] if m].pop()
|
||||
|
||||
zip.extractall(r'{0}'.format(self.unzip_dir))
|
||||
|
||||
datfile = "{0}/{1}".format(self.unzip_dir, datfilename)
|
||||
binfile = "{0}/{1}".format(self.unzip_dir, binfilename)
|
||||
|
||||
# print "DAT file: " + datfile
|
||||
# print "BIN file: " + binfile
|
||||
|
||||
return binfile, datfile
|
||||
|
||||
#--------------------------------------------------------------------------
|
||||
#
|
||||
#--------------------------------------------------------------------------
|
||||
def delete(self):
|
||||
# delete self.unzip_dir and its contents
|
||||
shutil.rmtree(self.unzip_dir)
|
70
bootloader/ota-dfu-python/util.py
Normal file
70
bootloader/ota-dfu-python/util.py
Normal file
|
@ -0,0 +1,70 @@
|
|||
import sys
|
||||
import binascii
|
||||
import re
|
||||
|
||||
def bytes_to_uint32_le(bytes):
|
||||
return (int(bytes[3], 16) << 24) | (int(bytes[2], 16) << 16) | (int(bytes[1], 16) << 8) | (int(bytes[0], 16) << 0)
|
||||
|
||||
def uint32_to_bytes_le(uint32):
|
||||
return [(uint32 >> 0) & 0xff,
|
||||
(uint32 >> 8) & 0xff,
|
||||
(uint32 >> 16) & 0xff,
|
||||
(uint32 >> 24) & 0xff]
|
||||
|
||||
def uint16_to_bytes_le(value):
|
||||
return [(value >> 0 & 0xFF),
|
||||
(value >> 8 & 0xFF)]
|
||||
|
||||
def zero_pad_array_le(data, padsize):
|
||||
for i in range(0, padsize):
|
||||
data.insert(0, 0)
|
||||
|
||||
def array_to_hex_string(arr):
|
||||
hex_str = ""
|
||||
for val in arr:
|
||||
if val > 255:
|
||||
raise Exception("Value is greater than it is possible to represent with one byte")
|
||||
hex_str += "%02x" % val
|
||||
|
||||
return hex_str
|
||||
|
||||
def crc32_unsigned(bytestring):
|
||||
return binascii.crc32(bytestring.encode('UTF-8')) % (1 << 32)
|
||||
|
||||
def mac_string_to_uint(mac):
|
||||
parts = list(re.match('(..):(..):(..):(..):(..):(..)', mac).groups())
|
||||
ints = [int(x, 16) for x in parts]
|
||||
|
||||
res = 0
|
||||
for i in range(0, len(ints)):
|
||||
res += (ints[len(ints)-1 - i] << 8*i)
|
||||
|
||||
return res
|
||||
|
||||
def uint_to_mac_string(mac):
|
||||
ints = [0, 0, 0, 0, 0, 0]
|
||||
for i in range(0, len(ints)):
|
||||
ints[len(ints)-1 - i] = (mac >> 8*i) & 0xff
|
||||
|
||||
return ':'.join(['{:02x}'.format(x).upper() for x in ints])
|
||||
|
||||
# Print a nice console progress bar
|
||||
def print_progress(iteration, total, prefix = '', suffix = '', decimals = 1, barLength = 100):
|
||||
"""
|
||||
Call in a loop to create terminal progress bar
|
||||
@params:
|
||||
iteration - Required : current iteration (Int)
|
||||
total - Required : total iterations (Int)
|
||||
prefix - Optional : prefix string (Str)
|
||||
suffix - Optional : suffix string (Str)
|
||||
decimals - Optional : positive number of decimals in percent complete (Int)
|
||||
barLength - Optional : character length of bar (Int)
|
||||
"""
|
||||
formatStr = "{0:." + str(decimals) + "f}"
|
||||
percents = formatStr.format(100 * (iteration / float(total)))
|
||||
filledLength = int(round(barLength * iteration / float(total)))
|
||||
bar = 'x' * filledLength + '-' * (barLength - filledLength)
|
||||
sys.stdout.write('\r%s |%s| %s%s %s (%d of %d bytes)' % (prefix, bar, percents, '%', suffix, iteration, total)),
|
||||
if iteration == total:
|
||||
sys.stdout.write('\n')
|
||||
sys.stdout.flush()
|
Loading…
Reference in a new issue