Welcome to Hackster!
Hackster is a community dedicated to learning hardware, from beginner to pro. Join us, it's free!
droraha
Published

DM Console (D&D)

When your first Arduino project is to build a moon lander, or more exactly a genuine working product.

AdvancedFull instructions provided1,988
DM Console (D&D)

Things used in this project

Hardware components

Arduino UNO
Arduino UNO
×1
Arduino Nano R3
Arduino Nano R3
×1
Alphanumeric LCD, 20 x 4
Alphanumeric LCD, 20 x 4
×1
Sensor Shield V5 Arduino Uno
×1
Sensor Shield Arduino Nano
×1
YX6300 UART TTL serial MP3 music player module
×1
Jumper wires (generic)
Jumper wires (generic)
×1
MB-102 MB102 power module
×1
Flash Memory Card, SD Card
Flash Memory Card, SD Card
×2
Micro SD TF Card Module SPI For Arduino
×1
SparkFun Solder-able Breadboard - Mini
SparkFun Solder-able Breadboard - Mini
×6
Connector Kit, Wire To Wire
Connector Kit, Wire To Wire
×1

Hand tools and fabrication machines

Laser cutter (generic)
Laser cutter (generic)
3D Printer (generic)
3D Printer (generic)
Soldering iron (generic)
Soldering iron (generic)
Solder Wire, Lead Free
Solder Wire, Lead Free

Story

Read more

Custom parts and enclosures

front panel

Front panel

Buttons

STL files for all the buttons I 3D printed
(the button with the dragon for the RND monster has 2 vertions)

Schematics

complete circuit

This is the complete circuit sketch.
(I used a BlueTooth module to represent the XY6300 UART TTL MP3 module)
The power module is connected to the Vin and GND of both Arduinos.
The buttons arranged in one row for simplicity,

Code

LCD

Arduino
powering the LCD by the intended buttons
//BUG - the screen freezes after several seconds
//Compatible with the Arduino IDE 1.0
//Library version:1.1
// this code is a DM consul - 1 button shows on LCD 5 random D20 result , 2nd button shows a random speel (from SD card), 3rd button shows a random monster (from SD card).
// 4 - random DM decision, 5 -random magic item, 6 -random NPC (race + trait), 7 - random gold treasure (1-500)
#include <Wire.h> 
#include <LiquidCrystal_I2C.h>
#include <SPI.h>
#include <SD.h>
File myFile;
int LCD_colums = 20;
int LCD_rows = 4;
LiquidCrystal_I2C lcd(0x3F,LCD_colums,LCD_rows);  // set the LCD address to 0x3F for a 20 chars and 4 line display
int n=0;
int rnd=0;
int DLY=0;
// defining string arrays of races
char *race[22] = {"Dwarf", "Elf", "Halfling" , "Human" , "Gnome" ,"Half-orc" , "Dragonborn", "Tiefling", "Aasimar", "Warforged", 
              "Yuan-ti-Pureblood", "Triton", "Goliath", "Tabaxi", "Half-Elf" , "LizardFolk", "Genasi" , "Aarakocra" ,"Bugbear" , "Kenku", "Githyanki", "Tortle"};


// spell char per row = 34
//int LineLength = 34;
// constants won't change. They're used here to set pin numbers:
const int BUTTON_PIN_D20 = 7; // the number of the d20 pushbutton pin
const int BUTTON_PIN_SPELL = 6; // the number of the spell pushbutton pin
const int BUTTON_PIN_MONSTER = 8; // the number of the monster pushbutton pin
const int BUTTON_PIN_DM = 9; // the number of the DM decision pushbutton pin
const int BUTTON_PIN_item = 5; // the number of the Magic items pushbutton pin
const int BUTTON_PIN_NPC = 4; // the number of the NPC characters pushbutton pin
const int BUTTON_PIN_gold = 3; // the number of the NPC characters pushbutton pin


// Variables will change:

