Calculate CAN bit timing parameters -- STM32

Calculate CAN bit timing parameters

Calculate CAN bit timing parameters

typedef struct
{
  //char name[ 16 ];                // Name of the CAN controller hardware
  //uint32_t ref_clk;               // CAN system clock frequency in Hz
  //uint32_t sjw_max;               // Synchronisation jump width
  uint32_t brp_min;                 // Bit-rate prescaler
  uint32_t brp_max;
  uint32_t brp_inc;
  uint32_t tseg1_min;               // Time segement 1 = prop_seg + phase_seg1
  uint32_t tseg1_max;
  uint32_t tseg2_min;               // Time segement 2 = phase_seg2
  uint32_t tseg2_max;
} CAN_BitTimingConst_TypeDef;
 
typedef struct
{
  uint32_t ref_clk;                 // CAN system clock frequency in Hz
  uint32_t bitrate;                 // Bit-rate in bits/second
  uint32_t sample_point;            // Sample point in one-tenth of a percent
  uint32_t brp;                     // Bit-rate prescaler
  uint32_t tq;                      // Time quanta (TQ) in nanoseconds
  uint32_t tseg1;                   // Time segement 1 = prop_seg + phase_seg1
  uint32_t tseg2;                   // Time segement 2 = phase_seg2
  uint32_t sjw;                     // Synchronisation jump width in TQs
//uint32_t prop_seg;                // Propagation segment in TQs
//uint32_t phase_seg1;              // Phase buffer segment 1 in TQs
//uint32_t phase_seg2;              // Phase buffer segment 2 in TQs
} CAN_BitTiming_TypeDef;

#define CAN_CALC_MAX_ERROR 50   // in one-tenth of a percent
 
int32_t CAN_UpdateSamplePoint( CAN_BitTimingConst_TypeDef *btc,
  int32_t sampl_pt, int32_t tseg, int32_t *tseg1, int32_t *tseg2 )
{
  *tseg2 = tseg +  - ( sampl_pt * ( tseg +  ) ) / ;
 
  if ( *tseg2 < btc->tseg2_min )
    *tseg2 = btc->tseg2_min;
 
  if ( *tseg2 > btc->tseg2_max )
    *tseg2 = btc->tseg2_max;
 
  *tseg1 = tseg - *tseg2;
 
  if ( *tseg1 > btc->tseg1_max )
  {
    *tseg1 = btc->tseg1_max;
    *tseg2 = tseg - *tseg1;
  }
 
  return  * ( tseg +  - *tseg2 ) / ( tseg +  );
}
 
// CIA Sample Point : 75.0% : Speed > 800000
// CIA Sample Point : 80.0% : Speed > 500000
// CIA Sample Point : 87.5% : Speed <= 500000
uint32_t CAN_CIA_SamplePoint( uint32_t bitrate )
{
  uint32_t sampl_pt;
 
  if ( bitrate >  )
    sampl_pt = ;
  else if ( bitrate >  )
    sampl_pt = ;
  else
    sampl_pt = ;
 
  return sampl_pt;
}
 
int32_t CAN_CalcBitTiming( CAN_BitTimingConst_TypeDef *btc,
  CAN_BitTiming_TypeDef *bt )
{
  uint64_t v64;
  int32_t rate = ;
  int32_t best_error = , error = ;
  int32_t best_tseg = , best_brp = , brp = ;
  int32_t tsegall, tseg = , tseg1 = , tseg2 = ;
  int32_t spt_error = , spt = , sampl_pt;
 
  // Use gived sample points
  if ( bt->sample_point )
    sampl_pt = bt->sample_point;
  else
    // Use CIA recommended sample points
    sampl_pt = CAN_CIA_SamplePoint( bt->bitrate );
 
  // tseg even = round down, odd = round up
  for ( tseg = ( btc->tseg1_max + btc->tseg2_max ) *  + ;
      tseg >= ( btc->tseg1_min + btc->tseg2_min ) * ; tseg-- )
  {
    tsegall =  + tseg / ;
 
    // Compute all possible tseg choices (tseg=tseg1+tseg2)
    brp = bt->ref_clk / ( tsegall * bt->bitrate ) + tseg % ;
 
    // chose brp step which is possible in system
    brp = ( brp / btc->brp_inc ) * btc->brp_inc;
    if ( ( brp < btc->brp_min ) || ( brp > btc->brp_max ) )
      continue;
 
    rate = bt->ref_clk / ( brp * tsegall );
    error = bt->bitrate - rate;
 
    // tseg brp biterror
    if ( error <  )
      error = -error;
 
    if ( error > best_error )
      continue;
 
    best_error = error;
    if ( error ==  )
    {
      spt = CAN_UpdateSamplePoint( btc, sampl_pt, tseg / , &tseg1, &tseg2 );
      error = sampl_pt - spt;
      if ( error <  )
        error = -error;
      if ( error > spt_error )
        continue;
 
      spt_error = error;
    }
 
    best_tseg = tseg / ;
    best_brp = brp;
    if ( error ==  )
      break;
  }
 
  if ( best_error )
  {
    /* Error in one-tenth of a percent */
    error = ( best_error *  ) / bt->bitrate;
    if ( error > CAN_CALC_MAX_ERROR )
    {
      // error ( "bitrate error %ld.%ld%% too high\n", error / 10, error % 10 );
      return DRIVER_ERROR_PARAMETER;
    }
    else
    {
      // warn( "bitrate error %ld.%ld%%\n", error / 10,  error % 10 );
    }
  }
 
  v64 = ( (uint64_t) best_brp * 1000000000UL ) / bt->ref_clk;
 
  bt->tq = (uint32_t) v64;
  bt->brp = best_brp;
  bt->tseg2 = tseg2;
  bt->tseg1 = tseg1;
  bt->sjw = ;
  // bt->prop_seg = tseg1 / 2;
  // bt->phase_seg1 = tseg1 - bt->prop_seg;
  // bt->phase_seg2 = tseg2;
 
  // real bit-rate
  bt->bitrate = bt->ref_clk / ( bt->brp * ( tseg1 + tseg2 +  ) );
  // real sample point
 
  bt->sample_point = CAN_UpdateSamplePoint( btc, sampl_pt, best_tseg, &tseg1,
    &tseg2 );
 
  return DRIVER_OK;
}

