Load firmware Examples

Load firmware through CANopen Example

import argparse

from ingenialink.canopen.network import CAN_BAUDRATE, CAN_DEVICE, CanopenNetwork


def print_status_message(msg: str) -> None:
    """Example of a callback function."""
    print(f"Current status message: {msg}")


def print_progress(value: int) -> None:
    """Example of a callback function."""
    print(f"Progress: {value}")


def print_progress_total(value: str) -> None:
    """Example of a callback function."""
    print(f"Total progress to be done: {value}")


def print_errors_enabled(value: int) -> None:
    """Example of a callback function."""
    print(f"Errors enabled: {value}")


def load_firmware_example(args: argparse.Namespace) -> None:
    """Loads a firmware to an already connected drive."""
    can_device = CAN_DEVICE(args.transceiver)
    can_baudrate = CAN_BAUDRATE(args.baudrate)
    net = CanopenNetwork(device=can_device, channel=args.channel, baudrate=can_baudrate)

    nodes = net.scan_slaves()
    print(nodes)

    if len(nodes) > 0:
        servo = net.connect_to_slave(target=args.node_id, dictionary=args.dictionary_path)

        fw_version = servo.read("DRV_ID_SOFTWARE_VERSION")
        print("Firmware version before loading new firmware", fw_version)

        net.load_firmware(
            args.node_id,
            args.firmware_path,
            print_status_message,
            print_progress,
            print_errors_enabled,
        )

        fw_version = servo.read("DRV_ID_SOFTWARE_VERSION")
        print("Firmware version after loading new firmware", fw_version)

        net.disconnect_from_slave(servo)
    else:
        print("Could not find any nodes")


def load_firmware_example_disconnected() -> None:
    """Loads a firmware to a disconnected drive."""
    net = CanopenNetwork(device=CAN_DEVICE.IXXAT, channel=0, baudrate=CAN_BAUDRATE.Baudrate_1M)
    net.load_firmware(
        32,
        "../../resources/firmware/eve-net-c_1.8.1.sfu",
        print_status_message,
        print_progress,
        print_errors_enabled,
    )


def setup_command() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="Canopen example")
    parser.add_argument("-d", "--dictionary_path", help="Path to drive dictionary", required=True)
    parser.add_argument("-f", "--firmware_path", help="Path to the firmware file", required=True)
    parser.add_argument("-n", "--node_id", default=32, type=int, help="Node ID")
    parser.add_argument(
        "-t",
        "--transceiver",
        default="ixxat",
        choices=["pcan", "kvaser", "ixxat"],
        help="CAN transceiver",
    )
    parser.add_argument(
        "-b",
        "--baudrate",
        default=1000000,
        type=int,
        choices=[50000, 100000, 125000, 250000, 500000, 1000000],
        help="CAN baudrate",
    )
    parser.add_argument("-c", "--channel", default=0, type=int, help="CAN transceiver channel")
    return parser.parse_args()


if __name__ == "__main__":
    args = setup_command()
    load_firmware_example(args)

Load firmware through EtherCAT Example

Note

In Linux administrator privileges are needed.

import argparse

from ingenialink.ethercat.network import EthercatNetwork


def ecat_load_fw(args: argparse.Namespace) -> None:
    net = EthercatNetwork(args.interface)
    boot_in_app = args.firmware_path.endswith(".sfu")
    net.load_firmware(args.firmware_path, boot_in_app, slave_id=args.slave_id)


def setup_command() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="EtherCAT connection example script.")
    interface_help = """Network adapter interface name. To find it: \n
    - On Windows, \\Device\\NPF_{id}. To get the id, run the command: wmic nic get name, guid \n
    - On linux, run the command: ip link show
    """
    parser.add_argument("-i", "--interface", type=str, help=interface_help, required=True)
    parser.add_argument(
        "-f", "--firmware_path", type=str, help="Path to the firmware file.", required=True
    )
    parser.add_argument("-s", "--slave_id", type=int, help="Slave ID.", default=1)
    args = parser.parse_args()
    return args


if __name__ == "__main__":
    args = setup_command()
    ecat_load_fw(args)

Load firmware through Ethernet Example

import argparse

from ingenialink.ethernet.network import EthernetNetwork


def eth_load_fw(args: argparse.Namespace) -> None:
    net = EthernetNetwork()
    net.load_firmware(
        fw_file=args.firmware_path, target=args.ip_address, ftp_user="Ingenia", ftp_pwd="Ingenia"
    )


def setup_command() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="Ethernet load firmware example")
    parser.add_argument("-f", "--firmware_path", help="Path to firmware file", required=True)
    parser.add_argument("-ip", "--ip_address", help="IP address", type=str, required=True)
    return parser.parse_args()


if __name__ == "__main__":
    args = setup_command()
    eth_load_fw(args)