int currentStateD20;    // the current reading from the input pin
int currentStateSPELL;    // the current reading from the input pin
int currentStateMONSTER;
int currentStateDM;    // the current reading from the input pin
int currentStateitem;    // the current reading from the input pin
int currentStateNPC;    // the current reading from the input pin
int currentStategold;    // the current reading from the input pin

void setup()
{
  // initialize serial communication at 9600 bits per second:
  Serial.begin(9600);
  lcd.init();                      // initialize the lcd 
  // Print a message to the LCD.
  lcd.backlight();
  lcd.setCursor(0,1);
  lcd.print(F("Hello, DM Yoni Zabow"));
    // initialize the pushbutton pin as an pull-up input
  // the pull-up input pin will be HIGH when the switch is open and LOW when the switch is closed.
  pinMode(BUTTON_PIN_D20, INPUT_PULLUP);
  pinMode(BUTTON_PIN_SPELL, INPUT_PULLUP);
  pinMode(BUTTON_PIN_MONSTER, INPUT_PULLUP);
  pinMode(BUTTON_PIN_DM, INPUT_PULLUP);
  pinMode(BUTTON_PIN_item, INPUT_PULLUP);
  pinMode(BUTTON_PIN_NPC, INPUT_PULLUP);
  pinMode(BUTTON_PIN_gold, INPUT_PULLUP);
}

// this function finds the needed line (lineNumber) in a txt file from sd card (indecated by filenmber) and shows it on the lcd screen
void printLineN(unsigned int lineNumber, unsigned int filenumber ){
  char rnd_string[LCD_colums+1] = ""; 
  rnd_string[1] = 0; 
  char cr;
  //  SD card initialization
  while (!Serial) {
  ; // wait for serial port to connect. Needed for native USB port only
  }
  Serial.print(F("Initializing SD card..."));
  if (!SD.begin(10)) {
    Serial.println(F("initialization failed!"));
    while (1);
  }
  Serial.println(F("initialization done."));

  // finding the correct file to open
  switch (filenumber) {
    case 1: {myFile = SD.open("monsters.txt");
            break;}
    case 2: {myFile = SD.open("spells.txt");
            break;}
    case 3: {myFile = SD.open("DMD.txt");
            break;}
    case 4: {myFile = SD.open("item.txt");
            break;}
    case 5: {myFile = SD.open("NPCtrait.txt");
            break;}
  }
  myFile.seek(0);
  Serial.println(F("file opened sucssesfuly."));  
  
  // seeking the right line in the file
  for(unsigned int i = 0; i < (lineNumber -1);){
    cr = myFile.read();
    if(cr == '\n'){
      i++;
    }
  }
  int j=0; //string index
  cr = ' '; // initialization of cr to get inside while loop
  
  //Now we are at the right line
  while(cr != '\n'){ 
    cr = myFile.read();
    Serial.println(cr);
    rnd_string[j] = cr;
    j++;
    //if string is bigger than LCD max columns than print to LCD and move one row down
    if (j == LCD_colums) { 
      if (rnd_string[j] == '\n') 
         rnd_string[j-1] = 0;
      else if (rnd_string[j] == '\r') 
         rnd_string[j-1] = 0;
      lcd.setCursor(0,1);
      //print first row
      lcd.print(rnd_string);
      // zero the string and the counter
      rnd_string[0] = 0;
      j=0;
    }
  }
      //closing the string without \n\r which adds unwanted char in the end
      rnd_string[j-2] = 0;
      lcd.setCursor(0,2);
      //printing the string to LCD
      lcd.print(rnd_string);
      // close the file:
      myFile.close();
}

