Subversion Repositories neo430

// #################################################################################################
// #  < Conway's Game of Life >                                                                    #
// # ********************************************************************************************* #
// # BSD 3-Clause License                                                                          #
// #                                                                                               #
// # Copyright (c) 2020, Stephan Nolting. All rights reserved.                                     #
// #                                                                                               #
// # Redistribution and use in source and binary forms, with or without modification, are          #
// # permitted provided that the following conditions are met:                                     #
// #                                                                                               #
// # 1. Redistributions of source code must retain the above copyright notice, this list of        #
// #    conditions and the following disclaimer.                                                   #
// #                                                                                               #
// # 2. Redistributions in binary form must reproduce the above copyright notice, this list of     #
// #    conditions and the following disclaimer in the documentation and/or other materials        #
// #    provided with the distribution.                                                            #
// #                                                                                               #
// # 3. Neither the name of the copyright holder nor the names of its contributors may be used to  #
// #    endorse or promote products derived from this software without specific prior written      #
// #    permission.                                                                                #
// #                                                                                               #
// # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS   #
// # OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF               #
// # MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE    #
// # COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,     #
// # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE #
// # GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED    #
// # AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING     #
// # NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED  #
// # OF THE POSSIBILITY OF SUCH DAMAGE.                                                            #
// # ********************************************************************************************* #
// # The NEO430 Processor - https://github.com/stnolting/neo430                                    #
// #################################################################################################
 
 
// Libraries
#include <stdint.h>
#include <neo430.h>
 
// Configuration
#define NUM_CELLS_X   160 // must be a multiple of 8
#define NUM_CELLS_Y   40
#define BAUD_RATE     19200
#define GEN_DELAY     500 // delay between iterations in ms
#define TRNG_TAP_MASK 0b01010001000000 // highly experimental!
 
// Global variables
uint8_t universe[2][NUM_CELLS_X/8][NUM_CELLS_Y];
 
// Prototypes
void clear_universe(uint8_t u);
void set_cell(uint8_t u, int16_t x, int16_t y);
uint8_t get_cell(uint8_t u, int16_t x, int16_t y);
uint8_t get_neighborhood(uint8_t u, int16_t x, int16_t y);
void print_universe(uint8_t u);
uint16_t pop_count(uint8_t u);
 
 
/* ------------------------------------------------------------
 * INFO Main function
 * ------------------------------------------------------------ */
int main(void) {
 
  uint8_t u = 0, cell = 0, n = 0;
  int16_t x, y;
  uint16_t trng_available = 0;
  uint8_t trng_data = 0;
 
  // setup UART
  neo430_uart_setup(BAUD_RATE);
 
 
  // initialize universe
  uint32_t generation = 0;
  clear_universe(0);
  clear_universe(1);
 
  neo430_printf("\n\n<<< Conways's Game of Life >>>\n\n");
  neo430_printf("This program requires a terminal resolution of at least %ux%u characters.\n", NUM_CELLS_X+2, NUM_CELLS_Y+3);
  neo430_printf("Press any key to start a random-initialized torus-style universe of %ux%u cells.\n", NUM_CELLS_X, NUM_CELLS_Y);
  neo430_printf("You can pause/restart the simulation by pressing any key.\n");
 
  // check if TRNG was synthesized
  if ((SYS_FEATURES & (1<<SYS_TRNG_EN))) {
    neo430_printf("TRNG detected. Using TRNG for universe initialization.\n");
    neo430_trng_enable(TRNG_TAP_MASK);
    trng_available = 1;
  }
 
  if (trng_available) {
    neo430_uart_getc(); // wait for pressed key
  }
  else {
    // randomize until key pressed
    while (neo430_uart_char_received() == 0) {
      neo430_xorshift32();
    }
  }
 
  // initialize universe using random data
  for (x=0; x<NUM_CELLS_X/8; x++) {
    for (y=0; y<NUM_CELLS_Y; y++) {
      if (trng_available) {
        if (neo430_trng_get(&trng_data)) {
          neo430_printf("TRNG error!\n");
          return 1;
        }
        universe[0][x][y] = (uint8_t)trng_data; // use data from TRNG
      }
      else {
        universe[0][x][y] = (uint8_t)neo430_xorshift32(); // use data von PRNG
      }
    }
  }
 
  while(1) {
 
    // user abort?
    if (neo430_uart_char_received()) {
      neo430_printf("\nRestart (y/n)?");
      if (neo430_uart_getc() == 'y') {
        neo430_soft_reset();
      }
    }
 
    // print generation, population count and the current universe
    neo430_printf("\n\nGeneration %l: %u/%u living cells\n", generation, pop_count(u), NUM_CELLS_X*NUM_CELLS_Y);
    print_universe(u);
 
    // compute next generation
    clear_universe((u + 1) & 1);
 
    for (x=0; x<NUM_CELLS_X; x++) {
      for (y=0; y<NUM_CELLS_Y; y++) {
 
        cell = get_cell(u, x, y); // state of current cell
        n = get_neighborhood(u, x, y); // number of living neighbor cells
 
        // classic rule set
        if (((cell == 0) && (n == 3)) || ((cell != 0) && ((n == 2) || (n == 3)))) {
          set_cell((u + 1) & 1, x, y);
        }
 
      } // y
    } // x
    u = (u + 1) & 1; // switch universe
    generation++;
 
    // wait 500ms
    neo430_cpu_delay_ms(GEN_DELAY);
  }
 
  return 0;
}
 
 
/* ------------------------------------------------------------
 * INFO Print universe u to console
 * ------------------------------------------------------------ */
