On-board CANbus werkt niet via STM32F107VCT6 MCU op EasyMX Pro-v7

Hallo allemaal,

Ik probeer de on-board CANBUS te activeren met behulp van de meegeleverde code (zie code hieronder). Wij krijgen hem op geen enkele manier aan de praat.
Dit board is aangesloten op een tweede ontwikkelboard. Dit is de EasyPIC-v7. Hierop draait ook de meegeleverde code (voor PIC uiteraard) maar dan voor Node2.
Ik heb tevens een CANBUS analizer eraan gekoppeld. Er zou dus communicatie moeten zijn maar dat is er dus niet.

Heeft iemand een idee waarom er geen communicatie is?

Hieronder staat de code waarop de STM32F107VCT6 draait.

c code:

/* Project name:
     CAN_1st (CAN Network demonstration with mikroE's CAN-1 module)
 * Copyright:
     (c) MikroElektronika, 2011.
 * Revision History:
     20110511(TL):
       - initial release;
 * Description:
      This code demonstrates how to use CAN library functions and procedures.
      It is used together with the CAN_2nd example (on second MCU), and it can
      be used to test the connection of MCU to the CAN network.
      This node initiates the communication with the 2nd node by sending some
      data to its address. The 2nd node responds by sending back the data incre-
      mented by 1. This (1st) node then does the same and sends incremented data
      back to 2nd node, etc.
      With minor adjustments, it should work with any other MCU that has a CAN module.
 * Test configuration:
     MCU:             STM32F107VC
                      http://www.st.com/internet/com/technical_resources/technical_literature/datasheet/cd00220364.pdf
     Dev.Board:       EasyMx PRO v7 for STM32(R) ARM(R)
                      http://www.mikroe.com/eng/products/view/852/easymx-pro-v7-for-stm32/
     Oscillator:      HSE-PLL, 72.000MHz
     Ext. Modules:    None.
     SW:              mikroC PRO for ARM
                      http://www.mikroe.com/eng/products/view/752/mikroc-pro-for-arm/
 * NOTES:
     - Turn on PORTE LEDs at SW10 and turn on CAN RX and TX switches at SW12. 
     */

unsigned long Can_Init_Flags;
unsigned char Can_Send_Flags, Can_Rcv_Flags; // can flags
unsigned char Rx_Data_Len;                                   // received data length in bytes
char RxTx_Data[8];                                           // can rx/tx data buffer
char Msg_Rcvd;                                               // reception flag
const long ID_1st = 12111, ID_2nd = 3;                       // node IDs
long Rx_ID;

void main() {

  GPIO_Digital_Output(&GPIOE_BASE, 0xFF00);
  GPIOE_ODR  = 0;


  Can_Init_Flags = 0;                                       //
  Can_Send_Flags = 0;                                       // clear flags
  Can_Rcv_Flags  = 0;                                       //

  Can_Send_Flags = _CAN_TX_XTD_FRAME &                      //     with CANWrite
                   _CAN_TX_NO_RTR_FRAME;

  Can_Init_Flags = _CAN_CONFIG_AUTOMATIC_RETRANSMISSION &              // form value to be used
                   _CAN_CONFIG_RX_FIFO_NOT_LOCKED_ON_OVERRUN &         // with CANInit
                   _CAN_CONFIG_TIME_TRIGGERED_MODE_DISABLED &
                   _CAN_CONFIG_TX_FIFO_PRIORITY_BY_IDINTIFIER &
                   _CAN_CONFIG_WAKE_UP;

  CAN1InitializeAdvanced(1,5,4,4,1,Can_Init_Flags, &_GPIO_MODULE_CAN1_PD01); // Initialize CAN module
  CAN1SetOperationMode(_CAN_OperatingMode_Initialization);                   // set CONFIGURATION mode

  CANSetFilterScale32(0, _CAN_FILTER_ENABLED & _CAN_FILTER_ID_MASK_MODE & _CAN_FILTER_XTD_MSG, ID_2nd, -1);

  CAN1SetOperationMode(_CAN_OperatingMode_Normal); // set NORMAL mode

  RxTx_Data[0] = 9;                                // set initial data to be sent

  CAN1Write(ID_1st, RxTx_Data, 1, Can_Send_Flags); // send initial message

  while(1) {  // endless loop
    Msg_Rcvd = CAN1Read(0, &Rx_ID , RxTx_Data , &Rx_Data_Len, &Can_Rcv_Flags);  // receive message
    if ((Rx_ID == ID_2nd) && Msg_Rcvd) {                                        // if message received check id
      GPIOE_ODR  = RxTx_Data[0] << 8;                                           // id correct, output data at PORTE
      RxTx_Data[0]++ ;                                                          // increment received data
      Delay_ms(10);
      CAN1Write(ID_1st, RxTx_Data, 1, Can_Send_Flags);                          // send incremented data back
    }
  }
}

Hieronder staat de code voor de tweede Node op de EasyPIC-v7 board

