Différences entre versions de « Arduino Memoire Optimiser SRAM »

De MCHobby - Wiki
Sauter à la navigation Sauter à la recherche
 
(22 versions intermédiaires par le même utilisateur non affichées)
Ligne 4 : Ligne 4 :
 
Cette partie du tutoriel s'attarde sur l'optimisation de la mémoire SRAM.
 
Cette partie du tutoriel s'attarde sur l'optimisation de la mémoire SRAM.
  
SRAM is the most precious memory commodity on the Arduino. Although SRAM shortages are probably the most common memory problems on the Arduino. They are also the hardest to diagnose. If your program is failing in an otherwise inexplicable fashion, the chances are good you have crashed the stack due to a SRAM shortage.
+
SRAM est l'une des denrées les plus précieuses sur Arduino. Le manque de mémoire SRAM est probablement le problème de mémoire le plus répandu sur Arduino mais aussi le plus difficile à diagnostiquer.  
  
There are a number of things that you can do to reduce SRAM usage.  
+
Si votre programme plante de façon inexplicable, il y a des chances pour que vous soyez face à un crash de la ''stack'' (la pile) dut à un manque de mémoire SRAM.
  
These are just a few guidelines here under to get you started.
+
Il y a pas mal de choses qui peuvent être réalisée pour réduire la consommation de SRAM.
 +
 
 +
Nous en avons repris quelques lignes directrices ci-dessous pour vous aider à démarrer.
  
 
== Eliminer les variables inutilisées ==
 
== Eliminer les variables inutilisées ==
If you are not sure whether a variable is being used or not, comment it out. If the sketch still compiles, get rid of it!  
+
Si vous ne savez pas si telle ou telle variable est utilisée, mettez la en commentaire.
 +
 
 +
Si votre sketch/croquis compile encore alors cela signifie qu'elle est inutile et que vous pouvez l'éliminer!
  
 
== F() ces Strings! ==
 
== F() ces Strings! ==
Ligne 18 : Ligne 22 :
 
Le type String permet de stocker une chaine de caractère.
 
Le type String permet de stocker une chaine de caractère.
  
Literal strings are repeat memory offenders. First they take up space in the program image in Flash, then they are copied to SRAM at startup as static variables. This is a horrible waste of SRAM since we will never be writing to them.
+
Les chaines de caractères littérales (''literal strings'') sont des délinquants récidivistes emportant votre précieuse mémoire SRAM. Plus sérieusement ces chaînes de caractères sont de gigantesques consommateurs de SRAM.
  
