504 lines
13 KiB
C
504 lines
13 KiB
C
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <ctype.h>
|
|
#include <stdbool.h>
|
|
#include <setjmp.h>
|
|
#include <limits.h>
|
|
#include <avr/interrupt.h>
|
|
#include <avr/pgmspace.h>
|
|
#include <avr/eeprom.h>
|
|
#include "../config.h"
|
|
#include "../borg_hw/borg_hw.h"
|
|
#ifdef JOYSTICK_SUPPORT
|
|
#include "../joystick/joystick.h"
|
|
extern unsigned char waitForFire;
|
|
#endif
|
|
#include "../scrolltext/scrolltext.h"
|
|
#include "../animations/program.h"
|
|
#include "uart.h"
|
|
#include "uart_commands.h"
|
|
|
|
#ifndef USE_UART1
|
|
# define UART_PUTS(STR) uart_puts(STR)
|
|
# define UART_PUTS_P(STR) uart_puts_p(STR)
|
|
# define UART_GETC uart_getc
|
|
# define UART_PUTC uart_putc
|
|
#else
|
|
# define UART_PUTS(STR) uart1_puts(STR)
|
|
# define UART_PUTS_P(STR) uart1_puts_p(STR)
|
|
# define UART_GETC uart1_getc
|
|
# define UART_PUTC uart1_putc
|
|
#endif
|
|
|
|
#define UART_BUFFER_SIZE (SCROLLTEXT_BUFFER_SIZE + 8)
|
|
char g_rx_buffer[UART_BUFFER_SIZE];
|
|
uint8_t g_rx_index;
|
|
|
|
extern jmp_buf newmode_jmpbuf;
|
|
extern volatile unsigned char mode;
|
|
extern volatile unsigned char reverseMode;
|
|
|
|
#define CR "\r\n"
|
|
|
|
#if (!(defined(eeprom_update_block) && \
|
|
((E2PAGESIZE == 2) || (E2PAGESIZE == 4) || (E2PAGESIZE == 8)))) || \
|
|
!(defined(ANIMATION_TESTS))
|
|
char const UART_STR_NOTIMPL[] PROGMEM = "Not implemented."CR;
|
|
#endif
|
|
|
|
char const UART_STR_CLEARLINE[] PROGMEM = "\r\033[J";
|
|
char const UART_STR_BACKSPACE[] PROGMEM = "\b \b";
|
|
char const UART_STR_PROMPT[] PROGMEM = "> ";
|
|
char const UART_STR_MODE[] PROGMEM = "%d"CR;
|
|
char const UART_STR_MODE_ERR[] PROGMEM = "Range is between 0 and 255."CR;
|
|
char const UART_STR_GAMEMO_ERR[] PROGMEM = "No mode change during games."CR;
|
|
char const UART_STR_GAMETX_ERR[] PROGMEM = "No text messages during games."CR;
|
|
char const UART_STR_UART_ERR[] PROGMEM = "Transmission error."CR;
|
|
char const UART_STR_UNKNOWN[] PROGMEM = "Unknown command or syntax error."CR;
|
|
char const UART_STR_TOOLONG[] PROGMEM = CR"Command is too long."CR;
|
|
char const UART_STR_HELP[] PROGMEM = "Allowed commands: erase help mode "
|
|
"msg next prev reset scroll test"CR;
|
|
|
|
char const UART_CMD_ERASE[] PROGMEM = "erase";
|
|
char const UART_CMD_HELP[] PROGMEM = "help";
|
|
char const UART_CMD_MODE[] PROGMEM = "mode";
|
|
char const UART_CMD_MSG[] PROGMEM = "msg ";
|
|
char const UART_CMD_NEXT[] PROGMEM = "next";
|
|
char const UART_CMD_PREV[] PROGMEM = "prev";
|
|
char const UART_CMD_RESET[] PROGMEM = "reset";
|
|
char const UART_CMD_SCROLL[] PROGMEM = "scroll ";
|
|
char const UART_CMD_TEST[] PROGMEM = "test";
|
|
|
|
#ifdef ANIMATION_TESTS
|
|
char const UART_STR_TEST_EXIT[] PROGMEM = "Press ENTER to exit test."CR;
|
|
char const UART_STR_TEST_ERR[] PROGMEM = "Range is between 0 and %d."CR;
|
|
char const UART_STR_GAMETS_ERR[] PROGMEM = "No display tests during games."CR;
|
|
char const UART_STR_TEST_UP[] PROGMEM = "UP ";
|
|
char const UART_STR_TEST_DOWN[] PROGMEM = "DOWN ";
|
|
char const UART_STR_TEST_LEFT[] PROGMEM = "LEFT ";
|
|
char const UART_STR_TEST_RIGHT[] PROGMEM = "RIGHT ";
|
|
char const UART_STR_TEST_FIRE[] PROGMEM = "FIRE";
|
|
|
|
enum uartcmd_joytest_e {
|
|
UARTCMD_JOY_UP = 0x01,
|
|
UARTCMD_JOY_DOWN = 0x02,
|
|
UARTCMD_JOY_LEFT = 0x04,
|
|
UARTCMD_JOY_RIGHT = 0x08,
|
|
UARTCMD_JOY_FIRE = 0x10
|
|
};
|
|
|
|
# ifdef NDEBUG
|
|
typedef uint8_t uartcmd_joytest_t;
|
|
# else
|
|
typedef enum uartcmd_joytest_e uartcmd_joytest_t;
|
|
# endif
|
|
#endif
|
|
|
|
|
|
bool g_uartcmd_permit_processing = 1;
|
|
|
|
|
|
/**
|
|
* Checks if command processing is allowed.
|
|
*/
|
|
static bool uartcmd_processing_allowed(void) {
|
|
bool result;
|
|
cli();
|
|
result = g_uartcmd_permit_processing;
|
|
sei();
|
|
return result;
|
|
}
|
|
|
|
|
|
/**
|
|
* Clears the command string buffer.
|
|
*/
|
|
static void uartcmd_clear_buffer(void) {
|
|
char *p = &g_rx_buffer[0];
|
|
for (uint8_t i = UART_BUFFER_SIZE; i--;) {
|
|
*p++ = 0;
|
|
}
|
|
g_rx_index = 0;
|
|
}
|
|
|
|
|
|
/**
|
|
* Erases the complete EEPROM to reset counters and high score tables.
|
|
*/
|
|
static void uartcmd_erase_eeprom(void) {
|
|
#if defined(eeprom_update_block) && \
|
|
((E2PAGESIZE == 2) || (E2PAGESIZE == 4) || (E2PAGESIZE == 8))
|
|
uint8_t const eeclear[] =
|
|
# if E2PAGESIZE == 8
|
|
{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
|
|
# elif E2PAGESIZE == 4
|
|
{0xFF, 0xFF, 0xFF, 0xFF};
|
|
# elif E2PAGESIZE == 2
|
|
{0xFF, 0xFF};
|
|
# endif
|
|
for (void *ee = 0; ee < (void *)E2END; ee += E2PAGESIZE) {
|
|
eeprom_busy_wait();
|
|
eeprom_update_block(eeclear, ee, E2PAGESIZE);
|
|
}
|
|
#else
|
|
UART_PUTS_P(UART_STR_NOTIMPL);
|
|
#endif
|
|
}
|
|
|
|
|
|
/**
|
|
* Displays a simple message without the need to prefix a scrolltext command.
|
|
*/
|
|
static void uartcmd_simple_message(void) {
|
|
if (uartcmd_processing_allowed()) {
|
|
uartcmd_forbid();
|
|
#ifdef JOYSTICK_SUPPORT
|
|
if (waitForFire) {
|
|
waitForFire = 0;
|
|
#endif
|
|
g_rx_buffer[1] = '<';
|
|
g_rx_buffer[2] = '/';
|
|
g_rx_buffer[3] = '#';
|
|
// text must not be longer than the scroll text buffer
|
|
g_rx_buffer[1 + SCROLLTEXT_BUFFER_SIZE - 1] = 0;
|
|
scrolltext(&g_rx_buffer[1]);
|
|
|
|
#ifdef JOYSTICK_SUPPORT
|
|
waitForFire = 1;
|
|
} else {
|
|
UART_PUTS_P(UART_STR_GAMETX_ERR);
|
|
}
|
|
#endif
|
|
uartcmd_permit();
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Displays a message which may use the complete range of scrolltext commands.
|
|
*/
|
|
static void uartcmd_scroll_message(void) {
|
|
if (uartcmd_processing_allowed()) {
|
|
uartcmd_forbid();
|
|
#ifdef JOYSTICK_SUPPORT
|
|
if (waitForFire) {
|
|
waitForFire = 0;
|
|
#endif
|
|
// text must not be longer than the scroll text buffer
|
|
g_rx_buffer[7 + SCROLLTEXT_BUFFER_SIZE - 1] = 0;
|
|
scrolltext(&g_rx_buffer[7]);
|
|
#ifdef JOYSTICK_SUPPORT
|
|
waitForFire = 1;
|
|
} else {
|
|
UART_PUTS_P(UART_STR_GAMETX_ERR);
|
|
}
|
|
#endif
|
|
uartcmd_permit();
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* As long there's no game active, jump to the next animation.
|
|
*/
|
|
static void uartcmd_next_anim(void) {
|
|
#ifdef JOYSTICK_SUPPORT
|
|
if (waitForFire) {
|
|
#endif
|
|
UART_PUTS_P(UART_STR_PROMPT);
|
|
uartcmd_clear_buffer();
|
|
longjmp(newmode_jmpbuf, mode);
|
|
#ifdef JOYSTICK_SUPPORT
|
|
} else {
|
|
UART_PUTS_P(UART_STR_GAMEMO_ERR);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
|
|
/**
|
|
* As long there's no game active, jump to the previous animation.
|
|
*/
|
|
static void uartcmd_prev_anim(void) {
|
|
#ifdef JOYSTICK_SUPPORT
|
|
if (waitForFire) {
|
|
#endif
|
|
reverseMode = mode - 2;
|
|
UART_PUTS_P(UART_STR_PROMPT);
|
|
uartcmd_clear_buffer();
|
|
longjmp(newmode_jmpbuf, mode - 2);
|
|
#ifdef JOYSTICK_SUPPORT
|
|
} else {
|
|
UART_PUTS_P(UART_STR_GAMEMO_ERR);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
|
|
/**
|
|
* Extracts a positive number from an ASCII string (up to INT_MAX).
|
|
* @param buffer String to be examined. Preceding whitespaces are skipped.
|
|
* ASCII control characters and [Space] act as delimiters.
|
|
* @return The extracted number or -1 if a conversion error occurred.
|
|
*/
|
|
int uartcmd_extract_num_arg(char *buffer) {
|
|
int res = -1;
|
|
uint8_t i = 0;
|
|
while (buffer[i] <= ' ' && buffer[i] != 0) ++i; // skip whitespaces
|
|
for (; buffer[i] > 0x20; ++i) {
|
|
if (res < 0) {
|
|
res = 0;
|
|
}
|
|
int const d = buffer[i] - '0';
|
|
if (isdigit(buffer[i]) && (res <= (INT_MAX / 10)) &&
|
|
((res * 10) <= (INT_MAX - d))) {
|
|
res = res * 10 + d;
|
|
} else {
|
|
res = -1;
|
|
break;
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
|
|
|
|
/**
|
|
* Outputs current mode number via UART.
|
|
*/
|
|
static void uartcmd_print_mode(void) {
|
|
char mode_output[6] = "";
|
|
snprintf_P(mode_output, 6, UART_STR_MODE, mode - 1);
|
|
uart_puts(mode_output);
|
|
}
|
|
|
|
|
|
/**
|
|
* Retrieves desired mode number from command line and switches to that mode.
|
|
*/
|
|
static void uartcmd_mode(void) {
|
|
if (g_rx_buffer[4] != 0) {
|
|
int new_mode = uartcmd_extract_num_arg(&g_rx_buffer[4]);
|
|
if (new_mode <= UINT8_MAX) {
|
|
#ifdef JOYSTICK_SUPPORT
|
|
if (waitForFire) {
|
|
#endif
|
|
UART_PUTS_P(UART_STR_PROMPT);
|
|
uartcmd_clear_buffer();
|
|
longjmp(newmode_jmpbuf, new_mode);
|
|
#ifdef JOYSTICK_SUPPORT
|
|
} else {
|
|
UART_PUTS_P(UART_STR_GAMEMO_ERR);
|
|
}
|
|
#endif
|
|
} else {
|
|
UART_PUTS_P(UART_STR_MODE_ERR);
|
|
}
|
|
} else {
|
|
uartcmd_print_mode();
|
|
}
|
|
}
|
|
|
|
|
|
#if defined(ANIMATION_TESTS) && defined(JOYSTICK_SUPPORT)
|
|
/**
|
|
* Prints current joystick status via UART.
|
|
*/
|
|
static void uartcmd_joy_test(uint8_t *last) {
|
|
uint8_t joy_value = 0;
|
|
if (JOYISUP) {
|
|
joy_value |= UARTCMD_JOY_UP;
|
|
}
|
|
if (JOYISDOWN) {
|
|
joy_value |= UARTCMD_JOY_DOWN;
|
|
}
|
|
if (JOYISLEFT) {
|
|
joy_value |= UARTCMD_JOY_LEFT;
|
|
}
|
|
if (JOYISRIGHT) {
|
|
joy_value |= UARTCMD_JOY_RIGHT;
|
|
}
|
|
if (JOYISFIRE) {
|
|
joy_value |= UARTCMD_JOY_FIRE;
|
|
}
|
|
|
|
if (joy_value != *last) {
|
|
UART_PUTS_P(UART_STR_CLEARLINE);
|
|
if (joy_value & UARTCMD_JOY_UP) {
|
|
UART_PUTS_P(UART_STR_TEST_UP);
|
|
}
|
|
if (joy_value & UARTCMD_JOY_DOWN) {
|
|
UART_PUTS_P(UART_STR_TEST_DOWN);
|
|
}
|
|
if (joy_value & UARTCMD_JOY_LEFT) {
|
|
UART_PUTS_P(UART_STR_TEST_LEFT);
|
|
}
|
|
if (joy_value & UARTCMD_JOY_RIGHT) {
|
|
UART_PUTS_P(UART_STR_TEST_RIGHT);
|
|
}
|
|
if (joy_value & UARTCMD_JOY_FIRE) {
|
|
UART_PUTS_P(UART_STR_TEST_FIRE);
|
|
}
|
|
*last = joy_value;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
|
|
/**
|
|
* Draws test patterns for display inspection.
|
|
*/
|
|
static void uartcmd_test(void) {
|
|
#ifdef ANIMATION_TESTS
|
|
# ifdef JOYSTICK_SUPPORT
|
|
if (waitForFire) {
|
|
waitForFire = 0;
|
|
# endif
|
|
uartcmd_forbid();
|
|
int pattern_no = uartcmd_extract_num_arg(&g_rx_buffer[4]);
|
|
if (pattern_no >= 0 && pattern_no <= NUMPLANE + 2) {
|
|
UART_PUTS_P(UART_STR_TEST_EXIT);
|
|
if (pattern_no <= NUMPLANE) {
|
|
test_level(pattern_no, true);
|
|
} else if (pattern_no == (NUMPLANE + 1)) {
|
|
test_palette(true);
|
|
} else if (pattern_no == (NUMPLANE + 2)) {
|
|
test_palette2(true);
|
|
}
|
|
# ifdef JOYSTICK_SUPPORT
|
|
uint8_t last_joy_value = 0;
|
|
# endif
|
|
while (UART_GETC() >= 0x20){ // wait for any control character
|
|
# ifdef JOYSTICK_SUPPORT
|
|
uartcmd_joy_test(&last_joy_value);
|
|
wait(20);
|
|
# endif
|
|
}
|
|
} else {
|
|
char msg[36] = "";
|
|
snprintf_P(msg, sizeof(msg), UART_STR_TEST_ERR, NUMPLANE + 2);
|
|
UART_PUTS(msg);
|
|
}
|
|
uartcmd_permit();
|
|
# ifdef JOYSTICK_SUPPORT
|
|
waitForFire = 1;
|
|
} else {
|
|
UART_PUTS_P(UART_STR_GAMETS_ERR);
|
|
}
|
|
# endif
|
|
#else
|
|
UART_PUTS_P(UART_STR_NOTIMPL);
|
|
#endif
|
|
}
|
|
|
|
|
|
/**
|
|
* Perform a MCU reset by triggering the watchdog.
|
|
*/
|
|
static void uartcmd_reset_borg(void) {
|
|
timer0_off();
|
|
}
|
|
|
|
|
|
/**
|
|
* Appends new characters the buffer until a line break is entered.
|
|
* @return true if a line break was entered, false otherwise.
|
|
*/
|
|
static bool uartcmd_read_until_enter(void) {
|
|
static char last_line_break = '\n';
|
|
|
|
while (g_rx_index < (UART_BUFFER_SIZE - 1)) {
|
|
int uart_result = uart_getc();
|
|
|
|
if (uart_result < 0x100u) {
|
|
switch ((char)uart_result) {
|
|
case '\n': // line feed
|
|
case '\r': // carriage return
|
|
if ((g_rx_index > 0) || (uart_result == last_line_break)) {
|
|
UART_PUTS(CR);
|
|
g_rx_buffer[g_rx_index++] = 0;
|
|
last_line_break = uart_result;
|
|
return true;
|
|
}
|
|
break;
|
|
case '\b': // BS
|
|
case '\177': // DEL
|
|
if (g_rx_index != 0) {
|
|
g_rx_buffer[--g_rx_index] = 0;
|
|
UART_PUTS_P(UART_STR_BACKSPACE);
|
|
}
|
|
break;
|
|
case '\f': // Form Feed (Ctrl-L), reprints the line buffer
|
|
UART_PUTS_P(UART_STR_CLEARLINE); // clear current line
|
|
UART_PUTS_P(UART_STR_PROMPT); // output prompt
|
|
g_rx_buffer[g_rx_index] = 0; // terminate input buffer
|
|
UART_PUTS(g_rx_buffer); // finally reprint it
|
|
break;
|
|
case 21: // NAK (Ctrl-U), clears the line buffer
|
|
UART_PUTS_P(UART_STR_CLEARLINE); // clear current line
|
|
UART_PUTS_P(UART_STR_PROMPT); // output prompt
|
|
uartcmd_clear_buffer(); // clear buffer
|
|
break;
|
|
case 27: // ignore Esc
|
|
break;
|
|
default:
|
|
// We don't accept control characters which are not handled
|
|
// above. We also limit the input to 7 bit ASCII.
|
|
if ((uart_result < 0x20) || (uart_result > 0x7f)) {
|
|
UART_PUTC('\a'); // complain via ASCII bell
|
|
} else {
|
|
g_rx_buffer[g_rx_index++] = uart_result; // accept input
|
|
UART_PUTC(uart_result); // echo input back to terminal
|
|
}
|
|
break;
|
|
}
|
|
} else if ((uart_result & 0xFF00u) != UART_NO_DATA) {
|
|
uartcmd_clear_buffer();
|
|
UART_PUTS_P(UART_STR_UART_ERR);
|
|
UART_PUTS_P(UART_STR_PROMPT);
|
|
break;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (g_rx_index >= (UART_BUFFER_SIZE - 1)) {
|
|
uartcmd_clear_buffer();
|
|
UART_PUTS_P(UART_STR_TOOLONG);
|
|
UART_PUTS_P(UART_STR_PROMPT);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
/**
|
|
* Checks for entered commands and dispatches them to the appropriate handler.
|
|
*/
|
|
void uartcmd_process(void) {
|
|
if (uartcmd_processing_allowed() && uartcmd_read_until_enter()) {
|
|
if (!strncmp_P(g_rx_buffer, UART_CMD_ERASE, UART_BUFFER_SIZE)) {
|
|
uartcmd_erase_eeprom();
|
|
} else if (!strncmp_P(g_rx_buffer, UART_CMD_HELP, UART_BUFFER_SIZE)) {
|
|
UART_PUTS_P(UART_STR_HELP);
|
|
} else if (!strncmp_P(g_rx_buffer, UART_CMD_MODE, 4)) {
|
|
uartcmd_mode();
|
|
} else if (!strncmp_P(g_rx_buffer, UART_CMD_MSG, 4)) {
|
|
uartcmd_simple_message();
|
|
} else if (!strncmp_P(g_rx_buffer, UART_CMD_NEXT, UART_BUFFER_SIZE)) {
|
|
uartcmd_next_anim();
|
|
} else if (!strncmp_P(g_rx_buffer, UART_CMD_PREV, UART_BUFFER_SIZE)) {
|
|
uartcmd_prev_anim();
|
|
} else if (!strncmp_P(g_rx_buffer, UART_CMD_RESET, UART_BUFFER_SIZE)) {
|
|
uartcmd_reset_borg();
|
|
} else if (!strncmp_P(g_rx_buffer, UART_CMD_SCROLL, 7)) {
|
|
uartcmd_scroll_message();
|
|
} else if (!strncmp_P(g_rx_buffer, UART_CMD_TEST, 4)) {
|
|
uartcmd_test();
|
|
} else if (g_rx_buffer[0] != 0) {
|
|
UART_PUTS_P(UART_STR_UNKNOWN);
|
|
}
|
|
UART_PUTS_P(UART_STR_PROMPT);
|
|
uartcmd_clear_buffer();
|
|
}
|
|
}
|