c code:

/*
 * Project name:
     Can_Spi_2nd (CAN Network demonstration with mikroE's CAN-SPI module)
 * Copyright:
     (c) MikroElektronika, 2012.
 * Description:
     This project is a simple demonstration of using CAN-SPI module; with minor
     adjustments, it should work with any other MCU that has a SPI module.
     This code demonstrates how to use CANSPI library functions and procedures.
     It is used together with the CanSpi_1st example (on second MCU), and it can
     be used to test the connection of MCU to the CAN network.
     This node receives data, increments it by 1 and send it back to the 1st node.
 * Test configuration:
     MCU:             PIC18F45K22
                      http://ww1.microchip.com/downloads/en/DeviceDoc/41291F.pdf
     Dev.Board:       EasyPIC7
                      http://www.mikroe.com/easypic/
     Oscillator:      HS-PLL, 32.00000 MHz
     Ext. Modules:    ac:CAN_SPI_Board on PORTC
     SW:              mikroC PRO for PIC
                      http://www.mikroe.com/mikroc/pic/
 * NOTES:
     - The indicator of good communication in this example is, that the 1st
       node always displays even data on PORTB, whilst the 2nd node always
       displays odd data.
     - Consult the CAN standard about CAN bus termination resistance.
     - Turn on LEDs on PORTB SW3.2
 */

unsigned char Can_Init_Flags, Can_Send_Flags, Can_Rcv_Flags; // can flags
unsigned char Rx_Data_Len;                                   // received data length in bytes
char RxTx_Data[8];                                           // can rx/tx data buffer
char Msg_Rcvd;                                               // reception flag
const long ID_1st = 0xA1, ID_2nd = 0xA2;                       // node IDs
long Rx_ID;

// CANSPI module connections
sbit CanSpi_CS            at  RC0_bit;
sbit CanSpi_CS_Direction  at  TRISC0_bit;
sbit CanSpi_Rst           at  RC2_bit;
sbit CanSpi_Rst_Direction at  TRISC2_bit;
// End CANSPI module connections

void main() {

  ANSELB  = 0;                                                // Configure AN pins as digital I/O
  ANSELC = 0;
  SLRCON = 0;                                                 // Set output slew rate on all ports at standard rate
  
  LATB = 0;                                                   // clear PORTB
  TRISB = 0;                                                  // set PORTB as output

  Can_Init_Flags = 0;                                         //
  Can_Send_Flags = 0;                                         // clear flags
  Can_Rcv_Flags  = 0;                                         //

  Can_Send_Flags = _CANSPI_TX_PRIORITY_0 &                    // form value to be used
                   _CANSPI_TX_XTD_FRAME &                     //   with CANSPIWrite
                   _CANSPI_TX_NO_RTR_FRAME;

  Can_Init_Flags = _CANSPI_CONFIG_SAMPLE_THRICE &             // Form value to be used
                   _CANSPI_CONFIG_PHSEG2_PRG_ON &             //  with CANSPIInit
                   _CANSPI_CONFIG_XTD_MSG &
                   _CANSPI_CONFIG_DBL_BUFFER_ON &
                   _CANSPI_CONFIG_VALID_XTD_MSG &
                   _CANSPI_CONFIG_LINE_FILTER_OFF;

  SPI1_Init();                                                                // initialize SPI1 module
  
  CANSPIInitialize(1,3,3,3,1,Can_Init_Flags);                                 // initialize external CANSPI module
  CANSPISetOperationMode(_CANSPI_MODE_CONFIG,0xFF);                           // set CONFIGURATION mode
  CANSPISetMask(_CANSPI_MASK_B1,-1,_CANSPI_CONFIG_XTD_MSG);                   // set all mask1 bits to ones
  CANSPISetMask(_CANSPI_MASK_B2,-1,_CANSPI_CONFIG_XTD_MSG);                   // set all mask2 bits to ones
  CANSPISetFilter(_CANSPI_FILTER_B2_F3,ID_1st,_CANSPI_CONFIG_XTD_MSG);        // set id of filter B2_F3 to 1st node ID

  CANSPISetOperationMode(_CANSPI_MODE_NORMAL,0xFF);                           // set NORMAL mode

  while (1) {                                                                 // endless loop
    Msg_Rcvd = CANSPIRead(&Rx_ID , RxTx_Data , &Rx_Data_Len, &Can_Rcv_Flags); // receive message
    if ((Rx_ID == ID_1st) && Msg_Rcvd) {                                      // if message received check id
      LATB = RxTx_Data[0];                                                    // id correct, output data at PORTC
      RxTx_Data[0]++ ;                                                        // increment received data
      CANSPIWrite(ID_2nd, RxTx_Data, 1, Can_Send_Flags);                      // send incremented data back
    }
  }
}

CAN bus niet afgesloten (2x 120 ohm aan beide uiteinden), grounds niet doorverbonden, geen kristallen gebruikt en daardoor een overmatige afwijking in de klok frequenties, CAN-L en CAN-H gekruist, etc.

