STM32 最小系统板带 CAN 485

只看该作者 · 2011-7-8 16:32

只看该作者 · 2011-7-10 09:36

zhangbing163swjtu@163.com 初学STM32，需做一个报警器，需最小系统板相关资料。望楼主多多指教！

只看该作者 · 2011-7-10 12:19

你好，你直接加入到我们的群吧，这样方便给你传资料
群号：72226149 STM32 学讨论群

只看该作者 · 2011-7-12 16:08

实验（一）  LED 流水灯

void LedInit(void)
{
      GPIO_InitTypeDef GPIO_InitStructure;

      RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);//使能外设时钟

      GPIO_InitStructure.GPIO_Pin = GPIO_Pin_15 | GPIO_Pin_14 | GPIO_Pin_13 | GPIO_Pin_12; //设置管脚为输出模式
      GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
      GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
      GPIO_Init(GPIOB, &GPIO_InitStructure);

      LedOff();
}

void LedOff(void)
{
      LedOutput(0,0);
      LedOutput(1,0);
      LedOutput(2,0);
      LedOutput(3,0);
}

void LedOutput(unsigned char LedNumber,unsigned char IfOn)
{
      if(LedNumber>3)
      {
            LedNumber = 0;
      }

      switch (LedNumber)
      {

            case 0:
                     if(IfOn)
                     {
                              GPIO_ResetBits(GPIOB,GPIO_Pin_14);
                     }
                     else
                     {
                              GPIO_SetBits(GPIOB,GPIO_Pin_14);
                     }
                     break;
            case 1:
                     if(IfOn)
                     {
                              GPIO_ResetBits(GPIOB,GPIO_Pin_12);
                     }
                     else
                     {
                              GPIO_SetBits(GPIOB,GPIO_Pin_12);
                     }
                     break;
            case 2:
                     if(IfOn)
                     {
                              GPIO_ResetBits(GPIOB,GPIO_Pin_13);
                     }
                     else
                     {
                              GPIO_SetBits(GPIOB,GPIO_Pin_13);
                     }
                     break;
            default:
                     break;
      }
}

void LedTest(void)
{
      while(1)
      {
            LedOutput(0,1);
            DelayNmS(200);
            LedOutput(0,0);

            LedOutput(1,1);
            DelayNmS(200);
            LedOutput(1,0);

            LedOutput(2,1);
            DelayNmS(200);
            LedOutput(2,0);


      }
}

只看该作者 · 2011-7-13 09:50

本帖最后由 jiaxinhui 于 2011-7-13 09:51 编辑

实验（二）  串口发送与接收

void UART1Init(void)
{
      GPIO_InitTypeDef GPIO_InitStructure;
      USART_InitTypeDef USART_InitStructure;

      RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
      RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);

      GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
      GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
      GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
      GPIO_Init(GPIOA, &GPIO_InitStructure);

      GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
      GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
      GPIO_Init(GPIOA, &GPIO_InitStructure);

      USART_InitStructure.USART_BaudRate = 9600;
      USART_InitStructure.USART_WordLength = USART_WordLength_8b;
      USART_InitStructure.USART_StopBits = USART_StopBits_1;
      USART_InitStructure.USART_Parity = USART_Parity_No;
      USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
      USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;
      USART_Init(USART1, &USART_InitStructure);

      USART_Cmd(USART1, ENABLE);
}

void UART1SendByte(unsigned char SendData)
{
      USART_SendData(USART1,SendData);
      while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);

}

unsigned char UART1GetByte(unsigned char* GetData)
{

      if(USART_GetFlagStatus(USART1, USART_FLAG_RXNE) == RESET)
      {
            return 0;//没有收到数据
      }

      *GetData = USART_ReceiveData(USART1);


      return 1;//收到数据
}

void UART1Test(void)
{
      unsigned char i = 0;

   while(1)
   {
               while(UART1GetByte(&i))
            {
                     USART_SendData(USART1,i);

            }
      }

｝

只看该作者 · 2011-7-13 13:16

很不错

只看该作者 · 2011-7-13 13:17

谢谢楼主

只看该作者 · 2011-7-13 13:32

:handshake

只看该作者 · 2011-7-13 14:55

楼主的观察力够敏锐，应该很有市场

只看该作者 · 2011-7-15 10:11

实验（三）  RTC寄存器的读写
void RTCInit(void)
{
      RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);
      PWR_BackupAccessCmd(ENABLE);

      if(BKP_ReadBackupRegister(BKP_DR1) != 0xA5A5) //判断备份寄存器是否已经设置过
      {
            RCC_LSEConfig(RCC_LSE_ON);
            while(RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET)
            {
            }
            RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);

            RCC_RTCCLKCmd(ENABLE);


            BKP_TamperPinCmd(DISABLE);

            BKP_RTCOutputConfig(DISABLE);

            RTC_WaitForSynchro();
            RTC_WaitForLastTask();

            //设置时间
            RTC_SetCounter(0);

            BKP_WriteBackupRegister(BKP_DR1, 0xA5A5);  //设置备份寄存器
      }
}

