در جستجوی سمپل کار با can در کتابخانه cmsis برای LPC1768

[mehrdad201]

سلام به همه دوستان عزیز وو گرامی

در یه پروژه ای نیاز هست که با can ها کار کنم. متوجه شدم که تو کتابخانه cmsis کتابخانه ای برای can در نظر گرفته شده اما هر چی گشتم یه سمپل پیدا نکردم که ببینم برای استفاه از can باید چه کرد و چه توابعی رو باید به کار برد.

از بین دوستان کسی میدونه از کجا میشه سمپل های خوب در ارتباط با مشکل من پیدا کرد ؟

سپاس از توجه دوستان

[mahdizarkoob]

پاسخ : در جستجوی سمپل کار با can در کتابخانه cmsis برای LPC1768

سلام
نمیشه که نباشه!
lpc17xx.cmsis.driver.library\Examples\CAN
این 5 سمپل هست:
CAN_LedControl
CAN_self_test
CAN_test_aflut
CAN_test_bypass_mode
CAN_test_two_kit

[mehrdad201]

پاسخ : در جستجوی سمپل کار با can در کتابخانه cmsis برای LPC1768

ضمن تشکر از شما

سمپلها رو پیدا کردم و بر اساس اونها 2 تا پروژه درست کردم که یکی کارش send هست و یکی هم receive

من 2 تا هدر برد دارم. روی یکی از بردها پروژه ارسال رو پروگرام کردم و روی یکی دیگه پروژه دریافت رو

الان پروژه send درست کار میکنه و وقفه ارسال رو هم روی can1 فعال کردم و به محض transmit شدن بایت وقفه رخ میده
اما تو پروژه receive با اینکه وقفه هاش رو فعال کردم اما تو وقفه نمیاد. به نظر میرسه که اصلا از برد اول (برد ارسال) دیتایی به برد دریافت فرستاده نمیشه.

من پورت 0 - پین 0 و پورت 0 - پین 1 رو در هر دو برد به عنوان can 1 در نظر گرفتم و پورت 2 پین 7 و پورت 2 پین 8 رو هم در هر دو برد به عنوان can 2

در برد ارسال هم 2 تا سیم وصل کردم به برد دریافت. پورت 0 پین 0 رو زدم به پورت 2 پین 7 و پورت 0 پین 1 رو زدم به پورت 2 پین 8
و اتصال هم به صورت مستقیم هست. حالا میخواستم ببینم ایا اصلا نوع اتصالی که من برقرار کردم درسته ؟؟؟؟

[mahdizarkoob]

پاسخ : در جستجوی سمپل کار با can در کتابخانه cmsis برای LPC1768

من با سمپل رجیستر ارسال و دریافت با وقفه از یک برد به یه برد دیگه انجام دادم موردی نبوده و به خوبی کار می کرده.

[mehrdad201]

پاسخ : در جستجوی سمپل کار با can در کتابخانه cmsis برای LPC1768

اقای زرکوب عزیز

میشه بگید پایه ها چطور وصل میشن ؟ ایا مستقیم از پینهای برد فرستنده وصل میشن به پینهای برد گیرنده؟ یا اینکه طور دیگه ای هست ؟

[parisa.masnadi]

پاسخ : در جستجوی سمپل کار با can در کتابخانه cmsis برای LPC1768

سلام
من CAN lpc1768 v, رو فعال کردم اگه فیلتر در حالت bypass باشه اینتراپت فعال میشه و دریافت به درستی صورت می گیره ولی زمانی که acceptance filter رو فعال می کنم با اینکه اینتراپت فعال میشه ولی چیزی نمی تونم بخونم. کد به این صورت نوشتم:

