Reprise du message précédent :
Il y a compatiblité entre les deux, sauf que c'est pas la même taille.
Me souvient plus comment j'ai fait mon bouzin, mais lib SPI+I2C+Serial = cela rentrait pas dedans > 30Ko.
C'est un peu comme l'arduino, tu as les librairies passe partout et si tu veux optimiser, tu es obligé de faire toi même (ou de recupérer une lib si elle existe) et là pour le coup, les optimisations me semblent assez impressionnantes

Ah ouais!

Hola,

C'est encore moua

Je passe des paramètres dans une fonction via une array :
void ma_fonction(uint8_t *data).

Dans l'idée, je trouvais cela bien, mais dans la pratique c'est relou parce que :
ma_fonction({1,2,3,4});

Et bien cela ne marche pas, quelqu'un a une solution simple à proposer qui compile sous arduino ? J'ai un peu tout tester comme :
(uint8_t *) {1,2,3,4}
ou uint8_t(&a)

A priori, il y a une chtite différence entre arduino & le C classic à ce sujet là

Si je fais : ma_fonction((uint8_t[2]) {1, 2});

J'ai : error: taking address of temporary array

Au pire, j'aurais voulu éviter de faire un truc genre :
uint8_t data[2] = {0}
data[0] = 1;
data[1] = 2;
ma_fonction(data);

Sauf si il y a mieux en C++ tu peux juste faire:
uint8_t data[2]={1,2};
fonction(data);

Par contre attention, ton tableau se transforme en pointeur vers le premier élément -> sizeof ne fonctionne plus (correctement) dans la fonction.

Edit: Autres piste? stdarg.h

Edit2: Tu peux rajouter un const devant le uint8_t, ça peut permettre au compilo de mieux optimiser. Idem pour ton prototype:
uint8_t (const) * const data
Le second const concerne le pointeur, le premier les variables, à ne pas mettre si elles changent bien sûr , mais vu que tu passes des constantes...

Edit3
C'est moche mais ça peut servir:

#define PARAMETER_SET_1 1,2,3,4
#define PARAMETER_SET_2 9,10,11,12
void func(const uint8_t p1, const uint8_t p2, const uint8_t p3, const uint8_t p4)

func(PARAMETER_SET1);

Exact, mais j'ai besoin de plus générique, j'ai plusieurs appel de fonction. Donc si à l'initialisation je peux faire :
uint8_t data[2] = {1,2};
 
Je ne peux plus le faire ensuite
 
Sinon je vais faire une fonction ma_fonction(param1, param2) je sens que cela sera plus rapide

Bah si, tant que tu fous pas const devant ton tableau tu peux modifier les élements ensuite. Par contre oui, tu ne pourras (à ma connaissance) pas réutiliser la syntaxe de l'initialisation.
 
Tu as vu tout mes edit?

J'ai des constantes et des pas constantes
 
La méthode du #define, c'est ce que j'ai utilisé dans ma première version de capteur pour les atinny85.
Cela permet d'économiser mass de la RAM.
 
Par contre c'est ingérable avec 4 modèles différents
Et comme là j'ai de la place et de la RAM avec le STM32, je cherche à faire un truc plus zoli  
 
Au final j'ai fait une fonction bis pour ce cas de figure

A mon avis tu fais fausse route avec ton tableau, enfin peut-être vu le peu de détails que j'ai.  
 
