SAMV71 Xplained Ultra Software Package 1.0

can.c

Go to the documentation of this file.
00001 /* ----------------------------------------------------------------------------
00002  *         SAM Software Package License 
00003  * ----------------------------------------------------------------------------
00004  * Copyright (c) 2012, Atmel Corporation
00005  *
00006  * All rights reserved.
00007  *
00008  * Redistribution and use in source and binary forms, with or without
00009  * modification, are permitted provided that the following conditions are met:
00010  *
00011  * - Redistributions of source code must retain the above copyright notice,
00012  * this list of conditions and the disclaimer below.
00013  *
00014  * Atmel's name may not be used to endorse or promote products derived from
00015  * this software without specific prior written permission.
00016  *
00017  * DISCLAIMER: THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR
00018  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
00019  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
00020  * DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR ANY DIRECT, INDIRECT,
00021  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
00022  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
00023  * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
00024  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
00025  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
00026  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00027  * ----------------------------------------------------------------------------
00028  */
00029 
00030 /** \file
00031  *  Implements functions for Controller Area Network (CAN)
00032  *  peripheral operations.
00033  */
00034 /** \addtogroup can_module
00035  *@{*/
00036 
00037 /*----------------------------------------------------------------------------
00038  *        Headers
00039  *----------------------------------------------------------------------------*/
00040 
00041 #include "chip.h"
00042 
00043 #include <assert.h>
00044 
00045 #if defined(REG_CAN0_MR) || defined(REG_CAN_MR)
00046 
00047 /* ----------- CAN_MR Operations --------------- */
00048 /**
00049  * \brief Set CAN Mode Register (CAN_MR)
00050  * \param pCan Pointer to Can instance.
00051  * \param dwMr Mode register settings.
00052  */
00053 void CAN_ConfigureMode(Can *pCan, uint32_t dwMr)
00054 {
00055     pCan->CAN_MR = dwMr;
00056 }
00057 
00058 /**
00059  * \brief CAN Controller Enable/Disable
00060  * \param pCan   Pointer to Can instance.
00061  * \param bEnDis 1 to enable and 0 to disable.
00062  */
00063 void CAN_Enable(Can *pCan, uint8_t bEnDis)
00064 {
00065     if (bEnDis) pCan->CAN_MR |=  CAN_MR_CANEN;
00066     else        pCan->CAN_MR &= ~CAN_MR_CANEN;
00067 }
00068 
00069 /**
00070  * \brief CAN Low Power Mode Enable/Disable
00071  * \param pCan   Pointer to Can instance.
00072  * \param bEnDis 1 to enable and 0 to disable.
00073  */
00074 void CAN_EnableLowPower(Can *pCan, uint8_t bEnDis)
00075 {
00076     if (bEnDis) pCan->CAN_MR |=  CAN_MR_LPM;
00077     else        pCan->CAN_MR &= ~CAN_MR_LPM;
00078 }
00079 
00080 /**
00081  * \brief CAN Autobaud/Listen mode
00082  * \param pCan   Pointer to Can instance.
00083  * \param bEnDis 1 to enable and 0 to disable.
00084  */
00085 void CAN_EnableAutobaud(Can *pCan, uint8_t bEnDis)
00086 {
00087     if (bEnDis) pCan->CAN_MR |=  CAN_MR_ABM;
00088     else        pCan->CAN_MR &= ~CAN_MR_ABM;
00089 }
00090 
00091 /**
00092  * \brief CAN Overload Frame Enable/Disable
00093  * \param pCan   Pointer to Can instance.
00094  * \param bEnDis 1 to enable and 0 to disable.
00095  */
00096 void CAN_EnableOverloadFrame(Can *pCan, uint8_t bEnDis)
00097 {
00098     if (bEnDis) pCan->CAN_MR |=  CAN_MR_OVL;
00099     else        pCan->CAN_MR &= ~CAN_MR_OVL;
00100 }
00101 
00102 /**
00103  * \brief CAN Timestamps capture mode (@EOF/@SOF).
00104  * \param pCan      Pointer to Can instance.
00105  * \param bEofSof   1 for EOF/0 for SOF.
00106  */
00107 void CAN_EnableTimeStampEof(Can *pCan, uint8_t bEofSof)
00108 {
00109     if (bEofSof) pCan->CAN_MR |=  CAN_MR_TEOF;
00110     else         pCan->CAN_MR &= ~CAN_MR_TEOF;
00111 }
00112 
00113 /**
00114  * \brief CAN Time Triggered Mode Enable/Disable
00115  * \param pCan      Pointer to Can instance.
00116  * \param bEnDis    Enable/Disable Time Trigger Mode.
00117  */
00118 void CAN_EnableTimeTriggerMode(Can *pCan, uint8_t bEnDis)
00119 {
00120     if (bEnDis) pCan->CAN_MR |=  CAN_MR_TTM;
00121     else        pCan->CAN_MR &= ~CAN_MR_TTM;
00122 }
00123 
00124 /**
00125  * \brief CAN Timer Freeze Enable/Disable
00126  * \param pCan      Pointer to Can instance.
00127  * \param bEnDis    Enable/Disable Timer Freeze.
00128  */
00129 void CAN_EnableTimerFreeze(Can *pCan, uint8_t bEnDis)
00130 {
00131     if (bEnDis) pCan->CAN_MR |=  CAN_MR_TIMFRZ;
00132     else        pCan->CAN_MR &= ~CAN_MR_TIMFRZ;
00133 }
00134 
00135 /**
00136  * \brief CAN Repeat Disable/Enable.
00137  * \param pCan      Pointer to Can instance.
00138  * \param bEnDis    Disable/Enable Repeat.
00139  */
00140 void CAN_DisableRepeat(Can *pCan, uint8_t bDisEn)
00141 {
00142     if (bDisEn) pCan->CAN_MR |=  CAN_MR_DRPT;
00143     else        pCan->CAN_MR &= ~CAN_MR_DRPT;
00144 }
00145 
00146 /* ---------- Interrupt settings ------------- */
00147 
00148 /**
00149  * \brief CAN Interrupts Enable
00150  * \param pCan      Pointer to Can instance.
00151  * \param dwSources Interrupt sources bits.
00152  */
00153 void CAN_EnableIt(Can *pCan, uint32_t dwSources)
00154 {
00155     pCan->CAN_IER = dwSources;
00156 }
00157 
00158 /**
00159  * \brief CAN Interrupts Disable
00160  * \param pCan      Pointer to Can instance.
00161  * \param dwSources Interrupt sources bits.
00162  */
00163 void CAN_DisableIt(Can *pCan, uint32_t dwSources)
00164 {
00165     pCan->CAN_IDR = dwSources;
00166 }
00167 
00168 /**
00169  * \brief Return CAN Interrupts Masks
00170  * \param pCan      Pointer to Can instance.
00171  */
00172 uint32_t CAN_GetItMask(Can *pCan)
00173 {
00174     return pCan->CAN_IMR;
00175 }
00176 
00177 /**
00178  * \brief Return CAN Statuses
00179  * \param pCan      Pointer to Can instance.
00180  */
00181 uint32_t CAN_GetStatus(Can *pCan)
00182 {
00183     return pCan->CAN_SR;
00184 }
00185 
00186 /**
00187  * \brief Calculate and configure the baudrate
00188  * \param pCan       Pointer to Can instance.
00189  * \param dwBaudrate Baudrate value (kB/s)
00190  *                   allowed: 100, 800, 500, 250, 125, 50, 25, 10
00191  * \param dwMck      MCK.
00192  * \return 1 in success, otherwise return 0.
00193  */
00194 uint8_t CAN_CalcBaudrate(Can *pCan, uint32_t dwBaudrate, uint32_t dwMck)
00195 {
00196     uint32_t BRP, PROPAG, PHASE1, PHASE2, SJW;
00197     uint8_t  TQ;
00198     uint32_t t1t2;
00199     uint32_t maxClock;
00200     uint32_t id = ID_CAN0;
00201 
00202     if ((uint32_t)pCan == (uint32_t)CAN0) id = ID_CAN0;
00203     else if ((uint32_t)pCan == (uint32_t)CAN1) id = ID_CAN1;
00204     maxClock = PMC_SetPeriMaxClock(id, dwMck);
00205 
00206     if (dwBaudrate >= 1000) TQ = 8;
00207     else                    TQ = 16;
00208     BRP = (maxClock / (dwBaudrate * 1000 * TQ)) - 1;
00209     if (BRP == 0) {
00210         return 0;
00211     }
00212 
00213     /* Timing delay:
00214        Delay Bus Driver     - 50ns
00215        Delay Receiver       - 30ns
00216        Delay Bus Line (20m) - 110ns */
00217     if ( (TQ * dwBaudrate * 2 * (50+30+110)/1000000) >= 1 )
00218         PROPAG = (TQ * dwBaudrate * 2 * (50+30+110)/1000000) - 1;
00219     else
00220         PROPAG = 0;
00221     t1t2 = TQ - 1 - (PROPAG + 1);
00222 
00223     if ( (t1t2 & 0x01) == 0x01 ) {
00224         PHASE1 = ((t1t2 - 1) / 2) - 1;
00225         PHASE2 = PHASE1 + 1;
00226     }
00227     else {
00228         PHASE1 = ((t1t2) / 2) - 1;
00229         PHASE2 = PHASE1;
00230     }
00231 
00232     if ( 1 > (4/(PHASE1 + 1)) ) SJW = 3;
00233     else                        SJW = PHASE1;
00234 
00235     if ( (PROPAG + PHASE1 + PHASE2) != (uint32_t)(TQ - 4) ) {
00236         return 0;
00237     }
00238 
00239     pCan->CAN_BR = CAN_BR_PHASE2(PHASE2)
00240         | CAN_BR_PHASE1(PHASE1)
00241         | CAN_BR_PROPAG(PROPAG)
00242         | CAN_BR_SJW(SJW)
00243         | CAN_BR_BRP(BRP)
00244         | CAN_BR_SMP_ONCE;
00245     return 1;
00246 }
00247 
00248 /**
00249  * \brief Set CAN baudrate register
00250  * \param pCan      Pointer to Can instance.
00251  * \param dwBr      Setting value for CAN_BR.
00252  */
00253 void CAN_ConfigureBaudrate(Can *pCan, uint32_t dwBr)
00254 {
00255     pCan->CAN_BR = dwBr;
00256 }
00257 
00258 /**
00259  * \brief Set CAN Sampling Mode
00260  * \param pCan      Pointer to Can instance.
00261  * \param bAvg3     Sample 3 times/sample once at sample point.
00262  */
00263 void CAN_SetSamplingMode(Can *pCan, uint8_t bAvg3)
00264 {
00265     if (bAvg3) pCan->CAN_BR |=  CAN_BR_SMP;
00266     else       pCan->CAN_BR &= ~CAN_BR_SMP;
00267 }
00268 
00269 /**
00270  * \brief Return CAN Timer Register
00271  * \param pCan      Pointer to Can instance.
00272  */
00273 uint32_t CAN_GetTimer(Can *pCan)
00274 {
00275     return pCan->CAN_TIM;
00276 }
00277 
00278 /**
00279  * \brief Return CAN TimeStamp Register
00280  * \param pCan      Pointer to Can instance.
00281  */
00282 uint32_t CAN_GetTimestamp(Can *pCan)
00283 {
00284     return pCan->CAN_TIMESTP;
00285 }
00286 
00287 /**
00288  * \brief Return Error Count (TEC << 16) + REC
00289  * \param pCan      Pointer to Can instance.
00290  */
00291 uint32_t CAN_GetErrorCount(Can *pCan)
00292 {
00293     return pCan->CAN_ECR;
00294 }
00295 
00296 /**
00297  * \brief Return Receive Error Count
00298  * \param pCan      Pointer to Can instance.
00299  */
00300 uint32_t CAN_GetRxErrorCount(Can *pCan)
00301 {
00302     return (pCan->CAN_ECR & CAN_ECR_REC_Msk) >> CAN_ECR_REC_Pos;
00303 }
00304 
00305 /**
00306  * \brief Return Transmit Error Count
00307  * \param pCan      Pointer to Can instance.
00308  */
00309 uint32_t CAN_GetTxErrorCount(Can *pCan)
00310 {
00311     return (pCan->CAN_ECR & CAN_ECR_TEC_Msk) >> CAN_ECR_TEC_Pos;
00312 }
00313 
00314 /**
00315  * \brief Set Transfer Command Register to initialize transfer requests.
00316  * \param pCan       Pointer to Can instance.
00317  * \param dwRequests Transfer Command Requests.
00318  */
00319 void CAN_Command(Can *pCan, uint32_t dwRequests)
00320 {
00321     pCan->CAN_TCR = dwRequests;
00322 }
00323 
00324 /**
00325  * \brief Resets CAN internal timer counter.
00326  * \param pCan       Pointer to Can instance.
00327  */
00328 void CAN_ResetTimer(Can *pCan)
00329 {
00330     pCan->CAN_TCR = CAN_TCR_TIMRST;
00331 }
00332 
00333 /**
00334  * \brief Request transfer on mailbox.
00335  * \param pCan       Pointer to Can instance.
00336  * \param bMb        Mailbox number.
00337  */
00338 void CAN_Tx(Can *pCan, uint8_t bMb)
00339 {
00340     pCan->CAN_TCR = CAN_TCR_MB0 << bMb;
00341 }
00342 
00343 /**
00344  * \brief Abort transfer on several mailboxes.
00345  * \param pCan       Pointer to Can instance.
00346  * \param dwAborts   Abort requests.
00347  */
00348 void CAN_Abort(Can *pCan, uint32_t dwAborts)
00349 {
00350     pCan->CAN_ACR = dwAborts;
00351 }
00352 
00353 /**
00354  * \brief Abort transfer on single mailbox.
00355  * \param pCan       Pointer to Can instance.
00356  * \param bMb        Mailbox number.
00357  */
00358 void CAN_AbortMailbox(Can *pCan, uint8_t bMb)
00359 {
00360     pCan->CAN_ACR = CAN_ACR_MB0 << bMb;
00361 }
00362 
00363 /**
00364  * \brief Configure CAN Message Mode (_MMRx)
00365  * \param pCan       Pointer to Can instance.
00366  * \param bMb        Mailbox number.
00367  * \param dwMr       Mode settings.
00368  */
00369 void CAN_ConfigureMessageMode(Can *pCan, uint8_t bMb, uint32_t dwMr)
00370 {
00371     pCan->CAN_MB[bMb].CAN_MMR = dwMr;
00372 }
00373 
00374 /**
00375  * \brief Return CAN Message Mode (_MMRx)
00376  * \param pCan       Pointer to Can instance.
00377  * \param bMb        Mailbox number.
00378  */
00379 uint32_t CAN_GetMessageMode(Can *pCan, uint8_t bMb)
00380 {
00381     return pCan->CAN_MB[bMb].CAN_MMR;
00382 }
00383 
00384 /**
00385  * \brief Set Mailbox Timemark for Time Triggered Mode.
00386  * \param pCan       Pointer to Can instance.
00387  * \param bMb        Mailbox number.
00388  * \param bTimemarks Mailbox timemarks.
00389  */
00390 void CAN_SetTimemark(Can *pCan, uint8_t bMb, uint8_t bTimemarks)
00391 {
00392     uint32_t dwMmr = (pCan->CAN_MB[bMb].CAN_MMR) & (~0xFFu);
00393     pCan->CAN_MB[bMb].CAN_MMR = dwMmr | ((bTimemarks << 0) & 0xFF);
00394 }
00395 
00396 /**
00397  * \brief Set Mailbox Priority.
00398  * \param pCan       Pointer to Can instance.
00399  * \param bMb        Mailbox number.
00400  * \param bPriority  Mailbox Priority.
00401  */
00402 void CAN_SetPriority(Can *pCan, uint8_t bMb, uint8_t bPriority)
00403 {
00404     uint32_t dwMmr = (pCan->CAN_MB[bMb].CAN_MMR & ~CAN_MMR_PRIOR_Msk);
00405     pCan->CAN_MB[bMb].CAN_MMR = dwMmr | CAN_MMR_PRIOR(bPriority);
00406 }
00407 
00408 /**
00409  * \brief Set Mailbox Object Type.
00410  * \param pCan       Pointer to Can instance.
00411  * \param bMb        Mailbox number.
00412  * \param bType      Mailbox Object Type.
00413  */
00414 void CAN_SetObjectType(Can *pCan, uint8_t bMb, uint8_t bType)
00415 {
00416     uint32_t dwMr = (pCan->CAN_MB[bMb].CAN_MMR & CAN_MMR_MOT_Msk) >> CAN_MMR_MOT_Pos;
00417     pCan->CAN_MB[bMb].CAN_MMR |= dwMr | ((bType << CAN_MMR_MOT_Pos) & CAN_MMR_MOT_Msk);
00418 }
00419 
00420 /**
00421  * \brief Configure CAN Message Acceptance Mask (_MAMx)
00422  * \param pCan       Pointer to Can instance.
00423  * \param bMb        Mailbox number.
00424  * \param dwMam      The setting value for _MAMx.
00425  */
00426 void CAN_ConfigureMessageAcceptanceMask(Can *pCan, uint8_t bMb, uint32_t dwMAM)
00427 {
00428     pCan->CAN_MB[bMb].CAN_MAM = dwMAM;
00429 }
00430 
00431 /**
00432  * \brief Return CAN Message Acceptance Mask (_MAMx)
00433  * \param pCan       Pointer to Can instance.
00434  * \param bMb        Mailbox number.
00435  */
00436 uint32_t CAN_GetMessageAcceptanceMask(Can *pCan, uint8_t bMb)
00437 {
00438     return pCan->CAN_MB[bMb].CAN_MAM;
00439 }
00440 
00441 /**
00442  * \brief Configure Identifier Version in CAN Message Acceptance Mask (_MAMx)
00443  * \param pCan       Pointer to Can instance.
00444  * \param bMb        Mailbox number.
00445  * \param bIdCfg     IDvA and IDvB/IDvA only Identify.
00446  */
00447 void CAN_ConfigureIdentifierMask(Can *pCan, uint8_t bMb, uint8_t bIdCfg)
00448 {
00449     if (bIdCfg) pCan->CAN_MB[bMb].CAN_MAM |=  CAN_MAM_MIDE;
00450     else        pCan->CAN_MB[bMb].CAN_MAM &= ~CAN_MAM_MIDE;
00451 }
00452 
00453 /**
00454  * \brief Set Identifier for standard frame mode (MIDvA) mask
00455  * \param pCan       Pointer to Can instance.
00456  * \param bMb        Mailbox number.
00457  * \param dwMIDvA    Identifier for standard frame mode.
00458  */
00459 void CAN_SetMIDvAMask(Can *pCan, uint8_t bMb, uint32_t dwIDvA)
00460 {
00461     uint32_t dwMam = pCan->CAN_MB[bMb].CAN_MAM & CAN_MAM_MIDvA_Msk;
00462     pCan->CAN_MB[bMb].CAN_MAM = dwMam | CAN_MAM_MIDvA(dwIDvA);
00463 }
00464 
00465 /**
00466  * \brief Set Complementary bits for identifier in extended frame mode (MIDvB) mask
00467  * \param pCan       Pointer to Can instance.
00468  * \param bMb        Mailbox number.
00469  * \param dwMIDvB    Identifier for extended frame mode.
00470  */
00471 void CAN_SetMIDvBMask(Can *pCan, uint8_t bMb, uint32_t dwIDvA)
00472 {
00473     uint32_t dwMam = pCan->CAN_MB[bMb].CAN_MAM & CAN_MAM_MIDvB_Msk;
00474     pCan->CAN_MB[bMb].CAN_MAM = dwMam | CAN_MAM_MIDvB(dwIDvA);
00475 }
00476 
00477 /**
00478  * \brief Configure CAN Message ID (_MIDx)
00479  * \param pCan       Pointer to Can instance.
00480  * \param bMb        Mailbox number.
00481  * \param dwMID      The setting value for _MIDx.
00482  */
00483 void CAN_ConfigureMessageID(Can *pCan, uint8_t bMb, uint32_t dwMID)
00484 {
00485     pCan->CAN_MB[bMb].CAN_MID = dwMID;
00486 }
00487 
00488 /**
00489  * \brief Return CAN Message ID (_MIDx)
00490  * \param pCan       Pointer to Can instance.
00491  * \param bMb        Mailbox number.
00492  */
00493 uint32_t CAN_GetMessageID(Can *pCan, uint8_t bMb)
00494 {
00495     return pCan->CAN_MB[bMb].CAN_MID;
00496 }
00497 
00498 /**
00499  * \brief Configure Identifier Version in CAN Message ID register (_MIDx)
00500  * \param pCan       Pointer to Can instance.
00501  * \param bMb        Mailbox number.
00502  * \param bIdVer     2.0 Part B/2.0 Part A.
00503  */
00504 void CAN_ConfigureIdVer(Can *pCan, uint8_t bMb, uint8_t bIdVer)
00505 {
00506     uint32_t dwMid = pCan->CAN_MB[bMb].CAN_MID & CAN_MID_MIDE;
00507     pCan->CAN_MB[bMb].CAN_MID = dwMid | (bIdVer ? CAN_MID_MIDE : 0);
00508 }
00509 
00510 /**
00511  * \brief Set Identifier for standard frame mode (MIDvA) value
00512  * \param pCan       Pointer to Can instance.
00513  * \param bMb        Mailbox number.
00514  * \param dwMIDvA    Identifier for standard frame mode.
00515  */
00516 void CAN_SetMIDvA(Can *pCan, uint8_t bMb, uint32_t dwIDvA)
00517 {
00518     uint32_t dwMam = pCan->CAN_MB[bMb].CAN_MID & CAN_MID_MIDvA_Msk;
00519     pCan->CAN_MB[bMb].CAN_MID = dwMam | CAN_MID_MIDvA(dwIDvA);
00520 }
00521 
00522 /**
00523  * \brief Set Complementary bits for identifier in extended frame mode (MIDvB) value
00524  * \param pCan       Pointer to Can instance.
00525  * \param bMb        Mailbox number.
00526  * \param dwMIDvB    Identifier for extended frame mode.
00527  */
00528 void CAN_SetMIDvB(Can *pCan, uint8_t bMb, uint32_t dwIDvA)
00529 {
00530     uint32_t dwMam = pCan->CAN_MB[bMb].CAN_MID & CAN_MID_MIDvB_Msk;
00531     pCan->CAN_MB[bMb].CAN_MID = dwMam | CAN_MID_MIDvB(dwIDvA);
00532 }
00533 
00534 /**
00535  * \brief Return CAN Message Family ID (Masked ID)
00536  * \param pCan       Pointer to Can instance.
00537  * \param bMb        Mailbox number.
00538  */
00539 uint32_t CAN_GetFamilyID(Can *pCan, uint8_t bMb)
00540 {
00541     return pCan->CAN_MB[bMb].CAN_MFID;
00542 }
00543 
00544 /**
00545  * \brief Return CAN Message Status
00546  * \param pCan       Pointer to Can instance.
00547  * \param bMb        Mailbox number.
00548  */
00549 uint32_t CAN_GetMessageStatus(Can *pCan, uint8_t bMb)
00550 {
00551     return pCan->CAN_MB[bMb].CAN_MSR;
00552 }
00553 
00554 /**
00555  * \brief Return CAN Message Data Low
00556  * \param pCan       Pointer to Can instance.
00557  * \param bMb        Mailbox number.
00558  */
00559 uint32_t CAN_GetMessageDataL(Can *pCan, uint8_t bMb)
00560 {
00561     return pCan->CAN_MB[bMb].CAN_MDL;
00562 }
00563 
00564 /**
00565  * \brief Set CAN Message Data Low
00566  * \param pCan       Pointer to Can instance.
00567  * \param bMb        Mailbox number.
00568  * \param dwL        Data Low Value.
00569  */
00570 void CAN_SetMessageDataL(Can *pCan, uint8_t bMb, uint32_t dwL)
00571 {
00572     pCan->CAN_MB[bMb].CAN_MDL = dwL;
00573 }
00574 
00575 /**
00576  * \brief Set CAN Message Data High
00577  * \param pCan       Pointer to Can instance.
00578  * \param bMb        Mailbox number.
00579  * \param dwH        Data High Value.
00580  */
00581 void CAN_SetMessageDataH(Can *pCan, uint8_t bMb, uint32_t dwH)
00582 {
00583     pCan->CAN_MB[bMb].CAN_MDH = dwH;
00584 }
00585 
00586 /**
00587  * \brief Return CAN Message Data High
00588  * \param pCan       Pointer to Can instance.
00589  * \param bMb        Mailbox number.
00590  */
00591 uint32_t CAN_GetMessageDataH(Can *pCan, uint8_t bMb)
00592 {
00593     return pCan->CAN_MB[bMb].CAN_MDH;
00594 }
00595 
00596 /**
00597  * \brief Copy DW array to CAN Message Data.
00598  * \param pCan       Pointer to Can instance.
00599  * \param bMb        Mailbox number.
00600  * \param pDwData    Pointer to a buffer for data.
00601  */
00602 void CAN_SetMessage(Can *pCan, uint8_t bMb, uint32_t *pDwData)
00603 {
00604     pCan->CAN_MB[bMb].CAN_MDL = pDwData[0];
00605     pCan->CAN_MB[bMb].CAN_MDH = pDwData[1];
00606 }
00607 
00608 /**
00609  * \brief Copy CAN Message Data to DW array.
00610  * \param pCan       Pointer to Can instance.
00611  * \param bMb        Mailbox number.
00612  * \param pDwData    Pointer to a buffer for data.
00613  */
00614 void CAN_GetMessage(Can *pCan, uint8_t bMb, uint32_t *pDwData)
00615 {
00616     pDwData[0] = pCan->CAN_MB[bMb].CAN_MDL;
00617     pDwData[1] = pCan->CAN_MB[bMb].CAN_MDH;
00618 }
00619 
00620 /**
00621  * \brief Set CAN Message Data in u64
00622  * \param pCan       Pointer to Can instance.
00623  * \param bMb        Mailbox number.
00624  */
00625 void CAN_SetMessageData64(Can *pCan, uint8_t bMb, uint64_t u64)
00626 {
00627     pCan->CAN_MB[bMb].CAN_MDL = (uint32_t)u64;
00628     pCan->CAN_MB[bMb].CAN_MDH = (u64 >> 32);
00629 }
00630 
00631 /**
00632  * \brief Return CAN Message Data in u64
00633  * \param pCan       Pointer to Can instance.
00634  * \param bMb        Mailbox number.
00635  */
00636 uint64_t CAN_GetMessageData64(Can *pCan, uint8_t bMb)
00637 {
00638     uint64_t ddwMd = (uint64_t)pCan->CAN_MB[bMb].CAN_MDH << 32;
00639     ddwMd += pCan->CAN_MB[bMb].CAN_MDL;
00640     return ddwMd;
00641 }
00642 
00643 /**
00644  * \brief Set CAN Message Control Register (_MCRx).
00645  * \param pCan       Pointer to Can instance.
00646  * \param bMb        Mailbox number.
00647  * \param dwCtrl     Control value.
00648  */
00649 void CAN_MessageControl(Can *pCan, uint8_t bMb, uint32_t dwCtrl)
00650 {
00651     pCan->CAN_MB[bMb].CAN_MCR = dwCtrl;
00652 }
00653 
00654 /**
00655  * \brief Start remote frame.
00656  * \param pCan       Pointer to Can instance.
00657  * \param bMb        Mailbox number.
00658  */
00659 void CAN_MessageRemote(Can *pCan, uint8_t bMb)
00660 {
00661     pCan->CAN_MB[bMb].CAN_MCR = CAN_MCR_MRTR;
00662 }
00663 
00664 /**
00665  * \brief Abort transmission.
00666  * \param pCan       Pointer to Can instance.
00667  * \param bMb        Mailbox number.
00668  */
00669 void CAN_MessageAbort(Can *pCan, uint8_t bMb)
00670 {
00671     pCan->CAN_MB[bMb].CAN_MCR = CAN_MCR_MACR;
00672 }
00673 
00674 /**
00675  * \brief Start transmission.
00676  * \param pCan       Pointer to Can instance.
00677  * \param bMb        Mailbox number.
00678  * \param bLen       Message length.
00679  */
00680 void CAN_MessageTx(Can *pCan, uint8_t bMb, uint8_t bLen)
00681 {
00682     pCan->CAN_MB[bMb].CAN_MCR = CAN_MCR_MTCR | CAN_MCR_MDLC(bLen);
00683 }
00684 
00685 /**
00686  * \brief Start reception.
00687  * \param pCan       Pointer to Can instance.
00688  * \param bMb        Mailbox number.
00689  */
00690 void CAN_MessageRx(Can *pCan, uint8_t bMb)
00691 {
00692     pCan->CAN_MB[bMb].CAN_MCR = CAN_MCR_MTCR;
00693 }
00694 
00695 #endif
00696 /**@}*/
00697 
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Defines