display tests

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 displayTest4.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.c

@@ -7,6 +7,7 @@
 
 
 #include <stdlib.h>
+#include <msp430g2553.h>
 
 
 #include "PontCoopScheduler.h"
@@ -15,7 +16,7 @@ tTask tasks[MAX_NUM_OF_TASKS];
 
 
 void schInit() {
-  for (uint8_t i = 0; i < MAX_NUM_OF_TASKS; i++) {
+  for (uint16_t i = 0; i < MAX_NUM_OF_TASKS; i++) {
     tasks[i].delay = 0;
     tasks[i].period = 0;
     tasks[i].run = 0;
@@ -25,7 +26,7 @@ void schInit() {
 }
 
 void schAdd(void (*exec)(void *), void *handle, uint32_t delay, uint32_t period) {
-  for (uint8_t i = 0; i < MAX_NUM_OF_TASKS; i++) {
+  for (uint16_t i = 0; i < MAX_NUM_OF_TASKS; i++) {
     if (tasks[i].exec == NULL) {
       tasks[i].delay = delay;
       tasks[i].period = period;
@@ -41,23 +42,34 @@ void schAdd(void (*exec)(void *), void *handle, uint32_t delay, uint32_t period)
   }
 }
 
+/*
 void schDel(void (*exec)(void *), void *handle) {
-  for (uint8_t i = 0; i < MAX_NUM_OF_TASKS; i++) {
+  for (uint16_t i = 0; i < MAX_NUM_OF_TASKS; i++) {
     if ((tasks[i].exec == exec) && (tasks[i].handle == handle)) {
       tasks[i].exec = NULL;
       break;
     }
   }
 }
+*/
 
 void schExec() {
-  for (uint8_t i = 0; i < MAX_NUM_OF_TASKS; i++) {
+  for (uint16_t i = 0; i < MAX_NUM_OF_TASKS; i++) {
+    // synchronize access to tasks[].run
+    __disable_interrupt(); 
     if (tasks[i].exec != NULL && tasks[i].run > 0) {
       tasks[i].run--;
+      // synchronize access to tasks[].run
+      // reenable interrupts before actually executing task
+      __enable_interrupt();
       tasks[i].exec(tasks[i].handle);
       if (tasks[i].period == 0) {
         tasks[i].exec = NULL;
       }
+    } else {
+      // synchronize access to tasks[].run
+      // reenable interrupts in case task is not yet executable
+      __enable_interrupt();
     }
   }
 }
@@ -65,7 +77,7 @@ void schExec() {
 
 
 void schUpdate() {
-  for (uint8_t i = 0; i < MAX_NUM_OF_TASKS; i++) {
+  for (uint16_t i = 0; i < MAX_NUM_OF_TASKS; i++) {
     if (tasks[i].exec != NULL) {
       if (tasks[i].delay == 0) {
         tasks[i].delay = tasks[i].period;
@@ -76,13 +88,3 @@ void schUpdate() {
     }
   }
 }
-
-uint8_t schTaskCnt() {
-  uint8_t cnt = 0;
-  for (uint8_t i = 0; i < MAX_NUM_OF_TASKS; i++) {
-    if (tasks[i].exec != NULL){
-      cnt++;
-    } 
-  }
-  return cnt;
-}

canvas.c

@@ -28,4 +28,26 @@ void canvasShow() {
   displayDriverTransferCanvas();
 }
 
+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,7 +5,7 @@
 
 
 #define CANVAS_WIDTH 10
-#define CANVAS_HEIGHT 6
+#define CANVAS_HEIGHT 11 
 
 typedef struct {
   uint8_t width;
@@ -17,7 +17,9 @@ typedef struct {
 void canvasInit();
 canvas_t *canvasGet();
 void canvasShow();
-
+void canvasSetPixel(uint8_t column, uint8_t row, uint8_t color);
+void canvasWipeRow(uint8_t row);
+uint8_t canvasIsRowFilled(uint8_t row);
 
 
 #endif // _CANVAS_H_

displayDriver.c

@@ -34,7 +34,7 @@ void displayDriverInit() {
   UCB0CTL0 = UCMST;
   // SPI timing config
   UCB0CTL1 = UCSSEL_3;
-  UCB0BR0 = 8;
+  UCB0BR0 = 4; // 2 would be too fast and ends up with errors
   UCB0BR1 = 0;
 
   // BIT5: UCB0CLK

displayTest.c

@@ -4,19 +4,177 @@
 
 
 static canvas_t *canvas;
-static uint8_t lastPixel = 0xff;
+
-static uint8_t currentPixel = 0;
+#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) {
-  if (lastPixel != 0xff) {
+  static int16_t last = 0xff;
-    *((canvas->canvas)+lastPixel) = 0x80;
+  static int16_t current = 0;
+  static uint8_t color = 0x01;
+  static t_State state = e_PIXELS_UP;
+
+  switch (state) {
+    // 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 = e_PIXELS_UP;
+    // pixels up
+    case e_PIXELS_UP:
+      if (last != 0xff) {
+        *((canvas->canvas)+last) = 0x80;
+      }
+
+      last = current;
+      *((canvas->canvas)+current) = (color + 0x80);
+      current++;
+      if (current >= canvas->size) {
+        current = 0;
+        state = e_WIPE_LAST_PIXEL_UP;
+      }
+      break;
+    // wipe last pixel
+    case e_WIPE_LAST_PIXEL_UP:
+      *((canvas->canvas)+last) = 0x80;
+      last = 0xff;
+      current = canvas->size - 1;
+      state = e_PIXELS_DOWN;
+    // pixels down
+    case e_PIXELS_DOWN:
+      if (last != 0xff) {
+        *((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++) {
+        canvasSetPixel(i, current, color);
+      }
+      current++;
+      if (current >= canvas->height) {
+        current = 0;
+        state = e_WIPE_LAST_ROW_UP;
+      }
+      break;
+    // wipe last row
+    case e_WIPE_LAST_ROW_UP:
+      for (uint16_t i = 0; i < canvas->width; i++) {
+        canvasSetPixel(i, last, 0);
+      }
+      last = 0xff;
+      current = canvas->height - 1;
+      state = e_ROWS_DOWN;
+    // rows down
+    case e_ROWS_DOWN:
+      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++) {
+        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++) {
+        canvasSetPixel(current, i, color);
+      }
+      current++;
+      if (current >= canvas->width) {
+        current = 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;
   }
 
-  lastPixel = currentPixel;
+  color++;
-  *((canvas->canvas)+currentPixel) = 0x81;
+  if (color > MAX_COLOR) {
-  currentPixel++;
+    color = 1;
-  if (currentPixel >= canvas->size) {
-    currentPixel = 0;
   }
 
   canvasShow();

led.c

@@ -21,7 +21,7 @@ void ledBlueOff() {
 }
 
 void ledExec(void *args) {
-  static int i = 0;
+  static uint16_t i = 0;
 
   if (i == 0) {
     ledGreenOff();
@@ -41,7 +41,7 @@ void ledInit() {
     ledBlueOff();
 
 
-//    schAdd(ledExec, NULL, 0, 50);
+    schAdd(ledExec, NULL, 0, 500);
 }
 
 

main.c

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

time.c

@@ -1,30 +1,16 @@
 #include <msp430g2553.h>
-#include <stdint.h>
 
 #include "time.h"
 #include "PontCoopScheduler.h"
 
 
-volatile uint32_t timestamp;
-
 void __attribute__ ((interrupt (TIMER0_A0_VECTOR))) ta0_isr() {
-  timestamp++;
   schUpdate();
 }
 
 void timeInit() {
-  timestamp = 0;
-
   TACCR0 = 32;
   TACCTL0 = CCIE;
   TACTL = MC_1 | ID_0 | TASSEL_1 | TACLR;
 }
 
-uint32_t getMillis() {
-  return timestamp;
-}
-
-void ms_active_delay(uint16_t delay) {
-  uint32_t start = timestamp;
-  while (start + delay > timestamp);
-}

time.h

@@ -4,8 +4,6 @@
 #include <stdint.h>
 
 void timeInit();
-uint32_t getMillis();
-void ms_active_delay(uint16_t delay);