Antoinnneee

recherche d'algo pour led ws2812B

Nov 18th, 2020 (edited)
33
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