Bonjour les amis
Je suis un Tunisien d'Afrique du Nord, développeur Arduino, j'ai un projet d'affichage matriciel à bande 7x42 ref WS2812.
Mais l'affichage est faux, les dimensions, les fonctions couleur et arc-en-ciel, l'effacement horizontal et vertical et les autres effets sont corrects, seul l'affichage est faux, je partage ce code avec vous pour le corriger, merci
Hello friends
I am Tunisian from North Africa, Arduino developer, I have a matrix display project of 7x42 strips ref WS2812
But the display is not correct, the dimensions of colors & Rainbow, Wipe Horizontal & vertical and other effect are correct, only the display which is not correct, I share this code to you to fix it, thank you
Je suis un Tunisien d'Afrique du Nord, développeur Arduino, j'ai un projet d'affichage matriciel à bande 7x42 ref WS2812.
Mais l'affichage est faux, les dimensions, les fonctions couleur et arc-en-ciel, l'effacement horizontal et vertical et les autres effets sont corrects, seul l'affichage est faux, je partage ce code avec vous pour le corriger, merci
Hello friends
I am Tunisian from North Africa, Arduino developer, I have a matrix display project of 7x42 strips ref WS2812
But the display is not correct, the dimensions of colors & Rainbow, Wipe Horizontal & vertical and other effect are correct, only the display which is not correct, I share this code to you to fix it, thank you
C++:
#include "FastLED.h"
#include "fontstuff.h" //https://github.com/ChuckM/bb-lcd/blob/master/font-5x7.c
#include <EEPROM.h>
//#include <stdio.h>
//#include <string.h>
//##############################################
// Combien de leds dans votre bande ?
#define NUM_LED 295
#définir TYPE_LEDS WS2812
#define Color_ORDER GRB
#définir DATA_PIN 8
#define LARGEUR 42
#define HAUTEUR 7
#define LUMINOSITE 240
// Définir le tableau de leds
LED CRGB[NUM_LEDS] ;
LED CRGB1[NUM_LEDS] ;
//##############################################
char NouveauTexte[128] = {0} ;
char LeTexte[128] = {0} ;
//int LeStyle = 0;
//int LaCouleur = 1;
entier Occupé = 0 ;
//##############################################
// Ceci sera rempli automatiquement dans setup() :
int matrice[HAUTEUR][LARGEUR] = {0} ;
// Pour les fondus "aléatoires" :
int random_fades[NUM_LEDS] = {0} ;
int rsort(const vide *a, const vide *b) {
retourne aléatoire(0,2);
}
//##############################################
void setup() {
// Configurez notre matrice de points :
// Notre matrice est en zigzag de bas en haut, en commençant de droite à gauche :)
// Donc chacune des 7 rangées de 42 directions alternées .......
for(int i=0;i<LARGEUR;i++) {
matrice[0][i] = 294 - i;// Ligne du haut == 294 - 253
matrice[1][i] = 211 + i;// Deuxième rangée == 211 - 252
matrice[2][i] = 210 - i;// Troisième rangée == 169 - 210
matrice[3][i] = 127 + i;// Quatrième rangée == 127 - 168
matrix[4][i] = 126 - i;// Cinquième rangée == 85 - 126
matrix[5][i] = 43 + i;// 6ième rangée == 43 - 84
matrix[6][i] = 42 - i;// Septieme rangée == 42 - 1
}
for(int i=1;i<NUM_LEDS;i++) random_fades[i] = i;
/*
La fonction qsort() implemente un algorithme de tri non specifie qui permet de trier tout ou partie
de n'importe quel tableau de donnees, du moment qu'il existe un critere de tri dans les donnees.
Elle s'appuie sur une fonction utilisateur qui se charge d'exprimer le critere de tri.
*/
qsort(random_fades + 1, NUM_LEDS, sizeof(int), rsort);
FastLED.addLeds<TYPE_LEDS, DATA_PIN, Color_ORDER>(leds, NUM_LEDS);
// Restez vide pendant que nous nous connectons:
//FastLED.setMaxPowerInVoltsAndMilliamps(5, 1800);
//FastLED.setCorrection(0xFF7F4F);
//FastLED.clear(true);
FastLED.setBrightness(BRIGHTNESS);
}
//###############################################
/*
* Colors:
* 0 White
* 1 Red
* 2 Yellow
* 3 Green
* 4 Cyan
* 5 Blue
* 6 Magenta
* 7 Rainbow
* 8 Random ("sparkle" or "unicorn")
*
* dtime:
* - VScroll - lower number = faster speed
* - HScroll - milliseconds to hold on screen before scrolling off
* - Blink - milliseconds for each on and off portion
*/
////////////////////////////////////////////////////////////////////
// Just print text in the specified Color using the Offsets:
// FadeIn = 1: Fade new text in crossfade-style
// FadeIn = 2: Fade new text in disolve-style (random dots)
void mPrint(char *Texte, int Color = 0, int hOffset = 0, int vOffset = 0,
int FadeIn = 0, unsigned long BgColor = 0);
// Helper function to print a character WITHOUT clearing or writing to the LEDs:
void mPrintChar(char c, int Color = 0, int Offset = 0, unsigned long BgColor = 0);
//
// "Swipe" in each character of *Texte from right to left at given Color:
void mPrintSwipe(char *Texte, int Color = 0, int dtime = 10, unsigned long BgColor = 0);
// Horizontal scroll, speed controlled by delay time (dtime):
//
// OnScreen:
// 0 = start & end past screen edges
// 1 = end fully on screen
// 2 = start/end fully on screen
//
// FadeIn:
// 0 = no fade effect
// 1 = crossfade in
// 2 = random fade in
// ONLY works if OnScreen = 2
//
// BlinkOut:
// 0 = no blink
// 1 = blink last 7 chars n times
// ONLY works if OnScreen > 0
void mPrintHScroll(char *Texte, int Color = 0, int dtime = 20, int OnScreen = 0,
int FadeIn = 0, int BlinkOut = 0, unsigned long BgColor = 0);
//
// One line of text swiping UP or DOWN:
// dtime = how long to wait before scrolling off
// stayon == don't scroll off (dtime is ignored)
void mPrintVScroll(char *Texte, int Color = 0, int down = 0, int dtime = 2000,
int stayon = 0, unsigned long BgColor = 0);
//
// Simple blink text function:
void mPrintBlink(char *Texte, int Color = 0, int times = 4, int dtime = 250,
unsigned long BgColor = 0);
//
// Wipe text in left to right (or RTL):
void mPrintWipe(char *Texte, int Color, int rtl = 0, unsigned long BgColor = 0);
//
// Just fade out whatever's on the screen by (approx) n milliseconds (minimum 200)
void mFadeOut(int n = 500);
//
// Fire effect...
void mFire(int howlong);
void loop() {
//#####################################################
mPrintVScroll("Bonjour", 7, 0, 0, 1); delay(1500);
mPrint("Scrolly", 7); delay(1000);
mPrintHScroll("A fully functional, full-Colored Scrolling Marquee", 7, 15, 1); delay(1000);
mPrintHScroll("Hannachi Samir", 4, 10, 1); delay(1000);
mPrintVScroll("Please", 2, 0, 0, 1); delay(1500);
FastLED.clear();
mPrintChar(252, 4, 0);
mPrintChar(253, 4, 6);
mPrint(" Like", 0, 12);delay(1500);
FastLED.clear();
mPrintChar(250, 0, 0);
mPrintChar(251, 0, 6);
mPrint(" Cmnt", 2, 12);delay(1500);
FastLED.clear();
mPrintChar(254, 1, 0);
mPrintChar(255, 1, 6);
mPrintChar('&', 0, 15);
mPrint("Sub", 1, 24);delay(2000);
mPrintVScroll(" On...", 2, 0, 0, 1, 0x140000);
mPrintVScroll("YouTube", 0, 0, 0, 1, 0x140000);
mPrintBlink("YouTube", 0, 4, 250, 0x140000);delay(1000);
FastLED.clear(true);
mPrintVScroll("WS2812B", 7, 0, 0, 1);delay(2000);
mPrintVScroll(" LED", 2, 1, 0, 1);delay(1000);
mPrintWipe(" Strip", 3, 0);delay(1000);
mPrintSwipe("Becomes", 6);
mFadeOut(1000);
mPrintHScroll("A fully functional, full-Colored Scrolling Marquee", 7, 15, 1);delay(1000);
mPrint("7 Chars", 0, 0, 0, 1);delay(1000);
mPrintWipe("5x7 Pix", 5, 0, 0x101000);delay(1000);
mPrintWipe("294 LED", 3, 1, 0x100010);delay(1000);
mPrintVScroll(" Array", 2, 0, 0, 1, 0x101020);delay(1000);
mPrint("Named..", 0, 0, 0, 2);delay(1000);
}
//#####################################################
void mPrint(char *inText,
int Color, // 0 White/ 1 Red/2 Yellow/3 Green/4 Cyan/5 Blue/6 Magenta/7 Rainbow/8 Random
int hOffset, //
int vOffset, //
int FadeIn, //
unsigned long BgColor) {
int n = 0;
int Rainbow = 0; // Rainbow
int RandomColor = 0; // RandomColor
int r, g, b;
char *Texte;
int len = strlen(inText);
if (len < 7) {
Texte = (char *) malloc(8);
strcpy(Texte, inText);
while (len < 7) Texte[len++] = ' ';
Texte[len] = 0;
} else {
Texte = inText;
}
//////////// Color ////////////////////////
if (Color <= 0 || Color > 8) {
Color = -1;
} else if (Color == 7) {
Rainbow = 1;
Color = 0;
} else if (Color == 8) {
RandomColor = 1;
} else {
Color = (Color - 1) * 128;
}
// Wipe the buffer!
if(FadeIn > 0) memset(leds1, 0, NUM_LEDS * sizeof(CRGB));
while (Texte[n]) {
for (int i = n == 0 ? -1 : 0; i < 6; i++) {
for (int k = 0; k < 7; k++) {
// Shit-ton of validation:
if (i + n * 6 + hOffset < LARGEUR &&
i + n * 6 + hOffset >= 0 &&
k + vOffset >= 0 &&
k + vOffset < 7) {
if (i >= 0 && FONT_BIT((int)Texte[n], i, 7 - k)) {
/////// Color /////////
// Trying something different (and maybe cool!):
if (RandomColor) Color = random(0, 768);
if (Color == -1 && !Rainbow) {
r = g = b = 85;
} else {
r = (Color + 255) % 768;
if (r > 511) r = 0;
if (r > 255) r = 511 - r;
g = (Color + 0) % 768;
if (g > 511) g = 0;
if (g > 255) g = 511 - g;
b = (Color + 511) % 768;
if (b > 511) b = 0;
if (b > 255) b = 511 - b;
}
} else {
r = (BgColor >> 16) & 0xFF;
g = (BgColor >> 8) & 0xFF;
b = BgColor & 0xFF;
}
if (FadeIn > 0) {
leds1[matrix[k + vOffset][i + n * 6 + hOffset]].r = r;
leds1[matrix[k + vOffset][i + n * 6 + hOffset]].g = g;
leds1[matrix[k + vOffset][i + n * 6 + hOffset]].b = b;
} else {
leds[matrix[k + vOffset][i + n * 6 + hOffset]].r = r;
leds[matrix[k + vOffset][i + n * 6 + hOffset]].g = g;
leds[matrix[k + vOffset][i + n * 6 + hOffset]].b = b;
}
}
}
if (Rainbow) Color += 16;
}
n++;
}
if (FadeIn == 2) {
// Re-sort (randomize) the random numbers each time:
qsort(random_fades + 1, NUM_LEDS-1, sizeof(int), rsort);
for (int f = 1; f < NUM_LEDS; f++) {
leds[random_fades[f]].r = leds1[random_fades[f]].r;
leds[random_fades[f]].g = leds1[random_fades[f]].g;
leds[random_fades[f]].b = leds1[random_fades[f]].b;
if (f % 8 == 0) {
FastLED.show();
delay(5);
}
}
memcpy(leds, leds1, NUM_LEDS * sizeof(CRGB));
} else if (FadeIn == 1) {
// Crossfade:
for (int i = 0; i < 30; i++) {
for (int f = 1; f < NUM_LEDS; f++) {
leds[f].r = leds[f].r * 7 / 8 + leds1[f].r / 8;
leds[f].g = leds[f].g * 7 / 8 + leds1[f].g / 8;
leds[f].b = leds[f].b * 7 / 8 + leds1[f].b / 8;
}
FastLED.show();
delay(20);
}
memcpy(leds, leds1, NUM_LEDS * sizeof(CRGB));
}
FastLED.show();
}
//#####################################################
void mFadeOut(int n) {
if (n < 200) n = 200;
if (n > 10000) n = 10000;
for (int k = 0; k < 30; k++) {
for (int i = 0; i < NUM_LEDS; i++) {
leds[i].r = leds[i].r * 7 / 8;
leds[i].g = leds[i].g * 7 / 8;
leds[i].b = leds[i].b * 7 / 8;
}
FastLED.show();
delay(n / 30);
}
FastLED.clear(true);
}
//#####################################################
void mPrintWipe(char *inText, int Color, int rtl, unsigned long BgColor) {
int rb = 0;
int r, g, b;
char Texte[8] = {0};
int len = strlen(inText);
if (len > 7) len = 7;
strncpy(Texte, inText, len);
Texte[len] = 0;
// Space pad:
while (len < 7) {
Texte[len] = ' ';
Texte[++len] = 0;
}
if (Color <= 0 || Color > 7) {
Color = -1;
} else if (Color == 7) {
rb = 1;
Color = 0;
} else {
Color = (Color - 1) * 128;
}
// Swipe each column of each letter in Right-to-Left:
if (rtl == 0) {
for (int n = 0; n < len; n++) {
// Each column:
for (int i = 0; i < 6; i++) {
for (int k = 0; k < 7; k++) {
if (FONT_BIT((int)Texte[n], i, 7 - k)) {
if (Color == -1 && !rb) {
r = g = b = 85;
} else {
r = (Color + 255) % 768;
if (r > 511) r = 0;
if (r > 255) r = 511 - r;
g = (Color + 0) % 768;
if (g > 511) g = 0;
if (g > 255) g = 511 - g;
b = (Color + 511) % 768;
if (b > 511) b = 0;
if (b > 255) b = 511 - b;
}
} else {
r = g = b = 0;
}
leds[matrix[k][i + n * 6]].r = r;
leds[matrix[k][i + n * 6]].g = g;
leds[matrix[k][i + n * 6]].b = b;
}
FastLED.show();
delay(3);
if (rb) Color += 17;
}
}
} else {
// Right-to-Left
for (int n = len - 1; n >= 0; n--) {
// Each column:
for (int i = 5; i >= 0; i--) {
for (int k = 0; k < 7; k++) {
if (FONT_BIT((int)Texte[n], i, 7 - k)) {
if (Color == -1 && !rb) {
r = g = b = 85;
} else {
r = (Color + 255) % 768;
if (r > 511) r = 0;
if (r > 255) r = 511 - r;
g = (Color + 0) % 768;
if (g > 511) g = 0;
if (g > 255) g = 511 - g;
b = (Color + 511) % 768;
if (b > 511) b = 0;
if (b > 255) b = 511 - b;
}
} else {
r = g = b = 0;
}
leds[matrix[k][i + n * 6]].r = r;
leds[matrix[k][i + n * 6]].g = g;
leds[matrix[k][i + n * 6]].b = b;
}
FastLED.show();
delay(3);
if (rb) Color += 17;
}
}
}
}
//#####################################################
void mPrintChar(char c, int Color, int Offset, unsigned long BgColor) {
int r, g, b;
if (Color < 0 || Color > 6) {
Color = -1; // Just for internal use
} else {
Color = (Color - 1) * 128;
}
for (int i = 0; i < 7; i++) {
for (int k = 0; k < 7; k++) {
if (i + Offset < LARGEUR && i + Offset >= 0) {
if (FONT_BIT((int)c, i, 7 - k)) {
if (Color < 0) {
r = g = b = 84;
} else {
r = (Color + 255) % 768;
if (r > 511) r = 0;
if (r > 255) r = 511 - r;
g = (Color + 0) % 768;
if (g > 511) g = 0;
if (g > 255) g = 511 - g;
b = (Color + 511) % 768;
if (b > 511) b = 0;
if (b > 255) b = 511 - b;
}
} else {
r = (BgColor >> 16) & 0xFF;
g = (BgColor >> 8) & 0xFF;
b = BgColor & 0xFF;
}
leds[matrix[k][i + Offset]].r = r;
leds[matrix[k][i + Offset]].g = g;
leds[matrix[k][i + Offset]].b = b;
}
}
}
}
//#####################################################
void mPrintSwipe(char *inText, int Color, int dtime, unsigned long BgColor) {
int rb = 0;
int r, g, b;
char Texte[8] = {0};
int len = strlen(inText);
if (len > 7) len = 7;
strncpy(Texte, inText, len);
Texte[len] = 0;
if (Color <= 0 || Color > 7) {
Color = 0;
} else if (Color == 7) {
rb = 1;
Color = 0;
}
for (int i = 0; i < 7; i++) {
// For each character:
for (int k = LARGEUR; k >= i * 6; k--) {
mPrintChar(Texte[i], rb ? Color + i + 1 : Color, k, BgColor);
FastLED.show();
delay(dtime);
}
}
}
//#####################################################
void mPrintHScroll(char *Texte, int Color, int dtime, int OnScreen, int FadeIn, int BlinkOut, unsigned long BgColor) {
int i;
int len = strlen(Texte);
int st, en;
if (OnScreen == 0 || OnScreen > 2) {
st = LARGEUR;
en = len * 6;
FadeIn = 0;
BlinkOut = 0;
} else if (OnScreen == 1) {
// Start off screen, end at last 7 chars:
st = LARGEUR;
en = len * 6 - LARGEUR;
FadeIn = 0;
} else if (OnScreen == 2) {
// Start on screen, end on screen
st = 0;
en = len * 6 - LARGEUR;
}
mPrint(Texte, Color, st, 0, FadeIn, BgColor);
if (!FadeIn && OnScreen == 2) delay(500);
// Deal with leading spaces at the end:
while(OnScreen > 0 && len > en/6 && Texte[en/6] == ' ') en += 6;
for (i = st - 1; i > -en; i--) {
mPrint(Texte, Color, i, 0, 0, BgColor);
delay(dtime);
}
// Blink:
if (BlinkOut) {
for (int k = 0; k < 4; k++) {
delay(250);
FastLED.clear(true);
delay(250);
mPrint(Texte, Color, i, 0, 0, BgColor);
}
} else if (OnScreen == 0) {
FastLED.clear(true);
}
}
//#####################################################
void mPrintVScroll(char *inText, int Color, int down, int dtime, int stayon, unsigned long BgColor) {
int i, f;
char Texte[8] = {0};
int len = strlen(inText);
if (len > 7) len = 7;
strncpy(Texte, inText, len);
// Space pad:
while (len < 7) {
Texte[len] = ' ';
Texte[++len] = 0;
}
if (down > 0) {
for (i = -7; i <= 0; i++) {
// First shift up existing dots:
for(f = NUM_LEDS-LARGEUR+1; f > LARGEUR; f--) {
leds[matrix[f/LARGEUR][f%LARGEUR]] = leds[matrix[f/LARGEUR-1][f%LARGEUR]];
}
for(;f>=0;f--) {leds[matrix[f/LARGEUR][f%LARGEUR]] = 0;}
mPrint(Texte, Color, 0, i, 0, BgColor);
delay(40);
}
if (stayon == 0) {
if (dtime) delay(dtime);
for (i = 1; i < 7; i++) {
FastLED.clear();
mPrint(Texte, Color, 0, i, 0, BgColor);
delay(40);
}
}
} else {
for (i = 7; i >= 0; i--) {
// First shift up existing dots:
for(f = 0; f < NUM_LEDS-LARGEUR+1; f++) {
leds[matrix[f/LARGEUR][f%LARGEUR]] = leds[matrix[f/LARGEUR+1][f%LARGEUR]];
}
for(;f<NUM_LEDS-1;f++) {leds[matrix[f/LARGEUR][f%LARGEUR]] = 0;}
mPrint(Texte, Color, 0, i, 0, BgColor);
delay(40);
}
if (stayon == 0) {
if (dtime) delay(dtime);
for (i = -1; i > -7; i--) {
FastLED.clear();
mPrint(Texte, Color, 0, i, 0, BgColor);
delay(40);
}
}
}
if (stayon == 0) FastLED.clear(true);
}
//#####################################################
void mPrintBlink(char *inText, int Color, int times, int dtime, unsigned long BgColor) {
int i;
char Texte[8] = {0};
int len = strlen(inText);
if (len > 7) len = 7;
strncpy(Texte, inText, len);
Texte[len] = 0;
for (i = 0; i < times - 1; i++) {
mPrint(Texte, Color, 0, 0, 0, BgColor);
delay(dtime);
FastLED.clear(true);
delay(dtime);
}
mPrint(Texte, Color, 0, 0, 0, BgColor);
}
//#####################################################
void mFire(int howlong) {
long i, k;
static long flevel[46] = {0};
long hl;
FastLED.clear(false);
for (hl = 0; hl < howlong * 10; hl++) {
for (i = 0; i < 46; i++) {
// First, drop each point by 5%:
flevel[i] = flevel[i] * 998 / 1000;
// Next, add random spikes:
if (i > 0 && i < 45 && random(0, 20) == 1) flevel[i] += random(0, 256 - flevel[i]);
}
long flevel2[46] = {0};
for (i = 1; i < 45; i++) {
flevel2[i] = (flevel[i] / 2 + flevel[i - 1] / 4 + flevel[i + 1] / 4);
}
for (i = 1; i < 45; i++) {
flevel[i] = (flevel2[i] / 2 + flevel2[i - 1] / 4 + flevel2[i + 1] / 4);
}
// Now display:
for (i = 2; i < 44; i++) {
long ll = flevel[i] +
flevel[i - 1] / 2 + flevel[i + 1] / 2 +
flevel[i - 2] / 3 + flevel[i + 2] / 3;
for (k = 0; k < 7; k++) {
// Now let's light it up!
long r, g; // Colors
// Amount of red:
r = ll / 2 - (7 - k) * 30;
// Amount of green:
g = ll / 3 - (7 - k) * 50;
if (r < 0) r = 0; if (r > 255) r = 255;
if (g < 0) g = 0; if (g > 255) g = 255;
leds[matrix[k][i - 2]].r = r;
leds[matrix[k][i - 2]].g = g / 2;
}
}
FastLED.show();
delay(35);
}
}
//#################### END ######################
file font
/*
* 5 x 7 ASCII font.
*
* Each byte here has one "column" of the character
* This minimizes the number of wasted bits (rather
* than 7 bytes of 5 bit 'lines' it is 5 bytes of
* 7 bit 'columns'.
*/
#define FONT_CHAR_HEIGHT 7
#define FONT_CHAR_WIDTH 5
//Generic to compute font bit on/off for this font
#define FONT_BIT(c, column, row) \
((font_data[(column)>5?0:(c*6)+(column)] & 1<<(7-(row))) != 0)
//
static const unsigned char font_data[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x3E, 0x5B, 0x4F, 0x5B, 0x3E, 0x00,
0x3E, 0x6B, 0x4F, 0x6B, 0x3E, 0x00,
0x1C, 0x3E, 0x7C, 0x3E, 0x1C, 0x00,
0x18, 0x3C, 0x7E, 0x3C, 0x18, 0x00,
0x1C, 0x57, 0x7D, 0x57, 0x1C, 0x00,
0x1C, 0x5E, 0x7F, 0x5E, 0x1C, 0x00,
0x00, 0x18, 0x3C, 0x18, 0x00, 0x00,
0xFF, 0xE7, 0xC3, 0xE7, 0xFF, 0x00,
0x00, 0x18, 0x24, 0x18, 0x00, 0x00,
0xFF, 0xE7, 0xDB, 0xE7, 0xFF, 0x00,
0x30, 0x48, 0x3A, 0x06, 0x0E, 0x00,
0x26, 0x29, 0x79, 0x29, 0x26, 0x00,
0x40, 0x7F, 0x05, 0x05, 0x07, 0x00,
0x40, 0x7F, 0x05, 0x25, 0x3F, 0x00,
0x5A, 0x3C, 0xE7, 0x3C, 0x5A, 0x00,
0x7F, 0x3E, 0x1C, 0x1C, 0x08, 0x00,
0x08, 0x1C, 0x1C, 0x3E, 0x7F, 0x00,
0x14, 0x22, 0x7F, 0x22, 0x14, 0x00,
0x5F, 0x5F, 0x00, 0x5F, 0x5F, 0x00,
0x06, 0x09, 0x7F, 0x01, 0x7F, 0x00,
0x00, 0x66, 0x89, 0x95, 0x6A, 0x00,
0x60, 0x60, 0x60, 0x60, 0x60, 0x00,
0x94, 0xA2, 0xFF, 0xA2, 0x94, 0x00,
0x08, 0x04, 0x7E, 0x04, 0x08, 0x00,
0x10, 0x20, 0x7E, 0x20, 0x10, 0x00,
0x08, 0x08, 0x2A, 0x1C, 0x08, 0x00,
0x08, 0x1C, 0x2A, 0x08, 0x08, 0x00,
0x1E, 0x10, 0x10, 0x10, 0x10, 0x00,
0x0C, 0x1E, 0x0C, 0x1E, 0x0C, 0x00,
0x30, 0x38, 0x3E, 0x38, 0x30, 0x00,
0x06, 0x0E, 0x3E, 0x0E, 0x06, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x5F, 0x00, 0x00, 0x00,
0x00, 0x07, 0x00, 0x07, 0x00, 0x00,
0x14, 0x7F, 0x14, 0x7F, 0x14, 0x00,
0x24, 0x2A, 0x7F, 0x2A, 0x12, 0x00,
0x23, 0x13, 0x08, 0x64, 0x62, 0x00,
0x36, 0x49, 0x56, 0x20, 0x50, 0x00,
0x00, 0x08, 0x07, 0x03, 0x00, 0x00,
0x00, 0x1C, 0x22, 0x41, 0x00, 0x00,
0x00, 0x41, 0x22, 0x1C, 0x00, 0x00,
0x2A, 0x1C, 0x7F, 0x1C, 0x2A, 0x00,
0x08, 0x08, 0x3E, 0x08, 0x08, 0x00,
0x00, 0x80, 0x70, 0x30, 0x00, 0x00,
0x08, 0x08, 0x08, 0x08, 0x08, 0x00,
0x00, 0x00, 0x60, 0x60, 0x00, 0x00,
0x20, 0x10, 0x08, 0x04, 0x02, 0x00,
0x3E, 0x51, 0x49, 0x45, 0x3E, 0x00,
0x00, 0x42, 0x7F, 0x40, 0x00, 0x00,
0x72, 0x49, 0x49, 0x49, 0x46, 0x00,
0x21, 0x41, 0x49, 0x4D, 0x33, 0x00,
0x18, 0x14, 0x12, 0x7F, 0x10, 0x00,
0x27, 0x45, 0x45, 0x45, 0x39, 0x00,
0x3C, 0x4A, 0x49, 0x49, 0x31, 0x00,
0x41, 0x21, 0x11, 0x09, 0x07, 0x00,
0x36, 0x49, 0x49, 0x49, 0x36, 0x00,
0x46, 0x49, 0x49, 0x29, 0x1E, 0x00,
0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
0x00, 0x40, 0x34, 0x00, 0x00, 0x00,
0x00, 0x08, 0x14, 0x22, 0x41, 0x00,
0x14, 0x14, 0x14, 0x14, 0x14, 0x00,
0x00, 0x41, 0x22, 0x14, 0x08, 0x00,
0x02, 0x01, 0x59, 0x09, 0x06, 0x00,
0x3E, 0x41, 0x5D, 0x59, 0x4E, 0x00,
0x7C, 0x12, 0x11, 0x12, 0x7C, 0x00,
0x7F, 0x49, 0x49, 0x49, 0x36, 0x00,
0x3E, 0x41, 0x41, 0x41, 0x22, 0x00,
0x7F, 0x41, 0x41, 0x41, 0x3E, 0x00,
0x7F, 0x49, 0x49, 0x49, 0x41, 0x00,
0x7F, 0x09, 0x09, 0x09, 0x01, 0x00,
0x3E, 0x41, 0x41, 0x51, 0x73, 0x00,
0x7F, 0x08, 0x08, 0x08, 0x7F, 0x00,
0x00, 0x41, 0x7F, 0x41, 0x00, 0x00,
0x20, 0x40, 0x41, 0x3F, 0x01, 0x00,
0x7F, 0x08, 0x14, 0x22, 0x41, 0x00,
0x7F, 0x40, 0x40, 0x40, 0x40, 0x00,
0x7F, 0x02, 0x1C, 0x02, 0x7F, 0x00,
0x7F, 0x04, 0x08, 0x10, 0x7F, 0x00,
0x3E, 0x41, 0x41, 0x41, 0x3E, 0x00,
0x7F, 0x09, 0x09, 0x09, 0x06, 0x00,
0x3E, 0x41, 0x51, 0x21, 0x5E, 0x00,
0x7F, 0x09, 0x19, 0x29, 0x46, 0x00,
0x26, 0x49, 0x49, 0x49, 0x32, 0x00,
0x03, 0x01, 0x7F, 0x01, 0x03, 0x00,
0x3F, 0x40, 0x40, 0x40, 0x3F, 0x00,
0x1F, 0x20, 0x40, 0x20, 0x1F, 0x00,
0x3F, 0x40, 0x38, 0x40, 0x3F, 0x00,
0x63, 0x14, 0x08, 0x14, 0x63, 0x00,
0x03, 0x04, 0x78, 0x04, 0x03, 0x00,
0x61, 0x59, 0x49, 0x4D, 0x43, 0x00,
0x00, 0x7F, 0x41, 0x41, 0x41, 0x00,
0x02, 0x04, 0x08, 0x10, 0x20, 0x00,
0x00, 0x41, 0x41, 0x41, 0x7F, 0x00,
0x04, 0x02, 0x01, 0x02, 0x04, 0x00,
0x40, 0x40, 0x40, 0x40, 0x40, 0x00,
0x00, 0x03, 0x07, 0x08, 0x00, 0x00,
0x20, 0x54, 0x54, 0x78, 0x40, 0x00,
0x7F, 0x28, 0x44, 0x44, 0x38, 0x00,
0x38, 0x44, 0x44, 0x44, 0x28, 0x00,
0x38, 0x44, 0x44, 0x28, 0x7F, 0x00,
0x38, 0x54, 0x54, 0x54, 0x18, 0x00,
0x00, 0x08, 0x7E, 0x09, 0x02, 0x00,
0x08, 0x54, 0x54, 0x54, 0x38, 0x00,
0x7F, 0x08, 0x04, 0x04, 0x78, 0x00,
0x00, 0x44, 0x7D, 0x40, 0x00, 0x00,
0x20, 0x40, 0x40, 0x3D, 0x00, 0x00,
0x7F, 0x10, 0x28, 0x44, 0x00, 0x00,
0x00, 0x41, 0x7F, 0x40, 0x00, 0x00,
0x7C, 0x04, 0x78, 0x04, 0x78, 0x00,
0x7C, 0x08, 0x04, 0x04, 0x78, 0x00,
0x38, 0x44, 0x44, 0x44, 0x38, 0x00,
0x7C, 0x18, 0x24, 0x24, 0x18, 0x00,
0x18, 0x24, 0x24, 0x18, 0x7C, 0x00,
0x7C, 0x08, 0x04, 0x04, 0x08, 0x00,
0x48, 0x54, 0x54, 0x54, 0x24, 0x00,
0x04, 0x04, 0x3F, 0x44, 0x24, 0x00,
0x3C, 0x40, 0x40, 0x20, 0x7C, 0x00,
0x1C, 0x20, 0x40, 0x20, 0x1C, 0x00,
0x3C, 0x40, 0x30, 0x40, 0x3C, 0x00,
0x44, 0x28, 0x10, 0x28, 0x44, 0x00,
0x0C, 0x50, 0x50, 0x50, 0x3C, 0x00,
0x44, 0x64, 0x54, 0x4C, 0x44, 0x00,
0x00, 0x08, 0x36, 0x41, 0x00, 0x00,
0x00, 0x00, 0x77, 0x00, 0x00, 0x00,
0x00, 0x41, 0x36, 0x08, 0x00, 0x00,
0x02, 0x01, 0x02, 0x04, 0x02, 0x00,
0x3C, 0x26, 0x23, 0x26, 0x3C, 0x00,
0x1E, 0xA1, 0xA1, 0x61, 0x12, 0x00,
0x3A, 0x40, 0x40, 0x20, 0x7A, 0x00,
0x38, 0x54, 0x54, 0x55, 0x59, 0x00,
0x21, 0x55, 0x55, 0x79, 0x41, 0x00,
0x21, 0x54, 0x54, 0x78, 0x41, 0x00,
0x21, 0x55, 0x54, 0x78, 0x40, 0x00,
0x20, 0x54, 0x55, 0x79, 0x40, 0x00,
0x0C, 0x1E, 0x52, 0x72, 0x12, 0x00,
0x39, 0x55, 0x55, 0x55, 0x59, 0x00,
0x39, 0x54, 0x54, 0x54, 0x59, 0x00,
0x39, 0x55, 0x54, 0x54, 0x58, 0x00,
0x00, 0x00, 0x45, 0x7C, 0x41, 0x00,
0x00, 0x02, 0x45, 0x7D, 0x42, 0x00,
0x00, 0x01, 0x45, 0x7C, 0x40, 0x00,
0xF0, 0x29, 0x24, 0x29, 0xF0, 0x00,
0xF0, 0x28, 0x25, 0x28, 0xF0, 0x00,
0x7C, 0x54, 0x55, 0x45, 0x00, 0x00,
0x20, 0x54, 0x54, 0x7C, 0x54, 0x00,
0x7C, 0x0A, 0x09, 0x7F, 0x49, 0x00,
0x32, 0x49, 0x49, 0x49, 0x32, 0x00,
0x32, 0x48, 0x48, 0x48, 0x32, 0x00,
0x32, 0x4A, 0x48, 0x48, 0x30, 0x00,
0x3A, 0x41, 0x41, 0x21, 0x7A, 0x00,
0x3A, 0x42, 0x40, 0x20, 0x78, 0x00,
0x00, 0x9D, 0xA0, 0xA0, 0x7D, 0x00,
0x39, 0x44, 0x44, 0x44, 0x39, 0x00,
0x3D, 0x40, 0x40, 0x40, 0x3D, 0x00,
0x3C, 0x24, 0xFF, 0x24, 0x24, 0x00,
0x48, 0x7E, 0x49, 0x43, 0x66, 0x00,
0x2B, 0x2F, 0xFC, 0x2F, 0x2B, 0x00,
0xFF, 0x09, 0x29, 0xF6, 0x20, 0x00,
0xC0, 0x88, 0x7E, 0x09, 0x03, 0x00,
0x20, 0x54, 0x54, 0x79, 0x41, 0x00,
0x00, 0x00, 0x44, 0x7D, 0x41, 0x00,
0x30, 0x48, 0x48, 0x4A, 0x32, 0x00,
0x38, 0x40, 0x40, 0x22, 0x7A, 0x00,
0x00, 0x7A, 0x0A, 0x0A, 0x72, 0x00,
0x7D, 0x0D, 0x19, 0x31, 0x7D, 0x00,
0x26, 0x29, 0x29, 0x2F, 0x28, 0x00,
0x26, 0x29, 0x29, 0x29, 0x26, 0x00,
0x30, 0x48, 0x4D, 0x40, 0x20, 0x00,
0x38, 0x08, 0x08, 0x08, 0x08, 0x00,
0x08, 0x08, 0x08, 0x08, 0x38, 0x00,
0x2F, 0x10, 0xC8, 0xAC, 0xBA, 0x00,
0x2F, 0x10, 0x28, 0x34, 0xFA, 0x00,
0x00, 0x00, 0x7B, 0x00, 0x00, 0x00,
0x08, 0x14, 0x2A, 0x14, 0x22, 0x00,
0x22, 0x14, 0x2A, 0x14, 0x08, 0x00,
0xAA, 0x00, 0x55, 0x00, 0xAA, 0x00,
0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x00,
0x00, 0x00, 0x00, 0xFF, 0x00, 0x00,
0x10, 0x10, 0x10, 0xFF, 0x00, 0x00,
0x14, 0x14, 0x14, 0xFF, 0x00, 0x00,
0x10, 0x10, 0xFF, 0x00, 0xFF, 0x00,
0x10, 0x10, 0xF0, 0x10, 0xF0, 0x00,
0x14, 0x14, 0x14, 0xFC, 0x00, 0x00,
0x14, 0x14, 0xF7, 0x00, 0xFF, 0x00,
0x00, 0x00, 0xFF, 0x00, 0xFF, 0x00,
0x14, 0x14, 0xF4, 0x04, 0xFC, 0x00,
0x14, 0x14, 0x17, 0x10, 0x1F, 0x00,
0x10, 0x10, 0x1F, 0x10, 0x1F, 0x00,
0x14, 0x14, 0x14, 0x1F, 0x00, 0x00,
0x10, 0x10, 0x10, 0xF0, 0x00, 0x00,
0x00, 0x00, 0x00, 0x1F, 0x10, 0x00,
0x10, 0x10, 0x10, 0x1F, 0x10, 0x00,
0x10, 0x10, 0x10, 0xF0, 0x10, 0x00,
0x00, 0x00, 0x00, 0xFF, 0x10, 0x00,
0x10, 0x10, 0x10, 0x10, 0x10, 0x00,
0x10, 0x10, 0x10, 0xFF, 0x10, 0x00,
0x00, 0x00, 0x00, 0xFF, 0x14, 0x00,
0x00, 0x00, 0xFF, 0x00, 0xFF, 0x00,
0x00, 0x00, 0x1F, 0x10, 0x17, 0x00,
0x00, 0x00, 0xFC, 0x04, 0xF4, 0x00,
0x14, 0x14, 0x17, 0x10, 0x17, 0x00,
0x14, 0x14, 0xF4, 0x04, 0xF4, 0x00,
0x00, 0x00, 0xFF, 0x00, 0xF7, 0x00,
0x14, 0x14, 0x14, 0x14, 0x14, 0x00,
0x14, 0x14, 0xF7, 0x00, 0xF7, 0x00,
0x14, 0x14, 0x14, 0x17, 0x14, 0x00,
0x10, 0x10, 0x1F, 0x10, 0x1F, 0x00,
0x14, 0x14, 0x14, 0xF4, 0x14, 0x00,
0x10, 0x10, 0xF0, 0x10, 0xF0, 0x00,
0x00, 0x00, 0x1F, 0x10, 0x1F, 0x00,
0x00, 0x00, 0x00, 0x1F, 0x14, 0x00,
0x00, 0x00, 0x00, 0xFC, 0x14, 0x00,
0x00, 0x00, 0xF0, 0x10, 0xF0, 0x00,
0x10, 0x10, 0xFF, 0x10, 0xFF, 0x00,
0x14, 0x14, 0x14, 0xFF, 0x14, 0x00,
0x10, 0x10, 0x10, 0x1F, 0x00, 0x00,
0x00, 0x00, 0x00, 0xF0, 0x10, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00,
0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0x00,
0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00,
0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x00,
0x38, 0x44, 0x44, 0x38, 0x44, 0x00,
0x7C, 0x2A, 0x2A, 0x3E, 0x14, 0x00,
0x7E, 0x02, 0x02, 0x06, 0x06, 0x00,
0x02, 0x7E, 0x02, 0x7E, 0x02, 0x00,
0x63, 0x55, 0x49, 0x41, 0x63, 0x00,
0x38, 0x44, 0x44, 0x3C, 0x04, 0x00,
0x40, 0x7E, 0x20, 0x1E, 0x20, 0x00,
0x06, 0x02, 0x7E, 0x02, 0x02, 0x00,
0x99, 0xA5, 0xE7, 0xA5, 0x99, 0x00,
0x1C, 0x2A, 0x49, 0x2A, 0x1C, 0x00,
0x4C, 0x72, 0x01, 0x72, 0x4C, 0x00,
0x30, 0x4A, 0x4D, 0x4D, 0x30, 0x00,
0x30, 0x48, 0x78, 0x48, 0x30, 0x00,
0xBC, 0x62, 0x5A, 0x46, 0x3D, 0x00,
0x3E, 0x49, 0x49, 0x49, 0x00, 0x00,
0x7E, 0x01, 0x01, 0x01, 0x7E, 0x00,
0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x00,
0x44, 0x44, 0x5F, 0x44, 0x44, 0x00,
0x40, 0x51, 0x4A, 0x44, 0x40, 0x00,
0x40, 0x44, 0x4A, 0x51, 0x40, 0x00,
0x00, 0x00, 0xFF, 0x01, 0x03, 0x00,
0xE0, 0x80, 0xFF, 0x00, 0x00, 0x00,
0x08, 0x08, 0x6B, 0x6B, 0x08, 0x00,
0x36, 0x12, 0x36, 0x24, 0x36, 0x00,
0x00, 0x02, 0x05, 0x02, 0x00, 0x00,
0x00, 0x00, 0x18, 0x18, 0x00, 0x00,
0x00, 0x00, 0x10, 0x10, 0x00, 0x00,
// Commentaire(250,251)
0x1E, 0x21, 0x25, 0x41, 0x25, 0x25,
0x29, 0x25, 0x21, 0x1E, 0x00, 0x00,
// Pouce levé(252,253)
0x38, 0x44, 0x38, 0x7C, 0x7F, 0x7F,
0x7C, 0x7C, 0x7C, 0x38, 0x00, 0x00,
// YoutubeLogo(254,255)
0x3E, 0x7F, 0x7F, 0x41, 0x41, 0x63,
0x63, 0x77, 0x77, 0x7F, 0x3E, 0x00
} ;
/
Изменено: