attempt at a overly graphical menu on a 8x8 led matrix

menu_graphics.c

#include <Energia.h>
#include <SPI.h>
#include "EnergiaMax7219.h"
#include "font2.h"

#define numberofstars 8

#define LEFT 1
#define RIGHT 2
#define UP 3
#define DOWN 4

#define xoffset 4
#define yoffset 4

#define maxvirtxres 64
#define maxvirtyres 64

int stardirection = RIGHT;
int starspeed = 5;

#define maxzdepth 12
#define minzdepth 7

EnergiaMax7219 ledmatrix;
uint32_t numberOfCharacters = sizeof(font) / 8, startingIndex;

struct star {
  int x;
  int y;
  byte z;
};

star stars[numberofstars];

byte framebuffer[8];
byte menulayer[8];

void initstars() {
  // set all stars to random position
  int i;
  for (i = 0; i < numberofstars; i++) {
    initstar(i);
  }
}

void initstar(int star) {
  stars[star].x = random(maxvirtxres*2)-maxvirtxres;
  stars[star].y = random(maxvirtyres*2)-maxvirtyres;
  stars[star].z = random(minzdepth,maxzdepth);
}

void updatestars() {
//  tone(GREEN_LED,0,1);
  // update position of stars
  int i;
  for (i = 0; i < numberofstars; i++) {

    switch (stardirection) {
      case LEFT:
        stars[i].x = stars[i].x - (starspeed);
        if (stars[i].x < -maxvirtxres) {
          initstar(i);
          stars[i].x = maxvirtxres;
        } 
        break;
      case RIGHT:
        stars[i].x = stars[i].x + (starspeed);
        if (stars[i].x > maxvirtxres) {
          initstar(i);
          stars[i].x = -maxvirtxres;
        }
        break;
      case UP:
        stars[i].y = stars[i].y - (starspeed);
        if (stars[i].y < -maxvirtyres) {
          initstar(i);
          stars[i].y = maxvirtyres;
        }
        break;
      case DOWN:
        stars[i].y = stars[i].y + (starspeed);
        if (stars[i].y > maxvirtyres) {
          initstar(i);
          stars[i].y = -maxvirtyres;
        }
        break;
    }
    

    
  }
}

void renderstars() {
  int i;
  int x2,y2;
  for (i = 0; i < numberofstars; i++) {

  x2 = (stars[i].x / stars[i].z) + xoffset;
  y2 = (stars[i].y / stars[i].z) + yoffset;
  
//  x2 = constrain(x2,0,7);
//  y2 = constrain(y2,0,7);
  
    if (1){
  Serial.print("star ");
  Serial.print(i);
  
  Serial.print(" x ");
  Serial.print(stars[i].x);
  Serial.print(" y ");
  Serial.print(stars[i].y);
  Serial.print(" z ");
  Serial.print(stars[i].z);
  
  Serial.print(" x2 ");
  Serial.print(x2);
  Serial.print(" y2 ");
  Serial.println(y2);
    }
    if ((y2 < 8) && (x2 <8) && (y2 >= 0) && (x2 >= 0) ) {
      bitSet(framebuffer[y2], x2);
    }
  }
}
/*  
#define bitRead(value, bit) (((value) >> (bit)) & 0x01)
#define bitSet(value, bit) ((value) |= (1UL << (bit)))
#define bitClear(value, bit) ((value) &= ~(1UL << (bit)))
#define bitWrite(value, bit, bitvalue) (bitvalue ? bitSet(value, bit) : bitClear(value, bit))
*/
 
void clearframebuffer() {
  int i;
  
  for (i = 0; i < 8; i++) {
    framebuffer[i] = 0;
  } 
}

void displayframebuffer() {
  int i;
  
  for (i = 0; i < 8; i++) {
    ledmatrix.Write(_max7219_register_digit_0 + i, framebuffer[i]);
  }
}

void rendercharacter( uint8_t* data, int offset) {
  
  int i;
  
  for (i=offset; i < 8 + offset; i++){
    menulayer[i - offset] = 0;
    if ((i<8) && (i>=0)) {
      menulayer[i] = *(data + (i - offset));
//      framebuffer[i] = framebuffer[i] | *(data + (i - offset));
    }
  }
}


void mergedown() {
  int i;
  
  for (i=0; i < 8; i++){
    framebuffer[i] = framebuffer[i] | menulayer[i];
  }
}


#define encoderpinA PD_0
#define encoderpinB PD_1
#define encoderClick PD_2


void setup() {
  // put your setup code here, to run once:
  ledmatrix.Initialize(DISPLAY_TEST_OFF, 0x9);
  randomSeed(analogRead(2));
  initstars();
    pinMode(encoderClick, INPUT_PULLUP);

  pinMode(encoderpinA, INPUT_PULLUP);
  pinMode(encoderpinB, INPUT_PULLUP);
  
  
  attachInterrupt(encoderpinA, doencoderA, CHANGE);
  attachInterrupt(encoderpinB, doencoderB, CHANGE);
  attachInterrupt(encoderClick, blink, FALLING);
  
  Serial.begin(115200);
  Serial.println("hallodaar");
  
}

volatile unsigned int encoderpos = 0;
static boolean rotating=false;      // debounce management

signed long next_poll;
signed long next_poll2;
unsigned long richtingvertel_interval = 1000;
unsigned long redraw_interval = 150;

void loop() {
  // put your main code here, to run repeatedly:

  if (((signed long)(millis() - next_poll2)) > 0)
  {
    next_poll2 = millis() + redraw_interval;

    updatestars();
    renderstars();
    rendercharacter(&font[encoderpos * 8],-1);
    mergedown();
    displayframebuffer();
    clearframebuffer();
  }
  
  rotating = true; 
    
  if (((signed long)(millis() - next_poll)) > 0)
  {
     next_poll = millis() + richtingvertel_interval;
     //Serial.println(stardirection);
     tone(RED_LED,66,1);
  }

}

volatile int Aold = 0;
volatile int Anew = 0;
volatile int Bold = 0;
volatile int Bnew = 0;


boolean A_set = false;              
boolean B_set = false;

unsigned int lastReportedPos = 1;

volatile long lastDebounceTime = 0;
volatile long debounceDelay = 8;


void doencoderA(){
  if ( rotating ) delay (debounceDelay);
  if( digitalRead(encoderpinA) != A_set ) { 
    A_set = !A_set;
    if ( A_set && !B_set ) encoderpos += 1;
    rotating = false;
  }
  if (encoderpos > 128) { encoderpos = 0; }
}

void doencoderB(){
  if ( rotating ) delay (debounceDelay);
  if( digitalRead(encoderpinB) != B_set ) {
    B_set = !B_set;
    if( B_set && !A_set ) encoderpos -= 1;
    rotating = false;
  }
  if (encoderpos < 0) { encoderpos = 128; }
}

void blink() {
  stardirection++;
  if (stardirection>4) { stardirection = 1; }
}