void CAN_setup (uint32_t ctrl)  {

    volatile uint32_t i;

  LPC_CAN_TypeDef *pCAN = (ctrl == 1) ? LPC_CAN1 : LPC_CAN2;





  if (ctrl == 1) {[FONT=Yekan]   [/FONT]

   

  } else {

    LPC_CANAF->AFMR = 0x00000001;                        /*Acceptance Filter Mode Register = Off  */                                 

        LPC_PINCON->PINSEL0 |=  (1 <<  9);           /* Pin P0.4 used as RD2 (CAN2) */

    LPC_PINCON->PINSEL0 |=  (1 << 11);           /* Pin P0.5 used as TD2 (CAN2) */

    pCAN->MOD   = 1;                               /* Enter reset mode */

    pCAN->IER   = 0;                               /* Disable all interrupts */

    pCAN->GSR   = 0;                               /* Clear status register */

        pCAN->CMR   = CAN_CMR_RRB | CAN_CMR_AT | CAN_CMR_CDO;  /* Request command to release Rx, Tx buffer and clear data overrun */    

      i           = pCAN->ICR;                       /* Read to clear interrupt pending in interrupt capture register */        

    }





    

        /* Clear AF Ram region */

    for (i = 0; i < CANAF_RAM_ENTRY_NUM; i++) {

        LPC_CANAF_RAM->mask[i] = 0;

    }

    

    /* Reset address registers */

  LPC_CANAF->SFF_sa     = 0;

    LPC_CANAF->SFF_GRP_sa = 0;

    LPC_CANAF->EFF_sa     = 0;

    LPC_CANAF->EFF_GRP_sa = 0;

    LPC_CANAF->ENDofTable = 0;

    

    //LPC_CANAF->AFMR       = 0;

    

    CAN_cfgBaudrate(ctrl, 500000);                 /* Set bit timing */





    pCAN->IER             = 0x00000001;            /* Enable Rx interrupt */

    

    CAN_wrFilter (2, 418, STANDARD_FORMAT);

  //LPC_CANAF->AFMR = 0x00000002;                           /* CAN_AF_FULL_MODE */

  LPC_CANAF->AFMR = 0x00000004;                  /* Use acceptance filter */

  

  

    NVIC_EnableIRQ(CAN_IRQn);                    /* Enable CAN interrupt */

    

    pCAN->MOD   = 0;                               /* Enter normal mode */

     }

/**************************************************************************/