void RTCTest(void)
{
      unsigned long RTCCounterValue;

      while(1)
      {
            RTCCounterValue = RTC_GetCounter();

            UART1SendByte(RTCCounterValue>>24);//读RTC时钟
            UART1SendByte(RTCCounterValue>>16);
            UART1SendByte(RTCCounterValue>>8);
            UART1SendByte(RTCCounterValue);

            DelayNmS(1000);       }
}

只看该作者 · 2011-7-18 09:57

实验（四）  RTC寄存器的读写
void KeyInit(void)
{
      GPIO_InitTypeDef GPIO_InitStructure;

      RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);//使能外设时钟
      RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);//使能外设时钟

      GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8 ;
      GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
      GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
      GPIO_Init(GPIOA, &GPIO_InitStructure);

      GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1 | GPIO_Pin_15 ;
      GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
      GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
      GPIO_Init(GPIOB, &GPIO_InitStructure);
}

unsigned char GetKey(void)
{
      if(Bit_RESET == GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_8))
      {
            DelayNmS(10);//去抖动
            if(Bit_RESET == GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_8))
            {
                     while(Bit_RESET == GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_8))//等待按键释放
                     {
                     }
                     return 3;//返回按键值
            }
      }

      if(Bit_RESET == GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_1))
      {
            DelayNmS(10);//去抖动
            if(Bit_RESET == GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_1))
            {
                     while(Bit_RESET == GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_1))//等待按键释放
                     {
                     }
                     return 1;//返回按键值
            }
      }

      if(Bit_RESET == GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_15))
      {
            DelayNmS(10);//去抖动
            if(Bit_RESET == GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_15))
            {
                     while(Bit_RESET == GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_15))//等待按键释放
                     {
                     }
                     return 2;//返回按键值
            }
      }



      return NO_KEY;
}

void KeyTest(void)
{
      unsigned char i = 0;

      while(1)
      {
                     i = GetKey();//按键扫描

         switch(i)
{ case 1:  LedOutput(0,1);break;  //按键1按下，LED1亮
                                                case 2:  LedOutput(1,1);break;  //按键2按下，LED2亮
   case 3:  LedOutput(2,1); break; //按键3按下，LED3亮
   default:  break;
}

      }
}

只看该作者 · 2011-7-25 07:47

注意：上面的实验（四）是按键查询程序。
实验（五）  SysTick
void SysTInit(void)
{
      SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);//2M
      SysTick_SetReload(200000);//100ms

      SysTick_ITConfig(ENABLE);

      NVIC_SystemHandlerPriorityConfig(SystemHandler_SysTick, 2, 0);

      SysTStop();
}

void SysTStart(void)
{
      SysTick_CounterCmd(SysTick_Counter_Enable);
}

void SysTStop(void)
{
      SysTick_CounterCmd(SysTick_Counter_Disable);
}

void SysTTest(void)
{
      SysTStart();
      while(1);
}

unsigned char SysTTestFlag = 0;
void SysTickHandler(void)
{
      if(SysTTestFlag)
      {
            SysTTestFlag = 0;
            LedOutput(0,0);
      }
      else
      {
            SysTTestFlag = 1;
            LedOutput(0,1);
      }
}

只看该作者 · 2011-7-25 08:32

请问LZ 这是个ADC模拟部分供电的吗？能解释一下这部分的接法吗？谢谢

只看该作者 · 2011-7-25 10:34

通过电感、电容先滤波，然后通过0欧姆的电阻与数字地相连。

只看该作者 · 2011-7-27 09:57

STM32固件库使用手册的中文翻译版.pdf (2.79 MB)

只看该作者 · 2011-7-27 11:38

楼主搞的不错，我也下来看看。

1万 · 2011-7-27 14:33

如果有技术，再多思考，商机还是很多的

只看该作者 · 2011-8-1 06:54

