MCU Flashing using flash_program

[filipovyfusky]

Hi everyone,

I'm currently experimenting with the excellent pyxcp library and wondering if anyone here has successfully used it for flashing an MCU via XCP.

My setup:

XCP Slave: Vector VX1000 + 1544B POD

Target MCU: Infineon TriCore TC367

In my usual workflow, I use CANape to load the flash kernel into RAM and then perform the flashing procedure on the TC367. I'm trying to replicate this process purely through Python using pyxcp — starting from loading the kernel via XCP (XCP over Ethernet), and eventually executing a custom flashing sequence.

Has anyone done this before or knows:

• How to upload a binary (e.g., flash kernel) to RAM via pyxcp?
• How to trigger execution (via PROGRAM_START or similar)?
• Any caveats specific to VX1000 or TriCore I should be aware of?

Any pointers, example code, or general insight would be super appreciated.

Thanks!

[christoph2]

Hello @filipovyfusky,

Flashing could be done, the infrastructure is there, but it may somewhat tricky, because the XCP specification left some details open.

Ok, let's try to implement a basic flash kernel loader.

• Before you start, make sure to use the latest pyXCP version; objutils is also required,
  to process HEX files -- just run

pip install objutils

Now you can check what's in your HEX file, e.g.:

oj-hex-info srec .\flash_kernel.s19

Sections
--------

Num   Address    Length
-------------------------------------------------------------------------------
000   0x00000030 1156
-------------------------------------------------------------------------------
				 1156 total bytes

(The first parameter is either ihex -- Intel Hex, or srec -- Motorola S-record).

---

#!/usr/bin/env python

import sys
from pathlib import Path

from objutils import load

from pyxcp.cmdline import ArgumentParser
from pyxcp.types import TryCommandResult
from pyxcp.types import XcpTimeoutError

BASE_DIR = Path(r".")

FLASH_KERNEL = "flash_kernel.s19"


START_ADDR = ???

with open(BASE_DIR / FLASH_KERNEL) as inf:
    image = load("srec", inf)


def flash_load_kernel(master, image, start_address: int):
    section = image.sections[0]
    print("Flash Kernel: ", section)   
    master.setMta(section.address)
    master.programPrepare(section.length)
    
    master.push(section.address, 0, section.data)  # Load kernel into ECU RAM.
    master.setMta(start_address) # The MTA *MUST* point to the entry point of the downloaded routine!!!
    
    
def flash_erase(master, address: int, size: int):
    master.setMta(address)
    master.programClear(0, size)
        
    
def read_memory(mster, address: int, size: int):    
    master.setMta(address)
    return master.pull(size)
         

ap = ArgumentParser(description="Basic XCP flash example.")

with ap.run() as x:
    try:
        x.connect()
    except XcpTimeoutError:
        sys.exit(2)

    if x.slaveProperties.optionalCommMode:
        x.getCommModeInfo()
  
    if x.slaveProperties.supportsPgm:
        print("PGM processor: ", x.slaveProperties.pgmProcessor)
        status, pgm = x.try_command(x.getPgmProcessorInfo)
        if status == TryCommandResult.OK:
            print(pgm)
    else:
        print("*** FLASH PROGRAMMING IS NOT SUPPORTED.")
        x.disconnect()
        sys.exit(1)
    x.cond_unlock("PGM")

    flash_load_kernel(x, image, START_ADDR)

    res = x.programStart()  # Hand-over to the fls kernel.
    print(res)
    
	## The actual programming goes here!
       
    x.programReset()

---

• Finally you need a configuration file to run pyXCP programs/scripts

xcp-profile create > .\pyxcp_conf.py

and modify the relevant options:

c.General.seed_n_key_dll = ''
c.Transport.layer = 'CAN'
c.Transport.Can.bitrate = 250000
c.Transport.Can.can_id_master = 0
c.Transport.Can.can_id_slave = 0
c.Transport.Can.interface = 'vector'
c.Transport.Can.Vector.app_name = None

The only problematic parameter could be app_name.

[filipovyfusky]

@christoph2 thanks for the code example! I will test it in the week and see if I can get somewhere.

I will keep you posted!