Merge pull request arduino#58 from bcmi-labs/LED-matrix-plus

New methods and flags + API refactoring

Author: facchinm

.gitignore

@@ -2,3 +2,5 @@
 cores/arduino/mydebug.cpp
 libraries/Storage/.development
 cores/arduino/mydebug.cpp.donotuse
+.DS_Store
+.DS_Store?

libraries/LED_Matrix/examples/Blink/Blink.ino renamed to libraries/Arduino_LED_Matrix/examples/Blink/Blink.ino

@@ -133,14 +133,15 @@ static uint32_t reverse(uint32_t x)
 }
 
 // TODO: this is dangerous, use with care
-#define load(x)     load_wrapper(x, sizeof(x))
+#define loadSequence(frames)                loadWrapper(frames, sizeof(frames))
+#define renderBitmap(bitmap, rows, columns) loadPixels(&bitmap[0][0], rows*columns)
 
 static uint8_t __attribute__((aligned)) framebuffer[NUM_LEDS / 8];
 
-class LED_Matrix {
+class ArduinoLEDMatrix {
 
 public:
-    LED_Matrix() {}
+    ArduinoLEDMatrix() {}
     // TODO: find a better name
     // autoscroll will be slower than calling next() at precise times
     void autoscroll(uint32_t interval_ms) {
@@ -156,41 +157,102 @@ class LED_Matrix {
         uint8_t type;
         uint8_t ch = FspTimer::get_available_timer(type);
         // TODO: avoid passing "this" argument to remove autoscroll
-        led_timer.begin(TIMER_MODE_PERIODIC, type, ch, 10000.0, 50.0, turnOnLedISR, this);
-        led_timer.setup_overflow_irq();
-        led_timer.open();
-        led_timer.start();
+        _ledTimer.begin(TIMER_MODE_PERIODIC, type, ch, 10000.0, 50.0, turnOnLedISR, this);
+        _ledTimer.setup_overflow_irq();
+        _ledTimer.open();
+        _ledTimer.start();
     }
     void next() {
         uint32_t frame[3];
-        static int j = 0;
-        frame[0] = reverse(*(_frames+(j*4)+0));
-        frame[1] = reverse(*(_frames+(j*4)+1));
-        frame[2] = reverse(*(_frames+(j*4)+2));
-        _interval = *(_frames+(j*4)+3);
-        j = (j + 1) % _lines;
+        frame[0] = reverse(*(_frames+(_currentFrame*4)+0));
+        frame[1] = reverse(*(_frames+(_currentFrame*4)+1));
+        frame[2] = reverse(*(_frames+(_currentFrame*4)+2));
+        _interval = *(_frames+(_currentFrame*4)+3);
+        _currentFrame = (_currentFrame + 1) % _framesCount;
+        if(_currentFrame == 0){
+            if(!_loop){
+                _interval = 0;
+            }
+            if(_callBack != nullptr){
+                _callBack();
+                _sequenceDone = true;
+            }
+        }
         memcpy(framebuffer, (uint32_t*)frame, sizeof(frame));
     }
-    void load_wrapper(const uint32_t frames[][4], uint32_t howMany) {
+    void loadFrame(const uint32_t buffer[3]){
+        uint32_t tempBuffer[][4] = {{
+            buffer[0], buffer[1], buffer[2], 0
+        }};
+        loadSequence(tempBuffer);
+        next();
+        _interval = 0;
+    }
+    void renderFrame(uint8_t frameNumber){
+        _currentFrame = frameNumber % _framesCount;
+        next();
+        _interval = 0;
+    }
+    void play(bool loop = false){
+        _loop = loop;
+        _sequenceDone = false;
+        next();
+    }
+    bool sequenceDone(){
+        if(_sequenceDone){
+            _sequenceDone = false;
+            return true;
+        }
+        return false;
+    }
+
+    void loadPixels(uint8_t *arr, size_t size){
+        uint32_t partialBuffer = 0;
+        uint8_t pixelIndex = 0;
+        uint8_t *frameP = arr;
+        uint32_t *frameHolderP = _frameHolder;
+        while (pixelIndex < size) {
+            partialBuffer |= *frameP++;
+            if ((pixelIndex + 1) % 32 == 0) {
+                *(frameHolderP++) = partialBuffer;
+            }
+            partialBuffer = partialBuffer << 1;
+            pixelIndex++;
+        }
+        loadFrame(_frameHolder);
+    };
+
+    void loadWrapper(const uint32_t frames[][4], uint32_t howMany) {
+        _currentFrame = 0;
         _frames = (uint32_t*)frames;
-        _lines = (howMany / 4) / sizeof(uint32_t);
+        _framesCount = (howMany / 4) / sizeof(uint32_t);
+    }
+    // WARNING: callbacks are fired from ISR. The execution time will be limited.
+    void setCallback(voidFuncPtr callBack){
+        _callBack = callBack;
     }
+    
 private:
+    int _currentFrame = 0;
+    uint32_t _frameHolder[3];
     uint32_t* _frames;
-    uint32_t _lines;
+    uint32_t _framesCount;
     uint32_t _interval = 0;
-    uint32_t _last_interval = 0;
-    FspTimer led_timer;
+    uint32_t _lastInterval = 0;
+    bool _loop = false;
+    FspTimer _ledTimer;
+    bool _sequenceDone = false;
+    voidFuncPtr _callBack;
 
     static void turnOnLedISR(timer_callback_args_t *arg) {
         static volatile int i_isr = 0;
         turnLed(i_isr, ((framebuffer[i_isr >> 3] & (1 << (i_isr % 8))) != 0));
         i_isr = (i_isr + 1) % NUM_LEDS;
         if (arg != nullptr && arg->p_context != nullptr) {
-            LED_Matrix* _m = (LED_Matrix*)arg->p_context;
-            if (_m->_interval != 0 && millis() - _m->_last_interval > _m->_interval) {
+            ArduinoLEDMatrix* _m = (ArduinoLEDMatrix*)arg->p_context;
+            if (_m->_interval != 0 && millis() - _m->_lastInterval > _m->_interval) {
                 _m->next();
-                _m->_last_interval = millis();
+                _m->_lastInterval = millis();
             }
         }
     }