void loop()
{
  if (DLY == 7000){
    DLY = 0;
    lcd.clear();
    lcd.setCursor(0,1);
    lcd.print(F("Hello, DM Yoni Zabow"));
  }
  // read the state of the switch/button:
  currentStateD20 = digitalRead(BUTTON_PIN_D20);
  if(currentStateD20 == LOW) 
  {
  lcd.clear();
  lcd.setCursor(1,0);
  lcd.print(F("5 X D20 roll"));
  lcd.setCursor(0,2);
  lcd.print(random(1, 21));
  lcd.setCursor(3,2);
  lcd.print(random(1, 21));
  lcd.setCursor(6,2);
  lcd.print(random(1, 21));
  lcd.setCursor(9,2);
  lcd.print(random(1, 21));
  lcd.setCursor(12,2);
  lcd.print(random(1, 21));
  DLY = 0;
  }
  // read the state of the switch/button:
  currentStateSPELL = digitalRead(BUTTON_PIN_SPELL);
  if(currentStateSPELL == LOW)
  {
   lcd.clear();
   lcd.setCursor(0,0); 
   lcd.print(F("RND Spell Name&LVL:"));
   rnd = random(1, 460);
   Serial.println(rnd);
   printLineN(rnd,2);
   DLY = 0;
  }
 currentStateMONSTER = digitalRead(BUTTON_PIN_MONSTER);
 if(currentStateMONSTER == LOW)
  {
   lcd.clear();
   lcd.setCursor(0,0); 
   lcd.print(F("Monster Name|AC|HP:"));
   rnd = random(1, 507);
   Serial.println(rnd);
   printLineN(rnd,1);
   DLY = 0;
  }
   currentStateDM = digitalRead(BUTTON_PIN_DM);
 if(currentStateDM == LOW)
  {
   lcd.clear();
   lcd.setCursor(0,0); 
   lcd.print(F("RND DM Decision:"));
   rnd = random(1, 25);
   Serial.println(rnd);
   printLineN(rnd,3);
   DLY = 0;
  }
   currentStateitem = digitalRead(BUTTON_PIN_item);
 if(currentStateitem == LOW)
  {
   lcd.clear();
   lcd.setCursor(0,0); 
   lcd.print(F("RND Magic item:"));
   rnd = random(1, 240);
   Serial.println(rnd);
   printLineN(rnd,4);
   DLY = 0;
  }
     currentStateNPC = digitalRead(BUTTON_PIN_NPC);
 if(currentStateNPC == LOW)
  {
   lcd.clear();
   lcd.setCursor(0,0); 
   lcd.print(F("RND NPC Trait:"));
   rnd = random(1, 1389);
   Serial.println(rnd);
   printLineN(rnd,5);
   lcd.setCursor(0,3); 
   lcd.print("Race: ");
   lcd.setCursor(6,3);
   rnd = random(0, 21); 
   lcd.print(race[rnd]);
   DLY = 0;
  }
  currentStategold = digitalRead(BUTTON_PIN_gold);
 if(currentStategold == LOW)
  {
   lcd.clear();
   lcd.setCursor(0,0); 
   lcd.print(F("RND Gold treature:"));
   rnd = random(1, 501);
   Serial.println(rnd);
   lcd.setCursor(0,2); 
   lcd.print(rnd);
   DLY = 0;
  }
  DLY++;
  Serial.println(DLY);
}

MP3

Arduino
// COPYIED FROM: https://create.arduino.cc/projecthub/moreirarobotics/how-to-use-the-yx5300-mp3-module-catalex-with-arduino-171a23
// Edited by Dror Moshe Aharoni

// pins connection: 7-12 - music buttons, 5 to mp3 TX, 6 to MP3 RX
#include <SoftwareSerial.h>

#define ARDUINO_RX 5  //should connect to TX of the Serial MP3 Player module
#define ARDUINO_TX 6  //connect to RX of the module

SoftwareSerial mp3(ARDUINO_RX, ARDUINO_TX);
//#define mp3 Serial3    // Connect the MP3 Serial Player to the Arduino MEGA Serial3 (14 TX3 -> RX, 15 RX3 -> TX)

static int8_t Send_buf[8] = {0}; // Buffer for Send commands.  // BETTER LOCALLY
static uint8_t ansbuf[10] = {0}; // Buffer for the answers.    // BETTER LOCALLY

