Discussion :

[electroremy]

Bonjour,

Je commençais à m'attaquer à la bibliothèque <Wire.h> pour voir s'il y avait des choses à optimiser.

Je copie Wire.h et Wire.cpp depuis le dossier
\arduino-1.8.12\hardware\arduino\avr\libraries\Wire\src
vers le dossier de mon projet INO.
Puis dans mon fichier .INO je remplace #include <Wire.h> par #include "Wire.h"

Le compilateur grogne car il ne trouve pas twi.h

En effet, dans Wire.cpp on a ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
extern "C" {
  #include <stdlib.h>
  #include <string.h>
  #include <inttypes.h>
  #include "utility/twi.h"
}

Au passage je ne sais pas du tout à quoi sert le extern "C" qui encadre les #include

Je comprend que comme "utility/twi.h" est entre guillemets, il n'arrive plus à trouver le fichier.

Je cherche et je trouve twi.h et twi.cpp dans \arduino-1.8.12\hardware\arduino\avr\libraries\Wire\src\utility, que je copie dans le dossier de mon projet INO.

Je compile pour voir si ça marche.

Non seulement ça marche, mais mon programme compilé est plus court de 900 octets de flash

Hum... c'est trop beau pour être vrai, il y a sûrement des bugs bien foireux là dessous

Je téléverse le programme, et ça fonctionne parfaitement

C'est cool d'avoir gratté 900 octets, je peux ajouter quelques fonctionnalités supplémentaires

Mais j'aimerais bien comprendre POURQUOI

Je pense pouvoir optimiser car dans Wire.h il y a des tartines de fonctions et le #include <string.h> qui ne me plait pas beaucoup.
C'est logique vu qu'il existe une grande variété de périphériques I2C, notamment des écrans, mais j'en ai juste besoin pour des capteurs.

A bientôt

[Jay M]

L'utilisation d'extern "C" permet au compilateur C++ de savoir que vous utilisez les conventions de dénomination et d'appel de fonction en C. C'est nécessaire car les compilateurs C++ modifient les noms dans leur table de symboles différemment des compilateurs C (ça joue au link).

le #include <string.h> qui ne me plait pas beaucoup

ce sont les fonctions des cStrings, pas la classe String.

Pour la taille (juste une hypothèse) il se peut que ça ait à voir avec la gestion des bibliothèques par l'IDE. En copiant en local vous forcez une recompilation et sans doute ça permet de virer plus de choses non utilisées à l'édition de lien. faudrait comparer les binaires générés pour voir la différence

[electroremy]

Bonjour,

Un autre mystère

J'ai remarqué que chaque appel à la fonction delay(); consommait pas mal de code.

J'ai donc remplacé tous les appels à delay(); par une fonction maison :

RLucas_Delay.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
#if !defined(rlucas_delay_h)
#define rlucas_delay_h
void rlucas_delay(unsigned int duration); 
#endif

RLucas_Delay.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
#include "RLucas_Delay.h"
#include <Arduino.h>
void rlucas_delay(unsigned int duration) {
	delay(duration);
}

