Difference between revisions of "F21: Flame Over"

Revision as of 04:45, 18 December 2021

Abstract

Flame Over is a single-player mode game where the player moves a fire fighter to destroy the fire flames that come shooting at the player using a water gun. The player is granted four lives at the start of the game at each level. The Player’s lives will decrease by one for every three flames that touch the fire fighter. The player transits to the next level when enough flames are destroyed at each level. The speed of the flames approaching the fire fighter varies between levels. If the fireman loses all the lives, player loses. If enough flames are destroyed at the end of level 3, player wins.

Objectives & Introduction

Game Console

Objectives

• Write driver module to display game characters and update the display continuously at an optimum refresh rate
• Implement game algorithm for movement of player and flames in real-time, generate water splash bullets.
• Implement player lives count, player health and collision algorithms.
• Write driver module to receive directions from the input device (joystick) via zigbee.
• Fetch Joystick data over ADC and transmit the joystick signals wirelessly via Zigbee with the help of UART drivers.
• Write driver module to play game sounds via MP3 encoder
• Use FreeRTOS tasks and understand task priority and synchronization.

Team Members & Responsibilities

• Naveena Sura
  • Game logic and design
  • Game implementation
  • Built game characters on LED matrix display
  • Game Animation Screens
  • Bug fixes and optimizations
  • Hardware wiring and assembly
• Suganya Nandakumar
  • GPIO Driver for LED matrix display
  • Built game characters on LED matrix display
  • PCB Schematic and Board Design
  • Component Integration on PCB
  • Hardware wiring and assembly
  • 3D case design and packaging
• Vaidehi Deshpande
  • Joystick Interfacing - ADC driver
  • Speaker and MP3 Decoder interfacing
  • Zigbee interfacing with UART driver for transmission and reception
  • Built game characters on LED matrix display
  • Component Integration on PCB
  • Hardware wiring and assembly

Schedule

Parts List & Cost

Design & Implementation

Pin Configuration

LED Matrix

A 64x64 RGB LED Matrix Panel is used as the display for this game. It has 64 rows and 64 columns. It is divided into two 32x64 sections. Each LED pixel can be accessed and controlled individually. A decoder is used to access individual row. One row can be selected at a time using A,B,C,D and E pins. This enables us to select one row in each of the 32X64 sections. Columns are controlled using shift registers, every bit in the shift register controls the corresponding column. On every falling edge of the clock pulse, the values at R1, B1, G1, R2, B2, and G2 pins are stored into the shift register and the register shifts the data by one bit. After this, the data on the shift register is passed onto the individual LED's when both OE and LE pins are set to high.

LED Matrix front View

LED Matrix rear View

MP3 Serial Player:

MP3 Serial Player module is a simple MP3 player device which is based on a high quality MP3 audio chip. It can support 8kHz - 48kHz sampling frequency MP3 and WAV file formats. Also, this board has a TF card socket so that a SD card can be inserted that stores audio files. SJTwo board can control this module via UART port, such as switch songs, change the volume and play mode, and so on.

The SD card should be formatted as FAT16 or FAT32 and should have some audio files with .mp3 or .wav formats. If the user wants to create separate folders then those should be created as “01”, “02” and the songs should be with the names 001xxx.mp3/ 002xxx.mp3/ 003xxx.mp3 in those created folders.

MP3 and SJTwo Board interface

Software Implementation:

The module communicates with the microcontroller through commands which are a combination of data and cmd fields. The cmd field allows us to control the module. Commands are available for the functions like Play NEXT_SONG, PREV_SONG, PLAY_WITH_INDEX, etc. The data field is required, the data field is required; this is noted, otherwise it is set to zero and ignored., otherwise it is set to zero and ignored.

Below is the command list followed for this project:

