Currently, like Arduino, libraries are determined by grepping for includes in the sketch.

It would be good to be able to preset REQUIRED_LIBS in the Makefile, and add to this by grepping as now.

Also rename LIBRARIES to LIBRARY_PATH, and allow adding to it. Then rename REQUIRED_LIBS to LIBRARIES.

Have a single include for all architectures, with defines for each scoped by processor family.

Aim is to allow a single makefile to build a sketch for multiple architectures.

Would like to specify the name as in the IDE:

BOARD_NAME := NodeMCU-32S

and derive BOARD from that.

• fs, upload-fs
• reset

also rename upload-fs to upload-littlefs for esp8266

also update documentation

Currently it's hardwired to minicom.

TERM ?= minicom
TERM_FLAGS ?= -D $(UPLOAD_PORT) -b $(TERM_SPEED)

term:
   $(TERM) $(TERM_FLAGS)

TERM := screen
TERM_FLAGS := $(UPLOAD_PORT) $(TERM_SPEED) -ixon -ixoff

everything built goes into
.deps/
build/

There is usually only one choice, use that, maybe with a warning.

Move all of the different upload implementations into build-targets.mk

Should follow the Arduino guidelines:

The source code found in src folder and all its subfolders is compiled and linked in the user’s sketch. Only the src folder is added to the include search path (both when compiling the sketch and the library). When the user imports a library into their sketch (from the "Tools > Import Library" menu), an #include statement will be added for all header (.h) files in the src/ directory (but not its subfolders).

(menu names are enumerated at the beginning of boards.txt.)

See here for example: https://github.com/jorgegarciadev/Arduino-Esp8266-Makefile

• show-variables
• size
• build and upload fs
• term

Starting with version 3.0.0, the esp32 core has refactored its libraries in a way which requires including a library's dependencies as well, e.g., to use WiFi need to include its dependency Network as well:

#include <Network.h>
#include <WiFi.h>

Otherwise the compilation will fail:

In file included from /home/steve/.arduino15/packages/esp32/hardware/esp32/3.0.1/libraries/WiFi/src/WiFiSTA.h:29,
                 from /home/steve/.arduino15/packages/esp32/hardware/esp32/3.0.1/libraries/WiFi/src/WiFi.h:33,
                 from Radar.ino:4:
/home/steve/.arduino15/packages/esp32/hardware/esp32/3.0.1/libraries/WiFi/src/WiFiGeneric.h:39:10: fatal error: Network.h: No such file or directory
   39 | #include "Network.h"
      |          ^~~~~~~~~~~
compilation terminated.
make: *** [build-targets.mk:68: Radar.ino.cpp.o] Error 1

More information here.

• use include path
  (check http://blog.jgc.org/2007/01/what-makefile-am-i-in.html)
• read ~/{.arduino15, .energia15}/preferences.txt for defaults
• handle multiple .ino files

https://arduino.github.io/arduino-cli/0.21/platform-specification/

.arduino15/preferences.txt

boardsmanager.additional.urls=http://arduino.esp8266.com/stable/package_esp8266com_index.json,https://dl.espressif.com/dl/package_esp32_index.json,http://drazzy.com/package_drazzy.com_index.json

should be possible to use in stm32 Makefiles

BOARD := GenF1
PNUM := HY-TINY...

however there are issues with variable substitution around this.

Should read and parse library.properties. Useful flags are, in order:

• depends
• dot_a_linkage (whether to build an archive and link that)
• ldflags
• architectures

/home/steve/sketchbook/hardware/esp8266com/esp8266/libraries/ESP8266WiFi/src/CertStoreSDBearSSL.cpp:20:16: fatal error: SD.h: No such file or directory
#include <SD.h>
^
compilation terminated.
ucmk.mk:78: recipe for target '.lib//home/steve/sketchbook/hardware/esp8266com/esp8266/libraries/ESP8266WiFi/src/CertStoreSDBearSSL.cpp.o' failed

It ought to be possible to automate away this sort of thing (esp32.mk):

build.flash_mode := $($(build.board).build.flash_mode)
build.flash_size := $($(build.board).build.flash_size)
build.flash_freq := $($(build.board).menu.FlashFreq.$(FLASH_FREQ).build.flash_freq)
build.boot := $($(build.board).build.boot)
build.partitions := $($(build.board).menu.PartitionScheme.$(PARTITION_SCHEME).build.partitions)

See this discussion (SO).

• objects
• include deps

This would be a good solution to the problem of tracking changes in each release.

Simple preprocessing with sed allows it to be read into gnu make:

$  sed -e "s/{/\${/g" -e "/^\#/d" -e "/^$/d" < ~/.arduino15/packages/esp8266/hardware/esp8266/2.5.1/platform.txt

Problems:

• generating targets from recipes
• "implicit" platform variables, exact semantics is unclear, will have to supply them for now.

See the specification.

This is required for arduino-esp32 2.0.10.

`# Set -DARDUINO_CORE_BUILD only on core file compilation
file_opts.path={build.path}/file_opts
recipe.hooks.prebuild.set_core_build_flag.pattern=bash -c ": > {file_opts.path}"
recipe.hooks.core.prebuild.set_core_build_flag.pattern=bash -c "echo '-DARDUINO_CORE_BUILD' > {file_opts.path}"
recipe.hooks.core.postbuild.set_core_build_flag.pattern=bash -c ": > {file_opts.path}"

recipe.hooks.prebuild.set_core_build_flag.pattern.windows=cmd /c type nul > {file_opts.path}
recipe.hooks.core.prebuild.set_core_build_flag.pattern.windows=cmd /c echo "-DARDUINO_CORE_BUILD" > {file_opts.path}
recipe.hooks.core.postbuild.set_core_build_flag.pattern.windows=cmd /c type nul > {file_opts.path}
`

See thunderace/Esp8266-Arduino-Makefile@8ac71c6

... and esp32
... and attiny

add:
define define-menus

clean up the output of "size" command: look at recipe.size.regex and friends in platform.txt

See here.

For detecting which libraries to include in the build, and for generating function prototypes, (just) the preprocessor is run. For this, the recipe.preproc.macros recipe exists. This recipe must run the preprocessor on a given source file, writing the preprocessed output to a given output file, and generate (only) preprocessor errors on standard output. This preprocessor run should happen with the same defines and other preprocessor-influencing-options as for normally compiling the source files.

This came to light trying to compile src/TommyPROM/HardwareVerify: it fails due to a missing function prototype.