Gain de 58 octets de code (16 appels de fonction sur l'ensemble du projet)

La fonction delay utilise certainement un type unsigned long en paramètre

Sachant qu'un unsigned int permet déjà d'attendre un peu plus d'une minute (65,536 secondes)

Mais qui utilise delay() avec un paramètre plus grand que 65536 ?

Une boucle qui scrute millis() régulièrement permet de faire des attentes tout en permettant à l'Arduino de faire autre chose

A bientôt

[electroremy]

Pour la taille (juste une hypothèse) il se peut que ça ait à voir avec la gestion des bibliothèques par l'IDE. En copiant en local vous forcez une recompilation et sans doute ça permet de virer plus de choses non utilisées à l'édition de lien. faudrait comparer les binaires générés pour voir la différence

Alors ça c'est vraiment intéressant comme information !

En effet, cela peut expliquer pas mal de choses.

Du coup il faudrait que je copie tous les fichiers inclus en local pour voir ce que ça donne !

Ou alors, trouver une option, si elle existe, pour forcer le compilateur à tout recompiler

A bientôt

[electroremy]

Effectivement, il semble bien que l'IDE Arduino ne fasse que des compilations partielles

L'origine du mal : des gens se plaignait de la lenteur : https://github.com/arduino/Arduino/issues/2255

Le problème actuel : https://forum.pjrc.com/threads/56965...mplete-rebuild

How can i assure a complete rebuild?

-> It has been asked for several times - there is no "one-click" possibility.

But you can simply select other build options, compile once, and then switch back.
This can take a long time, depending on the size of your project, but unfortunately it's the fastest option at the moment.
Maybe Paul Stoffregen can add it now, when the T4 beta test is over.

Bref il faut bidouiller...

Un bouton ou un menu "compilation complète" ça serait pas mal, tous les bons IDE ont cette fonction

A bientôt

[Jay M]

oui un bon make clean serait parfois utile... sauf que l'IDE n'utilise pas make...

[electroremy]

C'est la galère quand même...

Je croyais utiliser l'Arduino en version portable mais, à chaque compilation, il écrit des tartines de données :
- dans le dossier D:\TEMP
- dans le dossier C:\Users\Mon Nom\AppData\Local\Arduino15

Or j'ai un PC avec un SSD, j'avais pas mal galéré avec Windows pour ne pas mettre de dossiers de travail sur le C:
mais beaucoup de logiciels n'en font qu'à leur tête et écrivent des fichiers temporaires sur le C:

A chaque fermeture, Arduino supprime tout ce qu'il a écrit dans TEMP

Mais le C:\Users\Mon Nom\AppData\Local\Arduino15 n'est jamais néttoyé, la taille des données enfle à chaque utilisation.

On peut tout supprimer et l'IDE (sauf le fichier C:\Users\Mon Nom\AppData\Local\Arduino15\preferences.txt) :
- L'IDE Arduino ne bronche pas et démarre normalement
- je n'arrive pas à voir si la compilation dure plus longtemps qu'à la normale. Mais le résultat (utilisation Flash et Ram) est identique

Dans ce foutoir, je n'arrive même pas à trouver où sont les options de compilations.
J'avais du le faire à une époque mais je ne m'en souvient plus et ne retrouve pas la manip (beaucoup se plaignent sur Internet).

Une autre piste à explorer serait de supprimé tous les fichiers compilés dans le dossier d'installation portable d'Arduino

Qu'en penses-tu ?

[electroremy]

Bonjour,

Méthode bourrin (âmes sensibles s'abstenir)
- Recherche de tous les fichiers *.o
- Remarque : ils portent des noms correspondant aux cartes, et pas aux librairies
- Supprimer tout
- L'IDE démarre normalement
- Compilation...
- Erreur fichier manquant
- Restauration des fichiers supprimés
- Tout remarche

Qu'est-ce qu'on s'amuse avec le reverse engineering

Bref il semblerait bien que quand je compile avec la 1.8.12, l'IDE fait bien une compilation complète
La preuve, si je recompile sans toucher aux fichiers, c'est plus rapide et là il m'indique qu'il utilise des fichiers déjà compilés portant des noms correspondant au code

Le mystère du compilateur n'est pas résolut :
Pourquoi donc mon programme compilé est plus court de 900 octets de flash quand j'ai juste déplacé les fichiers de la bibliothèque <wire.h> dans le dossier de mon projet sans y toucher ???

Je me dis tout bêtement que les options de compilation ne seraient pas les mêmes pour le core et les fichiers de mon projet ?

Voyons ce que l'IDE Arduino affiche

Une belle tartine de texte où ce qui est important est un peu noyé...

Pour le fichier Wire qui est dans mon dossier INO, j'ai quatre lignes :

"D:\\...arduino-1.8.12\\hardware\\tools\\avr/bin/avr-g++" -c -g -Os -w -std=gnu++11 -fpermissive -fno-exceptions -ffunction-sections -fdata-sections -fno-threadsafe-statics -Wno-error=narrowing -flto -w -x c++ -E -CC -mmcu=atmega328p -DF_CPU=16000000L -DARDUINO=10812 -DARDUINO_AVR_UNO -DARDUINO_ARCH_AVR "-ID:\\...arduino-1.8.12\\hardware\\arduino\\avr\\cores\\arduino" "-ID:\\...arduino-1.8.12\\hardware\\arduino\\avr\\variants\\standard" "-ID:\\...arduino-1.8.12\\hardware\\arduino\\avr\\libraries\\SPI\\src" "-ID:\\...arduino-1.8.12\\hardware\\arduino\\avr\\libraries\\EEPROM\\src" "D:\\TEMP\\arduino_build_967409\\sketch\\Wire.cpp" -o nul

"D:\\...arduino-1.8.12\\hardware\\tools\\avr/bin/avr-g++" -c -g -Os -w -std=gnu++11 -fpermissive -fno-exceptions -ffunction-sections -fdata-sections -fno-threadsafe-statics -Wno-error=narrowing -MMD -flto -mmcu=atmega328p -DF_CPU=16000000L -DARDUINO=10812 -DARDUINO_AVR_UNO -DARDUINO_ARCH_AVR "-ID:\\...arduino-1.8.12\\hardware\\arduino\\avr\\cores\\arduino" "-ID:\\...arduino-1.8.12\\hardware\\arduino\\avr\\variants\\standard" "-ID:\\...arduino-1.8.12\\hardware\\arduino\\avr\\libraries\\SPI\\src" "-ID:\\...arduino-1.8.12\\hardware\\arduino\\avr\\libraries\\EEPROM\\src" "D:\\TEMP\\arduino_build_967409\\sketch\\Wire.cpp" -o "D:\\TEMP\\arduino_build_967409\\sketch\\Wire.cpp.o"

"D:\\...arduino-1.8.12\\hardware\\tools\\avr/bin/avr-g++" -c -g -Os -w -std=gnu++11 -fpermissive -fno-exceptions -ffunction-sections -fdata-sections -fno-threadsafe-statics -Wno-error=narrowing -MMD -flto -mmcu=atmega328p -DF_CPU=16000000L -DARDUINO=10812 -DARDUINO_AVR_UNO -DARDUINO_ARCH_AVR "-ID:\\...arduino-1.8.12\\hardware\\arduino\\avr\\cores\\arduino" "-ID:\\...arduino-1.8.12\\hardware\\arduino\\avr\\variants\\standard" "-ID:\\...arduino-1.8.12\\hardware\\arduino\\avr\\libraries\\SPI\\src" "-ID:\\...arduino-1.8.12\\hardware\\arduino\\avr\\libraries\\EEPROM\\src" "D:\\TEMP\\arduino_build_967409\\sketch\\Wire.cpp" -o "D:\\TEMP\\arduino_build_967409\\sketch\\Wire.cpp.o"

"D:\\...arduino-1.8.12\\hardware\\tools\\avr/bin/avr-gcc" -w -Os -g -flto -fuse-linker-plugin -Wl,--gc-sections -mmcu=atmega328p -o "D:\\TEMP\\arduino_build_967409/081_WebClient_TFT_OK.ino.elf" "D:\\TEMP\\arduino_build_967409\\sketch\\twi.c.o" "D:\\TEMP\\arduino_build_967409\\sketch\\081_WebClient_TFT_OK.ino.cpp.o" "D:\\TEMP\\arduino_build_967409\\sketch\\RLucas_Delay.cpp.o" "D:\\TEMP\\arduino_build_967409\\sketch\\RLucas_Ethernet.cpp.o" "D:\\TEMP\\arduino_build_967409\\sketch\\RLucas_EthernetClient.cpp.o" "D:\\TEMP\\arduino_build_967409\\sketch\\RLucas_EthernetServer.cpp.o" "D:\\TEMP\\arduino_build_967409\\sketch\\RLucas_IPAddress.cpp.o" "D:\\TEMP\\arduino_build_967409\\sketch\\RLucas_socket.cpp.o" "D:\\TEMP\\arduino_build_967409\\sketch\\RLucas_w5100.cpp.o" "D:\\TEMP\\arduino_build_967409\\sketch\\Wire.cpp.o" "D:\\TEMP\\arduino_build_967409\\libraries\\SPI\\SPI.cpp.o" "D:\\TEMP\\arduino_build_967409/core\\core.a" "-LD:\\TEMP\\arduino_build_967409" -lm

Pour Print.cpp qui est dans le core, j'ai trois lignes :

"D:\\...arduino-1.8.12\\hardware\\tools\\avr/bin/avr-g++" -c -g -Os -w -std=gnu++11 -fpermissive -fno-exceptions -ffunction-sections -fdata-sections -fno-threadsafe-statics -Wno-error=narrowing -MMD -flto -mmcu=atmega328p -DF_CPU=16000000L -DARDUINO=10812 -DARDUINO_AVR_UNO -DARDUINO_ARCH_AVR "-ID:\\...arduino-1.8.12\\hardware\\arduino\\avr\\cores\\arduino" "-ID:\\...arduino-1.8.12\\hardware\\arduino\\avr\\variants\\standard" "D:\\...arduino-1.8.12\\hardware\\arduino\\avr\\cores\\arduino\\Print.cpp" -o "D:\\TEMP\\arduino_build_967409\\core\\Print.cpp.o"

"D:\\...arduino-1.8.12\\hardware\\tools\\avr/bin/avr-g++" -c -g -Os -w -std=gnu++11 -fpermissive -fno-exceptions -ffunction-sections -fdata-sections -fno-threadsafe-statics -Wno-error=narrowing -MMD -flto -mmcu=atmega328p -DF_CPU=16000000L -DARDUINO=10812 -DARDUINO_AVR_UNO -DARDUINO_ARCH_AVR "-ID:\\...arduino-1.8.12\\hardware\\arduino\\avr\\cores\\arduino" "-ID:\\...arduino-1.8.12\\hardware\\arduino\\avr\\variants\\standard" "D:\\...arduino-1.8.12\\hardware\\arduino\\avr\\cores\\arduino\\Print.cpp" -o "D:\\TEMP\\arduino_build_967409\\core\\Print.cpp.o"

"D:\\...arduino-1.8.12\\hardware\\tools\\avr/bin/avr-gcc-ar" rcs "D:\\TEMP\\arduino_build_967409\\core\\core.a" "D:\\TEMP\\arduino_build_967409\\core\\Print.cpp.o"

Comme on peut le voir, les options seraient les mêmes pour les commandes avr-g++

Mais il y a une différence avr-gcc-ar" rcs pour Print.cpp alors que pour Wire c'est avr-gcc" -w -Os -g -flto

Je ne m'y connais pas assez pour savoir si l'explication se trouve ici, mais ça semble logique. Il y a une étape du process qui semble échapper aux options d'optimisation.

Et je m'y connais encore moins pour modifier ça

A bientôt

[Jay M]

L’IDE a sa vision bien à lui de la gestion de la compilation surtout quand on commence à mélanger du C, C++ et des .ino ...

Si vous voulez tout maîtriser il faut laisser tomber l’IDE et écrire votre propre main() et configurer l’Arduino vous même puis avoir le makefile qui va bien

[al1_24]

Comme IDE avec l'Arduino, j'utilise Sloeber qui permet une recompilation complète d'un projet.

[Delias]

Bonjour à tous

Je vais reprendre ma remarque préférée. Arduino est conçu, dès sa base, pour être à un niveau d'initiation à la programmation embarquée, pas pour être hyper-optimisé (voir même pour ceux à base d'AVR, pas pour faire des gros projets utilisant de multiples périphériques). Vouloir l'optimiser à ce niveau c'est reprendre depuis 0 la conception même de l'IDE et le code de base.

Si tu veux faire de l'hyper-optimisé, tu mets l'IDE Arduino à la poubelle, tu prends l'AVR Studio ou Eclipse avec le pack AVR et tu ne programmes qu'en C en n'utilisant que les includes de base des AVR.
Pour chaque projet tu vas écrire deux à trois plus de code, mais compilé, ce sera un programme deux à trois fois plus léger qu'un programme Arduino... (valeurs à la cuillère sans prétention d'être correctes)

