stm32_can.cpp File Reference

Functions
constexpr uint32_t	CAN_NBTP_H7 (uint32_t sjw, uint32_t prescaler, uint32_t seg1, uint32_t seg2)
constexpr uint32_t	CAN_DBTP_H7 (uint32_t sjw, uint32_t prescaler, uint32_t seg1, uint32_t seg2)
static bool	isValidCan1RxPin (brain_pin_e pin)
static bool	isValidCan1TxPin (brain_pin_e pin)
static bool	isValidCan2RxPin (brain_pin_e pin)
static bool	isValidCan2TxPin (brain_pin_e pin)
static bool	isValidCan3RxPin (brain_pin_e pin)
static bool	isValidCan3TxPin (brain_pin_e pin)
static	__attribute__ ((unused)) bool isValidCan3RxPin(brain_pin_e)
bool	isValidCanTxPin (brain_pin_e pin)
bool	isValidCanRxPin (brain_pin_e pin)
CANDriver *	detectCanDevice (brain_pin_e pinRx, brain_pin_e pinTx)
const CANConfig *	findCanConfig (can_baudrate_e rate)
void	canHwInfo (CANDriver *cand)
void	canHwRecover (const size_t busIndex, CANDriver *cand)

Variables
static const CANConfig	canConfig33
static const CANConfig	canConfig50
static const CANConfig	canConfig83
static const CANConfig	canConfig100
static const CANConfig	canConfig125
static const CANConfig	canConfig250
static const CANConfig	canConfig500
static const CANConfig	canConfig666
static const CANConfig	canConfig1000

Function Documentation

__attribute__()

static __attribute__ ( (unused)  )

static

Definition at line 290 of file stm32_can.cpp.

                                                                  {
    return false;
}

CAN_DBTP_H7()

constexpr uint32_t CAN_DBTP_H7 ( uint32_t  sjw, uint32_t  prescaler, uint32_t  seg1, uint32_t  seg2  )

constexpr

Definition at line 58 of file stm32_can.cpp.

                                                                                               {
    return ((prescaler-1) << 16) | ((seg1-1) << 8) | ((seg2-1)<<4) | (sjw-1);
}

CAN_NBTP_H7()

constexpr uint32_t CAN_NBTP_H7 ( uint32_t  sjw, uint32_t  prescaler, uint32_t  seg1, uint32_t  seg2  )

constexpr

Definition at line 55 of file stm32_can.cpp.

                                                                                               {
    return ((sjw-1)<<24) | ((prescaler-1)<<16) | ((seg1-1)<<8) | (seg2-1);
}

canHwInfo()

void canHwInfo

(

CANDriver *

cand

)

Definition at line 353 of file stm32_can.cpp.

                                {
   if (cand == NULL)
      return;
 
   if (cand->state != CAN_READY) {
      efiPrintf("Interface is not ready");
      return;
   }
 
#if STM32_CAN_USE_CAN1 || STM32_CAN_USE_CAN2
   if (cand->can == NULL) {
      efiPrintf("No device assigned!");
   }
 
   uint32_t esr = cand->can->ESR;
   efiPrintf("Receive error counter %ld", (esr >> 24) & 0xff);
   efiPrintf("Transmit error counter %ld", (esr >> 16) & 0xff);
   efiPrintf("Last error %ld", (esr >> 4) & 0x7);
   efiPrintf("Flags: %s %s %s",
      (esr & 0x4) ? "BOFF" : "",
      (esr & 0x2) ? "EPVF" : "",
      (esr & 0x1) ? "EWGF" : "");
#elif STM32_CAN_USE_FDCAN1 || STM32_CAN_USE_FDCAN2 || STM32_CAN_USE_FDCAN3
    if (cand->fdcan == NULL) {
        efiPrintf("No device assigned!");
    }
 
    uint32_t cccr = cand->fdcan->CCCR;
    efiPrintf("CCCR: %s %s %s",
        (cccr & FDCAN_CCCR_MON) ? "Bus monitoring mode" : "",
        (cccr & FDCAN_CCCR_ASM) ? "ASM restricted operation mode" : "",
        (cccr & FDCAN_CCCR_INIT) ? "INIT" : "");
 
    uint32_t ecr = cand->fdcan->ECR;
    efiPrintf("CAN error logging counter %ld",
        (ecr & FDCAN_ECR_CEL_Msk) >> FDCAN_ECR_CEL_Pos);
    if (ecr & FDCAN_ECR_RP) {
        efiPrintf("Receive error passive 128+");
    } else {
        efiPrintf("Receive error counter %ld",
            (ecr & FDCAN_ECR_REC_Msk) >> FDCAN_ECR_REC_Pos);
    }
    efiPrintf("Transmit error counter %ld",
        (ecr & FDCAN_ECR_TEC_Msk) >> FDCAN_ECR_TEC_Pos);
 
    uint32_t psr = cand->fdcan->PSR;
    efiPrintf("Flags: %s %s %s %s",
        (psr & FDCAN_PSR_PXE) ? "PXE" : "",
        (psr & FDCAN_PSR_BO) ? "Bus_Off" : "",
        (psr & FDCAN_PSR_EW) ? "EW" : "",
        (psr & FDCAN_PSR_EP) ? "Error passive" : "");
 
    static const char *lec_names[8] = {
        "No error",
        "Stuff error",
        "Form error",
        "AckError",
        "Bit1Error",
        "Bit0Error",
        "CRCError",
        "NoChange"
    };
 
    efiPrintf("Last error %s", lec_names[psr & 0x7]);
#endif
}