Un tableau = série de valeurs genre mesures etc; sinon c'est pas franchement adapté. Il y a les "struct" aussi sinon pour regrouper des choses. Et tu peux aussi, si c'est adapté à ton cas, utiliser des compilations conditionelles (#ifdef etc).

 
 
Rhoooo *projet secret defense* de pas du tout.
C'est pour les communications SPI/I2C/USART et pas mal d'autres trucs.
 
Pour un exemple concret, j'ai un truc comme. L'utilisation de *data me sauve de la manip normalement

 
Ce que je comprends pas, c'est que je peux passer des valeurs directement, mais à priori pas une array. J'ai trouvé des exemples sur l'internet mais cela fonctionne po.

cas2: Ca veut dire quoi "marche pas", quelle erreur? Dans tout les cas c'est pas du C, mais peut-être valide/possible en C++.
 
Sinon spontanément je mettrais du variadic argument dans ton truc, genre
 
#include <stdarg.h>
spi_write(const uint8_t len, ...)
{
blabla  
}
 
Nan, les ... ne sont pas une faute de frappe, c'est vraiment la syntaxe!

Pour spi_write(uint8_t {0x01, 0x02}, 2);
 
error: too many initializers for 'uint8_t' {aka 'unsigned char'}
 
Sinon, sur l'internet il y a : spi_write((uint8_t []) {1, 2, 3}, 2); :
 
error: taking address of temporary array

https://www.geeksforgeeks.org/variadic-functions-in-c/
 
Tu pourra pas balancer un tableau mais ça fera le job.

Le problème c'est que j'ai besoin de balancer une array
Par exemple dans le cas d'un buffer, j'ai une array[] que je remplis en amont avant de l'écrire via le port SPI

rdc l'avait proposé, cela répond d'ailleurs à mon interrogation ultime de comment pouvait bien fonctionner printf

Je comprend pas pourquoi tu veux un array? La boule de cristal me dit que tes valeurs viennent d'une autre fonction et que tu sais pas comment faire autrement?

Regarde (typedef) struct.

PS: Les variadic c'est très drôle en C/assembleur mixte aussi.

Sinon y'a toujours moyen de se compliquer la vie et faire des abominations(?) de ce genre.
 

 
Edit:

 
Je sors. (quoi que peut-être, peut-être ça peut t'aider...)

Dans l'exemple d'un buffer de taille indeterminée

Ton exemple est sympathique, mais j'ai plus vite fait de faire le cas spi(data1, data2); (ce que j'ai fait)

[edit]Sinon spi("\0\1\2" ); ? ^^
Mais j'ai des char d'un côté, et des bytes de l'autre cote et le compilo est po content
Et bon, une string, c'est une array de char ...

Mon exemple n'était qu'a moitié sérieux. Ca compile, ça tourne, mais je ne parlais pas d'abomination pour rien.  
 
Le soucis avec les char c'est que ça peut être signé ou non signé et par défaut (sur mon GCC, pas sûr ce que dit le standard) c'est signé. Donc compilateur qui va râler, ça peut poser des soucis et en plus c'est moche. Go différentes fonctions, sachant que tu peux - pour éviter du code en double et faciliter p.ex. le portage vers une autre base hardware - faire une seule fonction send_byte et puis différentes fonctions genre send_array, send_values3(u8, u8, u8), ... qui ne feront qu'appeler (avec une boucle si besoin) la fonction send_byte. C'est un peu l'idée des HAL (hardware abstraction layer). Avec l'optimisation du compilateur ça sera pas mal du tout.
 
D'ailleurs cette optimisation, elle est réglée sur quoi? Arduino utilise toujours GCC non? Je suppose que c'est -Os par défaut, donc taille du code; mais si on peut autant régler sur -O1/-O2 voir -O3 pour gagner en vitesse (plus ou moins) au détriment de la taille du firmware.
 
Et tant que tu bricoles les réglages compilo autant vérifier que -Wall -Wextra sont bien présents, c'est indispensable! Perso mon code final je le compile avec -Werror aussi, mais c'est pas pratique pour du développement en cours, la moindre variable inutilisée p.ex. va faire échouer la compilation (car il y aura un warning qui avec -Werror se transforme en erreur).

Faudrait que je les rajoute, mais actuellement je prefere pas trop de warning
 
Ce que je voulais dire par array de char, c'est qu'il l'accepte bien en passage de parametre. Donc pourquoi une array de int cela passe pas

Les warnings sont là pour t'aider! Un warning = un truc douteux qui ne fera pas ce que tu veux (en gros).
 
Pour le reste j'ai pas compris. Un string en mémoire c'est un tableau avec '\0' comme dernier élément, par contre pour le compilateur bah ça reste un string, pas un tableau.

un string c'est une suite de byte, donc s'il peut passer une suite de byte en parametre, il devrait pouvoir passer une suite de type {1,2,3}

Visiblement le C n'est pas fichu ainsi.  
 
(Désolé, j'ai le cerveau en compote...)

tu voulais dire qu'il n'est pas fichu ANSI ?

Je suis en train de bricoler une useless box avec du caractère.
Je vais faire différentes fonctions qui vont répondre différemment au basculement de l'inter.
Je vais utiliser le générateur aléatoire (seed sur une entrée analogique en l'air) pour déterminer quelle fonction appeler.
 
=> le générateur va me renvoyer un int, comment je fait pour appeler telle ou telle fonction ?
 
Je n'ai pas envie d'avoir une grosse fonction avec un gros case.
Je préférerais éclater chaque mouvement dans sa propre fonction.

Un tableau de paires <int,pointeur de fonction> ordonnés par clé croissante ( https://en.cppreference.com/w/cpp/container/map quand t'as un vrai proc )
Et une fonction qui parcours le tableau tant que la clé est inférieure à la clé tirée au sort et va taper dans la fonction pointée.
 
T'as plus qu'à répartir tes clés entre ton entier min et ton entier max issus de random()  

Fait plutot avec du bois ou du plastique, c'est mieux  
J'en ai fait une il y a quelques années, c'est marrant. Je te conseille de faire un debugger avec du telnet ou de l'UART pour pas passer des heures à configurer les mouvements

Dans tous les cas, ce sera un switch case ou sinon une série de if elseif, mais cela reviendra au même. Voir une array avec des pointeurs vers tes fonctions, mais cela changera pas grand chose.
Tout dépend de ce que tu veux faire au final, du nombre de moteur, des mouvements multiples en même temps, etc etc

La question c'est aussi comment tu vois les actions possibles

-----------

Sinon sur stm32, c'est rigolo les interruptions. Elles sont définies par ligne. Donc PA0 PB0 PC0 ... sont sur la même ligne. Impossible de savoir qui a lancé l'interruption entre chaque. /o\

Je pensais à un truc du genre ce qu'a dit Natospi : un tableau avec les pointeurs des fonctions, et j'appelle directement la fonction à l'élément n du tableau.
Bon pour le moment j'ai mis un gros case ...

Sinon la uselessbox on me la fournit c'est la classique en bois à 16e sur amazon.
Je vais au plus simple : j'ai démonté un servo pour récupérer l'elec et le potar de positionnement.
Je mets le potar sur l'axe du bras.
Je prends un digispark attiny85
L'idée étant que ça arrive à fonctionner avec les 2 piles d'origine.
Je mets sur l'inter principal l'alimentation du montage en parallèle de l'inter de repos.
Ainsi au repos tout est débranché.
Si on active l'inter principal le montage est sous tension.
Le bras va aller basculer l'interupteur avec un mouvements au pif.
Lorsque l'inter est remis en position "repos" alors le montage est toujours alimenté par l'inter de repos.
Puis le bras va revenir au repos et ça coupera le montage.
Voici la première version ultra beta car je n'ai même pas encore câblé les inters ou collé le potar.
Ya 5 mouvements pour le moment.

Nb : pas de debug, l'usb de mon digispark est flingué donc je le programme vis un USBtinyISP.
Nb2 : oui il y a une boucle infinie à la fin car le montage est sensé se mettre hors tension.

C'est la version de base, ensuite il y a beaucoup plus simple, mais je sais pas si tu veux la solution.
Sans possibilité de debugger, cela peut etre long pour tester les positions. Si tu as un autre uC, fait peut etre avec lui pour tester ? Les coordonnées restent les mêmes.

Vas y balance, je ne suis pas là pour chercher  
maintenant que le case est fait c'est pas dit que je modifie mais j'aurais bien voulu savoir.

Rholalalala, les djeunz jvous jure ^^

[reedit]Si tu veux faire plus compliqué, tu rajoutes des codes conditions genre 0xFFFE :

Ok je crois que j'ai capté, mais du coup mon but c'était que ce soit plus lisible, et là c'est l'inverse

Sur les actions de ce type, je crois pas qu'il y ai plus simple et lisible que de faire défiler une liste de séquence
 
Par exemple, le cas 3 :
 
{pos_entreouvre, 700, pos_hide, 700, pos_entrouve, 700, 0xFFFE, 0, 0xFFFF, 0xFFFF}
 
Ensuite c'est toi qui écrit donc faut que ce soit compréhensible pour toi.

Faut passer par des struct et enum; ça sera clair et concis. Mais pas le temps de pisser un exemple là.

Bon, après avoir viré le framework arduino dans platformio, viré les librairies HAL que j'utilise pas.
Le programme passe de 16K à 8K et la RAM de 2K à 800o

Et en plus, cela a l'air de fonctionner

Au final, il a fallu tout refaire (joie) car bizarrement il n'y a pas vraiment de librairie. Mais bon, avec la version "finger in the noize" c'était > 30K

Beau boulot froggy.  
 
@crazytiti:
Voila ce que je propose. Non testé.
 

Merci, mais trop contraignant.
J'ai des moves vraiment différents avec une trop grande quantité d'actions variables.
Et faut que je le finisse avant jeudi, donc priorité : que ça fonctionne peut importe la gueule du code

Je connais ça, c'est jamais bien.

PS: tableau de pointeurs de fonctions?

Non mais il va finir avec des if/elseif degueulasse
 
Au moins, ce n'est pas généré par une IA

Bon, j'ai share les librairies de base si jamais :
https://github.com/FroggyCorp/STM32-LL-Libraries/

Voila la useless box est terminé avec 1/2h d'avance
Avec plus de temps j'aurais mis d'autres moves mais ça faisait partit du challenge.

Vidéo démo https://youtu.be/-WEoi6DMTlU

Le code sur mon github https://github.com/crazytiti/uselessbox/tree/main
Nb : pas un seul if / else

Si, c'est possible en utilisant une compound-litteral (une feature introduite en C99):

La clé est le "cast" (les parens) autour du type avant la liste d'init.

edit: testé sur ardunio ide, en effet avec ce compilo moyen ageux il veux pas.
Il traite en erreur ce qui ne devrait etre qu'un warning (et encore...) "taking address of temporary array"