colors.h added

Makefile

@@ -4,14 +4,14 @@ OBJDUMP=$(TOOLCHAIN_PREFIX)/bin/msp430-elf-objdump
 
 ARTIFACT=firmware
 MCU=msp430g2553
-CFLAGS=-Wall -mmcu=$(MCU) -std=gnu99 -I $(TOOLCHAIN_PREFIX)/include -O3 -g0
+CFLAGS=-Wall -mmcu=$(MCU) -std=gnu99 -I $(TOOLCHAIN_PREFIX)/include -O1 -g0
 
 # for debugging
-#CFLAGS=-Wall -mmcu=$(MCU) -std=gnu99 -I $(TOOLCHAIN_PREFIX)/include -g3 -ggdb -gdwarf-2
+# CFLAGS+= -g3 -ggdb -gdwarf-2
 
 LDFLAGS=-mmcu=$(MCU) -L $(TOOLCHAIN_PREFIX)/include
 
-$(ARTIFACT).elf:	main.o led.o time.o PontCoopScheduler.o displayDriver.o canvas.o displayTest.o displayTest2.o displayTest3.o
+$(ARTIFACT).elf:	main.o led.o time.o PontCoopScheduler.o displayDriver.o canvas.o shapes.o shape_i.o shape_j.o shape_l.o shape_o.o shape_s.o shape_t.o shape_z.o game.o
 	$(CC) -o $@ $(LDFLAGS) $^
 	$(OBJDUMP) -D $(ARTIFACT).elf > $(ARTIFACT).txt
 

PontCoopScheduler.h

