mirror of https://github.com/tinygo-org/tinygo.git
sago35
4 years ago
committed by
Ron Evans
Ron Evans
12 changed files with 682 additions and 5 deletions
@ -0,0 +1,15 @@ |
|||
// +build feather_m4_can
|
|||
|
|||
package main |
|||
|
|||
import ( |
|||
"machine" |
|||
) |
|||
|
|||
func init() { |
|||
// power on the CAN Transceiver
|
|||
// https://learn.adafruit.com/adafruit-feather-m4-can-express/pinouts#can-bus-3078990-8
|
|||
boost_en := machine.BOOST_EN |
|||
boost_en.Configure(machine.PinConfig{Mode: machine.PinOutput}) |
|||
boost_en.High() |
|||
} |
|||
@ -0,0 +1,53 @@ |
|||
package main |
|||
|
|||
import ( |
|||
"fmt" |
|||
"machine" |
|||
"time" |
|||
) |
|||
|
|||
func main() { |
|||
can1 := machine.CAN1 |
|||
can1.Configure(machine.CANConfig{ |
|||
TransferRate: machine.CANTransferRate500kbps, |
|||
TransferRateFD: machine.CANTransferRate1000kbps, |
|||
Rx: machine.CAN1_RX, |
|||
Tx: machine.CAN1_TX, |
|||
Standby: machine.CAN1_STANDBY, |
|||
}) |
|||
|
|||
can0 := machine.CAN0 |
|||
can0.Configure(machine.CANConfig{ |
|||
TransferRate: machine.CANTransferRate500kbps, |
|||
TransferRateFD: machine.CANTransferRate1000kbps, |
|||
Rx: machine.CAN0_RX, |
|||
Tx: machine.CAN0_TX, |
|||
Standby: machine.NoPin, |
|||
}) |
|||
|
|||
rxMsg := machine.CANRxBufferElement{} |
|||
|
|||
for { |
|||
can1.Tx(0x123, []byte{0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF}, false, false) |
|||
can1.Tx(0x789, []byte{0x02, 0x24, 0x46, 0x67, 0x89, 0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF}, true, false) |
|||
time.Sleep(time.Millisecond * 1000) |
|||
|
|||
sz0 := can0.RxFifoSize() |
|||
if sz0 > 0 { |
|||
fmt.Printf("CAN0 %d\r\n", sz0) |
|||
for i := 0; i < sz0; i++ { |
|||
can0.RxRaw(&rxMsg) |
|||
fmt.Printf("-> %08X %X %#v\r\n", rxMsg.ID, rxMsg.DLC, rxMsg.Data()) |
|||
} |
|||
} |
|||
|
|||
sz1 := can1.RxFifoSize() |
|||
if sz1 > 0 { |
|||
fmt.Printf("CAN1 %d\r\n", sz1) |
|||
for i := 0; i < sz1; i++ { |
|||
can1.RxRaw(&rxMsg) |
|||
fmt.Printf("-> %08X %X %#v\r\n", rxMsg.ID, rxMsg.DLC, rxMsg.Data()) |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,15 @@ |
|||
// +build feather_m4_can
|
|||
|
|||
package main |
|||
|
|||
import ( |
|||
"machine" |
|||
) |
|||
|
|||
func init() { |
|||
// power on the CAN Transceiver
|
|||
// https://learn.adafruit.com/adafruit-feather-m4-can-express/pinouts#can-bus-3078990-8
|
|||
boost_en := machine.BOOST_EN |
|||
boost_en.Configure(machine.PinConfig{Mode: machine.PinOutput}) |
|||
boost_en.High() |
|||
} |
|||
@ -0,0 +1,75 @@ |
|||
package main |
|||
|
|||
import ( |
|||
"device/sam" |
|||
"fmt" |
|||
"machine" |
|||
"time" |
|||
) |
|||
|
|||
type canMsg struct { |
|||
ch byte |
|||
id uint32 |
|||
dlc byte |
|||
data []byte |
|||
} |
|||
|
|||
func main() { |
|||
ch := make(chan canMsg, 10) |
|||
go func() { |
|||
for { |
|||
select { |
|||
case m := <-ch: |
|||
fmt.Printf("%d %03X %X ", m.ch, m.id, m.dlc) |
|||
for _, d := range m.data { |
|||
fmt.Printf("%02X ", d) |
|||
} |
|||
fmt.Printf("\r\n") |
|||
} |
|||
|
|||
} |
|||
}() |
|||
|
|||
can1 := machine.CAN1 |
|||
can1.Configure(machine.CANConfig{ |
|||
TransferRate: machine.CANTransferRate500kbps, |
|||
TransferRateFD: machine.CANTransferRate1000kbps, |
|||
Rx: machine.CAN1_RX, |
|||
Tx: machine.CAN1_TX, |
|||
Standby: machine.CAN1_STANDBY, |
|||
}) |
|||
// RF0NE : Rx FIFO 0 New Message Interrupt Enable
|
|||
can1.SetInterrupt(sam.CAN_IE_RF0NE, func(*machine.CAN) { |
|||
rxMsg := machine.CANRxBufferElement{} |
|||
can1.RxRaw(&rxMsg) |
|||
m := canMsg{ch: 1, id: rxMsg.ID, dlc: rxMsg.DLC, data: rxMsg.Data()} |
|||
select { |
|||
case ch <- m: |
|||
} |
|||
}) |
|||
|
|||
can0 := machine.CAN0 |
|||
can0.Configure(machine.CANConfig{ |
|||
TransferRate: machine.CANTransferRate500kbps, |
|||
TransferRateFD: machine.CANTransferRate1000kbps, |
|||
Rx: machine.CAN0_RX, |
|||
Tx: machine.CAN0_TX, |
|||
Standby: machine.NoPin, |
|||
}) |
|||
// RF0NE : Rx FIFO 0 New Message Interrupt Enable
|
|||
can0.SetInterrupt(sam.CAN_IE_RF0NE, func(*machine.CAN) { |
|||
rxMsg := machine.CANRxBufferElement{} |
|||
can0.RxRaw(&rxMsg) |
|||
m := canMsg{ch: 2, id: rxMsg.ID, dlc: rxMsg.DLC, data: rxMsg.Data()} |
|||
select { |
|||
case ch <- m: |
|||
} |
|||
}) |
|||
|
|||
for { |
|||
can0.Tx(0x123, []byte{0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF}, false, false) |
|||
time.Sleep(time.Millisecond * 500) |
|||
can1.Tx(0x456, []byte{0xAA, 0xBB, 0xCC}, false, false) |
|||
time.Sleep(time.Millisecond * 1000) |
|||
} |
|||
} |
|||
@ -0,0 +1,468 @@ |
|||
// +build sam,atsame51 sam,atsame54
|
|||
|
|||
package machine |
|||
|
|||
import ( |
|||
"device/sam" |
|||
"errors" |
|||
"runtime/interrupt" |
|||
"unsafe" |
|||
) |
|||
|
|||
const ( |
|||
CANRxFifoSize = 16 |
|||
CANTxFifoSize = 16 |
|||
CANEvFifoSize = 16 |
|||
) |
|||
|
|||
// Message RAM can only be located in the first 64 KB area of the system RAM.
|
|||
// TODO: when the go:section pragma is merged, add the section configuration
|
|||
|
|||
//go:align 4
|
|||
var CANRxFifo [2][(8 + 64) * CANRxFifoSize]byte |
|||
|
|||
//go:align 4
|
|||
var CANTxFifo [2][(8 + 64) * CANTxFifoSize]byte |
|||
|
|||
//go:align 4
|
|||
var CANEvFifo [2][(8) * CANEvFifoSize]byte |
|||
|
|||
type CAN struct { |
|||
Bus *sam.CAN_Type |
|||
} |
|||
|
|||
type CANTransferRate uint32 |
|||
|
|||
// CAN transfer rates for CANConfig
|
|||
const ( |
|||
CANTransferRate125kbps CANTransferRate = 125000 |
|||
CANTransferRate250kbps CANTransferRate = 250000 |
|||
CANTransferRate500kbps CANTransferRate = 500000 |
|||
CANTransferRate1000kbps CANTransferRate = 1000000 |
|||
CANTransferRate2000kbps CANTransferRate = 2000000 |
|||
CANTransferRate4000kbps CANTransferRate = 4000000 |
|||
) |
|||
|
|||
// CANConfig holds CAN configuration parameters. Tx and Rx need to be
|
|||
// specified with some pins. When the Standby Pin is specified, configure it
|
|||
// as an output pin and output Low in Configure(). If this operation is not
|
|||
// necessary, specify NoPin.
|
|||
type CANConfig struct { |
|||
TransferRate CANTransferRate |
|||
TransferRateFD CANTransferRate |
|||
Tx Pin |
|||
Rx Pin |
|||
Standby Pin |
|||
} |
|||
|
|||
var ( |
|||
errCANInvalidTransferRate = errors.New("CAN: invalid TransferRate") |
|||
errCANInvalidTransferRateFD = errors.New("CAN: invalid TransferRateFD") |
|||
) |
|||
|
|||
// Configure this CAN peripheral with the given configuration.
|
|||
func (can *CAN) Configure(config CANConfig) error { |
|||
if config.Standby != NoPin { |
|||
config.Standby.Configure(PinConfig{Mode: PinOutput}) |
|||
config.Standby.Low() |
|||
} |
|||
|
|||
mode := PinCAN0 |
|||
if can.instance() == 1 { |
|||
mode = PinCAN1 |
|||
} |
|||
|
|||
config.Rx.Configure(PinConfig{Mode: mode}) |
|||
config.Tx.Configure(PinConfig{Mode: mode}) |
|||
|
|||
can.Bus.CCCR.SetBits(sam.CAN_CCCR_INIT) |
|||
for !can.Bus.CCCR.HasBits(sam.CAN_CCCR_INIT) { |
|||
} |
|||
|
|||
can.Bus.CCCR.SetBits(sam.CAN_CCCR_CCE) |
|||
|
|||
can.Bus.CCCR.SetBits(sam.CAN_CCCR_BRSE | sam.CAN_CCCR_FDOE) |
|||
can.Bus.MRCFG.Set(sam.CAN_MRCFG_QOS_MEDIUM) |
|||
// base clock == 48 MHz
|
|||
if config.TransferRate == 0 { |
|||
config.TransferRate = CANTransferRate500kbps |
|||
} |
|||
brp := uint32(6) |
|||
switch config.TransferRate { |
|||
case CANTransferRate125kbps: |
|||
brp = 32 |
|||
case CANTransferRate250kbps: |
|||
brp = 16 |
|||
case CANTransferRate500kbps: |
|||
brp = 8 |
|||
case CANTransferRate1000kbps: |
|||
brp = 4 |
|||
default: |
|||
return errCANInvalidTransferRate |
|||
} |
|||
can.Bus.NBTP.Set(8<<sam.CAN_NBTP_NTSEG1_Pos | (brp-1)<<sam.CAN_NBTP_NBRP_Pos | |
|||
1<<sam.CAN_NBTP_NTSEG2_Pos | 3<<sam.CAN_NBTP_NSJW_Pos) |
|||
|
|||
if config.TransferRateFD == 0 { |
|||
config.TransferRateFD = CANTransferRate1000kbps |
|||
} |
|||
if config.TransferRateFD < config.TransferRate { |
|||
return errCANInvalidTransferRateFD |
|||
} |
|||
brp = uint32(2) |
|||
switch config.TransferRateFD { |
|||
case CANTransferRate125kbps: |
|||
brp = 32 |
|||
case CANTransferRate250kbps: |
|||
brp = 16 |
|||
case CANTransferRate500kbps: |
|||
brp = 8 |
|||
case CANTransferRate1000kbps: |
|||
brp = 4 |
|||
case CANTransferRate2000kbps: |
|||
brp = 2 |
|||
case CANTransferRate4000kbps: |
|||
brp = 1 |
|||
default: |
|||
return errCANInvalidTransferRateFD |
|||
} |
|||
can.Bus.DBTP.Set((brp-1)<<sam.CAN_DBTP_DBRP_Pos | 8<<sam.CAN_DBTP_DTSEG1_Pos | |
|||
1<<sam.CAN_DBTP_DTSEG2_Pos | 3<<sam.CAN_DBTP_DSJW_Pos) |
|||
|
|||
can.Bus.RXF0C.Set(sam.CAN_RXF0C_F0OM | CANRxFifoSize<<sam.CAN_RXF0C_F0S_Pos | uint32(uintptr(unsafe.Pointer(&CANRxFifo[can.instance()][0])))&0xFFFF) |
|||
can.Bus.RXESC.Set(sam.CAN_RXESC_F0DS_DATA64) |
|||
can.Bus.TXESC.Set(sam.CAN_TXESC_TBDS_DATA64) |
|||
can.Bus.TXBC.Set(CANTxFifoSize<<sam.CAN_TXBC_TFQS_Pos | 0<<sam.CAN_TXBC_NDTB_Pos | uint32(uintptr(unsafe.Pointer(&CANTxFifo[can.instance()][0])))&0xFFFF) |
|||
can.Bus.TXEFC.Set(CANEvFifoSize<<sam.CAN_TXEFC_EFS_Pos | uint32(uintptr(unsafe.Pointer(&CANEvFifo[can.instance()][0])))&0xFFFF) |
|||
|
|||
can.Bus.TSCC.Set(sam.CAN_TSCC_TSS_INC) |
|||
|
|||
can.Bus.GFC.Set(0<<sam.CAN_GFC_ANFS_Pos | 0<<sam.CAN_GFC_ANFE_Pos) |
|||
|
|||
can.Bus.SIDFC.Set(0 << sam.CAN_SIDFC_LSS_Pos) |
|||
can.Bus.XIDFC.Set(0 << sam.CAN_SIDFC_LSS_Pos) |
|||
|
|||
can.Bus.XIDAM.Set(0x1FFFFFFF << sam.CAN_XIDAM_EIDM_Pos) |
|||
|
|||
can.Bus.ILE.SetBits(sam.CAN_ILE_EINT0) |
|||
|
|||
can.Bus.CCCR.ClearBits(sam.CAN_CCCR_CCE) |
|||
can.Bus.CCCR.ClearBits(sam.CAN_CCCR_INIT) |
|||
for can.Bus.CCCR.HasBits(sam.CAN_CCCR_INIT) { |
|||
} |
|||
|
|||
return nil |
|||
} |
|||
|
|||
// Callbacks to be called for CAN.SetInterrupt(). Wre're using the magic
|
|||
// constant 2 and 32 here beacuse th SAM E51/E54 has 2 CAN and 32 interrupt
|
|||
// sources.
|
|||
var ( |
|||
canInstances [2]*CAN |
|||
canCallbacks [2][32]func(*CAN) |
|||
) |
|||
|
|||
// SetInterrupt sets an interrupt to be executed when a particular CAN state.
|
|||
//
|
|||
// This call will replace a previously set callback. You can pass a nil func
|
|||
// to unset the CAN interrupt. If you do so, the change parameter is ignored
|
|||
// and can be set to any value (such as 0).
|
|||
func (can *CAN) SetInterrupt(ie uint32, callback func(*CAN)) error { |
|||
if callback == nil { |
|||
// Disable this CAN interrupt
|
|||
can.Bus.IE.ClearBits(ie) |
|||
return nil |
|||
} |
|||
can.Bus.IE.SetBits(ie) |
|||
|
|||
idx := 0 |
|||
switch can.Bus { |
|||
case sam.CAN0: |
|||
canInstances[0] = can |
|||
case sam.CAN1: |
|||
canInstances[1] = can |
|||
idx = 1 |
|||
} |
|||
|
|||
for i := uint(0); i < 32; i++ { |
|||
if ie&(1<<i) != 0 { |
|||
canCallbacks[idx][i] = callback |
|||
} |
|||
} |
|||
|
|||
switch can.Bus { |
|||
case sam.CAN0: |
|||
interrupt.New(sam.IRQ_CAN0, func(interrupt.Interrupt) { |
|||
ir := sam.CAN0.IR.Get() |
|||
sam.CAN0.IR.Set(ir) // clear interrupt
|
|||
for i := uint(0); i < 32; i++ { |
|||
if ir&(1<<i) != 0 && canCallbacks[0][i] != nil { |
|||
canCallbacks[0][i](canInstances[0]) |
|||
} |
|||
} |
|||
}).Enable() |
|||
case sam.CAN1: |
|||
interrupt.New(sam.IRQ_CAN1, func(interrupt.Interrupt) { |
|||
ir := sam.CAN1.IR.Get() |
|||
sam.CAN1.IR.Set(ir) // clear interrupt
|
|||
for i := uint(0); i < 32; i++ { |
|||
if ir&(1<<i) != 0 && canCallbacks[1][i] != nil { |
|||
canCallbacks[1][i](canInstances[1]) |
|||
} |
|||
} |
|||
}).Enable() |
|||
} |
|||
|
|||
return nil |
|||
} |
|||
|
|||
// TxFifoIsFull returns whether TxFifo is full or not.
|
|||
func (can *CAN) TxFifoIsFull() bool { |
|||
return (can.Bus.TXFQS.Get() & sam.CAN_TXFQS_TFQF_Msk) == sam.CAN_TXFQS_TFQF_Msk |
|||
} |
|||
|
|||
// TxRaw sends a CAN Frame according to CANTxBufferElement.
|
|||
func (can *CAN) TxRaw(e *CANTxBufferElement) { |
|||
putIndex := (can.Bus.TXFQS.Get() & sam.CAN_TXFQS_TFQPI_Msk) >> sam.CAN_TXFQS_TFQPI_Pos |
|||
|
|||
f := CANTxFifo[can.instance()][putIndex*(8+64) : (putIndex+1)*(8+64)] |
|||
id := e.ID |
|||
if !e.XTD { |
|||
// standard identifier is stored into ID[28:18]
|
|||
id <<= 18 |
|||
} |
|||
|
|||
f[3] = byte(id >> 24) |
|||
if e.ESI { |
|||
f[3] |= 0x80 |
|||
} |
|||
if e.XTD { |
|||
f[3] |= 0x40 |
|||
} |
|||
if e.RTR { |
|||
f[3] |= 0x20 |
|||
} |
|||
f[2] = byte(id >> 16) |
|||
f[1] = byte(id >> 8) |
|||
f[0] = byte(0) |
|||
f[7] = e.MM |
|||
f[6] = e.DLC |
|||
if e.EFC { |
|||
f[6] |= 0x80 |
|||
} |
|||
if e.FDF { |
|||
f[6] |= 0x20 |
|||
} |
|||
if e.BRS { |
|||
f[6] |= 0x10 |
|||
} |
|||
f[5] = 0x00 // reserved
|
|||
f[4] = 0x00 // reserved
|
|||
|
|||
length := CANDlcToLength(e.DLC, e.FDF) |
|||
for i := byte(0); i < length; i++ { |
|||
f[8+i] = e.DB[i] |
|||
} |
|||
|
|||
can.Bus.TXBAR.SetBits(1 << putIndex) |
|||
} |
|||
|
|||
// The Tx transmits CAN frames. It is easier to use than TxRaw, but not as
|
|||
// flexible.
|
|||
func (can *CAN) Tx(id uint32, data []byte, isFD, isExtendedID bool) { |
|||
length := byte(len(data)) |
|||
dlc := CANLengthToDlc(length, true) |
|||
|
|||
e := CANTxBufferElement{ |
|||
ESI: false, |
|||
XTD: isExtendedID, |
|||
RTR: false, |
|||
ID: id, |
|||
MM: 0x00, |
|||
EFC: true, |
|||
FDF: isFD, |
|||
BRS: isFD, |
|||
DLC: dlc, |
|||
} |
|||
|
|||
if !isFD { |
|||
if length > 8 { |
|||
length = 8 |
|||
} |
|||
} |
|||
for i := byte(0); i < length; i++ { |
|||
e.DB[i] = data[i] |
|||
} |
|||
|
|||
can.TxRaw(&e) |
|||
} |
|||
|
|||
// RxFifoSize returns the number of CAN Frames currently stored in the RXFifo.
|
|||
func (can *CAN) RxFifoSize() int { |
|||
sz := (can.Bus.RXF0S.Get() & sam.CAN_RXF0S_F0FL_Msk) >> sam.CAN_RXF0S_F0FL_Pos |
|||
return int(sz) |
|||
} |
|||
|
|||
// RxFifoIsFull returns whether RxFifo is full or not.
|
|||
func (can *CAN) RxFifoIsFull() bool { |
|||
sz := (can.Bus.RXF0S.Get() & sam.CAN_RXF0S_F0FL_Msk) >> sam.CAN_RXF0S_F0FL_Pos |
|||
return sz == CANRxFifoSize |
|||
} |
|||
|
|||
// RxFifoIsEmpty returns whether RxFifo is empty or not.
|
|||
func (can *CAN) RxFifoIsEmpty() bool { |
|||
sz := (can.Bus.RXF0S.Get() & sam.CAN_RXF0S_F0FL_Msk) >> sam.CAN_RXF0S_F0FL_Pos |
|||
return sz == 0 |
|||
} |
|||
|
|||
// RxRaw copies the received CAN frame to CANRxBufferElement.
|
|||
func (can *CAN) RxRaw(e *CANRxBufferElement) { |
|||
idx := (can.Bus.RXF0S.Get() & sam.CAN_RXF0S_F0GI_Msk) >> sam.CAN_RXF0S_F0GI_Pos |
|||
f := CANRxFifo[can.instance()][idx*(8+64):] |
|||
|
|||
e.ESI = false |
|||
if (f[3] & 0x80) != 0x00 { |
|||
e.ESI = true |
|||
} |
|||
|
|||
e.XTD = false |
|||
if (f[3] & 0x40) != 0x00 { |
|||
e.XTD = true |
|||
} |
|||
|
|||
e.RTR = false |
|||
if (f[3] & 0x20) != 0x00 { |
|||
e.RTR = true |
|||
} |
|||
|
|||
id := ((uint32(f[3]) << 24) + (uint32(f[2]) << 16) + (uint32(f[1]) << 8) + uint32(f[0])) & 0x1FFFFFFF |
|||
if (f[3] & 0x20) == 0 { |
|||
id >>= 18 |
|||
id &= 0x000007FF |
|||
} |
|||
e.ID = id |
|||
|
|||
e.ANMF = false |
|||
if (f[7] & 0x80) != 0x00 { |
|||
e.ANMF = true |
|||
} |
|||
|
|||
e.FIDX = f[7] & 0x7F |
|||
|
|||
e.FDF = false |
|||
if (f[6] & 0x20) != 0x00 { |
|||
e.FDF = true |
|||
} |
|||
|
|||
e.BRS = false |
|||
if (f[6] & 0x10) != 0x00 { |
|||
e.BRS = true |
|||
} |
|||
|
|||
e.DLC = f[6] & 0x0F |
|||
|
|||
e.RXTS = (uint16(f[5]) << 8) + uint16(f[4]) |
|||
|
|||
for i := byte(0); i < CANDlcToLength(e.DLC, e.FDF); i++ { |
|||
e.DB[i] = f[i+8] |
|||
} |
|||
|
|||
can.Bus.RXF0A.ReplaceBits(idx, sam.CAN_RXF0A_F0AI_Msk, sam.CAN_RXF0A_F0AI_Pos) |
|||
} |
|||
|
|||
// Rx receives a CAN frame. It is easier to use than RxRaw, but not as
|
|||
// flexible.
|
|||
func (can *CAN) Rx() (id uint32, dlc byte, data []byte, isFd, isExtendedID bool) { |
|||
e := CANRxBufferElement{} |
|||
can.RxRaw(&e) |
|||
length := CANDlcToLength(e.DLC, e.FDF) |
|||
return e.ID, length, e.DB[:length], e.FDF, e.XTD |
|||
} |
|||
|
|||
func (can *CAN) instance() byte { |
|||
if can.Bus == sam.CAN0 { |
|||
return 0 |
|||
} else { |
|||
return 1 |
|||
} |
|||
} |
|||
|
|||
// CANTxBufferElement is a struct that corresponds to the same5x' Tx Buffer
|
|||
// Element.
|
|||
type CANTxBufferElement struct { |
|||
ESI bool |
|||
XTD bool |
|||
RTR bool |
|||
ID uint32 |
|||
MM uint8 |
|||
EFC bool |
|||
FDF bool |
|||
BRS bool |
|||
DLC uint8 |
|||
DB [64]uint8 |
|||
} |
|||
|
|||
// CANRxBufferElement is a struct that corresponds to the same5x Rx Buffer and
|
|||
// FIFO Element.
|
|||
type CANRxBufferElement struct { |
|||
ESI bool |
|||
XTD bool |
|||
RTR bool |
|||
ID uint32 |
|||
ANMF bool |
|||
FIDX uint8 |
|||
FDF bool |
|||
BRS bool |
|||
DLC uint8 |
|||
RXTS uint16 |
|||
DB [64]uint8 |
|||
} |
|||
|
|||
// Data returns the received data as a slice of the size according to dlc.
|
|||
func (e CANRxBufferElement) Data() []byte { |
|||
return e.DB[:CANDlcToLength(e.DLC, e.FDF)] |
|||
} |
|||
|
|||
// CANDlcToLength() converts a DLC value to its actual length.
|
|||
func CANDlcToLength(dlc byte, isFD bool) byte { |
|||
length := dlc |
|||
if dlc == 0x09 { |
|||
length = 12 |
|||
} else if dlc == 0x0A { |
|||
length = 16 |
|||
} else if dlc == 0x0B { |
|||
length = 20 |
|||
} else if dlc == 0x0C { |
|||
length = 24 |
|||
} else if dlc == 0x0D { |
|||
length = 32 |
|||
} else if dlc == 0x0E { |
|||
length = 48 |
|||
} else if dlc == 0x0F { |
|||
length = 64 |
|||
} |
|||
return length |
|||
|
|||
} |
|||
|
|||
// CANLengthToDlc() converts its actual length to a DLC value.
|
|||
func CANLengthToDlc(length byte, isFD bool) byte { |
|||
dlc := length |
|||
if length <= 0x08 { |
|||
} else if length <= 12 { |
|||
dlc = 0x09 |
|||
} else if length <= 16 { |
|||
dlc = 0x0A |
|||
} else if length <= 20 { |
|||
dlc = 0x0B |
|||
} else if length <= 24 { |
|||
dlc = 0x0C |
|||
} else if length <= 32 { |
|||
dlc = 0x0D |
|||
} else if length <= 48 { |
|||
dlc = 0x0E |
|||
} else if length <= 64 { |
|||
dlc = 0x0F |
|||
} |
|||
return dlc |
|||
} |
|||
@ -0,0 +1,23 @@ |
|||
// +build sam,atsame51 sam,atsame54
|
|||
|
|||
package runtime |
|||
|
|||
import ( |
|||
"device/sam" |
|||
) |
|||
|
|||
func init() { |
|||
initCANClock() |
|||
} |
|||
|
|||
func initCANClock() { |
|||
// Turn on clocks for CAN0/CAN1.
|
|||
sam.MCLK.AHBMASK.SetBits(sam.MCLK_AHBMASK_CAN0_) |
|||
sam.MCLK.AHBMASK.SetBits(sam.MCLK_AHBMASK_CAN1_) |
|||
|
|||
// Put Generic Clock Generator 1 as source for USB
|
|||
sam.GCLK.PCHCTRL[sam.PCHCTRL_GCLK_CAN0].Set((sam.GCLK_PCHCTRL_GEN_GCLK1 << sam.GCLK_PCHCTRL_GEN_Pos) | |
|||
sam.GCLK_PCHCTRL_CHEN) |
|||
sam.GCLK.PCHCTRL[sam.PCHCTRL_GCLK_CAN1].Set((sam.GCLK_PCHCTRL_GEN_GCLK1 << sam.GCLK_PCHCTRL_GEN_Pos) | |
|||
sam.GCLK_PCHCTRL_CHEN) |
|||
} |
|||
Loading…
Reference in new issue