Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-mini-2024-07-18· OpenAIAi2 WildChat-4.8M (AI2)

у меня есть микроконтроллер Iskra JS STM32F405RGT6 и CAN-BUS Shield V2.0, так как Iskra…

  1. User

    у меня есть микроконтроллер Iskra JS STM32F405RGT6 и CAN-BUS Shield V2.0, так как Iskra имеет совместимые порты с Ардуино, мне не составило труда их соединить. Этот Шилд должен взаимодейтсвовать с МК по SPI интерфейсу, я написал код, который обращается через SPI, чтобы прочитать данные из буфера, которые пришли через CAN и вывожу их на экран, но это не работает по причине того, что в буфере ничего нет, на Шилде стоит микросхема MCP2515. Как мне решить проблему?

  2. Assistant

    Для решения проблемы с отсутствием данных в буфере MCP2515 в вашей системе CAN-BUS, попробуйте следующие шаги:

    1. Проверьте соединения: Убедитесь, что все соединения между микроконтроллером STM32F405RGT6 и CAN-BUS Shield установлены правильно. Проверьте правильность подключения линий SPI (MOSI, MISO, SCK, CS) и линий CAN (CAN_H, CAN_L).

    2. Инициализация MCP2515: Убедитесь, что вы правильно инициализируете MCP2515 в своем коде. Проверьте, что вы настраиваете параметры, такие как скорость передачи данных, режим работы (например, нормальный режим или режим прослушивания) и другие настройки.

      Пример инициализации может выглядеть так:

      MCP2515 mcp2515(spi); // создайте объект MCP2515
      
      if (mcp2515.begin(MCP_STDEXT, CAN_125KBPS, MCP2515_16MHZ) == MCP2515::ERROR) {
          // Обработка ошибки инициализации
      }
      
    3. Убедитесь в наличии сообщений: Проверьте, что на линиях CAN действительно есть сообщения, которые можно прочитать. Для этого вы можете использовать другой CAN-анализатор или осциллограф, чтобы убедиться, что данные передаются корректно.

    4. Настройка фильтров: Убедитесь, что фильтры и маски CAN настроены правильно, чтобы к MCP2515 приходили сообщения. Если фильтры были неправильно установлены, сообщения могут игнорироваться.

    5. Чтение сообщений: После инициализации и настройки фильтров убедитесь, что ваш код, отвечающий за чтение сообщений из буфера, написан корректно и выполняется успешно. Выделите участок кода, который отвечает за чтение сообщения, и убедитесь в его правильности.

      Пример чтения сообщения:

      MCP2515::RxMessage msg;
      if (mcp2515.readMessage(&msg) == MCP2515::ERROR) {
          // Обработка ошибки чтения
      } else {
          // Обработка прочитанного сообщения
      }
      
    6. Проверьте настройки таймеров: Убедитесь, что настройки таймеров вашего микроконтроллера не конфликтуют и работают корректно. Это может быть важно, если вы используете прерывания или другие асинхронные методы.

    7. Проверка конфликтов с использованием других библиотек: Убедитесь, что в вашем проекте нет конфликтов с другими библиотеками, которые могут использовать SPI или другие ресурсы.

    Если вы попробовали все вышеперечисленное и проблема не решается, возможно, стоит обратиться к документации MCP2515, а также проверить форумы и сообщества разработчиков для получения дополнительной информации.

  3. User

    /* (c) 2016 Microchip Technology Inc. and its subsidiaries. You may use this software and any derivatives exclusively with Microchip products.

    THIS SOFTWARE IS SUPPLIED BY MICROCHIP "AS IS". NO WARRANTIES, WHETHER
    EXPRESS, IMPLIED OR STATUTORY, APPLY TO THIS SOFTWARE, INCLUDING ANY IMPLIED
    WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY, AND FITNESS FOR A
    PARTICULAR PURPOSE, OR ITS INTERACTION WITH MICROCHIP PRODUCTS, COMBINATION
    WITH ANY OTHER PRODUCTS, OR USE IN ANY APPLICATION.
    
    IN NO EVENT WILL MICROCHIP BE LIABLE FOR ANY INDIRECT, SPECIAL, PUNITIVE,
    INCIDENTAL OR CONSEQUENTIAL LOSS, DAMAGE, COST OR EXPENSE OF ANY KIND
    WHATSOEVER RELATED TO THE SOFTWARE, HOWEVER CAUSED, EVEN IF MICROCHIP HAS
    BEEN ADVISED OF THE POSSIBILITY OR THE DAMAGES ARE FORESEEABLE. TO THE
    FULLEST EXTENT ALLOWED BY LAW, MICROCHIP'S TOTAL LIABILITY ON ALL CLAIMS IN
    ANY WAY RELATED TO THIS SOFTWARE WILL NOT EXCEED THE AMOUNT OF FEES, IF ANY,
    THAT YOU HAVE PAID DIRECTLY TO MICROCHIP FOR THIS SOFTWARE.
    
    MICROCHIP PROVIDES THIS SOFTWARE CONDITIONALLY UPON YOUR ACCEPTANCE OF THESE
    TERMS.
    

    */

    #include "CANSPI.h" #include "mcp2515.h"

    /** Local Function Prototypes */ static uint32_t convertReg2ExtendedCANid(uint8_t tempRXBn_EIDH, uint8_t tempRXBn_EIDL, uint8_t tempRXBn_SIDH, uint8_t tempRXBn_SIDL); static uint32_t convertReg2StandardCANid(uint8_t tempRXBn_SIDH, uint8_t tempRXBn_SIDL) ; static void convertCANid2Reg(uint32_t tempPassedInID, uint8_t canIdType, id_reg_t *passedIdReg);

    /** Local Variables */ ctrl_status_t ctrlStatus; ctrl_error_status_t errorStatus; id_reg_t idReg;

    /** CAN SPI APIs */

    /* Entering Sleep Mode / void CANSPI_Sleep(void) { / Clear CAN bus wakeup interrupt */ MCP2515_BitModify(MCP2515_CANINTF, 0x40, 0x00);

    /* Enable CAN bus activity wakeup */ MCP2515_BitModify(MCP2515_CANINTE, 0x40, 0x40);

    MCP2515_SetSleepMode(); }

    /* Initialize CAN */ bool CANSPI_Initialize(void) { RXF0 RXF0reg; RXF1 RXF1reg; RXF2 RXF2reg; RXF3 RXF3reg; RXF4 RXF4reg; RXF5 RXF5reg; RXM0 RXM0reg; RXM1 RXM1reg;

    /* Intialize Rx Mask values */ RXM0reg.RXM0SIDH = 0x00; RXM0reg.RXM0SIDL = 0x00; RXM0reg.RXM0EID8 = 0x00; RXM0reg.RXM0EID0 = 0x00;

    RXM1reg.RXM1SIDH = 0x00; RXM1reg.RXM1SIDL = 0x00; RXM1reg.RXM1EID8 = 0x00; RXM1reg.RXM1EID0 = 0x00;

    /* Intialize Rx Filter values */ RXF0reg.RXF0SIDH = 0x00; RXF0reg.RXF0SIDL = 0x00; //Starndard Filter RXF0reg.RXF0EID8 = 0x00; RXF0reg.RXF0EID0 = 0x00;

    RXF1reg.RXF1SIDH = 0x00; RXF1reg.RXF1SIDL = 0x08; //Exntended Filter RXF1reg.RXF1EID8 = 0x00; RXF1reg.RXF1EID0 = 0x00;

    RXF2reg.RXF2SIDH = 0x00; RXF2reg.RXF2SIDL = 0x00; RXF2reg.RXF2EID8 = 0x00; RXF2reg.RXF2EID0 = 0x00;

    RXF3reg.RXF3SIDH = 0x00; RXF3reg.RXF3SIDL = 0x00; RXF3reg.RXF3EID8 = 0x00; RXF3reg.RXF3EID0 = 0x00;

    RXF4reg.RXF4SIDH = 0x00; RXF4reg.RXF4SIDL = 0x00; RXF4reg.RXF4EID8 = 0x00; RXF4reg.RXF4EID0 = 0x00;

    RXF5reg.RXF5SIDH = 0x00; RXF5reg.RXF5SIDL = 0x08; RXF5reg.RXF5EID8 = 0x00; RXF5reg.RXF5EID0 = 0x00;

    /* Intialize MCP2515, check SPI */ if(!MCP2515_Initialize()) { return false; }

    /* Change mode as configuration mode */ if(!MCP2515_SetConfigMode()) { return false; }

    /* Configure filter & mask */ MCP2515_WriteByteSequence(MCP2515_RXM0SIDH, MCP2515_RXM0EID0, &(RXM0reg.RXM0SIDH)); MCP2515_WriteByteSequence(MCP2515_RXM1SIDH, MCP2515_RXM1EID0, &(RXM1reg.RXM1SIDH)); MCP2515_WriteByteSequence(MCP2515_RXF0SIDH, MCP2515_RXF0EID0, &(RXF0reg.RXF0SIDH)); MCP2515_WriteByteSequence(MCP2515_RXF1SIDH, MCP2515_RXF1EID0, &(RXF1reg.RXF1SIDH)); MCP2515_WriteByteSequence(MCP2515_RXF2SIDH, MCP2515_RXF2EID0, &(RXF2reg.RXF2SIDH)); MCP2515_WriteByteSequence(MCP2515_RXF3SIDH, MCP2515_RXF3EID0, &(RXF3reg.RXF3SIDH)); MCP2515_WriteByteSequence(MCP2515_RXF4SIDH, MCP2515_RXF4EID0, &(RXF4reg.RXF4SIDH)); MCP2515_WriteByteSequence(MCP2515_RXF5SIDH, MCP2515_RXF5EID0, &(RXF5reg.RXF5SIDH));

    /* Accept All (Standard + Extended) */ MCP2515_WriteByte(MCP2515_RXB0CTRL, 0x04); //Enable BUKT, Accept Filter 0 MCP2515_WriteByte(MCP2515_RXB1CTRL, 0x01); //Accept Filter 1

    /*

    • tq = 2 * (brp(0) + 1) / 16000000 = 0.125us
    • tbit = (SYNC_SEG(1 fixed) + PROP_SEG + PS1 + PS2)
    • tbit = 1tq + 5tq + 6tq + 4tq = 16tq
    • 16tq = 2us = 500kbps */

    /* 00(SJW 1tq) 000000 */ MCP2515_WriteByte(MCP2515_CNF1, 0x00);

    /* 1 1 100(5tq) 101(6tq) */ MCP2515_WriteByte(MCP2515_CNF2, 0xE5);

    /* 1 0 000 011(4tq) */ MCP2515_WriteByte(MCP2515_CNF3, 0x83);

    /* Normal */ if(!MCP2515_SetNormalMode()) return false;

    return true; }

    /* Transmit CAN message */ uint8_t CANSPI_Transmit(uCAN_MSG *tempCanMsg) { uint8_t returnValue = 0;

    idReg.tempSIDH = 0; idReg.tempSIDL = 0; idReg.tempEID8 = 0; idReg.tempEID0 = 0;

    ctrlStatus.ctrl_status = MCP2515_ReadStatus();

    /* Finding empty buffer / if (ctrlStatus.TXB0REQ != 1) { / convert CAN ID for register */ convertCANid2Reg(tempCanMsg->frame.id, tempCanMsg->frame.idType, &idReg);

    /* Load data to Tx Buffer */
    MCP2515_LoadTxSequence(MCP2515_LOAD_TXB0SIDH, &(idReg.tempSIDH), tempCanMsg->frame.dlc, &(tempCanMsg->frame.data0));
    
    /* Request to transmit */
    MCP2515_RequestToSend(MCP2515_RTS_TX0);
    
    returnValue = 1;
    

    } else if (ctrlStatus.TXB1REQ != 1) { convertCANid2Reg(tempCanMsg->frame.id, tempCanMsg->frame.idType, &idReg);

    MCP2515_LoadTxSequence(MCP2515_LOAD_TXB1SIDH, &(idReg.tempSIDH), tempCanMsg->frame.dlc, &(tempCanMsg->frame.data0));
    MCP2515_RequestToSend(MCP2515_RTS_TX1);
    
    returnValue = 1;
    

    } else if (ctrlStatus.TXB2REQ != 1) { convertCANid2Reg(tempCanMsg->frame.id, tempCanMsg->frame.idType, &idReg);

    MCP2515_LoadTxSequence(MCP2515_LOAD_TXB2SIDH, &(idReg.tempSIDH), tempCanMsg->frame.dlc, &(tempCanMsg->frame.data0));
    MCP2515_RequestToSend(MCP2515_RTS_TX2);
    
    returnValue = 1;
    

    }

    return (returnValue); }

    /* Receive CAN message */ uint8_t CANSPI_Receive(uCAN_MSG *tempCanMsg) { uint8_t returnValue = 0; rx_reg_t rxReg; ctrl_rx_status_t rxStatus;

    rxStatus.ctrl_rx_status = MCP2515_GetRxStatus();

    /* Check receive buffer / if (rxStatus.rxBuffer != 0) { / Ищем буфер, в котором сообщение */ if ((rxStatus.rxBuffer == MSG_IN_RXB0)|(rxStatus.rxBuffer == MSG_IN_BOTH_BUFFERS)) { MCP2515_ReadRxSequence(MCP2515_READ_RXB0SIDH, rxReg.rx_reg_array, sizeof(rxReg.rx_reg_array)); } else if (rxStatus.rxBuffer == MSG_IN_RXB1) { MCP2515_ReadRxSequence(MCP2515_READ_RXB1SIDH, rxReg.rx_reg_array, sizeof(rxReg.rx_reg_array)); }

    /* Если сообщение CAN расширенного типа */
    if (rxStatus.msgType == dEXTENDED_CAN_MSG_ID_2_0B)
    {
      tempCanMsg->frame.idType = (uint8_t) dEXTENDED_CAN_MSG_ID_2_0B;
      tempCanMsg->frame.id = convertReg2ExtendedCANid(rxReg.RXBnEID8, rxReg.RXBnEID0, rxReg.RXBnSIDH, rxReg.RXBnSIDL);
    }
    else
    {
      /* Стандартного типа */
      tempCanMsg->frame.idType = (uint8_t) dSTANDARD_CAN_MSG_ID_2_0B;
      tempCanMsg->frame.id = convertReg2StandardCANid(rxReg.RXBnSIDH, rxReg.RXBnSIDL);
    }
    
    tempCanMsg->frame.dlc   = rxReg.RXBnDLC;
    tempCanMsg->frame.data0 = rxReg.RXBnD0;
    tempCanMsg->frame.data1 = rxReg.RXBnD1;
    tempCanMsg->frame.data2 = rxReg.RXBnD2;
    tempCanMsg->frame.data3 = rxReg.RXBnD3;
    tempCanMsg->frame.data4 = rxReg.RXBnD4;
    tempCanMsg->frame.data5 = rxReg.RXBnD5;
    tempCanMsg->frame.data6 = rxReg.RXBnD6;
    tempCanMsg->frame.data7 = rxReg.RXBnD7;
    
    returnValue = 1;
    

    }

    return (returnValue); }

    /* check message buffer and return count */ uint8_t CANSPI_messagesInBuffer(void) { uint8_t messageCount = 0;

    ctrlStatus.ctrl_status = MCP2515_ReadStatus();

    if(ctrlStatus.RX0IF != 0) { messageCount++; }

    if(ctrlStatus.RX1IF != 0) { messageCount++; }

    return (messageCount); }

    /* check BUS off */ uint8_t CANSPI_isBussOff(void) { uint8_t returnValue = 0;

    errorStatus.error_flag_reg = MCP2515_ReadByte(MCP2515_EFLG);

    if(errorStatus.TXBO == 1) { returnValue = 1; }

    return (returnValue); }

    /* check Rx Passive Error */ uint8_t CANSPI_isRxErrorPassive(void) { uint8_t returnValue = 0;

    errorStatus.error_flag_reg = MCP2515_ReadByte(MCP2515_EFLG);

    if(errorStatus.RXEP == 1) { returnValue = 1; }

    return (returnValue); }

    /* check Tx Passive Error */ uint8_t CANSPI_isTxErrorPassive(void) { uint8_t returnValue = 0;

    errorStatus.error_flag_reg = MCP2515_ReadByte(MCP2515_EFLG);

    if(errorStatus.TXEP == 1) { returnValue = 1; }

    return (returnValue); }

    /* convert register value to extended CAN ID */ static uint32_t convertReg2ExtendedCANid(uint8_t tempRXBn_EIDH, uint8_t tempRXBn_EIDL, uint8_t tempRXBn_SIDH, uint8_t tempRXBn_SIDL) { uint32_t returnValue = 0; uint32_t ConvertedID = 0; uint8_t CAN_standardLo_ID_lo2bits; uint8_t CAN_standardLo_ID_hi3bits;

    CAN_standardLo_ID_lo2bits = (tempRXBn_SIDL & 0x03); CAN_standardLo_ID_hi3bits = (tempRXBn_SIDL >> 5); ConvertedID = (tempRXBn_SIDH << 3); ConvertedID = ConvertedID + CAN_standardLo_ID_hi3bits; ConvertedID = (ConvertedID << 2); ConvertedID = ConvertedID + CAN_standardLo_ID_lo2bits; ConvertedID = (ConvertedID << 8); ConvertedID = ConvertedID + tempRXBn_EIDH; ConvertedID = (ConvertedID << 8); ConvertedID = ConvertedID + tempRXBn_EIDL; returnValue = ConvertedID; return (returnValue); }

    /* convert register value to standard CAN ID */ static uint32_t convertReg2StandardCANid(uint8_t tempRXBn_SIDH, uint8_t tempRXBn_SIDL) { uint32_t returnValue = 0; uint32_t ConvertedID;

    ConvertedID = (tempRXBn_SIDH << 3); ConvertedID = ConvertedID + (tempRXBn_SIDL >> 5); returnValue = ConvertedID;

    return (returnValue); }

    /* convert CAN ID to register value */ static void convertCANid2Reg(uint32_t tempPassedInID, uint8_t canIdType, id_reg_t *passedIdReg) { uint8_t wipSIDL = 0;

    if (canIdType == dEXTENDED_CAN_MSG_ID_2_0B) { //EID0 passedIdReg->tempEID0 = 0xFF & tempPassedInID; tempPassedInID = tempPassedInID >> 8;

    //EID8
    passedIdReg->tempEID8 = 0xFF & tempPassedInID;
    tempPassedInID = tempPassedInID >> 8;
    
    //SIDL
    wipSIDL = 0x03 & tempPassedInID;
    tempPassedInID = tempPassedInID << 3;
    wipSIDL = (0xE0 & tempPassedInID) + wipSIDL;
    wipSIDL = wipSIDL + 0x08;
    passedIdReg->tempSIDL = 0xEB & wipSIDL;
    
    //SIDH
    tempPassedInID = tempPassedInID >> 8;
    passedIdReg->tempSIDH = 0xFF & tempPassedInID;
    

    } else { passedIdReg->tempEID8 = 0; passedIdReg->tempEID0 = 0; tempPassedInID = tempPassedInID << 5; passedIdReg->tempSIDL = 0xFF & tempPassedInID; tempPassedInID = tempPassedInID >> 8; passedIdReg->tempSIDH = 0xFF & tempPassedInID; } }

  4. Assistant

    Ваш код выглядит как реализация интерфейса для работы с контроллером CAN MCP2515 через SPI. Применение кода зависит от того, как вы используете эту библиотеку. Я покажу вам несколько советов и рекомендаций, которые могут помочь вам устранить проблему с отсутствующими сообщениями CAN в буфере.

    1. Проверка инициализации

    Убедитесь, что функция CANSPI_Initialize() вызывается правильно в вашем основном цикле:

    if (!CANSPI_Initialize()) {
        // Не удалось инициализировать.
        while (1);
    }
    

    2. Отправка и прием сообщений

    Убедитесь, что вы правильно отправляете сообщения на шину CAN и затем пытаетесь их получить:

    • После инициализации проверяйте, что сообщения отправляются с помощью CANSPI_Transmit().
    • Затем, в цикле, используйте CANSPI_Receive().

    Пример кода для передачи и приема:

    uCAN_MSG message;
    
    // Заполните сообщение
    message.frame.id = 0x123; // Пример ID
    message.frame.idType = dSTANDARD_CAN_MSG_ID_2_0B; // Тип ID
    message.frame.dlc = 1; // Размер данных
    message.frame.data0 = 0xFF; // Данные
    
    // Отправка сообщения
    if (CANSPI_Transmit(&message)) {
        // Сообщение отправлено
    }
    
    // Проверка на получение сообщений
    while (1) {
        if (CANSPI_messagesInBuffer() > 0) {
            uCAN_MSG receivedMessage;
            if (CANSPI_Receive(&receivedMessage)) {
                // Обработка полученного сообщения
            }
        }
        // Небольшая пауза для предотвращения слишком частых проверок
        delay(10);
    }
    

    3. Проверка фильтров и масок

    Проверьте, что ваши фильтры правильно настроены. Вызов функции CANSPI_Initialize() должен устанавливать корректные фильтры:

    /* Accept All (Standard + Extended) */
    MCP2515_WriteByte(MCP2515_RXB0CTRL, 0x04);    // Enable BUKT, Accept Filter 0
    MCP2515_WriteByte(MCP2515_RXB1CTRL, 0x01);    // Accept Filter 1
    

    Вы можете временно откатить фильтры назад к значению по умолчанию или установить их в 0, чтобы убедиться, что проблема с фильтрацией.

    4. Проверка скорости передачи и подключений

    Убедитесь, что скорость передачи данных на вашем CAN-бусе совпадает с настроенной в MCP2515. Например, если вы используете скорость 500 kbps, убедитесь, что все устройства, подключенные к шине CAN, работают на той же скорости.

    Также проверьте соединения:

    • Убедитесь, что линии CAN (CAN_H и CAN_L) подключены корректно.
    • Замените резисторы на концах шины CAN при необходимости (обычно 120 Ом).

    5. Использование отладчиков

    Если проблемы продолжаются, используйте отладчик или логгер (например, Serial Monitor), чтобы вывести значения переменных на разных этапах и убедиться, что каждая функция выполняется как надо.

    6. Проверка состояния MCP2515 и сообщений

    Проверьте состояние MCP2515, чтобы убедиться, что он не находится в режиме ошибки:

    if (CANSPI_isBussOff()) {
        // Обработка ситуации "BUS Off"
    }
    

    Заключение

    Следуйте этим шагам, и, если проблема с отсутствующими данными не устранится, вы можете дополнительно исследовать компоненты схемы (проводку, использование других устройств на шине CAN, и т.д.) или проверить документацию MCP2515 на наличие специфических требований.

  5. User

    Какие значения фильтров установить чтобы принимало все пакеты

  6. Assistant

    Чтобы настроить MCP2515 для приема всех CAN-сообщений (как стандартных, так и расширенных идентификаторов), необходимо правильно настроить фильтры и маски. Для этого вы можете установить фильтры и маски, которые позволяют принимать любые сообщения.

    Вот как это можно сделать:

    1. Установите маски: Маски управляют тем, как фильтры применяются к CAN-сообщениям. Чтобы избежать фильтрации, маска должна принимать все значения. Это делается путем установки маски в 0x00 (для всех битов).

    2. Установите фильтры: Фильтры также можно настроить для принятия всех пакетов. Обычно это достигается путем установки фильтров в 0x00 или, при использовании расширенных идентификаторов, также установив соответствующие старшие биты.

    Вот пример кода на C, который устанавливает такие фильтры:

    // Установить маски
    MCP2515_WriteByte(MCP2515_RXM0SIDH, 0x00); // RXM0 - маска 0
    MCP2515_WriteByte(MCP2515_RXM0SIDL, 0x00);
    MCP2515_WriteByte(MCP2515_RXM1SIDH, 0x00); // RXM1 - маска 1
    MCP2515_WriteByte(MCP2515_RXM1SIDL, 0x00);
    
    // Установить фильтры
    MCP2515_WriteByte(MCP2515_RXF0SIDH, 0x00); // RXF0 - фильтр 0
    MCP2515_WriteByte(MCP2515_RXF0SIDL, 0x00);
    MCP2515_WriteByte(MCP2515_RXF1SIDH, 0x00); // RXF1 - фильтр 1
    MCP2515_WriteByte(MCP2515_RXF1SIDL, 0x00);
    MCP2515_WriteByte(MCP2515_RXF2SIDH, 0x00); // RXF2 - фильтр 2
    MCP2515_WriteByte(MCP2515_RXF2SIDL, 0x00);
    MCP2515_WriteByte(MCP2515_RXF3SIDH, 0x00); // RXF3 - фильтр 3
    MCP2515_WriteByte(MCP2515_RXF3SIDL, 0x00);
    MCP2515_WriteByte(MCP2515_RXF4SIDH, 0x00); // RXF4 - фильтр 4
    MCP2515_WriteByte(MCP2515_RXF4SIDL, 0x00);
    MCP2515_WriteByte(MCP2515_RXF5SIDH, 0x00); // RXF5 - фильтр 5
    MCP2515_WriteByte(MCP2515_RXF5SIDL, 0x00);
    
    // Установить RXB0 и RXB1 для принятия сообщений
    MCP2515_WriteByte(MCP2515_RXB0CTRL, 0x04); // RXB0, включить BUKT, фильтр 0
    MCP2515_WriteByte(MCP2515_RXB1CTRL, 0x01); // RXB1, фильтр 1
    

    Примечания:

    • Фильтры и маски: Маска определяет, какие биты идентификатора должны проверяться при фильтрации; если все биты маски установлены в 0, это значит, что будут проверяться все биты идентификатора. Фильтр, установленный в 0x00, будет принимать все идентификаторы.
    • После настройки фильтров и масок убедитесь, что MCP2515 находится в нормальном режиме работы.

    Установив такие значения, вы сможете принимать все CAN-сообщения на шине без каких-либо ограничений по идентификатору.

  7. User

    я не понимаю что мне нужно изменить в коде

  8. Assistant

    Понял вас. Давайте я предоставлю вам конкретные шаги с изменениями в коде, чтобы настроить фильтры и маски на MCP2515 для приема всех CAN-сообщений.

    Изменения в коде

    1. Нужно изменить раздел кода, который настраивает фильтры и маски в функции CANSPI_Initialize(). Вам нужно установить значения фильтров и масок так, чтобы они принимали все сообщения.

    Вот как может выглядеть обновленный код для настройки фильтров и масок:

    bool CANSPI_Initialize(void)
    {
        RXF0 RXF0reg;
        RXF1 RXF1reg;
        RXF2 RXF2reg;
        RXF3 RXF3reg;
        RXF4 RXF4reg;
        RXF5 RXF5reg;
        RXM0 RXM0reg;
        RXM1 RXM1reg;
    
        // Инициализация масок для приема всех сообщений
        RXM0reg.RXM0SIDH = 0x00; // Маска 0
        RXM0reg.RXM0SIDL = 0x00;
        RXM0reg.RXM0EID8 = 0x00;
        RXM0reg.RXM0EID0 = 0x00;
    
        RXM1reg.RXM1SIDH = 0x00; // Маска 1
        RXM1reg.RXM1SIDL = 0x00;
        RXM1reg.RXM1EID8 = 0x00;
        RXM1reg.RXM1EID0 = 0x00;
    
        // Инициализация фильтров для приема всех сообщений
        RXF0reg.RXF0SIDH = 0x00; // Фильтр 0
        RXF0reg.RXF0SIDL = 0x00;
        RXF0reg.RXF0EID8 = 0x00;
        RXF0reg.RXF0EID0 = 0x00;
    
        RXF1reg.RXF1SIDH = 0x00; // Фильтр 1
        RXF1reg.RXF1SIDL = 0x00;
        RXF1reg.RXF1EID8 = 0x00;
        RXF1reg.RXF1EID0 = 0x00;
    
        RXF2reg.RXF2SIDH = 0x00; // Фильтр 2
        RXF2reg.RXF2SIDL = 0x00;
        RXF2reg.RXF2EID8 = 0x00;
        RXF2reg.RXF2EID0 = 0x00;
    
        RXF3reg.RXF3SIDH = 0x00; // Фильтр 3
        RXF3reg.RXF3SIDL = 0x00;
        RXF3reg.RXF3EID8 = 0x00;
        RXF3reg.RXF3EID0 = 0x00;
    
        RXF4reg.RXF4SIDH = 0x00; // Фильтр 4
        RXF4reg.RXF4SIDL = 0x00;
        RXF4reg.RXF4EID8 = 0x00;
        RXF4reg.RXF4EID0 = 0x00;
    
        RXF5reg.RXF5SIDH = 0x00; // Фильтр 5
        RXF5reg.RXF5SIDL = 0x00;
        RXF5reg.RXF5EID8 = 0x00;
        RXF5reg.RXF5EID0 = 0x00;
    
        // Инициализация MCP2515, проверка SPI
        if(!MCP2515_Initialize())
        {
            return false;
        }
    
        // Переключение в конфигурационный режим
        if(!MCP2515_SetConfigMode())
        {
            return false;
        }
    
        // Конфигурация фильтров и масок
        MCP2515_WriteByteSequence(MCP2515_RXM0SIDH, MCP2515_RXM0EID0, &(RXM0reg.RXM0SIDH));
        MCP2515_WriteByteSequence(MCP2515_RXM1SIDH, MCP2515_RXM1EID0, &(RXM1reg.RXM1SIDH));
        MCP2515_WriteByteSequence(MCP2515_RXF0SIDH, MCP2515_RXF0EID0, &(RXF0reg.RXF0SIDH));
        MCP2515_WriteByteSequence(MCP2515_RXF1SIDH, MCP2515_RXF1EID0, &(RXF1reg.RXF1SIDH));
        MCP2515_WriteByteSequence(MCP2515_RXF2SIDH, MCP2515_RXF2EID0, &(RXF2reg.RXF2SIDH));
        MCP2515_WriteByteSequence(MCP2515_RXF3SIDH, MCP2515_RXF3EID0, &(RXF3reg.RXF3SIDH));
        MCP2515_WriteByteSequence(MCP2515_RXF4SIDH, MCP2515_RXF4EID0, &(RXF4reg.RXF4SIDH));
        MCP2515_WriteByteSequence(MCP2515_RXF5SIDH, MCP2515_RXF5EID0, &(RXF5reg.RXF5SIDH));
    
        // Установить RXB0 и RXB1 для принятия сообщений
        MCP2515_WriteByte(MCP2515_RXB0CTRL, 0x04); // Включить BUKT, использовать фильтр 0
        MCP2515_WriteByte(MCP2515_RXB1CTRL, 0x01); // Использовать фильтр 1
    
        // Установить параметры конфигурации CAN
        MCP2515_WriteByte(MCP2515_CNF1, 0x00); // SJW
        MCP2515_WriteByte(MCP2515_CNF2, 0xE5); // BRP and Propagation Segment
        MCP2515_WriteByte(MCP2515_CNF3, 0x83); // Phase Segment 1 and Phase Segment 2
    
        // Переключение в нормальный режим
        if(!MCP2515_SetNormalMode())
        {
            return false;
        }
    
        return true;
    }
    

    Объяснение внесенных изменений

    1. Маски и фильтры: Мы инициализировали маски RXM0 и RXM1, а также все фильтры RXF0 до RXF5 в 0x00. Это позволяет принимать сообщения любых идентификаторов (как стандартных, так и расширенных).

    2. RXB0 и RXB1: Убедитесь, что настройка принимает сообщения с использованием MCP2515_WriteByte(MCP2515_RXB0CTRL, 0x04) и MCP2515_WriteByte(MCP2515_RXB1CTRL, 0x01).

    Теперь с этими изменениями, MCP2515 должен принимать все CAN-сообщения. Убедитесь, что после внесения изменений вы перезагрузили ваше устройство и протестировали его.