diff options
| author | Yuval Adam <yuv.adm@gmail.com> | 2014-06-29 12:34:32 +0300 |
|---|---|---|
| committer | Yuval Adam <yuv.adm@gmail.com> | 2014-06-29 12:34:32 +0300 |
| commit | c3e4c9a25c2910d2d66d52215b3406b13d5b23d5 (patch) | |
| tree | added370d1e356901f8579f076e3263fb0464db7 /boards/dk-tm4c129x/synth/synth.c | |
| parent | 990090a4cc9070837d31e66b58d40f0c3d038741 (diff) | |
Add more board models
Diffstat (limited to 'boards/dk-tm4c129x/synth/synth.c')
| -rw-r--r-- | boards/dk-tm4c129x/synth/synth.c | 1438 |
1 files changed, 1438 insertions, 0 deletions
diff --git a/boards/dk-tm4c129x/synth/synth.c b/boards/dk-tm4c129x/synth/synth.c new file mode 100644 index 0000000..7a59e3b --- /dev/null +++ b/boards/dk-tm4c129x/synth/synth.c @@ -0,0 +1,1438 @@ +//*****************************************************************************
+//
+// synth.c - A single-octave synthesizer to demonstrate the use of the sound
+// driver.
+//
+// Copyright (c) 2013-2014 Texas Instruments Incorporated. All rights reserved.
+// Software License Agreement
+//
+// Texas Instruments (TI) is supplying this software for use solely and
+// exclusively on TI's microcontroller products. The software is owned by
+// TI and/or its suppliers, and is protected under applicable copyright
+// laws. You may not combine this software with "viral" open-source
+// software in order to form a larger program.
+//
+// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS.
+// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT
+// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY
+// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL
+// DAMAGES, FOR ANY REASON WHATSOEVER.
+//
+// This is part of revision 2.1.0.12573 of the DK-TM4C129X Firmware Package.
+//
+//*****************************************************************************
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "inc/hw_memmap.h"
+#include "inc/hw_types.h"
+#include "driverlib/gpio.h"
+#include "driverlib/rom.h"
+#include "driverlib/rom_map.h"
+#include "driverlib/sysctl.h"
+#include "grlib/grlib.h"
+#include "grlib/widget.h"
+#include "utils/sine.h"
+#include "drivers/frame.h"
+#include "drivers/kentec320x240x16_ssd2119.h"
+#include "drivers/pinout.h"
+#include "drivers/sound.h"
+#include "drivers/touch.h"
+
+//*****************************************************************************
+//
+//! \addtogroup example_list
+//! <h1>Synthesizer (synth)</h1>
+//!
+//! This application provides a single-octave synthesizer utilizing the touch
+//! screen as a virtual piano keyboard. The notes played on the virtual piano
+//! are played out via the on-board speaker.
+//
+//*****************************************************************************
+
+//*****************************************************************************
+//
+// The colors used to draw the white keys.
+//
+//*****************************************************************************
+#define ClrWhiteKey 0xcfcfcf
+#define ClrWhiteBright 0xffffff
+#define ClrWhiteDim 0x9f9f9f
+
+//*****************************************************************************
+//
+// The colors used to draw the black keys.
+//
+//*****************************************************************************
+#define ClrBlackKey 0x000000
+#define ClrBlackBright 0x606060
+#define ClrBlackDim 0x303030
+
+//*****************************************************************************
+//
+// The color used to draw a pressed key.
+//
+//*****************************************************************************
+#define ClrPressed 0x3f3fbf
+
+//*****************************************************************************
+//
+// The width and height of the white keys. The width should be an even number.
+//
+//*****************************************************************************
+#define WHITE_WIDTH 36
+#define WHITE_HEIGHT 190
+
+//*****************************************************************************
+//
+// The width and height of the black keys. The width should be a multiple of
+// four.
+//
+//*****************************************************************************
+#define BLACK_WIDTH 26
+#define BLACK_HEIGHT 110
+
+//*****************************************************************************
+//
+// The screen offset of the upper left hand corner of the keyboard.
+//
+//*****************************************************************************
+#define X_OFFSET 16
+#define Y_OFFSET 32
+
+//*****************************************************************************
+//
+// A structure that describes a key on the keyboard.
+//
+//*****************************************************************************
+typedef struct
+{
+ //
+ // The outline of the key.
+ //
+ tRectangle sOutline;
+
+ //
+ // The first/top fill for the key.
+ //
+ tRectangle sFill1;
+
+ //
+ // The second/bottom fill for the key (not used for black keys).
+ //
+ tRectangle sFill2;
+
+ //
+ // The frequency of the note produced by this key.
+ //
+ uint32_t ui32Freq;
+}
+tKey;
+
+//*****************************************************************************
+//
+// The white keys on the keyboard.
+//
+//*****************************************************************************
+static const tKey g_psWhiteKeys[] =
+{
+ //
+ // C4
+ //
+ {
+ //
+ // Outline
+ //
+ {
+ X_OFFSET,
+ Y_OFFSET,
+ X_OFFSET + WHITE_WIDTH - 1,
+ Y_OFFSET + WHITE_HEIGHT - 1
+ },
+
+ //
+ // Top fill
+ //
+ {
+ X_OFFSET + 2,
+ Y_OFFSET + 2,
+ X_OFFSET + WHITE_WIDTH - ((BLACK_WIDTH * 3) / 4) - 1,
+ Y_OFFSET + BLACK_HEIGHT - 1
+ },
+
+ //
+ // Bottom fill
+ //
+ {
+ X_OFFSET + 2,
+ Y_OFFSET + BLACK_HEIGHT,
+ X_OFFSET + WHITE_WIDTH - 3,
+ Y_OFFSET + WHITE_HEIGHT - 3
+ },
+
+ //
+ // Frequency
+ //
+ 261
+ },
+
+ //
+ // D4
+ //
+ {
+ //
+ // Outline
+ //
+ {
+ X_OFFSET + WHITE_WIDTH,
+ Y_OFFSET,
+ X_OFFSET + (WHITE_WIDTH * 2) - 1,
+ Y_OFFSET + WHITE_HEIGHT - 1
+ },
+
+ //
+ // Top fill
+ //
+ {
+ X_OFFSET + WHITE_WIDTH + (BLACK_WIDTH / 4),
+ Y_OFFSET + 2,
+ X_OFFSET + (WHITE_WIDTH * 2) - (BLACK_WIDTH / 4) - 1,
+ Y_OFFSET + BLACK_HEIGHT - 1
+ },
+
+ //
+ // Bottom fill
+ //
+ {
+ X_OFFSET + WHITE_WIDTH + 2,
+ Y_OFFSET + BLACK_HEIGHT,
+ X_OFFSET + (WHITE_WIDTH * 2) - 3,
+ Y_OFFSET + WHITE_HEIGHT - 3
+ },
+
+ //
+ // Frequency
+ //
+ 294
+ },
+
+ //
+ // E4
+ //
+ {
+ //
+ // Outline
+ //
+ {
+ X_OFFSET + (WHITE_WIDTH * 2),
+ Y_OFFSET,
+ X_OFFSET + (WHITE_WIDTH * 3) - 1,
+ Y_OFFSET + WHITE_HEIGHT - 1
+ },
+
+ //
+ // Top fill
+ //
+ {
+ X_OFFSET + (WHITE_WIDTH * 2) + ((BLACK_WIDTH * 3) / 4),
+ Y_OFFSET + 2,
+ X_OFFSET + (WHITE_WIDTH * 3) - 3,
+ Y_OFFSET + BLACK_HEIGHT - 1,
+ },
+
+ //
+ // Bottom fill
+ //
+ {
+ X_OFFSET + (WHITE_WIDTH * 2) + 2,
+ Y_OFFSET + BLACK_HEIGHT,
+ X_OFFSET + (WHITE_WIDTH * 3) - 3,
+ Y_OFFSET + WHITE_HEIGHT - 3
+ },
+
+ //
+ // Frequency
+ //
+ 330
+ },
+
+ //
+ // F4
+ //
+ {
+ //
+ // Outline
+ //
+ {
+ X_OFFSET + (WHITE_WIDTH * 3),
+ Y_OFFSET,
+ X_OFFSET + (WHITE_WIDTH * 4) - 1,
+ Y_OFFSET + WHITE_HEIGHT - 1
+ },
+
+ //
+ // Top fill
+ //
+ {
+ X_OFFSET + (WHITE_WIDTH * 3) + 2,
+ Y_OFFSET + 2,
+ X_OFFSET + (WHITE_WIDTH * 4) - ((BLACK_WIDTH * 3) / 4) - 1,
+ Y_OFFSET + BLACK_HEIGHT - 1
+ },
+
+ //
+ // Bottom fill
+ //
+ {
+ X_OFFSET + (WHITE_WIDTH * 3) + 2,
+ Y_OFFSET + BLACK_HEIGHT,
+ X_OFFSET + (WHITE_WIDTH * 4) - 3,
+ Y_OFFSET + WHITE_HEIGHT - 3
+ },
+
+ //
+ // Frequency
+ //
+ 349
+ },
+
+ //
+ // G4
+ //
+ {
+ //
+ // Outline
+ //
+ {
+ X_OFFSET + (WHITE_WIDTH * 4),
+ Y_OFFSET,
+ X_OFFSET + (WHITE_WIDTH * 5) - 1,
+ Y_OFFSET + WHITE_HEIGHT - 1
+ },
+
+ //
+ // Top fill
+ //
+ {
+ X_OFFSET + (WHITE_WIDTH * 4) + (BLACK_WIDTH / 4),
+ Y_OFFSET + 2,
+ X_OFFSET + (WHITE_WIDTH * 5) - (BLACK_WIDTH / 2) - 1,
+ Y_OFFSET + BLACK_HEIGHT - 1
+ },
+
+ //
+ // Bottom fill
+ //
+ {
+ X_OFFSET + (WHITE_WIDTH * 4) + 2,
+ Y_OFFSET + BLACK_HEIGHT,
+ X_OFFSET + (WHITE_WIDTH * 5) - 3,
+ Y_OFFSET + WHITE_HEIGHT - 3
+ },
+
+ //
+ // Frequency
+ //
+ 392
+ },
+
+ //
+ // A4
+ //
+ {
+ //
+ // Outline
+ //
+ {
+ X_OFFSET + (WHITE_WIDTH * 5),
+ Y_OFFSET,
+ X_OFFSET + (WHITE_WIDTH * 6) - 1,
+ Y_OFFSET + WHITE_HEIGHT - 1
+ },
+
+ //
+ // Top fill
+ //
+ {
+ X_OFFSET + (WHITE_WIDTH * 5) + (BLACK_WIDTH / 2),
+ Y_OFFSET + 2,
+ X_OFFSET + (WHITE_WIDTH * 6) - (BLACK_WIDTH / 4) - 1,
+ Y_OFFSET + BLACK_HEIGHT - 1
+ },
+
+ //
+ // Bottom fill
+ //
+ {
+ X_OFFSET + (WHITE_WIDTH * 5) + 2,
+ Y_OFFSET + BLACK_HEIGHT,
+ X_OFFSET + (WHITE_WIDTH * 6) - 3,
+ Y_OFFSET + WHITE_HEIGHT - 3
+ },
+
+ //
+ // Frequency
+ //
+ 440
+ },
+
+ //
+ // B4
+ //
+ {
+ //
+ // Outline
+ //
+ {
+ X_OFFSET + (WHITE_WIDTH * 6),
+ Y_OFFSET,
+ X_OFFSET + (WHITE_WIDTH * 7) - 1,
+ Y_OFFSET + WHITE_HEIGHT - 1
+ },
+
+ //
+ // Top fill
+ //
+ {
+ X_OFFSET + (WHITE_WIDTH * 6) + ((BLACK_WIDTH * 3) / 4),
+ Y_OFFSET + 2,
+ X_OFFSET + (WHITE_WIDTH * 7) - 3,
+ Y_OFFSET + BLACK_HEIGHT - 1
+ },
+
+ //
+ // Bottom fill
+ //
+ {
+ X_OFFSET + (WHITE_WIDTH * 6) + 2,
+ Y_OFFSET + BLACK_HEIGHT,
+ X_OFFSET + (WHITE_WIDTH * 7) - 3,
+ Y_OFFSET + WHITE_HEIGHT - 3
+ },
+
+ //
+ // Frequency
+ //
+ 494
+ },
+
+ //
+ // C5
+ //
+ {
+ //
+ // Outline
+ //
+ {
+ X_OFFSET + (WHITE_WIDTH * 7),
+ Y_OFFSET,
+ X_OFFSET + (WHITE_WIDTH * 8) - 1,
+ Y_OFFSET + WHITE_HEIGHT - 1
+ },
+
+ //
+ // Top fill
+ //
+ {
+ X_OFFSET + (WHITE_WIDTH * 7) + 2,
+ Y_OFFSET + 2,
+ X_OFFSET + (WHITE_WIDTH * 8) - 3,
+ Y_OFFSET + BLACK_HEIGHT - 1
+ },
+
+ //
+ // Bottom fill
+ //
+ {
+ X_OFFSET + (WHITE_WIDTH * 7) + 2,
+ Y_OFFSET + BLACK_HEIGHT,
+ X_OFFSET + (WHITE_WIDTH * 8) - 3,
+ Y_OFFSET + WHITE_HEIGHT - 3
+ },
+
+ //
+ // Frequency
+ //
+ 523
+ }
+};
+
+//*****************************************************************************
+//
+// The number of white keys.
+//
+//*****************************************************************************
+#define NUM_WHITE_KEYS (sizeof(g_psWhiteKeys) / \
+ sizeof(g_psWhiteKeys[0]))
+
+//*****************************************************************************
+//
+// The black keys on the keyboard.
+//
+//*****************************************************************************
+static const tKey g_psBlackKeys[] =
+{
+ //
+ // C#4
+ //
+ {
+ //
+ // Outline
+ //
+ {
+ X_OFFSET + WHITE_WIDTH - ((BLACK_WIDTH * 3) / 4),
+ Y_OFFSET,
+ X_OFFSET + WHITE_WIDTH + (BLACK_WIDTH / 4) - 1,
+ Y_OFFSET + BLACK_HEIGHT - 1
+ },
+
+ //
+ // Fill
+ //
+ {
+ X_OFFSET + WHITE_WIDTH - ((BLACK_WIDTH * 3) / 4) + 2,
+ Y_OFFSET + 2,
+ X_OFFSET + WHITE_WIDTH + (BLACK_WIDTH / 4) - 3,
+ Y_OFFSET + BLACK_HEIGHT - 3
+ },
+
+ //
+ // Unused
+ //
+ {
+ 0
+ },
+
+ //
+ // Frequency
+ //
+ 277
+ },
+
+ //
+ // D#4
+ //
+ {
+ //
+ // Outline
+ //
+ {
+ X_OFFSET + (WHITE_WIDTH * 2) - (BLACK_WIDTH / 4),
+ Y_OFFSET,
+ X_OFFSET + (WHITE_WIDTH * 2) + ((BLACK_WIDTH * 3) / 4) - 1,
+ Y_OFFSET + BLACK_HEIGHT - 1
+ },
+
+ //
+ // Fill
+ //
+ {
+ X_OFFSET + (WHITE_WIDTH * 2) - (BLACK_WIDTH / 4) + 2,
+ Y_OFFSET + 2,
+ X_OFFSET + (WHITE_WIDTH * 2) + ((BLACK_WIDTH * 3) / 4) - 3,
+ Y_OFFSET + BLACK_HEIGHT - 3
+ },
+
+ //
+ // Unused
+ //
+ {
+ 0
+ },
+
+ //
+ // Frequency
+ //
+ 311
+ },
+
+ //
+ // F#4
+ //
+ {
+ //
+ // Outline
+ //
+ {
+ X_OFFSET + (WHITE_WIDTH * 4) - ((BLACK_WIDTH * 3) / 4),
+ Y_OFFSET,
+ X_OFFSET + (WHITE_WIDTH * 4) + (BLACK_WIDTH / 4) - 1,
+ Y_OFFSET + BLACK_HEIGHT - 1
+ },
+
+ //
+ // Fill
+ //
+ {
+ X_OFFSET + (WHITE_WIDTH * 4) - ((BLACK_WIDTH * 3) / 4) + 2,
+ Y_OFFSET + 2,
+ X_OFFSET + (WHITE_WIDTH * 4) + (BLACK_WIDTH / 4) - 3,
+ Y_OFFSET + BLACK_HEIGHT - 3
+ },
+
+ //
+ // Unused
+ //
+ {
+ 0
+ },
+
+ //
+ // Frequency
+ //
+ 370
+ },
+
+ //
+ // G#4
+ //
+ {
+ //
+ // Outline
+ //
+ {
+ X_OFFSET + (WHITE_WIDTH * 5) - (BLACK_WIDTH / 2),
+ Y_OFFSET,
+ X_OFFSET + (WHITE_WIDTH * 5) + (BLACK_WIDTH / 2) - 1,
+ Y_OFFSET + BLACK_HEIGHT - 1
+ },
+
+ //
+ // Fill
+ //
+ {
+ X_OFFSET + (WHITE_WIDTH * 5) - (BLACK_WIDTH / 2) + 2,
+ Y_OFFSET + 2,
+ X_OFFSET + (WHITE_WIDTH * 5) + (BLACK_WIDTH / 2) - 3,
+ Y_OFFSET + BLACK_HEIGHT - 3
+ },
+
+ //
+ // Unused
+ //
+ {
+ 0
+ },
+
+ //
+ // Frequency
+ //
+ 415
+ },
+
+ //
+ // A#4
+ //
+ {
+ //
+ // Outline
+ //
+ {
+ X_OFFSET + (WHITE_WIDTH * 6) - (BLACK_WIDTH / 4),
+ Y_OFFSET,
+ X_OFFSET + (WHITE_WIDTH * 6) + ((BLACK_WIDTH * 3) / 4) - 1,
+ Y_OFFSET + BLACK_HEIGHT - 1
+ },
+
+ //
+ // Fill
+ //
+ {
+ X_OFFSET + (WHITE_WIDTH * 6) - (BLACK_WIDTH / 4) + 2,
+ Y_OFFSET + 2,
+ X_OFFSET + (WHITE_WIDTH * 6) + ((BLACK_WIDTH * 3) / 4) - 3,
+ Y_OFFSET + BLACK_HEIGHT - 3
+ },
+
+ //
+ // Unused
+ //
+ {
+ 0
+ },
+
+ //
+ // Frequency
+ //
+ 466
+ }
+};
+
+//*****************************************************************************
+//
+// The number of black keys.
+//
+//*****************************************************************************
+#define NUM_BLACK_KEYS (sizeof(g_psBlackKeys) / \
+ sizeof(g_psBlackKeys[0]))
+
+//*****************************************************************************
+//
+// The buffer used to store the synthesized waveform that is to be played. The
+// buffer size must be a power of 2 less than or equal to 2048.
+//
+//*****************************************************************************
+#define AUDIO_SIZE 2048
+static int16_t g_pi16AudioBuffer[AUDIO_SIZE];
+
+//*****************************************************************************
+//
+// A set of flags that indicate the current state of the application.
+//
+//*****************************************************************************
+static uint32_t g_ui32Flags;
+#define FLAG_PING 0 // The "ping" half of the sound
+ // buffer needs to be filled
+#define FLAG_PONG 1 // The "pong" half of the sound
+ // buffer needs to be filled
+
+//*****************************************************************************
+//
+// The key that is currently pressed.
+//
+//*****************************************************************************
+uint32_t g_ui32Key = NUM_WHITE_KEYS + NUM_BLACK_KEYS;
+
+//*****************************************************************************
+//
+// The position within the waveform of the currently playing key.
+//
+//*****************************************************************************
+uint32_t g_ui32AudioPos;
+
+//*****************************************************************************
+//
+// The step rate of the waveform for the currently playing key.
+//
+//*****************************************************************************
+uint32_t g_ui32AudioStep;
+
+//*****************************************************************************
+//
+// The error routine that is called if the driver library encounters an error.
+//
+//*****************************************************************************
+#ifdef DEBUG
+void
+__error__(char *pcFilename, uint32_t ui32Line)
+{
+}
+#endif
+
+//*****************************************************************************
+//
+// Fills in one of the white keys with the given color.
+//
+//*****************************************************************************
+static inline void
+FillWhiteKey(tContext *pContext, uint32_t ui32Key, uint32_t ui32Color)
+{
+ //
+ // Select the specified color.
+ //
+ GrContextForegroundSet(pContext, ui32Color);
+
+ //
+ // Fill in the upper and lower portions of the white key.
+ //
+ GrRectFill(pContext, &(g_psWhiteKeys[ui32Key].sFill1));
+ GrRectFill(pContext, &(g_psWhiteKeys[ui32Key].sFill2));
+}
+
+//*****************************************************************************
+//
+// Draws the white keys on the display.
+//
+//*****************************************************************************
+static inline void
+DrawWhiteKeys(tContext *pContext)
+{
+ uint32_t ui32Key;
+
+ //
+ // Loop through the white keys.
+ //
+ for(ui32Key = 0; ui32Key < NUM_WHITE_KEYS; ui32Key++)
+ {
+ //
+ // Select the color for the top and left edges of the white key.
+ //
+ GrContextForegroundSet(pContext, ClrWhiteBright);
+
+ //
+ // Draw the top and left edges of the white key.
+ //
+ GrLineDraw(pContext,
+ g_psWhiteKeys[ui32Key].sOutline.i16XMin,
+ g_psWhiteKeys[ui32Key].sOutline.i16YMin,
+ g_psWhiteKeys[ui32Key].sOutline.i16XMax,
+ g_psWhiteKeys[ui32Key].sOutline.i16YMin);
+ GrLineDraw(pContext,
+ g_psWhiteKeys[ui32Key].sOutline.i16XMin + 1,
+ g_psWhiteKeys[ui32Key].sOutline.i16YMin + 1,
+ g_psWhiteKeys[ui32Key].sOutline.i16XMax - 1,
+ g_psWhiteKeys[ui32Key].sOutline.i16YMin + 1);
+ GrLineDraw(pContext,
+ g_psWhiteKeys[ui32Key].sOutline.i16XMin,
+ g_psWhiteKeys[ui32Key].sOutline.i16YMin + 1,
+ g_psWhiteKeys[ui32Key].sOutline.i16XMin,
+ g_psWhiteKeys[ui32Key].sOutline.i16YMax);
+ GrLineDraw(pContext,
+ g_psWhiteKeys[ui32Key].sOutline.i16XMin + 1,
+ g_psWhiteKeys[ui32Key].sOutline.i16YMin + 2,
+ g_psWhiteKeys[ui32Key].sOutline.i16XMin + 1,
+ g_psWhiteKeys[ui32Key].sOutline.i16YMax - 1);
+
+ //
+ // Select the color for the bottom and right edges of the white key.
+ //
+ GrContextForegroundSet(pContext, ClrWhiteDim);
+
+ //
+ // Draw the bottom and right edges of the white key.
+ //
+ GrLineDraw(pContext,
+ g_psWhiteKeys[ui32Key].sOutline.i16XMax,
+ g_psWhiteKeys[ui32Key].sOutline.i16YMin + 1,
+ g_psWhiteKeys[ui32Key].sOutline.i16XMax,
+ g_psWhiteKeys[ui32Key].sOutline.i16YMax);
+ GrLineDraw(pContext,
+ g_psWhiteKeys[ui32Key].sOutline.i16XMax - 1,
+ g_psWhiteKeys[ui32Key].sOutline.i16YMin + 2,
+ g_psWhiteKeys[ui32Key].sOutline.i16XMax - 1,
+ g_psWhiteKeys[ui32Key].sOutline.i16YMax - 1);
+ GrLineDraw(pContext,
+ g_psWhiteKeys[ui32Key].sOutline.i16XMin + 1,
+ g_psWhiteKeys[ui32Key].sOutline.i16YMax,
+ g_psWhiteKeys[ui32Key].sOutline.i16XMax - 1,
+ g_psWhiteKeys[ui32Key].sOutline.i16YMax);
+ GrLineDraw(pContext,
+ g_psWhiteKeys[ui32Key].sOutline.i16XMin + 2,
+ g_psWhiteKeys[ui32Key].sOutline.i16YMax - 1,
+ g_psWhiteKeys[ui32Key].sOutline.i16XMax - 2,
+ g_psWhiteKeys[ui32Key].sOutline.i16YMax - 1);
+
+ //
+ // Fill in the white key with the default color.
+ //
+ FillWhiteKey(pContext, ui32Key, ClrWhiteKey);
+ }
+}
+
+//*****************************************************************************
+//
+// Fills in one of the black keys with the given color.
+//
+//*****************************************************************************
+static inline void
+FillBlackKey(tContext *pContext, uint32_t ui32Key, uint32_t ui32Color)
+{
+ //
+ // Select the specified color.
+ //
+ GrContextForegroundSet(pContext, ui32Color);
+
+ //
+ // FIll in the black key.
+ //
+ GrRectFill(pContext, &(g_psBlackKeys[ui32Key].sFill1));
+}
+
+//*****************************************************************************
+//
+// Draws the black keys on the display.
+//
+//*****************************************************************************
+static inline void
+DrawBlackKeys(tContext *pContext)
+{
+ uint32_t ui32Key;
+
+ //
+ // Loop through the black keys.
+ //
+ for(ui32Key = 0; ui32Key < NUM_BLACK_KEYS; ui32Key++)
+ {
+ //
+ // Select the color for the top and left edges of the black key.
+ //
+ GrContextForegroundSet(pContext, ClrBlackBright);
+
+ //
+ // Draw the top and left edges of the black key.
+ //
+ GrLineDraw(pContext,
+ g_psBlackKeys[ui32Key].sOutline.i16XMin,
+ g_psBlackKeys[ui32Key].sOutline.i16YMin,
+ g_psBlackKeys[ui32Key].sOutline.i16XMax,
+ g_psBlackKeys[ui32Key].sOutline.i16YMin);
+ GrLineDraw(pContext,
+ g_psBlackKeys[ui32Key].sOutline.i16XMin + 1,
+ g_psBlackKeys[ui32Key].sOutline.i16YMin + 1,
+ g_psBlackKeys[ui32Key].sOutline.i16XMax - 1,
+ g_psBlackKeys[ui32Key].sOutline.i16YMin + 1);
+ GrLineDraw(pContext,
+ g_psBlackKeys[ui32Key].sOutline.i16XMin,
+ g_psBlackKeys[ui32Key].sOutline.i16YMin + 1,
+ g_psBlackKeys[ui32Key].sOutline.i16XMin,
+ g_psBlackKeys[ui32Key].sOutline.i16YMax);
+ GrLineDraw(pContext,
+ g_psBlackKeys[ui32Key].sOutline.i16XMin + 1,
+ g_psBlackKeys[ui32Key].sOutline.i16YMin + 2,
+ g_psBlackKeys[ui32Key].sOutline.i16XMin + 1,
+ g_psBlackKeys[ui32Key].sOutline.i16YMax - 1);
+
+ //
+ // Select the color for the bottom and right edges of the black key.
+ //
+ GrContextForegroundSet(pContext, ClrBlackDim);
+
+ //
+ // Draw the bottom and right edges of the black key.
+ //
+ GrLineDraw(pContext,
+ g_psBlackKeys[ui32Key].sOutline.i16XMax,
+ g_psBlackKeys[ui32Key].sOutline.i16YMin + 1,
+ g_psBlackKeys[ui32Key].sOutline.i16XMax,
+ g_psBlackKeys[ui32Key].sOutline.i16YMax);
+ GrLineDraw(pContext,
+ g_psBlackKeys[ui32Key].sOutline.i16XMax - 1,
+ g_psBlackKeys[ui32Key].sOutline.i16YMin + 2,
+ g_psBlackKeys[ui32Key].sOutline.i16XMax - 1,
+ g_psBlackKeys[ui32Key].sOutline.i16YMax - 1);
+ GrLineDraw(pContext,
+ g_psBlackKeys[ui32Key].sOutline.i16XMin + 1,
+ g_psBlackKeys[ui32Key].sOutline.i16YMax,
+ g_psBlackKeys[ui32Key].sOutline.i16XMax - 1,
+ g_psBlackKeys[ui32Key].sOutline.i16YMax);
+ GrLineDraw(pContext,
+ g_psBlackKeys[ui32Key].sOutline.i16XMin + 2,
+ g_psBlackKeys[ui32Key].sOutline.i16YMax - 1,
+ g_psBlackKeys[ui32Key].sOutline.i16XMax - 2,
+ g_psBlackKeys[ui32Key].sOutline.i16YMax - 1);
+
+ //
+ // Fill in the black key with the default color.
+ //
+ FillBlackKey(pContext, ui32Key, ClrBlackKey);
+ }
+}
+
+//*****************************************************************************
+//
+// The callback function that is called by the sound driver to indicate that
+// half of the sound buffer has been played.
+//
+//*****************************************************************************
+void
+SoundCallback(uint32_t ui32Half)
+{
+ //
+ // See which half of the sound buffer has been played.
+ //
+ if(ui32Half == 0)
+ {
+ //
+ // The first half of the sound buffer needs to be filled.
+ //
+ HWREGBITW(&g_ui32Flags, FLAG_PING) = 1;
+ }
+ else
+ {
+ //
+ // The second half of the sound buffer needs to be filled.
+ //
+ HWREGBITW(&g_ui32Flags, FLAG_PONG) = 1;
+ }
+}
+
+//*****************************************************************************
+//
+// The callback function that is called by the touch screen driver to indicate
+// activity on the touch screen.
+//
+//*****************************************************************************
+int32_t
+TouchCallback(uint32_t ui32Message, int32_t i32X, int32_t i32Y)
+{
+ uint32_t ui32Key;
+
+ //
+ // See if this touch event occurred on one of the black keys.
+ //
+ for(ui32Key = 0; ui32Key < NUM_BLACK_KEYS; ui32Key++)
+ {
+ if((i32X >= g_psBlackKeys[ui32Key].sOutline.i16XMin) &&
+ (i32X <= g_psBlackKeys[ui32Key].sOutline.i16XMax) &&
+ (i32Y >= g_psBlackKeys[ui32Key].sOutline.i16YMin) &&
+ (i32Y <= g_psBlackKeys[ui32Key].sOutline.i16YMax))
+ {
+ break;
+ }
+ }
+
+ //
+ // See if a match was found.
+ //
+ if(ui32Key != NUM_BLACK_KEYS)
+ {
+ //
+ // The touch event occurred on one of the black keys. Increment the
+ // index by the number of white keys since they are listed first.
+ //
+ ui32Key += NUM_WHITE_KEYS;
+ }
+ else
+ {
+ //
+ // The touch event did not occur on one of the black keys. Check the
+ // white keys.
+ //
+ for(ui32Key = 0; ui32Key < NUM_WHITE_KEYS; ui32Key++)
+ {
+ if((i32X >= g_psWhiteKeys[ui32Key].sOutline.i16XMin) &&
+ (i32X <= g_psWhiteKeys[ui32Key].sOutline.i16XMax) &&
+ (i32Y >= g_psWhiteKeys[ui32Key].sOutline.i16YMin) &&
+ (i32Y <= g_psWhiteKeys[ui32Key].sOutline.i16YMax))
+ {
+ break;
+ }
+ }
+
+ //
+ // If the touch event did not occur on one of the white keys, set the
+ // key number to a non-existant key.
+ //
+ if(ui32Key == NUM_WHITE_KEYS)
+ {
+ ui32Key += NUM_BLACK_KEYS;
+ }
+ }
+
+ //
+ // Determine the message that is being sent.
+ //
+ switch(ui32Message)
+ {
+ //
+ // The user has just touched the screen.
+ //
+ case WIDGET_MSG_PTR_DOWN:
+ {
+ //
+ // Save this key as the currently pressed key.
+ //
+ g_ui32Key = ui32Key;
+
+ //
+ // Done handling this message.
+ //
+ break;
+ }
+
+ //
+ // The user has moved the touch location on the screen.
+ //
+ case WIDGET_MSG_PTR_MOVE:
+ {
+ //
+ // Save this key as the currently pressed key.
+ //
+ g_ui32Key = ui32Key;
+
+ //
+ // Done handling this message.
+ //
+ break;
+ }
+
+ //
+ // The user is no longer touching the screen.
+ //
+ case WIDGET_MSG_PTR_UP:
+ {
+ //
+ // Indicate that no key is being pressed.
+ //
+ g_ui32Key = NUM_WHITE_KEYS + NUM_BLACK_KEYS;
+
+ //
+ // Done handling this message.
+ //
+ break;
+ }
+ }
+
+ //
+ // Success.
+ //
+ return(0);
+}
+
+//*****************************************************************************
+//
+// Generates an additional section of the audio output based on the currently
+// pressed key (if any).
+//
+//*****************************************************************************
+uint32_t
+GenerateAudio(int16_t *pi16Buffer, uint32_t ui32Count)
+{
+ int32_t i32Val, i32Vol, i32VolStep;
+ uint32_t ui32Key, ui32NewStep;
+
+ //
+ // See if one of the push buttons is pressed.
+ //
+ ui32Key = (ROM_GPIOPinRead(GPIO_PORTN_BASE, GPIO_PIN_3) |
+ ROM_GPIOPinRead(GPIO_PORTE_BASE, GPIO_PIN_5));
+ if(ui32Key == GPIO_PIN_5)
+ {
+ //
+ // The up botton is pressed and the down button is not pressed.
+ // Therefore, turn up the volume.
+ //
+ SoundVolumeUp(1);
+ }
+ if(ui32Key == GPIO_PIN_3)
+ {
+ //
+ // The up botton is not pressed and the down button is pressed.
+ // Therefore, turn down the volume.
+ //
+ SoundVolumeDown(1);
+ }
+
+ //
+ // Get the currently pressed piano key.
+ //
+ ui32Key = g_ui32Key;
+
+ //
+ // See if this key is one of the white keys.
+ //
+ if(ui32Key < NUM_WHITE_KEYS)
+ {
+ //
+ // Compute the step value required to generate this white key's
+ // frequency.
+ //
+ ui32NewStep =
+ ((g_psWhiteKeys[ui32Key].ui32Freq * 65536) / 64000) * 65536;
+ }
+
+ //
+ // See if this key is one of the black keys.
+ //
+ else if(ui32Key < (NUM_WHITE_KEYS + NUM_BLACK_KEYS))
+ {
+ //
+ // Compute the step value required to generate this black key's
+ // frequency.
+ //
+ ui32NewStep =
+ (((g_psBlackKeys[ui32Key - NUM_WHITE_KEYS].ui32Freq * 65536) /
+ 64000) * 65536);
+ }
+
+ //
+ // No key is being pressed.
+ //
+ else
+ {
+ //
+ // Do not generate any waveform.
+ //
+ ui32NewStep = 0;
+ }
+
+ //
+ // See if no key was previously pressed and no key is currently pressed.
+ //
+ if((g_ui32AudioStep == 0) && (ui32NewStep == 0))
+ {
+ //
+ // Fill the buffer with silence.
+ //
+ while(ui32Count--)
+ {
+ *pi16Buffer++ = 0;
+ }
+
+ //
+ // There is nothing further to do.
+ //
+ return(ui32Key);
+ }
+
+ //
+ // See if the same key as last time is pressed.
+ //
+ if(g_ui32AudioStep == ui32NewStep)
+ {
+ //
+ // Set the volume of the waveform generator to full volume.
+ //
+ i32Vol = 1024;
+ i32VolStep = 0;
+ }
+
+ //
+ // See if a key was previously pressed.
+ //
+ else if(g_ui32AudioStep == 0)
+ {
+ //
+ // There was not a previously pressed key, so ramp the volume of the
+ // first waveform generator to full volume.
+ //
+ i32Vol = 0;
+ i32VolStep = 1024 / ui32Count;
+
+ //
+ // Start the new waveform at zero.
+ //
+ g_ui32AudioPos = 0;
+ }
+
+ //
+ // Otherwise there is already a key playing.
+ //
+ else
+ {
+ //
+ // Ramp the volume of the waveform generator to zero.
+ //
+ i32Vol = 1024;
+ i32VolStep = -1024 / ui32Count;
+ }
+
+ //
+ // Loop through the samples to be generated.
+ //
+ while(ui32Count--)
+ {
+ //
+ // Compute the value of the waveform.
+ //
+ i32Val = sine(g_ui32AudioPos + (sine(g_ui32AudioPos * 3) * 10922));
+
+ //
+ // Increment the position of the waveform.
+ //
+ g_ui32AudioPos += g_ui32AudioStep;
+
+ //
+ // Scale the waveform value by the volume.
+ //
+ i32Val = (i32Val * i32Vol) / 1024;
+
+ //
+ // Increment the waveform volume by the step.
+ //
+ i32Vol += i32VolStep;
+ if(i32Vol < 0)
+ {
+ i32Vol = 0;
+ }
+ if(i32Vol > 1024)
+ {
+ i32Vol = 1024;
+ }
+
+ //
+ // Cilp the waveform to min/max if required.
+ //
+ i32Val /= 2;
+ if(i32Val > 32767)
+ {
+ i32Val = 32767;
+ }
+ if(i32Val < -32768)
+ {
+ i32Val = -32768;
+ }
+
+ //
+ // Add the new waveform value to the sample buffer.
+ //
+ *pi16Buffer++ = (int16_t)i32Val;
+ }
+
+ //
+ // Save the new step value.
+ //
+ g_ui32AudioStep = ui32NewStep;
+
+ //
+ // Return the currently pressed key.
+ //
+ return(ui32Key);
+}
+
+//*****************************************************************************
+//
+// This application performs simple audio synthesis and playback based on the
+// keys pressed on the touch screen virtual piano keyboard.
+//
+//*****************************************************************************
+int
+main(void)
+{
+ uint32_t ui32SysClock, ui32OldKey, ui32NewKey;
+ tContext sContext;
+
+ //
+ // Run from the PLL at 120 MHz.
+ //
+ ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |
+ SYSCTL_OSC_MAIN | SYSCTL_USE_PLL |
+ SYSCTL_CFG_VCO_480), 120000000);
+
+ //
+ // Configure the device pins.
+ //
+ PinoutSet();
+
+ //
+ // Initialize the display driver.
+ //
+ Kentec320x240x16_SSD2119Init(ui32SysClock);
+
+ //
+ // Initialize the graphics context.
+ //
+ GrContextInit(&sContext, &g_sKentec320x240x16_SSD2119);
+
+ //
+ // Draw the application frame.
+ //
+ FrameDraw(&sContext, "synth");
+
+ //
+ // Draw the keys on the virtual piano keyboard.
+ //
+ DrawWhiteKeys(&sContext);
+ DrawBlackKeys(&sContext);
+
+ //
+ // Initialize the touch screen driver.
+ //
+ TouchScreenInit(ui32SysClock);
+ TouchScreenCallbackSet(TouchCallback);
+
+ //
+ // Initialize the sound driver.
+ //
+ SoundInit(ui32SysClock);
+ SoundVolumeSet(128);
+ SoundStart(g_pi16AudioBuffer, AUDIO_SIZE, 64000, SoundCallback);
+
+ //
+ // Default the old and new key to not pressed so that the first key press
+ // will be properly drawn on the keyboard.
+ //
+ ui32OldKey = NUM_WHITE_KEYS + NUM_BLACK_KEYS;
+ ui32NewKey = NUM_WHITE_KEYS + NUM_BLACK_KEYS;
+
+ //
+ // Loop forever.
+ //
+ while(1)
+ {
+ //
+ // See if the first half of the sound buffer needs to be filled.
+ //
+ if(HWREGBITW(&g_ui32Flags, FLAG_PING) == 1)
+ {
+ //
+ // Synthesize new audio into the first half of the sound buffer.
+ //
+ ui32NewKey = GenerateAudio(g_pi16AudioBuffer, AUDIO_SIZE / 2);
+
+ //
+ // Clear the flag for the first half of the sound buffer.
+ //
+ HWREGBITW(&g_ui32Flags, FLAG_PING) = 0;
+ }
+
+ //
+ // See if the second half of the sound buffer needs to be filled.
+ //
+ if(HWREGBITW(&g_ui32Flags, FLAG_PONG) == 1)
+ {
+ //
+ // Synthesize new audio into the second half of the sound buffer.
+ //
+ ui32NewKey = GenerateAudio(g_pi16AudioBuffer + (AUDIO_SIZE / 2),
+ AUDIO_SIZE / 2);
+
+ //
+ // Clear the flag for the second half of the sound buffer.
+ //
+ HWREGBITW(&g_ui32Flags, FLAG_PONG) = 0;
+ }
+
+ //
+ // See if a different key has been pressed.
+ //
+ if(ui32OldKey != ui32NewKey)
+ {
+ //
+ // See if the old key was a white key.
+ //
+ if(ui32OldKey < NUM_WHITE_KEYS)
+ {
+ //
+ // Redraw the face of the white key so that it no longer shows
+ // as being pressed.
+ //
+ FillWhiteKey(&sContext, ui32OldKey, ClrWhiteKey);
+ }
+
+ //
+ // See if the old key was a black key.
+ //
+ else if(ui32OldKey < (NUM_WHITE_KEYS + NUM_BLACK_KEYS))
+ {
+ //
+ // Redraw the face of the black key so that it no longer shows
+ // as being pressed.
+ //
+ FillBlackKey(&sContext, ui32OldKey - NUM_WHITE_KEYS,
+ ClrBlackKey);
+ }
+
+ //
+ // See if the new key is a white key.
+ //
+ if(ui32NewKey < NUM_WHITE_KEYS)
+ {
+ //
+ // Redraw the face of the white key so that it is shown as
+ // being pressed.
+ //
+ FillWhiteKey(&sContext, ui32NewKey, ClrPressed);
+ }
+
+ //
+ // See if the new key is a black key.
+ //
+ else if(ui32NewKey < (NUM_WHITE_KEYS + NUM_BLACK_KEYS))
+ {
+ //
+ // Redraw the face of the black key so that it is shown as
+ // being pressed.
+ //
+ FillBlackKey(&sContext, ui32NewKey - NUM_WHITE_KEYS,
+ ClrPressed);
+ }
+
+ //
+ // Save the new key as the old key.
+ //
+ ui32OldKey = ui32NewKey;
+ }
+ }
+}
|