String mp3Answer;           // Answer from the MP3.

String sanswer(void);
String sbyte2hex(uint8_t b);

int BUTTON_PIN;
int last_pushed;
int buttonState;
int currentSong = 1;
int pause = 0;

/************ Command byte **************************/
#define CMD_NEXT_SONG     0X01  // Play next song.
#define CMD_PREV_SONG     0X02  // Play previous song.
#define CMD_PLAY_W_INDEX  0X03
#define CMD_VOLUME_UP     0X04
#define CMD_VOLUME_DOWN   0X05
#define CMD_SET_VOLUME    0X06

#define CMD_SNG_CYCL_PLAY 0X08  // Single Cycle Play.
#define CMD_SEL_DEV       0X09
#define CMD_SLEEP_MODE    0X0A
#define CMD_WAKE_UP       0X0B
#define CMD_RESET         0X0C
#define CMD_PLAY          0X0D
#define CMD_PAUSE         0X0E
#define CMD_PLAY_FOLDER_FILE 0X0F

#define CMD_STOP_PLAY     0X16
#define CMD_FOLDER_CYCLE  0X17
#define CMD_SHUFFLE_PLAY  0x18 //
#define CMD_SET_SNGL_CYCL 0X19 // Set single cycle.

#define CMD_SET_DAC 0X1A
#define DAC_ON  0X00
#define DAC_OFF 0X01

#define CMD_PLAY_W_VOL    0X22
#define CMD_PLAYING_N     0x4C
#define CMD_QUERY_STATUS      0x42
#define CMD_QUERY_VOLUME      0x43
#define CMD_QUERY_FLDR_TRACKS 0x4e
#define CMD_QUERY_TOT_TRACKS  0x48
#define CMD_QUERY_FLDR_COUNT  0x4f

/************ Opitons **************************/
#define DEV_TF            0X02

/*********************************************************************/


void setup()
{
  // starting the serial communication through the mp3 object
  // The mp3 module is controlled through commands received by the Arduino serial. In this process, we used the SoftwareSerial library and emulated a serial on the Arduino digital pins.
  // Thus, you will be able to use the Arduino to control the MP3 module through commands sent to it.
  Serial.begin(9600);
  mp3.begin(9600);
  delay(500);
  // initialization of the MP3 Card module
  sendCommand(CMD_SEL_DEV, 0, DEV_TF);
  delay(500);
  
  // initialize the pushbutton pins as an pull-up input
  // the pull-up input pin will be HIGH when the switch is open and LOW when the switch is closed.
  for (BUTTON_PIN = 7; BUTTON_PIN < 13; BUTTON_PIN++){
    //BUTTON_PIN is the number of the pushbutton pin
    pinMode(BUTTON_PIN, INPUT_PULLUP); 
  }
  sendCommand(0x06, 0 , 30);
  Serial.println("playing the greetings sound");
  sendCommand(0x03, 0 , 1);
  //delay(19000);
  delay(1000);
  last_pushed = 1;
}

//starting loop
void loop() {
  //Serial.println("start loop");
  buttonState = HIGH;
  BUTTON_PIN = 6;
  // read the state of the switch/button:
  while (buttonState == HIGH){
    BUTTON_PIN++;
    if (BUTTON_PIN == 13) BUTTON_PIN = 7;
    buttonState = digitalRead(BUTTON_PIN);
    // print out the button's state
    //Serial.println(BUTTON_PIN);
    //Serial.println(buttonState);
 }

  //Serial.println("DM pushed button:");
  //Serial.println(BUTTON_PIN);
  if (BUTTON_PIN == last_pushed){
    switch (pause) {
      case 0:
        sendCommand(0x0E);
        last_pushed = BUTTON_PIN;
        pause = 1;
        sanswer();
        break;
      case 1:
        pause = 0;
        sendCommand(0x03, 0, BUTTON_PIN-5);
        if (mp3.available()) Serial.println(decodeMP3Answer());
        break;
    }
    
  }
    
  else 
  {
    // saving the last pushed button in order to enable music pause
    last_pushed = BUTTON_PIN;
        
    // playing the desired music file
    sendCommand(0x03, 0, BUTTON_PIN-5);
    //delay(3000);

    // Check for the answer.
  if (mp3.available()) Serial.println(decodeMP3Answer());
  }

}



