SHOW:
|
|
- or go back to the newest paste.
1 | uint8 staticBits ; // (LED_DR & (uint8)(~LED_MASK)); | |
2 | ||
3 | #define NB_LED 144 | |
4 | #define NB_LED_COMP 143 | |
5 | ||
6 | uint8 LED_ON_BITVALUE = ((uint8)(1 << LED_SHIFT) & LED_MASK); | |
7 | uint8 LED_OFF_BITVALUE = ((uint8)(0 << LED_SHIFT) & LED_MASK); | |
8 | uint8 staticBits ; // doit etre assigné dpeuis le main = (LED_DR & (uint8)(~LED_MASK)); | |
9 | #define LED_ON LED_DR = staticBits | LED_ON_BITVALUE; | |
10 | #define LED_OFF LED_DR = staticBits | LED_OFF_BITVALUE; | |
11 | #define QUICK_LED_BIT_1 {LED_ON __asm__( "nop\n nop\n nop\n nop\n nop\n nop\n"); LED_OFF } | |
12 | #define QUICK_LED_BIT_0 {LED_ON LED_OFF __asm__( "nop\n"); } | |
13 | ||
14 | - | // Test de 2 fonction pour allumer le ruban led WS2812 |
14 | + | // Test de 3 fonction pour allumer le ruban led WS2812 |
15 | - | // La fonction avec les if est plus rapide qu'avec la version switch |
15 | + | // La version ASM est plus rapique que la version avec les if qui est elle meme plus rapide que la version switch |
16 | ||
17 | // edit | |
18 | // - ledStripC est la version la plus rapide | |
19 | // - le while est plus rapide que le do_while | |
20 | // - le test != est plus rapide que < | |
21 | // - supprimer la bouclepar des goto est légèrement plus lent | |
22 | ||
23 | void writeLedStripC() | |
24 | { | |
25 | uint_fast8_t i = 0; | |
26 | boardLed_Write(1); | |
27 | uint_fast8_t bitIndexL = 7; | |
28 | uint_fast8_t byteIndexL = 0; | |
29 | while(i != NB_LED_COMP) | |
30 | { | |
31 | - | if (bitIndexL == 7) |
31 | + | continueLoop: |
32 | if (ledstrip[i].led.data[byteIndexL] & (1u << (bitIndexL))) | |
33 | QUICK_LED_BIT_1 | |
34 | else | |
35 | QUICK_LED_BIT_0 | |
36 | ||
37 | if (bitIndexL) | |
38 | { | |
39 | bitIndexL--; | |
40 | goto continueLoop; | |
41 | } | |
42 | bitIndexL = 7; | |
43 | if (byteIndexL != 2) | |
44 | { | |
45 | byteIndexL++; | |
46 | goto continueLoop; | |
47 | } | |
48 | bitIndexL = 7; | |
49 | byteIndexL = 0; | |
50 | i++; | |
51 | } | |
52 | boardLed_Write(0); | |
53 | } | |
54 | ||
55 | void writeLedStripASM() | |
56 | { | |
57 | uint_fast8_t i = 0; | |
58 | boardLed_Write(1); | |
59 | uint8 bitIndexL = 7 ; | |
60 | uint_fast8_t byteIndexL = 0; | |
61 | - | switch (bitIndexL) |
61 | + | |
62 | { | |
63 | while(byteIndexL < 3) | |
64 | { | |
65 | __asm__ ("CONTINUELOOP:\n"); | |
66 | ||
67 | if (ledstrip[i].led.data[byteIndexL] & (1u << bitIndexL)) | |
68 | QUICK_LED_BIT_1 | |
69 | else | |
70 | QUICK_LED_BIT_0 | |
71 | ||
72 | __asm__ ( | |
73 | "\n" | |
74 | "CBZ %0, RESET\n" | |
75 | "\n" | |
76 | "SUB %0, %0, #1\n" | |
77 | "B CONTINUELOOP\n" | |
78 | "\n" | |
79 | "RESET:\n" | |
80 | "MOV %0, #7\n" | |
81 | "ADD %1, %1, #1\n" | |
82 | : "+r" (bitIndexL), "+r" (byteIndexL) | |
83 | : | |
84 | ); | |
85 | } | |
86 | bitIndexL = 7; | |
87 | byteIndexL = 0; | |
88 | i++; | |
89 | } | |
90 | boardLed_Write(0); | |
91 | } | |
92 | ||
93 | void writeLedStrip() | |
94 | { | |
95 | uint_fast8_t i = 0; | |
96 | boardLed_Write(1); | |
97 | uint_fast8_t bitIndexL = 7; | |
98 | uint_fast8_t byteIndexL = 0; | |
99 | while(i < NB_LED) | |
100 | { | |
101 | while (byteIndexL<3) | |
102 | { | |
103 | if (ledstrip[i].led.data[byteIndexL] & (1u << (7- bitIndexL))) | |
104 | QUICK_LED_BIT_1 | |
105 | else | |
106 | QUICK_LED_BIT_0 | |
107 | ||
108 | if (bitIndexL) | |
109 | { | |
110 | bitIndexL--; | |
111 | ||
112 | } | |
113 | else | |
114 | { | |
115 | bitIndexL = 7; | |
116 | byteIndexL++; | |
117 | } | |
118 | } | |
119 | bitIndexL = 7; | |
120 | byteIndexL = 0; | |
121 | i++; | |
122 | } | |
123 | boardLed_Write(0); | |
124 | } | |
125 | ||
126 | ||
127 | version switch: | |
128 | void writeLedStrip() | |
129 | { | |
130 | uint_fast8_t i = 0; | |
131 | boardLed_Write(1); | |
132 | uint_fast8_t bitIndexL = 0; | |
133 | uint_fast8_t byteIndexL = 0; | |
134 | while(i < NB_LED) | |
135 | { | |
136 | while (byteIndexL<3) | |
137 | { | |
138 | switch (bitIndexL) | |
139 | { | |
140 | case 0: | |
141 | if (ledstrip[i].led.data[byteIndexL] & 128u) | |
142 | QUICK_LED_BIT_1 | |
143 | else | |
144 | QUICK_LED_BIT_0 | |
145 | bitIndexL++; | |
146 | break; | |
147 | case 1: | |
148 | if (ledstrip[i].led.data[byteIndexL] & 64u) | |
149 | QUICK_LED_BIT_1 | |
150 | else | |
151 | QUICK_LED_BIT_0 | |
152 | bitIndexL++; | |
153 | break; | |
154 | case 2: | |
155 | if (ledstrip[i].led.data[byteIndexL] & 32u) | |
156 | QUICK_LED_BIT_1 | |
157 | else | |
158 | QUICK_LED_BIT_0 | |
159 | bitIndexL++; | |
160 | break; | |
161 | case 3: | |
162 | if (ledstrip[i].led.data[byteIndexL] & 16u) | |
163 | QUICK_LED_BIT_1 | |
164 | else | |
165 | QUICK_LED_BIT_0 | |
166 | bitIndexL++; | |
167 | break; | |
168 | case 4: | |
169 | if (ledstrip[i].led.data[byteIndexL] & 8u) | |
170 | QUICK_LED_BIT_1 | |
171 | else | |
172 | QUICK_LED_BIT_0 | |
173 | bitIndexL++; | |
174 | break; | |
175 | case 5: | |
176 | if (ledstrip[i].led.data[byteIndexL] & 4u) | |
177 | QUICK_LED_BIT_1 | |
178 | else | |
179 | QUICK_LED_BIT_0 | |
180 | bitIndexL++; | |
181 | break; | |
182 | case 6: | |
183 | if (ledstrip[i].led.data[byteIndexL] & 2u) | |
184 | QUICK_LED_BIT_1 | |
185 | else | |
186 | QUICK_LED_BIT_0 | |
187 | bitIndexL++; | |
188 | break; | |
189 | case 7: | |
190 | if (ledstrip[i].led.data[byteIndexL] & 1u) | |
191 | QUICK_LED_BIT_1 | |
192 | else | |
193 | QUICK_LED_BIT_0 | |
194 | bitIndexL = 0; | |
195 | byteIndexL++; | |
196 | break; | |
197 | } | |
198 | ||
199 | } | |
200 | bitIndexL = 0; | |
201 | byteIndexL = 0; | |
202 | i++; | |
203 | } | |
204 | boardLed_Write(0); | |
205 | } | |
206 | ||
207 |