other button to start config mode

display-driver/main.c

@@ -76,7 +76,7 @@ int main() {
   P1SEL |= BIT4 | BIT5 | BIT6 | BIT7;
   P1SEL2 |= BIT4 | BIT5 | BIT6 | BIT7;
   // most significant bit first, enable STE
-  UCB0CTL0 = UCSYNC | UCMSB | UCMODE_2;
+  UCB0CTL0 = UCCKPH | UCSYNC | UCMSB | UCMODE_2;
   UCB0CTL1 = 0x00;
   // enable RX interrupt
   UC0IE |= UCB0RXIE;

game-ctrl/Makefile

@@ -11,7 +11,7 @@ CFLAGS=-Wall -mmcu=$(MCU) -std=gnu99 -I $(TOOLCHAIN_PREFIX)/include -O1 -g0
 
 LDFLAGS=-mmcu=$(MCU) -L $(TOOLCHAIN_PREFIX)/include
 
-$(ARTIFACT).elf:	main.o spi.o scheduler.o canvas.o shapes.o game.o buttons.o myrand.o display.o sound.o
+$(ARTIFACT).elf:	main.o spi.o scheduler.o canvas.o shapes.o game.o buttons.o myrand.o display.o sound.o eeprom.o config.o
 	$(CC) -o $@ $(LDFLAGS) $^
 	$(OBJDUMP) -D $(ARTIFACT).elf > $(ARTIFACT).txt
 

game-ctrl/buttons.c

@@ -10,6 +10,8 @@
 #include "sound.h"
 
 
+bool mutedFlag = true;
+
 static uint8_t buttonsMoveLeftPressed() {
   static uint8_t last = 0;
   uint8_t current = (P2IN & BIT4);
@@ -18,6 +20,10 @@ static uint8_t buttonsMoveLeftPressed() {
   return res;
 }
 
+bool buttonsConfig1Pressed() {
+  return buttonsMoveLeftPressed();
+}
+
 static uint8_t buttonsMoveRightPressed() {
   static uint8_t last = 0;
   uint8_t current = (P2IN & BIT0);
@@ -26,6 +32,10 @@ static uint8_t buttonsMoveRightPressed() {
   return res;
 }
 
+bool buttonsConfig4Pressed() {
+  return buttonsMoveRightPressed();
+}
+
 static uint8_t buttonsRotateLeftPressed() {
   static uint8_t last = 0;
   uint8_t current = (P2IN & BIT3);
@@ -34,6 +44,10 @@ static uint8_t buttonsRotateLeftPressed() {
   return res;
 }
 
+bool buttonsConfig2Pressed() {
+  return buttonsRotateLeftPressed();
+}
+
 static uint8_t buttonsRotateRightPressed() {
   static uint8_t last = 0;
   uint8_t current = (P2IN & BIT1);
@@ -42,14 +56,23 @@ static uint8_t buttonsRotateRightPressed() {
   return res;
 }
 
+bool buttonsConfig3Pressed() {
+  return buttonsRotateRightPressed();
+}
+
+
 static uint8_t buttonsMoveDownPressed() {
   return P2IN & BIT2;
 }
 
+bool isConfigMode() {
+  return (P2IN & BIT2);
+}
+
+
 void buttonsExec(void *handle) {
   static uint32_t unmuteTimestamp;
   uint32_t currentTimestamp = getSeconds();
-  static bool unmuteFlag = true;
 
 
   if (! stoneIsValid()) {
@@ -88,22 +111,28 @@ void buttonsExec(void *handle) {
   if (buttonPressed == 1) {
     canvasShow();
 
-    if (! unmuteFlag) {
+    if (mutedFlag) {
       soundCtrl(SOUND_UNMUTE);
-      unmuteFlag = true;
+      mutedFlag = false;
     }
     unmuteTimestamp = currentTimestamp;
   }
 
-  if (unmuteFlag && (unmuteTimestamp + MUTE_DELAY < currentTimestamp)) {
+  if ((! mutedFlag) && (unmuteTimestamp + MUTE_DELAY < currentTimestamp)) {
     soundCtrl(SOUND_MUTE);
-    unmuteFlag = false;
+    mutedFlag = true;
   }
 }
 
 void buttonsInit() {
   P2DIR &= ~(BIT0|BIT1|BIT2|BIT3|BIT4);
+}
 
+void buttonsStart() {
   schAdd(buttonsExec, NULL, 0, 25);
 }
 
+bool isGameActive() {
+  return ! mutedFlag;
+}
+

game-ctrl/buttons.h

@@ -1,7 +1,16 @@
 #ifndef _BUTTONS_H_
 #define _BUTTONS_H_
 
+#include <stdbool.h>
+
 void buttonsInit();
+void buttonsStart();
+bool isGameActive();
+bool isConfigMode();
+bool buttonsConfig1Pressed();
+bool buttonsConfig2Pressed();
+bool buttonsConfig3Pressed();
+bool buttonsConfig4Pressed();
 
 
 #endif // _BUTTONS_H_

game-ctrl/canvas.c

@@ -5,6 +5,8 @@
 
 #include "canvas.h"
 #include "spi.h"
+#include "eeprom.h"
+#include "../rgb-driver/colors.h"
 
 
 static uint8_t canvasStorage[CANVAS_WIDTH * CANVAS_HEIGHT];
@@ -22,6 +24,8 @@ const canvas_t miniCanvas = {
 };
 
 void canvasShow() {
+  uint8_t brightness_offset = _brightness_offset * eepromReadBrightness();
+
   // wait for signal waiting for data
   while (!(P1IN & BIT3));
 
@@ -31,14 +35,14 @@ void canvasShow() {
     if ((*((canvas.canvas)+i) & 0x80) != 0) {
       *((canvas.canvas)+i) &= ~0x80;
       spiSendOctet(i);
-      spiSendOctet(*((canvas.canvas)+i));
+      spiSendOctet((*((canvas.canvas)+i) == 0) ? 0 : (*((canvas.canvas)+i) + brightness_offset));
     }
   }
   for (uint8_t i = 0; i < (MINI_CANVAS_WIDTH*MINI_CANVAS_HEIGHT); i++) {
     if ((*((miniCanvas.canvas)+i) & 0x80) != 0) {
       *((miniCanvas.canvas)+i) &= ~0x80;
       spiSendOctet(i + (CANVAS_HEIGHT*CANVAS_WIDTH));
-      spiSendOctet(*((miniCanvas.canvas)+i));
+      spiSendOctet((*((miniCanvas.canvas)+i) == 0) ? 0 : (*((miniCanvas.canvas)+i) + brightness_offset));
     }
   }
   spiSendOctet(0xfe);

game-ctrl/config.c

@@ -0,0 +1,91 @@
+#include <stddef.h>
+#include "config.h"
+#include "canvas.h"
+#include "../rgb-driver/colors.h"
+#include "scheduler.h"
+#include "buttons.h"
+#include "eeprom.h"
+#include "display.h"
+#include "shapes.h"
+
+
+static bool configChanged = false;
+
+static void configHandleFlash() {
+  if (buttonsConfig2Pressed()) {
+    configChanged = true;
+    uint8_t color = eepromReadFlashColor() + 1;
+    if (color > _color_end) {
+      color = 0;
+    }
+    canvasFillRow(CANVAS_HEIGHT-1, color);
+    displaySetValue(color);
+    eepromSetFlashColor(color);
+  }
+}
+
+static void configHandleResetHighScore() {
+  displaySetValue(eepromReadHighScore());
+
+  if (buttonsConfig2Pressed()) {
+    configChanged = true;
+    eepromSetHighScore(0);
+  }
+}
+
+static void configHandleBrightness() {
+  displaySetValue(eepromReadBrightness());
+
+  if (buttonsConfig2Pressed()) {
+    configChanged = true;
+    uint8_t brightness = eepromReadBrightness() + 1;
+    if (brightness > _brightness_shifts) {
+      brightness = 0;
+    }
+    eepromSetBrightness(brightness);
+
+    stoneDrawConfigPattern();
+  }
+}
+
+void (*configHandler[])(void) = { configHandleFlash, configHandleResetHighScore, configHandleBrightness };
+
+
+void configExec(void *handle) {
+  static uint8_t configState = 0;
+  static uint8_t lastConfigState = 255;
+
+  if (configState != lastConfigState) {
+    lastConfigState = configState;
+
+    miniCanvasClear();
+    canvasClear();
+    miniCanvasSetPixel(configState, 0, _red);
+  }
+
+  if (buttonsConfig1Pressed()) {
+    configState += 1;
+    if (configState >= sizeof(configHandler) / sizeof(configHandler[0])) {
+      configState = 0;
+    }
+  }
+
+  configHandler[configState]();
+
+  if (configChanged) {
+    miniCanvasSetPixel(0, 2, _red);
+    if (buttonsConfig4Pressed()) {
+      eepromCommit();
+      configChanged = false;
+    }
+  } else {
+    miniCanvasSetPixel(0, 2, _green);
+  }
+
+  canvasShow();
+}
+
+
+void configInit() {
+  schAdd(configExec, NULL, 0, 25);
+}

game-ctrl/config.h

@@ -0,0 +1,8 @@
+#ifndef _CONFIG_H_
+#define _CONFIG_H_
+
+
+void configInit();
+
+
+#endif // _CONFIG_H_

game-ctrl/eeprom.c

@@ -0,0 +1,96 @@
+#include <stdint.h>
+#include "eeprom.h"
+#include "spi.h"
+
+
+#define MAGIC 0xb000
+#define HIGHSCORE_ADDR 0x00
+#define DUMMY 0x00
+#define CMD_READ  0b00000011
+#define CMD_WRITE 0b00000010
+#define CMD_WRDI  0b00000100
+#define CMD_WREN  0b00000110
+
+
+typedef struct {
+  uint16_t magic;
+  uint16_t highScore;
+  uint8_t flashColor;
+  uint8_t brightness;
+} t_configBlock;
+
+typedef union {
+  t_configBlock v;
+  uint8_t buffer[sizeof(t_configBlock)];
+} eepromBuf_t;
+
+eepromBuf_t buf;
+
+static void writeBuf() {
+  spiSendBegin(e_SPI_EEPROM);
+  spiSendOctet(CMD_WREN);
+  spiSendEnd(e_SPI_EEPROM);
+
+  spiSendBegin(e_SPI_EEPROM);
+  spiSendOctet(CMD_WRITE);
+  spiSendOctet(HIGHSCORE_ADDR);
+  for (uint8_t i = 0; i < sizeof(t_configBlock); i++) {
+    spiSendOctet(buf.buffer[i]);
+  }
+  spiSendEnd(e_SPI_EEPROM);
+}
+
+static void readBuf() {
+  spiSendBegin(e_SPI_EEPROM);
+  spiSendOctet(CMD_READ);
+  spiReceiveOctet();
+  spiSendOctet(HIGHSCORE_ADDR);
+  spiReceiveOctet();
+  for (uint8_t i = 0; i < sizeof(t_configBlock); i++) {
+    spiSendOctet(DUMMY);
+    buf.buffer[i] = spiReceiveOctet();
+  }
+  spiSendEnd(e_SPI_EEPROM);
+}
+
+void eepromInit() {
+  readBuf();
+
+  if (buf.v.magic != MAGIC) {
+    buf.v.magic = MAGIC;
+    buf.v.highScore = 0;
+    buf.v.flashColor = 0;
+    buf.v.brightness = 0;
+    writeBuf();
+  }
+}
+
+void eepromCommit() {
+  writeBuf();
+}
+
+uint16_t eepromReadHighScore() {
+  return buf.v.highScore;
+}
+
+void eepromSetHighScore(uint16_t v) {
+  buf.v.highScore = v;
+  writeBuf();
+}
+
+uint8_t eepromReadFlashColor() {
+  return buf.v.flashColor;
+}
+
+void eepromSetFlashColor(uint8_t v) {
+  buf.v.flashColor = v;
+}
+
+uint8_t eepromReadBrightness() {
+  return buf.v.brightness;
+}
+
+void eepromSetBrightness(uint8_t v) {
+  buf.v.brightness = v;
+}
+

game-ctrl/eeprom.h

@@ -0,0 +1,18 @@
+#ifndef _EEPROM_H_
+#define _EEPROM_H_
+
+#include <stdint.h>
+
+
+void eepromInit();
+uint16_t eepromReadHighScore();
+void eepromSetHighScore(uint16_t v);
+uint8_t eepromReadFlashColor();
+void eepromSetFlashColor(uint8_t v);
+uint8_t eepromReadBrightness();
+void eepromSetBrightness(uint8_t v);
+void eepromCommit();
+
+
+
+#endif // _EEPROM_H_

game-ctrl/game.c

@@ -1,3 +1,5 @@
+// #define STATE_DEBUGGING
+
 #include "stddef.h"
 #include "stdint.h"
 
@@ -8,34 +10,40 @@
 #include "../rgb-driver/colors.h"
 #include "display.h"
 #include "sound.h"
+#include "eeprom.h"
+#include "buttons.h"
 
 
-#define GAME_CYCLE_TIME 100
+#define GAME_CYCLE_TIME 10
 #define GAMEOVER_DELAY 10
+#define MAX_LEVEL 100
 
 
-static uint8_t delayFactor(uint8_t level) {
+static uint16_t delayFactor(uint16_t level) {
-  return 11 - level;
+  return MAX_LEVEL + 1 - level;
 }
 
 typedef enum { 
-  e_Phase_Game, e_Phase_GameOver 
+  e_Start, e_NewStone, e_Down, e_DownDelay, 
-} phase_t;
+  e_ClearRowInit, e_ClearRowNext, e_ClearRowCheck, e_ClearRowFlash, e_ClearRowFlashDelay, e_ClearRowWipe,
-
-typedef enum { 
-  e_Start, e_NewStone, e_Down, e_DownDelay, e_ClearRows,
   e_GameOver, e_GameOverFill, e_GameOverWipe, e_GameOverDelay 
 } state_t;
 
 void gameExec(void *handle) {
-  static phase_t phase;
   static state_t state = e_Start;
   static uint8_t gameOverDelay;
   static uint8_t rowIndex;
-  static uint8_t proceedDelay;
+  static uint16_t proceedDelay;
-  static uint8_t level;
+  static uint16_t level;
+  static uint16_t filledLines;
   static uint16_t score;
+  static bool newHighScoreAchieved;
 
+  static uint8_t clearCheckCnt;
+
+#ifdef STATE_DEBUGGING
+  displaySetValue(state);
+#endif
 // --- engine begin -------------------------------------------------------
   switch (state) {
 // --- phase: game --------------------------------------------------------
@@ -43,9 +51,9 @@ void gameExec(void *handle) {
       canvasClear();
       soundCtrl(SOUND_START);
       level = 1;
+      filledLines = 0;
       score = 0;
-      displaySetValue(score);
+      newHighScoreAchieved = false;
-      phase = e_Phase_Game;
       state = e_NewStone;
       break;
 
@@ -62,36 +70,84 @@ void gameExec(void *handle) {
     case e_DownDelay:
       proceedDelay--;
       if (proceedDelay == 0) {
-        rowIndex = 0;
-        state = e_ClearRows;
-      }
-      break;
-
-    case e_ClearRows:
         state = e_Down;
+      }
       break;
 
     case e_Down:
       if (! stoneMoveDown()) {
         soundCtrl(SOUND_LOCK);
-        state = e_NewStone;
+        stoneLock();
+        state = e_ClearRowInit;
       } else {
         proceedDelay = delayFactor(level);
         state = e_DownDelay;
       }
       break;
 
+// --- phase: clear rows --------------------------------------------------
+    case e_ClearRowInit:
+      clearCheckCnt = 0;
+      state = e_ClearRowCheck;
+      break;
+
+    case e_ClearRowNext:
+      if (clearCheckCnt >= CANVAS_HEIGHT) {
+        state = e_NewStone;
+      } else {
+        clearCheckCnt += 1;
+        state = e_ClearRowCheck;
+      }
+      break;
+
+    case e_ClearRowCheck:
+      if (canvasIsRowFilled(clearCheckCnt)) {
+        score += level;
+        if (score > eepromReadHighScore()) {
+          newHighScoreAchieved = true;
+          eepromSetHighScore(score);
+          eepromCommit();
+        }
+        state = e_ClearRowFlash;
+      } else {
+        state = e_ClearRowNext;
+      }
+      break;
+
+    case e_ClearRowFlash:
+      canvasFillRow(clearCheckCnt, eepromReadFlashColor());
+      state = e_ClearRowFlashDelay;
+      break;
+
+    case e_ClearRowFlashDelay:
+      state = e_ClearRowWipe;
+      break;
+
+    case e_ClearRowWipe:
+      canvasWipeRow(clearCheckCnt);
+      filledLines += 1;
+
+      if ((filledLines > 0) && ((filledLines % 10) == 0)) {
+        if (level < MAX_LEVEL) {
+          level += 1;
+        }
+        soundCtrl(SOUND_FANFARE); 
+      } else {
+        soundCtrl(SOUND_PLING);
+      }
+      state = e_ClearRowNext;
+      break;
+
 // --- phase: game over ---------------------------------------------------
     case e_GameOver:
       soundCtrl(SOUND_GAMEOVER);
       rowIndex = CANVAS_HEIGHT;
-      phase = e_Phase_GameOver;
       state = e_GameOverFill;
       break;
 
     case e_GameOverFill:
       rowIndex--;
-      canvasFillRow(rowIndex, _red);
+      canvasFillRow(rowIndex, newHighScoreAchieved ? _green : _red);
       if (rowIndex == 0) {
         state = e_GameOverWipe;
       }
@@ -116,21 +172,14 @@ void gameExec(void *handle) {
 // --- engine end ---------------------------------------------------------
 
   canvasShow();
-  if (phase == e_Phase_Game) {
+
-    uint8_t wipeCnt = 0;
+#ifndef STATE_DEBUGGING  
-    for (uint8_t r = 0; r < CANVAS_HEIGHT; r++) {
+  if (isGameActive()) {
-      if (canvasIsRowFilled(r)) {
-        score += level;
     displaySetValue(score);
-        canvasWipeRow(r);
+  } else {
-        canvasShow();
+    displaySetValue(eepromReadHighScore());
-        wipeCnt += 1;
-      }
-    }
-    if (wipeCnt != 0) {
-      soundCtrl(SOUND_FANFARE); 
-    }
   }
+#endif 
 }
 
 void gameInit() {

game-ctrl/main.c

@@ -12,6 +12,8 @@
 #include "myrand.h"
 #include "spi.h"
 #include "display.h"
+#include "eeprom.h"
+#include "config.h"
 
 
 int main() {
@@ -28,13 +30,19 @@ int main() {
     schInit();
 
     spiInit();
+    eepromInit();
     displayInit();
     myRandInit();
     canvasInit();
+    buttonsInit();
 
+    if (isConfigMode()) {
+      configInit();
+    } else {
       shapesInit();
       gameInit();
-    buttonsInit();
+      buttonsStart();
+    }
 
     __enable_interrupt();
 

game-ctrl/shapes.c

@@ -1,6 +1,7 @@
 #include <stdint.h>
 #include <stddef.h>
 #include <stdlib.h>
+#include <stdbool.h>
 
 #include "shapes.h"
 #include "myrand.h"
@@ -19,6 +20,7 @@ typedef struct {
   orientation_t orientation;
   uint8_t x; // column
   uint8_t y; // row
+  bool locked;
 } stone_t;
 
 typedef struct {
@@ -363,6 +365,11 @@ void stoneCreate() {
   stone.orientation = e_0;
   stone.x = 4;
   stone.y = 0;
+  stone.locked = false;
+}
+
+void stoneLock() {
+  stone.locked = true;
 }
 
 uint8_t stoneIsValid() {
@@ -376,6 +383,12 @@ static uint8_t move(direction_t direction) {
   if (motions[stone.shape].nullRotation && (direction == e_RotateLeft || direction == e_RotateRight)) {
     return 1;
   }
+
+  // if the stone is already locked, do nothing
+  if (stone.locked) {
+    return 0;
+  }
+
   // check whether the pixels to move to are free
   if (canvasIsPixelFree(stone.x + motions[stone.shape].motion[direction][stone.orientation].set[0].x, 
                         stone.y + motions[stone.shape].motion[direction][stone.orientation].set[0].y) &&
@@ -470,6 +483,31 @@ uint8_t stoneDraw() {
   return res;
 }
 
+static void stoneJustDraw(uint8_t x, uint8_t y, shape_t shape) {
+  canvasSetPixel(x + motions[shape].draw[0].x, 
+                 y + motions[shape].draw[0].y, 
+                 motions[shape].color);
+  canvasSetPixel(x + motions[shape].draw[1].x, 
+                 y + motions[shape].draw[1].y, 
+                 motions[shape].color);
+  canvasSetPixel(x + motions[shape].draw[2].x, 
+                 y + motions[shape].draw[2].y, 
+                 motions[shape].color);
+  canvasSetPixel(x + motions[shape].draw[3].x, 
+                 y + motions[shape].draw[3].y, 
+                 motions[shape].color);
+}
+
+void stoneDrawConfigPattern() {
+  stoneJustDraw(1, 0, e_I);
+  stoneJustDraw(3, 4, e_O);
+  stoneJustDraw(4, 7, e_T);
+  stoneJustDraw(5, 10, e_Z);
+  stoneJustDraw(1, 12, e_S);
+  stoneJustDraw(5, 15, e_L);
+  stoneJustDraw(1, 17, e_J);
+}
+
 uint8_t stoneMoveDown() {
   return move(e_MoveDown);
 }

game-ctrl/shapes.h

@@ -5,6 +5,7 @@
 
 void shapesInit();
 void stoneCreate();
+void stoneLock();
 uint8_t stoneIsValid();
 uint8_t stoneDraw();
 uint8_t stoneMoveDown();
@@ -13,5 +14,6 @@ uint8_t stoneMoveRight();
 uint8_t stoneRotateLeft();
 uint8_t stoneRotateRight();
 
+void stoneDrawConfigPattern();
 
 #endif // _SHAPES_H_

game-ctrl/spi.c

@@ -3,7 +3,7 @@
 
 void spiInit() {
   // SPI in master mode, most significant bit first
-  UCB0CTL0 = UCMST | UCMSB;
+  UCB0CTL0 = UCCKPH | UCMST | UCMSB;
   // SPI timing config
   UCB0CTL1 = UCSSEL_3;
   // Faster than 8 ends up in strange communication errors
@@ -19,25 +19,25 @@ void spiInit() {
   // BIT7: UCB0SIMO
   P1SEL |= BIT5 | BIT6 | BIT7;
   P1SEL2 |= BIT5 | BIT6 | BIT7;
-  P1DIR |= BIT5 | BIT7;
+  // P1DIR |= BIT5 | BIT7;
 
-  // Device Select Lines: 0: Canvas, 1: Display, 2: Sound
+  // Device Select Lines: 0: Canvas, 1: Display, 2: Sound, 4: EEPROM
-  P1DIR |= BIT0 | BIT1 | BIT2;
+  P1DIR |= BIT0 | BIT1 | BIT2 | BIT4;
   // Disable all of them
-  P1OUT |= BIT0 | BIT1 | BIT2;
+  P1OUT |= BIT0 | BIT1 | BIT2 | BIT4;
 
   // enable SPI module
   UCB0CTL1 &= ~UCSWRST;
 }
 
 void spiSendBegin(t_SpiDeviceSelector d) {
-  uint16_t bit = ((uint16_t[]){ BIT0, BIT1, BIT2 })[d];
+  uint16_t bit = ((uint16_t[]){ BIT0, BIT1, BIT2, BIT4 })[d];
   P1OUT &= ~bit;
 }
 
 void spiSendEnd(t_SpiDeviceSelector d) {
   while (UCB0STAT & UCBUSY);
-  uint16_t bit = ((uint16_t[]){ BIT0, BIT1, BIT2 })[d];
+  uint16_t bit = ((uint16_t[]){ BIT0, BIT1, BIT2, BIT4 })[d];
   P1OUT |= bit;
 }
 
@@ -48,3 +48,9 @@ void spiSendOctet(uint8_t v) {
   UCB0TXBUF = v;
 }
 
+uint8_t spiReceiveOctet() {
+  while (!(UC0IFG & UCB0RXIFG));
+  uint8_t v = UCB0RXBUF;
+  return v;
+}
+

game-ctrl/spi.h

@@ -4,12 +4,13 @@
 #include <stdint.h>
 
 
-typedef enum { e_SPI_CANVAS, e_SPI_DISPLAY, e_SPI_SOUND } t_SpiDeviceSelector;
+typedef enum { e_SPI_CANVAS, e_SPI_DISPLAY, e_SPI_SOUND, e_SPI_EEPROM } t_SpiDeviceSelector;
 
 void spiInit();
 void spiSendBegin(t_SpiDeviceSelector d);
 void spiSendEnd(t_SpiDeviceSelector d);
 void spiSendOctet(uint8_t v); 
+uint8_t spiReceiveOctet();
 
 
 

readme.md

@@ -0,0 +1,68 @@
+# Tetris - Hardware and Software
+
+![](./docs/IMG_4936.jpg)
+
+Update Amplifier (separate input circuitry per PSG, it appears, that a silent PSG has a DC level on its output which is summarized to the AC output of the working PSG, so two input circuits with individual couping capacitor):
+
+![](./docs/IMG_4941.jpg)
+
+Update of the power switch of the amplifier (at appears, that the small transistor couldn't deliver enough current):
+
+![](./docs/IMG_4958.jpeg)
+
+This Tetris implementation consists of a hardware and a software (running on that hardware).
+
+The hardware utilizes four MSP430 microcontrollers for 1.) the game play, 2.) the play ground canvas, 3.) the score display and 4.) the sound effects.
+
+Further documentation including calculations and drawing can be found in the `docs` subdirs of the four main subdirs.
+
+## Game Play
+
+Code is in subdir `game-ctrl` (https://gitea.hottis.de/wn/tetris/src/branch/main/game-ctrl).
+
+In the firmware for this MSP430 microcontroller the whole game mechanics, reading the buttons, reading and writing the highscore EEPROM  and the control of the peripherial microcontrollers are implemented.
+
+The buttons are debounced using RC circuitry and Schmitt triggers and connected to GPIOs of the microcontroller.
+
+The peripherial microcontrollers and the EEPROM are connected via SPI including individual chip select lines.
+
+![](./docs/game-ctrl.jpg)
+
+
+## Play Ground Canvas
+
+Code is in subdir `rgb-driver` (https://gitea.hottis.de/wn/tetris/src/branch/main/rgb-driver).
+
+The play ground is implemented using a 10 * 20 matrix of PL9823 RGB LEDs which are controlled by another MSP430 microcontroller. The firmware for this microcontroller is implemented for performance and real time requirements in assembly code. Through some discret logic the signals for PL9823 LEDs are generated. Major challenge was to generated the signals according the datasheet of all 200 (including a mini canvas for the stone preview: 212) LEDs in real time without interrupts.
+
+The communcation with the game play controller is implemented as a sequences of tuples of LED address (0 to 211) and color code. A single octet of 253 where the LED address is expected is taken as the end-of-telegram mark. Readiness to receive a telegram is signaled to the game play controller via a single line connected to a GPIO of the game play controller.
+
+![](./docs/rgb-driver.jpg)
+
+
+## Score Display
+
+Code is in subdir `display-driver` (https://gitea.hottis.de/wn/tetris/src/branch/main/display-driver).
+
+In the first place, a MAX7221 was meant to be used for connecting a multiple digit seven-segment display. However, it appears, that the MAX7221 requires 3.5V as minimum voltage for the high-level, which caan't be provided by the MSP430 (which runs on 3.3V) and level-shifters haven't been around. Thus, the minimal required amount of functionality of the MAX7221 has been implemented in C on an MSP430. Just four digits are supported. 
+
+Communication with the game play controller is just a 16 bit number to be displayed.
+
+![](./docs/display-driver.jpg)
+
+
+## Sound Effects
+
+Code is in subdir `sound-driver` (https://gitea.hottis.de/wn/tetris/src/branch/main/sound-driver).
+
+An MSP430 microcontroller and two mediaeval AY-3-8913 sound chips are deployed. The sound chips themselve run on 5V, their 8-bit-address/data bus is connected to the port 2 (bit 0 to 7) of the microcontroller. The bus control signal `_CS`, `BC1` and `BDIR` are generated in software and provided via GPIOs.
+
+An amplifier following the proposal of the AY-3-8913 datasheet is implemented using a LM386 chip. A MOSFET BS108 controlled via a GPIO is use the shortcut the input of the amplifier to ground to mute sound effects.
+
+The clock generator proposed by the AY-3-8913 does not work reliably, so an alternative design from "The Art of Electronics" has been used.
+
+![](./docs/sound-driver-1.jpg) 
+![](./docs/sound-driver-2.png) 
+![](./docs/sound-driver-3.jpg) 
+![](./docs/sound-driver-4.jpg) 
+

rgb-driver/colors.S

@@ -1,38 +1,55 @@
 #include "colors.h"
 
-#define DIMM_FACTOR 3
   .section ".rodata","a"
 ;; color definitions according to
 ;; https://learn.sparkfun.com/tutorials/lilypad-protosnap-plus-activity-guide/3-custom-color-mixing
 colors:
   .global colors
   ;;      red, green, blue, padding
-off:
+  .byte   0x00, 0x00, 0x00, 0               ;; off
-  .byte   0x00, 0x00, 0x00, 0
+
-blue:
+  .byte   0x00>>5, 0x00>>5, 0xff>>5, 0   ;; blue
-  .byte   0x00>>DIMM_FACTOR, 0x00>>DIMM_FACTOR, 0xff>>DIMM_FACTOR, 0
+  .byte   0x00>>5, 0xff>>5, 0x00>>5, 0   ;; green
-green:
+  .byte   0xff>>5, 0x80>>5, 0x00>>5, 0   ;; orange
-  .byte   0x00>>DIMM_FACTOR, 0xff>>DIMM_FACTOR, 0x00>>DIMM_FACTOR, 0
+  .byte   0x80>>5, 0x00>>5, 0xff>>5, 0   ;; violet
-orange:
+  .byte   0x00>>5, 0xff>>5, 0xff>>5, 0   ;; cyan
-  .byte   0xff>>DIMM_FACTOR, 0x80>>DIMM_FACTOR, 0x00>>DIMM_FACTOR, 0
+  .byte   0xff>>5, 0xff>>5, 0x00>>5, 0   ;; yellow
-rose:
+  .byte   0xff>>5, 0x00>>5, 0x00>>5, 0   ;; red
-  .byte   0xff>>DIMM_FACTOR, 0x00>>DIMM_FACTOR, 0x80>>DIMM_FACTOR, 0
+  .byte   0xff>>5, 0xff>>5, 0xff>>5, 0   ;; white
-magenta:
+
-  .byte   0xff>>DIMM_FACTOR, 0x00>>DIMM_FACTOR, 0xff>>DIMM_FACTOR, 0
+  .byte   0x00>>4, 0x00>>4, 0xff>>4, 0   ;; blue
-violet:
+  .byte   0x00>>4, 0xff>>4, 0x00>>4, 0   ;; green
-  .byte   0x80>>DIMM_FACTOR, 0x00>>DIMM_FACTOR, 0xff>>DIMM_FACTOR, 0
+  .byte   0xff>>4, 0x80>>4, 0x00>>4, 0   ;; orange
-azure:
+  .byte   0x80>>4, 0x00>>4, 0xff>>4, 0   ;; violet
-  .byte   0x00>>DIMM_FACTOR, 0x80>>DIMM_FACTOR, 0xff>>DIMM_FACTOR, 0
+  .byte   0x00>>4, 0xff>>4, 0xff>>4, 0   ;; cyan
-cyan:
+  .byte   0xff>>4, 0xff>>4, 0x00>>4, 0   ;; yellow
-  .byte   0x00>>DIMM_FACTOR, 0xff>>DIMM_FACTOR, 0xff>>DIMM_FACTOR, 0
+  .byte   0xff>>4, 0x00>>4, 0x00>>4, 0   ;; red
-springgreen:
+  .byte   0xff>>4, 0xff>>4, 0xff>>4, 0   ;; white
-  .byte   0x00>>DIMM_FACTOR, 0xff>>DIMM_FACTOR, 0x80>>DIMM_FACTOR, 0
+
-chartreuse:
+  .byte   0x00>>3, 0x00>>3, 0xff>>3, 0   ;; blue
-  .byte   0x80>>DIMM_FACTOR, 0xff>>DIMM_FACTOR, 0x00>>DIMM_FACTOR, 0
+  .byte   0x00>>3, 0xff>>3, 0x00>>3, 0   ;; green
-yellow:
+  .byte   0xff>>3, 0x80>>3, 0x00>>3, 0   ;; orange
-  .byte   0xff>>DIMM_FACTOR, 0xff>>DIMM_FACTOR, 0x00>>DIMM_FACTOR, 0
+  .byte   0x80>>3, 0x00>>3, 0xff>>3, 0   ;; violet
-white:
+  .byte   0x00>>3, 0xff>>3, 0xff>>3, 0   ;; cyan
-  .byte   0xff>>DIMM_FACTOR, 0xff>>DIMM_FACTOR, 0xff>>DIMM_FACTOR, 0
+  .byte   0xff>>3, 0xff>>3, 0x00>>3, 0   ;; yellow
-red:
+  .byte   0xff>>3, 0x00>>3, 0x00>>3, 0   ;; red
-  .byte   0xff>>DIMM_FACTOR, 0x00>>DIMM_FACTOR, 0x00>>DIMM_FACTOR, 0
+  .byte   0xff>>3, 0xff>>3, 0xff>>3, 0   ;; white
+
+  .byte   0x00>>2, 0x00>>2, 0xff>>2, 0   ;; blue
+  .byte   0x00>>2, 0xff>>2, 0x00>>2, 0   ;; green
+  .byte   0xff>>2, 0x80>>2, 0x00>>2, 0   ;; orange
+  .byte   0x80>>2, 0x00>>2, 0xff>>2, 0   ;; violet
+  .byte   0x00>>2, 0xff>>2, 0xff>>2, 0   ;; cyan
+  .byte   0xff>>2, 0xff>>2, 0x00>>2, 0   ;; yellow
+  .byte   0xff>>2, 0x00>>2, 0x00>>2, 0   ;; red
+  .byte   0xff>>2, 0xff>>2, 0xff>>2, 0   ;; white
+
+  .byte   0x00>>1, 0x00>>1, 0xff>>1, 0   ;; blue
+  .byte   0x00>>1, 0xff>>1, 0x00>>1, 0   ;; green
+  .byte   0xff>>1, 0x80>>1, 0x00>>1, 0   ;; orange
+  .byte   0x80>>1, 0x00>>1, 0xff>>1, 0   ;; violet
+  .byte   0x00>>1, 0xff>>1, 0xff>>1, 0   ;; cyan
+  .byte   0xff>>1, 0xff>>1, 0x00>>1, 0   ;; yellow
+  .byte   0xff>>1, 0x00>>1, 0x00>>1, 0   ;; red
+  .byte   0xff>>1, 0xff>>1, 0xff>>1, 0   ;; white
 

rgb-driver/colors.h

@@ -2,21 +2,20 @@
 #define _COLORS_H_
 
 
-#define _off 0x00
+#define _off 0
-#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
 
+#define _blue 1
+#define _green 2
+#define _orange 3
+#define _violet 4
+#define _cyan 5
+#define _yellow 6
+#define _red 7
+#define _white 8
+
+#define _brightness_offset 8
+#define _brightness_shifts 5
+#define _color_end (_brightness_offset * _brightness_shifts)
 
 
 #endif

rgb-driver/main.S

@@ -123,7 +123,7 @@ init:
 
   ;; spi configuration
   ;;  USCI B to slave mode, enable STE and most significant bit first
-  mov.b   #UCSYNC|UCMODE_2|UCMSB, &UCB0CTL0
+  mov.b   #UCCKPH|UCSYNC|UCMODE_2|UCMSB, &UCB0CTL0
   mov.b   #0x00, &UCB0CTL1
 
   ;; make sure the isr will not immediately start

sound-driver/Makefile

@@ -4,16 +4,15 @@ OBJDUMP=$(TOOLCHAIN_PREFIX)/bin/msp430-elf-objdump
 
 ARTIFACT=firmware
 MCU=msp430g2553
-COMMONFLAGS=-Wall -mmcu=$(MCU) -I $(TOOLCHAIN_PREFIX)/include -O0 -g0
+DEBUGFLAGS=
+# DEBUGFLAGS+= -g3 -ggdb -gdwarf-2
+COMMONFLAGS=-Wall -mmcu=$(MCU) -I $(TOOLCHAIN_PREFIX)/include -O0 -g0 $(DEBUGFLAGS)
 CFLAGS=$(COMMONFLAGS) -std=gnu99 
 ASFLAGS=$(COMMONFLAGS) -D__ASSEMBLER__
 
-# for debugging
-CFLAGS+= -g3 -ggdb -gdwarf-2
-
 LDFLAGS=-mmcu=$(MCU) -L $(TOOLCHAIN_PREFIX)/include
 
-$(ARTIFACT).elf:	main.o scheduler.o spi.o spi_init.o sequencer.o melody_tetris.o melody_tusch1.o ay_3_8913.o mute.o
+$(ARTIFACT).elf:	main.o scheduler.o spi.o spi_init.o sequencer.o melody_tetris.o melody_tusch1.o psg.o mute.o melody_pling.o
 	$(CC) -o $@ $(LDFLAGS) $^
 	$(OBJDUMP) -D $(ARTIFACT).elf > $(ARTIFACT).txt
 

sound-driver/main.c

@@ -31,7 +31,6 @@ int main() {
 
   __enable_interrupt();
 
-  // playMelodyTetris();
 
   while (1) {
     schExec();

sound-driver/melody_pling.c

@@ -0,0 +1,32 @@
+#include <stdbool.h>
+#include <stddef.h>
+#include "psg.h"
+#include "sequencer.h"
+#include "scheduler.h"
+
+const t_tone plingVoice1[] = {
+  { .octave = e_O_5,    .note = e_C,     .length = e_L_1_16,    .legato = false, .staccato = false },
+  { .octave = e_O_5,    .note = e_Cis,   .length = e_L_1_16,    .legato = false, .staccato = false },
+  { .octave = e_O_5,    .note = e_D,     .length = e_L_1_16,    .legato = false, .staccato = false },
+  { .octave = e_O_5,    .note = e_Dis,   .length = e_L_1_16,    .legato = false, .staccato = false },
+  { .octave = e_O_5,    .note = e_E,     .length = e_L_1_8,     .legato = false, .staccato = false },
+
+  { .octave = e_O_Null, .note = e_Null,  .length = e_L_SyncMark,.legato = false, .staccato = false },
+  { .octave = e_O_Null, .note = e_Null,  .length = e_L_StopMark,.legato = false, .staccato = false },
+
+  { .octave = e_O_Null, .note = e_Null,  .length = e_L_EndMark, .legato = false, .staccato = false },
+};
+
+t_melodies pling = {
+  .melodies = { { .amplitude = 12, .tones = plingVoice1 } },
+  .numOfMelodies = 1,
+  .pace = 200,
+  .chip = 1
+};
+
+void playPling() {
+  sequencerPlayMelodies(&pling);
+}
+
+
+

sound-driver/melody_pling.h

@@ -0,0 +1,8 @@
+#ifndef _MELODY_PLING_H_
+#define _MELODY_PLING_H_
+
+
+void playPling();
+
+
+#endif // _MELODY_PLING_H_

sound-driver/melody_tetris.c

@@ -922,19 +922,27 @@ const t_tone voice3[] = {
   { .octave = e_O_Null, .note = e_Null,  .length = e_L_EndMark, .legato = false, .staccato = false },
 };
 
+#define INITIAL_PACE 160
 t_melodies tetrisTheme = {
-  .melodies = { { .chip = 0, .amplitude = 8, .tones = voice1 }, { .chip = 0, .amplitude = 8, .tones = voice2 }, { .chip = 0, .amplitude = 8, .tones = voice3 } },
+  .melodies = { { .amplitude = 8, .tones = voice1 }, { .amplitude = 8, .tones = voice2 }, { .amplitude = 8, .tones = voice3 } },
   .numOfMelodies = 3,
-  .pace = 160,
+  .pace = INITIAL_PACE,
-  .slotMask = 0x01
+  .chip = 0
 };
 
 void playMelodyTetris() {
+  tetrisTheme.pace = INITIAL_PACE; // reset to start value each time
   sequencerPlayMelodies(&tetrisTheme);
 }
 
+void playMelodyTetrisFaster() {
+  tetrisTheme.pace += 15;
+  sequencerChangePace(&tetrisTheme);
+}
+
 void stopMelodyTetris() {
   sequencerStopMelodies(&tetrisTheme);
 }
 
 
+

sound-driver/melody_tetris.h

@@ -4,6 +4,6 @@
 
 void playMelodyTetris();
 void stopMelodyTetris();
-
+void playMelodyTetrisFaster();
 
 #endif // _MELODY_TETRIS_H_

sound-driver/melody_tusch1.c

@@ -3,6 +3,7 @@
 #include "psg.h"
 #include "sequencer.h"
 #include "scheduler.h"
+#include "melody_tetris.h"
 
 const t_tone tusch1voice1[] = {
   { .octave = e_O_5,    .note = e_C,     .length = e_L_1_4,     .legato = false, .staccato = true  },
@@ -71,14 +72,15 @@ const t_tone tusch1voice3[] = {
 };
 
 t_melodies tusch1 = {
-  .melodies = { { .chip = 1, .amplitude = 12, .tones = tusch1voice1 }, { .chip = 1, .amplitude = 12, .tones = tusch1voice2 }, { .chip = 1, .amplitude = 12, .tones = tusch1voice3 } },
+  .melodies = { { .amplitude = 12, .tones = tusch1voice1 }, { .amplitude = 12, .tones = tusch1voice2 }, { .amplitude = 12, .tones = tusch1voice3 } },
   .numOfMelodies = 3,
   .pace = 200,
-  .slotMask = 0x02
+  .chip = 1
 };
 
 void playTusch1() {
   sequencerPlayMelodies(&tusch1);
+//  playMelodyTetrisFaster();
 }
 
 

sound-driver/mute.c

@@ -6,15 +6,17 @@
 void muteInit() {
   // BIT6: MuteCtrl
   P1DIR |= BIT6;
+
+  // initially, mute
   P1OUT &= ~BIT6;
 }
 
 void mute() {
-  P1OUT |= BIT6;
-}
-
-void unMute() {
   P1OUT &= ~BIT6;
 }
 
+void unMute() {
+  P1OUT |= BIT6;
+}
+
 

sound-driver/psg.c

@@ -81,19 +81,6 @@ inline static void BUS_OP_CS1_DISABLE() {
   BUS_CTRL_REG |= _CS1;
 }
 
-#if 0
-static void delay() {
-asm volatile (
-    "push r12\n"
-    "mov.w #5, r12\n"
-    "loop:\n"
-    "dec.w r12\n"
-    "jnz loop\n"
-    "pop r12\n"
-);
-}
-#endif
-
 static uint8_t psgReadShadow(uint8_t chip, uint8_t address) {
   return psgShadowRegisters[chip][address];
 }

sound-driver/scheduler.c

@@ -52,16 +52,6 @@ uint16_t schAdd(void (*exec)(void *), void *handle, uint32_t delay, uint32_t per
   return taskId;
 }
 
-/*
-void schDel(void (*exec)(void *), void *handle) {
-  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 schDel(uint16_t taskId) {
   tasks[taskId].exec = NULL;
 }

sound-driver/sequencer.c

@@ -59,7 +59,7 @@ void sequencerExec(void *handle) {
           if (melody->tones[melody->idx].length == e_L_EndMark) {
             melody->idx = 0;
           }
-          psgPlayTone(melody->chip, channel, melody->amplitude, melody->tones[melody->idx].octave, melody->tones[melody->idx].note);
+          psgPlayTone(melodies->chip, channel, melody->amplitude, melody->tones[melody->idx].octave, melody->tones[melody->idx].note);
           melody->lengthCnt = (melody->tones[melody->idx].staccato) ? 
             (calcLength(melodies, melody->tones[melody->idx].length) / 2) : 
             calcLength(melodies, melody->tones[melody->idx].length);
@@ -78,7 +78,7 @@ void sequencerExec(void *handle) {
         }
         break;
       case e_StaccatoBreak:
-        psgPlayTone(melody->chip, channel, 0, e_O_Null, e_Pause);
+        psgPlayTone(melodies->chip, channel, 0, e_O_Null, e_Pause);
         melody->lengthCnt = calcLength(melodies, melody->tones[melody->idx].length) / 2;
         melody->state = e_HoldStaccatoBreak;
         break;
@@ -90,15 +90,17 @@ void sequencerExec(void *handle) {
         break;
       case e_SeparateTone:
         if (! (melody->tones[melody->idx].legato)) {
-          psgPlayTone(melody->chip, channel, 0, e_O_Null, e_Pause);
+          psgPlayTone(melodies->chip, channel, 0, e_O_Null, e_Pause);
         }
         melody->idx += 1;
         melody->state = e_PlayTone;
         break;
       case e_Hold:
+        psgPlayTone(melodies->chip, channel, 0, e_O_Null, e_Pause);
         break;
       case e_Terminate:
         schDel(melodies->taskId);
+        psgPlayTone(melodies->chip, channel, 0, e_O_Null, e_Pause);
         slots &= ~(melodies->slotMask);
         break;
     }
@@ -106,6 +108,8 @@ void sequencerExec(void *handle) {
 }
 
 void sequencerPlayMelodies(t_melodies *melodies) {
+  melodies->slotMask = (1 << melodies->chip);
+
   if ((slots & melodies->slotMask) != 0) {
     return;
   }
@@ -123,7 +127,14 @@ void sequencerPlayMelodies(t_melodies *melodies) {
 }
 
 void sequencerStopMelodies(t_melodies *melodies) {
-  slots &= ~(melodies->slotMask);
   schDel(melodies->taskId);
+  slots &= ~(melodies->slotMask);
+  for (uint8_t channel = 0; channel < melodies->numOfMelodies; channel++) {
+    psgPlayTone(melodies->chip, channel, 0, e_O_Null, e_Pause);
+  }
+}
+
+void sequencerChangePace(t_melodies *melodies) {
+  melodies->quarterLength = 60000 / melodies->pace / SEQUENCER_PERIOD; // duration of a 1/4 tone in ms
 }
 

sound-driver/sequencer.h

@@ -42,7 +42,6 @@ typedef enum {
 
 typedef struct {
   uint16_t idx;
-  uint8_t chip;
   uint16_t lengthCnt;
   t_sequencerState state;
   uint8_t amplitude;
@@ -53,10 +52,11 @@ typedef struct {
 #define NUM_OF_CHANNELS 3
 typedef struct {
   uint8_t slotMask;
+  uint8_t chip;
   uint8_t taskId;
   uint16_t quarterLength;
   uint8_t numOfMelodies;
-  uint8_t pace; // quarter notes per minute
+  uint16_t pace; // quarter notes per minute
   uint8_t sync;
   t_melody melodies[NUM_OF_CHANNELS];
 } t_melodies;
@@ -64,5 +64,6 @@ typedef struct {
 void sequencerInit();
 void sequencerPlayMelodies(t_melodies *melodies);
 void sequencerStopMelodies(t_melodies *melodies);
+void sequencerChangePace(t_melodies *melodies); 
 
 #endif // _SEQUENCER_H_

sound-driver/sn76489an.c

@@ -1,171 +0,0 @@
-#include <msp430g2553.h>
-#include <stdint.h>
-#include <stdlib.h>
-
-#include "psg.h"
-#include "scheduler.h"
-
-
-// generated using utils/calc-76489an.py
-const uint16_t frequencyCodes[8][12] = {
-  { 3420, 3229, 3047, 2876, 2715, 2562, 2419, 2283, 2155, 2034, 1920, 1812 }, 
-  { 1710, 1614, 1524, 1438, 1357, 1281, 1209, 1141, 1077, 1017, 960, 906 }, 
-  { 855, 807, 762, 719, 679, 641, 605, 571, 539, 508, 480, 453 }, 
-  { 428, 404, 381, 360, 339, 320, 302, 285, 269, 254, 240, 226 }, 
-  { 214, 202, 190, 180, 170, 160, 151, 143, 135, 127, 120, 113 }, 
-  { 107, 101, 95, 90, 85, 80, 76, 71, 67, 64, 60, 57 }, 
-  { 53, 50, 48, 45, 42, 40, 38, 36, 34, 32, 30, 28 }, 
-  { 27, 25, 24, 22, 21, 20, 19, 18, 17, 16, 15, 14 }
-};
-
-
-#define ADDR_DATA_REG P2OUT
-#define BUS_CTRL_REG P1OUT
-#define BUS_CTRL_IN_REG P1IN
-#define _CS0 BIT0
-#define _CS1 BIT1
-#define _WE BIT2
-#define READY BIT3
-
-#define CHANNEL_A_PERIOD_ADDR 0
-#define CHANNEL_A_ATTEN_ADDR 1
-#define CHANNEL_B_PERIOD_ADDR 2
-#define CHANNEL_B_ATTEN_ADDR 3
-#define CHANNEL_C_PERIOD_ADDR 4
-#define CHANNEL_C_ATTEN_ADDR 5
-
-#define IGNORE_OCTET 0xff
-
-uint8_t psgAmplitudeShadowValue[3];
-
-static void delay() {
-  asm volatile (
-      "push r12\n"
-      "mov.w #5, r12\n"
-      "loop:\n"
-      "dec.w r12\n"
-      "jnz loop\n"
-      "pop r12\n"
-  );
-}
-
-inline static void WRITE_CYCLE(uint8_t chipNo) {
-  if (chipNo == 0) {
-    BUS_CTRL_REG &= ~_CS0;
-  } else {
-    BUS_CTRL_REG &= ~_CS1;
-  }
-
-  BUS_CTRL_REG &= ~_WE;
-
-  delay();
-
-  while ((BUS_CTRL_IN_REG & READY) == 0);
-
-  BUS_CTRL_REG |= _WE;
-
-  if (chipNo == 0) {
-    BUS_CTRL_REG |= _CS0;
-  } else {
-    BUS_CTRL_REG |= _CS1;
-  }
-
-  delay();
-}
-
-static void psgWrite(uint8_t chipNo, uint8_t value) {
-  ADDR_DATA_REG = value;
-  WRITE_CYCLE(chipNo);
-}
-
-static void psgWriteFrequency(uint8_t channel, uint16_t frequencyCode) {
-  uint8_t chipNo = channel / 3;
-  uint8_t regAddr = (channel % 3) * 2;
-
-  // bit order in frequncyCode and order in octet on data bus are reversed
-  // see datacheat cp. 1 and cp. 6
-  uint8_t firstOctet = 0x01;
-  firstOctet |= ((regAddr & 0x04) > 1);
-  firstOctet |= ((regAddr & 0x02) < 1);
-  firstOctet |= ((regAddr & 0x01) < 3);
-  uint8_t lowerPart = frequencyCode & 0x0f;
-  firstOctet |= ((lowerPart & 0x08) << 1);
-  firstOctet |= ((lowerPart & 0x04) << 3);
-  firstOctet |= ((lowerPart & 0x02) << 5);
-  firstOctet |= ((lowerPart & 0x01) << 7);
-
-  uint8_t secondOctet = 0;
-  uint8_t upperPart = (frequencyCode & 0x03f0) >> 4;
-  secondOctet |= ((upperPart & 0x20) >> 3);
-  secondOctet |= ((upperPart & 0x10) >> 1);
-  secondOctet |= ((upperPart & 0x08) << 1);
-  secondOctet |= ((upperPart & 0x04) << 3);
-  secondOctet |= ((upperPart & 0x02) << 5);
-  secondOctet |= ((upperPart & 0x01) << 7);
-
-  ADDR_DATA_REG = firstOctet;
-  WRITE_CYCLE(chipNo);
-
-  ADDR_DATA_REG = secondOctet;
-  WRITE_CYCLE(chipNo);
-}
-
-void psgAmplitude(uint8_t channel, uint8_t volume) {
-  psgAmplitudeShadowValue[channel] = volume;
-  uint8_t chipNo = channel / 3;
-  uint8_t regAddr = ((channel % 3) * 2) + 1;
-
-  uint8_t attenuation = 15 - volume;
-
-  uint8_t firstOctet = 0x01;
-  firstOctet |= ((regAddr & 0x04) >> 1);
-  firstOctet |= ((regAddr & 0x02) << 1);
-  firstOctet |= ((regAddr & 0x01) << 3);
-  firstOctet |= ((attenuation & 0x01) << 7);
-  firstOctet |= ((attenuation & 0x02) << 5);
-  firstOctet |= ((attenuation & 0x04) << 3);
-  firstOctet |= ((attenuation & 0x08) << 1);
-
-  ADDR_DATA_REG = firstOctet;
-  WRITE_CYCLE(chipNo);
-}
-
-void psgPlayTone(uint8_t channel, uint8_t volume, t_octave octave, t_note note) {
-  if (note == e_Pause) {
-    psgAmplitude(channel, 0);
-  } else {
-//    if (psgAmplitudeShadowValue[channel] == 0) {
-      psgAmplitude(channel, volume);
-//    }
-    psgWriteFrequency(channel, frequencyCodes[octave][note]);
-  }
-}
-
-void psgInit() {
-  // address/data bus
-  P2DIR = 0xff;
-  P2SEL = 0;
-  P2SEL2 = 0;
-
-  // bus control lines
-  //   output:
-  //     BIT0: /CS chip 0
-  //     BIT1: /CS chip 1
-  //     BIT2: /WE
-  //   input:
-  //     BIT3: READY
-  P1DIR |= BIT0 | BIT1 | BIT2;
-  P1DIR &= ~BIT3;
-  // immediately disable all outputs, all are active low
-  P1OUT |= BIT0 | BIT1 | BIT2;
-
-  // shutdown all channels including noise
-  psgWrite(0, 0b11111001);
-  psgWrite(0, 0b11111101);
-  psgWrite(0, 0b11111011);
-  psgWrite(0, 0b11111111);
-
-//  psgPlayTone(0, 5, e_O_3, e_A);
-  psgAmplitude(0, 3);
-}
-

sound-driver/soundCodes.h

@@ -9,6 +9,6 @@
 #define SOUND_FANFARE 0x10
 #define SOUND_LOCK 0x20
 #define SOUND_MOTION 0x40
-#define SOUND_SPEED_UP 0x80
+#define SOUND_PLING 0x80
 
 #endif // _SOUND_CODES_H_

sound-driver/spi.S

@@ -1,10 +1,6 @@
 #include <msp430g2553.h>
 #include "soundCodes.h"
 
-  .section ".data"
-  .global cmd
-cmd:
-  .byte   
 
   .section ".text","ax",@progbits
 receive_isr:
@@ -34,11 +30,12 @@ spiCmdHandler_3:
 spiCmdHandler_4:
   bit     #SOUND_GAMEOVER, &cmd
   jz      spiCmdHandler_5
-  ;; insert a call here
+  call    #stopMelodyTetris
   bic     #SOUND_GAMEOVER, &cmd
 spiCmdHandler_5:
   bit     #SOUND_FANFARE, &cmd
   jz      spiCmdHandler_6
+  call    #playMelodyTetrisFaster
   call    #playTusch1
   bic     #SOUND_FANFARE, &cmd
 spiCmdHandler_6:
@@ -52,17 +49,14 @@ spiCmdHandler_7:
   ;; insert a call here
   bic     #SOUND_MOTION, &cmd
 spiCmdHandler_8:
-  bit     #SOUND_SPEED_UP, &cmd
+  bit     #SOUND_PLING, &cmd
   jz      spiCmdHandler_end
-  ;; insert a call here
+  call    #playPling
-  bic     #SOUND_SPEED_UP, &cmd
+  bic     #SOUND_PLING, &cmd
 spiCmdHandler_end:
   ret
 
 
-
-
-
   .section "__interrupt_vector_8","ax",@progbits
   .word   receive_isr
 

sound-driver/spi_init.c

@@ -6,7 +6,7 @@
 #include "soundCodes.h"
 
 
-extern uint8_t cmd;
+uint8_t cmd;
 
 void spiInit() {
   // SPI slave
@@ -18,7 +18,7 @@ void spiInit() {
   P1SEL2 |= BIT4 | BIT5 | BIT7;
 
   // most significant bit first, enable STE
-  UCB0CTL0 = UCSYNC | UCMSB | UCMODE_2;
+  UCB0CTL0 = UCCKPH | UCSYNC | UCMSB | UCMODE_2;
   UCB0CTL1 = 0x00;
 
   // enable RX interrupt