bc127 (on working) manual firmware update

bc127 dfu update

#!/usr/local/bin/python3
# encoding: utf-8
'''
bc127upgrade -- shortdesc

bc127upgrade is a description

It defines classes_and_methods

@author:     Stefan

@copyright:  2018 All rights reserved.

@license:    GPL

@contact:    
@deffield    updated: Updated
'''

import sys
import os
import logging
import serial
import time
import math

from argparse import ArgumentParser
from argparse import RawDescriptionHelpFormatter

__all__ = []
__version__ = 0.1
__date__ = '2018-07-17'
__updated__ = '2018-07-17'

#################################
# logging magic
#################################
logger = logging.getLogger("bc127upgrade")

# create file handler which logs even debug messages
fh = logging.FileHandler('bc127upgrade.log', mode="w+")
fh.setLevel(logging.DEBUG)
#formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
formatter = logging.Formatter('%(asctime)s[%(levelname)s]: %(message)s')
fh.setFormatter(formatter)
# add the handlers to the logger
logger.addHandler(fh)
logger.setLevel(logging.DEBUG)

#################################
# exception handling
#################################

class CLIError(Exception):
    '''Generic exception to raise and log different fatal errors.'''
    def __init__(self, msg):
        super(CLIError).__init__(type(self))
        self.msg = "E: %s" % msg
    def __str__(self):
        return self.msg
    def __unicode__(self):
        return self.msg

#################################
# uart
#################################


uart = None
uart_timeout = 0.1

def uart_open(dev, br, p=serial.PARITY_NONE, rtscts=False):
    global uart
    if None != uart:
        uart.close()
    uart = serial.Serial(dev, br, parity=p,timeout=uart_timeout, rtscts=rtscts)

def uart_close():
    global uart
    uart.close()
    uart = None

def uart_sendData(bd):
    global uart
    uart.write(bd)
    
def uart_send(txt):
    global uart
    st = txt.replace("\n", "\r")
    uart.write(st.encode('utf-8'))
    
def uart_rx():
    global uart
    txt = uart.readall()
    return (txt.decode(encoding="utf-8")).replace("\r","\n")

def bc127_configUart(br):
    cfgStr = """CONFIG
SET UART_CONFIG={br} OFF 0
WRITE
RESET
""".format(br=br)
    uart_send(cfgStr)
    time.sleep(1)
    return uart_rx()
    

def bc127_getVersion():
    uart_send("VERSION\n")
    time.sleep(0.05)
    return uart_rx()


def bc127_dfu(dev, file):
    with open(file, "rb") as f:
        dfuImage = bytearray(f.read())
    ms = len(dfuImage)
    print("dfu file size "+str(ms)+"Bytes")
    tb = []
    bs = 1024
    am = math.ceil(ms / bs)
    si = 0
    ei = 0
    for i in range(0, am):
        ei += bs
        if ei > ms:
            ei = ms
        tb.append(dfuImage[si:ei])
        si += bs
#    uart_send("RESET\n")
#    uart_close()
    uart_open(dev, 9600, p=serial.PARITY_NONE)
    uart_send("DFU\n")
    uart_close()
    time.sleep(0.05)
    i = 0.0
    uart_open(dev, br=115200, p=serial.PARITY_EVEN, rtscts=True)
    print("dfu upgrade in process:\n")
#    for e in tb:
#        print("{p}% done".format(p=round(100.0*i/am, 2)))
#        sys.stdout.flush()
#        uart_sendData(e)
#        i +=1.0
    uart_sendData(dfuImage)
    print("dfu done")
    
def main(argv=None): # IGNORE:C0111
    
    logger.info("start")
    '''Command line options.'''

    if argv is None:
        argv = sys.argv
    else:
        sys.argv.extend(argv)

    program_name = os.path.basename(sys.argv[0])
    program_version = "v%s" % __version__
    program_build_date = str(__updated__)
    program_version_message = '%%(prog)s %s (%s)' % (program_version, program_build_date)
    program_shortdesc = __import__('__main__').__doc__.split("\n")[1]
    program_license = '''%s

  Created by user_name on %s.
  Copyright 2018 Kokoon All rights reserved.

USAGE
''' % (program_shortdesc, str(__date__))

    try:
        # Setup argument parser
        parser = ArgumentParser(description=program_license, formatter_class=RawDescriptionHelpFormatter)
        parser.add_argument('-V', '--version', action='version', version=program_version_message)
        parser.add_argument("-d", "--dev", type=str, help="the serial port", default="/dev/ttyUSB1")
        parser.add_argument("-f", "--dfufile", type=str, help="the firmware(dfu) file", default="/home/stefan/Downloads/1526921906_Melody_7_1_STANDARD.dfu")

        args = parser.parse_args()
        dfufile = args.dfufile 
        dev = args.dev
        uart_open(dev, 9600)
        #uart_open("/dev/ttyUSB0", 9600)
        ver = bc127_getVersion()
        print(ver)
        bc127_dfu(dev, dfufile)
        #ver = bc127_getVersion()
        #print(ver)
        #uart_send(cfgStr)
        #res = uart_rx()
        #print(res)
        #print("success")
        return 0
    except KeyboardInterrupt:
        ### handle keyboard interrupt ###
        return 0
    except Exception as e:
        indent = len(program_name) * " "
        sys.stderr.write(program_name + ": " + repr(e) + "\n")
        sys.stderr.write(indent + "  for help use --help")
        return 2

if __name__ == "__main__":
    rc = main()
    sys.exit(rc)