LIFE STM8s

#include <intrinsics.h>
#include <iostm8s103f3.h>
#include "types.h"
#include "system.c"
#include "Random.c"

//------------------------------------------------------------------------------
//
//  Settings Modify these to suit your specific setup
//
#define ROWS 8
#define COLUMNS 8

#define COLUMN0 PB_ODR_ODR0
#define COLUMN1 PC_ODR_ODR6
#define COLUMN2 PB_ODR_ODR2
#define COLUMN3 PB_ODR_ODR3
#define COLUMN4 PB_ODR_ODR4
#define COLUMN5 PB_ODR_ODR5
#define COLUMN6 PB_ODR_ODR6
#define COLUMN7 PB_ODR_ODR7

#define ROW0 PD_ODR_ODR0
#define ROW1 PC_ODR_ODR7
#define ROW2 PD_ODR_ODR2
#define ROW3 PD_ODR_ODR3
#define ROW4 PD_ODR_ODR4
#define ROW5 PD_ODR_ODR5
#define ROW6 PD_ODR_ODR6
#define ROW7 PD_ODR_ODR7

#define RNDSRC ADC

//------------------------------------------------------------------------------
//
//  End of settings, do not modify anything beyond this point
//

char PREVField[ROWS][COLUMNS];
char SNDPREVField[ROWS][COLUMNS];
char field[ROWS][COLUMNS];
char firstGen = 1;

void UpdateDisplay( void );
void SetRow( char, char );
void SetColumn( char, char );
void Set( char, char, char );
void Delay( int );
void BlankDisplay( void );
void DrawLetter( char );
void IterateField( void );
void ClearField( void );

#include "Patterns.c"


//------------------------------------------------------------------------------
//
//  Iterate the the field when the interrupt fires
//
#pragma vector = TIM2_OVR_UIF_vector
__interrupt void TIM2_UPD_OVF_IRQHandler()
{
  __disable_interrupt();

  IterateField();
  //UpdateDisplay();
  PC_ODR_ODR4 = !PC_ODR_ODR4;

  TIM2_SR1_UIF = 0;

  __enable_interrupt();
}

//------------------------------------------------------------------------------
//
//  Setup the field wtih 0s
//
void InitField(char field[ROWS][COLUMNS])
{
  firstGen = 1;
  ClearField();
  return;
}

//------------------------------------------------------------------------------
//
//  Check if the previous field is a duplicate of the current field.
//
char IsDuplicate()
{
  for(int i = 0; i < ROWS; i++)
  {
    for(int j = 0; j < COLUMNS; j++)
    {
      if(PREVField[i][j] != field[i][j] && SNDPREVField[i][j] != field[i][j])
      {
        return 0;
      }
    }
  }
  return 1;
}

//------------------------------------------------------------------------------
//
//  Generate a random field
//
void GenerateRandomField( void )
{
  for(int i = 0; i < ROWS; i++)
  {
    for(int j = 0; j < COLUMNS; j++)
    {
      field[i][j] = GetRandomBit(RNDSRC);
    }
  }
}

//------------------------------------------------------------------------------
//
//  Iterate the fields following the rules of Conway's game of life.
//
void IterateField()
{
  /*
   *  First create a copy of the field we use the copy as a reference
   *  the field is then updated directly.
   *
   */

  char fieldCopy[ROWS][COLUMNS];

  int count = 0;

  if(IsDuplicate())
    GenerateRandomField();

  //Copy the current field to the comparison copy
  for(int i = 0; i < ROWS; i++)
  {
      for(int j = 0; j < COLUMNS; j++)
      {
        {
          SNDPREVField[i][j] = PREVField[i][j];
          PREVField[i][j] = field[i][j];
          fieldCopy[i][j] = field[i][j];
        }
    }
  }

  for(int i = 0; i < ROWS; i++)
  {
    for(int j = 0; j < COLUMNS; j++)
    {
      count = 0;

      //if i < 1 no need to check left
      //if j < 1 no need to check up

      //Up 1 Left 1
      if((i > 0 && j > 0) && fieldCopy[i - 1][j - 1] == 1)
        count++;

      //Up 1 Right 1
      if((i > 0 && j < 7) && fieldCopy[i - 1][j + 1] == 1)
        count++;


      //Left 1
      if(j > 0 && fieldCopy[i][j - 1] == 1)
        count++;

      //Right 1
      if(j < 7 && fieldCopy[i][j + 1] == 1)
        count++;

      //down 1
      if(i < 7 && fieldCopy[i + 1][j] == 1)
        count++;

      //up 1
      if(i > 0 && fieldCopy[i - 1][j] == 1)
        count++;


      //down 1 left 1
      if((i < 7 && j > 0) && fieldCopy[i + 1][j - 1] == 1)
        count++;
      //down 1 right 1
      if((i < 7 && j < 7) && fieldCopy[i + 1][j + 1] == 1)
        count++;

      //<2 live neighbors, under-population
      if(count < 2)
        field[i][j] = 0;

      //2 or 3 live neighbords, lives
      if(count == 3)
        field[i][j]  = 1;

      //>3 live neighbors, over-population
      if(count > 3)
        field[i][j] = 0;
    }
  }
}

