sprintf for floats on Arduino Mega?

[tofrnr]

could we finally have sprintf for floats on Arduino Mega?
enabled perhaps by a #include or by a #pragma config

[Chris--A]

To keep things consistent, this would probably have to be added to the Uno and other small variants. Otherwise code will fail to work correctly between them. This has been discussed before I'm pretty sure, and I think the overhead would be undesirable for the smaller boards. There are already floating point conversions in both the Print class and String class. If both are used, then there is a substantial code size increase.

If there is a pragma for this option, you cuold simply add it to your sketch when you need it.

If you're interested, I have a library PrintEx in the library manager which has sprintf and a printf for Print objects. It also supports repition, reading from PROGMEM, and EEPROM.

Using a GString object you can also use print/printf functions and streaming to write to RAM variables. Which is far more efficient that grabbing in the whole sprintf function (depending on how much of its functionality you use).
.

[tofrnr]

my question was about to be optionally (!!) enabled perhaps by a #include or by a #pragma config.

Having to deal currently with the mutilated AVR-sprintf-crippel stuff and those unconscionable ftoa functions is an impertinence, so every programmer should be empowered to decide by his own if he wants the full ANSI C /stdio.h functionality or not (like on the Due, and the Mega is powerful enough for that purpose, too). And finally the original stdio.h-sprintf version is already existing and available, so why not to be simply - optionally - enabled for Sketch?

[matthijskooijman]

Enabling float support for printf is currently only possible by passing some compiler flags to the linker, which is not currently possible from within a sketch. This feature is disabled by default to save space.

[tofrnr]

re: "This feature is disabled by default to save space."

Of course I know that, and that's already been said.
Workarounds like mentioned or e.g., patching all those lib.c files is also no option on the duration.

So my post was meant to be a request for a new additional feature.

[tofrnr]

now what about making possible that sprintf() can be optionally (!!) enabled perhaps by a #include or by a #pragma config ??

[matthijskooijman]

now what about making possible that sprintf() can be optionally (!!) enabled perhaps by a #include or by a #pragma config ??

I cannot think of any way to do this, without having to make significant changes to gcc and/or avr-libc...

[tofrnr]

Perhaps have just two sets of different lib.c folders?
and then choose manually in the proprietary which set the user wishes to be #included.

either by #include an extended lib manually:

#include <libfloat.h> // switches from lib.c ctandard to libcfloat (extended)

or., e.g., set a #define:

#define libcfloat // switches the libs for the linker automatically

or., e.g., set a #pragma:

#pragma config  libcfloat

which does the same automatically by preprocessor, compiler and linker.

Finally when patching all lib.c files it is actually already possible to enable sprintf also for floats for all AVRs!.
But then it's irreversible for small Unos, Minis, Micros and Nanos which is also unreasonable.

[oqibidipo]

Add this to boards.txt and you can select printf and scanf version from the Tools menu:

##############################################################

menu.printf=AVR printf Version
menu.scanf=AVR scanf Version

uno.menu.printf.default=Default printf
uno.menu.printf.default.avr_printf_flags=
uno.menu.printf.full=Full printf
uno.menu.printf.full.avr_printf_flags=-Wl,-u,vfprintf -lprintf_flt
uno.menu.printf.minimal=Minimal printf
uno.menu.printf.minimal.avr_printf_flags=-Wl,-u,vfprintf -lprintf_min

uno.menu.scanf.default=Default scanf
uno.menu.scanf.default.avr_scanf_flags=
uno.menu.scanf.full=Full scanf
uno.menu.scanf.full.avr_scanf_flags=-Wl,-u,vfscanf -lscanf_flt
uno.menu.scanf.minimal=Minimal scanf
uno.menu.scanf.minimal.avr_scanf_flags=-Wl,-u,vfscanf -lscanf_min

uno.compiler.c.elf.extra_flags={avr_printf_flags} {avr_scanf_flags}

mega.menu.printf.default=Default printf
mega.menu.printf.default.avr_printf_flags=
mega.menu.printf.full=Full printf
mega.menu.printf.full.avr_printf_flags=-Wl,-u,vfprintf -lprintf_flt
mega.menu.printf.minimal=Minimal printf
mega.menu.printf.minimal.avr_printf_flags=-Wl,-u,vfprintf -lprintf_min