Wat zie je met een scope op de CAN-L en CAN-H lijnen, en ontvang je wel een bericht als je met je CAN analyser een bericht op de bus zet?

Een manager is iemand die denkt dat negen vrouwen in één maand een kind kunnen maken

Hallo SparkyGSX,

Bedankt voor je reactie.

De physical layer is absoluut in order. Ik heb e.e.a. al werkend gehad alleen dat was met gebruik van een CANSPI module. Dit is een extern boardje van Mikroelektronika met daarop de Microchip MCP2515 CANcontroller en de MCP2551 Tranceiver. (Zie afbeelding hieronder).
http://www.mikroe.com/img/development-tools/accessory-boards/click/canspi/canspi_click_5v_main.png
Dus in combinatie met een externe can controller en tranceiver gaat het goed. Ik wil alleen de in de MCU gebouwde CANcontroller(s) gaan toepassen.

Met de scoop zie ik alleen CAN berichten afkomstig van de EasyPIC board. De EasyMXPro geeft geen enkel bericht.

Ik zoek eigenlijk iemand die weet hoe de STM32F107VCT6 moet worden geïnitialiseerd zodat beide CAN's (CAN1 en CAN2) werken.

Momenteel gebruik is onderstaande code voor de EasyMXPro board. Deze code werkte wel i.c.m. de CANSPI click:

c code:

/* Project name:
     CAN_1st (CAN Network demonstration with mikroE's CAN-1 module)
 * Copyright:
     (c) MikroElektronika, 2011.
 * Revision History:
     20110511(TL):
       - initial release;
 * Description:
      This is code that shows simple connection of two CAN SPI modules. This is for 1st node.
     Press buttons on PortD/L to send message and receive message on TFT.
 * Test configuration:
     MCU:             STM32F107VC
                      http://www.st.com/internet/com/technical_resources/technical_literature/datasheet/cd00220364.pdf
     Dev.Board:       EasyMx PRO v7 for STM32(R) ARM(R)
                      http://www.mikroe.com/eng/products/view/852/easymx-pro-v7-for-stm32/
     Oscillator:      HSE-PLL, 72.000MHz
     Ext. Modules:    None.
     SW:              mikroC PRO for ARM
                      http://www.mikroe.com/eng/products/view/752/mikroc-pro-for-arm/
 * NOTES:
     - Turn on PORTE LEDs at SW10 and turn on CAN RX and TX switches at SW12.
*/

/**************************************************************************************************/
#include "resources.h"
/**************************************************************************************************
* Global variables
**************************************************************************************************/
unsigned long Can_Init_Flags;
unsigned char Can_Send_Flags, Can_Rcv_Flags; // can flags
unsigned char Rx_Data_Len;                                   // received data length in bytes
char RxTx_Data[8];                                           // can rx/tx data buffer
char Msg_Rcvd;                                               // reception flag
const long ID_1st = 12111, ID_2nd = 3;                       // node IDs
long Rx_ID;

/**************************************************************************************************
* Draw Screen
**************************************************************************************************/
void DrawScr(){
  TFT_Fill_Screen(CL_WHITE);
  TFT_Set_Pen(CL_Black, 1);
  TFT_Line(20, 220, 300, 220);
  TFT_LIne(20,  46, 300,  46);
  TFT_Set_Font(&HandelGothic_BT21x22_Regular, CL_RED, FO_HORIZONTAL);
  TFT_Write_Text("CAN spi click  TEST", 75, 14);
  TFT_Set_Font(&Verdana12x13_Regular, CL_BLACK, FO_HORIZONTAL);
  TFT_Write_Text("EasyMX PRO for ST", 19, 223);
  TFT_Set_Font(&Verdana12x13_Regular, CL_RED, FO_HORIZONTAL);
  TFT_Write_Text("www.mikroe.com", 200, 223);
  TFT_Set_Font(&TFT_defaultFont, CL_BLACK, FO_HORIZONTAL);
}
/**************************************************************************************************
* Draw LED on screen
**************************************************************************************************/
void DrawLed(short No, char fill){
char xcoo, ycoo;

  if (fill)
    TFT_Set_Brush(1, CL_RED, 1, LEFT_TO_RIGHT, CL_PURPLE, CL_RED);
  else
    TFT_Set_Brush(1, CL_WHITE, 0, LEFT_TO_RIGHT, CL_BLACK, CL_WHITE);

  xcoo = 180 - (No / 4) * 40;
  ycoo = 190 - (No % 4) * 30;
  TFT_Circle(xcoo, ycoo, 10);
}
/**************************************************************************************************
* Port read variables
**************************************************************************************************/
char port_rd;
char port_rd_temp;
char i;
char old_message = 0xFF;

/**************************************************************************************************
* MAIN PROGRAM
**************************************************************************************************/

