AnsweredAssumed Answered

Processor starts at random address when debug is initialized

Question asked by gearhead1107 on Jul 1, 2015
Latest reply on Jul 13, 2015 by gearhead1107

I'm working on code for an MC9S08QG8 which will take an int from the capture module, scale it, and send it over I2C to a DAC. As a general note, I'm currently working with optimization disabled.


I've gotten the I2C function to communicate with the DAC, however when I add a function to initialize my "scale" struct which computes/ holds some constants for the scaling operation it runs into the weeds. Even though the function (below) seems simple enough, just commenting it out is the difference between the code working vs not working.


By not working, I mean to say that the processor seems to start immediately at its I2C instructions rather that go though it's initialization functions - including the PE init function.


I'm rather new to this, and I would *greatly* appreciate some help in where to start debugging this and what to look for. When the debugger doesn't start at the beginning of the program I'm not really sure where to start.


//The function that throws everything off when not commented out is below

typedef struct{

  int Num, Den, Sin_low, Sout_low;

  char status_Error;//!<Allows higher level code to tell if something happened, or if an error occurred

  byte Error; //!<stores the actual error

} scaledOut;


byte scale_init(scaledOut * scale_struct, const int out_low, const int out_hi, const int in_low, const int in_hi){

  int tempNum = 0;

  int tempDen = 0;

  scale_struct->Num = 0;

  scale_struct->Den = 0;

  scale_struct->Sin_low = in_low;

  scale_struct->Sout_low = out_low;

  scale_struct->status_Error = 0;

  scale_struct->Error = 0;

  //go from ranges to a form of y= mx + b

  //basic formula is y= (out_hi) (x - in_low)  + a

  //  ---------------------

  //  in_hi - in_low


  //Which roughly translates to (x-in_low)*(out_hi-out_low)/(in_hi-in_low) + out_low

  //We will hold in_low and out_low, as well as pre-compute the numerator and denominator so

  //that the processor only has to run


  // (x-in_low)*(Num)/(Den) + out_low


  // Compute Num and Den

  tempNum = out_hi - out_low;

  tempDen = in_hi - in_low;

  scale_struct->Num = tempNum;

  scale_struct->Den = tempDen;


  return ERR_OK;//Good time to eliminate divide by zero, etc.





The function is called from the following main() function

void main(void)


  /*Local variable definition*/



  //!< Period Capture vars

  Capture PeriodCap;

  scaledOut scale_struct;

  byte scale_err = 0;


  //!<I2C Vars




  //!<Vars for main, mostly for scaling voltage

  int time = 0; //!<place-holder for our time capture

  int oldTime = 0; //!<holds the last time capture so we don't bother sending it again

  int out = 0; //!<scaled for output

  const int out_low = 512; //!<Lowest value of our output (12 bit DAC)

  const int out_hi = 3686; //!<Highest output value

  const int in_low = 6683; //!<smallest expected input

  const int in_hi = 20017; //!<Largest expected input

  char loop = 0;

  byte ErrorHold = 0; //!<Holds an error for debugging

  word size = 0;


  int i; //!<var for delay


  flags = 1;


  /*** Processor Expert internal initialization. DON'T REMOVE THIS CODE!!! ***/


  /*** End of Processor Expert internal initialization.                    ***/



  /* Write your code here */


  //!<Initialize peripherals and their corresponding structs

  I2C_init(&DAC, DAC_addr);



  //!< Get ready to scale some stuff

  scale_err = scale_init(&scale_struct, out_low, out_hi, in_low, in_hi);


  //!<Loop forever

  for(;;) {


   //Loop output for testing;

   out = out + 1;

   size = sizeof (out); //should always be sending two bytes





//////////////////////////////////////////////////////////////IIC Send (Direct)

   //Bring input into an array so we have some precise bounds


   /* Set slave address */


   /*! Send bytes in master mode

    * "Send Block" takes a "const void *", which is then cast into OutPtrM which is a "const byte *"

    * The data is finally read into the (8 bit) I2C I/O register, IICD, via


    * IICD = *(OutPtrM)++;


    * Which will begin transmitting MSB first


   error_I2CSend = I2C1_SendBlock(&Buff_Out,size,&ret);



   for(i = 0; i< 200;i++)







  /*** Don't write any code pass this line, or it will be deleted during code generation. ***/

  /*** Processor Expert end of main routine. DON'T MODIFY THIS CODE!!! ***/


  /*** Processor Expert end of main routine. DON'T WRITE CODE BELOW!!! ***/

} /*** End of main routine. DO NOT MODIFY THIS TEXT!!! ***/