void CAN_wrFilter (uint32_t ctrl, uint32_t id, uint8_t format)  {

  static int CAN_std_cnt = 0;

  static int CAN_ext_cnt = 0;

         uint32_t buf0, buf1;

         int cnt1, cnt2, bound1;





  /* Acceptance Filter Memory full */

  if ((((CAN_std_cnt + 1) >> 1) + CAN_ext_cnt) >= 512)

    return;                                       /* error: objects full */





  /* Setup Acceptance Filter Configuration 

    Acceptance Filter Mode Register = Off  */                                 

  //LPC_CANAF->AFMR = 0x00000001;





  if (format == STANDARD_FORMAT)  {              /* Add mask for standard identifiers */

    id |= (ctrl-1) << 13;                        /* Add controller number */

        id |= 1 << 11;                               /* interrupt enable bit */

    id &= 0x0000FFFF;                            /* Mask out 16-bits of ID */





    /* Move all remaining extended mask entries one place up                 

       if new entry will increase standard ID filters list   */

    if ((CAN_std_cnt & 0x0001) == 0 && CAN_ext_cnt != 0) {

      cnt1   = (CAN_std_cnt >> 1);

      bound1 = CAN_ext_cnt;

      buf0   = LPC_CANAF_RAM->mask[cnt1];

      while (bound1--)  {

        cnt1++;

        buf1 = LPC_CANAF_RAM->mask[cnt1];

        LPC_CANAF_RAM->mask[cnt1] = buf0;

        buf0 = buf1;

      }        

    }





    if (CAN_std_cnt == 0)  {                     /* For entering first  ID */

      LPC_CANAF_RAM->mask[0] = 0x0000FFFF | (id << 16);

    }  else if (CAN_std_cnt == 1)  {             /* For entering second ID */

      if ((LPC_CANAF_RAM->mask[0] >> 16) > id)

        LPC_CANAF_RAM->mask[0] = (LPC_CANAF_RAM->mask[0] >> 16) | (id << 16);

      else

        LPC_CANAF_RAM->mask[0] = (LPC_CANAF_RAM->mask[0] & 0xFFFF0000) | id;

    }  else  {

      /* Find where to insert new ID */

      cnt1 = 0;

      cnt2 = CAN_std_cnt;

      bound1 = (CAN_std_cnt - 1) >> 1;

      while (cnt1 <= bound1)  {                  /* Loop through standard existing IDs */

        if ((LPC_CANAF_RAM->mask[cnt1] >> 16) > id)  {

          cnt2 = cnt1 * 2;

          break;

        }

        if ((LPC_CANAF_RAM->mask[cnt1] & 0x0000FFFF) > id)  {

          cnt2 = cnt1 * 2 + 1;

          break;

        }

        cnt1++;                                  /* cnt1 = U32 where to insert new ID */

      }                                          /* cnt2 = U16 where to insert new ID */





      if (cnt1 > bound1)  {                      /* Adding ID as last entry */

        if ((CAN_std_cnt & 0x0001) == 0)         /* Even number of IDs exists */

          LPC_CANAF_RAM->mask[cnt1]  = 0x0000FFFF | (id << 16);

        else                                     /* Odd  number of IDs exists */

          LPC_CANAF_RAM->mask[cnt1]  = (LPC_CANAF_RAM->mask[cnt1] & 0xFFFF0000) | id;

      }  else  {

        buf0 = LPC_CANAF_RAM->mask[cnt1];        /* Remember current entry */

        if ((cnt2 & 0x0001) == 0)                /* Insert new mask to even address */

          buf1 = (id << 16) | (buf0 >> 16);

        else                                     /* Insert new mask to odd  address */

          buf1 = (buf0 & 0xFFFF0000) | id;

     

        LPC_CANAF_RAM->mask[cnt1] = buf1;        /* Insert mask */





        bound1 = CAN_std_cnt >> 1;

        /* Move all remaining standard mask entries one place up */

        while (cnt1 < bound1)  {

          cnt1++;

          buf1  = LPC_CANAF_RAM->mask[cnt1];

          LPC_CANAF_RAM->mask[cnt1] = (buf1 >> 16) | (buf0 << 16);

          buf0  = buf1;

        }





        if ((CAN_std_cnt & 0x0001) == 0)         /* Even number of IDs exists */

          LPC_CANAF_RAM->mask[cnt1] = (LPC_CANAF_RAM->mask[cnt1] & 0xFFFF0000) | (0x0000FFFF);

      }

    }

    CAN_std_cnt++;

  }  else  {                                     /* Add mask for extended identifiers */

    id |= (ctrl-1) << 29;                        /* Add controller number */





    cnt1 = ((CAN_std_cnt + 1) >> 1);

    cnt2 = 0;

    while (cnt2 < CAN_ext_cnt)  {                /* Loop through extended existing masks */

      if (LPC_CANAF_RAM->mask[cnt1] > id)

        break;

      cnt1++;                                    /* cnt1 = U32 where to insert new mask */

      cnt2++;

    }





    buf0 = LPC_CANAF_RAM->mask[cnt1];            /* Remember current entry */

    LPC_CANAF_RAM->mask[cnt1] = id;              /* Insert mask */





    CAN_ext_cnt++;





    bound1 = CAN_ext_cnt - 1;

    /* Move all remaining extended mask entries one place up */

    while (cnt2 < bound1)  {

      cnt1++;

      cnt2++;

      buf1 = LPC_CANAF_RAM->mask[cnt1];

      LPC_CANAF_RAM->mask[cnt1] = buf0;

      buf0 = buf1;

    }        

  }

  

  /* Calculate std ID start address (buf0) and ext ID start address (buf1) */

  buf0 = ((CAN_std_cnt + 1) >> 1) << 2;

  buf1 = buf0 + (CAN_ext_cnt << 2);





  /* Setup acceptance filter pointers */

  LPC_CANAF->SFF_sa     = 0x08;

  LPC_CANAF->SFF_GRP_sa = 0x08;

  LPC_CANAF->EFF_sa     = 0x08;

  LPC_CANAF->EFF_GRP_sa = 0x08;

  LPC_CANAF->ENDofTable = 0x7D0;

    

    LPC_CANAF->FCANIE |= 1;





  //LPC_CANAF->AFMR = 0x00000000;                  /* Use acceptance filter */

}