Here is the call graph for this function:

canHwRecover()

void canHwRecover	(	const size_t	busIndex,
		CANDriver *	cand
	)

Definition at line 420 of file stm32_can.cpp.

{
#if STM32_CAN_USE_FDCAN1 || STM32_CAN_USE_FDCAN2 || STM32_CAN_USE_FDCAN3
    // equal to TIMEOUT_INIT_MS
    #define TIMEOUT_RECOVER_MS  250U
 
    // mostly copy-paste of static bool fdcan_active_mode(CANDriver *canp) from ChibiOS hal_can_lld.c
    if (cand->fdcan->CCCR & FDCAN_CCCR_INIT) {
        systime_t start, end;
 
        /* Going in active mode then waiting for it to happen.*/
        cand->fdcan->CCCR &= ~FDCAN_CCCR_INIT;
        start = osalOsGetSystemTimeX();
        end = osalTimeAddX(start, TIME_MS2I(TIMEOUT_RECOVER_MS));
        while ((cand->fdcan->CCCR & FDCAN_CCCR_INIT) != 0U) {
            if (!osalTimeIsInRangeX(osalOsGetSystemTimeX(), start, end)) {
                return;
            }
            osalThreadSleep(1);
        }
    }
#endif
}

detectCanDevice()

CANDriver * detectCanDevice	(	brain_pin_e	pinRx,
		brain_pin_e	pinTx
	)

Definition at line 309 of file stm32_can.cpp.

                                                                 {
    if (pinRx == Gpio::Unassigned || pinTx == Gpio::Unassigned) {
        return nullptr;
    }
#if STM32_CAN_USE_CAN1 || STM32_CAN_USE_FDCAN1
   if (isValidCan1RxPin(pinRx) && isValidCan1TxPin(pinTx))
      return &CAND1;
#endif
#if STM32_CAN_USE_CAN2 || STM32_CAN_USE_FDCAN2
   if (isValidCan2RxPin(pinRx) && isValidCan2TxPin(pinTx))
      return &CAND2;
#endif
#if STM32_CAN_USE_CAN3 || STM32_CAN_USE_FDCAN3
   if (isValidCan3RxPin(pinRx) && isValidCan3TxPin(pinTx))
      return &CAND3;
#endif
   criticalError("invalid CAN pins tx %s and rx %s", hwPortname(pinTx), hwPortname(pinRx));
   return nullptr;
}

Here is the call graph for this function:

findCanConfig()

const CANConfig * findCanConfig

(

can_baudrate_e

rate

)

Definition at line 329 of file stm32_can.cpp.

                                                     {
   switch (rate) {
   case B33KBPS:
      return &canConfig33;
   case B50KBPS:
      return &canConfig50;
   case B83KBPS:
      return &canConfig83;
   case B100KBPS:
      return &canConfig100;
   case B125KBPS:
      return &canConfig125;
   case B250KBPS:
      return &canConfig250;
   case B666KBPS:
      return &canConfig666;
   case B1MBPS:
      return &canConfig1000;
   case B500KBPS:
   default:
      return &canConfig500;
   }
}

Referenced by CanInit().

Here is the caller graph for this function:

isValidCan1RxPin()

static bool isValidCan1RxPin ( brain_pin_e  pin )

static

Definition at line 254 of file stm32_can.cpp.

                                              {
    return pin == Gpio::A11 || pin == Gpio::B8 || pin == Gpio::D0;
}

Referenced by detectCanDevice(), and isValidCanRxPin().

Here is the caller graph for this function:

isValidCan1TxPin()

static bool isValidCan1TxPin ( brain_pin_e  pin )

static

Definition at line 258 of file stm32_can.cpp.

                                              {
    return pin == Gpio::A12 || pin == Gpio::B9 || pin == Gpio::D1;
}

Referenced by detectCanDevice(), and isValidCanTxPin().

Here is the caller graph for this function:

isValidCan2RxPin()

static bool isValidCan2RxPin ( brain_pin_e  pin )

static

Definition at line 262 of file stm32_can.cpp.

                                              {
    return pin == Gpio::B5 || pin == Gpio::B12;
}

Referenced by detectCanDevice(), and isValidCanRxPin().