Surtout tu vas te rendre compte que pour chaque projet tu définiras à des valeurs différentes les blocs de base, de manière a être optimum par rapport au projet en question.

f-leb a publié quelques tutos sur comment programmer un Arduino sans la base logicielle Arduino (c'est : Arduino et le langage C). La suite c'est de prendre le datasheet de l'ATMega328p et de comprendre un à un chaque module du microcontrôleur et ses multiples paramétrages.

Bonne suite

Delias

[electroremy]

Je vais reprendre ma remarque préférée. Arduino est conçu, dès sa base, pour être à un niveau d'initiation à la programmation embarquée, pas pour être hyper-optimisé (voir même pour ceux à base d'AVR, pas pour faire des gros projets utilisant de multiples périphériques).

Je ne suis pas d'accord avec cette explication, VB est un bon contre exemple.
VB.NET reste presque aussi facile que VB5 et il est aussi performant que C#
J'ai pu faire des calculs 3D et CAO en VB.NET de façon rapide

Arduino pouvait très bien faire les deux, être accessible en étant performant.
Un choix a été fait.

Si tu veux faire de l'hyper-optimisé, tu mets l'IDE Arduino à la poubelle, tu prends l'AVR Studio ou Eclipse avec le pack AVR et tu ne programmes qu'en C en n'utilisant que les includes de base des AVR

