Antoinnneee

recherche d'algo pour led ws2812B

Nov 18th, 2020 (edited)
62
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  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 3 fonction pour allumer le ruban led WS2812
  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.         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.     while(i < NB_LED)
  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.  
RAW Paste Data

Adblocker detected! Please consider disabling it...

We've detected AdBlock Plus or some other adblocking software preventing Pastebin.com from fully loading.

We don't have any obnoxious sound, or popup ads, we actively block these annoying types of ads!

Please add Pastebin.com to your ad blocker whitelist or disable your adblocking software.

×