Le blog de f-leb

Les Arduinautes connaissent bien ce genre de LED programmables que l'on retrouve souvent sous la forme de rubans souples de longueur 1m, 3m, ... 10m et plus, et que l'on utilise pour créer des effets lumineux personnalisés. Voir les bibliothèques FastLED ou NeoPixel par Adafruit.

Pour la démonstration, j'utiliserai un anneau de 12 LED WS2812B (quelques euros l'anneau en cherchant bien), mais que je connecterai à une carte FPGA Altera DE0-Nano.

La carte FPGA, en grand seigneur des ténèbres, contrôle les pouvoirs de l'anneau Unique (forgé par Sauron)... mais je m'égare

/!\ Attention : une seule LED de cet anneau à la luminosité maximale peut consommer jusqu'à 50 mA. Il faudra prévoir une alimentation extérieure ou veiller à ne pas dépasser la limite de courant en contrôlant le nombre de LED allumées simultanément, leurs couleurs et leurs luminosités.

Principe

Ces rubans ou anneaux de LED sont constitués de LED multicolores RGB (Red-Green-Blue) adressables connectées en cascade, c’est à dire que l’on peut définir la luminosité et la couleur de chaque LED indépendamment. Le contrôleur intégré à chaque LED récupère et traite les données série en entrée (sur un seul fil) pour allumer sa LED ou communiquer les données à la LED suivante en sortie selon un timing et un protocole série bien précis.

Principe avec trois LED en cascade d'après WS2812B datasheet

Protocole de transmission série

Au niveau des données à communiquer, c'est très simple, la couleur de la LED est définie par les 24 bits des composantes Rouge-Vert-Bleu selon le schéma ci-dessous :

D'après WS2812B datasheet

Le bit de poids fort est transmis en premier, avec les couleurs suivant l'ordre : Green (G7 à G0), Red (R7 à R0) puis Blue (B7 à B0). C'est tout...

La transmission en cascade est aussi simple sur le principe. Au démarrage (ou après un signal Reset), le contrôleur de la LED PIX1 se sert des 24 premiers bits reçus pour allumer sa LED à la bonne couleur. Les signaux des 24 bits suivants seront reconditionnés par PIX1 et transmis sur sa sortie vers PIX2 qui s'en servira pour allumer sa LED PIX2. Et on poursuit... PIX1 reçoit les 24 bits suivants, qui seront transmis à PIX2, et PIX2 transmettra à PIX3 pour allumer sa LED PIX3, etc.
Chaque LED reçoit donc 24 bits de données et transmet le reste des données à la LED suivante. Pour piloter les 12 LED de l'anneau, il faut donc transmettre 12 x 24 = 288 bits. Pour redémarrer le cycle à partir de la première LED, on envoie un signal Reset et on recommence.

Les signaux physiques

Comment générer physiquement des "0" et des "1" sur un fil ? En suivant le codage des diagrammes suivants, extraits de la documentation :

D'après WS2812B datasheet
T0H = 0,4 µs, T0L = 0,85 µs, T1H = 0,8 µs, T1L = 0,45 µs, avec une tolérance ± 150 ns.
Treset doit être supérieur à 50 µs.

Ce codage consiste donc à envoyer des impulsions électriques de durée variable pour représenter les bits "0" ou "1". Un état haut pendant 0,4 µs suivi d'un état bas pendant 0,85 µs représente un bit "0". Un état haut pendant 0,8 µs suivi d'un état bas pendant 0,45 µs représente un bit "1".
Ainsi, la durée de transmission d'un bit est : TH + TL = 1,25 µs ±300 ns.

Le contrôleur FPGA

Le contrôleur à implémenter dans la puce FPGA est donc le circuit qui génèrera en sortie le signal à transmettre au ruban ou à l'anneau.

Le contrôleur FPGA

Entrées :

• clk : à connecter à l'horloge principale 50 MHz. La durée d'un bit correspond à 60 périodes de l'horloge (60 / 50.10⁶ = 1,2 µs).
• address[7..0] : bus 8 bits, adresse de la LED en cours. La 1^re LED est à l'adresse 0.
• red[7..0], green[7..0], blue[7..0] : bus 8 bits, composantes rouge, verte et bleue de la LED en cours.
• load : lorsque cette entrée est active, et sur front montant de l'horloge, un registre interne est chargé avec les composantes rouge, verte et bleue présentes en entrée pour la LED dont l'adresse est présente en entrée.
• latch_n : entrée active à l'état bas, le registre interne est déverrouillé sur front descendant de l'horloge, et les données série sont transmises en sortie.