void main() {

  // PORT set up
  GPIO_Digital_Input(&GPIOD_BASE, _GPIO_PINMASK_LOW);
  GPIO_Digital_Output(&GPIOD_BASE, _GPIO_PINMASK_13);
  GPIO_Digital_Output(&GPIOC_BASE, _GPIO_PINMASK_2);

  TFT_Init_ILI9341_8bit(320, 240);
  DrawScr();
  for(i = 0; i < 8; i++)
    DrawLed(i, 0);
  TFT_Write_Text("PORT D/L buttons from 2nd node", 70, 60);


  Can_Init_Flags = 0;                                       //
  Can_Send_Flags = 0;                                       // clear flags
  Can_Rcv_Flags  = 0;                                       //

  Can_Send_Flags = _CAN_TX_XTD_FRAME &                      //     with CANWrite
                   _CAN_TX_NO_RTR_FRAME;

  Can_Init_Flags = _CAN_CONFIG_AUTOMATIC_RETRANSMISSION &              // form value to be used
                   _CAN_CONFIG_RX_FIFO_NOT_LOCKED_ON_OVERRUN &         // with CANInit
                   _CAN_CONFIG_TIME_TRIGGERED_MODE_DISABLED &
                   _CAN_CONFIG_TX_FIFO_PRIORITY_BY_IDINTIFIER &
                   _CAN_CONFIG_WAKE_UP;


  CAN1InitializeAdvanced(1,5,4,4,1,Can_Init_Flags, &_GPIO_MODULE_CAN1_PD01); // Initialize CAN module
  CAN1SetOperationMode(_CAN_OperatingMode_Initialization);                   // set CONFIGURATION mode

  CANSetFilterScale32(0, _CAN_FILTER_ENABLED & _CAN_FILTER_ID_MASK_MODE & _CAN_FILTER_XTD_MSG, ID_2nd, -1);

  CAN1SetOperationMode(_CAN_OperatingMode_Normal); // set NORMAL mode





  RxTx_Data[0] = 9;                                // set initial data to be sent

  CAN1Write(ID_1st, RxTx_Data, 1, Can_Send_Flags); // send initial message

  while(1)
  {                                                                           // endless loop
    Msg_Rcvd = CAN1Read(1, &Rx_ID , RxTx_Data , &Rx_Data_Len, &Can_Rcv_Flags);  // receive message

    if ((Rx_ID == ID_2nd) && Msg_Rcvd) {                                      // if message received check id

      if (RxTx_Data[0] != old_message){                                       // id correct, output data at PORTD
        old_message = RxTx_Data[0];
        for (i = 0; i < 8; i ++){
          DrawLed(i, RxTx_Data[0] % 2);
          RxTx_Data[0] = RxTx_Data[0] / 2;
        }
      }
//      Delay_ms(10);
    }

    port_rd = GPIOD_IDR;                                                      // Read value from PORTB
    if (port_rd != port_rd_temp)                                              // Check for change on PORTB
    {
       port_rd_temp = port_rd;            // Save current port value
          CAN1Write(ID_1st, &port_rd, 1, Can_Send_Flags);                      // send incremented data back
    }
  }
}

In de EasyPIC board zit onderstaande code. Deze werkt met een CANSPI Click board aangezien er geen interne CANcontroller in de PIC18F45K22 zit.

c code:

/**************************************************************************************************
 * Project name:
     CAN_SPI_click 2nd NODE (Demonstration of mikroBUS CAN SPI click board)
 * Copyright:
     (c) Mikroelektronika, 2011.
 * Revision History:
     20111228:
       - initial release (DA & JK);
 * Description:
     This is code that shows simple connection of two CAN SPI modules. This is for 2nd node.
     Press buttons on PortB to send message and receive message on PortD LEDs.

 * Test configuration:
     MCU:             PIC18F45K22
                      http://ww1.microchip.com/downloads/en/DeviceDoc/41412D.pdf
     dev.board:       EasyPIC7
                      http://www.mikroe.com/eng/products/view/757/easypic-v7-development-system/
     Oscillator:      HS-PLL 32.0000 MHz, 8.0000 MHz Crystal
     ext. modules:    can spi click 5v   
                      http://www.mikroe.com/eng/products/view/814/can-spi-click-5v/
                      with MCP2551 on board:
                      http://www.microchip.com/wwwproducts/Devices.aspx?dDocName=en010405
     SW:              mikroC PRO for PIC
                      http://www.mikroe.com/eng/products/view/7/mikroc-pro-for-pic/

 * NOTES:
     - Place jumper J5 to select 5V power supply voltage level.
     - Plug CAN SPI Board to mikroBUS 1 socket
     - Turn On PortD LEDs (SW3.4)
     - Turn On PortE LEDs (SW3.1)
     - Set pull-up on PortB (PortB three state switch)
     - Place jumper J17 in lower position.
**************************************************************************************************/

/**************************************************************************************************
* Global variables
**************************************************************************************************/