/****************************************************************************/

void CAN_IRQHandler (void)  {

  volatile uint32_t icr;

    uint16_t i = 0;









  /* check CAN controller 2 */

  icr = LPC_CAN2->ICR;                           /* clear interrupts */





  if (icr & (1 << 0)) {                          /* CAN Controller #2 meassage is received */

    CAN_rdMsg (2, &CAN_RxMsg[1]);                /*  read the message */

   // LPC_CAN2->CMR = (1 << 2);                    /* Release receive buffer */





    CAN_RxRdy[1] = 1;                            /*  set receive flag */

  }

    

        for (i = 0; i < Full_CAN_Entry_Num; i++)

    {

        if (Chip_CAN_GetFullCANIntStatus(i)) {

            uint8_t SCC;

            Chip_CAN_FullCANReceive(i, &CAN_RxMsg[1], &SCC);

    }





}

    }

/******************************************************************************/

uint32_t Chip_CAN_GetFullCANIntStatus(uint8_t ObjID)

{

    if (ObjID < 64) {

        return (LPC_CANAF->FCANIC1 & (1 << (ObjID % 32))) ? SET : RESET;

    }

    return RESET;

}

/****************************************************************************/

/* Read FullCAN message received */

Status Chip_CAN_FullCANReceive(uint8_t ObjID, CAN_msg *pMsg, uint8_t *pSCC) {

    uint32_t    *pSrc;

//    uint16_t    FullCANEntryCnt;

    pSrc = (uint32_t *) LPC_CANAF_RAM;





    pSrc += Full_CAN_Entry_Num + ObjID * 3;

    /* If the AF hasn't finished updating msg info */

    if (((pSrc[0] >> CANAF_FULLCAN_MSG_SEM_POS) & CANAF_FULLCAN_MSG_SEM_BITMASK) !=

        CANAF_FULCAN_MSG_AF_FINISHED) {

        return ERROR;

    }





    /* Mark that CPU is handling message */

    pSrc[0] = CANAF_FULCAN_MSG_CPU_READING << CANAF_FULLCAN_MSG_SEM_POS;

    /* Read Message */

    *pSCC = (pSrc[0] >> CANAF_FULLCAN_MSG_SCC_POS) & CANAF_FULLCAN_MSG_SCC_BITMASK;

    pMsg->id = (pSrc[0] >> CANAF_FULLCAN_MSG_ID11_POS) & CANAF_FULLCAN_MSG_ID11_BITMASK;

    pMsg->type = 0;

    if (pSrc[0] & (1 << CANAF_FULLCAN_MSG_RTR_POS)) {

        pMsg->type = 1;  //remote data

    }

    pMsg->len = (pSrc[0] >> CANAF_FULLCAN_MSG_DLC_POS) & CANAF_FULLCAN_MSG_DLC_BITMASK;

    ((uint32_t *) pMsg->data)[0] = pSrc[1];

    ((uint32_t *) pMsg->data)[1] = pSrc[2];

    

    /* Recheck message status to make sure data is not be updated while CPU is reading */

    if (((pSrc[0] >> CANAF_FULLCAN_MSG_SEM_POS) & CANAF_FULLCAN_MSG_SEM_BITMASK) !=

        CANAF_FULCAN_MSG_CPU_READING) {

        return ERROR;

    }





    return SUCCESS;

}

اینتراپت فعال میشه ولی FCANIC1 صفره :( میشه لطفا راهنمایی کنین؟