Paul Stoffregen of PJRC and Teensyduino fame developed the F() macro as a super-simple solution to this problem. The F() macro tells the compiler to keep your strings in PROGMEM. All you have to do is to enclose the literal string in the F() macro.
+
Pour commencer, ces chaines de caractères utilise de la place dans la mémoire Flash (l'image du programme) et elle sont ensuite copiée en SRAM lors de l'initialisation des variables statiques. Quel horrible gaspillage de mémooire SRAM étant donné que nous n'allons jamais écrire dedans.
  
For example, replacing this:  
+
Paul Stoffregen de PJRC et Teensyduino have développé la macro F() qui offre une solution super-simple a ce problème. La macro F() indique au compilateur de garder la chaine de caractère dans la PROGMEM (la mémoire flash qui stocke le programme). Tout ce que vous avez à faire, c'est d'enfermer la chaine littérale dans la macro F().
 +
 
 +
Par exemple, vous pouvez remplacer le code suivant :  
 
  <nowiki>Serial.println("Sram sram sram sram. Lovely sram! Wonderful sram! Sram sra-a-a-a-a-am sram sra-a-a-a-a-am sram. Lovely sram! Lovely sram! Lovely sram! Lovely sram! Lovely sram! Sram sram sram sram!");</nowiki>
 
  <nowiki>Serial.println("Sram sram sram sram. Lovely sram! Wonderful sram! Sram sra-a-a-a-a-am sram sra-a-a-a-a-am sram. Lovely sram! Lovely sram! Lovely sram! Lovely sram! Lovely sram! Sram sram sram sram!");</nowiki>
  
with this:
+
avec celui ci:
 
  <nowiki>Serial.println(F("Sram sram sram sram. Lovely sram! Wonderful sram! Sram sra-a-a-a-a-am sram sra-a-a-a-a-am sram. Lovely sram! Lovely sram! Lovely sram! Lovely sram! Lovely sram! Sram sram sram sram!"));</nowiki>
 
  <nowiki>Serial.println(F("Sram sram sram sram. Lovely sram! Wonderful sram! Sram sra-a-a-a-a-am sram sra-a-a-a-a-am sram. Lovely sram! Lovely sram! Lovely sram! Lovely sram! Lovely sram! Sram sram sram sram!"));</nowiki>
  
Will save you 180 bytes of wonderful SRAM!  
+
Et vous allez économiser 180 bytes/octets de notre merveilleuse SRAM!
 +
 
 +
== Réservez l'espace des chaines de caractères ==
 +
 
 +
Dans la libraire srting Arduino dévolue aux chaines de caractères, il existe la fonction '''fonction reserve()''' qui permet de réserver un espace mémoire (''buffer'' en anglais) pour une string.
 +
 
 +
L'idée en de prévenir la fragmentation de la ''heap'' (le tas) en utilisant ''reserve(num)'' pour pré-allouer la mémoire d'un chaine de caractère destinée à grandir.
  
== Réservez l'espace de vos Strings ==
+
Avec la mémoire déjà allouée, String n'a pas besoin d'appeler realloc() lorsque la longueur de la chaine de caractère augmente.
  
The Arduino string library allows you to reserve buffer space for a string with the '''fonction reserve()'''. The idea is you can prevent String from fragmenting the heap by using reserve(num) to pre-allocate memory for a String that grows.
+
Dans la plupart des cas d'utilisation, beaucoup de petits objets String sont temporairement utilisés  pendant que vous effectuez ce type d'opération (agrandissement de la string). Cela force l'allocation d'une nouvelle chaine de caractères sur la ''Heap'' (le tas) laissant ainsi un grand trou à la position ou se trouvait l'ancienne string. C'est ainsi que l'on obtient une mémoire.  
  
With the memory already allocated, String doesn't need to call realloc() if the string grows in length. In most usages, lots of other little String objects are used temporarily as you perform these operations, forcing the new string allocation to a new area of the heap and leaving a big hole where the previous one was (memory fragmentation). Usually all you need to do is use reserve() on any long-lived String objects that you know will be increasing in length as you process text.
+
Habituellement, tout ce que vous avez besoin de faire, c'est un '''reserve()''' sur les objets String ayant une longue durée de vie et dont vous savez pertinent que le longueur va augmenter au fur et à mesure que votre programme effectue ses traitements.
  
You can do better with C strings, but if you just follow these guidelines for String objects, they work nearly as efficiently and using them is so much easier.
+
Vous pouvez obtenir de meilleurs résultats avec les 'C strings' mais si vous suivez ces recommandations sur les objets String, vous obtiendrez presque la même efficacité en les utilisant bien plus facilement.
  
 
== Placer vos données constantes en PROGMEM ==
 
== Placer vos données constantes en PROGMEM ==
Data items declared as PROGMEM do not get copied to SRAM at startup. They are a little less convenient to work with, but they can save significant amounts of SRAM. The basic Arduino reference for PROGMEM is [http://arduino.cc/en/Reference/PROGMEM here] (''Anglais, Arduino.CC''). And there is a more detailed tutorial on the subject [http://www.avrfreaks.net/index.php?name=PNphpBB2&file=viewtopic&t=38003 here] (''Anglais, AVRFreaks.Net'').
+
Les données déclarées comme PROGMEM ne sont pas copiées en SRAM au démarrage du sketch/croquis.  
 +
 
 +
Il est un peu moins facile de travailler avec ces donnée mais cela économise une quantité significative de mémoire SRAM. Vous trouverez [http://arduino.cc/en/Reference/PROGMEM les références de PROGMEM sur le site d'Arduino.CC] (''Anglais, Arduino.CC''). Finalement, vous trouverez des informations détaillée dans [http://www.avrfreaks.net/index.php?name=PNphpBB2&file=viewtopic&t=38003 ce tutoriel traitant de ce sujet] (''Anglais, AVRFreaks.Net'').
  
 
== Réduire la taille des Buffers ==
 
== Réduire la taille des Buffers ==
  
=== Allocation des Buffers et Array ===
+
=== Allocation des tableaux et mémoires tampons ===
If you allocate a buffer, make sure it is no bigger than it needs to be.
+
Si vous allouez des tableau (''Array'') et des mémoires tampons (''buffers''), assurez vous de ne pas les faire plus grand que vraiment nécessaire.
  
=== Buffers dans les librairies ===
+
=== Mémoire tampons dans les librairies ===
Also be aware that some libraries allocate buffers behind the scenes that may be candidates for trimming as well.
+
Vous devez également savoir que certaines librairies allouent des mémoires tampons (''buffer'') pour leur bon fonctionnement. Ces derniers peuvent aussi être des candidats pour les cure d'amaigrissement.
  
=== Buffers bystèmes ===
+
=== Mémoire tampon systèmes ===
Another buffer hidden deeply in the system is the 64 byte serial receive buffer. If your sketch is not receiving a lot of high-speed serial data, you can probably cut this buffer size in half - or maybe even less.
+
Une autre mémoire tampon (''buffer'') caché très profondément dans le système est le buffer de 64 bytes/octets de réception pour la connexion série.  
  
The Serial buffer size is defined in HardwareSerial.cpp. This file can be found in your Arduino install directory:
+
Si votre croquis/sketch ne recoit pas beaucoup de données à haute vitesse, vous pouvez probablement diviser la taille de ce buffer par 2 (ou peut-être même plus).
 +
 
 +
La taille du buffer série est définie dans HardwareSerial.cpp. Ce fichier peut être trouvé dans votre répertoire d'installation Arduino.:
  
 
'''....\Arduino-1.x.x\hardware\arduino\cores\arduino\HardwareSerial.cpp'''
 
'''....\Arduino-1.x.x\hardware\arduino\cores\arduino\HardwareSerial.cpp'''
  
Look for the line:
+
Cherchez après la ligne:
  
 
'''#define SERIAL_BUFFER_SIZE 64'''
 
'''#define SERIAL_BUFFER_SIZE 64'''
  
And change it to 32 or less.
+
et changez la valeur 64 vers 32 (ou moins).
  
 
== Réduire les variables surdimensionnées ==
 
== Réduire les variables surdimensionnées ==
Don't use a float when an int will do. Don't use an int when a byte will do. Try to use the smallest data type capable of holding the information.  
+
N'utilisez pas un "float" lorsqu'un "int" suffirait. N'utilisez pas un "int" si un "byte" convient.  
  
xxx
+
Essayez d'utiliser le plus petit type de donnée capable de contenir l'information.
 +
 
 +
{| class="wikitable" border="1"
 +
|-
 +
| align="center" | Types de données
 +
| align="center" | Taille en octets/Bytes
 +
| align="center" | Peut contenir:
 +
|- style="font-size: 90%"
 +
| align="left" | boolean
 +
| align="left" | 1
 +
| align="left" | true (1, pour ''vrai'') ou false (0, pour ''faux'')
 +
|- style="font-size: 90%"
 +
| align="left" | char
 +
| align="left" | 1
 +
| align="left" | Un caractères ASCII ou une valeur signée entre -128 et 127
 +
|- style="font-size: 90%"
 +
| align="left" | unsigned char, byte, uint8_t
 +
| align="left" | 1
 +
| align="left" | Un caractères ASCII ou une valeur '''non signée''' entre 0 et 255
 +
|- style="font-size: 90%"
 +
| align="left" | int, short
 +
| align="left" | 2
 +
| align="left" | Une valeur signée entre -32.768 et 32767. Int est le diminutif de ''Ingeter'' signifiant "Entier".
 +
|- style="font-size: 90%"
 +
| align="left" | unsigned int, word, uint16_t
 +
| align="left" | 2
 +
| align="left" | Une valeur '''non signée''' entre 0 et 65535.
 +
|- style="font-size: 90%"
 +
| align="left" | long
 +
| align="left" | 4
 +
| align="left" | Une valeur signée entre -2.147.483.648 et 2.147.483.647
 +
|- style="font-size: 90%"
 +
| align="left" | unsigned long, uint32_t
 +
| align="left" | 4
 +
| align="left" | Valeur '''non signée''' entre 0 et 4.294.967.295
 +
|- style="font-size: 90%"
 +
| align="left" | float, double
 +
| align="left" | 4
 +
| align="left" | Une valeur en virgule flottante (''floating point value'' en anglais) dont la valeur est comprise entre -3,4028235E-38 et 3,4028235E+38.<br />Note: Sur cette plateforme, le ''double'' est identique au ''float'').
 +
|}
  
 
== Pensez globalement. Allouez localement ==  
 