unsigned char Can_Init_Flags, Can_Send_Flags, Can_Rcv_Flags; // can flags
unsigned char Rx_Data_Len;                                   // received data length in bytes
char RxTx_Data[8];                                           // can rx/tx data buffer
char Msg_Rcvd;                                               // reception flag
const long ID_1st = 12111, ID_2nd = 3;                       // node IDs
long Rx_ID;
char cnt=0;
char j=0;
// CANSPI module connections
sbit CanSpi_CS            at  RC0_bit;
sbit CanSpi_CS_Direction  at  TRISC0_bit;
sbit CanSpi_Rst           at  RC2_bit;
sbit CanSpi_Rst_Direction at  TRISC2_bit;
// End CANSPI module connections
// Glcd module connections
char GLCD_DataPort at PORTD;

sbit GLCD_CS1 at LATB0_bit;
sbit GLCD_CS2 at LATB1_bit;
sbit GLCD_RS  at LATB2_bit;
sbit GLCD_RW  at LATB3_bit;
sbit GLCD_EN  at LATB4_bit;
sbit GLCD_RST at LATB5_bit;

sbit GLCD_CS1_Direction at TRISB0_bit;
sbit GLCD_CS2_Direction at TRISB1_bit;
sbit GLCD_RS_Direction  at TRISB2_bit;
sbit GLCD_RW_Direction  at TRISB3_bit;
sbit GLCD_EN_Direction  at TRISB4_bit;
sbit GLCD_RST_Direction at TRISB5_bit;

void main() {

  ANSELA=0;                                                   // Configure AN pins as digital I/O
  ANSELB  = 0;                                                // Configure AN pins as digital I/O
  ANSELC = 0;
  SLRCON = 0;                                                 // Set output slew rate on all ports at standard rate

  LATB = 0;                                                   // clear PORTB
  TRISB = 0;                                                  // set PORTB as output
  TRISA=0;
  PORTA=0x00;
  Glcd_Init();                   // Initialize GLCD
  Glcd_Fill(0x00);
  Can_Init_Flags = 0;                                         //
  Can_Send_Flags = 0;                                         // clear flags
  Can_Rcv_Flags  = 0;                                         //

  Can_Send_Flags = _CANSPI_TX_PRIORITY_0 &                    // form value to be used
                   _CANSPI_TX_XTD_FRAME &                     //     with CANSPIWrite
                   _CANSPI_TX_NO_RTR_FRAME;

  Can_Init_Flags = _CANSPI_CONFIG_SAMPLE_THRICE &             // Form value to be used
                   _CANSPI_CONFIG_PHSEG2_PRG_ON &             //  with CANSPIInit
                   _CANSPI_CONFIG_XTD_MSG &
                   _CANSPI_CONFIG_DBL_BUFFER_ON &
                   _CANSPI_CONFIG_VALID_XTD_MSG &
                   _CANSPI_CONFIG_LINE_FILTER_OFF;


  SPI1_Init();                                                     // initialize SPI1 module

  CANSPIInitialize(1,3,3,3,1,Can_Init_Flags);                      // Initialize external CANSPI module
  CANSPISetOperationMode(_CANSPI_MODE_CONFIG,0xFF);                // set CONFIGURATION mode
  CANSPISetMask(_CANSPI_MASK_B1,-1,_CANSPI_CONFIG_XTD_MSG);        // set all mask1 bits to ones
  CANSPISetMask(_CANSPI_MASK_B2,-1,_CANSPI_CONFIG_XTD_MSG);        // set all mask2 bits to ones
  CANSPISetFilter(_CANSPI_FILTER_B2_F4,ID_2nd,_CANSPI_CONFIG_XTD_MSG);// set id of filter B2_F4 to 2nd node ID

  CANSPISetOperationMode(_CANSPI_MODE_NORMAL,0xFF);                // set NORMAL mode

  RxTx_Data[0] = 'H'; RxTx_Data[1] = 'O'; RxTx_Data[2] = 'L'; RxTx_Data[3] = 'A';                                                // set initial data to be sent
  for(cnt=0;cnt<20;cnt++){
  PORTA=~PORTA;
  Delay_ms(100);
  }
  PORTA=0x00;
  cnt=0;
  //CANSPIWrite(ID_1st, RxTx_Data, 6, Can_Send_Flags);               // send initial message

  while(1) {                                                                 // endless loop
    if (cnt==10) cnt=0;
    Rxtx_Data[4]=cnt+48;
    RxTx_Data[5] = 0;
    CANSPIWrite(ID_1st, RxTx_Data, 6, Can_Send_Flags);                     // send incremented data back
    Glcd_Fill(0x00);
    Glcd_Write_Text(RxTx_Data, 0, 1, 1);
    for(j=0;j<10;j++){                                                    // Blink PORTA
    PORTA=~PORTA;
    Delay_ms(200);
    }
    Delay_ms(3000);
    cnt++;
    }
}

/**************************************************************************************************
* End of File
**************************************************************************************************/

Alvast bedankt voor de reactie.