J'ai installé Sloeber et je suis en train de le tester pour voir...

Cet IDE est bien plus sérieux.
J'ai pas mal de modif à faire car le typage est plus strict.

A bientôt

[electroremy]

Bonjour,

Sloeber est vraiment bien, ça change du coupe Arduino IDE / Notepad++

Il corrige même l'orthographe dans les commentaires, en anglais bien sûr.
C'est peut être un détail mais ça contribua au sérieux de la publication du projet.

Finalement je n'ai pas eu grand chose à modifier, il suffisait d'ajouter #pragma once à quelques fichiers .h, le petit truc à savoir, car Sloeber fait une sorte d'inclusion double avec le .INO

Le projet compilé avec Arduino occupe 30696 octets de flash

Sloeber compile et envoi via AVR dude 28826 dans la flash

La joie fut de courte durée.

Bien que ça compile, rien ne fonctionne : la carte est totalement muette : pas de requête HTTP, pas d'affichage, comme si l'Arduino était planté.
C'est intéressant mais ça va être un sacré défit.
Je ne sais même pas par où commencer

C'est peut-être un truc tout bête (genre configuration de fusibles ou je ne sais quoi d'autre)

A bientôt

[al1_24]

Il corrige même l'orthographe dans les commentaires, en anglais bien sûr.