== Pensez globalement. Allouez localement ==  
Let's have another look at how SRAM is used (and abused):
+
Revenon sur notre diagramme d'utilisation (et d'abus) de la SRAM:
 +
 
 +
{{ADFImage|Arduino-Memoire-41.jpg|480px}}
 +
<small>Traduction par MCHobby.be</small>
 +
 
 +
=== Variables Globales et Statiques ===
 +
 
 +
Les variables globales et statiques sont les premières variables à être chargées en SRAM. Elle repousse le début de la ''heap'' (le tas) vers la ''stack'' (la pile) '''et occuperont cet espace pour l'éternité'''.
 +
 
 +
=== Allocations dynamiques ===
 +
L'allocation dynamique des données et objets fait grandit la ''heap'' (tas) en direction de la ''stack'' (tas).
 +
 
 +
Au contraire des variables globales et statiques, ces variables peuvent être désallouée (de-allocated) pour libérer de l'espace mémoire. '''Mais cela n'implique pas forcement une diminution/réduction de la taille de la ''heap'' (tas)!'''. S'il y a d'autre données dynamiques au dessus de la désallocation, le dessus de la ''heap'' (tas) ne bouge pas. Lorsque la ''heap'' (tas) est plein de trou comme un fromage suisse on dit que la "'''heap est fragmenté'''".
 +
 
 +