/********************************************************************************/
/*Function sendMP3Command: seek for a 'c' command and send it to MP3  */
/*Parameter: c. Code for the MP3 Command, 'h' for help.                                                                                                         */
/*Return:  void                                                                */

void sendMP3Command(char c) {
  
  switch (c) {
    case '?':
    case 'h':
      Serial.println("HELP  ");
      Serial.println(" p = Play");
      Serial.println(" P = Pause");
      Serial.println(" > = Next");
      Serial.println(" < = Previous");
      Serial.println(" s = Stop Play"); 
      Serial.println(" + = Volume UP");
      Serial.println(" - = Volume DOWN");
      Serial.println(" c = Query current file");
      Serial.println(" q = Query status");
      Serial.println(" v = Query volume");
      Serial.println(" x = Query folder count");
      Serial.println(" t = Query total file count");
      Serial.println(" f = Play folder 1.");
      Serial.println(" S = Sleep");
      Serial.println(" W = Wake up");
      Serial.println(" r = Reset");
      break;

    case 'p':
      Serial.println("Play ");
      sendCommand(CMD_PLAY);
      break;

    case 'P':
      Serial.println("Pause");
      sendCommand(CMD_PAUSE);
      break;

    case '>':
      Serial.println("Next");
      sendCommand(CMD_NEXT_SONG);
      sendCommand(CMD_PLAYING_N); // ask for the number of file is playing
      break;

    case '<':
      Serial.println("Previous");
      sendCommand(CMD_PREV_SONG);
      sendCommand(CMD_PLAYING_N); // ask for the number of file is playing
      break;

    case 's':
      Serial.println("Stop Play");
      sendCommand(CMD_STOP_PLAY);
      break;

    case '+':
      Serial.println("Volume Up");
      sendCommand(CMD_VOLUME_UP);
      break;

    case '-':
      Serial.println("Volume Down");
      sendCommand(CMD_VOLUME_DOWN);
      break;

    case 'c':
      Serial.println("Query current file");
      sendCommand(CMD_PLAYING_N);
      break;

    case 'q':
      Serial.println("Query status");
      sendCommand(CMD_QUERY_STATUS);
      break;

    case 'v':
      Serial.println("Query volume");
      sendCommand(CMD_QUERY_VOLUME);
      break;

    case 'x':
      Serial.println("Query folder count");
      sendCommand(CMD_QUERY_FLDR_COUNT);
      break;

    case 't':
      Serial.println("Query total file count");
      sendCommand(CMD_QUERY_TOT_TRACKS);
      break;

    case 'f':
      Serial.println("Playing folder 1");
      sendCommand(CMD_FOLDER_CYCLE, 1, 0);
      break;

    case 'S':
      Serial.println("Sleep");
      sendCommand(CMD_SLEEP_MODE);
      break;

    case 'W':
      Serial.println("Wake up");
      sendCommand(CMD_WAKE_UP);
      break;

    case 'r':
      Serial.println("Reset");
      sendCommand(CMD_RESET);
      break;
  }
}

/********************************************************************************/
/*Function decodeMP3Answer: Decode MP3 answer.                                  */
/*Parameter:-void                                                               */
/*Return: The                                                  */

