Add example drawing routing for numbers

2 files changed, 196 insertions, 151 deletions

diff --git a/Makefile b/Makefile
index cfb7766..42763b3 100644
--- a/Makefile
+++ b/Makefile
@@ -16,6 +16,7 @@ ELF = $(BUILDDIR)/launchpad_pro.elf
 HEX = $(BUILDDIR)/launchpad_pro.hex
 HEXTOSYX = $(BUILDDIR)/hextosyx
 SIMULATOR = $(BUILDDIR)/simulator
+PORT = hw:4,0,0
 
 # tools
 HOST_GPP = g++
@@ -65,3 +66,6 @@ $(BUILDDIR)/%.o: %.c
 
 clean:
         rm -rf $(BUILDDIR)
+
+run: $(SYX)
+        amidi -p $(PORT) -s $(SYX) -i 20
diff --git a/src/app.c b/src/app.c
index 4ce908e..667ce32 100644
--- a/src/app.c
+++ b/src/app.c
@@ -1,22 +1,22 @@
 /******************************************************************************
- 
- Copyright (c) 2015, Focusrite Audio Engineering Ltd.
- All rights reserved.
- 
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are met:
- 
+
+  Copyright (c) 2015, Focusrite Audio Engineering Ltd.
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+
  * Redistributions of source code must retain the above copyright notice, this
  list of conditions and the following disclaimer.
- 
+
  * Redistributions in binary form must reproduce the above copyright notice,
  this list of conditions and the following disclaimer in the documentation
  and/or other materials provided with the distribution.
- 
+
  * Neither the name of Focusrite Audio Engineering Ltd., nor the names of its
  contributors may be used to endorse or promote products derived from
  this software without specific prior written permission.
- 
+
  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
@@ -27,182 +27,223 @@
  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- 
- *****************************************************************************/
 
-//______________________________________________________________________________
-//
-// Headers
-//______________________________________________________________________________
+ *****************************************************************************/
 
 #include "app.h"
 
-//______________________________________________________________________________
-//
-// This is where the fun is!  Add your code to the callbacks below to define how
-// your app behaves.
-//
-// In this example, we either render the raw ADC data as LED rainbows or store
-// and recall the pad state from flash.
-//______________________________________________________________________________
-
 // store ADC frame pointer
 static const u16 *g_ADC = 0;
 
 // buffer to store pad states for flash save
 #define BUTTON_COUNT 100
