Subversion Repositories neorv32

// #################################################################################################
// # << NEORV32 - 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 NEORV32 Processor - https://github.com/stnolting/neorv32              (c) Stephan Nolting #
// #################################################################################################
 
 
/**********************************************************************//**
 * @file blink_led/main.c
 * @author Stephan Nolting
 * @brief Simple blinking LED demo program using the lowest 8 bits of the GPIO.output port.
 **************************************************************************/
 
#include <neorv32.h>
 
 
/**********************************************************************//**
 * @name User configuration
 **************************************************************************/
/**@{*/
/** UART BAUD rate */
#define BAUD_RATE     19200
/** Universe x size (has to be a multiple of 8) */
#define NUM_CELLS_X   160
/** Universe y size */
#define NUM_CELLS_Y   40
/** Delay between generations in ms */
#define GEN_DELAY     500
/**@}*/
 
 
 
/**********************************************************************//**
 * The universe
 **************************************************************************/
uint8_t universe[2][NUM_CELLS_X/8][NUM_CELLS_Y];
 
// Prototypes
void clear_universe(int u);
void set_cell(int u, int x, int y);
int get_cell(int u, int x, int y);
int get_neighborhood(int u, int x, int y);
void print_universe(int u);
int pop_count(int u);
uint32_t xorshift32(void);
 
 
/**********************************************************************//**
 * Conway's Game of Life.
 *
 * @note This program requires the UART to be synthesized (the TRNG is optional).
 *
 * @return Irrelevant.
 **************************************************************************/
int main(void) {
 
  // check if UART unit is implemented at all
  if (neorv32_uart_available() == 0) {
    return 0;
  }
 
 
  // capture all exceptions and give debug info via UART
  // this is not required, but keeps us safe
  neorv32_rte_enable_debug_mode();
 
 
  // init UART at default baud rate, no rx interrupt, no tx interrupt
  neorv32_uart_setup(BAUD_RATE, 0, 0);
 
 
  while (1) {
 
    int u = 0, cell = 0, n = 0;
    int x, y;
    int trng_available = 0;
    uint16_t trng_data;
 
 
    // initialize universe
    uint32_t generation = 0;
    clear_universe(0);
    clear_universe(1);
 
    // intro
    neorv32_uart_printf("\n\n<<< Conways's Game of Life >>>\n\n");
    neorv32_uart_printf("This program requires a terminal resolution of at least %ux%u characters.\n", NUM_CELLS_X+2, NUM_CELLS_Y+3);
    neorv32_uart_printf("Press any key to start a random-initialized torus-style universe of %ux%u cells.\n", NUM_CELLS_X, NUM_CELLS_Y);
    neorv32_uart_printf("You can pause/restart the simulation by pressing any key.\n");
 
 
    // check if TRNG was synthesized
    if (neorv32_trng_available()) {
      uint16_t trng_tap_config = neorv32_trng_find_tap_mask();
      neorv32_trng_setup(trng_tap_config);
      neorv32_uart_printf("\nTRNG detected (tap mask 0x%x). Using TRNG for universe initialization.\n", (uint32_t)trng_tap_config);
      trng_available = 1;
    }
 
 
    // randomize until key pressed
    while (neorv32_uart_char_received() == 0) {
      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 (neorv32_trng_get(&trng_data)) {
            neorv32_uart_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)xorshift32(); // use data from PRNG
        }
      }
    }
 
 
    while(1) {
 
      // user abort?
      if (neorv32_uart_char_received()) {
        neorv32_uart_printf("\nRestart (y/n)?");
        if (neorv32_uart_getc() == 'y') {
          break;
        }
      }
 
      // print generation, population count and the current universe
      neorv32_uart_printf("\n\nGeneration %u: %u/%u living cells\n", (uint32_t)generation, (uint32_t)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 GEN_DELAY ms
      neorv32_cpu_delay_ms(GEN_DELAY);
    }
 
  }
 
  return 0;
}
 
 
/**********************************************************************//**
 * Print universe via UARt.
 *
 * @param[in] u Universe select (0 or 1).
 **************************************************************************/
void print_universe(int u){
 
  int16_t x, y;
 
  neorv32_uart_putc('+');
  for (x=0; x<NUM_CELLS_X; x++) {
    neorv32_uart_putc('-');
  }
  neorv32_uart_putc('+');
  neorv32_uart_putc('\r');
  neorv32_uart_putc('\n');
 
  for (y=0; y<NUM_CELLS_Y; y++) {
    neorv32_uart_putc('|');
 
    for (x=0; x<NUM_CELLS_X; x++) {
      if (get_cell(u, x, y))
        neorv32_uart_putc('#');
      else
        neorv32_uart_putc(' ');
    }
 
    // end of line
    neorv32_uart_putc('|');
    neorv32_uart_putc('\r');
    neorv32_uart_putc('\n');
  }
 
  neorv32_uart_putc('+');
  for (x=0; x<NUM_CELLS_X; x++) {
    neorv32_uart_putc('-');
  }
  neorv32_uart_putc('+');
}
 
 
/**********************************************************************//**
 * Kill all cells in universe.
 *
 * @param[in] u Universe select (0 or 1).
 **************************************************************************/
void clear_universe(int 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;
    }
  }
}
 
 
/**********************************************************************//**
 * Make cell alive.
 *
 * @param[in] u Universe select (0 or 1).
 * @param[in] x X coordinate of cell.
 * @param[in] y Y coordinate of cell.
 **************************************************************************/
void set_cell(int u, int x, int y){
 
  if ((x >= NUM_CELLS_X) || (y >= NUM_CELLS_Y))
    return; // out of range
 
  universe[u][x>>3][y] |= (uint8_t)(1 << (7 - (x & 7)));
}
 
 
/**********************************************************************//**
 * Get state of cell.
 *
 * @param[in] u Universe select (0 or 1).
 * @param[in] x X coordinate of cell.
 * @param[in] y Y coordinate of cell.
 * @return Cell is dead when 0, cell is alive when 1.
 **************************************************************************/
int get_cell(int u, int x, int 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
}
 
 
/**********************************************************************//**
 * Get number of living cells in neighborhood.
 *
 * @param[in] u Universe select (0 or 1).
 * @param[in] x X coordinate of the neighborhood's center cell.
 * @param[in] y Y coordinate of the neighborhood's center cell.
 * @return Number of living cells in neighborhood (0..9).
 **************************************************************************/
int get_neighborhood(int u, int x, int y){
 
// Cell index layout:
// 012
// 3#4
// 567
 
  int 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;
}
 
 
/**********************************************************************//**
 * Count living cells in universe.
 *
 * @param[in] u Universe select (0 or 1).
 * @return Number of living cells.
 **************************************************************************/
int pop_count(int u) {
 
  int x, y, cnt;
 
  cnt = 0;
  for (x=0; x<NUM_CELLS_X; x++) {
    for (y=0; y<NUM_CELLS_Y; y++) {
      cnt += (int)get_cell(u, x, y);
    }
  }
 
  return cnt;
}
 
 
/**********************************************************************//**
 * Simple pseudo random number generator.
 *
 * @return Random number.
 **************************************************************************/
uint32_t xorshift32(void) {
 
  static uint32_t x32 = 314159265;
 
  x32 ^= x32 << 13;
  x32 ^= x32 >> 17;
  x32 ^= x32 << 5;
 
  return x32;
}