实验（五）  CAN环回测试
void GPIO_Configuration(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
/* LED1 LED2 LED3 的控制管脚为输出模式*/

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_14 ;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOB, &GPIO_InitStructure);

    /* Configure CAN pin: RX */
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
    GPIO_Init(GPIOB, &GPIO_InitStructure);

    /* Configure CAN pin: TX */
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_Init(GPIOB, &GPIO_InitStructure);

GPIO_PinRemapConfig(GPIO_Remap1_CAN1, ENABLE );    //重影射CAN IO脚到 PB8，PB9
}

//系统中断管理
void NVIC_Configuration(void)
{
NVIC_InitTypeDef NVIC_InitStructure;

    /* Configure the NVIC Preemption Priority Bits */
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);

#ifdef  VECT_TAB_RAM
   /* Set the Vector Table base location at 0x20000000 */
   NVIC_SetVectorTable(NVIC_VectTab_RAM, 0x0);
#else  /* VECT_TAB_FLASH  */
   /* Set the Vector Table base location at 0x08000000 */
   NVIC_SetVectorTable(NVIC_VectTab_FLASH, 0x0);
#endif

/* enabling interrupt */
    NVIC_InitStructure.NVIC_IRQChannel=USB_LP_CAN1_RX0_IRQn;;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);
}

//配置系统时钟,使能各外设时钟
void RCC_Configuration(void)
{

      ErrorStatus HSEStartUpStatus;
      // RCC system reset(for debug purpose)
      RCC_DeInit();

      // Enable HSE
      RCC_HSEConfig(RCC_HSE_ON);

      // Wait till HSE is ready
      HSEStartUpStatus = RCC_WaitForHSEStartUp();

      if(HSEStartUpStatus == SUCCESS)
      {
            // HCLK = SYSCLK
            RCC_HCLKConfig(RCC_SYSCLK_Div1);

            // PCLK2 = HCLK
            RCC_PCLK2Config(RCC_HCLK_Div1);

            // PCLK1 = HCLK/2
            RCC_PCLK1Config(RCC_HCLK_Div2);

            // Flash 2 wait state
            //FLASH_SetLatency(FLASH_Latency_2);
            FLASH_SetLatency(FLASH_Latency_0);
            //FLASH_SetLatency(FLASH_Latency_1);


            // Enable Prefetch Buffer
            FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);

            // PLLCLK = 8MHz /2*2 = 8 MHz
            RCC_PLLConfig(RCC_PLLSource_HSE_Div2, RCC_PLLMul_2);

            // Enable PLL
            RCC_PLLCmd(ENABLE);

            // Wait till PLL is ready
            while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET)
            {
            }

            // Select PLL as system clock source
            RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);

            // Wait till PLL is used as system clock source
            while(RCC_GetSYSCLKSource() != 0x08)
            {
            }

      }

      // Enable peripheral clocks --------------------------------------------------

RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1 | RCC_APB2Periph_GPIOA
                        |RCC_APB2Periph_GPIOB | RCC_APB2Periph_GPIOC
                        |RCC_APB2Periph_GPIOD | RCC_APB2Periph_GPIOE
   |RCC_APB2Periph_ADC1  | RCC_APB2Periph_AFIO
                        |RCC_APB2Periph_SPI1, ENABLE );
  //RCC_APB2PeriphClockCmd(RCC_APB2Periph_ALL ,ENABLE );
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4
                        |RCC_APB1Periph_USART3|RCC_APB1Periph_TIM2
                        , ENABLE );
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
/* CAN Periph clock enable */
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);
}

//配置所有外设
void Init_All_Periph(void)
{
RCC_Configuration();

GPIO_Configuration();
NVIC_Configuration();
}

int main(void)
{
Init_All_Periph();

GPIO_SetBits(GPIOB, GPIO_Pin_14);
GPIO_SetBits(GPIOB, GPIO_Pin_12);
GPIO_SetBits(GPIOB, GPIO_Pin_13);

/* CAN transmit at 100Kb/s and receive by polling in loopback mode*/
    TestRx = CAN_Polling();

    if (TestRx == FAILED) //失败LED2亮
    {
/* Turn on led connected to PD.04 pin (LD3) */
GPIO_ResetBits(GPIOB, GPIO_Pin_12);
    }
    else //成功LED1亮
    {
/* Turn on led connected to PD.02 pin (LD1) */
      GPIO_ResetBits(GPIOB, GPIO_Pin_14);
    }

    /* CAN transmit at 500Kb/s and receive by interrupt in loopback mode*/
    TestRx = CAN_Interrupt();

    if (TestRx == FAILED) //失败LED2亮
    {
        /* Turn on led connected to PD.07 pin (LD4) */
GPIO_ResetBits(GPIOB, GPIO_Pin_12);
    }
    else //成功LED3亮
    {
/* Turn on led connected to PD.03 pin (LD2) */
GPIO_ResetBits(GPIOB, GPIO_Pin_13);
}
while(1)
    {
    }
}

