maxgerhardt
commented
3 years ago Ah, I was about to open this issue as well.
I've played around a long time with this circa a month ago and had a good fight with sdcc, stm8-gdb and openocd; the first two to make them generate an ELF file with debug symbols that stm8-gdb can read, and the last one to figure out the correct command to program the chip, since it wouldn't except the usually used program command (https://sourceforge.net/p/openocd/tickets/293/). In the end (see bottom) I managed to teach PlatformIO how to flash the binary via openocd.
I'll talk about what I've expiermented with / found out / having problems with so that maybe other people can gloss over it, too.
For SDCC to include debug information into the compiled files (or the .rel files), it must be given the --debug flag. However on Windows there's a nice bug (https://sourceforge.net/p/sdcc/bugs/2970/) that will make sdcc generate a file with Unix lineendings which then it itself cannot read at a later point since it's using the file-encoding of the OS, Windows in my case, and fails.
I've experimented quite a bit with it and used advanced scripting to work around this bug by last-minute fixing the line-endings before feeding into SDCC. This does allow it to compile correctly with --debug.
However, as a next blockade, reading the generated .elf file with stm8-gdb (which is a separate project from SDCC) still says that no debug information was found. At this point I'm not sure whether SDCC is still generating the ELF in a wrong way or if stm8-gdb has a bug.
In any case, I'm also able to connect to my chip using OpenOCD. Using simliar commands per your debug_x directives above, I'm able to connect to a separately started OpenOCD instance. It's a bit hacky (after connecting I have to type target remote :3333 to actually connect to OpenOCD) but there are signs of life: The registers of the STM8 core are being read out (PC, A, X, Y, SP, CC) and there's a callstack, albeit with all function addresses being unknown due to the ELF file or stm8-gdb.
I'll continue my journey to get this working further regarding:
- building the ELF file with debug info that can be read out with stm8-gdb, or finding out why it it isn't being read out
- making PlatformIO understand how to flash the chip correctly natively
- getting SVD register description files for the STM8 boards (work being done in parallel by @gicking at https://github.com/gicking/STM8_headers/tree/master/XML)
- having VSCode support SDCC as a compiler for the IntelliSense
And hopefully at the end, we have fully-featured development environment for STM8 chips with PlatformIO, beatiful and correctly working Intellisense for SDCC, and debugging with OpenOCD with the help of debug symbols generated by SDCC and read by stm8-gdb, plus register decoding as one can e.g. see here, as it already works for other PlatformIO platforms.
Addendum:
I'm testing with a STM8S103F3P6 breakout board. My platformio.ini is
[env:stm8sblue]
;build_type = debug
platform = ststm8
board = stm8sblue
framework = arduino
;upload_protocol = stlinkv2
upload_protocol = custom
upload_flags =
-f
interface\stlink-dap.cfg
-c
transport select swim
-f
target\stm8s103.cfg
upload_command = $PROJECT_PACKAGES_DIR/tool-openocd/bin/openocd $UPLOAD_FLAGS -c "init; reset halt; load_image {$SOURCE}; verify_image {$SOURCE}; reset; shutdown"
debug_tool = custom
; empty. You need to start openocd yourself with
; openocd -f interface\stlink-dap.cfg -f target\stm8s103.cfg
debug_server =
; $PROJECT_PACKAGES_DIR/tool-openocd/bin/openocd
; -f
; interface\stlink-dap.cfg
; -f
; target\stm8s103.cfg
debug_port = localhost:3333
;debug_load_mode = manual
debug_init_break =
;tbreak setup
debug_init_cmds =
$INIT_BREAK
; monitor init
; monitor reset halt
debug_load_mode = manual
build_flags = --debug --fverbose-asm --verbose
debug_build_flags = --debug
extra_scripts = fix_debug_compile.pyand the fix_debug_compile.py script is
import shutil
Import("env")
def dos2unix(file_to_strip, output_file):
content = ''
outsize = 0
with open(file_to_strip, 'rb') as infile:
content = infile.read()
with open(output_file, 'wb') as output:
for line in content.splitlines():
outsize += len(line) + 1
output.write(line + b'\n')
def fix_elf(source, target, env):
# build our own
#print(env["LINKCOM"])
#env.Execute([env["LINKCOM"]])
pass
def fix_rel_file(source, target, env):
for src in source:
print("dos2unix fix: " + str(src))
dos2unix(str(src), str(src)+".fixed")
shutil.move(str(src)+".fixed", str(src))
# so that debug output ends up in the final ELF file
#env.Append(LINKFLAGS=["--debug"])
# hook pre-build actions of these files to workaround SDCC error:
# if .rel files compiled in --debug mode have Windows line endings, linking will fail.
env.AddPreAction("$BUILD_DIR/libFrameworkArduino.lib", fix_rel_file)
env.AddPreAction("$BUILD_DIR/libFrameworkArduinoVariant.lib", fix_rel_file)
env.AddPreAction("$BUILD_DIR/${PROGNAME}.elf", fix_rel_file)
env.AddPostAction("$BUILD_DIR/${PROGNAME}.elf", fix_elf)
env.Append(LINKFLAGS = ["--verbose", "--debug", "--fverbose-asm", "--no-peep"])
#env["OBJSUFFIX"] = ".o"
#env.Replace(LD="sdld")
#env["LINK"] = "stm8-ld"
##env["LINKFLAGS"] =[]
cocus
valeros
anshchawla521
Hi! I'm currently porting an existing project I have from IAR to SDCC and Platformio. One thing I really need is the debug feature using the STLink/V2 probe I have. I found out that this platform on platformio doesn't support being debugged, although the STM8S105 from the ST8Discovery kit does allow it (even if that one also has an STLink embedded on it). So I figured I could give that board a try, even if my MCU is different. It turns out that the openocd doesn't allow to use SWIM with the provided arguments, but it can use SWIM by changing the arguments you pass to it. Then I managed to run OpenOCD with custom parameters, with the following code added to platformio.ini:
It's actually able to communicate with the board I have, but I don't have a complete running code to validate it actually works. Moreover, OpenOCD complains that the provided image doesn't contain debug symbols and I should specify them with the "file" command. I thought platformio would be creating an .elf file with debug symbols, but might not be the case? Or am I missing something?
Thanks!