Sortie :

• data_ws2812b : les données série à transmettre en entrée du ruban ou de l'anneau. La transmission débute au front montant de l'horloge qui suit le front descendant de l'entrée latch_n. Une fois les 12 x 24 bits transmis, la sortie est à l'état bas. Un signal Reset est donc transmis si l'état bas est maintenu pendant au moins 50 µs.

Ci-dessous, on montre des chronogrammes obtenus par simulation avec seulement deux LED :

• 1^re LED à l'adresse 0 : Rouge=0x33, Vert=0x44, Bleu=0x55
• 2^nd LED à l'adresse 1 : Rouge=0x66, Vert=0x77, Bleu=0x88

On voit le chargement du registre interne colors (2 x 24 bits) sur front montant de l'horloge lorsque l'entrée load est active.
Une fois le registre chargé, les données commencent à être transmises un cycle d'horloge après le front descendant du signal latch_n.

Si on fait un zoom arrière sur ces chronogrammes, on visualise le début de la trame envoyée (les huit premiers bits) juste après l'impulsion du signal latch_n (entourée en rouge) :

Le premier octet transmis : 0x44, la composante verte de la 1^re LED à l'adresse 0

Voici le code commenté du contrôleur en langage Verilog :

ws2812b_controller.v :

Code Verilog :

Sélectionner tout - Visualiser dans une fenêtre à part

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
module ws2812b_controller #(parameter NB_LEDS = 12)
   (
      input clk,				// borloge 50 MHz
      //input reset,       // reset du ruban
      input [7:0] red,
      input [7:0] green,
      input [7:0] blue,
      input [7:0] address, // numéro de la Led entre 0 et NB_LEDS-1
      input load,          // chargement du registre interne (colors)
      input latch_n,       // déverrouille les données et débute la transmission sur front descendant
      
      output data_ws2812b
   );
   
   reg [24 * NB_LEDS - 1 : 0] colors = 0;
   reg latch_n_previous = 1;
   
   localparam  T_HIGH   = 20, // 20 périodes à 50 Mhz = 20 x 20ns = 0,4 us
               T_LOW    = 40, // 40 périodes à 50 Mhz = 40 x 20ns = 0,8 us
               //T_RESET   = 3250,
               T        = T_HIGH + T_LOW;
               
   reg [11:0] t_counter = 0;           // compteur pour le temps
   reg [13:0] rgb_data_index = 0;      // indice de position entre 0 et 23 
   reg transfer_state_reg = 0;
   
   wire load_state;
   wire transfer_state;
   assign load_state = (load==1) & (address < NB_LEDS);
   assign transfer_state = (transfer_state_reg==1) & (~load_state);
   
   
   always@(posedge clk) begin
      if (load_state) begin  // chargement du registre
         colors[(24 * (NB_LEDS - address) - 1)-:24] = {green, red, blue};
      end
   end
   

   always@(posedge clk) begin
      if (transfer_state) begin  // transmission des données

         t_counter <= t_counter - 12'b1;
         
         if (t_counter==0) begin
            t_counter <= T;
            rgb_data_index <= rgb_data_index - 1;
            
            if (rgb_data_index==0) begin
               t_counter <= T;
               rgb_data_index <= 24 * NB_LEDS - 1;
               transfer_state_reg <= 0;
            end         
         end         
      end // if transfer_state   
      
      else if (!latch_n && latch_n != latch_n_previous) begin // si front descendant de latch_n
         rgb_data_index <= 24 * NB_LEDS - 1;
         t_counter <= T;
         transfer_state_reg <= 1;
      end
      
      latch_n_previous <= latch_n;     
   end

   // signal de sortie  
   assign data_ws2812b = (transfer_state==1) & (colors[rgb_data_index] ? t_counter > (T - T_LOW) : t_counter > (T - T_HIGH));
   
   
endmodule

Exemples d'application