SJW[1:0]: Resynchronization jump width
These bits define the maximum number of time quanta the CAN hardware 
is allowed to lengthen or shorten a bit to perform the resynchronization.
tRJW = tq x (SJW[1:0] + 1)

TS2[2:0]: Time segment 2
These bits define the number of time quanta in Time Segment 2.
tBS2 = tq x (TS2[2:0] + 1)

TS1[3:0]: Time segment 1
These bits define the number of time quanta in Time Segment 1
tBS1 = tq x (TS1[3:0] + 1)

BRP[9:0]: Baud rate prescaler
These bits define the length of a time quanta.
tq = (BRP[9:0]+1) x tPCLK

const CAN_BitTimingConst_TypeDef CAN_BitTimingConst =
{ ,    // Bit-rate prescaler Min
  , // Bit-rate prescaler Max
  ,    // Bit-rate prescaler Inc
  ,    // Time segement 1 = prop_seg + phase_seg1 Min
  ,   // Time segement 1 = prop_seg + phase_seg1 Max
  ,    // Time segement 2 = phase_seg2 Min
  ,    // Time segement 2 = phase_seg2 Max
  };
 
static int32_t CAN_SetSpeed( CAN_Controller_TypeDef *can, uint32_t speed )
{
  int32_t RetValue = CAN_EnterInit( can );
  if ( RetValue != DRIVER_OK )
    return RetValue;
 
  uint32_t Freq = can->freq( );
  CAN_BitTiming_TypeDef CAN_BitTiming;
  CAN_BitTiming.ref_clk = Freq;
  CAN_BitTiming.bitrate = speed;                // be updated to real speed
  CAN_BitTiming.sample_point = 0;               // be updated to real spt
 
  RetValue = CAN_CalcBitTiming( &CAN_BitTimingConst, &CAN_BitTiming );
  if ( RetValue == DRIVER_OK )
  {
    can->info->speed = CAN_BitTiming.bitrate;   // updated
    uint32_t BTR = can->reg->BTR & 0xC0000000;  // SILM|LBKM
    BTR |= ( ( CAN_BitTiming.brp -  ) <<  )   // BRP
    | ( ( CAN_BitTiming.tseg1 ) <<  )         // TS1
      | ( ( CAN_BitTiming.tseg2 -  ) <<  )   // TS2
      | ( ( CAN_BitTiming.sjw -  ) <<  );    // SJW
    can->reg->BTR = BTR;
  }
 
  return CAN_LeaveInit( can );

/*                           BPR TSEG1 TSEG2 */
/*  36 MHz    1 Mbps  */   { ,  , },  // 75%
/*  36 MHz  800 Kbps  */   { , , },  // 80%
/*  36 MHz  500 Kbps  */   { , , },  // 83.3%
/*  36 MHz  250 Kbps  */   { , , },  // 87.5%
/*  36 MHz  125 Kbps  */   {, , },  // 87.5%
/*  36 MHz  100 Kbps  */   {, , },  // 86.6%
/*  36 MHz 83.3 Kbps  */   {, , },  // 83.3%
/*  36 MHz 62.5 Kbps  */   {, , },  // 87.5%
/*  36 MHz  50 Kbps   */   {, , },  // 87.5%
/*  36 MHz  20 Kbps   */   {,, },  // 86.6%
/*  36 MHz  10 Kbps   */   {,, },  // 87.5%
/*  36 MHz  500 Kbps  */   { , , }   // 83.3%