mega.menu.scanf.default=Default scanf
mega.menu.scanf.default.avr_scanf_flags=
mega.menu.scanf.full=Full scanf
mega.menu.scanf.full.avr_scanf_flags=-Wl,-u,vfscanf -lscanf_flt
mega.menu.scanf.minimal=Minimal scanf
mega.menu.scanf.minimal.avr_scanf_flags=-Wl,-u,vfscanf -lscanf_min

mega.compiler.c.elf.extra_flags={avr_printf_flags} {avr_scanf_flags}

# ... repeat for each board

(Full version attached.)

avr_printf_scanf_2.txt

[tofrnr]

I just need the functionality for sprintf and possibly vsprintf and sscanf,
i.e. just for formatting different value types to a char* (string).

• not for read/write from stdin/stdout or from/to files (printf, scanf, fprintf, fscanf,...)

But your list does not mention sprintf and either string formatting function so I'm curious if it will solve the sprintf issue?

(BTW, for the DUE sprintf and vsprintf work fine even for floats, just not for AVRs)

[oqibidipo]

It covers the whole printf (and scanf) family of functions.
vfprintf and vfscanf are the functions that do the actual work, others are more or less just wrappers for them.

[tofrnr]

ok,
once having done that for 1 of my projects, how can I switch back and forth to include/exclude this functionality if desirable?

[oqibidipo]

Just select Default printf / Default scanf if you don't need floating point support.

[tofrnr]

how can I do it in a couple of programs and do the other thing in another couple of programs from inside my code?

as I wrote in my TOP:
e.g., enabled perhaps by a #include or by a #pragma config

• or even by a different approach ?

one time I must be able to exclude the full sprintf functionality optionally because of memory reasons, and the other time I must be able to have this sprintf feat. floats formatting optionally when I need this functionality !

[bperrybap]

@tofrnr
You don't seem to be understanding that the way this is controlled is through compiler and linker flags.
That means that there is nothing you can do inside a source code module to control this.

Could it done differently, perhaps. It might be possible to have played some games with some weak symbols to affect link ordering to trick the linker to select different libraries by using a dummy symbol in the application code. However, that is now how the AVR libC is implemented and it is very unlikely something that Arduino development team would ever want to take on.

So basically there are a hand full of approaches.

• Create custom board types that control the compiler/linker options
• Modify the build recipes to permanently enable/disable AVR floating point support
• Modify the IDE to control the compiler/linker options through some sort of GUI preference option similat to the way verbose mode is handled.

None of these will give you control from the application source code.

As an alternative you might want to look at the PrintEx library.
It offers most of the xxprintf() capability as well as some extensions and works with Arduino Print class objects as well.
Currently, I'm in the process of working with the Author to simplify how the object initialization works to avoid creating a separate object so you will be able to do things like:
objname.printf(......)
and get what you want for any object that uses the Print class without having to use a separate PrintEx object.
It will essentially transparently extend the objects methods.
(see the github issues list for the PrintEx library for that discussion)

It is actually a much nicer solution than using the xxprintf() routines and will work consistently across all platforms with a smaller footprint than using the libC xxpprintf() routines, particularly on some of the other (non AVR) platforms.

[tofrnr]

re: "You don't seem to be understanding that the way this is controlled is through compiler and linker flags."
I know that it's the way it's done currently, but that should be changed for the future:

perhaps by a #pragma config which changes the compiler and linker flags or by doing different magic things, or a
#include of a 2nd library like the already existing lib.c float patch lib for example: then one could switch between the default lib.c libs and the float-patched lib.c libs.
This lib.c float patch finally is also already existing - you know that lib.c float patch, I suppose?

Anyway, oqibidipo's proposal sounded as if perhaps he might have found a workaround nevertheless.

So my wish is still the same, i.e. to change the current implementation into a more suitable one:

"could we finally have sprintf for floats on Arduino Mega?
enabled perhaps by a #include or by a #pragma config"