spi timing

Makefile

@@ -11,7 +11,7 @@ CFLAGS=-Wall -mmcu=$(MCU) -std=gnu99 -I $(TOOLCHAIN_PREFIX)/include -O3 -g0
 
 LDFLAGS=-mmcu=$(MCU) -L $(TOOLCHAIN_PREFIX)/include
 
-$(ARTIFACT).elf:	main.o led.o time.o PontCoopScheduler.o displayDriver.o canvas.o displayTest.o
+$(ARTIFACT).elf:	main.o led.o time.o PontCoopScheduler.o displayDriver.o canvas.o displayTest.o displayTest2.o displayTest3.o
 	$(CC) -o $@ $(LDFLAGS) $^
 	$(OBJDUMP) -D $(ARTIFACT).elf > $(ARTIFACT).txt
 
@@ -24,7 +24,7 @@ all:	$(ARTIFACT).elf
 
 .PHONY: clean
 clean:
-	-rm -f *.o *.elf
+	-rm -f *.o $(ARTIFACT).elf $(ARTIFACT).txt
 
 .PHONY: upload
 upload: $(ARTIFACT).elf

PontCoopScheduler.h

@@ -13,7 +13,7 @@
 
 
 
-#define MAX_NUM_OF_TASKS 4
+#define MAX_NUM_OF_TASKS 2
 
 
 typedef struct {

canvas.c

@@ -5,23 +5,25 @@
 #include "displayDriver.h"
 
 
-static canvas_t canvas;
 static uint8_t canvasStorage[CANVAS_WIDTH * CANVAS_HEIGHT];
+const canvas_t canvas = { 
+  .height = CANVAS_HEIGHT,
+  .width = CANVAS_WIDTH,
+  .size = CANVAS_WIDTH * CANVAS_HEIGHT,
+  .canvas = canvasStorage
+};
 
 void canvasInit() {
-  canvas.height = CANVAS_HEIGHT;
-  canvas.width = CANVAS_WIDTH;
-  canvas.size = CANVAS_HEIGHT * CANVAS_WIDTH;
-  canvas.canvas = canvasStorage;
-
-  // Bit7 signals need to be transfered for octet
-  memset(canvasStorage, 0x80, canvas.size);
-
+  canvasClear();
   displayDriverTransferCanvas();
 }
 
-canvas_t *canvasGet() {
-  return &canvas;
+void canvasClear() {
+  memset(canvas.canvas, 0x80, canvas.size);
+}
+
+void canvasSetAll(uint8_t color) {
+  memset(canvas.canvas, color + 0x80, canvas.size);
 }
 
 void canvasShow() {
@@ -31,3 +33,23 @@ void canvasShow() {
 void canvasSetPixel(uint8_t column, uint8_t row, uint8_t color) {
   *((canvas.canvas) + (row * canvas.width + column)) = (color + 0x80);
 }
+
+void canvasWipeRow(uint8_t row) {
+  memmove(((canvas.canvas)+canvas.width), canvas.canvas, canvas.width*row);
+  for (uint8_t i = 10; i < canvas.width*(row+1); i++) {
+    *((canvas.canvas)+i) += 0x80;
+  }
+  memset(canvas.canvas, 0x80, canvas.width);
+}
+
+uint8_t canvasIsRowFilled(uint8_t row) {
+  uint8_t res = 1;
+  for (uint8_t column = 0; column < canvas.width; column++) {
+    if (*((canvas.canvas) + (row * canvas.width + column)) == 0) {
+      res = 0;
+      break;
+    }
+  }
+  return res;
+}
+

canvas.h

@@ -5,20 +5,23 @@
 
 
 #define CANVAS_WIDTH 10
-#define CANVAS_HEIGHT 6
+#define CANVAS_HEIGHT 11 
 
 typedef struct {
-  uint8_t width;
-  uint8_t height;
-  uint8_t size;
-  uint8_t *canvas;
+  const uint8_t width;
+  const uint8_t height;
+  const uint8_t size;
+  uint8_t * const canvas;
 } canvas_t;
 
 void canvasInit();
-canvas_t *canvasGet();
+void canvasClear();
+void canvasSetAll(uint8_t color);
 void canvasShow();
 void canvasSetPixel(uint8_t column, uint8_t row, uint8_t color);
+void canvasWipeRow(uint8_t row);
+uint8_t canvasIsRowFilled(uint8_t row);
 
-
+extern const canvas_t canvas;
 
 #endif // _CANVAS_H_

displayDriver.c

@@ -18,12 +18,11 @@ void displayDriverTransferCanvas() {
   // wait for signal waiting for data
   while ((P1IN & BIT3) == 0);
 
-  canvas_t *canvas = canvasGet();
-  for (uint8_t i = 0; i < canvas->size; i++) {
-    if ((*((canvas->canvas)+i) & 0x80) != 0) {
-      *((canvas->canvas)+i) &= ~0x80;
+  for (uint8_t i = 0; i < canvas.size; i++) {
+    if ((*((canvas.canvas)+i) & 0x80) != 0) {
+      *((canvas.canvas)+i) &= ~0x80;
       spiSendOctet(i);
-      spiSendOctet(*((canvas->canvas)+i));
+      spiSendOctet(*((canvas.canvas)+i));
     }
   }
   spiSendOctet(0xfe);
@@ -34,7 +33,11 @@ void displayDriverInit() {
   UCB0CTL0 = UCMST;
   // SPI timing config
   UCB0CTL1 = UCSSEL_3;
-  UCB0BR0 = 4; // 2 would be too fast and ends up with errors
+  // Faster than 8 ends up in strange communication errors
+  // between the both MCUs.
+  // With 8 the transfer of a complete 110 pixel canvas takes
+  // about 720us.
+  UCB0BR0 = 8; 
   UCB0BR1 = 0;
 
   // BIT5: UCB0CLK

displayTest.c

@@ -3,78 +3,169 @@
 #include "PontCoopScheduler.h"
 
 
-static canvas_t *canvas;
-
 #define MAX_COLOR 0x0d
 
+typedef enum {
+  e_WIPE_LAST_COLUMN_DOWN,
+  e_PIXELS_UP,
+  e_WIPE_LAST_PIXEL_UP,
+  e_PIXELS_DOWN,
+  e_WIPE_LAST_PIXEL_DOWN,
+  e_ROWS_UP,
+  e_WIPE_LAST_ROW_UP,
+  e_ROWS_DOWN,
+  e_WIPE_LAST_ROW_DOWN,
+  e_COLUMNS_UP,
+  e_WIPE_LAST_COLUMN_UP,
+  e_COLUMNS_DOWN
+} t_State;
+
 void displayTestExec(void *args) {
-  static uint8_t last = 0xff;
-  static uint8_t current = 0;
+  static int16_t last = 0xff;
+  static int16_t current = 0;
   static uint8_t color = 0x01;
-  static uint8_t state = 1;
+  static t_State state = e_PIXELS_UP;
 
   switch (state) {
-    case 0:
-      for (uint16_t i = 0; i < canvas->height; i++) {
+    // wipe last column
+    case e_WIPE_LAST_COLUMN_DOWN:
+      for (uint16_t i = 0; i < canvas.height; i++) {
         canvasSetPixel(last, i, 0);
       }
       last = 0xff;
-      state = 1;
-    case 1:
+      state = e_PIXELS_UP;
+    // pixels up
+    case e_PIXELS_UP:
       if (last != 0xff) {
-        *((canvas->canvas)+last) = 0x80;
+        *((canvas.canvas)+last) = 0x80;
       }
 
       last = current;
-      *((canvas->canvas)+current) = (color + 0x80);
+      *((canvas.canvas)+current) = (color + 0x80);
       current++;
-      if (current >= canvas->size) {
+      if (current >= canvas.size) {
         current = 0;
-        state = 2;
+        state = e_WIPE_LAST_PIXEL_UP;
       }
       break;
-    case 2:
-      *((canvas->canvas)+last) = 0x80;
+    // wipe last pixel
+    case e_WIPE_LAST_PIXEL_UP:
+      *((canvas.canvas)+last) = 0x80;
       last = 0xff;
-      state = 3;
-    case 3:
+      current = canvas.size - 1;
+      state = e_PIXELS_DOWN;
+    // pixels down
+    case e_PIXELS_DOWN:
       if (last != 0xff) {
-        for (uint16_t i = 0; i < canvas->width; i++) {
+        *((canvas.canvas)+last) = 0x80;
+      }
+
+      last = current;
+      *((canvas.canvas)+current) = (color + 0x80);
+      current--;
+      if (current < 0) {
+        current = 0;
+        state = e_WIPE_LAST_PIXEL_DOWN;
+      }
+      break;
+    // wipe last pixel
+    case e_WIPE_LAST_PIXEL_DOWN:
+      *((canvas.canvas)+last) = 0x80;
+      last = 0xff;
+      state = e_ROWS_UP;
+    // rows up
+    case e_ROWS_UP:
+      if (last != 0xff) {
+        for (uint16_t i = 0; i < canvas.width; i++) {
           canvasSetPixel(i, last, 0);
         }
       }
 
       last = current;
-      for (uint16_t i = 0; i < canvas->width; i++) {
+      for (uint16_t i = 0; i < canvas.width; i++) {
         canvasSetPixel(i, current, color);
       }
       current++;
-      if (current >= canvas->height) {
+      if (current >= canvas.height) {
         current = 0;
-        state = 4;
+        state = e_WIPE_LAST_ROW_UP;
       }
       break;
-    case 4:
-      for (uint16_t i = 0; i < canvas->width; i++) {
+    // wipe last row
+    case e_WIPE_LAST_ROW_UP:
+      for (uint16_t i = 0; i < canvas.width; i++) {
         canvasSetPixel(i, last, 0);
       }
       last = 0xff;
-      state = 5;
-    case 5:
+      current = canvas.height - 1;
+      state = e_ROWS_DOWN;
+    // rows down
+    case e_ROWS_DOWN:
       if (last != 0xff) {
-        for (uint16_t i = 0; i < canvas->height; i++) {
+        for (uint16_t i = 0; i < canvas.width; i++) {
+          canvasSetPixel(i, last, 0);
+        }
+      }
+
+      last = current;
+      for (uint16_t i = 0; i < canvas.width; i++) {
+        canvasSetPixel(i, current, color);
+      }
+      current--;
+      if (current < 0) {
+        current = 0;
+        state = e_WIPE_LAST_ROW_DOWN;
+      }
+      break;
+    // wipe last row
+    case e_WIPE_LAST_ROW_DOWN:
+      for (uint16_t i = 0; i < canvas.width; i++) {
+        canvasSetPixel(i, last, 0);
+      }
+      last = 0xff;
+      state = e_COLUMNS_UP;
+    // columns up
+    case e_COLUMNS_UP:
+      if (last != 0xff) {
+        for (uint16_t i = 0; i < canvas.height; i++) {
           canvasSetPixel(last, i, 0);
         }
       }
 
       last = current;
-      for (uint16_t i = 0; i < canvas->height; i++) {
+      for (uint16_t i = 0; i < canvas.height; i++) {
         canvasSetPixel(current, i, color);
       }
       current++;
-      if (current >= canvas->width) {
+      if (current >= canvas.width) {
         current = 0;
-        state = 0;
+        state = e_WIPE_LAST_COLUMN_UP;
+      }
+      break;
+    // wipe last column
+    case e_WIPE_LAST_COLUMN_UP:
+      for (uint16_t i = 0; i < canvas.height; i++) {
+        canvasSetPixel(last, i, 0);
+      }
+      last = 0xff;
+      current = canvas.width - 1;
+      state = e_COLUMNS_DOWN;
+    // columns down
+    case e_COLUMNS_DOWN:
+      if (last != 0xff) {
+        for (uint16_t i = 0; i < canvas.height; i++) {
+          canvasSetPixel(last, i, 0);
+        }
+      }
+
+      last = current;
+      for (uint16_t i = 0; i < canvas.height; i++) {
+        canvasSetPixel(current, i, color);
+      }
+      current--;
+      if (current < 0) {
+        current = 0;
+        state = e_WIPE_LAST_COLUMN_DOWN;
       }
       break;
   }
@@ -88,7 +179,6 @@ void displayTestExec(void *args) {
 }
 
 void displayTestInit() {
-  canvas = canvasGet();
   schAdd(displayTestExec, NULL, 0, 50);
 }
 

displayTest2.c

@@ -0,0 +1,75 @@
+#include <stdlib.h>
+#include <string.h>
+#include "canvas.h"
+#include "PontCoopScheduler.h"
+#include "displayTest2.h"
+
+
+
+
+typedef enum { e_idle, e_start, e_fillArea, e_placeObject, e_wipeLines_7, e_wipeLines_8, e_wipeLines_9, e_wipeLines_10 } t_state;
+
+void displayTest2Exec(void *args) {
+  static t_state state = e_start;
+
+  switch (state) {
+    case e_idle:
+      break;
+
+    case e_start:
+      state = e_fillArea;
+      break;
+
+    case e_fillArea:
+      memset((canvas.canvas)+(canvas.width*7), 0x81, canvas.width);
+      memset((canvas.canvas)+(canvas.width*8), 0x8d, canvas.width);
+      memset((canvas.canvas)+(canvas.width*9), 0x82, canvas.width);
+      memset((canvas.canvas)+(canvas.width*10), 0x88, canvas.width);
+      for (uint8_t i = 0; i < canvas.width; i++) {
+        if (i != 4 && i != 5) {
+          canvasSetPixel(i, 6, 0x05);
+        }
+      }
+      state = e_placeObject;
+      break;
+
+    case e_placeObject:
+      canvasSetPixel(4, 0, 0x04);
+      canvasSetPixel(5, 0, 0x04);
+      canvasSetPixel(6, 0, 0x04);
+      canvasSetPixel(5, 1, 0x04);
+      state = e_wipeLines_7;
+      break;
+
+    case e_wipeLines_7:
+      canvasWipeRow(7);
+      state = e_wipeLines_8;
+      break;
+
+    case e_wipeLines_8:
+      canvasWipeRow(8);
+      state = e_wipeLines_9;
+      break;
+
+    case e_wipeLines_9:
+      canvasWipeRow(9);
+      state = e_wipeLines_10;
+      break;
+
+    case e_wipeLines_10:
+      canvasWipeRow(10);
+      state = e_idle;
+      break;
+
+    default:
+      state = e_idle;
+      break;
+  }
+
+  canvasShow();
+}
+
+void displayTest2Init() {
+  schAdd(displayTest2Exec, NULL, 0, 5000);
+}
+

displayTest2.h

@@ -0,0 +1,11 @@
+#ifndef _DISPLAY_TEST_2_H_
+#define _DISPLAY_TEST_2_H_
+
+
+void displayTest2Init();
+void displayTest2Exec();
+
+
+
+
+#endif // _DISPLAY_TEST_2_H_

displayTest3.c

@@ -0,0 +1,78 @@
+#include <stdlib.h>
+#include <string.h>
+#include "canvas.h"
+#include "PontCoopScheduler.h"
+#include "displayTest3.h"
+#include "led.h"
+
+
+typedef enum { e_idle, e_delay, e_start, e_fillArea, e_placeObject, e_preWipeLines, e_wipeLines } t_state;
+
+void displayTest3Exec(void *args) {
+  static t_state state = e_start;
+  static uint8_t wipeLineHelper = 0;
+
+  ledBlueToggle();
+
+  switch (state) {
+    case e_idle:
+      state = e_delay;
+      break;
+
+    case e_delay:
+      canvasClear();
+      state = e_start;
+      break;
+
+    case e_start:
+      state = e_fillArea;
+      break;
+
+    case e_fillArea:
+      memset((canvas.canvas)+(canvas.width*7), 0x84, canvas.width);
+      memset((canvas.canvas)+(canvas.width*8), 0x8d, canvas.width);
+      memset((canvas.canvas)+(canvas.width*9), 0x82, canvas.width);
+      memset((canvas.canvas)+(canvas.width*10), 0x88, canvas.width);
+      for (uint8_t i = 0; i < canvas.width; i++) {
+        if (i != 4 && i != 5) {
+          canvasSetPixel(i, 6, 0x05);
+        }
+      }
+      state = e_placeObject;
+      break;
+
+    case e_placeObject:
+      canvasSetPixel(4, 0, 0x04);
+      canvasSetPixel(5, 0, 0x04);
+      canvasSetPixel(6, 0, 0x04);
+      canvasSetPixel(5, 1, 0x04);
+      state = e_preWipeLines;
+      break;
+
+    case e_preWipeLines:
+      wipeLineHelper = 0;
+      state = e_wipeLines;
+      // no break
+      
+    case e_wipeLines:
+      if (canvasIsRowFilled(wipeLineHelper) == 1) {
+        canvasWipeRow(wipeLineHelper);
+      }
+      wipeLineHelper++;
+      if (wipeLineHelper >= canvas.height) {
+        state = e_idle;
+      }
+      break;
+
+    default:
+      state = e_idle;
+      break;
+  }
+
+  canvasShow();
+}
+
+void displayTest3Init() {
+  schAdd(displayTest3Exec, NULL, 0, 1000);
+}
+

displayTest3.h

@@ -0,0 +1,11 @@
+#ifndef _DISPLAY_TEST_3_H_
+#define _DISPLAY_TEST_3_H_
+
+
+void displayTest3Init();
+void displayTest3Exec();
+
+
+
+
+#endif // _DISPLAY_TEST_3_H_

led.c

@@ -12,6 +12,10 @@ void ledGreenOff() {
   P1OUT &= ~BIT0;
 }
 
+void ledGreenToggle() {
+  P1OUT ^= BIT0;
+}
+
 void ledBlueOn() {
   P1OUT |= BIT1;
 }
@@ -20,6 +24,10 @@ void ledBlueOff() {
   P1OUT &= ~BIT1;
 }
 
+void ledBlueToggle() {
+  P1OUT ^= BIT1;
+}
+
 void ledExec(void *args) {
   static uint16_t i = 0;
 
@@ -41,7 +49,7 @@ void ledInit() {
     ledBlueOff();
 
 
-    schAdd(ledExec, NULL, 0, 500);
+//    schAdd(ledExec, NULL, 0, 500);
 }
 
 

led.h

@@ -4,8 +4,10 @@
 
 void ledBlueOff();
 void ledBlueOn();
+void ledBlueToggle();
 void ledGreenOff();
 void ledGreenOn();
+void ledGreenToggle();
 
 void ledInit();
 void ledExec();

main.c

@@ -9,6 +9,8 @@
 #include "displayDriver.h"
 #include "canvas.h"
 #include "displayTest.h"
+#include "displayTest2.h"
+#include "displayTest3.h"
 
 
 int main() {
@@ -29,7 +31,7 @@ int main() {
     ledInit();
     displayDriverInit();
     canvasInit();
-     displayTestInit();
+    displayTest3Init();
 
 
     __enable_interrupt();