void print_universe(uint8_t u){
 
  int16_t x, y;
 
  neo430_uart_putc('+');
  for (x=0; x<NUM_CELLS_X; x++) {
    neo430_uart_putc('-');
  }
  neo430_uart_putc('+');
  neo430_uart_putc('\r');
  neo430_uart_putc('\n');
 
  for (y=0; y<NUM_CELLS_Y; y++) {
    neo430_uart_putc('|');
 
    for (x=0; x<NUM_CELLS_X; x++) {
      if (get_cell(u, x, y))
        neo430_uart_putc('#');
      else
        neo430_uart_putc(' ');
    }
 
    // end of line
    neo430_uart_putc('|');
    neo430_uart_putc('\r');
    neo430_uart_putc('\n');
  }
 
  neo430_uart_putc('+');
  for (x=0; x<NUM_CELLS_X; x++) {
    neo430_uart_putc('-');
  }
  neo430_uart_putc('+');
}
 
 
/* ------------------------------------------------------------
 * INFO Clear universe u
 * ------------------------------------------------------------ */
void clear_universe(uint8_t u){
 
  uint16_t x, y;
 
  for (x=0; x<NUM_CELLS_X/8; x++) {
    for (y=0; y<NUM_CELLS_Y; y++) {
      universe[u][x][y] = 0;
    }
  }
}
 
 
/* ------------------------------------------------------------
 * INFO Set single cell (make ALIVE) in uinverse u
 * ------------------------------------------------------------ */
void set_cell(uint8_t u, int16_t x, int16_t y){
 
  if ((x >= NUM_CELLS_X) || (y >= NUM_CELLS_Y))
    return; // out of range
 
  universe[u][x>>3][y] |= 1 << (7 - (x & 7));
}
 
 
/* ------------------------------------------------------------
 * INFO Get state of cell
 * RETURN Cell state (DEAD or ALIVE)
 * ------------------------------------------------------------ */
uint8_t get_cell(uint8_t u, int16_t x, int16_t y){
 
  // range check: wrap around -> torus-style universe
  if (x < 0)
    x = NUM_CELLS_X-1;
 
  if (x > NUM_CELLS_X-1)
    x = 0;
 
  if (y < 0)
    y = NUM_CELLS_Y-1;
 
  if (y > NUM_CELLS_Y-1)
    y = 0;
 
  // check bit according to cell
  uint8_t tmp = universe[u][x>>3][y];
  tmp &= 1 << (7 - (x & 7));
 
  if (tmp == 0)
    return 0; // DEAD
  else
    return 1; // ALIVE
}
 
 
/* ------------------------------------------------------------
 * INFO Get number of alive cells in direct neigborhood
 * RETURN Number of set cells in neigborhood
 * ------------------------------------------------------------ */
uint8_t get_neighborhood(uint8_t u, int16_t x, int16_t y){
 
// Cell index layout:
// 012
// 3#4
// 567
 
  uint8_t num = 0;
  num += get_cell(u, x-1, y-1); // 0
  num += get_cell(u, x,   y-1); // 1
  num += get_cell(u, x+1, y-1); // 2
  num += get_cell(u, x-1, y);   // 3
  num += get_cell(u, x+1, y);   // 4
  num += get_cell(u, x-1, y+1); // 5
  num += get_cell(u, x,   y+1); // 6
  num += get_cell(u, x+1, y+1); // 7
 
  return num;
}
 
 
/* ------------------------------------------------------------
 * INFO Population count
 * RETURN 16-bit number of living cells in universe u
 * ------------------------------------------------------------ */
uint16_t pop_count(uint8_t u) {
 
  uint16_t x, y, cnt;
 
  cnt = 0;
  for (x=0; x<NUM_CELLS_X; x++) {
    for (y=0; y<NUM_CELLS_Y; y++) {
      cnt += (uint16_t)get_cell(u, x, y);
    }
  }
 
  return cnt;
}