@@ -17,8 +17,8 @@
 
 
 typedef struct {
-  uint32_t delay;
-  uint32_t period;
+  uint16_t delay;
+  uint16_t period;
   uint8_t run;
   void (*exec)(void *handle);
   void *handle;

colors.h

@@ -0,0 +1,22 @@
+#ifndef _COLORS_H_
+#define _COLORS_H_
+
+
+#define _off 0x00
+#define _blue 0x01
+#define _green 0x02
+#define _orange 0x03
+#define _rose 0x04
+#define _magenta 0x05
+#define _violet 0x06
+#define _azure 0x07
+#define _cyan 0x08
+#define _springgreen 0x09
+#define _chartreuse 0x0a
+#define _yellow 0x0b
+#define _white 0x0c
+#define _red 0x0d
+
+
+
+#endif

displayDriver.c

@@ -7,7 +7,7 @@
 
 
 
-static void spiSendOctet(uint8_t v) {
+inline static void spiSendOctet(uint8_t v) {
   // wait for TX buffer empty
   while (!(UC0IFG & UCB0TXIFG));
   // load octet into TX buffer

displayTest3.c

@@ -20,22 +20,22 @@ void displayTest3Exec(void *args) {
       break;
 
     case e_delay:
-      canvasClear();
       state = e_start;
       break;
 
     case e_start:
+      canvasClear();
       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);
+      memset((canvas.canvas)+(canvas.width*7), 0x82, canvas.width);
+      memset((canvas.canvas)+(canvas.width*8), 0x83, canvas.width);
+      memset((canvas.canvas)+(canvas.width*9), 0x84, canvas.width);
+      memset((canvas.canvas)+(canvas.width*10), 0x85, canvas.width);
       for (uint8_t i = 0; i < canvas.width; i++) {
         if (i != 4 && i != 5) {
-          canvasSetPixel(i, 6, 0x05);
+          canvasSetPixel(i, 6, 0x01);
         }
       }
       state = e_placeObject;

game.c

@@ -0,0 +1,67 @@
+#include "stddef.h"
+#include "stdint.h"
+
+#include "game.h"
+#include "PontCoopScheduler.h"
+#include "shapes.h"
+#include "canvas.h"
+
+
+typedef enum { e_idle, e_start, e_newStone, e_down, e_gameOver, e_delay } state_t;
+
+void gameExec(void *handle) {
+  static state_t state = e_start;
+  static uint8_t delay;
+
+  switch (state) {
+    case e_idle:
+      break;
+
+    case e_start:
+      canvasClear();
+      state = e_newStone;
+      break;
+
+    case e_newStone:
+      stoneCreate();
+      if (stoneDraw()) {
+        state = e_down;
+      } else {
+        state = e_gameOver;
+      }
+      break;
+      
+    case e_down:
+      if (! stoneMoveDown()) {
+        state = e_newStone;
+      }
+      break;
+
+    case e_gameOver:
+      for (uint8_t c = 0; c < canvas.width; c++) {
+        canvasSetPixel(c, 0, 0x0d);
+        canvasSetPixel(c, canvas.height-1, 0x0d);
+      }
+      for (uint8_t r = 0; r < canvas.height; r++) {
+        canvasSetPixel(0, r, 0x0d);
+        canvasSetPixel(canvas.width-1, r, 0x0d);
+      }
+      delay = 10;
+      state = e_delay;
+      break;
+
+    case e_delay:
+      delay--;
+      if (delay == 0) {
+        state = e_start;
+      }
+      break;
+  }
+
+  canvasShow();
+}
+
+void gameInit() {
+  schAdd(gameExec, NULL, 0, 1000);
+}
+

game.h

@@ -0,0 +1,7 @@
+#ifndef _GAME_H_
+#define _GAME_H_
+
+void gameInit();
+
+
+#endif // _GAME_H_

main.c

@@ -8,9 +8,7 @@
 #include "led.h"
 #include "displayDriver.h"
 #include "canvas.h"
-#include "displayTest.h"
-#include "displayTest2.h"
-#include "displayTest3.h"
+#include "game.h"
 
 
 int main() {
@@ -24,15 +22,14 @@ int main() {
     BCSCTL2 = 0;
     BCSCTL3 = 0;
 
-
     timeInit();
     schInit();
 
     ledInit();
     displayDriverInit();
     canvasInit();
-    displayTest3Init();
 
+    gameInit();
 
     __enable_interrupt();
 

shape_i.c

@@ -0,0 +1,31 @@
+#include "shapes.h"
+#include "shape_i.h"
+#include "canvas.h"
+
+uint8_t draw_i() {
+  canvasSetPixel(stone.x, stone.y, 0x01);
+  canvasSetPixel(stone.x, stone.y+1, 0x01);
+  canvasSetPixel(stone.x, stone.y+2, 0x01);
+  canvasSetPixel(stone.x, stone.y+3, 0x01);
+  return 1;
+}
+
+uint8_t moveDown_i() {
+  return 1;
+}
+
+uint8_t moveLeft_i() {
+  return 1;
+}
+
+uint8_t moveRight_i() {
+  return 1;
+}
+
+uint8_t rotateLeft_i() {
+  return 1;
+}
+
+uint8_t rotateRight_i() {
+  return 1;
+}

shape_i.h

@@ -0,0 +1,14 @@
+#ifndef _SHAPE_I_H_
+#define _SHAPE_I_H_
+
+#include <stdint.h>
+
+uint8_t draw_i();
+uint8_t moveDown_i();
+uint8_t moveRight_i();
+uint8_t moveLeft_i();
+uint8_t rotateLeft_i();
+uint8_t rotateRight_i();
+
+
+#endif // _SHAPE_I_H_

shape_j.c

@@ -0,0 +1,26 @@
+#include "shapes.h"
+#include "shape_j.h"
+
+uint8_t draw_j() {
+  return 0;
+}
+
+uint8_t moveDown_j() {
+  return 0;
+}
+
+uint8_t moveLeft_j() {
+  return 0;
+}
+
+uint8_t moveRight_j() {
+  return 0;
+}
+
+uint8_t rotateLeft_j() {
+  return 0;
+}
+
+uint8_t rotateRight_j() {
+  return 0;
+}

shape_j.h

@@ -0,0 +1,14 @@
+#ifndef _SHAPE_J_H_
+#define _SHAPE_J_H_
+
+#include <stdint.h>
+
+uint8_t draw_j();
+uint8_t moveDown_j();
+uint8_t moveRight_j();
+uint8_t moveLeft_j();
+uint8_t rotateLeft_j();
+uint8_t rotateRight_j();
+
+
+#endif // _SHAPE_J_H_

shape_l.c

@@ -0,0 +1,26 @@
+#include "shapes.h"
+#include "shape_l.h"
+
+uint8_t draw_l() {
+  return 0;
+}
+
+uint8_t moveDown_l() {
+  return 0;
+}
+
+uint8_t moveLeft_l() {
+  return 0;
+}
+
+uint8_t moveRight_l() {
+  return 0;
+}
+
+uint8_t rotateLeft_l() {
+  return 0;
+}
+
+uint8_t rotateRight_l() {
+  return 0;
+}

shape_l.h

@@ -0,0 +1,14 @@
+#ifndef _SHAPE_L_H_
+#define _SHAPE_L_H_
+
+#include <stdint.h>
+
+uint8_t draw_l();
+uint8_t moveDown_l();
+uint8_t moveRight_l();
+uint8_t moveLeft_l();
+uint8_t rotateLeft_l();
+uint8_t rotateRight_l();
+
+
+#endif // _SHAPE_L_H_

shape_o.c

@@ -0,0 +1,26 @@
+#include "shapes.h"
+#include "shape_o.h"
+
+uint8_t draw_o() {
+  return 0;
+}
+
+uint8_t moveDown_o() {
+  return 0;
+}
+
+uint8_t moveLeft_o() {
+  return 0;
+}
+
+uint8_t moveRight_o() {
+  return 0;
+}
+
+uint8_t rotateLeft_o() {
+  return 0;
+}
+
+uint8_t rotateRight_o() {
+  return 0;
+}

shape_o.h

@@ -0,0 +1,14 @@
+#ifndef _SHAPE_O_H_
+#define _SHAPE_O_H_
+
+#include <stdint.h>
+
+uint8_t draw_o();
+uint8_t moveDown_o();
+uint8_t moveRight_o();
+uint8_t moveLeft_o();
+uint8_t rotateLeft_o();
+uint8_t rotateRight_o();
+
+
+#endif // _SHAPE_O_H_

shape_s.c

@@ -0,0 +1,26 @@
+#include "shapes.h"
+#include "shape_s.h"
+
+uint8_t draw_s() {
+  return 0;
+}
+
+uint8_t moveDown_s() {
+  return 0;
+}
+
+uint8_t moveLeft_s() {
+  return 0;
+}
+
+uint8_t moveRight_s() {
+  return 0;
+}
+
+uint8_t rotateLeft_s() {
+  return 0;
+}
+
+uint8_t rotateRight_s() {
+  return 0;
+}

shape_s.h

@@ -0,0 +1,14 @@
+#ifndef _SHAPE_S_H_
+#define _SHAPE_S_H_
+
+#include <stdint.h>
+
+uint8_t draw_s();
+uint8_t moveDown_s();
+uint8_t moveRight_s();
+uint8_t moveLeft_s();
+uint8_t rotateLeft_s();
+uint8_t rotateRight_s();
+
+
+#endif // _SHAPE_S_H_

shape_t.c

@@ -0,0 +1,26 @@
+#include "shapes.h"
+#include "shape_t.h"
+
+uint8_t draw_t() {
+  return 0;
+}
+
+uint8_t moveDown_t() {
+  return 0;
+}
+
+uint8_t moveLeft_t() {
+  return 0;
+}
+
+uint8_t moveRight_t() {
+  return 0;
+}
+
+uint8_t rotateLeft_t() {
+  return 0;
+}
+
+uint8_t rotateRight_t() {
+  return 0;
+}

shape_t.h

@@ -0,0 +1,14 @@
+#ifndef _SHAPE_T_H_
+#define _SHAPE_T_H_
+
+#include <stdint.h>
+
+uint8_t draw_t();
+uint8_t moveDown_t();
+uint8_t moveRight_t();
+uint8_t moveLeft_t();
+uint8_t rotateLeft_t();
+uint8_t rotateRight_t();
+
+
+#endif // _SHAPE_T_H_

shape_z.c

@@ -0,0 +1,26 @@
+#include "shapes.h"
+#include "shape_z.h"
+
+uint8_t draw_z() {
+  return 0;
+}
+
+uint8_t moveDown_z() {
+  return 0;
+}
+
+uint8_t moveLeft_z() {
+  return 0;
+}
+
+uint8_t moveRight_z() {
+  return 0;
+}
+
+uint8_t rotateLeft_z() {
+  return 0;
+}
+
+uint8_t rotateRight_z() {
+  return 0;
+}

shape_z.h

@@ -0,0 +1,14 @@
+#ifndef _SHAPE_Z_H_
+#define _SHAPE_Z_H_
+
+#include <stdint.h>
+
+uint8_t draw_z();
+uint8_t moveDown_z();
+uint8_t moveRight_z();
+uint8_t moveLeft_z();
+uint8_t rotateLeft_z();
+uint8_t rotateRight_z();
+
+
+#endif // _SHAPE_Z_H_

shapes.c

@@ -0,0 +1,73 @@
+#include <stdint.h>
+#include <stddef.h>
+
+#include "shapes.h"
+#include "shape_i.h"
+#include "shape_o.h"
+#include "shape_t.h"
+#include "shape_z.h"
+#include "shape_s.h"
+#include "shape_l.h"
+#include "shape_j.h"
+
+
+
+typedef struct {
+  uint8_t (* draw)();
+  uint8_t (*moveDown)();
+  uint8_t (*moveLeft)();
+  uint8_t (*moveRight)();
+  uint8_t (*rotateLeft)();
+  uint8_t (*rotateRight)();
+} stoneOperations_t;
+
+const stoneOperations_t stoneOperations[] = {
+  { .draw = draw_i, .moveDown = moveDown_i, .moveLeft = moveLeft_i, .moveRight = moveRight_i, .rotateLeft = rotateLeft_i, .rotateRight = rotateRight_i },
+  { .draw = draw_o, .moveDown = moveDown_o, .moveLeft = moveLeft_o, .moveRight = moveRight_o, .rotateLeft = rotateLeft_o, .rotateRight = rotateRight_o },
+  { .draw = draw_t, .moveDown = moveDown_t, .moveLeft = moveLeft_t, .moveRight = moveRight_t, .rotateLeft = rotateLeft_t, .rotateRight = rotateRight_t },
+  { .draw = draw_z, .moveDown = moveDown_z, .moveLeft = moveLeft_z, .moveRight = moveRight_z, .rotateLeft = rotateLeft_z, .rotateRight = rotateRight_z },
+  { .draw = draw_s, .moveDown = moveDown_s, .moveLeft = moveLeft_s, .moveRight = moveRight_s, .rotateLeft = rotateLeft_s, .rotateRight = rotateRight_s },
+  { .draw = draw_l, .moveDown = moveDown_l, .moveLeft = moveLeft_l, .moveRight = moveRight_l, .rotateLeft = rotateLeft_l, .rotateRight = rotateRight_l },
+  { .draw = draw_j, .moveDown = moveDown_j, .moveLeft = moveLeft_j, .moveRight = moveRight_j, .rotateLeft = rotateLeft_j, .rotateRight = rotateRight_j }
+};
+
+stone_t stone;
+
+void stoneCreate() {
+  stone.shape = e_I;
+  stone.orientation = e_0;
+  stone.x = 5;
+  stone.y = 0;
+}
+
+// all of them return 1 in case of success and 0 in case of error
+uint8_t stoneDraw() {
+  return stoneOperations[stone.shape].draw();
+}
+
+uint8_t stoneMoveDown() {
+  return stoneOperations[stone.shape].moveDown();
+}
+
+uint8_t stoneMoveLeft() {
+  return stoneOperations[stone.shape].moveLeft();
+}
+
+uint8_t stoneMoveRight() {
+  return stoneOperations[stone.shape].moveRight();
+}
+
+uint8_t stoneRotateLeft() {
+  return stoneOperations[stone.shape].rotateLeft();
+}
+
+uint8_t stoneRotateRight() {
+  return stoneOperations[stone.shape].rotateRight();
+}
+
+
+
+
+
+
+

shapes.h

@@ -0,0 +1,28 @@
+#ifndef _SHAPES_H_
+#define _SHAPES_H_
+
+#include <stdint.h>
+
+void stoneCreate();
+uint8_t stoneDraw();
+uint8_t stoneMoveDown();
+uint8_t stoneMoveLeft();
+uint8_t stoneMoveRight();
+uint8_t stoneRotateLeft();
+uint8_t stoneRotateRight();
+
+
+typedef enum { e_I=0, e_O, e_T, e_Z, e_S, e_L, e_J, e_ShapeEnd } shape_t;
+typedef enum { e_0, e_90, e_180, e_270 } orientation_t;
+
+typedef struct {
+  shape_t shape;
+  orientation_t orientation;
+  uint8_t x; // column
+  uint8_t y; // row
+} stone_t;
+
+
+extern stone_t stone;
+
+#endif // _SHAPES_H_