Here is the caller graph for this function:

isValidCan2TxPin()

static bool isValidCan2TxPin ( brain_pin_e  pin )

static

Definition at line 266 of file stm32_can.cpp.

                                              {
    return pin == Gpio::B6 || pin == Gpio::B13;
}

Referenced by detectCanDevice(), and isValidCanTxPin().

Here is the caller graph for this function:

isValidCan3RxPin()

static bool isValidCan3RxPin ( brain_pin_e  pin )

static

Definition at line 272 of file stm32_can.cpp.

                                              {
    return pin == Gpio::A8 || pin == Gpio::B3;
}

Referenced by detectCanDevice().

Here is the caller graph for this function:

isValidCan3TxPin()

static bool isValidCan3TxPin ( brain_pin_e  pin )

static

Definition at line 276 of file stm32_can.cpp.

                                              {
    return pin == Gpio::A15 || pin == Gpio::B4;
}

Referenced by detectCanDevice().

Here is the caller graph for this function:

isValidCanRxPin()

bool isValidCanRxPin

(

brain_pin_e

pin

)

Definition at line 305 of file stm32_can.cpp.

                                      {
    return isValidCan1RxPin(pin) || isValidCan2RxPin(pin) /* || isValidCan3RxPin(pin) */;
}

Here is the call graph for this function:

isValidCanTxPin()

bool isValidCanTxPin

(

brain_pin_e

pin

)

Definition at line 299 of file stm32_can.cpp.

                                      {
    // Note: different AF for CAN3 and CANFD3, so check for CAN1/CANFD1 and CAN2/CANFD2 only
    // see startCanPins()
    return isValidCan1TxPin(pin) || isValidCan2TxPin(pin) /* || isValidCan3TxPin(pin) */;
}

Here is the call graph for this function:

Variable Documentation

canConfig100

static const CANConfig canConfig100

static

Initial value:

= {
   .mcr = STM32FxMCR,
   .btr = CAN_BTR_100
}

Definition at line 132 of file stm32_can.cpp.

                                      {
   .mcr = STM32FxMCR,
   .btr = CAN_BTR_100
};

Referenced by findCanConfig().

canConfig1000

static const CANConfig canConfig1000

static

Initial value:

= {
    .mcr = STM32FxMCR,
   .btr = CAN_BTR_1k0
}

Definition at line 157 of file stm32_can.cpp.

                                       {
    .mcr = STM32FxMCR,
   .btr = CAN_BTR_1k0
};

Referenced by findCanConfig().

canConfig125

static const CANConfig canConfig125

static

Initial value:

= {
   .mcr = STM32FxMCR,
   .btr = CAN_BTR_125
}

Definition at line 137 of file stm32_can.cpp.

                                      {
   .mcr = STM32FxMCR,
   .btr = CAN_BTR_125
};

Referenced by findCanConfig().

canConfig250

static const CANConfig canConfig250

static

Initial value:

= {
   .mcr = STM32FxMCR,
   .btr = CAN_BTR_250
}

Definition at line 142 of file stm32_can.cpp.

                                      {
   .mcr = STM32FxMCR,
   .btr = CAN_BTR_250
};

Referenced by findCanConfig().

canConfig33

static const CANConfig canConfig33

static

Initial value:

= {
   .mcr = STM32FxMCR,
   .btr = CAN_BTR_33
}

Definition at line 117 of file stm32_can.cpp.

                                     {
   .mcr = STM32FxMCR,
   .btr = CAN_BTR_33
};

Referenced by findCanConfig().

canConfig50

static const CANConfig canConfig50

static

Initial value:

= {
   .mcr = STM32FxMCR,
   .btr = CAN_BTR_50
}

Definition at line 122 of file stm32_can.cpp.

                                     {
   .mcr = STM32FxMCR,
   .btr = CAN_BTR_50
};

Referenced by findCanConfig().

canConfig500

static const CANConfig canConfig500

static

Initial value:

= {
   .mcr = STM32FxMCR,
   .btr = CAN_BTR_500
}

Definition at line 147 of file stm32_can.cpp.

                                      {
   .mcr = STM32FxMCR,
   .btr = CAN_BTR_500
};

Referenced by findCanConfig().

canConfig666

static const CANConfig canConfig666

static

Initial value:

= {
   .mcr = STM32FxMCR,
   .btr = CAN_BTR_666
}

Definition at line 152 of file stm32_can.cpp.

                                      {
   .mcr = STM32FxMCR,
   .btr = CAN_BTR_666
};

Referenced by findCanConfig().

canConfig83

static const CANConfig canConfig83

static

Initial value:

= {
   .mcr = STM32FxMCR,
   .btr = CAN_BTR_83
}

Definition at line 127 of file stm32_can.cpp.

                                     {
   .mcr = STM32FxMCR,
   .btr = CAN_BTR_83
};

Referenced by findCanConfig().

Go to the source code of this file.