Tu peux ajouter un dictionnaire de mots français pour une correction des commentaires en français . C'est un paramétrage d'Eclipse (General/Editors/Text editors/Spelling/User defined dictionnary)

[electroremy]

Bonjour,

J'ai remarqué que Sloeber utilisant la version 1.8.3 d'Arduino alors que j'avais fait mon projet avec l'IDE 1.8.12

J'ai pu ajouter la plateforme 1.8.12 de la façon suivante :

Dans D:\...\Sloeber\arduinoPlugin\packages\arduino\hardware\avr
Créer un sous dossier 1.8.12

Puis, dans D:\...\Sloeber\arduinoPlugin\packages\arduino\hardware\avr\1.8.12
Copier le contenu de ce dossier de l'IDE :
D:\...\arduino-1.8.12\hardware\arduino\avr

Sloeber me permet de choisir dans les propriétés du projet la plateforme 1.8.3 ou 1.8.12

Mais le résultat est le même

Je fouille du coté des outils pour trouver des différences entre Sloeber et Arduino 1.8.12
D:\...\Sloeber\arduinoPlugin\packages\arduino\tools

arduinoOTA.exe : identique
avrdude.exe : identique
avr-gcc-7.3.0.exe semble identique (même taille à l'octet près) mais dates différentes et différences vue avec un l'éditeur hexadécimal.

Je copie le contenu de
D:\...\arduino-1.8.12\hardware\tools\avr
dans :
D:\...\Sloeber\arduinoPlugin\packages\arduino\tools\avr-gcc\7.3.0-atmel3.6.1-arduino7\builtin_tools_versions.txt

Remarque : le fichier
D:\...\ARDUINO\arduino-1.8.12\hardware\tools\avr\
contient les lignes suivantes :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
arduino.avrdude=6.3.0-arduino17
arduino.arduinoOTA=1.3.0
arduino.avr-gcc=7.3.0-atmel3.6.1-arduino5

Mais le résultat est toujours identique (code compilé 28826 octets, Arduino muet)

A bientôt

[Delias]

Bonsoir Remy

Tu as compris ce que tu voulais comprendre. Quand je dis de mettre l'IDE Arduino à la poubelle c'est avec tout le code qui y est associé.
Plus de .ino, plus de setup(), plus de loop(), etc.
Toute cette base d'Arduino permet certes d'avoir plein de raccourcis, mais elle est très pénalisante en terme de performance et de taille de code compilé.

Quand on a les connaissances pour aller taper dans les bibliothèques, on a les compétences pour écrire le code sans la béquille Arduino.

Les seules choses Arduino à garder c'est le hardware et le bootloader.

A oui cela nécessite de repartir de 0, ou presque, mais au final tu y passeras moins de temps que de chercher la petite bête dans les bibliothèques.

Bonne suite

Delias

[electroremy]

Quand je dis de mettre l'IDE Arduino à la poubelle c'est avec tout le code qui y est associé.

Donc il faut laisser tomber Sloeber, étant donné qu'il est basé sur un plugin Arduino.

Je comprend ton raisonnement.
Et d'ailleurs, pour aller jusqu'au bout il faudrait se débarrasser aussi du matériel.

Ce que je veux dire, c'est faire un circuit imprimé avec l'Atmega 328 et juste les composants nécessaires.
Et utiliser un module W5500 tout fait, mais plus compact que le shield.

Là on est pro à 100%.
Une commercialisation d'un produit fini est envisageable.
Ce que je ne souhaite pas faire.

Au point où j'en suis, le projet est quasi terminé.
Les optimisation supplémentaires c'est du bonus.
C'est plus un passe temps, gagner des octets de flash comme refaire 20 fois le même jeu vidéo pour chercher le high-score.
Je n'ai plus de problème de performance (j'avais déjà gagné un facteur 15 par rapport à la bibliothèque de base Adafruit)
Le projet a déjà toutes les fonctionnalités requises.
Le projet est stable.
En fait là je suis même en train de chercher quelle fonctionnalité ajouter avec les 2ko de flash qu'il reste de libre car je n'ai plus trop d'idées...