//------------------------------------------------------------------------------
//
//  Shift the entire array left 1 column, loop the leftmost column to the right
//
void ShiftLeft( void )
{
  char leftmost[] = {0,0,0,0,0,0,0,0};

  for(int i = 0; i < ROWS; i++)
  {
    for(int j = 0; j < COLUMNS; j++)
    {
      if(j == 0)
        leftmost[i] = field[i][j];

      if(j < COLUMNS - 1)
        field[i][j] = field[i][j + 1];
    }
  }
  for(int i = 0; i < 8; i++)
  {
    field[i][COLUMNS - 1] = leftmost[i];
  }
}

//------------------------------------------------------------------------------
//
// Shift the entire array right 1 column, loop the rightmost column to the left
//
void ShiftRight( void )
{
  char rightmost[] = {0,0,0,0,0,0,0,0};

  for(int i = 0; i < ROWS; i++)
  {
    for(int j = 0; j < COLUMNS; j++)
    {
      if(j == COLUMNS - 1)
        rightmost[i] = field[i][j];

      if(j > 0)
        field[i][j] = field[i][j - 1];
    }
  }
  for(int i = 0; i < 8; i++)
  {
    field[i][0] = rightmost[i];
  }
}

//------------------------------------------------------------------------------
//
//  Update the display with the current field, and multiplex
//
void UpdateDisplay( void )
{
  for(int i = 0; i < ROWS; i++)
  {
    for(int j = 0; j < COLUMNS; j++)
    {
      BlankDisplay();
      if(field[i][j])
      {
        ROW0 = (i == 0);
        ROW1 = (i == 1);
        ROW2 = (i == 2);
        ROW3 = (i == 3);
        ROW4 = (i == 4);
        ROW5 = (i == 5);
        ROW6 = (i == 6);
        ROW7 = (i == 7);
        COLUMN0 = !(j == 0);
        COLUMN1 = !(j == 1);
        COLUMN2 = !(j == 2);
        COLUMN3 = !(j == 3);
        COLUMN4 = !(j == 4);
        COLUMN5 = !(j == 5);
        COLUMN6 = !(j == 6);
        COLUMN7 = !(j == 7);
      }
    }
  }
}

//------------------------------------------------------------------------------
//
//  Write the entire field to 0
//
void ClearField( void )
{
  for(int i = 0; i < ROWS; i++)
  {
    for(int j = 0; j < COLUMNS; j++)
    {
      field[i][j] = 0;
    }
  }
}

//------------------------------------------------------------------------------
//
//  ReInit the display and flash the display
//
void Reset( void )
{
  FillDisplay();
  Delay(10000);
  BlankDisplay();
  Delay(10000);
  FillDisplay();
  Delay(10000);
  BlankDisplay();
  Delay(10000);
  InitField(field);
}

//------------------------------------------------------------------------------
//
//
//
void main( void )
{
  //Disable interrupts while everything is setup
  __disable_interrupt();

  //Initialise hardware and software
  init();

  //Setup the array with 0s
  InitField(field);

  //Generate a random field
  //GenerateRandomField();

  //Generate a glider, bottom left
  CreateGlider();

  //enable interrupts so that iterations can start taking place
  __enable_interrupt();

  //Main Loop
  while(TRUE)
  {
    //Update the display & keep the multiplexing going;
    UpdateDisplay();
  }
}