=== Variables Locales ===
 +
Chaque appel de fonction crée un "stack frame" qui contient des informations importantes (critiques) lors du retour d'appel de fonction. Ce "stack frame" est empilé sur la ''stack'' (la pile) avant l'appel de fonction ce qui fait grossir la ''stack'' qui se rapproche de la ''heap'' (le tas).
 +
 
 +
Chaque "stack frame" contient:
 +
 
 +
* Tous les paramètres passés à la fonction
 +
* toutes les variables locales déclarées dans la fonction
 +
 
 +
Ces données sont utilisables à l'intérieur de la fonction, mais '''l'espace est récupéré à 100% à la sortie de la fonction'''!
 +
 
 +
=== Les bons trucs! ===
 +
* '''Evitez les allocation dynamiques sur la heap''' - Elle peuvent rapidement fragmenter l'espace disponible pour la ''heap'' (tas).
 +
* '''Préférez les allocations locale aux allocations globales''' - les variables sur la ''stack'' pile n'existent que durant leur utilisation. '''SI''' vous avez des variables qui ne sont utilisées que dans une petite section de votre code '''ALORS''' considérez l'utilisation d'une fonction avec cette variable déclarée dans la fonction.
 +
 
 +
{{Arduino-Memoire-TRAILER}}

Version actuelle datée du 5 septembre 2013 à 16:11


MCHobby investit du temps et de l'argent dans la réalisation de traduction et/ou documentation. C'est un travail long et fastidieux réalisé dans l'esprit Open-Source... donc gratuit et librement accessible.
SI vous aimez nos traductions et documentations ALORS aidez nous à en produire plus en achetant vos produits chez MCHobby.

Introduction

Cette partie du tutoriel s'attarde sur l'optimisation de la mémoire SRAM.

SRAM est l'une des denrées les plus précieuses sur Arduino. Le manque de mémoire SRAM est probablement le problème de mémoire le plus répandu sur Arduino mais aussi le plus difficile à diagnostiquer.

Si votre programme plante de façon inexplicable, il y a des chances pour que vous soyez face à un crash de la stack (la pile) dut à un manque de mémoire SRAM.

Il y a pas mal de choses qui peuvent être réalisée pour réduire la consommation de SRAM.

Nous en avons repris quelques lignes directrices ci-dessous pour vous aider à démarrer.

Eliminer les variables inutilisées

Si vous ne savez pas si telle ou telle variable est utilisée, mettez la en commentaire.

Si votre sketch/croquis compile encore alors cela signifie qu'elle est inutile et que vous pouvez l'éliminer!

F() ces Strings!

(Stocker les char* dans le PROGMEM de l'architecture Harvard).
PROGMEM signifie "Mémoire Programme", la mémoire Flash allouée au stockage du programme

Le type String permet de stocker une chaine de caractère.

Les chaines de caractères littérales (literal strings) sont des délinquants récidivistes emportant votre précieuse mémoire SRAM. Plus sérieusement ces chaînes de caractères sont de gigantesques consommateurs de SRAM.

Pour commencer, ces chaines de caractères utilise de la place dans la mémoire Flash (l'image du programme) et elle sont ensuite copiée en SRAM lors de l'initialisation des variables statiques. Quel horrible gaspillage de mémooire SRAM étant donné que nous n'allons jamais écrire dedans.

Paul Stoffregen de PJRC et Teensyduino have développé la macro F() qui offre une solution super-simple a ce problème. La macro F() indique au compilateur de garder la chaine de caractère dans la PROGMEM (la mémoire flash qui stocke le programme). Tout ce que vous avez à faire, c'est d'enfermer la chaine littérale dans la macro F().

Par exemple, vous pouvez remplacer le code suivant :

Serial.println("Sram sram sram sram. Lovely sram! Wonderful sram! Sram sra-a-a-a-a-am sram sra-a-a-a-a-am sram. Lovely sram! Lovely sram! Lovely sram! Lovely sram! Lovely sram! Sram sram sram sram!");

avec celui ci:

Serial.println(F("Sram sram sram sram. Lovely sram! Wonderful sram! Sram sra-a-a-a-a-am sram sra-a-a-a-a-am sram. Lovely sram! Lovely sram! Lovely sram! Lovely sram! Lovely sram! Sram sram sram sram!"));

Et vous allez économiser 180 bytes/octets de notre merveilleuse SRAM!

Réservez l'espace des chaines de caractères

Dans la libraire srting Arduino dévolue aux chaines de caractères, il existe la fonction fonction reserve() qui permet de réserver un espace mémoire (buffer en anglais) pour une string.

L'idée en de prévenir la fragmentation de la heap (le tas) en utilisant reserve(num) pour pré-allouer la mémoire d'un chaine de caractère destinée à grandir.

Avec la mémoire déjà allouée, String n'a pas besoin d'appeler realloc() lorsque la longueur de la chaine de caractère augmente.

Dans la plupart des cas d'utilisation, beaucoup de petits objets String sont temporairement utilisés pendant que vous effectuez ce type d'opération (agrandissement de la string). Cela force l'allocation d'une nouvelle chaine de caractères sur la Heap (le tas) laissant ainsi un grand trou à la position ou se trouvait l'ancienne string. C'est ainsi que l'on obtient une mémoire.

Habituellement, tout ce que vous avez besoin de faire, c'est un reserve() sur les objets String ayant une longue durée de vie et dont vous savez pertinent que le longueur va augmenter au fur et à mesure que votre programme effectue ses traitements.

Vous pouvez obtenir de meilleurs résultats avec les 'C strings' mais si vous suivez ces recommandations sur les objets String, vous obtiendrez presque la même efficacité en les utilisant bien plus facilement.

Placer vos données constantes en PROGMEM

Les données déclarées comme PROGMEM ne sont pas copiées en SRAM au démarrage du sketch/croquis.

Il est un peu moins facile de travailler avec ces donnée mais cela économise une quantité significative de mémoire SRAM. Vous trouverez les références de PROGMEM sur le site d'Arduino.CC (Anglais, Arduino.CC). Finalement, vous trouverez des informations détaillée dans ce tutoriel traitant de ce sujet (Anglais, AVRFreaks.Net).

Réduire la taille des Buffers

Allocation des tableaux et mémoires tampons

Si vous allouez des tableau (Array) et des mémoires tampons (buffers), assurez vous de ne pas les faire plus grand que vraiment nécessaire.

Mémoire tampons dans les librairies

Vous devez également savoir que certaines librairies allouent des mémoires tampons (buffer) pour leur bon fonctionnement. Ces derniers peuvent aussi être des candidats pour les cure d'amaigrissement.

Mémoire tampon systèmes

Une autre mémoire tampon (buffer) caché très profondément dans le système est le buffer de 64 bytes/octets de réception pour la connexion série.

Si votre croquis/sketch ne recoit pas beaucoup de données à haute vitesse, vous pouvez probablement diviser la taille de ce buffer par 2 (ou peut-être même plus).

La taille du buffer série est définie dans HardwareSerial.cpp. Ce fichier peut être trouvé dans votre répertoire d'installation Arduino.:

....\Arduino-1.x.x\hardware\arduino\cores\arduino\HardwareSerial.cpp

Cherchez après la ligne:

#define SERIAL_BUFFER_SIZE 64

et changez la valeur 64 vers 32 (ou moins).

Réduire les variables surdimensionnées

N'utilisez pas un "float" lorsqu'un "int" suffirait. N'utilisez pas un "int" si un "byte" convient.

Essayez d'utiliser le plus petit type de donnée capable de contenir l'information.

Types de données Taille en octets/Bytes Peut contenir:
boolean 1 true (1, pour vrai) ou false (0, pour faux)
char 1 Un caractères ASCII ou une valeur signée entre -128 et 127
unsigned char, byte, uint8_t 1 Un caractères ASCII ou une valeur non signée entre 0 et 255
int, short 2 Une valeur signée entre -32.768 et 32767. Int est le diminutif de Ingeter signifiant "Entier".
unsigned int, word, uint16_t 2 Une valeur non signée entre 0 et 65535.
long 4 Une valeur signée entre -2.147.483.648 et 2.147.483.647
unsigned long, uint32_t 4 Valeur non signée entre 0 et 4.294.967.295
float, double 4 Une valeur en virgule flottante (floating point value en anglais) dont la valeur est comprise entre -3,4028235E-38 et 3,4028235E+38.
Note: Sur cette plateforme, le double est identique au float).

Pensez globalement. Allouez localement

Revenon sur notre diagramme d'utilisation (et d'abus) de la SRAM:

Arduino-Memoire-41.jpg
Crédit: AdaFruit Industries www.adafruit.com Traduction par MCHobby.be

Variables Globales et Statiques

Les variables globales et statiques sont les premières variables à être chargées en SRAM. Elle repousse le début de la heap (le tas) vers la stack (la pile) et occuperont cet espace pour l'éternité.

Allocations dynamiques

L'allocation dynamique des données et objets fait grandit la heap (tas) en direction de la stack (tas).

Au contraire des variables globales et statiques, ces variables peuvent être désallouée (de-allocated) pour libérer de l'espace mémoire. Mais cela n'implique pas forcement une diminution/réduction de la taille de la heap (tas)!. S'il y a d'autre données dynamiques au dessus de la désallocation, le dessus de la heap (tas) ne bouge pas. Lorsque la heap (tas) est plein de trou comme un fromage suisse on dit que la "heap est fragmenté".

Variables Locales

Chaque appel de fonction crée un "stack frame" qui contient des informations importantes (critiques) lors du retour d'appel de fonction. Ce "stack frame" est empilé sur la stack (la pile) avant l'appel de fonction ce qui fait grossir la stack qui se rapproche de la heap (le tas).

Chaque "stack frame" contient:

  • Tous les paramètres passés à la fonction
  • toutes les variables locales déclarées dans la fonction

Ces données sont utilisables à l'intérieur de la fonction, mais l'espace est récupéré à 100% à la sortie de la fonction!

Les bons trucs!

  • Evitez les allocation dynamiques sur la heap - Elle peuvent rapidement fragmenter l'espace disponible pour la heap (tas).
  • Préférez les allocations locale aux allocations globales - les variables sur la stack pile n'existent que durant leur utilisation. SI vous avez des variables qui ne sont utilisées que dans une petite section de votre code ALORS considérez l'utilisation d'une fonction avec cette variable déclarée dans la fonction.

Source: Memories of an Arduino. Crédit AdaFruit Industries.

Créé par Bill Earl pour AdaFruit Industries.

Traduit par Meurisse D. pour MCHobby.be

Traduit avec l'autorisation d'AdaFruit Industries - Translated with the permission from Adafruit Industries - www.adafruit.com

Toute référence, mention ou extrait de cette traduction doit être explicitement accompagné du texte suivant : «  Traduction par MCHobby (www.MCHobby.be) - Vente de kit et composants » avec un lien vers la source (donc cette page) et ce quelque soit le média utilisé.

L'utilisation commercial de la traduction (texte) et/ou réalisation, même partielle, pourrait être soumis à redevance. Dans tous les cas de figures, vous devez également obtenir l'accord du(des) détenteur initial des droits. Celui de MC Hobby s'arrêtant au travail de traduction proprement dit.