seg_racer.c

#include _ADC_HEADER_
//   #include <stdio.h>
#include <stdlib.h>   //rand()


void racer_init(void)
{
	adc_takeInput(6);
	adc_init();
	adc_select(6);
}




//For converting an integer to text-characters without using sprintf...
// Call once with the value to be written, and newVal TRUE
// then call repeatedly with the same value and newVal FALSE
// in order to grab each decimal digit in an entire uint32 from left to
// right.
//Returns 0-9 or -1 if we've reached 0...
int8_t grabDecimal_u32(uint32_t value, uint8_t newVal)
{
   static uint32_t divisor = 1000000000;

   static uint32_t thisVal;

   if(newVal)
   {
      divisor = 1000000000;
      thisVal = value;
   }

   uint8_t decimal = 0;



   if(divisor == 0)
      return -1;

   while(thisVal >= divisor)
   {
      decimal++;
      thisVal -= divisor;

   }




   divisor /= 10;

   return decimal;
}


//Including raceWidth, and maybe some buffer...
#define RACE_WIDTH_PSEGS   272


//Returns the number of psegs drawn...
uint8_t showScore(uint16_t rowNum, uint32_t score, uint8_t color)
{

   //The first few rows aren't displaying?
//      rowNum-=6;
      int8_t decimal;
      uint8_t scoreFound = FALSE;

      static uint32_t thisScore;

      if(rowNum == 0)
         thisScore = score; // goodCount;

      decimal = grabDecimal_u32(thisScore, 1);

      uint8_t col;

      uint8_t charRow = 0;

		uint8_t psegs = 0;

      for(col=0; col<NUM_PSEGS-3-RACE_WIDTH_PSEGS; col++)
      {
			psegs++;
//         uint8_t charRow = 0;
         
         if(col%8==0)
         {
            if((decimal != 0) && (decimal != -1))
               scoreFound = TRUE;

            if((decimal == -1) || (!scoreFound))
               charRow = 0;
            else
               charRow = getCharRow(decimal+'0', rowNum/2);
            decimal = grabDecimal_u32(thisScore, 0);
         }

         if(getbit(col%8, charRow))
            addSegfb(1,color);
         else
            addSegfb(1,_B);
      }

		return psegs;
}   