String decodeMP3Answer() {
  String decodedMP3Answer = "";

  decodedMP3Answer += sanswer();

  switch (ansbuf[3]) {
    case 0x3A:
      decodedMP3Answer += " -> Memory card inserted.";
      break;

    case 0x3D:
      decodedMP3Answer += " -> Completed play num " + String(ansbuf[6], DEC);
      //sendCommand(CMD_NEXT_SONG);
      //sendCommand(CMD_PLAYING_N); // ask for the number of file is playing
      break;

    case 0x40:
      decodedMP3Answer += " -> Error";
      break;

    case 0x41:
      decodedMP3Answer += " -> Data recived correctly. ";
      break;

    case 0x42:
      decodedMP3Answer += " -> Status playing: " + String(ansbuf[6], DEC);
      break;

    case 0x48:
      decodedMP3Answer += " -> File count: " + String(ansbuf[6], DEC);
      break;

    case 0x4C:
      decodedMP3Answer += " -> Playing: " + String(ansbuf[6], DEC);
      break;

    case 0x4E:
      decodedMP3Answer += " -> Folder file count: " + String(ansbuf[6], DEC);
      break;

    case 0x4F:
      decodedMP3Answer += " -> Folder count: " + String(ansbuf[6], DEC);
      break;
  }

  return decodedMP3Answer;
}

/********************************************************************************/
/*Function: Send command to the MP3                                             */
/*Parameter: byte command                                                       */
/*Parameter: byte dat1 parameter for the command                                */
/*Parameter: byte dat2 parameter for the command                                */

void sendCommand(byte command){
  sendCommand(command, 0, 0);
}

void sendCommand(byte command, byte dat1, byte dat2){
  delay(20);
  Send_buf[0] = 0x7E;    //
  Send_buf[1] = 0xFF;    //
  Send_buf[2] = 0x06;    // Len
  Send_buf[3] = command; //
  Send_buf[4] = 0x01;    // 0x00 NO, 0x01 feedback
  Send_buf[5] = dat1;    // datah
  Send_buf[6] = dat2;    // datal
  Send_buf[7] = 0xEF;    //
  Serial.print("Sending: ");
  for (uint8_t i = 0; i < 8; i++)
  {
    mp3.write(Send_buf[i]) ;
    Serial.print(sbyte2hex(Send_buf[i]));
  }
  Serial.println();
}



/********************************************************************************/
/*Function: sbyte2hex. Returns a byte data in HEX format.                       */
/*Parameter:- uint8_t b. Byte to convert to HEX.                                */
/*Return: String                                                                */


String sbyte2hex(uint8_t b)
{
  String shex;

  shex = "0X";

  if (b < 16) shex += "0";
  shex += String(b, HEX);
  shex += " ";
  return shex;
}


/********************************************************************************/
/*Function: shex2int. Returns a int from an HEX string.                         */
/*Parameter: s. char *s to convert to HEX.                                      */
/*Parameter: n. char *s' length.                                                */
/*Return: int                                                                   */

int shex2int(char *s, int n){
  int r = 0;
  for (int i=0; i<n; i++){
     if(s[i]>='0' && s[i]<='9'){
      r *= 16; 
      r +=s[i]-'0';
     }else if(s[i]>='A' && s[i]<='F'){
      r *= 16;
      r += (s[i] - 'A') + 10;
     }
  }
  return r;
}


/********************************************************************************/
/*Function: sanswer. Returns a String answer from mp3 UART module.          */
/*Parameter:- uint8_t b. void.                                                  */
/*Return: String. If the answer is well formated answer.                        */

String sanswer(void)
{
  uint8_t i = 0;
  String mp3answer = "";

  // Get only 10 Bytes
  while (mp3.available() && (i < 10))
  {
    uint8_t b = mp3.read();
    ansbuf[i] = b;
    i++;

    mp3answer += sbyte2hex(b);
  }

  // if the answer format is correct.
  if ((ansbuf[0] == 0x7E) && (ansbuf[9] == 0xEF))
  {
    return mp3answer;
  }

  return "???: " + mp3answer;
}

Credits

droraha
0 projects • 0 followers
Contact

Comments

Please log in or sign up to comment.