diff --git a/libraries/CAN/README_CAN.md b/libraries/CAN/README_CAN.md index c5569ef8..332ba6aa 100644 --- a/libraries/CAN/README_CAN.md +++ b/libraries/CAN/README_CAN.md @@ -205,7 +205,7 @@ if ((packetId & mask) == id) { Returns `1` on success, `0` on failure. - + ## Other modes ### Loopback mode @@ -216,6 +216,7 @@ Put the CAN controller in loopback mode, any outgoing packets will also be recei CAN.loopback(); ``` + ### Sleep mode Put the CAN contoller in sleep mode. @@ -233,8 +234,5 @@ CAN.wakeup(); # Develop notes -## XMCLibs Version -For CAN development, we use v4.3.0 of XMClib. But other source code stay 2.1.16. Need to be fixed and updated in the future!! - ## CAN macro Because XMClibs use CAN macro, conflicts with Arduino default CAN class name, so we manually changed XMClib (CAN -> CAN_xmc). Automatic patch might be needed in the future. \ No newline at end of file diff --git a/libraries/CAN/examples/CANLoopBack/CANLoopBack.ino b/libraries/CAN/examples/CANLoopBack/CANLoopBack.ino new file mode 100644 index 00000000..5c67dd3e --- /dev/null +++ b/libraries/CAN/examples/CANLoopBack/CANLoopBack.ino @@ -0,0 +1,61 @@ +// Copyright (c) Linjing Zhang. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. + +#include +using namespace ifx; + +void setup() { + // put your setup code here, to run once: + Serial.begin(9600); + while (!Serial) + ; + + Serial.println("CAN Loopback"); + + // start the CAN bus at 500 kbps + if (!CAN.begin(500E3)) { + Serial.println("Starting CAN failed!"); + while (1) + ; + } + + // set the can in loopback mode + CAN.loopback(); +} + +void loop() { + + // + Serial.print("Sending packet"); + CAN.beginPacket(0x12); + CAN.write('L'); + CAN.write('O'); + CAN.write('O'); + CAN.write('P'); + CAN.endPacket(); + + + int packetSize = CAN.parsePacket(); + + if (packetSize) { + // received a packet + Serial.print("Received "); + + if (CAN.packetExtended()) { + Serial.print("extended "); + } + + Serial.print("packet with id 0x"); + Serial.print(CAN.packetId(), HEX); + + Serial.print(" and length "); + Serial.println(packetSize); + + while (CAN.available()) { + Serial.print((char)CAN.read()); + } + Serial.println(); + } + + delay(1000); +} diff --git a/libraries/CAN/src/CANXMC.cpp b/libraries/CAN/src/CANXMC.cpp index 1d49d0b9..4a24769e 100644 --- a/libraries/CAN/src/CANXMC.cpp +++ b/libraries/CAN/src/CANXMC.cpp @@ -1,10 +1,10 @@ #include "CANXMC.h" #include - namespace ifx { -/* CAN Receive Message Object definition, can also be used for transmit remote frame*/ +/* CAN Receive Message Object definition, can also be used for transmit remote + * frame*/ XMC_CAN_MO_t CAN_msg_rx = { .can_mo_ptr = (CAN_MO_TypeDef *)CAN_MO0, {0xFF, XMC_CAN_FRAME_TYPE_STANDARD_11BITS, // {can_identifier, can_id_mode @@ -20,7 +20,7 @@ XMC_CAN_MO_t CAN_msg_tx = { {0xFF, XMC_CAN_FRAME_TYPE_STANDARD_11BITS, // {can_identifier, can_id_mode XMC_CAN_ARBITRATION_MODE_ORDER_BASED_PRIO_1}, // can_priority} {0x7FFU, 1U}, // {can_id_mask, can_ide_mask} - .can_data_length = 1U, + .can_data_length = 0U, .can_mo_type = XMC_CAN_MO_TYPE_TRANSMSGOBJ, }; @@ -31,100 +31,125 @@ static volatile bool can_frame_received = false; CANXMC::CANXMC(XMC_ARD_CAN_t *conf) { _XMC_CAN_config = conf; } CANXMC::~CANXMC() {} - int CANXMC::setIdentifier(long id) { // TODO: delete in the future! - // figure out filtering problem for xmc4700 - XMC_CAN_MO_SetIdentifier(&CAN_msg_rx, id); - return 0; +int CANXMC::setIdentifier(long id) { // TODO: delete in the future! + // figure out filtering problem for xmc4700 + XMC_CAN_MO_SetIdentifier(&CAN_msg_rx, id); + return 0; +}; + +int CANXMC::begin(long baudrate /*= 500e3*/) { + /* CAN bit time configuration*/ + XMC_CAN_NODE_NOMINAL_BIT_TIME_CONFIG_t CAN_NODE_bit_time_config = { + .can_frequency = _XMC_CAN_config->can_frequency, + .baudrate = (uint32_t)baudrate, + .sample_point = (uint16_t)(80 * 100), + .sjw = (uint16_t)1, }; + XMC_CAN_Enable(CAN_xmc); - int CANXMC::begin(long baudrate /*= 500e3*/) - { - /* CAN bit time configuration*/ - XMC_CAN_NODE_NOMINAL_BIT_TIME_CONFIG_t CAN_NODE_bit_time_config = - { - .can_frequency = _XMC_CAN_config->can_frequency, - .baudrate = (uint32_t)baudrate, - .sample_point = (uint16_t)(80 * 100), - .sjw = (uint16_t)1, - }; - - XMC_CAN_Enable(CAN_xmc); - - /* Configuration of CAN Node and enable the clock */ - XMC_CAN_InitEx(CAN_xmc, _XMC_CAN_config->can_clock , _XMC_CAN_config->can_frequency); - if(XMC_CAN_STATUS_SUCCESS == XMC_CAN_NODE_NominalBitTimeConfigureEx(_XMC_CAN_config->can_node, &CAN_NODE_bit_time_config)) - { - XMC_CAN_NODE_EnableConfigurationChange(_XMC_CAN_config->can_node); - XMC_CAN_NODE_SetInitBit(_XMC_CAN_config->can_node); - XMC_CAN_NODE_ReSetAnalyzerMode(_XMC_CAN_config->can_node); - - /* Configure CAN NODE input pin */ - XMC_GPIO_Init(_XMC_CAN_config->tx.port, _XMC_CAN_config->tx.pin, &(_XMC_CAN_config->tx_config)); - XMC_GPIO_SetHardwareControl(_XMC_CAN_config->tx.port, _XMC_CAN_config->tx.pin, XMC_GPIO_HWCTRL_DISABLED); - XMC_GPIO_Init(_XMC_CAN_config->rx.port, _XMC_CAN_config->rx.pin, &(_XMC_CAN_config->rx_config)); - XMC_GPIO_SetHardwareControl(_XMC_CAN_config->rx.port, _XMC_CAN_config->rx.pin, XMC_GPIO_HWCTRL_DISABLED); - XMC_CAN_NODE_SetReceiveInput(_XMC_CAN_config->can_node, _XMC_CAN_config->node_input); - - /* Allocate the rx and tx message object*/ - XMC_CAN_MO_Config(&CAN_msg_rx); - XMC_CAN_AllocateMOtoNodeList(CAN_xmc, _XMC_CAN_config->can_node_num, 0); - XMC_CAN_MO_Config(&CAN_msg_tx); - XMC_CAN_AllocateMOtoNodeList(CAN_xmc, _XMC_CAN_config->can_node_num, 1); - - /* Message object accepts the reception of both, standard and extended frames */ - XMC_CAN_MO_AcceptStandardAndExtendedID(&CAN_msg_rx); + /* Configuration of CAN Node and enable the clock */ + XMC_CAN_InitEx(CAN_xmc, _XMC_CAN_config->can_clock, + _XMC_CAN_config->can_frequency); + if (XMC_CAN_STATUS_SUCCESS == + XMC_CAN_NODE_NominalBitTimeConfigureEx(_XMC_CAN_config->can_node, + &CAN_NODE_bit_time_config)) { + XMC_CAN_NODE_EnableConfigurationChange(_XMC_CAN_config->can_node); + XMC_CAN_NODE_SetInitBit(_XMC_CAN_config->can_node); + XMC_CAN_NODE_ReSetAnalyzerMode(_XMC_CAN_config->can_node); + + /* Configure CAN NODE input pin */ + XMC_GPIO_Init(_XMC_CAN_config->tx.port, _XMC_CAN_config->tx.pin, + &(_XMC_CAN_config->tx_config)); + XMC_GPIO_SetHardwareControl(_XMC_CAN_config->tx.port, + _XMC_CAN_config->tx.pin, + XMC_GPIO_HWCTRL_DISABLED); + XMC_GPIO_Init(_XMC_CAN_config->rx.port, _XMC_CAN_config->rx.pin, + &(_XMC_CAN_config->rx_config)); + XMC_GPIO_SetHardwareControl(_XMC_CAN_config->rx.port, + _XMC_CAN_config->rx.pin, + XMC_GPIO_HWCTRL_DISABLED); + XMC_CAN_NODE_SetReceiveInput(_XMC_CAN_config->can_node, + _XMC_CAN_config->node_input); + + /* Allocate the rx and tx message object*/ + XMC_CAN_MO_Config(&CAN_msg_rx); + XMC_CAN_AllocateMOtoNodeList(CAN_xmc, _XMC_CAN_config->can_node_num, 0); + XMC_CAN_MO_Config(&CAN_msg_tx); + XMC_CAN_AllocateMOtoNodeList(CAN_xmc, _XMC_CAN_config->can_node_num, 1); + + /* Message object accepts the reception of both, standard and extended + * frames */ + XMC_CAN_MO_AcceptStandardAndExtendedID(&CAN_msg_rx); #if (UC_SERIES == XMC14) - // select interrupt source (A,B,C etc) input to NVIC node (only for XMC1400 devices) - XMC_SCU_SetInterruptControl(_XMC_CAN_config->irq_num, _XMC_CAN_config->irq_source); + // select interrupt source (A,B,C etc) input to NVIC node (only for XMC1400 + // devices) + XMC_SCU_SetInterruptControl(_XMC_CAN_config->irq_num, + _XMC_CAN_config->irq_source); #endif - XMC_CAN_MO_SetEventNodePointer(&CAN_msg_rx, XMC_CAN_MO_POINTER_EVENT_RECEIVE, _XMC_CAN_config->irq_service_request); - XMC_CAN_MO_EnableEvent(&CAN_msg_rx, XMC_CAN_MO_EVENT_RECEIVE); + XMC_CAN_MO_SetEventNodePointer(&CAN_msg_rx, + XMC_CAN_MO_POINTER_EVENT_RECEIVE, + _XMC_CAN_config->irq_service_request); + XMC_CAN_MO_EnableEvent(&CAN_msg_rx, XMC_CAN_MO_EVENT_RECEIVE); - XMC_CAN_NODE_DisableConfigurationChange(_XMC_CAN_config->can_node); - XMC_CAN_NODE_ResetInitBit(_XMC_CAN_config->can_node); + XMC_CAN_NODE_DisableConfigurationChange(_XMC_CAN_config->can_node); + XMC_CAN_NODE_ResetInitBit(_XMC_CAN_config->can_node); - /* enable the interrupt for receive 11bits message*/ - return 1; + /* enable the interrupt for receive 11bits message*/ + return 1; + } else { + return 0; + } +}; + +void CANXMC::end() { + XMC_CAN_MO_DisableEvent(&CAN_msg_rx, XMC_CAN_MO_EVENT_RECEIVE); + XMC_CAN_Disable(CAN_xmc); + CANControllerClass::end(); +}; + +int CANXMC::endPacket() { + if (!CANControllerClass::endPacket()) { + return 0; + } + + if (_txRtr) { + // TODO: LJ: how to receive remote frame? and response... + /* Configure remote frame to be transmitted and data length code */ + if (_txExtended) { + XMC_CAN_MO_SetExtendedID(&CAN_msg_rx); + } else { + XMC_CAN_MO_SetStandardID(&CAN_msg_rx); } - else - { - return 0; - } - }; + XMC_CAN_MO_SetIdentifier(&CAN_msg_rx, _txId); + XMC_CAN_MO_SetDataLengthCode(&CAN_msg_rx, _txLength); + XMC_CAN_MO_UpdateData(&CAN_msg_rx); - void CANXMC::end(){ - XMC_CAN_MO_DisableEvent(&CAN_msg_rx, XMC_CAN_MO_EVENT_RECEIVE); - XMC_CAN_Disable(CAN_xmc); - CANControllerClass::end(); - }; + /* Send remote frame */ + XMC_CAN_STATUS_t send_status = XMC_CAN_MO_Transmit(&CAN_msg_rx); - int CANXMC::endPacket() { - if (!CANControllerClass::endPacket()) { + if (send_status == XMC_CAN_STATUS_SUCCESS) { + return 1; + } else { return 0; } - /* setup message object */ + } else { + /* Configure data frame to be transmitted and data length code */ if (_txExtended) { XMC_CAN_MO_SetExtendedID(&CAN_msg_tx); } else { XMC_CAN_MO_SetStandardID(&CAN_msg_tx); } XMC_CAN_MO_SetIdentifier(&CAN_msg_tx, _txId); - if (!_txRtr) { - memcpy(CAN_msg_tx.can_data_byte, _txData, _txLength); - } - + memcpy(CAN_msg_tx.can_data_byte, _txData, _txLength); XMC_CAN_MO_SetDataLengthCode(&CAN_msg_tx, _txLength); - - - /* Configure data to be transmitted and data length code */ XMC_CAN_MO_UpdateData(&CAN_msg_tx); - /* Send data in CAN_NODE_LMO_0 */ + /* Send data frame */ XMC_CAN_STATUS_t send_status = XMC_CAN_MO_Transmit(&CAN_msg_tx); if (send_status == XMC_CAN_STATUS_SUCCESS) { @@ -132,128 +157,177 @@ CANXMC::~CANXMC() {} } else { return 0; } - }; + } +}; - int CANXMC::parsePacket() - { - while((XMC_CAN_MO_GetStatus(&CAN_msg_rx) & CAN_MO_MOSTAT_NEWDAT_Msk) >> CAN_MO_MOSTAT_NEWDAT_Pos != 1); - XMC_CAN_MO_Receive(&CAN_msg_rx); - - /* check CAN frame type */ - _rxId = XMC_CAN_MO_GetIdentifier(&CAN_msg_rx); - - if (CAN_msg_rx.can_id_mode == XMC_CAN_FRAME_TYPE_EXTENDED_29BITS){ - _rxExtended = true; - } else { - _rxExtended = false; - }; - - _rxRtr = CAN_msg_rx.can_mo_ptr->MOFCR & (uint32_t)CAN_MO_MOFCR_RMM_Msk; - _rxDlc = CAN_msg_rx.can_data_length; - if (_rxRtr) { - _rxLength = 0; - } else { - _rxLength = _rxDlc; - memcpy(_rxData, CAN_msg_rx.can_data_byte, _rxLength); - } - /* set the flag back and wait for next receive */ - can_frame_received = false; - - _rxIndex = 0; - - return _rxLength; - - // if((XMC_CAN_MO_GetStatus(&CAN_msg_rx) & CAN_MO_MOSTAT_NEWDAT_Msk) >> CAN_MO_MOSTAT_NEWDAT_Pos){ - // // return CAN message data length - // return _rxLength; - // } else { - // return 0; - // }; - - }; +int CANXMC::parsePacket() { + while ((XMC_CAN_MO_GetStatus(&CAN_msg_rx) & CAN_MO_MOSTAT_NEWDAT_Msk) >> + CAN_MO_MOSTAT_NEWDAT_Pos != + 1) + ; + XMC_CAN_MO_Receive(&CAN_msg_rx); - void CANXMC::onReceive(void (*callback)(int)){ - CANControllerClass::onReceive(callback); - if (callback) { - NVIC_EnableIRQ(_XMC_CAN_config->irq_num); - } else { - NVIC_DisableIRQ(_XMC_CAN_config->irq_num); - } + /* check CAN frame type */ + _rxId = XMC_CAN_MO_GetIdentifier(&CAN_msg_rx); + + if (CAN_msg_rx.can_id_mode == XMC_CAN_FRAME_TYPE_EXTENDED_29BITS) { + _rxExtended = true; + } else { + _rxExtended = false; }; - int CANXMC::filter(int id, int mask) - { - XMC_CAN_MO_SetStandardID(&CAN_msg_rx); - XMC_CAN_MO_SetIdentifier(&CAN_msg_rx, id); - XMC_CAN_MO_AcceptOnlyMatchingIDE(&CAN_msg_rx); - XMC_CAN_MO_SetAcceptanceMask(&CAN_msg_rx, mask); + _rxRtr = CAN_msg_rx.can_mo_ptr->MOFCR & (uint32_t)CAN_MO_MOFCR_RMM_Msk; + _rxDlc = CAN_msg_rx.can_data_length; + if (_rxRtr) { + _rxLength = 0; + } else { + _rxLength = _rxDlc; + memcpy(_rxData, CAN_msg_rx.can_data_byte, _rxLength); + } + /* set the flag back and wait for next receive */ + can_frame_received = false; - return 1; - }; + _rxIndex = 0; - int CANXMC::filterExtended(long id, long mask) - { - XMC_CAN_MO_SetExtendedID(&CAN_msg_rx); - XMC_CAN_MO_SetIdentifier(&CAN_msg_rx, id); - XMC_CAN_MO_AcceptOnlyMatchingIDE(&CAN_msg_rx); - XMC_CAN_MO_SetAcceptanceMask(&CAN_msg_rx, mask); - return 0; - }; + return _rxLength; - int CANXMC::observe() - { - XMC_CAN_NODE_SetInitBit(_XMC_CAN_config->can_node); - return 0; - }; + // if((XMC_CAN_MO_GetStatus(&CAN_msg_rx) & CAN_MO_MOSTAT_NEWDAT_Msk) >> + // CAN_MO_MOSTAT_NEWDAT_Pos){ + // // return CAN message data length + // return _rxLength; + // } else { + // return 0; + // }; +}; - int CANXMC::loopback() - { - XMC_CAN_NODE_SetInitBit(_XMC_CAN_config->can_node); - return 0; +void CANXMC::onReceive(void (*callback)(int)) { + CANControllerClass::onReceive(callback); + if (callback) { + NVIC_EnableIRQ(_XMC_CAN_config->irq_num); + } else { + NVIC_DisableIRQ(_XMC_CAN_config->irq_num); + } +}; + +int CANXMC::filter(int id, int mask) { + XMC_CAN_MO_SetStandardID(&CAN_msg_rx); + XMC_CAN_MO_SetIdentifier(&CAN_msg_rx, id); + XMC_CAN_MO_AcceptOnlyMatchingIDE(&CAN_msg_rx); + XMC_CAN_MO_SetAcceptanceMask(&CAN_msg_rx, mask); + + return 1; +}; + +int CANXMC::filterExtended(long id, long mask) { + XMC_CAN_MO_SetExtendedID(&CAN_msg_rx); + XMC_CAN_MO_SetIdentifier(&CAN_msg_rx, id); + XMC_CAN_MO_AcceptOnlyMatchingIDE(&CAN_msg_rx); + XMC_CAN_MO_SetAcceptanceMask(&CAN_msg_rx, mask); + return 0; +}; + +int CANXMC::observe() { + // TODO: LJ: no idea what this is + return 0; +}; + +int CANXMC::loopback() { + // TODO: LJ: It is actually only some application level... it is not + // library... + /* reset CAN nodes*/ + XMC_CAN_Disable(CAN_xmc); + /* CAN bit time configuration*/ + XMC_CAN_NODE_NOMINAL_BIT_TIME_CONFIG_t CAN_NODE_bit_time_config = { + .can_frequency = _XMC_CAN_config->can_frequency, + .baudrate = (uint32_t)50000, // TODO: LJ: need to be changed + .sample_point = (uint16_t)(80 * 100), + .sjw = (uint16_t)1, }; - int CANXMC::sleep() - { - XMC_CAN_NODE_SetInitBit(_XMC_CAN_config->can_node); + XMC_CAN_Enable(CAN_xmc); + /* Configuration of CAN Node and enable the clock */ + XMC_CAN_InitEx(CAN_xmc, _XMC_CAN_config->can_clock, + _XMC_CAN_config->can_frequency); + if (XMC_CAN_STATUS_SUCCESS == XMC_CAN_NODE_NominalBitTimeConfigureEx( + CAN_NODE1, &CAN_NODE_bit_time_config)) { + + /* Enable CAN node 1 for Loop-back mode */ + XMC_CAN_NODE_EnableConfigurationChange(CAN_NODE1); + XMC_CAN_NODE_EnableLoopBack(CAN_NODE1); + XMC_CAN_NODE_DisableConfigurationChange(CAN_NODE1); + XMC_CAN_NODE_ResetInitBit(CAN_NODE1); + + /* Initializes CAN tx Message Object for loopback */ + XMC_CAN_MO_Config(&CAN_msg_tx); + /* Allocate tx Message object to Node 1 */ + XMC_CAN_AllocateMOtoNodeList(CAN_xmc, 1, 1); + } else { return 0; - }; + } - int CANXMC::wakeup(){ - XMC_CAN_NODE_SetInitBit(_XMC_CAN_config->can_node); + if (XMC_CAN_STATUS_SUCCESS == XMC_CAN_NODE_NominalBitTimeConfigureEx( + CAN_NODE0, &CAN_NODE_bit_time_config)) { + /* Enable CAN node 0 for Loop-back mode */ + XMC_CAN_NODE_EnableConfigurationChange(CAN_NODE0); + XMC_CAN_NODE_EnableLoopBack(CAN_NODE0); + XMC_CAN_NODE_DisableConfigurationChange(CAN_NODE0); + XMC_CAN_NODE_ResetInitBit(CAN_NODE0); + + /* Initializes CAN rx Message Object for loopback */ + XMC_CAN_MO_Config(&CAN_msg_rx); + /*Allocate rx Message object to Node 0 */ + XMC_CAN_AllocateMOtoNodeList(CAN_xmc, 0, 0); + XMC_CAN_MO_AcceptStandardAndExtendedID(&CAN_msg_rx); + /* Enable receive event */ + XMC_CAN_MO_SetEventNodePointer(&CAN_msg_rx, + XMC_CAN_MO_POINTER_EVENT_RECEIVE, + _XMC_CAN_config->irq_service_request); + XMC_CAN_MO_EnableEvent(&CAN_msg_rx, XMC_CAN_MO_EVENT_RECEIVE); + + return 1; + } else { return 0; - }; + } +}; - void CANXMC::onInterrupt() { - if (can_frame_received == true) { - CAN.parsePacket(); - CAN._onReceive(CAN.available()); - } - }; +int CANXMC::sleep() { + XMC_CAN_NODE_SetInitBit(_XMC_CAN_config->can_node); + return 0; +}; - /* Interrupt Handler*/ - extern "C" { -#if(UC_FAMILY == XMC4) - void CAN0_7_IRQHandler() { - /* Set the frame received flag to true */ - can_frame_received = true; +int CANXMC::wakeup() { + XMC_CAN_NODE_SetInitBit(_XMC_CAN_config->can_node); + return 0; +}; - CAN.onInterrupt(); +void CANXMC::onInterrupt() { + if (can_frame_received == true) { + CAN.parsePacket(); + CAN._onReceive(CAN.available()); } -#endif +}; -#if(UC_SERIES == XMC14) - void CAN0_3_IRQHandler() { - /* Set the frame received flag to true */ - can_frame_received = true; +/* Interrupt Handler */ +extern "C" { +#if (UC_FAMILY == XMC4) +void CAN0_7_IRQHandler() { + /* Set the frame received flag to true */ + can_frame_received = true; - CAN.onInterrupt(); - } + CAN.onInterrupt(); +} #endif - } - CANXMC CAN(&XMC_CAN_0); +#if (UC_SERIES == XMC14) +void CAN0_3_IRQHandler() { + /* Set the frame received flag to true */ + can_frame_received = true; - }; // namespace ifx - + CAN.onInterrupt(); +} +#endif +} +CANXMC CAN(&XMC_CAN_0); +}; // namespace ifx diff --git a/libraries/CAN/src/CANXMC.h b/libraries/CAN/src/CANXMC.h index 3ed12b69..a2ab2b68 100644 --- a/libraries/CAN/src/CANXMC.h +++ b/libraries/CAN/src/CANXMC.h @@ -4,38 +4,36 @@ namespace ifx { class CANXMC : public CANControllerClass { - public: - // CANXMC(); - CANXMC(XMC_ARD_CAN_t* conf); - ~CANXMC() final; + // CANXMC(); + CANXMC(XMC_ARD_CAN_t *conf); + ~CANXMC() final; - int begin(long baudRate = 500E3) final; - void end() final; + int begin(long baudRate = 500E3) final; + void end() final; - int endPacket() final; - - int parsePacket() final; + int endPacket() final; - void onReceive(void (*callback)(int)) final; + int parsePacket() final; - using CANControllerClass::filter; - int filter(int id, int mask) final; - using CANControllerClass::filterExtended; - int filterExtended(long id, long mask) final; + void onReceive(void (*callback)(int)) final; - int observe() final; - int loopback() final; - int sleep() final; - int wakeup() final; - int setIdentifier(long); - static void onInterrupt(); + using CANControllerClass::filter; + int filter(int id, int mask) final; + using CANControllerClass::filterExtended; + int filterExtended(long id, long mask) final; + int observe() final; + int loopback() final; + int sleep() final; + int wakeup() final; + int setIdentifier(long); + static void onInterrupt(); private: - XMC_ARD_CAN_t* _XMC_CAN_config; + XMC_ARD_CAN_t *_XMC_CAN_config; }; extern CANXMC CAN; -}; \ No newline at end of file +}; // namespace ifx \ No newline at end of file diff --git a/variants/XMC1400/config/XMC1400_XMC2GO/pins_arduino.h b/variants/XMC1400/config/XMC1400_XMC2GO/pins_arduino.h index 0923e2a7..b0c8b7f6 100644 --- a/variants/XMC1400/config/XMC1400_XMC2GO/pins_arduino.h +++ b/variants/XMC1400/config/XMC1400_XMC2GO/pins_arduino.h @@ -200,7 +200,7 @@ XMC_PWM4_t mapping_pwm4[] = {CCU40, CCU40_CC43, 3, mapping_port_pin[2], P0_3_AF_CCU40_OUT3, XMC_CCU4_SLICE_PRESCALER_64, PWM4_TIMER_PERIOD, DISABLED}, // PWM disabled 2 P0.3 {CCU40, CCU40_CC41, 1, mapping_port_pin[3], P0_4_AF_CCU40_OUT1, XMC_CCU4_SLICE_PRESCALER_64, PWM4_TIMER_PERIOD, DISABLED}, // PWM disabled 3 P0.4 {CCU40, CCU40_CC40, 0, mapping_port_pin[8], P0_5_AF_CCU40_OUT0, XMC_CCU4_SLICE_PRESCALER_64, PWM4_TIMER_PERIOD, DISABLED}, // PWM disabled 8 P0.5 - {CCU41, CCU41_CC40, 3, mapping_port_pin[9], P1_4_AF_CCU41_OUT0, XMC_CCU4_SLICE_PRESCALER_64, PWM4_TIMER_PERIOD, DISABLED} // PWM disabled 9 P1.4 + {CCU41, CCU41_CC40, 0, mapping_port_pin[9], P1_4_AF_CCU41_OUT0, XMC_CCU4_SLICE_PRESCALER_64, PWM4_TIMER_PERIOD, DISABLED} // PWM disabled 9 P1.4 }; const uint8_t NUM_PWM = ( sizeof( mapping_pwm4 ) / sizeof( XMC_PWM4_t ) ); const uint8_t NUM_PWM4 = ( sizeof( mapping_pwm4 ) / sizeof( XMC_PWM4_t ) );