from typing import Optional, Union

class BitTiming:

"""Representation of a bit timing configuration.

The class can be constructed in various ways, depending on the information

available or the capabilities of the interfaces that need to be supported.

The preferred way is using bitrate, CAN clock frequency, TSEG1, TSEG2, SJW::

can.BitTiming(bitrate=1000000, f_clock=8000000, tseg1=5, tseg2=1, sjw=1)

If the clock frequency is unknown it may be omitted but some interfaces may

require it.

Alternatively the BRP can be given instead of bitrate and clock frequency but this

will limit the number of supported interfaces.

It is also possible specify BTR registers directly,

but will not work for all interfaces::

can.BitTiming(btr0=0x00, btr1=0x14)

"""

sync_seg = 1

def __init__(

self,

bitrate: Optional[int] = None,

f_clock: Optional[int] = None,

brp: Optional[int] = None,

tseg1: Optional[int] = None,

tseg2: Optional[int] = None,

sjw: Optional[int] = None,

nof_samples: int = 1,

btr0: Optional[int] = None,

btr1: Optional[int] = None,

):

"""

:param int bitrate:

Bitrate in bits/s.

:param int f_clock:

The CAN system clock frequency in Hz.

Usually the oscillator frequency divided by 2.

:param int brp:

Bit Rate Prescaler. Prefer to use bitrate and f_clock instead.

:param int tseg1:

Time segment 1, that is, the number of quanta from (but not including)

the Sync Segment to the sampling point.

:param int tseg2:

Time segment 2, that is, the number of quanta from the sampling

point to the end of the bit.

:param int sjw:

The Synchronization Jump Width. Decides the maximum number of time quanta

that the controller can resynchronize every bit.

:param int nof_samples:

Either 1 or 3. Some CAN controllers can also sample each bit three times.

In this case, the bit will be sampled three quanta in a row,

with the last sample being taken in the edge between TSEG1 and TSEG2.

Three samples should only be used for relatively slow baudrates.

:param int btr0:

The BTR0 register value used by many CAN controllers.

:param int btr1:

The BTR1 register value used by many CAN controllers.

"""

self._bitrate = bitrate

self._brp = brp

self._sjw = sjw

self._tseg1 = tseg1

self._tseg2 = tseg2

self._nof_samples = nof_samples

self._f_clock = f_clock

if btr0 is not None:

self._brp = (btr0 & 0x3F) + 1

self._sjw = (btr0 >> 6) + 1

if btr1 is not None:

self._tseg1 = (btr1 & 0xF) + 1

self._tseg2 = ((btr1 >> 4) & 0x7) + 1

self._nof_samples = 3 if btr1 & 0x80 else 1

if nof_samples not in (1, 3):

raise ValueError("nof_samples must be 1 or 3")

@property

def nbt(self) -> int:

"""Nominal Bit Time."""

return self.sync_seg + self.tseg1 + self.tseg2

@property

def bitrate(self) -> Union[int, float]:

"""Bitrate in bits/s."""

if self._bitrate:

return self._bitrate

if self._f_clock and self._brp:

return self._f_clock / (self._brp * self.nbt)

raise ValueError("bitrate must be specified")

@property

def brp(self) -> int:

"""Bit Rate Prescaler."""

if self._brp:

return self._brp

if self._f_clock and self._bitrate:

return round(self._f_clock / (self._bitrate * self.nbt))

raise ValueError("Either bitrate and f_clock or brp must be specified")

@property

def sjw(self) -> int:

"""Synchronization Jump Width."""

if not self._sjw:

raise ValueError("sjw must be specified")

return self._sjw

@property

def tseg1(self) -> int:

"""Time segment 1.

The number of quanta from (but not including) the Sync Segment to the sampling point.

"""

if not self._tseg1:

raise ValueError("tseg1 must be specified")

return self._tseg1

@property

def tseg2(self) -> int:

"""Time segment 2.

The number of quanta from the sampling point to the end of the bit.

"""

if not self._tseg2:

raise ValueError("tseg2 must be specified")

return self._tseg2

@property

def nof_samples(self) -> int:

"""Number of samples (1 or 3)."""

if not self._nof_samples:

raise ValueError("nof_samples must be specified")

return self._nof_samples

@property

def f_clock(self) -> int:

"""The CAN system clock frequency in Hz.

Usually the oscillator frequency divided by 2.

"""

if not self._f_clock:

raise ValueError("f_clock must be specified")

return self._f_clock

@property

def sample_point(self) -> float:

"""Sample point in percent."""

return 100.0 * (self.nbt - self.tseg2) / self.nbt

@property

def btr0(self) -> int:

sjw = self.sjw

brp = self.brp

if brp < 1 or brp > 64:

raise ValueError("brp must be 1 - 64")

if sjw < 1 or sjw > 4:

raise ValueError("sjw must be 1 - 4")

return (sjw - 1) << 6 | brp - 1

@property

def btr1(self) -> int:

sam = 1 if self.nof_samples == 3 else 0

tseg1 = self.tseg1

tseg2 = self.tseg2

if tseg1 < 1 or tseg1 > 16:

raise ValueError("tseg1 must be 1 - 16")

if tseg2 < 1 or tseg2 > 8:

raise ValueError("tseg2 must be 1 - 8")

return sam << 7 | (tseg2 - 1) << 4 | tseg1 - 1

def __str__(self) -> str:

segments = []

try:

segments.append(f"{self.bitrate} bits/s")

except ValueError:

pass

try:

segments.append(f"sample point: {self.sample_point:.2f}%")

except ValueError:

pass

try:

segments.append(f"BRP: {self.brp}")

except ValueError:

pass

try:

segments.append(f"TSEG1: {self.tseg1}")

except ValueError:

pass

try:

segments.append(f"TSEG2: {self.tseg2}")

except ValueError:

pass

try:

segments.append(f"SJW: {self.sjw}")

except ValueError:

pass

try:

segments.append(f"BTR: {self.btr0:02X}{self.btr1:02X}h")

except ValueError:

pass

return ", ".join(segments)

def __repr__(self) -> str:

kwargs = {}

if self._f_clock:

kwargs["f_clock"] = self._f_clock

if self._bitrate:

kwargs["bitrate"] = self._bitrate

if self._brp:

kwargs["brp"] = self._brp

if self._tseg1:

kwargs["tseg1"] = self._tseg1

if self._tseg2:

kwargs["tseg2"] = self._tseg2

if self._sjw:

kwargs["sjw"] = self._sjw

if self._nof_samples != 1:

kwargs["nof_samples"] = self._nof_samples

args = ", ".join(f"{key}={value}" for key, value in kwargs.items())

return f"can.BitTiming({args})"