-
-u8 g_Buttons[BUTTON_COUNT] = {0};
-
-//______________________________________________________________________________
-
-void app_surface_event(u8 type, u8 index, u8 value)
-{
-    switch (type)
-    {
-        case  TYPEPAD:
-        {
+u8 buttons[BUTTON_COUNT] = {0};
+u16 font_numbers[10] = {
+    /*
+    * 0: 111 | 1111 0110 1101 1110
+    *    101 |
+    *    101 |
+    *    101 |
+    *    111 |
+    */
+    0xF6DE,
+    /*
+    * 1: 010 | 0101 1001 0010 1110
+    *    110 |
+    *    010 |
+    *    010 |
+    *    111 |
+    */
+    0x592E,
+    /*
+    * 2: 111 | 1110 0111 1100 1110
+    *    001 |
+    *    111 |
+    *    100 |
+    *    111 |
+    */
+    0xE7CE,
+    /*
+    * 3: 111 | 1110 0101 1001 1110
+    *    001 |
+    *    011 |
+    *    001 |
+    *    111 |
+    */
+    0xE59E,
+    /*
+    * 4: 101 | 1011 0110 1111 0010
+    *    101 |
+    *    101 |
+    *    111 |
+    *    001 |
+    */
+    0xB6F2,
+    /*
+    * 5: 111 | 1111 0011 1001 1110
+    *    100 |
+    *    111 |
+    *    001 |
+    *    111 |
+    */
+    0xF39E,
+    /*
+    * 6: 111 | 1111 0011 1101 1110
+    *    100 |
+    *    111 |
+    *    101 |
+    *    111 |
+    */
+    0xF3DE,
+    /*
+    * 7: 111 | 1110 0101 0100 1000
+    *    001 |
+    *    010 |
+    *    100 |
+    *    100 |
+    */
+    0xE548,
+    /*
+    * 8: 111 | 1111 0111 1101 1110
+    *    101 |
+    *    111 |
+    *    101 |
+    *    111 |
+    */
+    0xF7DE,
+    /*
+    * 9: 111 | 1111 0111 1001 0010
+    *    101 |
+    *    111 |
+    *    001 |
+    *    001 |
+    */
+    0xF792,
+};
+
+void
+app_surface_event(u8 type, u8 index, u8 value) {
+    switch (type) {
+        case  TYPEPAD: {
             // toggle it and store it off, so we can save to flash if we want to
-            if (value)
-            {
-                g_Buttons[index] = MAXLED * !g_Buttons[index];
+            if (value) {
+                buttons[index] = MAXLED * !buttons[index];
             }
-            
+
             // example - light / extinguish pad LEDs
-            hal_plot_led(TYPEPAD, index, 0, 0, g_Buttons[index]);
-            
+            // hal_plot_led(TYPEPAD, index, 0, 0, buttons[index]);
+
             // example - send MIDI
-            hal_send_midi(DINMIDI, NOTEON | 0, index, value);
-            
-        }
-        break;
-            
-        case TYPESETUP:
-        {
-            if (value)
-            {
-                // save button states to flash (reload them by power cycling the hardware!)
-                hal_write_flash(0, g_Buttons, BUTTON_COUNT);
+            // hal_send_midi(DINMIDI, NOTEON | 0, index, value);
+        } break;
+        case TYPESETUP: {
+            if (value) {
+                // Pressing the setup button will save the current buttons/pad
+                // state to the flash. The flash memory is USER_AREA_SIZE bytes
+                // long and can be organized however we need.
+                hal_write_flash(0, buttons, BUTTON_COUNT);
             }
-        }
-        break;
+        } break;
     }
 }
 
-//______________________________________________________________________________
-
-void app_midi_event(u8 port, u8 status, u8 d1, u8 d2)
-{
-    // example - MIDI interface functionality for USB "MIDI" port -> DIN port
-    if (port == USBMIDI)
-    {
+void
+app_midi_event(u8 port, u8 status, u8 d1, u8 d2) {
+    if (port == USBMIDI) {
         hal_send_midi(DINMIDI, status, d1, d2);
     }
-    
-    // // example -MIDI interface functionality for DIN -> USB "MIDI" port port
-    if (port == DINMIDI)
-    {
+    if (port == DINMIDI) {
         hal_send_midi(USBMIDI, status, d1, d2);
     }
 }
 
-//______________________________________________________________________________
-
-void app_sysex_event(u8 port, u8 * data, u16 count)
-{
+void
+app_sysex_event(u8 port, u8 * data, u16 count) {
     // example - respond to UDI messages?
 }
 
-//______________________________________________________________________________
-
-void app_aftertouch_event(u8 index, u8 value)
-{
+void
+app_aftertouch_event(u8 index, u8 value) {
     // example - send poly aftertouch to MIDI ports
-    hal_send_midi(USBMIDI, POLYAFTERTOUCH | 0, index, value);
-    
-    
+    // hal_send_midi(USBMIDI, POLYAFTERTOUCH | 0, index, value);
 }
 
-//______________________________________________________________________________
-
-void app_cable_event(u8 type, u8 value)
-{
+void
+app_cable_event(u8 type, u8 value) {
     // example - light the Setup LED to indicate cable connections
-    if (type == MIDI_IN_CABLE)
-    {
-        hal_plot_led(TYPESETUP, 0, 0, value, 0); // green
-    }
-    else if (type == MIDI_OUT_CABLE)
-    {
-        hal_plot_led(TYPESETUP, 0, value, 0, 0); // red
-    }
+    // if (type == MIDI_IN_CABLE) {
+    //     hal_plot_led(TYPESETUP, 0, 0, value, 0); // green
+    // } else if (type == MIDI_OUT_CABLE) {
+    //     hal_plot_led(TYPESETUP, 0, value, 0, 0); // red
+    // }
 }
 
-//______________________________________________________________________________
-
-void app_timer_event()
-{
-    // example - send MIDI clock at 125bpm
-#define TICK_MS 20
-    
-    static u8 ms = TICK_MS;
-    
-    if (++ms >= TICK_MS)
-    {
-        ms = 0;
-        
-        // send a clock pulse up the USB
-        hal_send_midi(USBSTANDALONE, MIDITIMINGCLOCK, 0, 0);
+void
+print_number(u8 n, u16 r, u16 g, u16 b, u8 x, u8 y) {
+    u16 number = font_numbers[n];
+    for (u8 row = 0; row < 5; row++) {
+        u8 pos = 11 + 10 * (7 - x + y * 8) - row * 10;
+        u16 cur = number >> (13 - 3 * row);
+        for (u8 i = 0; i < 3; i++) {
+            if ((cur >> (2 - i)) & 0x1) {
+                hal_plot_led(TYPEPAD, pos + i, r, g, b);
+            }
+        }
     }
-    
-        // alternative example - show raw ADC data as LEDs
-        for (int i=0; i < PAD_COUNT; ++i)
-        {
-                // raw adc values are 12 bit, but LEDs are 6 bit.
-                // Let's saturate into r;g;b for a rainbow effect to show pressure
-                u16 r = 0;
-                u16 g = 0;
-                u16 b = 0;
-                
-                u16 x = (3 * MAXLED * g_ADC[i]) >> 12;
-                
-                if (x < MAXLED)
-                {
-                        r = x;
-                }
-                else if (x >= MAXLED && x < (2*MAXLED))
-                {
-                        r = 2*MAXLED - x;
-                        g = x - MAXLED;
-                }
-                else
-                {
-                        g = 3*MAXLED - x;
-                        b = x - 2*MAXLED;
-                }
-                
-                hal_plot_led(TYPEPAD, ADC_MAP[i], r, g, b);
-        }
 }
 
-//______________________________________________________________________________
+void
+app_timer_event() {
+    // example - send MIDI clock at 125bpm
+// #define TICK_MS 20
+
+//     static u8 ms = TICK_MS;
+
+//     if (++ms >= TICK_MS)
+//     {
+//         ms = 0;
+
+//         // send a clock pulse up the USB
+//         hal_send_midi(USBSTANDALONE, MIDITIMINGCLOCK, 0, 0);
+//     }
+
+    // alternative example - show raw ADC data as LEDs
+    // for (int i = 0; i < PAD_COUNT; ++i) {
+    //     // raw adc values are 12 bit, but LEDs are 6 bit.
+    //     // Let's saturate into r;g;b for a rainbow effect to show pressure
+    //     u16 r = 0;
+    //     u16 g = 0;
+    //     u16 b = 0;
+
+    //     u16 x = (3 * MAXLED * g_ADC[i]) >> 12;
+
+    //     if (x < MAXLED) {
+    //         r = x;
+    //     } else if (x >= MAXLED && x < (2*MAXLED)) {
+    //         r = 2 * MAXLED - x;
+    //         g = x - MAXLED;
+    //     }
+    //     else {
+    //         g = 3 * MAXLED - x;
+    //         b = x - 2*MAXLED;
+    //     }
+
+    //     print_number(i, r, g, b, 0, 0);
+    //     break;
+    //     // if (buttons[ADC_MAP[i]] == MAXLED) {
+    //         // hal_plot_led(TYPEPAD, ADC_MAP[i], r, g, b);
+    //     // } else {
+    //     //     hal_plot_led(TYPEPAD, ADC_MAP[i], 0, 0, MAXLED);
+    //     // }
+    // }
+    print_number(9, MAXLED, MAXLED, MAXLED, 0, 0);
+}
 
-void app_init(const u16 *adc_raw)
-{
+void
+app_init(const u16 *adc_raw) {
     // example - load button states from flash
-    hal_read_flash(0, g_Buttons, BUTTON_COUNT);
-    
-    // example - light the LEDs to say hello!
-    for (int i=0; i < 10; ++i)
-    {
-        for (int j=0; j < 10; ++j)
-        {
-            u8 b = g_Buttons[j*10 + i];
-            
-            hal_plot_led(TYPEPAD, j*10 + i, 0, 0, b);
-        }
-    }
-        
-        // store off the raw ADC frame pointer for later use
-        g_ADC = adc_raw;
+    hal_read_flash(0, buttons, BUTTON_COUNT);
+
+    // store off the raw ADC frame pointer for later use
+    g_ADC = adc_raw;
 }