void racer_loadRow(uint16_t rowNum) 
{
  #define NEXT_COLOR   _R
  #define THIS_COLOR   _G
  #define OVERLAP_COLOR   _Y
  #define BG_COLOR   _C
  #define BG_BAD_COLOR   _M



   int16_t racerPseg = NUM_PSEGS/2 - 2;

   adc_startConversion();
   while(adc_isBusy())
      asm("nop;");
   racerPseg = (adc_getValue()>>2)+5;
   if(racerPseg > NUM_PSEGS-2)
      racerPseg = NUM_PSEGS-2;

   segClear();
   addSegfb(1, _W);
   static uint16_t raceWidth = 16;
   static uint8_t trackPosition = 0;
  #define TRACK_LENGTH   24   //24*32 = 768
  #define TRACK_ROWS   (V_COUNT/TRACK_LENGTH)
   static uint16_t raceTrack[TRACK_LENGTH*2];

   uint8_t bgColor = BG_COLOR;

   //racePseg += ((rand()&0xff0)>>4)*2/0xff - 1;

   uint8_t thisTrackRow = rowNum/TRACK_ROWS; //(V_COUNT/TRACK_LENGTH);
   uint8_t thisPosition = thisTrackRow + (trackPosition? TRACK_LENGTH : 0);
   uint8_t nextPosition = thisTrackRow + (trackPosition? 0 : TRACK_LENGTH);

   static hfm_t thisSmoothingHFM, nextSmoothingHFM;
   static uint8_t thisTrackGrowing, nextTrackGrowing;

/*
   static theta_t racerTheta = 0;
   if(racerTheta >= SINE_2PI)
      racerTheta -= SINE_2PI;

   racerPseg = sineRaw8(racerTheta) + -(INT8_MIN);
   racerTheta++;
*/

   uint8_t outOfTrack = FALSE;
   typedef struct _IST_BLAH_
   {
      uint16_t length;
      uint8_t color;
   }   intermediateSeg_t;

#define ISEGS_PER_WHATEVER   3
#define IS_SEGS (5*ISEGS_PER_WHATEVER)
   intermediateSeg_t is[IS_SEGS] = 
   { {0,_W}, {0,_W}, {0,_W}, {0,_W}, {0,_W},
     {0,_W}, {0,_W}, {0,_W}, {0,_W}, {0,_W},
     {0,_W}, {0,_W}, {0,_W}, {0,_W}, {0,_W} };

   uint8_t isPos = 0;

#define addSegIS(len, c) \
({\
    is[isPos].length = (len); \
    is[isPos].color = (c); \
    isPos+=ISEGS_PER_WHATEVER; \
    {}; \
})



   int8_t prevNextPosition;
   int8_t prevThisPosition;

   static uint16_t thisIS, nextIS;

   static uint8_t level = 1;


   if(rowNum%TRACK_ROWS == 0) //(V_COUNT/TRACK_LENGTH) == 0)
   {
      prevNextPosition = nextPosition - 1;
      if(prevNextPosition < 0)
         prevNextPosition = TRACK_LENGTH*2 - 1; //+prevNextPosition;

      prevThisPosition = thisPosition - 1;
      if(prevThisPosition < 0)
         prevThisPosition = TRACK_LENGTH*2 - 1; //+prevThisPosition;
      
      static theta_t racerTheta=0;

      int16_t nextTrackPseg;

      nextTrackPseg = sineRaw8(racerTheta) + -(INT8_MIN);
      racerTheta+=level;
      if(racerTheta >= SINE_2PI)
         racerTheta-=SINE_2PI;
/*
   int8_t randomVal = rand()&0x03;
   switch(randomVal)
   {
      case 1:
         if(nextTrackPseg < NUM_PSEGS-2-raceWidth)
            nextTrackPseg += 1;
         break;
      case 2:
         if(nextTrackPseg > 1)
            nextTrackPseg -= 1;
         break;
      default:
         break;
   }
*/


      raceTrack[nextPosition] = nextTrackPseg;

      thisIS = raceTrack[prevThisPosition];
      nextIS = raceTrack[prevNextPosition];
      uint8_t nextHFMdist, thisHFMdist;

      if(raceTrack[nextPosition] > nextIS)
      {
         nextTrackGrowing = TRUE;
         nextHFMdist = raceTrack[nextPosition] - nextIS;
      }
      else
      {
         nextTrackGrowing = FALSE;
         nextHFMdist = nextIS - raceTrack[nextPosition];
      }
      
      if(raceTrack[thisPosition] > thisIS)
      {
         thisTrackGrowing = TRUE;
         thisHFMdist = raceTrack[thisPosition] - thisIS;
      }
      else
      {
         thisTrackGrowing = FALSE;
         thisHFMdist = thisIS - raceTrack[thisPosition];
      }

      hfm_setup(&nextSmoothingHFM, nextHFMdist, TRACK_ROWS);

      hfm_setup(&thisSmoothingHFM, thisHFMdist, TRACK_ROWS);
   }


   if(thisTrackGrowing)//raceTrack[thisPosition] > raceTrack[prevThisPosition])
      thisIS += hfm_nextOutput(&thisSmoothingHFM);
   else
      thisIS -= hfm_nextOutput(&thisSmoothingHFM);

   if(nextTrackGrowing)//raceTrack[nextPosition] > raceTrack[prevNextPosition])
      nextIS += hfm_nextOutput(&nextSmoothingHFM);
   else
      nextIS -= hfm_nextOutput(&nextSmoothingHFM);

   if(thisIS < nextIS)
   {
      addSegIS(thisIS, bgColor);

      //Tracks overlap
      if(nextIS < thisIS + raceWidth)
      {
         addSegIS(nextIS - thisIS, THIS_COLOR);
         addSegIS(thisIS + raceWidth - nextIS, OVERLAP_COLOR);
         addSegIS(nextIS - thisIS, NEXT_COLOR);
         //outOfTrack=TRUE;
      }
      else
      {
         addSegIS(raceWidth, THIS_COLOR);
         addSegIS(nextIS - thisIS - raceWidth, bgColor);
         addSegIS(raceWidth, NEXT_COLOR);
      }

      //addSegIS(NUM_PSEGS-2-nextIS-raceWidth, bgColor);
      addSegIS(RACE_WIDTH_PSEGS-nextIS-raceWidth, bgColor);

   }
   else if(thisIS > nextIS)
   {
      addSegIS(nextIS, bgColor);

      //Tracks overlap
      if(thisIS < nextIS + raceWidth)
      {
         addSegIS(thisIS - nextIS, NEXT_COLOR);
         addSegIS(nextIS + raceWidth - thisIS, OVERLAP_COLOR);
         addSegIS(thisIS - nextIS, THIS_COLOR);
         //outOfTrack=TRUE;
      }
      else
      {
         addSegIS(raceWidth, NEXT_COLOR);
         addSegIS(thisIS - nextIS - raceWidth, bgColor);
         addSegIS(raceWidth, THIS_COLOR);
      }
   
      //addSegIS(NUM_PSEGS-2-thisIS-raceWidth, bgColor);
      addSegIS(RACE_WIDTH_PSEGS-thisIS-raceWidth, bgColor);
   }
   else //Positions equal
   {
      //outOfTrack=TRUE;
      addSegIS(thisIS, bgColor);

      addSegIS(raceWidth, OVERLAP_COLOR);
      //addSegIS(NUM_PSEGS-2-thisIS-raceWidth, bgColor);
      addSegIS(RACE_WIDTH_PSEGS-thisIS-raceWidth, bgColor);
   }
/*
addSegfb(raceWidth, _W);
   addSegfb(NUM_PSEGS-racePseg-raceWidth-2, _R);
*/
   uint8_t isSeg;
   uint16_t isSegTrackPos = 0;
   uint16_t oldTrackPos = 0;
   //uint8_t racerFound = FALSE;

   for(isSeg = 0; isSeg<IS_SEGS; isSeg++)
   {
      isSegTrackPos += is[isSeg].length;

      //if(!racerFound && 
      if((isSegTrackPos >= (uint16_t)racerPseg))
      {
         //racerFound = TRUE;
         uint16_t oldLength = is[isSeg].length;
         is[isSeg].length = racerPseg - oldTrackPos;
         is[isSeg+1].length = 1;
         is[isSeg+1].color = _K;
         //Not sure why this shouldn't be -1...
         is[isSeg+2].length = oldLength - is[isSeg].length; //- 1;
         is[isSeg+2].color = is[isSeg].color;
         if((is[isSeg].color != THIS_COLOR) && (is[isSeg].color != OVERLAP_COLOR))
            outOfTrack = TRUE;
         isSeg++;
         break;
      }
      oldTrackPos = isSegTrackPos;
   }

   
   for(isSeg = 0; isSeg<IS_SEGS; isSeg++)
     {
      if(is[isSeg].length == 0)
         continue;
      if(outOfTrack && (is[isSeg].color==BG_COLOR))
         addSegfb(is[isSeg].length, BG_BAD_COLOR);
      else
         addSegfb(is[isSeg].length, is[isSeg].color);
   }

   static uint32_t badCount=0;
   static uint32_t goodCount=0;

   if(outOfTrack)
      badCount++;
   else
      goodCount++;

   
   addSegfb(1, _B);


   uint8_t percentage = goodCount*100/(badCount+goodCount);
   static uint32_t lastLevelUpdate = 0;

   if((percentage > 50) && (goodCount - lastLevelUpdate > V_COUNT*3))
   {
      lastLevelUpdate = goodCount;
      level++;
   }

	uint8_t scorePsegs = 0;

   if((rowNum>=6) && (rowNum < 22))
      scorePsegs = showScore(rowNum-6, level, _C);

   else if((rowNum>=24) && (rowNum <40))
      scorePsegs = showScore(rowNum-24, goodCount, _G);
   else if((rowNum >= 42) && rowNum < 58)
      scorePsegs = showScore(rowNum-42, badCount, _R);
   else if((rowNum >= 60) && (rowNum < 76))
      scorePsegs = showScore(rowNum-60, percentage, _Y);

	//The addition of -scorePsegs, below, seems to have cleared up a weird
	// problem... the entire display looked right, except some of the
	// characters were printing incorrectly (as solid blocks, repeated first
	// row?)
	// Sometimes these extended-DE's (that extend past the screen)
	// cause weirdness like rows which print only half-way then repeat the 
	// previous row, for the second half.
	// Only odd thing remaining, is that it seems to be one pseg too short
	// (displaying a column of white next to the score)
	// Whatev.
	// Also, there's some oddities when viewing with PLL_SYSCLK
	// (weird green and magenta lines in the unwritten space)
	// Maybe related to similar issues..? ROW_CALC_DELAY too low?
	// Yeahp, ROW_CALCULATION_CYCS needs to be >20000, (currently 40000)
	//scorePsegs=0;
	// Actually, the column of white seems more related to calc-cycs too low
	// Actually, 40000 fixed both oddities, (and maybe woulda affected the
	// blockiness as well?)
	// Hard to test conclusively...
   //This should be varied according to the remaining space on the screen
   // in order to keep DE constant.
   // (it isn't currently, and in fact draws off-screen on showScore lines)
   addSegfb(NUM_PSEGS-2-RACE_WIDTH_PSEGS-scorePsegs, _B);

   addSegfb(1, _W);
   segTerminate();

   if(rowNum >= V_COUNT-1)
      trackPosition = !trackPosition;

}