Next_song 0x01 Play next song. Prev_song 0x02 Play previous song. Play_with_index 0x03 Play song with index number. Data is the index of the file. Volume_up 0x04 Volume increase by one. Volume_down 0x05 Volume decrease by one. Set_volume 0x06 Set the volume to level specified. Data is the volume level [0..30]. Set_equalizer 0x07 Set the equalizer to specified level. Data is [0..5] – 0=normal, 1=pop, 2=rock, 3=jazz, 4=classic or 5=base. Sng_cycl_play 0x08 Loop play (repeat) specified track. Data is the track number. Sel_dev 0x09 Select file storage device. The only valid choice for data is tf (0x02). Sleep_mode 0x0a Chip enters sleep mode. Wake_up 0x0b Chip wakes up from sleep mode. Reset 0x0c Chip reset. Play 0x0d Playback restart. Pause 0x0e Pause playback. Play_folder_file 0x0f Play the file with the specified folder and index number Stop_play 0x16 Stop playback. Folder_cycle 0x17 Loop playback within specified folder. Data is the folder index. Shuffle_play 0x18 Playback shuffle mode. Data is 0 to enable, 1 to disable. Set_sngl_cycl 0x19 Set loop play (repeat) on/off for current file. Data is 0 to enable, 1 to disable. Set_dac 0x1a Dac on/off control (mute sound). Data is 0 to enable dac, 1 to disable dac (mute). Play_w_vol 0x22 Play track at the specified volume. Data hi byte is the track index, low byte is the volume level [0..30]. Shuffle_folder 0x28 Playback shuffle mode for folder specified. Data high byte is the folder index. Code Snippet of MP3 module:

void MP3__command(uint8_t command, uint16_t dat) {

 MP3_buffer[0] = 0x7e;                // starting byte
 MP3_buffer[1] = 0xff;                // version
 MP3_buffer[2] = 0x06;                // the number of bytes of the command without starting byte and ending byte
 MP3_buffer[3] = command;             //
 MP3_buffer[4] = 0x00;                // 0x00 = no feedback, 0x01 = feedback
 MP3_buffer[5] = (uint8_t)(dat >> 8); // datah
 MP3_buffer[6] = (uint8_t)(dat);      // datal
 MP3_buffer[7] = 0xef;                // ending byte
 for (uint8_t i = 0; i < 8; i++)
   uart__polled_put(UART__3, MP3_buffer[i]);

}

Hardware Implementation

Block Diagram

We used two SJ2 boards for this project. One main SJ2 board to drive the LED Matrix Display and the MP3 Decoder, another SJ2 board to collect the control signals from the Analog Joystick connected to it. These signals are wirelessly transmitted from this board to the main SJ2 board driving the LED Display. This communication is achieved using Zigbee over UART.

Universal Asynchronous Receiver Transmitter (UART) is also used as an interface to connect the main SJ2 board and MP3 Serial Player. UART_3 is configured for YX5300 MP3 player. Below is the pinout connections between UART and MP3 Serial Player:

Software Design and Implementation

Game Start screen

At the start of the game, a welcome screen is continously displayed until the player is ready and presses the start key. Only on start key press, the freertos game logic tasks are scheduled.

Game Design and tasks

We used six freertos tasks of different priorities to control the course of the game:

• Game display Task
  • Refreshes the screen ie., it clears and updates the screen every 3 milliseconds.
  • Draws all the game characters ie., fireman, flames and fireman lives periodically every 3 milliseconds.
  • Implements logic to check for level ups, game win or lose status.
  • Checks if the fireman was able to successfully put the flames off or if the flames hit the fireman and updates the count of fireman lives based on this.

• Fireman Task
  • Keeps track of the direction control data transmitted wirelessly from the joystick device from the other board and accordingly updates Fireman position.
  • Also has a logic to update water splash trigger flag when the joystick key press signal is received.

• Water Splash Task
  • Reads the water splash trigger flag that has been updated in ‘Fireman Task’ and controls the movement of water splash bullets.
  • Plays a water bullet sound track every time water splash bullets are released.

• Flame1 Task and Flame2 Task
  • Generates Flames on two horizontal tracks from the left and move them towards the right end unless striked by a water bullet, in which case, the flames burst and are put off.
  • Generates random starting row positions for each of these flames.
  • Controls the speed of movement of these flames based on the game level.
  • Decrements the fireman health every time the fireman is hit by a flame.

