EL4121 Embedded System / mbed-os

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Dependents:   cobaLCDJoyMotor_Thread odometry_omni_3roda_v3 odometry_omni_3roda_v1 odometry_omni_3roda_v2 ... more

targets/TARGET_NUVOTON/TARGET_M451/can_api.c@0:b74591d5ab33, 2017-12-11 (annotated)

Committer:
be_bryan
Date:
Mon Dec 11 17:54:04 2017 +0000
Revision:
0:b74591d5ab33
motor ++

Who changed what in which revision?

UserRevisionLine numberNew contents of line
be_bryan 0:b74591d5ab33 1 /* mbed Microcontroller Library
be_bryan 0:b74591d5ab33 2 * Copyright (c) 2015-2016 Nuvoton
be_bryan 0:b74591d5ab33 3 *
be_bryan 0:b74591d5ab33 4 * Licensed under the Apache License, Version 2.0 (the "License");
be_bryan 0:b74591d5ab33 5 * you may not use this file except in compliance with the License.
be_bryan 0:b74591d5ab33 6 * You may obtain a copy of the License at
be_bryan 0:b74591d5ab33 7 *
be_bryan 0:b74591d5ab33 8 * http://www.apache.org/licenses/LICENSE-2.0
be_bryan 0:b74591d5ab33 9 *
be_bryan 0:b74591d5ab33 10 * Unless required by applicable law or agreed to in writing, software
be_bryan 0:b74591d5ab33 11 * distributed under the License is distributed on an "AS IS" BASIS,
be_bryan 0:b74591d5ab33 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
be_bryan 0:b74591d5ab33 13 * See the License for the specific language governing permissions and
be_bryan 0:b74591d5ab33 14 * limitations under the License.
be_bryan 0:b74591d5ab33 15 */
be_bryan 0:b74591d5ab33 16
be_bryan 0:b74591d5ab33 17 #include "can_api.h"
be_bryan 0:b74591d5ab33 18 #include "m451_gpio.h"
be_bryan 0:b74591d5ab33 19 #include "m451_can.h"
be_bryan 0:b74591d5ab33 20
be_bryan 0:b74591d5ab33 21 #if DEVICE_CAN
be_bryan 0:b74591d5ab33 22 #include <string.h>
be_bryan 0:b74591d5ab33 23 #include "cmsis.h"
be_bryan 0:b74591d5ab33 24 #include "pinmap.h"
be_bryan 0:b74591d5ab33 25 #include "PeripheralPins.h"
be_bryan 0:b74591d5ab33 26 #include "nu_modutil.h"
be_bryan 0:b74591d5ab33 27 #include "nu_miscutil.h"
be_bryan 0:b74591d5ab33 28 #include "nu_bitutil.h"
be_bryan 0:b74591d5ab33 29 #include "mbed_critical.h"
be_bryan 0:b74591d5ab33 30
be_bryan 0:b74591d5ab33 31 #define NU_CAN_DEBUG 0
be_bryan 0:b74591d5ab33 32 #define CAN_NUM 1
be_bryan 0:b74591d5ab33 33
be_bryan 0:b74591d5ab33 34 static uint32_t can_irq_ids[CAN_NUM] = {0};
be_bryan 0:b74591d5ab33 35 static can_irq_handler can0_irq_handler;
be_bryan 0:b74591d5ab33 36
be_bryan 0:b74591d5ab33 37
be_bryan 0:b74591d5ab33 38 static const struct nu_modinit_s can_modinit_tab[] = {
be_bryan 0:b74591d5ab33 39 {CAN_0, CAN0_MODULE, 0, 0, CAN0_RST, CAN0_IRQn, NULL},
be_bryan 0:b74591d5ab33 40
be_bryan 0:b74591d5ab33 41 {NC, 0, 0, 0, 0, (IRQn_Type) 0, NULL}
be_bryan 0:b74591d5ab33 42 };
be_bryan 0:b74591d5ab33 43
be_bryan 0:b74591d5ab33 44
be_bryan 0:b74591d5ab33 45 void can_init_freq(can_t *obj, PinName rd, PinName td, int hz)
be_bryan 0:b74591d5ab33 46 {
be_bryan 0:b74591d5ab33 47 uint32_t can_td = (CANName)pinmap_peripheral(td, PinMap_CAN_TD);
be_bryan 0:b74591d5ab33 48 uint32_t can_rd = (CANName)pinmap_peripheral(rd, PinMap_CAN_RD);
be_bryan 0:b74591d5ab33 49 obj->can = (CANName)pinmap_merge(can_td, can_rd);
be_bryan 0:b74591d5ab33 50 MBED_ASSERT((int)obj->can != NC);
be_bryan 0:b74591d5ab33 51
be_bryan 0:b74591d5ab33 52 const struct nu_modinit_s *modinit = get_modinit(obj->can, can_modinit_tab);
be_bryan 0:b74591d5ab33 53 MBED_ASSERT(modinit != NULL);
be_bryan 0:b74591d5ab33 54 MBED_ASSERT(modinit->modname == obj->can);
be_bryan 0:b74591d5ab33 55
be_bryan 0:b74591d5ab33 56 // Reset this module
be_bryan 0:b74591d5ab33 57 SYS_ResetModule(modinit->rsetidx);
be_bryan 0:b74591d5ab33 58
be_bryan 0:b74591d5ab33 59 // Enable IP clock
be_bryan 0:b74591d5ab33 60 CLK_EnableModuleClock(modinit->clkidx);
be_bryan 0:b74591d5ab33 61
be_bryan 0:b74591d5ab33 62 obj->index = 0;
be_bryan 0:b74591d5ab33 63
be_bryan 0:b74591d5ab33 64 pinmap_pinout(td, PinMap_CAN_TD);
be_bryan 0:b74591d5ab33 65 pinmap_pinout(rd, PinMap_CAN_RD);
be_bryan 0:b74591d5ab33 66
be_bryan 0:b74591d5ab33 67 /* For M453 mbed Board Transmitter Setting (RS Pin) */
be_bryan 0:b74591d5ab33 68 GPIO_SetMode(PA, BIT0| BIT1, GPIO_MODE_OUTPUT);
be_bryan 0:b74591d5ab33 69 PA0 = 0x00;
be_bryan 0:b74591d5ab33 70 PA1 = 0x00;
be_bryan 0:b74591d5ab33 71
be_bryan 0:b74591d5ab33 72 CAN_Open((CAN_T *)NU_MODBASE(obj->can), hz, CAN_NORMAL_MODE);
be_bryan 0:b74591d5ab33 73
be_bryan 0:b74591d5ab33 74 can_filter(obj, 0, 0, CANStandard, 0);
be_bryan 0:b74591d5ab33 75 }
be_bryan 0:b74591d5ab33 76
be_bryan 0:b74591d5ab33 77
be_bryan 0:b74591d5ab33 78 void can_init(can_t *obj, PinName rd, PinName td)
be_bryan 0:b74591d5ab33 79 {
be_bryan 0:b74591d5ab33 80 can_init_freq(obj, rd, td, 500000);
be_bryan 0:b74591d5ab33 81 }
be_bryan 0:b74591d5ab33 82
be_bryan 0:b74591d5ab33 83
be_bryan 0:b74591d5ab33 84 void can_free(can_t *obj)
be_bryan 0:b74591d5ab33 85 {
be_bryan 0:b74591d5ab33 86
be_bryan 0:b74591d5ab33 87 const struct nu_modinit_s *modinit = get_modinit(obj->can, can_modinit_tab);
be_bryan 0:b74591d5ab33 88
be_bryan 0:b74591d5ab33 89 MBED_ASSERT(modinit != NULL);
be_bryan 0:b74591d5ab33 90 MBED_ASSERT(modinit->modname == obj->can);
be_bryan 0:b74591d5ab33 91
be_bryan 0:b74591d5ab33 92 // Reset this module
be_bryan 0:b74591d5ab33 93 SYS_ResetModule(modinit->rsetidx);
be_bryan 0:b74591d5ab33 94
be_bryan 0:b74591d5ab33 95 CLK_DisableModuleClock(modinit->clkidx);
be_bryan 0:b74591d5ab33 96 }
be_bryan 0:b74591d5ab33 97
be_bryan 0:b74591d5ab33 98 int can_frequency(can_t *obj, int hz)
be_bryan 0:b74591d5ab33 99 {
be_bryan 0:b74591d5ab33 100 CAN_SetBaudRate((CAN_T *)NU_MODBASE(obj->can), hz);
be_bryan 0:b74591d5ab33 101
be_bryan 0:b74591d5ab33 102 return CAN_GetCANBitRate((CAN_T *)NU_MODBASE(obj->can));
be_bryan 0:b74591d5ab33 103 }
be_bryan 0:b74591d5ab33 104
be_bryan 0:b74591d5ab33 105 static void can_irq(CANName name, int id)
be_bryan 0:b74591d5ab33 106 {
be_bryan 0:b74591d5ab33 107
be_bryan 0:b74591d5ab33 108 CAN_T *can = (CAN_T *)NU_MODBASE(name);
be_bryan 0:b74591d5ab33 109 uint32_t u8IIDRstatus;
be_bryan 0:b74591d5ab33 110
be_bryan 0:b74591d5ab33 111 u8IIDRstatus = can->IIDR;
be_bryan 0:b74591d5ab33 112
be_bryan 0:b74591d5ab33 113 if(u8IIDRstatus == 0x00008000) { /* Check Status Interrupt Flag (Error status Int and Status change Int) */
be_bryan 0:b74591d5ab33 114 /**************************/
be_bryan 0:b74591d5ab33 115 /* Status Change interrupt*/
be_bryan 0:b74591d5ab33 116 /**************************/
be_bryan 0:b74591d5ab33 117 if(can->STATUS & CAN_STATUS_RXOK_Msk) {
be_bryan 0:b74591d5ab33 118 can->STATUS &= ~CAN_STATUS_RXOK_Msk; /* Clear Rx Ok status*/
be_bryan 0:b74591d5ab33 119 can0_irq_handler(can_irq_ids[id], IRQ_RX);
be_bryan 0:b74591d5ab33 120 }
be_bryan 0:b74591d5ab33 121
be_bryan 0:b74591d5ab33 122 if(can->STATUS & CAN_STATUS_TXOK_Msk) {
be_bryan 0:b74591d5ab33 123 can->STATUS &= ~CAN_STATUS_TXOK_Msk; /* Clear Tx Ok status*/
be_bryan 0:b74591d5ab33 124 can0_irq_handler(can_irq_ids[id], IRQ_TX);
be_bryan 0:b74591d5ab33 125 }
be_bryan 0:b74591d5ab33 126
be_bryan 0:b74591d5ab33 127 /**************************/
be_bryan 0:b74591d5ab33 128 /* Error Status interrupt */
be_bryan 0:b74591d5ab33 129 /**************************/
be_bryan 0:b74591d5ab33 130 if(can->STATUS & CAN_STATUS_EWARN_Msk) {
be_bryan 0:b74591d5ab33 131 can0_irq_handler(can_irq_ids[id], IRQ_ERROR);
be_bryan 0:b74591d5ab33 132 }
be_bryan 0:b74591d5ab33 133
be_bryan 0:b74591d5ab33 134 if(can->STATUS & CAN_STATUS_BOFF_Msk) {
be_bryan 0:b74591d5ab33 135 can0_irq_handler(can_irq_ids[id], IRQ_BUS);
be_bryan 0:b74591d5ab33 136 }
be_bryan 0:b74591d5ab33 137 } else if (u8IIDRstatus!=0) {
be_bryan 0:b74591d5ab33 138
be_bryan 0:b74591d5ab33 139 can0_irq_handler(can_irq_ids[id], IRQ_OVERRUN);
be_bryan 0:b74591d5ab33 140
be_bryan 0:b74591d5ab33 141 CAN_CLR_INT_PENDING_BIT(can, ((can->IIDR) -1)); /* Clear Interrupt Pending */
be_bryan 0:b74591d5ab33 142
be_bryan 0:b74591d5ab33 143 } else if(can->WU_STATUS == 1) {
be_bryan 0:b74591d5ab33 144
be_bryan 0:b74591d5ab33 145 can->WU_STATUS = 0; /* Write '0' to clear */
be_bryan 0:b74591d5ab33 146 can0_irq_handler(can_irq_ids[id], IRQ_WAKEUP);
be_bryan 0:b74591d5ab33 147 }
be_bryan 0:b74591d5ab33 148 }
be_bryan 0:b74591d5ab33 149
be_bryan 0:b74591d5ab33 150 void CAN0_IRQHandler(void)
be_bryan 0:b74591d5ab33 151 {
be_bryan 0:b74591d5ab33 152 can_irq(CAN_0, 0);
be_bryan 0:b74591d5ab33 153 }
be_bryan 0:b74591d5ab33 154
be_bryan 0:b74591d5ab33 155 void can_irq_init(can_t *obj, can_irq_handler handler, uint32_t id)
be_bryan 0:b74591d5ab33 156 {
be_bryan 0:b74591d5ab33 157 can0_irq_handler = handler;
be_bryan 0:b74591d5ab33 158 can_irq_ids[obj->index] = id;
be_bryan 0:b74591d5ab33 159 }
be_bryan 0:b74591d5ab33 160
be_bryan 0:b74591d5ab33 161 void can_irq_free(can_t *obj)
be_bryan 0:b74591d5ab33 162 {
be_bryan 0:b74591d5ab33 163 CAN_DisableInt((CAN_T *)NU_MODBASE(obj->can), (CAN_CON_IE_Msk|CAN_CON_SIE_Msk|CAN_CON_EIE_Msk));
be_bryan 0:b74591d5ab33 164
be_bryan 0:b74591d5ab33 165 can_irq_ids[obj->index] = 0;
be_bryan 0:b74591d5ab33 166
be_bryan 0:b74591d5ab33 167 NVIC_DisableIRQ(CAN0_IRQn);
be_bryan 0:b74591d5ab33 168 }
be_bryan 0:b74591d5ab33 169
be_bryan 0:b74591d5ab33 170 void can_irq_set(can_t *obj, CanIrqType irq, uint32_t enable)
be_bryan 0:b74591d5ab33 171 {
be_bryan 0:b74591d5ab33 172 CAN_T *can_base = (CAN_T *) NU_MODBASE(obj->can);
be_bryan 0:b74591d5ab33 173
be_bryan 0:b74591d5ab33 174 CAN_EnterInitMode(can_base, ((enable != 0 )? CAN_CON_IE_Msk :0) );
be_bryan 0:b74591d5ab33 175
be_bryan 0:b74591d5ab33 176
be_bryan 0:b74591d5ab33 177 switch (irq)
be_bryan 0:b74591d5ab33 178 {
be_bryan 0:b74591d5ab33 179 case IRQ_ERROR:
be_bryan 0:b74591d5ab33 180 case IRQ_BUS:
be_bryan 0:b74591d5ab33 181 case IRQ_PASSIVE:
be_bryan 0:b74591d5ab33 182 can_base->CON = can_base->CON |CAN_CON_EIE_Msk;
be_bryan 0:b74591d5ab33 183 can_base->CON = can_base->CON |CAN_CON_SIE_Msk;
be_bryan 0:b74591d5ab33 184 break;
be_bryan 0:b74591d5ab33 185
be_bryan 0:b74591d5ab33 186 case IRQ_RX:
be_bryan 0:b74591d5ab33 187 case IRQ_TX:
be_bryan 0:b74591d5ab33 188 case IRQ_OVERRUN:
be_bryan 0:b74591d5ab33 189 case IRQ_WAKEUP:
be_bryan 0:b74591d5ab33 190 can_base->CON = can_base->CON |CAN_CON_SIE_Msk;
be_bryan 0:b74591d5ab33 191 break;
be_bryan 0:b74591d5ab33 192
be_bryan 0:b74591d5ab33 193 default:
be_bryan 0:b74591d5ab33 194 break;
be_bryan 0:b74591d5ab33 195
be_bryan 0:b74591d5ab33 196 }
be_bryan 0:b74591d5ab33 197
be_bryan 0:b74591d5ab33 198 CAN_LeaveInitMode(can_base);
be_bryan 0:b74591d5ab33 199
be_bryan 0:b74591d5ab33 200 NVIC_SetVector(CAN0_IRQn, (uint32_t)&CAN0_IRQHandler);
be_bryan 0:b74591d5ab33 201 NVIC_EnableIRQ(CAN0_IRQn);
be_bryan 0:b74591d5ab33 202
be_bryan 0:b74591d5ab33 203 }
be_bryan 0:b74591d5ab33 204
be_bryan 0:b74591d5ab33 205 int can_write(can_t *obj, CAN_Message msg, int cc)
be_bryan 0:b74591d5ab33 206 {
be_bryan 0:b74591d5ab33 207 STR_CANMSG_T CMsg;
be_bryan 0:b74591d5ab33 208
be_bryan 0:b74591d5ab33 209 CMsg.IdType = (uint32_t)msg.format;
be_bryan 0:b74591d5ab33 210 CMsg.FrameType = (uint32_t)!msg.type;
be_bryan 0:b74591d5ab33 211 CMsg.Id = msg.id;
be_bryan 0:b74591d5ab33 212 CMsg.DLC = msg.len;
be_bryan 0:b74591d5ab33 213 memcpy((void *)&CMsg.Data[0],(const void *)&msg.data[0], (unsigned int)8);
be_bryan 0:b74591d5ab33 214
be_bryan 0:b74591d5ab33 215 return CAN_Transmit((CAN_T *)NU_MODBASE(obj->can), cc, &CMsg);
be_bryan 0:b74591d5ab33 216 }
be_bryan 0:b74591d5ab33 217
be_bryan 0:b74591d5ab33 218 int can_read(can_t *obj, CAN_Message *msg, int handle)
be_bryan 0:b74591d5ab33 219 {
be_bryan 0:b74591d5ab33 220 STR_CANMSG_T CMsg;
be_bryan 0:b74591d5ab33 221
be_bryan 0:b74591d5ab33 222 if(!CAN_Receive((CAN_T *)NU_MODBASE(obj->can), handle, &CMsg))
be_bryan 0:b74591d5ab33 223 return 0;
be_bryan 0:b74591d5ab33 224
be_bryan 0:b74591d5ab33 225 msg->format = (CANFormat)CMsg.IdType;
be_bryan 0:b74591d5ab33 226 msg->type = (CANType)!CMsg.FrameType;
be_bryan 0:b74591d5ab33 227 msg->id = CMsg.Id;
be_bryan 0:b74591d5ab33 228 msg->len = CMsg.DLC;
be_bryan 0:b74591d5ab33 229 memcpy(&msg->data[0], &CMsg.Data[0], 8);
be_bryan 0:b74591d5ab33 230
be_bryan 0:b74591d5ab33 231 return 1;
be_bryan 0:b74591d5ab33 232 }
be_bryan 0:b74591d5ab33 233
be_bryan 0:b74591d5ab33 234 int can_mode(can_t *obj, CanMode mode)
be_bryan 0:b74591d5ab33 235 {
be_bryan 0:b74591d5ab33 236 CAN_T *can_base = (CAN_T *) NU_MODBASE(obj->can);
be_bryan 0:b74591d5ab33 237
be_bryan 0:b74591d5ab33 238 int success = 0;
be_bryan 0:b74591d5ab33 239 switch (mode)
be_bryan 0:b74591d5ab33 240 {
be_bryan 0:b74591d5ab33 241 case MODE_RESET:
be_bryan 0:b74591d5ab33 242 CAN_LeaveTestMode(can_base);
be_bryan 0:b74591d5ab33 243 success = 1;
be_bryan 0:b74591d5ab33 244 break;
be_bryan 0:b74591d5ab33 245
be_bryan 0:b74591d5ab33 246 case MODE_NORMAL:
be_bryan 0:b74591d5ab33 247 CAN_EnterTestMode(can_base, CAN_TEST_BASIC_Msk);
be_bryan 0:b74591d5ab33 248 success = 1;
be_bryan 0:b74591d5ab33 249 break;
be_bryan 0:b74591d5ab33 250
be_bryan 0:b74591d5ab33 251 case MODE_SILENT:
be_bryan 0:b74591d5ab33 252 CAN_EnterTestMode(can_base, CAN_TEST_SILENT_Msk);
be_bryan 0:b74591d5ab33 253 success = 1;
be_bryan 0:b74591d5ab33 254 break;
be_bryan 0:b74591d5ab33 255
be_bryan 0:b74591d5ab33 256 case MODE_TEST_LOCAL:
be_bryan 0:b74591d5ab33 257 case MODE_TEST_GLOBAL:
be_bryan 0:b74591d5ab33 258 CAN_EnterTestMode(can_base, CAN_TEST_LBACK_Msk);
be_bryan 0:b74591d5ab33 259 success = 1;
be_bryan 0:b74591d5ab33 260 break;
be_bryan 0:b74591d5ab33 261
be_bryan 0:b74591d5ab33 262 case MODE_TEST_SILENT:
be_bryan 0:b74591d5ab33 263 CAN_EnterTestMode(can_base, CAN_TEST_SILENT_Msk | CAN_TEST_LBACK_Msk);
be_bryan 0:b74591d5ab33 264 success = 1;
be_bryan 0:b74591d5ab33 265 break;
be_bryan 0:b74591d5ab33 266
be_bryan 0:b74591d5ab33 267 default:
be_bryan 0:b74591d5ab33 268 success = 0;
be_bryan 0:b74591d5ab33 269 break;
be_bryan 0:b74591d5ab33 270
be_bryan 0:b74591d5ab33 271 }
be_bryan 0:b74591d5ab33 272
be_bryan 0:b74591d5ab33 273
be_bryan 0:b74591d5ab33 274 return success;
be_bryan 0:b74591d5ab33 275 }
be_bryan 0:b74591d5ab33 276
be_bryan 0:b74591d5ab33 277 int can_filter(can_t *obj, uint32_t id, uint32_t mask, CANFormat format, int32_t handle)
be_bryan 0:b74591d5ab33 278 {
be_bryan 0:b74591d5ab33 279 return CAN_SetRxMsg((CAN_T *)NU_MODBASE(obj->can), handle , (uint32_t)format, id);
be_bryan 0:b74591d5ab33 280 }
be_bryan 0:b74591d5ab33 281
be_bryan 0:b74591d5ab33 282
be_bryan 0:b74591d5ab33 283 void can_reset(can_t *obj)
be_bryan 0:b74591d5ab33 284 {
be_bryan 0:b74591d5ab33 285 const struct nu_modinit_s *modinit = get_modinit(obj->can, can_modinit_tab);
be_bryan 0:b74591d5ab33 286
be_bryan 0:b74591d5ab33 287 MBED_ASSERT(modinit != NULL);
be_bryan 0:b74591d5ab33 288 MBED_ASSERT(modinit->modname == obj->can);
be_bryan 0:b74591d5ab33 289
be_bryan 0:b74591d5ab33 290 // Reset this module
be_bryan 0:b74591d5ab33 291 SYS_ResetModule(modinit->rsetidx);
be_bryan 0:b74591d5ab33 292
be_bryan 0:b74591d5ab33 293 }
be_bryan 0:b74591d5ab33 294
be_bryan 0:b74591d5ab33 295 unsigned char can_rderror(can_t *obj)
be_bryan 0:b74591d5ab33 296 {
be_bryan 0:b74591d5ab33 297 CAN_T *can = (CAN_T *)NU_MODBASE(obj->can);
be_bryan 0:b74591d5ab33 298 return ((can->ERR>>8)&0xFF);
be_bryan 0:b74591d5ab33 299 }
be_bryan 0:b74591d5ab33 300
be_bryan 0:b74591d5ab33 301 unsigned char can_tderror(can_t *obj)
be_bryan 0:b74591d5ab33 302 {
be_bryan 0:b74591d5ab33 303 CAN_T *can = (CAN_T *)NU_MODBASE(obj->can);
be_bryan 0:b74591d5ab33 304 return ((can->ERR)&0xFF);
be_bryan 0:b74591d5ab33 305 }
be_bryan 0:b74591d5ab33 306
be_bryan 0:b74591d5ab33 307 void can_monitor(can_t *obj, int silent)
be_bryan 0:b74591d5ab33 308 {
be_bryan 0:b74591d5ab33 309 CAN_EnterTestMode((CAN_T *)NU_MODBASE(obj->can), CAN_TEST_SILENT_Msk);
be_bryan 0:b74591d5ab33 310 }
be_bryan 0:b74591d5ab33 311
be_bryan 0:b74591d5ab33 312 #endif // DEVICE_CAN