add highscore display

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

@@ -7,11 +7,11 @@ MCU=msp430g2553
 CFLAGS=-Wall -mmcu=$(MCU) -std=gnu99 -I $(TOOLCHAIN_PREFIX)/include -O1 -g0
 
 # for debugging
-#CFLAGS+= -g3 -ggdb -gdwarf-2
+CFLAGS+= -g3 -ggdb -gdwarf-2
 
 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
+$(ARTIFACT).elf:	main.o spi.o scheduler.o canvas.o shapes.o game.o buttons.o myrand.o display.o sound.o eeprom.o
 	$(CC) -o $@ $(LDFLAGS) $^
 	$(OBJDUMP) -D $(ARTIFACT).elf > $(ARTIFACT).txt
 

game-ctrl/buttons.c

@@ -1,13 +1,17 @@
 #include <stddef.h>
 #include <stdint.h>
+#include <stdbool.h>
 #include <msp430g2553.h>
 
 #include "buttons.h"
 #include "scheduler.h"
 #include "shapes.h"
 #include "canvas.h"
+#include "sound.h"
 
 
+bool mutedFlag = true;
+
 static uint8_t buttonsMoveLeftPressed() {
   static uint8_t last = 0;
   uint8_t current = (P2IN & BIT4);
@@ -45,6 +49,10 @@ static uint8_t buttonsMoveDownPressed() {
 }
 
 void buttonsExec(void *handle) {
+  static uint32_t unmuteTimestamp;
+  uint32_t currentTimestamp = getSeconds();
+
+
   if (! stoneIsValid()) {
     // don't do anything, the stone has not been initialized
     return;
@@ -54,27 +62,43 @@ void buttonsExec(void *handle) {
 
   if (buttonsMoveLeftPressed()) {
     stoneMoveLeft();
+    soundCtrl(SOUND_MOTION);
     buttonPressed = 1;
   }
   if (buttonsMoveRightPressed()) {
     stoneMoveRight();
+    soundCtrl(SOUND_MOTION);
     buttonPressed = 1;
   }
   if (buttonsRotateLeftPressed()) {
     stoneRotateLeft();
+    soundCtrl(SOUND_MOTION);
     buttonPressed = 1;
   }
   if (buttonsRotateRightPressed()) {
     stoneRotateRight();
+    soundCtrl(SOUND_MOTION);
     buttonPressed = 1;
   }
   if (buttonsMoveDownPressed()) {
     stoneMoveDown();
+    soundCtrl(SOUND_MOTION);
     buttonPressed = 1;
   }
 
   if (buttonPressed == 1) {
     canvasShow();
+
+    if (mutedFlag) {
+      soundCtrl(SOUND_UNMUTE);
+      mutedFlag = false;
+    }
+    unmuteTimestamp = currentTimestamp;
+  }
+
+  if ((! mutedFlag) && (unmuteTimestamp + MUTE_DELAY < currentTimestamp)) {
+    soundCtrl(SOUND_MUTE);
+    mutedFlag = true;
   }
 }
 
@@ -84,3 +108,7 @@ void buttonsInit() {
   schAdd(buttonsExec, NULL, 0, 25);
 }
 
+bool isGameActive() {
+  return ! mutedFlag;
+}
+

game-ctrl/buttons.h

@@ -1,7 +1,10 @@
 #ifndef _BUTTONS_H_
 #define _BUTTONS_H_
 
+#include <stdbool.h>
+
 void buttonsInit();
+bool isGameActive();
 
 
 #endif // _BUTTONS_H_

game-ctrl/eeprom.c

@@ -0,0 +1,75 @@
+#include <stdint.h>
+#include "eeprom.h"
+#include "spi.h"
+
+
+#define MAGIC 0xaffe
+#define HIGHSCORE_ADDR 0x00
+#define DUMMY 0x00
+#define CMD_READ  0b00000011
+#define CMD_WRITE 0b00000010
+#define CMD_WRDI  0b00000100
+#define CMD_WREN  0b00000110
+
+
+typedef union {
+  uint8_t buffer[4];
+  struct {
+    uint16_t magic;
+    uint16_t highScore;
+  } v;
+} 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);
+  spiSendOctet(buf.buffer[0]);
+  spiSendOctet(buf.buffer[1]);
+  spiSendOctet(buf.buffer[2]);
+  spiSendOctet(buf.buffer[3]);
+  spiSendEnd(e_SPI_EEPROM);
+}
+
+static void readBuf() {
+  spiSendBegin(e_SPI_EEPROM);
+  spiSendOctet(CMD_READ);
+  spiReceiveOctet();
+  spiSendOctet(HIGHSCORE_ADDR);
+  spiReceiveOctet();
+  spiSendOctet(DUMMY);
+  buf.buffer[0] = spiReceiveOctet();
+  spiSendOctet(DUMMY);
+  buf.buffer[1] = spiReceiveOctet();
+  spiSendOctet(DUMMY);
+  buf.buffer[2] = spiReceiveOctet();
+  spiSendOctet(DUMMY);
+  buf.buffer[3] = spiReceiveOctet();
+  spiSendEnd(e_SPI_EEPROM);
+}
+
+void eepromInit() {
+  readBuf();
+
+  if (buf.v.magic != MAGIC) {
+    buf.v.magic = MAGIC;
+    buf.v.highScore = 0;
+    writeBuf();
+  }
+}
+
+uint16_t eepromReadHighScore() {
+  return buf.v.highScore;
+}
+
+void eepromWriteHighScore(uint16_t v) {
+  buf.v.highScore = v;
+  writeBuf();
+}
+

game-ctrl/eeprom.h

@@ -0,0 +1,13 @@
+#ifndef _EEPROM_H_
+#define _EEPROM_H_
+
+#include <stdint.h>
+
+
+void eepromInit();
+uint16_t eepromReadHighScore();
+void eepromWriteHighScore(uint16_t v);
+
+
+
+#endif // _EEPROM_H_

game-ctrl/game.c

@@ -7,6 +7,9 @@
 #include "canvas.h"
 #include "../rgb-driver/colors.h"
 #include "display.h"
+#include "sound.h"
+#include "eeprom.h"
+#include "buttons.h"
 
 
 #define GAME_CYCLE_TIME 100
@@ -34,15 +37,17 @@ void gameExec(void *handle) {
   static uint8_t proceedDelay;
   static uint8_t level;
   static uint16_t score;
+  static bool newHighScoreAchieved;
 
 // --- engine begin -------------------------------------------------------
   switch (state) {
 // --- phase: game --------------------------------------------------------
     case e_Start:
       canvasClear();
+      soundCtrl(SOUND_START);
       level = 1;
       score = 0;
-      displaySetValue(score);
+      newHighScoreAchieved = false;
       phase = e_Phase_Game;
       state = e_NewStone;
       break;
@@ -71,6 +76,7 @@ void gameExec(void *handle) {
       
     case e_Down:
       if (! stoneMoveDown()) {
+        soundCtrl(SOUND_LOCK);
         state = e_NewStone;
       } else {
         proceedDelay = delayFactor(level);
@@ -80,6 +86,7 @@ void gameExec(void *handle) {
 
 // --- phase: game over ---------------------------------------------------
     case e_GameOver:
+      soundCtrl(SOUND_GAMEOVER);
       rowIndex = CANVAS_HEIGHT;
       phase = e_Phase_GameOver;
       state = e_GameOverFill;
@@ -87,7 +94,7 @@ void gameExec(void *handle) {
 
     case e_GameOverFill:
       rowIndex--;
-      canvasFillRow(rowIndex, _red);
+      canvasFillRow(rowIndex, newHighScoreAchieved ? _green : _red);
       if (rowIndex == 0) {
         state = e_GameOverWipe;
       }
@@ -113,17 +120,33 @@ void gameExec(void *handle) {
 
   canvasShow();
   if (phase == e_Phase_Game) {
+    uint8_t wipeCnt = 0;
     for (uint8_t r = 0; r < CANVAS_HEIGHT; r++) {
       if (canvasIsRowFilled(r)) {
         score += level;
+        if (score > eepromReadHighScore()) {
+          newHighScoreAchieved = true;
+          eepromWriteHighScore(score);
+        }
         displaySetValue(score);
         canvasWipeRow(r);
         canvasShow();
+        wipeCnt += 1;
       }
     }
+    if (wipeCnt != 0) {
+      soundCtrl(SOUND_FANFARE); 
+    }
+  }
+
+  if (isGameActive()) {
+    displaySetValue(score);
+  } else {
+    displaySetValue(eepromReadHighScore());
   }
 }
 
 void gameInit() {
   schAdd(gameExec, NULL, 0, GAME_CYCLE_TIME);
 }
+

game-ctrl/main.c

@@ -12,6 +12,7 @@
 #include "myrand.h"
 #include "spi.h"
 #include "display.h"
+#include "eeprom.h"
 
 
 int main() {
@@ -28,6 +29,7 @@ int main() {
     schInit();
 
     spiInit();
+    eepromInit();
     displayInit();
     myRandInit();
     canvasInit();

game-ctrl/scheduler.c

@@ -12,6 +12,7 @@
 
 tTask tasks[MAX_NUM_OF_TASKS];
 
+uint32_t seconds;
 
 void schInit() {
   TACCR0 = 32;
@@ -25,9 +26,18 @@ void schInit() {
     tasks[i].exec = NULL;
     tasks[i].handle = NULL;
   }
+
+  seconds = 0;
 }
 
 void __attribute__ ((interrupt (TIMER0_A0_VECTOR))) schUpdate() {
+  static uint16_t milliSeconds = 0;
+  if (milliSeconds >= 1000) {
+    seconds += 1;
+    milliSeconds = 0;
+  }
+  milliSeconds += 1;
+
   for (uint16_t i = 0; i < MAX_NUM_OF_TASKS; i++) {
     if (tasks[i].exec != NULL) {
       if (tasks[i].delay == 0) {
@@ -89,4 +99,13 @@ void schExec() {
   }
 }
 
+uint32_t getSeconds() {
+  uint32_t s;
+
+  __disable_interrupt();
+  s = seconds;
+  __enable_interrupt();
+
+  return s;
+}
 

game-ctrl/scheduler.h

@@ -31,6 +31,7 @@ void schDel(void (*exec)(void *), void *handle);
 void schExec();
 void schUpdate();
 uint8_t schTaskCnt();
+uint32_t getSeconds();
 
 
 #endif /* PONTCOOPSCHEDULER_H_ */

game-ctrl/sound.c

@@ -0,0 +1,18 @@
+#include <stdint.h>
+#include "sound.h"
+#include "spi.h"
+
+
+
+void soundInit() {
+}
+
+
+void soundCtrl(uint8_t cmd) {
+  spiSendBegin(e_SPI_SOUND);
+
+  spiSendOctet(cmd);
+
+  spiSendEnd(e_SPI_SOUND);
+}
+

game-ctrl/sound.h

@@ -0,0 +1,15 @@
+#ifndef _SOUND_H_
+#define _SOUND_H_
+
+#include <stdint.h>
+
+#define MUTE_DELAY 30 // seconds
+
+#include "../sound-driver/soundCodes.h"
+
+void soundInit();
+void soundCtrl(uint8_t cmd);
+
+
+
+#endif // _SOUND_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
-  P1DIR |= BIT0 | BIT1 | BIT2;
+  // Device Select Lines: 0: Canvas, 1: Display, 2: Sound, 4: EEPROM
+  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();
 
 
 

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,20 +4,25 @@ OBJDUMP=$(TOOLCHAIN_PREFIX)/bin/msp430-elf-objdump
 
 ARTIFACT=firmware
 MCU=msp430g2553
-CFLAGS=-Wall -mmcu=$(MCU) -std=gnu99 -I $(TOOLCHAIN_PREFIX)/include -O1 -g0
+COMMONFLAGS=-Wall -mmcu=$(MCU) -I $(TOOLCHAIN_PREFIX)/include -O0 -g0
+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 sequencer.o melody.o ay_3_8913.o
+$(ARTIFACT).elf:	main.o scheduler.o spi.o spi_init.o sequencer.o melody_tetris.o melody_tusch1.o psg.o mute.o
 	$(CC) -o $@ $(LDFLAGS) $^
 	$(OBJDUMP) -D $(ARTIFACT).elf > $(ARTIFACT).txt
 
 .c.o:	
 	$(CC) $(CFLAGS) -c $<
 
+.S.o:	
+	$(CC) $(ASFLAGS) -c $<
+
 
 .PHONY: all
 all:	$(ARTIFACT).elf

sound-driver/main.c

@@ -6,7 +6,9 @@
 #include "psg.h"
 #include "scheduler.h"
 #include "sequencer.h"
-#include "melody.h"
+#include "melody_tetris.h"
+#include "melody_tusch1.h"
+#include "mute.h"
 
 int main() {
   WDTCTL = WDTPW | WDTHOLD;
@@ -22,14 +24,14 @@ int main() {
 
   schInit();
 
-//  spiInit();
+  spiInit();
   psgInit();
+  muteInit();
   sequencerInit();
 
   __enable_interrupt();
 
-  melodyInit();
-
+  // playMelodyTetris();
 
   while (1) {
     schExec();

sound-driver/melody.h

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

sound-driver/melody_tetris.c

@@ -1,119 +1,9 @@
 #include <stdbool.h>
+#include <stddef.h>
 #include "psg.h"
 #include "sequencer.h"
+#include "scheduler.h"
 
-/*
- * most simple Tetris from https://de.wikipedia.org/wiki/Korobeiniki
-const t_tone notes[] = {
-  { .octave = e_O_3,    .note = e_G,     .length = e_L_1_4,     .legato = false, .staccato = false },
-  { .octave = e_O_3,    .note = e_D,     .length = e_L_1_8,     .legato = false, .staccato = false },
-  { .octave = e_O_3,    .note = e_Es,    .length = e_L_1_8,     .legato = false, .staccato = false },
-
-  { .octave = e_O_3,    .note = e_F,     .length = e_L_1_4,     .legato = false, .staccato = false },
-  // Triller
-  { .octave = e_O_3,    .note = e_Es,    .length = e_L_1_32,    .legato = false, .staccato = false },
-  { .octave = e_O_3,    .note = e_F,     .length = e_L_1_32,    .legato = false, .staccato = false },
-  { .octave = e_O_3,    .note = e_Es,    .length = e_L_1_32,    .legato = false, .staccato = false },
-  { .octave = e_O_3,    .note = e_F,     .length = e_L_1_32,    .legato = false, .staccato = false },
-  { .octave = e_O_3,    .note = e_D,     .length = e_L_1_8,     .legato = false, .staccato = false },
-
-  { .octave = e_O_3,    .note = e_C,     .length = e_L_1_4,     .legato = false, .staccato = false },
-  { .octave = e_O_3,    .note = e_C,     .length = e_L_1_8,     .legato = false, .staccato = false },
-  { .octave = e_O_3,    .note = e_Es,    .length = e_L_1_8,     .legato = false, .staccato = false },
-
-  { .octave = e_O_3,    .note = e_G,     .length = e_L_1_4,     .legato = false, .staccato = false },
-  { .octave = e_O_3,    .note = e_F,     .length = e_L_1_8,     .legato = false, .staccato = false },
-  { .octave = e_O_3,    .note = e_Es,    .length = e_L_1_8,     .legato = false, .staccato = false },
-
-  { .octave = e_O_3,    .note = e_D,     .length = e_L_1_4,     .legato = true , .staccato = false },
-  { .octave = e_O_3,    .note = e_D,     .length = e_L_1_8,     .legato = false, .staccato = false },
-  { .octave = e_O_3,    .note = e_Es,    .length = e_L_1_8,     .legato = false, .staccato = false },
-
-  { .octave = e_O_3,    .note = e_F,     .length = e_L_1_4,     .legato = false, .staccato = false },
-  { .octave = e_O_3,    .note = e_G,     .length = e_L_1_4,     .legato = false, .staccato = false },
-
-  { .octave = e_O_3,    .note = e_Es,    .length = e_L_1_4,     .legato = false, .staccato = true  },
-  { .octave = e_O_3,    .note = e_C,     .length = e_L_1_4,     .legato = false, .staccato = true  },
-
-  { .octave = e_O_3,    .note = e_C,     .length = e_L_1_4,     .legato = false, .staccato = false },
-  { .octave = e_O_Null, .note = e_Pause, .length = e_L_1_4,     .legato = false, .staccato = false },
-
-
-  { .octave = e_O_Null, .note = e_Pause, .length = e_L_1_8,     .legato = false, .staccato = false },
-  { .octave = e_O_3,    .note = e_F,     .length = e_L_1_8,     .legato = true , .staccato = false },
-  { .octave = e_O_3,    .note = e_F,     .length = e_L_1_8,     .legato = false, .staccato = false },
-  { .octave = e_O_3,    .note = e_As,    .length = e_L_1_8,     .legato = false, .staccato = false },
-
-  { .octave = e_O_4,    .note = e_C,     .length = e_L_1_4,     .legato = false, .staccato = false },
-  { .octave = e_O_3,    .note = e_B,     .length = e_L_1_8,     .legato = false, .staccato = false },
-  { .octave = e_O_3,    .note = e_As,    .length = e_L_1_8,     .legato = false, .staccato = false },
-
-  { .octave = e_O_3,    .note = e_G,     .length = e_L_1_4,     .legato = true , .staccato = false },
-  { .octave = e_O_3,    .note = e_G,     .length = e_L_1_8,     .legato = false, .staccato = false },
-  { .octave = e_O_3,    .note = e_Es,    .length = e_L_1_8,     .legato = false, .staccato = false },
-
-  { .octave = e_O_3,    .note = e_G,     .length = e_L_1_4,     .legato = false, .staccato = false },
-  { .octave = e_O_3,    .note = e_F,     .length = e_L_1_8,     .legato = false, .staccato = false },
-  { .octave = e_O_3,    .note = e_Es,    .length = e_L_1_8,     .legato = false, .staccato = false },
-
-  { .octave = e_O_3,    .note = e_D,     .length = e_L_1_4,     .legato = false, .staccato = false },
-  { .octave = e_O_3,    .note = e_D,     .length = e_L_1_8,     .legato = false, .staccato = false },
-  { .octave = e_O_3,    .note = e_Es,    .length = e_L_1_8,     .legato = false, .staccato = false },
-
-  { .octave = e_O_3,    .note = e_F,     .length = e_L_1_4,     .legato = false, .staccato = false },
-  { .octave = e_O_3,    .note = e_G,     .length = e_L_1_4,     .legato = false, .staccato = false },
-
-  { .octave = e_O_3,    .note = e_Es,    .length = e_L_1_4,     .legato = false, .staccato = true  },
-  { .octave = e_O_3,    .note = e_C,     .length = e_L_1_4,     .legato = false, .staccato = true  },
-
-  { .octave = e_O_3,    .note = e_C,     .length = e_L_1_4,     .legato = false, .staccato = false },
-  { .octave = e_O_Null, .note = e_Pause, .length = e_L_1_4,     .legato = false, .staccato = false },
-
-  { .octave = e_O_Null, .note = e_Null,  .length = e_L_EndMark, .legato = false, .staccato = false },
-};
-*/
-
-const t_tone tonleiter[] = {
-  { .octave = e_O_6,    .note = e_C,     .length = e_L_1_4,     .legato = false, .staccato = false },
-  { .octave = e_O_6,    .note = e_D,     .length = e_L_1_4,     .legato = false, .staccato = false },
-  { .octave = e_O_6,    .note = e_E,     .length = e_L_1_4,     .legato = false, .staccato = false },
-  { .octave = e_O_6,    .note = e_F,     .length = e_L_1_4,     .legato = false, .staccato = false },
-  { .octave = e_O_6,    .note = e_G,     .length = e_L_1_4,     .legato = false, .staccato = false },
-  { .octave = e_O_6,    .note = e_A,     .length = e_L_1_4,     .legato = false, .staccato = false },
-  { .octave = e_O_6,    .note = e_H,     .length = e_L_1_4,     .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_EndMark, .legato = false, .staccato = false },
-};
-
-const t_tone tonleiter2[] = {
-  { .octave = e_O_4,    .note = e_C,     .length = e_L_1_4,     .legato = false, .staccato = false },
-  { .octave = e_O_4,    .note = e_D,     .length = e_L_1_4,     .legato = false, .staccato = false },
-  { .octave = e_O_4,    .note = e_E,     .length = e_L_1_4,     .legato = false, .staccato = false },
-  { .octave = e_O_4,    .note = e_F,     .length = e_L_1_4,     .legato = false, .staccato = false },
-  { .octave = e_O_4,    .note = e_G,     .length = e_L_1_4,     .legato = false, .staccato = false },
-  { .octave = e_O_4,    .note = e_A,     .length = e_L_1_4,     .legato = false, .staccato = false },
-  { .octave = e_O_4,    .note = e_H,     .length = e_L_1_4,     .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_EndMark, .legato = false, .staccato = false },
-};
-
-const t_tone tonleiter3[] = {
-  { .octave = e_O_5,    .note = e_C,     .length = e_L_1_4,     .legato = false, .staccato = false },
-  { .octave = e_O_5,    .note = e_D,     .length = e_L_1_4,     .legato = false, .staccato = false },
-  { .octave = e_O_5,    .note = e_E,     .length = e_L_1_4,     .legato = false, .staccato = false },
-  { .octave = e_O_5,    .note = e_F,     .length = e_L_1_4,     .legato = false, .staccato = false },
-  { .octave = e_O_5,    .note = e_G,     .length = e_L_1_4,     .legato = false, .staccato = false },
-  { .octave = e_O_5,    .note = e_A,     .length = e_L_1_4,     .legato = false, .staccato = false },
-  { .octave = e_O_5,    .note = e_H,     .length = e_L_1_4,     .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_EndMark, .legato = false, .staccato = false },
-};
 
 /*
  * three voices theme from https://www.gamemusicthemes.com/sheetmusic/gameboy/tetris/themea/Tetris_-_Theme_A_by_Gori_Fater.pdf
@@ -1033,19 +923,18 @@ const t_tone voice3[] = {
 };
 
 t_melodies tetrisTheme = {
-  .melodies = { { .amplitude = 3, .tones = voice1 }, { .amplitude = 3, .tones = voice2 }, { .amplitude = 3, .tones = voice3 } },
+  .melodies = { { .chip = 0, .amplitude = 8, .tones = voice1 }, { .chip = 0, .amplitude = 8, .tones = voice2 }, { .chip = 0, .amplitude = 8, .tones = voice3 } },
   .numOfMelodies = 3,
-  .pace = 160
+  .pace = 160,
+  .slotMask = 0x01
 };
 
-t_melodies tonleiterTheme = {
-  .melodies = { { .amplitude = 3, .tones = tonleiter }, { .amplitude = 3, .tones = tonleiter2 }, { .amplitude = 3, .tones = tonleiter3 } },
-  .numOfMelodies = 3,
-  .pace = 160
-};
-
-void melodyInit() {
+void playMelodyTetris() {
   sequencerPlayMelodies(&tetrisTheme);
 }
 
+void stopMelodyTetris() {
+  sequencerStopMelodies(&tetrisTheme);
+}
+
 

sound-driver/melody_tetris.h

@@ -0,0 +1,9 @@
+#ifndef _MELODY_TETRIS_H_
+#define _MELODY_TETRIS_H_
+
+
+void playMelodyTetris();
+void stopMelodyTetris();
+
+
+#endif // _MELODY_TETRIS_H_

sound-driver/melody_tusch1.c

@@ -0,0 +1,85 @@
+#include <stdbool.h>
+#include <stddef.h>
+#include "psg.h"
+#include "sequencer.h"
+#include "scheduler.h"
+
+const t_tone tusch1voice1[] = {
+  { .octave = e_O_5,    .note = e_C,     .length = e_L_1_4,     .legato = false, .staccato = true  },
+  { .octave = e_O_5,    .note = e_F,     .length = e_L_1_2,     .legato = false, .staccato = false },
+
+  { .octave = e_O_Null, .note = e_Pause, .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_5,    .note = e_C,     .length = e_L_1_4,     .legato = false, .staccato = true  },
+  { .octave = e_O_5,    .note = e_F,     .length = e_L_1_2,     .legato = false, .staccato = false },
+
+  { .octave = e_O_Null, .note = e_Pause, .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_5,    .note = e_C,     .length = e_L_1_4,     .legato = false, .staccato = true  },
+  { .octave = e_O_5,    .note = e_F,     .length = e_L_1_2,     .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 },
+};
+
+const t_tone tusch1voice2[] = {
+  { .octave = e_O_Null, .note = e_Pause, .length = e_L_1_4,     .legato = false, .staccato = false },
+  { .octave = e_O_5,    .note = e_C,     .length = e_L_1_2,     .legato = false, .staccato = false },
+
+  { .octave = e_O_Null, .note = e_Pause, .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_Pause, .length = e_L_1_4,     .legato = false, .staccato = false },
+  { .octave = e_O_5,    .note = e_C,     .length = e_L_1_2,     .legato = false, .staccato = false },
+
+  { .octave = e_O_Null, .note = e_Pause, .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_Pause, .length = e_L_1_4,     .legato = false, .staccato = false },
+  { .octave = e_O_5,    .note = e_C,     .length = e_L_1_2,     .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_HoldMark,.legato = false, .staccato = false },
+
+  { .octave = e_O_Null, .note = e_Null,  .length = e_L_EndMark, .legato = false, .staccato = false },
+};
+
+const t_tone tusch1voice3[] = {
+  { .octave = e_O_Null, .note = e_Pause, .length = e_L_1_4,     .legato = false, .staccato = false },
+  { .octave = e_O_4,    .note = e_A,     .length = e_L_1_2,     .legato = false, .staccato = false },
+
+  { .octave = e_O_Null, .note = e_Pause, .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_Pause, .length = e_L_1_4,     .legato = false, .staccato = false },
+  { .octave = e_O_4,    .note = e_A,     .length = e_L_1_2,     .legato = false, .staccato = false },
+
+  { .octave = e_O_Null, .note = e_Pause, .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_Pause, .length = e_L_1_4,     .legato = false, .staccato = false },
+  { .octave = e_O_4,    .note = e_A,     .length = e_L_1_2,     .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_HoldMark,.legato = false, .staccato = false },
+
+  { .octave = e_O_Null, .note = e_Null,  .length = e_L_EndMark, .legato = false, .staccato = false },
+};
+
+t_melodies tusch1 = {
+  .melodies = { { .chip = 1, .amplitude = 12, .tones = tusch1voice1 }, { .chip = 1, .amplitude = 12, .tones = tusch1voice2 }, { .chip = 1, .amplitude = 12, .tones = tusch1voice3 } },
+  .numOfMelodies = 3,
+  .pace = 200,
+  .slotMask = 0x02
+};
+
+void playTusch1() {
+  sequencerPlayMelodies(&tusch1);
+}
+
+
+

sound-driver/melody_tusch1.h

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

sound-driver/mute.c

@@ -0,0 +1,22 @@
+#include <msp430g2553.h>
+#include "mute.h"
+
+
+
+void muteInit() {
+  // BIT6: MuteCtrl
+  P1DIR |= BIT6;
+
+  // initially, mute
+  P1OUT |= BIT6;
+}
+
+void mute() {
+  P1OUT |= BIT6;
+}
+
+void unMute() {
+  P1OUT &= ~BIT6;
+}
+
+

sound-driver/mute.h

@@ -0,0 +1,8 @@
+#ifndef _MUTE_H_
+#define _MUTE_H_
+
+void muteInit();
+void mute();
+void unMute();
+
+#endif // _MUTE_H_

sound-driver/psg.c

@@ -56,7 +56,7 @@ const uint16_t frequencyCodes[8][12] = {
 #define R15 015
 #define ENVELOPE_SHAPE_REG R15
 
-uint8_t psgShadowRegisters[14];
+uint8_t psgShadowRegisters[2][14];
 
 inline static void BUS_OP_NACT() {
   BUS_CTRL_REG &= ~(BDIR | BC1);
@@ -94,16 +94,20 @@ asm volatile (
 }
 #endif
 
-static uint8_t psgReadShadow(uint8_t address) {
-  return psgShadowRegisters[address];
+static uint8_t psgReadShadow(uint8_t chip, uint8_t address) {
+  return psgShadowRegisters[chip][address];
 }
 
-static void psgWrite(uint8_t address, uint8_t data) {
-  psgShadowRegisters[address] = data;
+static void psgWrite(uint8_t chip, uint8_t address, uint8_t data) {
+  psgShadowRegisters[chip][address] = data;
 
   // according to "State Timing" (p. 15) of datasheet
 
-  BUS_OP_CS1_ENABLE();
+  if (chip == 0) {
+    BUS_OP_CS0_ENABLE();
+  } else {
+    BUS_OP_CS1_ENABLE();
+  }
 
   // put bus into inactive state
   BUS_OP_NACT();
@@ -126,26 +130,30 @@ static void psgWrite(uint8_t address, uint8_t data) {
   // set inactive again
   BUS_OP_NACT();
 
-  BUS_OP_CS1_DISABLE();
-}
-
-static void psgWriteFrequency(uint8_t channel, uint16_t frequencyCode) {
-  psgWrite(CHANNEL_A_TONE_PERIOD_FINE_REG + (channel * 2), (frequencyCode & 0x00ff));
-  psgWrite(CHANNEL_A_TONE_PERIOD_COARSE_REG + (channel * 2), ((frequencyCode >> 8) & 0x000f));
-}
-
-void psgPlayTone(uint8_t channel, uint8_t volume, t_octave octave, t_note note) {
-  if (note == e_Pause) {
-    psgWrite(_ENABLE_REG, psgReadShadow(_ENABLE_REG) | (1 << channel));
+  if (chip == 0) {
+    BUS_OP_CS0_DISABLE();
   } else {
-    psgWrite(_ENABLE_REG, psgReadShadow(_ENABLE_REG) & ~(1 << channel));
-    psgAmplitude(channel, volume);
-    psgWriteFrequency(channel, frequencyCodes[octave][note]);
+    BUS_OP_CS1_DISABLE();
   }
 }
 
-void psgAmplitude(uint8_t channel, uint8_t volume) {
-  psgWrite(CHANNEL_A_AMPLITUDE_REG + channel, volume);
+static void psgWriteFrequency(uint8_t chip, uint8_t channel, uint16_t frequencyCode) {
+  psgWrite(chip, CHANNEL_A_TONE_PERIOD_FINE_REG + (channel * 2), (frequencyCode & 0x00ff));
+  psgWrite(chip, CHANNEL_A_TONE_PERIOD_COARSE_REG + (channel * 2), ((frequencyCode >> 8) & 0x000f));
+}
+
+void psgPlayTone(uint8_t chip, uint8_t channel, uint8_t volume, t_octave octave, t_note note) {
+  if (note == e_Pause) {
+    psgWrite(chip, _ENABLE_REG, psgReadShadow(chip, _ENABLE_REG) | (1 << channel));
+  } else {
+    psgWrite(chip, _ENABLE_REG, psgReadShadow(chip, _ENABLE_REG) & ~(1 << channel));
+    psgAmplitude(chip, channel, volume);
+    psgWriteFrequency(chip, channel, frequencyCodes[octave][note]);
+  }
+}
+
+void psgAmplitude(uint8_t chip, uint8_t channel, uint8_t volume) {
+  psgWrite(chip, CHANNEL_A_AMPLITUDE_REG + channel, volume);
 }
 
 void psgInit() {
@@ -154,18 +162,6 @@ void psgInit() {
   P2SEL = 0;
   P2SEL2 = 0;
 
-  // sound chip reset
-  // BIT2: /RST
-  // P1DIR |= BIT2;
-
-#if 0
-  // put sound chip into reset state
-  P1OUT &= ~BIT2;
-  delay();
-  delay();
-  delay();
-#endif
-  
   // bus control lines
   // BIT3: BC1
   // BIT1: BDIR
@@ -176,15 +172,8 @@ void psgInit() {
   // put bus into inactive state
   BUS_CTRL_REG &= ~(BDIR | BC1);
   
-#if 0
-  // release sound chip from reset state
-  P1OUT |= BIT2;
-  delay();
-  delay();
-  delay();
-#endif
-
   // disable everything
-  psgWrite(_ENABLE_REG, 0xff);
+  psgWrite(0, _ENABLE_REG, 0xff);
+  psgWrite(1, _ENABLE_REG, 0xff);
 }
 

sound-driver/psg.h

@@ -39,8 +39,8 @@ typedef enum {
 
 void psgInit();
 
-void psgPlayTone(uint8_t channel, uint8_t volume, t_octave octave, t_note note);
-void psgAmplitude(uint8_t channel, uint8_t volume);
+void psgPlayTone(uint8_t chip, uint8_t channel, uint8_t volume, t_octave octave, t_note note);
+void psgAmplitude(uint8_t chip, uint8_t channel, uint8_t volume);
 
 
 #endif // _PSG_H_

sound-driver/scheduler.h

@@ -6,7 +6,7 @@
 
 
 
-#define MAX_NUM_OF_TASKS 8
+#define MAX_NUM_OF_TASKS 4
 
 
 typedef struct {

sound-driver/sequencer.c

@@ -6,28 +6,36 @@
 #include "psg.h"
 
 
+uint8_t slots;
 
 void sequencerInit() {
+  slots = 0;
 }
 
-void sequencerExec(void *handle) {  
-  static uint16_t lengths[e_L_LengthEnd];
-  t_melodies *melodies = (t_melodies*) handle;
-
-  if (melodies->firstRun) {
-    melodies->firstRun = false;
-
-    lengths[e_L_1_4]  = 60000 / melodies->pace; // duration of a 1/4 tone in ms
-    lengths[e_L_1_2]  = lengths[e_L_1_4] << 1;
-    lengths[e_L_1]    = lengths[e_L_1_4] << 2;
-    lengths[e_L_1_8]  = lengths[e_L_1_4] >> 1;
-    lengths[e_L_1_16] = lengths[e_L_1_4] >> 2;
-    lengths[e_L_1_32] = lengths[e_L_1_4] >> 4;
-
-    for (uint8_t i = 0; i < e_L_LengthEnd; i++) {
-      lengths[i] /= SEQUENCER_PERIOD;
-    }
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wswitch"
+#pragma GCC diagnostic ignored "-Wreturn-type"
+static uint16_t calcLength(t_melodies *m, t_noteLength l) {
+  switch (l) {
+    case e_L_1:
+      return m->quarterLength << 2;
+    case e_L_1_2:
+      return m->quarterLength << 1;
+    case e_L_1_4:
+      return m->quarterLength;
+    case e_L_1_8:
+      return m->quarterLength >> 1;
+    case e_L_1_16:
+      return m->quarterLength >> 2;
+    case e_L_1_32:
+      return m->quarterLength >> 4;
   }
+}
+#pragma GCC diagnostic pop
+
+
+void sequencerExec(void *handle) {  
+  t_melodies *melodies = (t_melodies*) handle;
 
   for (uint8_t channel = 0; channel < melodies->numOfMelodies; channel++) {
     t_melody *melody = &(melodies->melodies[channel]);
@@ -43,12 +51,18 @@ void sequencerExec(void *handle) {
           }
           melodies->sync -= 1;
           melody->state = e_Sync;
+        } else if (melody->tones[melody->idx].length == e_L_HoldMark) {
+          melody->state = e_Hold;
+        } else if (melody->tones[melody->idx].length == e_L_StopMark) {
+          melody->state = e_Terminate;
         } else {
           if (melody->tones[melody->idx].length == e_L_EndMark) {
             melody->idx = 0;
           }
-          psgPlayTone(channel, melody->amplitude, melody->tones[melody->idx].octave, melody->tones[melody->idx].note);
-          melody->lengthCnt = (melody->tones[melody->idx].staccato) ? (lengths[melody->tones[melody->idx].length] / 2) : lengths[melody->tones[melody->idx].length];
+          psgPlayTone(melody->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);
           melody->state = e_HoldTone;
         }
         break;
@@ -64,8 +78,8 @@ void sequencerExec(void *handle) {
         }
         break;
       case e_StaccatoBreak:
-        psgPlayTone(channel, 0, e_O_Null, e_Pause);
-        melody->lengthCnt = lengths[melody->tones[melody->idx].length] / 2;
+        psgPlayTone(melody->chip, channel, 0, e_O_Null, e_Pause);
+        melody->lengthCnt = calcLength(melodies, melody->tones[melody->idx].length) / 2;
         melody->state = e_HoldStaccatoBreak;
         break;
       case e_HoldStaccatoBreak:
@@ -76,24 +90,40 @@ void sequencerExec(void *handle) {
         break;
       case e_SeparateTone:
         if (! (melody->tones[melody->idx].legato)) {
-          psgPlayTone(channel, 0, e_O_Null, e_Pause);
+          psgPlayTone(melody->chip, channel, 0, e_O_Null, e_Pause);
         }
         melody->idx += 1;
         melody->state = e_PlayTone;
         break;
+      case e_Hold:
+        break;
+      case e_Terminate:
+        schDel(melodies->taskId);
+        slots &= ~(melodies->slotMask);
+        break;
     }
   }
 }
 
-uint16_t sequencerPlayMelodies(t_melodies *melodies) {
+void sequencerPlayMelodies(t_melodies *melodies) {
+  if ((slots & melodies->slotMask) != 0) {
+    return;
+  }
+
+  slots |= melodies->slotMask;
   for (uint8_t i = 0; i < NUM_OF_CHANNELS; i++) {
     melodies->melodies[i].idx = 0;
     melodies->melodies[i].lengthCnt = 0;
     melodies->melodies[i].state = e_Init;
   }
   melodies->sync = 0;
-  melodies->firstRun = true;
+  melodies->quarterLength = 60000 / melodies->pace / SEQUENCER_PERIOD; // duration of a 1/4 tone in ms
 
-  return schAdd(sequencerExec, (void*) melodies, 0, SEQUENCER_PERIOD);
+  melodies->taskId = schAdd(sequencerExec, (void*) melodies, 0, SEQUENCER_PERIOD);
+}
+
+void sequencerStopMelodies(t_melodies *melodies) {
+  slots &= ~(melodies->slotMask);
+  schDel(melodies->taskId);
 }
 

sound-driver/sequencer.h

@@ -14,6 +14,8 @@ typedef enum {
   e_L_1_16 = 4,
   e_L_1_32 = 5,
   e_L_LengthEnd = 6,
+  e_L_HoldMark = 252,
+  e_L_StopMark = 253,
   e_L_EndMark = 254,
   e_L_SyncMark = 255,
 } t_noteLength;
@@ -33,11 +35,14 @@ typedef enum {
   e_HoldTone, 
   e_StaccatoBreak,
   e_HoldStaccatoBreak,
-  e_SeparateTone 
+  e_SeparateTone,
+  e_Hold,
+  e_Terminate
 } t_sequencerState;
 
 typedef struct {
   uint16_t idx;
+  uint8_t chip;
   uint16_t lengthCnt;
   t_sequencerState state;
   uint8_t amplitude;
@@ -47,15 +52,17 @@ typedef struct {
 #define SEQUENCER_PERIOD 4 // ms
 #define NUM_OF_CHANNELS 3
 typedef struct {
+  uint8_t slotMask;
+  uint8_t taskId;
+  uint16_t quarterLength;
   uint8_t numOfMelodies;
-  bool firstRun;
   uint8_t pace; // quarter notes per minute
   uint8_t sync;
   t_melody melodies[NUM_OF_CHANNELS];
 } t_melodies;
 
 void sequencerInit();
-uint16_t sequencerPlayMelodies(t_melodies *melodies);
-
+void sequencerPlayMelodies(t_melodies *melodies);
+void sequencerStopMelodies(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

@@ -0,0 +1,14 @@
+#ifndef _SOUND_CODES_H_
+#define _SOUND_CODES_H_
+
+#define SOUND_IDLE 0x00
+#define SOUND_MUTE 0x01
+#define SOUND_UNMUTE 0x02
+#define SOUND_START 0x04
+#define SOUND_GAMEOVER 0x08
+#define SOUND_FANFARE 0x10
+#define SOUND_LOCK 0x20
+#define SOUND_MOTION 0x40
+#define SOUND_SPEED_UP 0x80
+
+#endif // _SOUND_CODES_H_

sound-driver/spi.S

@@ -0,0 +1,70 @@
+#include <msp430g2553.h>
+#include "soundCodes.h"
+
+  .section ".data"
+  .global cmd
+cmd:
+  .byte   
+
+  .section ".text","ax",@progbits
+receive_isr:
+  bit     #UCB0RXIFG, &UC0IFG
+  jz      receive_isr_no_data
+  bis     UCB0RXBUF, &cmd
+receive_isr_no_data:
+  reti
+
+  .global spiCmdHandler
+spiCmdHandler:
+spiCmdHandler_1:
+  bit     #SOUND_MUTE, &cmd
+  jz      spiCmdHandler_2
+  call    #mute
+  bic     #SOUND_MUTE, &cmd
+spiCmdHandler_2:
+  bit     #SOUND_UNMUTE, &cmd
+  jz      spiCmdHandler_3
+  call    #unMute
+  bic     #SOUND_UNMUTE, &cmd
+spiCmdHandler_3:
+  bit     #SOUND_START, &cmd
+  jz      spiCmdHandler_4
+  call    #playMelodyTetris
+  bic     #SOUND_START, &cmd
+spiCmdHandler_4:
+  bit     #SOUND_GAMEOVER, &cmd
+  jz      spiCmdHandler_5
+  ;; insert a call here
+  bic     #SOUND_GAMEOVER, &cmd
+spiCmdHandler_5:
+  bit     #SOUND_FANFARE, &cmd
+  jz      spiCmdHandler_6
+  call    #playTusch1
+  bic     #SOUND_FANFARE, &cmd
+spiCmdHandler_6:
+  bit     #SOUND_LOCK, &cmd
+  jz      spiCmdHandler_7
+  ;; insert a call here
+  bic     #SOUND_LOCK, &cmd
+spiCmdHandler_7:
+  bit     #SOUND_MOTION, &cmd
+  jz      spiCmdHandler_8
+  ;; insert a call here
+  bic     #SOUND_MOTION, &cmd
+spiCmdHandler_8:
+  bit     #SOUND_SPEED_UP, &cmd
+  jz      spiCmdHandler_end
+  ;; insert a call here
+  bic     #SOUND_SPEED_UP, &cmd
+spiCmdHandler_end:
+  ret
+
+ 
+
+
+
+  .section "__interrupt_vector_8","ax",@progbits
+  .word   receive_isr
+
+
+  .end

sound-driver/spi.c

@@ -1,29 +0,0 @@
-#include <msp430g2553.h>
-#include "spi.h"
-
-
-void __attribute__ ((interrupt (USCIAB0RX_VECTOR))) receive() {
-  if (UC0IFG & UCB0RXIFG) {
-    // receive an octet
-  }
-}
-
-
-void spiInit() {
-  // SPI slave
-  // BIT4: UCB0STE
-  // BIT5: UCB0CLK
-  // BIT6: UCB0SOMI
-  // BIT7: UCB0SIMO
-  P1SEL |= BIT4 | BIT5 | BIT6 | BIT7;
-  P1SEL2 |= BIT4 | BIT5 | BIT6 | BIT7;
-
-  // most significant bit first, enable STE
-  UCB0CTL0 = UCSYNC | UCMSB | UCMODE_2;
-  UCB0CTL1 = 0x00;
-
-  // enable RX interrupt
-  UC0IE |= UCB0RXIE;
-}
-
-

sound-driver/spi.h

@@ -3,7 +3,7 @@
 
 
 void spiInit();
-
+void spiCmdHandler();
 
 
 #endif // _SPI_H_

sound-driver/spi_init.c

@@ -0,0 +1,31 @@
+#include <stddef.h>
+#include <msp430g2553.h>
+#include <stdint.h>
+#include "scheduler.h"
+#include "spi.h"
+#include "soundCodes.h"
+
+
+extern uint8_t cmd;
+
+void spiInit() {
+  // SPI slave
+  // BIT4: UCB0STE
+  // BIT5: UCB0CLK
+  // BIT6: UCB0SOMI
+  // BIT7: UCB0SIMO
+  P1SEL |= BIT4 | BIT5 | BIT7;
+  P1SEL2 |= BIT4 | BIT5 | BIT7;
+
+  // most significant bit first, enable STE
+  UCB0CTL0 = UCCKPH | UCSYNC | UCMSB | UCMODE_2;
+  UCB0CTL1 = 0x00;
+
+  // enable RX interrupt
+  UC0IE |= UCB0RXIE;
+
+  cmd = SOUND_IDLE;
+  schAdd(spiCmdHandler, NULL, 0, 100);
+}
+
+