Collision detection:

• Flame to Water bullet Collision
  • When the water bullet hits the flames, the bullets and flames disappear on the screen indicating the flame was successfully put off. The number of flames put off is incremented for level up and respective flags are set. Burst animation is played at the collision.

• Fireman to Flame Collision
  • When the flame hits the fireman for 3 times, fireman's health reduced by 1. Burst animation is played at the collision. And once the fireman's health reduces to 20 from the initial 100, the player loses all lives and loses the game.

Printed Circuit Board

Layout & Design

We have designed our Printed Circuit Board using 'AUTODESK EAGLE software', version 9.6.2.The lecture on Eagle PCB provided by Professor Preet provided a good insight about using this software and building a PCB. As suggested during the lecture, we followed Sparkfun Eagle tutorials and libraries while working on the PCB. These resources served as a good source of information for us and made our work easy.

For PCB fabrication, we selected the PCB manufacturer 'JLCPCB' because their production lead-time was less compared to other manufacturers. They had an efficient customer service and faster delivery option that helped us to get our PCBs on time.

Schematic and Board Design of PCB

      1. We created a common PCB design for both of our SJ2 Boards.  
      2. The following connectors were used to design a schematic for our design
                 •LED Matrix        - 10-pin series 057 contact pc board low profile headers
                 •SJ2 Board         - 40-pin series 057 contact pc board low profile headers
                 •Joystick          - 5 pin header
                 •MP3 Serial Player - 4 pin header
                 •Xbee              - Adafruit library Xbee Module

Eagle Board Layout

PCB Layout - Top Layer

PCB Layout - Bottom Layer

3D Packaging

Testing & Technical Challenges

This section includes information about testing and the technical challenges we faced while developing this project

• Technical Challenges

Flickering of data - Finding a good refresh rate was crucial for the display. The screen ended up flickering for few refresh rates. The task design had to be curated and the refresh rate had to be reevaluated to mitigate flickering. In the initial stages of familiarizing with the LED matrix display, we observed random pixels being lit instead of the desired ones. We referred to online sources to see what we were doing wrong. We later changed our initializing sequence and it started working fine.

SD card formatting and file structure - Songs are referenced by folder and by song ‘index’, although it seems that the numeric index is sometimes ignored and the songs played in the order they are stored in the SD card. The documentation is unclear on this and seems to imply both situations. So, even if you plan only one playlist, it is better to keep them in a ’01’ folder and save all the songs to the SD card at the same time.

Exhausting UART peripherals -

We initially planned of using only one SJ2 board for the driving the LED, Music and Joystick. But we exhausted the UART peripherals on the SJ2 board with LED Matrix display pins and MP3 Decoder. So we used another SJ2 board to wirelessly transmit the joystick signals to the main board over zigbee.

Finding game sounds to suit our game took a while, as we were looking for free sounds and many websites were selling it for price.

Conclusion

Working on this project has helped us gain hands-on experience in working with real time systems. We implemented various concepts that we learned in our class. We developed ADC, UART, GPIO drivers on ARM based microcontroller. Working with FreeRTOS tasks we understood the importance of various factors such as semaphores, task priority, task delay. Even though we faced many challenges working hard to solve them was truly rewarding. Apart from technical knowledge we learned other skills such as teamwork, using GIT for version control, debugging etc.

Project Video

Project Demonstration Link

Project Source Code

• Sourceforge Source Code Link

References

Acknowledgement

We would like to thank our Professor Preetpal Kang for designing a great course which really engages the students and is thought provoking. We'd also like to thank our ISA team for being there whenever we were stuck on various stages of this course and timely help with the Project. Finally, the credit goes to our entire team, Flame Over. With full support and cooperation from each other, we were successfully able to complete this project as planned.

References Used

• RGB Panel Hookup Guide 1
• FreeRTOS documentations
• AutoDesk Eagle Software Tutorial
• WikiPage by Preetpal Kang
• MP3 commands