[Bericht gewijzigd door Moomin op maandag 15 december 2014 00:12:43 (90%)

Hmm weet verr de rest niks over dat ding, maar ik mis toch een paar dingen, bv welke baudrate en zijn eigen ID

Hoi Zylar,

De baudrate staat ingesteld op 125Kb/s, althans op de externe CANSPI module. Deze werken probleemloos en kan ik meten met de analyzer. De juiste instelling van de processor is onzeker omdat er geen berichten worden uitgestuurd. Ik heb dus nog niets kunnen meten aan de EasyMXv7 board met de STM32F107VCT6 MCU.

Zijn eigen ID is 12111 decimaal oftewel 2F4F Hex. De ID van de 2e Node is 3.

[Bericht gewijzigd door Moomin op maandag 15 december 2014 00:23:57 (11%)

Ik weet niet of het nodig is op 107, maar op de 303 moest ik eerst een paar clocks activeren met bv.

c code:

RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);

Pinnetjes activeren i.v.m. alternate functies van de pinnen:

c code:

GPIO_PinAFConfig(GPIOx, GPIO_PinSourcex, GPIO_AF_CANx);

Wellicht staat dit ook al in de functie CAN1InitializeAdvanced.

Misschien moet er ook nog een PLL of prescalers ingesteld worden of van interne RC naar extern kristal.

Wellicht kun je ook met JTAG de registers nalopen.

Ik moet er bij zeggen dat ik niet gewerkt heb met de canbus op de 303, maar wel met spi en i2c etc. Ik gebruikt de libraries van ST zelf.

Congratulations on your purchase. To begin using your quantum computer, set the power switch to both off and on simultaneously

Ok, de physical layer controleren lijkt me de beste eerste stap, anders ben je op de verkeerde plaats aan het zoeken, maar dat lijkt dus wel in orde. Zie je, met een scope, helemaal geen bitjes langskomen? Als de clock niet klopt, zou de bit timing verkeerd kunnen zijn (een beetje ernaast, of veel te hoog of te laag), dus voor mij zou de volgende stap toch zijn om een scope op de bus te hangen.

Ik ken de controller niet goed genoeg om je met je code te kunnen helpen; ik gebruik ze eigenlijk alleen in combinatie met code generatie tools (Simulink), en dan zijn deze dingen allemaal al geregeld.

Een manager is iemand die denkt dat negen vrouwen in één maand een kind kunnen maken

Hallo shizzle dizzle,

Bedankt voor je reactie. Volgens mij zou het hier weleens in kunnen zitten. Ik zie dat jij hier duidelijk meer verstand van hebt dan ik.

Zou jij mij (tegen een vergoeding) willen helpen het programma aan te passen? Ik kan eventueel naar je toe komen als je dat wilt.

Ik hoor graag van je. Alvast bedankt.

Dat gaat niet lukken, tijd zat, alleen m'n energie laat het afweten, ik heb ook in de ziektewet gezeten.

Ik ken de library's van mikro elektronica verder niet. Het handigste is dat je een werkend voorbeeld hebt van de Mikroc library en vanuit daar verder gaat en zoals SparkyGSX zegt met een scope direct op de pin meten om het hardware gedeelte uit te sluiten, maar zo te lezen moet dat goed zijn. (alhoewel, aanname's zijn dodelijk)

