Bibliothèque d'encodage Base64 avec Arduino
Base64 est un système de codage qui utilise 64 symboles regroupés en messages d'une longueur multiple de quatre. Ces messages (paquets de données) sont complétés, si nécessaire, par un symbole plus (on en utilise donc 65), souvent le signe égal (=), si les informations utiles codées aboutissent à une longueur plus courte.
A l'aide de 64 signes vous pouvez travailler avec les 10 chiffres et lettres majuscules et minuscules (26+26) du code ASCII, le problème est qu'il y a 62, disons, symboles non ambigus plus deux qui varient selon les différentes implémentations. Bien que parfois désigné par l'expression « personnages ASCII imprimable", en réalité ce sont ceux qui vont de celui représenté par le code 32 (espace) au 126 (~) le 95 véritablement imprimable.
La mise en œuvre du codage Base64 le plus utilisé, celui de PEM, qui est également utilisé par MIME, travaillez avec les signes supplémentaires "+" et "/" et le signe "=" pour compléter afin que les paquets aient une longueur multiple de quatre. Les lettres AZ occupent les positions 0 à 25, les lettres az occupent les positions 26 à 51, les chiffres 0 à 9 occupent les positions 52 à 61, le signe plus (+) les positions 62 et la position 63 est occupée par la barre oblique (/ ).
La façon de représenter les données au format Base64 consiste à prélever, à partir des données originales, des groupes de 6 bits qui sont représentés avec le code correspondant. S'il reste des bits, ils sont remplis de zéros à droite. Si le nombre de codes obtenu n'est pas un multiple de quatre, il est rempli avec des signes égaux à droite.
L'image suivante montre le codage ASCII d'un texte ("ohm") et la manière dont il est converti en Base64. Puisqu’il y a 7 symboles, le message final devra être rempli d’un signe égal à la fin. On pourrait dire que le texte "ohm" dans ASCII équivalent à «b2htaW8=" dans Base64.
Utilisations spécifiques du codage Base64 Ils imposent également généralement une longueur de ligne maximale. La mise en oeuvre MIME Limite chaque ligne à 76 caractères. Normalement les lignes seront séparées par un code de fin de ligne (CR, représenté par la valeur 0x0D dans ASCII) et une autre nouvelle ligne (NL, qui correspond au code ASCII 0x0A).
L'inconvénient qui s'ajoute lors de la mise en œuvre du codage Base64 sur un appareil avec peu de ressources, comme c'est souvent le cas avec un microcontrôleur c'est qu'il faut coder au fur et à mesure que l'information arrive ou avec un tampon minimum, ce qui nécessite également de prévoir un système indiquant que la fin du message d'origine est atteinte, par exemple en ajoutant un code spécial, ou en utilisant un pin dont le niveau (synchronisé avec la réception) indique l'état du message.
L'exemple de code ci-dessous est un bibliothèque pour Arduino à encoder en Base64 qui est mis en œuvre avec les deux critères : encoder les informations qui arrivent (sans tampon) et attendez la fin d'un signal d'avertissement.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
//base64.h
#include <string.h> // memcpy/strncpy
#define LONGITUD_LINEA 76
#define MASCARA_B64 0B00111111
#define ULTIMO_CODIGO_BASE64 64 // 64 caracteres más el signo igual (empezando a contar desde cero)
#define MAXIMA_LONGITUD_RESULTADO 6 // Máximo número de caracteres del resultado parcial de la codificación. Puede ser 1 si no se ha llegado al final de un bloque (2 bytes en el original, 4 en la conversión), 2 si se ha llegado al final de un bloque, 3 si no se ha llegado al final de un bloque pero se supera la longitud máxima de la línea, 4 si se llega al final de un bloque y se supera la longitud máxima de la línea, 5 si hay que rellenar con un signo igual o 6 si hay que rellenar con dos signos igual
class Base64
{
private:
unsigned char simbolo_base64[ULTIMO_CODIGO_BASE64+1]; // Espacio para la codificación Base64, el relleno (=) una terminación en \0
unsigned int numero_valor; // Posición (empezando en cero) que ocupa el valor que se desea convertir en el mensaje completo original
unsigned int numero_codigo; // Posición del último código calculado. Podría limitarse al ancho de la línea (LONGITUD_LINEA, 76 caracteres) pero usando un contenedor alto se podría implementar también una cuenta estadística
unsigned char resto_base64; // Último resto obtenido al calcular el último código
unsigned char resultado[MAXIMA_LONGITUD_RESULTADO+1]; // Resultado de la conversión actual. Si es terminal puede incluir el caracter 65 (=) una o dos veces
unsigned char contador_caracteres_resultado=0;
void acumular_resultado(unsigned char valor);
public:
Base64();
~Base64();
void iniciar_conversion();
unsigned char *convertir(unsigned char valor_original, bool terminar_conversion);
unsigned char *convertir(unsigned char valor_original);
unsigned char *terminar();
};
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
|
//base64.cpp
#include “base64.h”
Base64::Base64() // Constructor
{
memcpy(simbolo_base64,“ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=”,ULTIMO_CODIGO_BASE64+1);
iniciar_conversion();
}
Base64::~Base64() // Destructor
{
}
void Base64::iniciar_conversion()
{
numero_valor=0;
numero_codigo=0;
resto_base64=0;
}
unsigned char *Base64::convertir(unsigned char valor_original, bool terminar_conversion) // Valor que se desea convertir a Base64
{
convertir(valor_original);
if(terminar_conversion)
{
terminar();
}
return resultado;
}
unsigned char *Base64::convertir(unsigned char valor_original) // Valor que se desea convertir a Base64
{
unsigned char desplazamiento;
contador_caracteres_resultado=0;
acumular_resultado((valor_original>>(2+(numero_valor%3)*2))|resto_base64);
desplazamiento=4–(numero_valor%3)*2;
resto_base64=(valor_original&(MASCARA_B64>>desplazamiento))<<desplazamiento;
if(((numero_codigo+1)%4==0))
{
acumular_resultado(resto_base64);
resto_base64=0;
}
numero_valor++;
resultado[contador_caracteres_resultado]=0;
return resultado;
}
unsigned char *Base64::terminar()
{
if(numero_codigo%4)
{
acumular_resultado(resto_base64);
while(numero_codigo%4)
{
acumular_resultado(ULTIMO_CODIGO_BASE64);
}
}
resultado[contador_caracteres_resultado]=0;
iniciar_conversion();
return resultado;
}
void Base64::acumular_resultado(unsigned char valor)
{
numero_codigo++;
resultado[contador_caracteres_resultado++]=simbolo_base64[valor];
if((numero_codigo%LONGITUD_LINEA)==0)
{
resultado[contador_caracteres_resultado++]=13; // CR “\r”
resultado[contador_caracteres_resultado++]=10; // LF “\n”
}
}
|
La partie fondamentale du calcul du code Base64 Cela se fait avec l'expression :
(valor_original>>(2+(numero_valor%3)*2))|resto_base64
et le calcul du reste avec l'expression :
(valor_original&(MASCARA_B64>>desplazamiento))<<desplazamiento,
siendo desplazamiento une valeur calculée avec l'expression :
4-(numero_valor%3)*2
Le processus suivi pour obtenir ces expressions consiste à généraliser le calcul de chacun des quatre codes Base64 qui résultent de la représentation de trois octets de la valeur d'origine.
Base64=((byte_1>>2)|resto)&0b00111111 |
resto=(byte_1&0b00000011)<<4 |
Base64=((byte_2>>4)|resto)&0b00111111 |
resto=(byte_2&0b00001111)<<2 |
Base64=((byte_3>>6)|resto)&0b00111111 |
resto=(byte_3&0b00111111)<<0 |
Base64=((byte_3>>0)|resto)&0b00111111 |
resto=(byte_3&0b00111111)<<0 |
Avec le texte Base64 Le pseudocode ci-dessus fait référence au code dans Base64 cela est en cours de calcul. L'expression a été utilisée byte_n pour faire référence au nième octet en cours de codage. Le texte resto représente les bits restants de l'octet en cours de codage. Au début du calcul, on suppose que le reste est nul
Pour plus de clarté, dans le pseudocode précédent, le masque de 6 bits a été inclus dans le calcul de tous les codes, bien qu'il soit seulement nécessaire de déterminer le dernier d'entre eux, puisque les autres sont tournés de manière à ce que les deux bits les plus soient toujours perdus. significatif.
Comme on peut le voir, le quatrième code est tout reste et il n'est pas nécessaire de calculer un reste par la suite ; Il suffit donc d'effectuer trois étapes, une par octet codé. Il est important de se rappeler que si un troisième octet d’un paquet n’était pas codé, le dernier code devrait être rempli de zéros à droite. Base64 obtenu.
Pour généraliser, la rotation à droite de l'expression qui calcule le code dans Base64 peut être représenté comme 2+(numero_byte%3)*2 de sorte que la partie à l'intérieur des parenthèses tournerait de zéro à deux, ce qui donnerait 2, 4 et 6 à chaque étape. Bien sûr, ce n’est pas la seule manière de généraliser, mais j’ai choisi celle-ci pour sa fonctionnalité et surtout pour sa clarté. Puisque le masque (ET) n'était nécessaire que dans le quatrième code et qu'il a déjà été vu qu'il n'est pas nécessaire de le calculer (c'est tout le reste), il n'est pas inclus dans l'expression finale pour la simplifier, même s'il faut se rappeler que le type de données utilisé (octet ) seuls les 6 bits de poids faible sont pris en compte.
La rotation à gauche du reste peut être généralisée de manière analogue à la précédente. On voit également que le masque appliqué (AND) subit la même rotation de bit mais en sens inverse. C'est la raison pour laquelle on calcule le déplacement avec 4-(numero_valor%3)*2 avant de l'appliquer dans le sens correspondant à chaque partie de l'expression.
L'exemple suivant montre comment utiliser la bibliothèque pour encoder une chaîne de texte (rappelez-vous que Base64 peut être utilisé pour n’importe quel ensemble de données, comme une image par exemple). Dans le code suivant, il y a quelques détails qu’il est intéressant de clarifier. Premièrement, un symbole spécial (le symbole ~) a été utilisé pour indiquer la fin du texte, au lieu d'un signal matériel ou indiquant la longueur du texte. Logiquement, ce symbole ne peut pas faire partie des données codées.
La deuxième question à considérer, aussi importante qu’évidente, est que le décodeur à destination doit savoir comment sont représentées les informations qui lui parviennent. Le texte comprend des caractères qui n'appartiennent pas à l'ensemble ASCII imprimables (de 32 à 126), lettres avec accent par exemple. Arduino utilisera deux octets (UTF-8) pour représenter ces personnages. L'habituel ne peut pas simplement être utilisé \0 comme terminateur de texte puisque, dans de nombreux cas, le premier octet avec lequel un caractère est représenté sera précisément zéro.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
|
#include “base64.h”
char texto_prueba[]=“La bella y graciosa moza marchose a lavar la ropa.\nLa mojó en el arroyuelo y cantando la lavó.\nLa frotó sobre una piedra, la colgó de un abedul.\nDespués de lavar la ropa, la niña se fue al mercado.\nUn pastor vendía ovejas pregonando a viva voz:\nved qué oveja, ved qué lana, ved qué bestia, qué animal.\nLa niña la vio muy flaca, sin embargo le gustó.\nYo te pago veinte escudos y no discutamos más.\nVuelve la niña cantando muy contenta con su oveja.\nCuando llegaron al bosque la ovejita se escapó.\nLa niña desesperada arrojose encima de ella.\nVelozmente y con destreza aferrola por detrás.\nLlegaba por el camino jinete de altivo porte.\nDescendió de su caballo y a la niña le cantó…~”;
char *resultado;
Base64 base64;
void setup()
{
Serial.begin(9600);
#if defined(__AVR_ATmega32U4__) || defined(__AVR_ATmega16U4__) // ¿Es un Arduino Leonardo (ATmega32U4)?
while(!Serial){}; // Esperar a Arduino Leonardo
#endif
// Mostrar el texto original
unsigned int contador=0;
while(texto_prueba[contador]!=‘~’)
{
//Serial.println(String(texto_prueba[contador])+”=”+String(texto_prueba[contador],DEC));
Serial.print(String(texto_prueba[contador]));
contador++;
}
Serial.println(“\n”);
// Mostrar el texto codificado en Base64
contador=0;
while(texto_prueba[contador]!=‘~’)
{
resultado=base64.convertir(texto_prueba[contador],texto_prueba[contador+1]==‘~’);
byte contador_resultado=0;
while(resultado[contador_resultado]>0)
{
Serial.print(String(resultado[contador_resultado]));
contador_resultado++;
}
contador++;
}
}
void loop()
{
}
|
La ligne 26 de l'exemple précédent montre l'utilisation du bibliothèque pour Arduino à encoder en Base64. Il suffit d'indiquer la méthode convertir chaque octet que vous souhaitez encoder et éventuellement si c'est le dernier ou, sinon, arrêtez la conversion avec la méthode terminar quand tu arriveras à la fin.
Comme on peut le voir dans la capture d'écran ci-dessous, l'exemple de programme du bibliothèque pour Arduino à encoder en Base64 affiche d'abord le texte à encoder Base64, en l'occurrence, le début du célèbre chant des géants Les Luthiers, et par la suite le résultat de l'encodage dans Base64 en utilisant la longueur de la ligne de format MIME.
Poster un commentaire