/*******************************************************************************
* Function Name  : CAN_Polling
* Description : Configures the CAN and transmit and receive by polling
* Input       : None
* Output       : None
* Return       : PASSED if the reception is well done, FAILED in other case
*******************************************************************************/
TestStatus CAN_Polling(void)
{
  CAN_InitTypeDef       CAN_InitStructure;
  CAN_FilterInitTypeDef  CAN_FilterInitStructure;
  CanTxMsg TxMessage;
  CanRxMsg RxMessage;
  u32 i = 0;
  u8 TransmitMailbox;

  /* CAN register init */
  CAN_DeInit(CAN1);
  CAN_StructInit(&CAN_InitStructure);

  /* CAN cell init */
  CAN_InitStructure.CAN_TTCM=DISABLE;
  CAN_InitStructure.CAN_ABOM=DISABLE;
  CAN_InitStructure.CAN_AWUM=DISABLE;
  CAN_InitStructure.CAN_NART=DISABLE;
  CAN_InitStructure.CAN_RFLM=DISABLE;
  CAN_InitStructure.CAN_TXFP=DISABLE;
  CAN_InitStructure.CAN_Mode=CAN_Mode_LoopBack; //工作在环回模式
  CAN_InitStructure.CAN_SJW=CAN_SJW_1tq;
  CAN_InitStructure.CAN_BS1=CAN_BS1_8tq;
  CAN_InitStructure.CAN_BS2=CAN_BS2_7tq;
  CAN_InitStructure.CAN_Prescaler=5;    //  8M/5/(1+8+7)=100k
  CAN_Init(CAN1,&CAN_InitStructure);

  /* CAN filter init */
  CAN_FilterInitStructure.CAN_FilterNumber=0;
  CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;
  CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit;
  CAN_FilterInitStructure.CAN_FilterIdHigh=0x0000;
  CAN_FilterInitStructure.CAN_FilterIdLow=0x0000;
  CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0x0000;
  CAN_FilterInitStructure.CAN_FilterMaskIdLow=0x0000;
  CAN_FilterInitStructure.CAN_FilterFIFOAssignment=0;
  CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;
  CAN_FilterInit(&CAN_FilterInitStructure);

  /* transmit */
  TxMessage.StdId=0x11;
  TxMessage.RTR=CAN_RTR_DATA;
  TxMessage.IDE=CAN_ID_STD;
  TxMessage.DLC=2;
  TxMessage.Data[0]=0xCA;
  TxMessage.Data[1]=0xFE;

  TransmitMailbox=CAN_Transmit(CAN1,&TxMessage);
  i = 0;
  while((CAN_TransmitStatus(CAN1,TransmitMailbox) != CANTXOK) && (i != 0xFF))
  {
i++;
  }

  i = 0;
  while((CAN_MessagePending(CAN1,CAN_FIFO0) < 1) && (i != 0xFF))
  {
i++;
  }

  /* receive */
  RxMessage.StdId=0x00;
  RxMessage.IDE=CAN_ID_STD;
  RxMessage.DLC=0;
  RxMessage.Data[0]=0x00;
  RxMessage.Data[1]=0x00;
  CAN_Receive(CAN1,CAN_FIFO0, &RxMessage);

  if (RxMessage.StdId!=0x11) return FAILED;

  if (RxMessage.IDE!=CAN_ID_STD) return FAILED;

  if (RxMessage.DLC!=2) return FAILED;

  if ((RxMessage.Data[0]<<8|RxMessage.Data[1])!=0xCAFE) return FAILED;

  return PASSED; /* Test Passed */
}