Pour animer l'anneau de LED, il faut maintenant mettre en œuvre la description principale (fichier top.v ci-dessous) qui instancie le contrôleur, raccorde ses entrées à des signaux de contrôle et sa sortie vers l'entrée IN de l'anneau (lignes 27 à 39). Pour cette démonstration, le code ci-dessous va charger les couleurs initiales de chacune des 12 LED (lignes 45 à 59) puis, à intervalle régulier, on décale le motif initial d'une LED (lignes 80 à 84) pour donner l'illusion d'une roue multicolore qui se met à tourner.

top.v :

Code Verilog :

Sélectionner tout - Visualiser dans une fenêtre à part

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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
module top
   (
      input CLOCK_50,         // Horloge 50MHz
      output GPIO_WS2812B     // à relier à l'entrée IN de l'anneau
   );
   
   localparam NB_LEDS = 12;      // Anneau avec 12 LED adressables
   localparam ON      = 8'h20,   // luminosité maxi=255, mais /!\ la consommation si toutes les Led sont allumées 
              OFF     = 8'h00;
   
    wire [7:0]    red;
    wire [7:0]    green;
    wire [7:0]    blue;
    wire [7:0]    address;       // numéro de la Led entre 0 et NB_LEDS-1
    wire          load;          // chargement du registre si load=1
    wire          latch_n;       // déverrouillage et transfert du registre sur front descendant

    reg [3:0] state = 0;      // état courant
  
    wire [23:0] rgb;
    reg [25:0] delay = 0;
    
    assign red    = rgb[23-: 8]; // bits 23 à 16
    assign green  = rgb[15-: 8]; // bits 15 à 8
    assign blue   = rgb[7-: 8];  // bits 7 à 0
   
    // instanciation contrôleur WS2812B
    ws2812b_controller #(.NB_LEDS(NB_LEDS)) ws2812b_controller_inst 
      (
        .clk(CLOCK_50),
        //.reset(1'b0),
        .data_ws2812b(GPIO_WS2812B),
        .address(address),
        .red(red),
        .green(green),
        .blue(blue),
        .load(load),
        .latch_n(latch_n)
      );

    integer i;  
    
    reg [23:0] led[0:NB_LEDS-1]; // état des LED
  
    initial begin // synthétisable avec Quartus Pro
    //            Red, Green, Blue
      led[0]   <= { ON , OFF, OFF}; // Led 0, Red
      led[1]   <= { OFF, ON , OFF}; // Led 1, Green
      led[2]   <= { OFF, OFF, ON }; // Led 2, Blue
      led[3]   <= { ON , ON , OFF}; // Led 3, Yellow
      led[4]   <= { ON , OFF, ON }; // Led 4, Purple
      led[5]   <= { OFF, ON , ON }; // Led 5, Cyan
      led[6]   <= { ON , ON , ON }; // Led 6, White
      led[7]   <= { OFF, ON , ON }; // Led 7, Cyan
      led[8]   <= { ON , OFF, ON }; // Led 8, Purple
      led[9]   <= { ON , ON , OFF}; // Led 9, Yellow
      led[10]  <= { OFF, OFF, ON }; // Led 10, Blue
      led[11]  <= { OFF, ON , OFF}; // Led 11, Green   
    end
     
   // assignation des sorties
   assign load = state < NB_LEDS;
   assign address = load ? state : 0;
   assign rgb = load ? led[state] : 0;
   assign latch_n = ~(state == NB_LEDS);

    
    // machine à états finis
    always @(posedge CLOCK_50) begin

      if (state < NB_LEDS) begin // chargement des couleurs pour chaque LED dans le registre
         state <= state + 1;
      end else begin
         case (state)
            NB_LEDS: begin // déverrouillage et transferts des données
               state <= state + 1;              
            end
            
            NB_LEDS+1: begin // rotation des Led
               if (delay[22]==1) begin // si fin temporisation
                  led[0] <= led[NB_LEDS - 1];
                  for (i=1; i<=NB_LEDS-1; i=i+1) begin
                     led[i] <= led[i-1];
                  end
                  
                  state <= 0; // retour à l'état initial
                  delay <= 0;
               end else begin
                  delay <= delay + 1;
               end
            end
         
            default: begin
               //
            end
         
         endcase
               
      end 
    
    end
    
    