Ik had ook even gekeken in de voorbeelden van de 303, maar daar staat jammer genoeg geen voorbeeld in van de canbus. Ook niet van het discovery bordje met de f1xx (de voorbeelden vind je hier http://www.st.com/web/catalog/tools/FM116/SC959/SS1532/LN1848/PF250863.

De functies die ik eerder noemde met RCC zijn functies die in de library van ST staat. Ik neem aan dat mikroe weer z'n eigen library heeft ?

We komen er vast wel uit hier.

Congratulations on your purchase. To begin using your quantum computer, set the power switch to both off and on simultaneously

Je hebt toch zo'n can chippie tussen je µP en het andere bordje?

Ben Belg sowat :D :: plaatjes zijn meestal klikbaar

Als je het schematic bekijkt zit deze erop:

http://www.mikroe.com/downloads/get/1837/easymx_pro_v7_stm32_schematic… U7 links van het midden onderaan. Ik neem dan aan dat TS de canbus via CN28 heeft aangesloten ?

Congratulations on your purchase. To begin using your quantum computer, set the power switch to both off and on simultaneously

Hoi shizzle dizzle,

Vervelend dat je energie het laat afweten. Nooit leuk zoiets. Toch fijn dat je toch, ondanks je gezondheid, op dit forum zit.
Het zou mooi zijn als we er zo uit kunnen komen. De hardware is in orde alleen de software nog.

Klopt dit is het schema. De CANtranceiver is de SN65HVD230. De scoop en analyzer en de EasyPICv7 zitten hierop aangesloten.

Ik denk dat ik me inderdaad ook moet concentreren op de RCC functies.

Ik zal zometeen even een screenshot maken van de processor instellingen die door Mikroelektronika zijn vooringesteld.

Hieronder staan de settings die Mikroelektronika bij het programma heeft vooringesteld.
Is hier een verkeerde setting uit te halen waarom de CAN het mogelijk niet doet?

[Bericht gewijzigd door Henry S. op woensdag 17 december 2014 19:22:19 (63%)

had je ook de dip switches goed gezet? de ground gekoppeld?

Dipswitches staan zeker goed. Het zijn er maar twee en dat SW12-5+6 oftewel PD0 en PD1.
Zelfs gemeten met een ohmmeter. De MCU maakt absoluut direct verbinding met de CANtranceiver.
De Ground is niet gekoppeld (zit overigens ook niet op de CANconnector) en is ook niet nodig met deze korte verbindingen.

Nou, daar zou ik niet al te hard op rekenen. Hoewel het vaak wel goed gaat, mag je op een CAN bus maar een beperkte common-mode spanning hebben, en als je de grounds niet met elkaar verbind, kunnen de verschillende schakelingen uit elkaar "zweven", waardoor je uit die common-mode range loopt.

Een manager is iemand die denkt dat negen vrouwen in één maand een kind kunnen maken

Hoi SparkyGSX,

Ok, is snap denk ik wat je bedoeld. De verschillende nodes moeten dezelfde GND hebben. Dus de massa van de voedingsspanning van de verschillende nodes moeten met elkaar verbonden zijn. Is dat wat je bedoeld?

Dit is in mijn situatie het geval. De twee ontwikkelboarden en de analyzer hangen via een USB-Hub aan elkaar. Daar krijgen ze ook de spanning vandaan.

Kijk eerst eens of je inderdaad geen data uit de pinnetjes krijgt.

Je moet in RCC_APB1_ENR de CAN enablen en je moet ook zorgen dat je in RCC_CR en RCC_CFGR de clockfrequentie zo kiest dat je op de goede baudrate uit komt.

ik heb je code voorderest niet bekeken maar als je ook interrupts gebruikt moet je de NVIC ook goed instellen. Let op: dit is voor de M3 core zelf en hoeft niet in de reference manual van de 107 te staan.

zoals hierboven ook gegeven is de pinnetjes op alternate function zetten. En misschien ook nog juist muxen (weet niet of de 107 dat heeft). En ook de gpio clock aan zetten in de RCC.

En verder je CAN registers goed instellen natuurlijk. Als je dit bovenstaande goed doet, moet het softwarematig werken. Ik ga er dan even vanuit dat je geen DMA gebruikt...

Als je mcu 1 bericht verstuurt en niet kan worden ontvangen, blijft de CAN controller dat bericht versturen. Kans bestaat dat je bus daar hangt. kijk ff of dat afgevangen is.

Het is voor mij alweer jaren geleden dat ik er mee bezig geweest ben, maar heb toen wel een verbinding voor elkaar gehad.
Helaas kwamen de berichten niet goed aan op momenten dat beide node's ongeveer gelijktijdig zenden, en is dit alles in de kast beland.

Hierbij uit beide programma's het Instel en Zend/Ontvangst deel:

c code:


Node 1 (zenden):

  //CAN BUS Instellingen:
  Can_Init_Flags = 0;                                   //
  Can_Send_Flags = 0;                                   //clear flags
  Can_Rcv_Flags  = 0;                                   //

  Can_Send_Flags = CAN_TX_PRIORITY_0 &                  //Form value to be used
                   CAN_TX_XTD_FRAME &                   //with CANWrite
                   CAN_TX_NO_RTR_FRAME;
                   
  Can_Init_Flags = CAN_CONFIG_SAMPLE_THRICE &           //form value to be used
                   CAN_CONFIG_PHSEG2_PRG_ON &           //with CANSPIInit
                   CAN_CONFIG_XTD_MSG &
                   CAN_CONFIG_DBL_BUFFER_ON &
                   CAN_CONFIG_VALID_XTD_MSG;

  RxTx_Data[0] = 9;                                //set initial data to be sent

  //125kbps
  //CANInitialize(1,3,3,3,1,Can_Init_Flags);       // initialize CAN

  //250kbps (1e)
  //CANInitialize(1,1,3,3,1,Can_Init_Flags);       // initialize CAN

  //250kbps (2e)
  //CANInitialize(1,0,8,6,1,Can_Init_Flags);       //initialize CAN


  //500kbps
  CANInitialize(1,0,3,3,1,Can_Init_Flags);         // initialize CAN

  //CANInitialize(1,3,3,3,1,Can_Init_Flags);       // initialize CAN


  CANSetOperationMode(CAN_MODE_CONFIG,0xFF);          //set CONFIGURATION mode
  CANSetMask(CAN_MASK_B1,-1,CAN_CONFIG_XTD_MSG);      //set all mask1 bits to ones
  CANSetMask(CAN_MASK_B2,-1,CAN_CONFIG_XTD_MSG);      //set all mask2 bits to ones
  CANSetFilter(CAN_FILTER_B2_F3,3,CAN_CONFIG_XTD_MSG);//set id of filter B1_F1 to 3
  CANSetOperationMode(CAN_MODE_NORMAL,0xFF);          //set NORMAL mode


  //Zenden:
  Tx_ID = 12111;                                   //set transmit ID
  RxTx_Data[0] = Counter;
  CANWrite(Tx_ID, RxTx_Data, 1, Can_Send_Flags);  //Zenden: Counter waarde naar ID 12111

c code:


Node 2 (Ontvangen):

  //CAN BUS Instellingen:
  Can_Send_Flags = CAN_TX_PRIORITY_0 &           //Form value to be used
                   CAN_TX_XTD_FRAME &            //with CANWrite
                   CAN_TX_NO_RTR_FRAME;

  Can_Init_Flags = CAN_CONFIG_SAMPLE_THRICE &    //Form value to be used
                   CAN_CONFIG_PHSEG2_PRG_ON &    //with CANSPIInit
                   CAN_CONFIG_XTD_MSG &
                   CAN_CONFIG_DBL_BUFFER_ON &
                   CAN_CONFIG_VALID_XTD_MSG &
                   CAN_CONFIG_LINE_FILTER_OFF;   //


  //125kbps
  //CANInitialize(1,3,3,3,1,Can_Init_Flags);     //initialize CAN

  //250kbps (1e)
  //CANInitialize(1,1,3,3,1,Can_Init_Flags);     //initialize CAN

  //250kbps (2e)
  //CANInitialize(1,0,8,6,1,Can_Init_Flags);     //initialize CAN

  //500kbps
  CANInitialize(1,0,3,3,1,Can_Init_Flags);       //initialize CAN

  //CANInitialize(1,3,3,3,1,Can_Init_Flags);     //initialize CAN

  CANSetOperationMode(CAN_MODE_CONFIG,0xFF);     //set CONFIGURATION mode

  CANSetMask(CAN_MASK_B1,-1,CAN_CONFIG_XTD_MSG);       //set all mask1 bits to ones
  CANSetMask(CAN_MASK_B2,-1,CAN_CONFIG_XTD_MSG);       //set all mask2 bits to ones
  CANSetFilter(CAN_FILTER_B1_F1,12111,CAN_CONFIG_XTD_MSG); //set id of filter B1_F1        
                                                           //to 12111

  CANSetOperationMode(CAN_MODE_NORMAL,0xFF);           //set NORMAL mode

  Tx_ID = 3;                                           //set tx ID


  //Ontvangen
  Msg_Rcvd = CANRead(&Rx_ID , RxTx_Data , &Rx_Data_Len, &Can_Rcv_Flags);//Ontvangen
  if ((Rx_ID == 12111u) && Msg_Rcvd) {           //if message received check id
  PORTC = RxTx_Data[0];                         //id correct, output data at PORTB

In de datasheet http://www.st.com/web/en/resource/technical/document/reference_manual/… op pagina 93 staat een overzicht hoe het met de clocks werkt. Ook op pagina 126 staat nog een overzicht.

Het blijft dan nog lastig om te zeggen waarom het bij jouw niet werkt. In principe moet MikroE dit werk jouw uit handen nemen.

Ik weet nog wel toen ik voor het eerst begon met een stm32, dat was wel even 'afzien', ik vond de leercurve een stuk steiler dan een AVR. Maar deze chips kunnen wel veel meer.

In jou afbeelding staat een paar registers die ingesteld worden, maar wordt het register RCC_APB1ENR ook ingesteld door MikroE ?, hier staat namelijk een bitje in (bit 25 CAN1_EN) om de clock voor de canbus te enabelen. Heb je ook debug mogelijkheden en kun je ook registers uit lezen ?

Wellicht heeft MMSoft de instellingen nog voor de clocks en canbus.

Congratulations on your purchase. To begin using your quantum computer, set the power switch to both off and on simultaneously

Het makkelijke is dat Mikroelektronika op zich met hun software veel werk m.b.t. het programmeren al vooringesteld hebben. Het nadeel is meteen dat niet (gemakkelijk) in de library van Mikroe gekeken kan worden.

Ondanks dat er flink met mij meegedacht wordt, wat ik overigens zeer waardeer, moet ik door een toch wel een te groot gebrek aan kennis van deze processor waarschijnlijk toch hulp inroepen van iemand op dit forum om de CAN-BUS_settings, al dan niet in een andere ontwikkelomgeving te gaan programmeren.

Dus bij deze een oproep wie mij een handje kan helpen (tegen een vergoeding) om de can1 en can2 op 500kB/s goed werkend te krijgen. Ik woon in de buurt van Arnhem maar kan zonder problemen op lokatie komen in heel Nederland.

Als er nog vragen zijn m.b.t. het hoe of wat dan hoor ik dat graag.

Alvast bedankt.