/*******************************************************************************
* Function Name  : CAN_Interrupt
* Description : Configures the CAN and transmit and receive by interruption
* Input       : None
* Output       : None
* Return       : PASSED if the reception is well done, FAILED in other case
*******************************************************************************/
TestStatus CAN_Interrupt(void)
{
  CAN_InitTypeDef       CAN_InitStructure;
  CAN_FilterInitTypeDef  CAN_FilterInitStructure;
  CanTxMsg TxMessage;
  u32 i = 0;

  /* CAN register init */
  CAN_DeInit(CAN1);
  CAN_StructInit(&CAN_InitStructure);

  /* CAN cell init */
  CAN_InitStructure.CAN_TTCM=DISABLE;
  CAN_InitStructure.CAN_ABOM=DISABLE;
  CAN_InitStructure.CAN_AWUM=DISABLE;
  CAN_InitStructure.CAN_NART=DISABLE;
  CAN_InitStructure.CAN_RFLM=DISABLE;
  CAN_InitStructure.CAN_TXFP=DISABLE;
  CAN_InitStructure.CAN_Mode=CAN_Mode_LoopBack;//工作在环回模式
  CAN_InitStructure.CAN_SJW=CAN_SJW_1tq;
  CAN_InitStructure.CAN_BS1=CAN_BS1_8tq;
  CAN_InitStructure.CAN_BS2=CAN_BS2_7tq;
  CAN_InitStructure.CAN_Prescaler=1;  //  8M/1/(1+8+7)=500k
  CAN_Init(CAN1,&CAN_InitStructure);

  /* CAN filter init */
  CAN_FilterInitStructure.CAN_FilterNumber=1;
  CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;
  CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit;
  CAN_FilterInitStructure.CAN_FilterIdHigh=0x0000;
  CAN_FilterInitStructure.CAN_FilterIdLow=0x0000;
  CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0x0000;
  CAN_FilterInitStructure.CAN_FilterMaskIdLow=0x0000;
  CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_FIFO0;
  CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;
  CAN_FilterInit(&CAN_FilterInitStructure);

  /* CAN FIFO0 message pending interrupt enable */
  CAN_ITConfig(CAN1,CAN_IT_FMP0, ENABLE);

  /* transmit 1 message */
  TxMessage.StdId=0x00;
  TxMessage.ExtId=0x1234;
  TxMessage.IDE=CAN_ID_EXT;
  TxMessage.RTR=CAN_RTR_DATA;
  TxMessage.DLC=2;
  TxMessage.Data[0]=0xDE;
  TxMessage.Data[1]=0xCA;
  CAN_Transmit(CAN1,&TxMessage);

  /* initialize the value that will be returned */
  ret = 0xFF;

  /* receive message with interrupt handling */
  i=0;
  while((ret == 0xFF) && (i < 0xFFF))
  {
i++;
  }

  if (i == 0xFFF)
  {
ret=0;
  }

  /* disable interrupt handling */
  CAN_ITConfig(CAN1,CAN_IT_FMP0, DISABLE);

  return (TestStatus)ret;
}

/*******************************************************************************
* Function Name  : USB_LP_CAN_RX0_IRQHandler
* Description : This function handles USB Low Priority or CAN RX0 interrupts
*                requests.
* Input       : None
* Output       : None
* Return       : None
*******************************************************************************/
void USB_LP_CAN1_RX0_IRQHandler(void)
{
  CanRxMsg RxMessage;

  RxMessage.StdId=0x00;
  RxMessage.ExtId=0x00;
  RxMessage.IDE=0;
  RxMessage.DLC=0;
  RxMessage.FMI=0;
  RxMessage.Data[0]=0x00;
  RxMessage.Data[1]=0x00;

  CAN_Receive(CAN1,CAN_FIFO0, &RxMessage);

  if((RxMessage.ExtId==0x1234) && (RxMessage.IDE==CAN_ID_EXT)
   && (RxMessage.DLC==2) && ((RxMessage.Data[1]|RxMessage.Data[0]<<8)==0xDECA))
  {
ret = 1;
  }
  else
  {
ret = 0;
  }
}

只看该作者 · 2011-8-2 10:08

实验内容：通过STM32的USB端口在PC上虚拟一个COM口，当虚拟成功后，可通过串口调试软件
发送控制命令，去点亮板子上相应的LED灯，同时输出调试信息。
代码

虚拟串口.zip (25.64 KB)
在PC机的设备管理器中可看到虚拟出的COM口

串口调试软件的输出状态

只看该作者 · 2011-8-5 13:45

过来看一下

STM32 最小系统板带 CAN 485

精华达人奖章

湍急之河流

七世轮回

技术奇才奖章

晶莹之水滴

常驻人口

技术高手奖章

缘定三生

技术新星奖章

经常做客