Le plus dur dans un projet informatique... c'est de s'arrêter, car il y a toujours une amélioration à faire

Je suis sur ce projet depuis un an, mais c'est une année qui compte triple, car le COVID en supprimant beaucoup d'activité à libéré du temps !

J'ai un projet de logiciel CAO d'usinage très ambitieux, j'ai commencé à travailler dessus en... 2011 ; il fonctionne, j'ai déjà fait pas mal de pièces avec, mais il n'est pas terminé et pas "publiable". Le sera-t-il un jour ?

Avec Arduino, je veux :
- faire ce projet pour moi, pour équiper ma maison en domotique sur mesure
- partager ce projet.

Mais au sein de la communauté Arduino, quel est le ratio de personnes en mesures de pouvoir comprendre et adapter à ses besoins un projet qui n'utilise pas du tout l'EDI Arduino ?

Après publication, la plus belle récompense c'est de voir son projet utilisé et repris par beaucoup de monde.
Idéalement, quelque chose qui pourrait être publié dans une revue d'électronique en étant facile à construire, facile à programmer, et facile à adapter.
Pour ce faire, quoi de mieux :
- que le matériel Arduino, facile à câbler (il faudra juste un petit circuit imprimé annexe, et encore le câblage sera possible avec un shield proto à pastilles)
- que l'IDE Arduino ; il est limité certes, mais mine de rien je suis quand même parvenu à optimiser pas mal de choses.

A bientôt

[Jay M]

J'ai un projet de logiciel CAO d'usinage très ambitieux, j'ai commencé à travailler dessus en... 2011 ; il fonctionne, j'ai déjà fait pas mal de pièces avec, mais il n'est pas terminé et pas "publiable". Le sera-t-il un jour ?

ça nous rajeunit pas mais "Real Artists Ship"

cela dit, quand on bosse pour soi, on n'a pas de deadline.

[electroremy]

cela dit, quand on bosse pour soi, on n'a pas de deadline.

Tout à fait !

C'est un énorme avantage !

Et en même temps, un énorme inconvénient, car on a tendance à rien finir !

Quand je reprends le travail après des congés, je suis content de passer dans un mode où on termine les choses