endmodule

La vidéo filmée avec mon smartphone ne rend pas bien les couleurs, mais je suis quand même très fier du résultat

Rotation roue multicolore

Et une autre animation pour le fun...

top.v :

Code Verilog :

Sélectionner tout - Visualiser dans une fenêtre à part

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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
module top
   (
      input CLOCK_50,         // Horloge 50MHz
      output GPIO_WS2812B     // à relier à l'entrée IN de l'anneau
   );
   
   localparam NB_LEDS = 12;      // Anneau avec 12 LED adressables
   localparam ON      = 8'h20,   // luminosité maxi=255, mais /!\ la consommation si toutes les Led sont allumées 
              OFF     = 8'h00;
   
    wire [7:0]    red;
    wire [7:0]    green;
    wire [7:0]    blue;
    wire [7:0]    address;       // numéro de la Led entre 0 et NB_LEDS-1
    wire          load;          // chargement du registre si load=1
    wire          latch_n;       // déverrouillage et transfert du registre sur front descendant

    reg [3:0] state = 0;      // état courant
  
    wire[23:0] rgb;
    reg [25:0] delay = 0;
    
    assign red    = rgb[23-: 8]; // bits 23 à 16
    assign green  = rgb[15-: 8]; // bits 15 à 8
    assign blue   = rgb[7-: 8];  // bits 7 à 0
   
    // instanciation contrôleur WS2812B
    ws2812b_controller #(.NB_LEDS(NB_LEDS)) ws2812b_controller_inst 
      (
        .clk(CLOCK_50),
        //.reset(1'b0),
        .data_ws2812b(GPIO_WS2812B),
        .address(address),
        .red(red),
        .green(green),
        .blue(blue),
        .load(load),
        .latch_n(latch_n)
      );

    integer i, c;  
    
    reg [23:0] led[0:NB_LEDS-1]; // état des LED
    reg [3:0] bottom_stack, pointer;
    reg [23:0] color[0:5];
  
    initial begin // synthétisable avec Quartus Pro
    //    
      for (i=0; i<NB_LEDS; i=i+1)  led[i] = {OFF, OFF, OFF};
         
      color[0] <= {ON, OFF, OFF};   // red
      color[1] <= {OFF, ON, OFF};   // green
      color[2] <= {OFF, OFF, ON};   // blue
      color[3] <= {ON, ON, OFF};    // yellow
      color[4] <= {OFF, ON, ON};    // cyan
      color[5] <= {ON, OFF, ON};    // purple
      
      bottom_stack <= NB_LEDS - 1;
      pointer <= 0;

    end
     
   // assignation des sorties
   assign load = state < NB_LEDS;
   assign address = load ? state : 0;
   assign rgb = load ? led[state] : 0;
   assign latch_n = ~(state == NB_LEDS);

    
    // machine à états finis
    always @(posedge CLOCK_50) begin

      if (state < NB_LEDS) begin // chargement des couleurs pour chaque LED dans le registre
         state <= state + 1;
      end else begin
         case (state)
            NB_LEDS: begin // déverrouillage et transferts des données
               state <= state + 1;              
            end
            
            NB_LEDS+1: begin // définition des couleurs des Led
               if (delay[21]==1) begin // si fin temporisation
               
                  for (i=0; i<=NB_LEDS-1 ; i=i+1) begin
                     if (i <= bottom_stack) begin                 
                        led[i] <= (i == pointer) ? color[c] : {OFF, OFF, OFF};                     
                     end else begin
                        led[i] <= color[c];                    
                     end
                  end   
                  
                  pointer <= pointer + 1;
                  
                  if (pointer == bottom_stack) begin
                     pointer <= 0;
                     bottom_stack <= bottom_stack - 1;
                     if (bottom_stack == 1)  begin
                        bottom_stack <= NB_LEDS - 1;
                        c <= c + 1;
                        if (c==5) c<=0;
                     end
                  end

                  state <= 0; // retour à l'état initial
                  delay <= 0;
               end else begin
                  delay <= delay + 1;
               end
            end
         
            default: begin
               //
            end
         
         endcase
               
      end 
    
    end
    
    
endmodule

Cycle rouge, vert, bleu, jaune, cyan, magenta