alpaca_isp/alpaca_isp/__init__.py

# Copyright 2017 Clayton G. Hobbs
# 
# 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.
"""In-system programming tool for LPC microcontrollers"""

__author__ = "Clayton G. Hobbs"
__version__ = "0"

import argparse
import sys

from alpaca_isp.chips import chips
from alpaca_isp.exceptions import *
from alpaca_isp.lpc import *


def create_lpc(tty, baudrate=DEFAULT_BAUDRATE, clock=DEFAULT_CLOCK,
        timeout=DEFAULT_TIMEOUT, control=False, try_sync=None,
        verbose=False):
    """Create an object of the appropriate LPC subclass for the chip"""
    # Open the LPC
    lpc = LPC(tty, baudrate=baudrate, clock=clock, timeout=timeout)
    lpc.open()

    # Enter ISP mode if we've been asked to
    if control:
        lpc.enter_isp()

    # Synchronize with the microcontroller
    if verbose:
        print("Synchronizing", end="", flush=True)
    try:
        lpc.synchronize(max_tries=try_sync, verbose=verbose)
    except RecvTimeout:
        lpc.close()
        if verbose:
            print(" failed")
        sys.exit(1)
    if verbose:
        print()

    # Turn the LPC object into the right type
    chip = chips[lpc.part_id]
    return chip.family(lpc, chip)



def main():
    """Entry point for Alpaca ISP command line tool"""
    # Make the argument parser
    parser = argparse.ArgumentParser(
            description="Flash an LPC microcontroller")
    parser.add_argument("file", metavar="file", nargs="+", type=str,
            help="Intel HEX file to flash to the microcontroller")
    parser.add_argument("tty", metavar="tty", type=str,
            help="the tty to which the microcontroller is attached")
    parser.add_argument("-b", "--baudrate", type=int,
            default=DEFAULT_BAUDRATE,
            help="baud rate used for communication (default: %(default)s)")
    parser.add_argument("-c", "--clock-khz", type=int, default=DEFAULT_CLOCK,
            help="microcontroller's clock frequency in kHz "
            "(default: %(default)s)")
    parser.add_argument("-t", "--timeout", type=float,
            default=DEFAULT_TIMEOUT,
            help="timeout for reading data from the microcontroller in "
            "seconds (default: %(default)s)")
    parser.add_argument("-e", "--erase", action="store_true",
            help="erase all the microcontroller's flash before flashing")
    parser.add_argument("--no-start", action="store_true",
            help="do not start the microcontroller after flashing")
    parser.add_argument("--try-sync", type=int,
            help="maximum number of tries to synchronize with the "
            "microcontroller")
    parser.add_argument("--control", action="store_true",
            help="control RS232 lines to enter ISP mode (/RST = DTR, /ISP = "
            "RTS)")
    parser.add_argument("--verify", action="store_true",
            help="verify that the data were written correctly after flashing")

    # Parse arguments
    args = parser.parse_args()

    # Open the LPC
    lpc = create_lpc(args.tty, baudrate=args.baudrate, clock=args.clock_khz,
            timeout=args.timeout, control=args.control, try_sync=args.try_sync,
            verbose=True)

    # Unlock the chip
    lpc.unlock()

    # Erase the flash if we've been asked to
    if args.erase:
        lpc.prepare_write()
        lpc.erase()

    # TODO: write the file to flash

    # Start the program if we haven't been asked not to
    if not args.no_start:
        lpc.go()

    lpc.close()