Couper une chaine de charactere pour revenir à la ligne entre les mots

Bonjour,
Je m'initie à la programmation et je galère sur un sujet.
A partir d'une chaine de caractère trop longue, au lieu de couper au milieu d'un mot pour revenir à la ligne (base de l'Arduino) j'aimerais pouvoir couper entre deux mots (au niveau du dernier espace avant de dépasser la taille de l'écran).
J'aimerais pouvoir du coup centrer le string complète en largeur et en hauteur en fonction du nombre de characteres et de lignes qu'il en ressort.
Est ce que vous pensez qu'on peut optimiser le positionnement pour que ce soit harmonieux (par exemple si il y a 10 mots, que ça fasse deux lignes de 5 au lieu d'une ligne de 8 et une ligne de 2 mots ?)

#define SIGNATURE "chaine de characteres sur plusieurs lignes centrée sur l'ecran en hauteur et en largeur"

void loop()
{
    tft.setFont(&FreeMono9pt7b);
    tft.setRotation(1); //pour tourner à 90°
    tft.fillScreen(BLACK);
    int width = tft.width();
    int height = tft.height();
    tft.drawRect(0, 0, width, height, WHITE);
    tft.setTextColor(WHITE);
    centerprint(SIGNATURE,50);
}

void centerprint(const char *s, int y)
{
    int len = strlen(s) * 12; // => 12 car c'est la largeur d'un caractère pour la police utilisée actuellement
    tft.setTextColor(WHITE);
    tft.setCursor((dispx - len) / 2, y);
    tft.print(s);
}

Merci d'avance pour votre aide.
SBands

Ça ressemble à un projet scolaire, est-ce le cas ?

Vous n’avez fait aucun effort pour le code…

Commencez par nous expliquer en français comment vous feriez pour réaliser cette tâche à la main à base d’instructions simples.

Voici un petit bout de code pour vous aider à séparer les mots, les compter et voir leur taille.

const size_t pageWidth = 20; // number of characters
const size_t maxWords = 100; // number of characters

char message[] = "This text has many words. In some languages you need UTF8 which will mess up the outcome of this algorithm. Also depending on language the '!' or '?' can be attached to the word or separated by space. That will possibly be an issue to deal with.";
char* wordPointers[maxWords];

size_t wordCount(char* buffer, const char* separators = " ")
{
  size_t count = 0;
  char* ptr = strtok(buffer, separators);
  while (ptr) {
    if (count < maxWords) wordPointers[count] = ptr;
    count++;
    ptr = strtok(NULL, separators);
  }
  return count;
}

void setup()
{
  Serial.begin(115200);
  size_t numberOfWords = wordCount(message);
  if (numberOfWords >= maxWords) {
    Serial.println(F("Erreur: trop de mots"));
    while (true); // on arrête là
  }

  Serial.print(F("Nombre de mots = "));
  Serial.println(numberOfWords);

  for (size_t i = 0; i < numberOfWords; i++) {
    Serial.print(i + 1);
    Serial.print(F("\t L = "));
    Serial.print(strlen(wordPointers[i]));
    Serial.print(F("\t\t["));
    Serial.print(wordPointers[i]);
    Serial.println(F("]"));
  }
}

void loop() {}

la console série (à 115200 bauds) vous dira:

Nombre de mots = 47
1	 L = 4		[This]
2	 L = 4		[text]
3	 L = 3		[has]
4	 L = 4		[many]
5	 L = 6		[words.]
6	 L = 2		[In]
7	 L = 4		[some]
8	 L = 9		[languages]
9	 L = 3		[you]
10	 L = 4		[need]
11	 L = 4		[UTF8]
12	 L = 5		[which]
13	 L = 4		[will]
14	 L = 4		[mess]
15	 L = 2		[up]
16	 L = 3		[the]
17	 L = 7		[outcome]
18	 L = 2		[of]
19	 L = 4		[this]
20	 L = 10		[algorithm.]
21	 L = 4		[Also]
22	 L = 9		[depending]
23	 L = 2		[on]
24	 L = 8		[language]
25	 L = 3		[the]
26	 L = 3		['!']
27	 L = 2		[or]
28	 L = 3		['?']
29	 L = 3		[can]
30	 L = 2		[be]
31	 L = 8		[attached]
32	 L = 2		[to]
33	 L = 3		[the]
34	 L = 4		[word]
35	 L = 2		[or]
36	 L = 9		[separated]
37	 L = 2		[by]
38	 L = 6		[space.]
39	 L = 4		[That]
40	 L = 4		[will]
41	 L = 8		[possibly]
42	 L = 2		[be]
43	 L = 2		[an]
44	 L = 5		[issue]
45	 L = 2		[to]
46	 L = 4		[deal]
47	 L = 5		[with.]

Attention si vous n’êtes pas en ASCII (caractères étendus UTF8 avec les accents etc) le nombre d’octets occupés par une chaîne n’est pas forcément représentatif de sa dimension…

En français on sépare un ‘!’ ou un ‘?’ à la fin de la phrase, il faudra intégrer des règles spécifiques pour les conserver accrochés au mot précédent sinon ça ne fera pas joli