陈酿！四年陈的STM32F103外设测试代码！希望对你有帮助~~~

陈酿！四年陈的STM32F103外设测试代码！希望对你有帮助~~~ 精华

[复制链接]

Dylan疾风闪电发布时间：2016-1-7 14:26

文章
文章封面:	-
文章简介:	-

一、前言
  今天在论坛上看到有人在讨论STM32睡眠模式的唤醒，一时兴起，就开始打扫“仓库”了。
结果扫出很多“旧货”，拿来分享给刚接触STM32的新人们！希望对你的学习有所帮助~~~

二、目录

  所有代码的功能使用和描述，均在头文件开头的注释中！（通过点击楼层，直接跳转到目标代码）
注：所有代码均是在例程上改版而来的，所以嵌入自己的程序前需要验证！所有资料都是2012年的，所以部分描述对现有版本不适用！
1）楼层#2：3ADCs_DMA.h  ADC1,2,3：独立模式、单通道、连续转换
  ADC1：通过 DMA1_Channel1 将数据存入 ADC1ConvertedValue 变量地址
  ADC2：用中断 ADC1_2_IRQn 将数据存入 ADC2ConvertedValue 变量
  ADC3：通过 DMA2_Channel5 将数据存入 ADC3ConvertedValue 变量地址
2）楼层#3：ADC_AnalogWatchdog.h
  ADC1：独立模式、单通道、连续转换
  如果ADC转换的模拟电压超出阀值范围，SR的AWD置1可产生中断.
  阀值位于ADC_HTR和ADC_LTR寄存器的最低12个有效位中.
  阀值独立于由ADC_CR2寄存器上的ALIGN位选择的数据对齐模式.  比较是在对齐之前完成的.
3）楼层#4：ADC_RegSimulDualMode.h
  ADC1,2：双ADC同步规则模式
  注意1：不要在2个ADC上转换相同的通道(如果转换两个ADC的相同通道，不可能提供重叠的采样时间)。
  注意2： ADC2的外部触发必须使能，否则只能采集一个数据。
4）楼层#5：ADC_TIMTrigAutoInjection.h
  ADC1：独立模式、单通道、单次转换、外部触发、自动注入
  自动注入如果设置了JAUTO位，在规则组通道之后，注入组通道被自动转换。
5）楼层#6：BKP_Tamper.h
  BKP：保存VBAT掉电前的数据
  当TAMPER引脚上的信号从’0’变成’1’或者从’1’变成’0’
  (取决于备份控制寄存器BKP_CR的TPAL位)，BKP_TamperPinLevelConfig(BKP_TamperPinLevel_Low);//设置侵入检测管脚的有效电平
  会产生一个侵入检测事件。
  侵入检测事件将所有数据备份寄存器内容清除。
  在一个侵入事件被检测到并被清除后，侵入检测引脚TAMPER应该被禁止。
  然后，在再次写入备份数据寄存器前重新用TPE位启动侵入检测功能。
  这样，可以阻止软件在侵入检测引脚上仍然有侵入事件时对备份数据寄存器进行写操作。这相当于对侵入引脚TAMPER进行电平检测。
6）楼层#7：CAN_Example.h
  收发寄存器 RDLR,RDHR,TDLR,TDHR
  例如 CANx->sFIFOMailBox[FIFONumber].RDLR;
7）楼层#9：CM3_BitBand.h
  CM3：BitBand(别名区域)
  use CortexM3 Bit-Band access to perform atomic read-modify-write and read operations on a varaible in SRAM.
  对Bit-band区域某个字节的写操作，Cortex-M3都将自动转换成对相对应比特位的读－修改－写操作。
  对Bit-band区域某个字节的读操作则将转换成相对应比特位的读操作。
  公式：Bit-Band地址= Bit-Band域首地址 + (操作字节的偏移量× 32) + (操作位的偏移量× 4)
                  = Bit-Band域首地址 | (操作字节的偏移量<<5) | (操作位的偏移量<<2)
  内置SRAM区的Bit-Band域首地址为0x22000000
  外设寄存器区的Bit-Band域首地址为0x42000000
8）楼层#10：CM3_ModePrivilege.h
  CM3：特殊模式 (此例未验证成功：__set_PSP()等宏未定义)
  阀值独立于由ADC_CR2寄存器上的ALIGN位选择的数据对齐模式.  比较是在对齐之前完成的.
9）楼层#11：CRC_Example.h
  CRC：以多项式(0x4C11DB7)进行CRC计算得到一个32位的值
10）楼层#12：DAC_2ChTriangleWave.h
DAC：使用不同三角波发生器的同时触发
11）楼层#13：DAC_DMAEscalator.h
  DAC：DMA输出梯形波
12）楼层#14：DAC_DualModeDMASineWave.h
  DAC：双DAC通道转换
  DAC集成了3个供双DAC模式使用的寄存器：DHR8RD、DHR12RD和DHR12LD，
  只需要访问一个寄存器即可完成同时驱动2个DAC通道的操作。
13）楼层#15：DAC_NoiseWave.h
  DAC：噪声生成
  可以利用线性反馈移位寄存器(Linear Feedback Shift Register LFSR)产生幅度变化的伪噪声。
14）楼层#16：DEBUG.h
  printf("...");
15）楼层#17：DMA_ADC_TIM1.h
  DMA：通过DMA将ADC采样反映为TIM1_CH1的脉冲频率(CCR1)
16）楼层#18：DMA_FlashRAM.h
  DMA：从ROM中拷贝数组常量到RAM中 (存在弊端，不复位的情况下可能 FAILED)
17）楼层#19：DMA_FSMC.h
  DMA：通过2个DMA通道，
  将32位数据SRC_Const_Buffer[]从FLASH_ROM写入外设FSMC的SRAM,
  然后从外设FSMC的SRAM以8位DST_Buffer[]逐个读取数据存入 (存在弊端，不复位的情况下可能卡while)
18）楼层#20：EXTI_Example.h
  EXTI：按下PB10(Key4) 翻转绿灯(PF6)上的电平
19）楼层#21：FLASH_Program.h
  FLASH：擦写数据到FLASH地址
20）楼层#22：FLASH_WriteProtection.h
  FLASH：写保护(写保护部分存在问题，无法设置保护)
21）楼层#23：FSMC_NAND.h
  FSMC：(未研究)
22）楼层#24：I2C_M24C02EEPROM.h
  I2C：(ST的I2C问题很多，建议不用，选择IO口模拟)--测试不通过，待调整。《申明：这里只是上传老的资料，描述也是以前的。故对存在问题的代码也不进行优化！》
23）楼层#25：IWDG_Example.h
  IWDG：The IWDG timeout is set to 280 ms,Systick Interrupt is 250ms
  黄灯闪烁，表示每250ms喂狗一次
  亮绿灯，表示系统已经由IWDG复位，resumed from IWDG reset
  按下Keyer4 进入EXTI中断，关闭Systick，使IWDG不能喂狗，系统复位
24）楼层#26：NVIC_CM3LPModes.h
  NVIC：低功耗
25）楼层#27：PWR_STANDBY.h
  PWR：待机模式
26）楼层#28：PWR_STOP.h
  PWR：停机模式
27）楼层#29：SPI_Example.h
  无.

三、结语
  为了便于大家阅读，所以将代码片段上传。
  可以按照每个示例中的“实例应用步骤：”直接复制粘贴，一步到位的进行测试，测试结果也在“4.Watch中观察”中写明。
  闲话不说，大家往下“看”吧！

赞收藏 22 评论60 发布时间：2016-1-7 14:26

60个回答

Dylan疾风闪电回答时间：2016-1-7 15:13:42

/**
******************************************************************************
* @file /FSMC_NAND.h
* @author xd.wu
* @version V1.0
* @date 2012-4-17
* @brief FSMC：(未研究)
use the FSMC firmware library and an associate driver to perform erase/read/write operations
on the NAND512W3A2CN6E memory mounted on STM3210E-LK board.
******************************************************************************
*用途：将某些掉电保持的数据存入FLASH，供下次上电检测
*/
/*实例应用步骤：
//1."main.cpp"调用fmain()
//2.Watch中观察
LED
TxBuffer,RxBuffer
*/
#ifndef __FSMC_NAND_H
#define __FSMC_NAND_H
/* Includes ------------------------------------------------------------------*/
#include "std32periph.h"
/* Private typedef -----------------------------------------------------------*/
typedef struct
{
u8 Maker_ID;
u8 Device_ID;
u8 Third_ID;
u8 Fourth_ID;
}NAND_IDTypeDef;
typedef struct
{
u16 Block;
u16 Page;
} NAND_ADDRESS;
/* Private define ------------------------------------------------------------*/
#define BUFFER_SIZE 0x80//0x1000
#define NAND_HY_ManufactureCode 0xAD
#define NAND_HY_DeviceCode 0xF1
#define NAND_HY_3rdCode 0x80
#define NAND_HY_4thCode 0x1D
#define FSMC_Bank_NAND FSMC_Bank2_NAND
#define Bank_NAND_ADDR Bank2_NAND_ADDR
#define Bank2_NAND_ADDR ((u32)0x70000000)
/* Private macro -------------------------------------------------------------*/
/*row address is in the unit of page
for HY nand data sheet --> address sequence --> A0~A11 as tail --> discard 1st & 2nd address cycle*/
#define ROW_ADDRESS (Address.Page + Address.Block * NAND_BLOCK_SIZE)
/* NAND Area definition for STM3210E-LK Board */
#define CMD_AREA (u32)(1<<16) /* A16 = CLE high */
#define ADDR_AREA (u32)(1<<17) /* A17 = ALE high */
#define DATA_AREA ((u32)0x00000000)
/* FSMC NAND memory command */
#define NAND_CMD_AREA_A ((u8)0x00)
//#define NAND_CMD_AREA_B ((u8)0x01)
//#define NAND_CMD_AREA_C ((u8)0x50)
#define NAND_CMD_AREA_TRUE1 ((u8)0x30)
#define NAND_CMD_WRITE0 ((u8)0x80)
#define NAND_CMD_WRITE_TRUE1 ((u8)0x10)
#define NAND_CMD_ERASE0 ((u8)0x60)
#define NAND_CMD_ERASE1 ((u8)0xD0)
#define NAND_CMD_READID ((u8)0x90)
#define NAND_CMD_STATUS ((u8)0x70)
#define NAND_CMD_LOCK_STATUS ((u8)0x7A)
#define NAND_CMD_RESET ((u8)0xFF)
/* NAND memory status */
#define NAND_VALID_ADDRESS ((u32)0x00000100)
#define NAND_INVALID_ADDRESS ((u32)0x00000200)
#define NAND_TIMEOUT_ERROR ((u32)0x00000400)
#define NAND_BUSY ((u32)0x00000000)
#define NAND_ERROR ((u32)0x00000001) // bit0
#define NAND_READY ((u32)0x00000040) // bit6
/* FSMC NAND memory parameters */
#define NAND_PAGE_SIZE ((u16)0x0800) /* 2k bytes per page without Spare Area */
#define NAND_BLOCK_SIZE ((u16)0x0040) /* 64 pages per block */
#define NAND_SPARE_AREA_SIZE ((u16)0x0040) /* last 64 bytes as spare area */
#define NAND_MAX_BLOCK ((u16)0x0400) /* max 1024 block */
/* FSMC NAND memory address computation */
#define ADDR_1st_CYCLE(ADDR) (u8)((ADDR)& 0xFF) /* 1st addressing cycle */
#define ADDR_2nd_CYCLE(ADDR) (u8)(((ADDR)& 0xFF00) >> 8) /* 2nd addressing cycle */
#define ADDR_3rd_CYCLE(ADDR) (u8)(((ADDR)& 0xFF0000) >> 16) /* 3rd addressing cycle */
#define ADDR_4th_CYCLE(ADDR) (u8)(((ADDR)& 0xFF000000) >> 24) /* 4th addressing cycle */
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
u8 page_data[NAND_PAGE_SIZE]; /*for temparoily hold the page data*/
u8 page_data_tmp; /* store 1st 2k main array data(flush) */
NAND_IDTypeDef NAND_ID;
NAND_ADDRESS WriteReadAddr;
u8 TxBuffer[BUFFER_SIZE], RxBuffer[BUFFER_SIZE];
vu32 PageNumber = 2, WriteReadStatus = 0, status= 0;
u32 j = 0;
/* Private functions ---------------------------------------------------------*/
void FSMC_NAND_Init(void);
void FSMC_NAND_ReadID(NAND_IDTypeDef* NAND_ID);
u32 FSMC_NAND_ProgramPage(u8 *pBuffer, NAND_ADDRESS Address, u32 NumPageToWrite);
u32 FSMC_NAND_ReadPage (u8 *pBuffer, NAND_ADDRESS Address, u32 NumPageToRead);
u32 FSMC_NAND_WriteSpareArea(u8 *pBuffer, NAND_ADDRESS Address, u32 NumSpareAreaTowrite);
u32 FSMC_NAND_ReadSpareArea(u8 *pBuffer, NAND_ADDRESS Address, u32 NumSpareAreaToRead);
u32 FSMC_NAND_EraseBlock(NAND_ADDRESS Address);
u32 FSMC_NAND_Reset(void);
u32 FSMC_NAND_GetStatus(void);
u32 FSMC_NAND_ReadStatus(void);
u32 FSMC_NAND_AddressIncrement(NAND_ADDRESS* Address);
void FSMC_NAND_Init(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
FSMC_NANDInitTypeDef FSMC_NANDInitStructure;
FSMC_NAND_PCCARDTimingInitTypeDef p;
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD | RCC_APB2Periph_GPIOE |
RCC_APB2Periph_GPIOF | RCC_APB2Periph_GPIOG, ENABLE);
/*-- GPIO Configuration ------------------------------------------------------*/
/* CLE, ALE, D0->D3, NOE, NWE and NCE2 NAND pin configuration */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11 | GPIO_Pin_12 | GPIO_Pin_14 | GPIO_Pin_15 |
GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_4 | GPIO_Pin_5 |
GPIO_Pin_7;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_Init(GPIOD, &GPIO_InitStructure);
/* D4->D7 NAND pin configuration */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7 | GPIO_Pin_8 | GPIO_Pin_9 | GPIO_Pin_10;
GPIO_Init(GPIOE, &GPIO_InitStructure);
/* NWAIT NAND pin configuration */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
GPIO_Init(GPIOD, &GPIO_InitStructure);
/* INT2 NAND pin configuration */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
GPIO_Init(GPIOG, &GPIO_InitStructure);
/*-- FSMC Configuration ------------------------------------------------------*/
p.FSMC_SetupTime = 0x1;
p.FSMC_WaitSetupTime = 0x3;
p.FSMC_HoldSetupTime = 0x2;
p.FSMC_HiZSetupTime = 0x1;
FSMC_NANDInitStructure.FSMC_Bank = FSMC_Bank2_NAND;
FSMC_NANDInitStructure.FSMC_Waitfeature = FSMC_Waitfeature_Enable;
FSMC_NANDInitStructure.FSMC_MemoryDataWidth = FSMC_MemoryDataWidth_8b;
FSMC_NANDInitStructure.FSMC_ECC = FSMC_ECC_Enable;
FSMC_NANDInitStructure.FSMC_ECCPageSize = FSMC_ECCPageSize_512Bytes;
//FSMC_NANDInitStructure.FSMC_AddressLowMapping = FSMC_AddressLowMapping_Direct;
FSMC_NANDInitStructure.FSMC_TCLRSetupTime = 0x00;
FSMC_NANDInitStructure.FSMC_TARSetupTime = 0x00;
FSMC_NANDInitStructure.FSMC_CommonSpaceTimingStruct = &p;
FSMC_NANDInitStructure.FSMC_AttributeSpaceTimingStruct = &p;
FSMC_NANDInit(&FSMC_NANDInitStructure);
/* FSMC NAND Bank Cmd Test */
FSMC_NANDCmd(FSMC_Bank2_NAND, ENABLE);
}
void FSMC_NAND_ReadID(NAND_IDTypeDef* NAND_ID)
{
u32 data = 0;
/* writing 90h to the command register, followed by an address input of 00h*/
*(vu8 *)(Bank_NAND_ADDR | CMD_AREA) = 0x90;
*(vu8 *)(Bank_NAND_ADDR | ADDR_AREA) = 0x00;
/* Four read cycles sequentially output the 1st cycle (ADh), and 2nd cycle (the device code) and
3rd cycle ID, 4th cycle ID */
data = *(vu32 *)(Bank_NAND_ADDR | DATA_AREA);
NAND_ID->Maker_ID = ADDR_1st_CYCLE (data);
NAND_ID->Device_ID = ADDR_2nd_CYCLE (data);
NAND_ID->Third_ID = ADDR_3rd_CYCLE (data);
NAND_ID->Fourth_ID = ADDR_4th_CYCLE (data);
}
u32 FSMC_NAND_ProgramPage(u8 *pBuffer, NAND_ADDRESS Address, u32 NumPageToWrite)
{
u32 index = 0x00, numpagewritten = 0x00, addressstatus = NAND_VALID_ADDRESS;
u32 status = NAND_READY, size = 0x00;
while((NumPageToWrite != 0x00) && (addressstatus == NAND_VALID_ADDRESS) && (status == NAND_READY))
{
/* begins by inputting the Serial Data Input command (80h)*/
*(vu8 *)(Bank_NAND_ADDR | CMD_AREA) = NAND_CMD_WRITE0;
/* followed by the four cycle address inputs */
*(vu8 *)(Bank_NAND_ADDR | ADDR_AREA) = 0x00;
*(vu8 *)(Bank_NAND_ADDR | ADDR_AREA) = 0x00;
*(vu8 *)(Bank_NAND_ADDR | ADDR_AREA) = ADDR_1st_CYCLE(ROW_ADDRESS);
*(vu8 *)(Bank_NAND_ADDR | ADDR_AREA) = ADDR_2nd_CYCLE(ROW_ADDRESS);
/* Calculate number of write operatin (the size of main array to be programed)*/
size = NAND_PAGE_SIZE + (NAND_PAGE_SIZE * numpagewritten);
/* then serial data and tADL of min=100ns should be guaranteed */
/* tADL is the time from the WE rising edge of final address cycle
to the WE rising of first data cycle. */
for(; index < size; index++)
{
*(vu8 *)(Bank_NAND_ADDR | DATA_AREA) = pBuffer[index];
}
*(vu8 *)(Bank_NAND_ADDR | CMD_AREA) = NAND_CMD_WRITE_TRUE1;
/* PG.6(FSMC_INT2) connect to R/!B of NAND flash */
while( GPIO_ReadInputDataBit(GPIOG, GPIO_Pin_6) == 0 );
/* Check status for successful operation */
status = FSMC_NAND_GetStatus();
if(status == NAND_READY)
{
numpagewritten++;
NumPageToWrite--;
/* Calculate Next small page Address */
addressstatus = FSMC_NAND_AddressIncrement(&Address);
}
}
return (status | addressstatus);
}
u32 FSMC_NAND_ReadPage(u8 *pBuffer, NAND_ADDRESS Address, u32 NumPageToRead)
{
u32 index = 0x00, numpageread = 0x00, addressstatus = NAND_VALID_ADDRESS;
u32 status = NAND_READY, size = 0x00;
while((NumPageToRead != 0x0) && (addressstatus == NAND_VALID_ADDRESS))
{
/* Page Read command and page address */
*(vu8 *)(Bank_NAND_ADDR | CMD_AREA) = NAND_CMD_AREA_A;
*(vu8 *)(Bank_NAND_ADDR | ADDR_AREA) = 0x00;
*(vu8 *)(Bank_NAND_ADDR | ADDR_AREA) = 0x00;
*(vu8 *)(Bank_NAND_ADDR | ADDR_AREA) = ADDR_1st_CYCLE(ROW_ADDRESS);
*(vu8 *)(Bank_NAND_ADDR | ADDR_AREA) = ADDR_2nd_CYCLE(ROW_ADDRESS);
*(vu8 *)(Bank_NAND_ADDR | CMD_AREA) = NAND_CMD_AREA_TRUE1;
/* PG.6(FSMC_INT2) connect to R/!B of NAND flash */
while( GPIO_ReadInputDataBit(GPIOG, GPIO_Pin_6) == 0 );
/* Calculate the size */
size = NAND_PAGE_SIZE + (NAND_PAGE_SIZE * numpageread);
/* Get Data into Buffer */
for(; index < size; index++)
{
pBuffer[index]= *(vu8 *)(Bank_NAND_ADDR | DATA_AREA);
}
numpageread++;
NumPageToRead--;
/* Calculate page address */
addressstatus = FSMC_NAND_AddressIncrement(&Address);
}
status = FSMC_NAND_GetStatus();
return (status | addressstatus);
}
u32 FSMC_NAND_WriteSpareArea(u8 *pBuffer, NAND_ADDRESS Address, u32 NumSpareAreaTowrite)
{
u32 index = 0x00, numsparesreawritten = 0x00, addressstatus = NAND_VALID_ADDRESS;
u32 status = NAND_READY, size = 0x00;
while((NumSpareAreaTowrite != 0x00) && (addressstatus == NAND_VALID_ADDRESS) && (status == NAND_READY))
{
/* read out main array data into page_data[] firstly */
FSMC_NAND_ReadPage(page_data, Address, 1);
/* Page write Spare area command and address */
*(vu8 *)(Bank_NAND_ADDR | CMD_AREA) = NAND_CMD_WRITE0;
*(vu8 *)(Bank_NAND_ADDR | ADDR_AREA) = 0x00;
*(vu8 *)(Bank_NAND_ADDR | ADDR_AREA) = 0x00;
*(vu8 *)(Bank_NAND_ADDR | ADDR_AREA) = ADDR_1st_CYCLE(ROW_ADDRESS);
*(vu8 *)(Bank_NAND_ADDR | ADDR_AREA) = ADDR_2nd_CYCLE(ROW_ADDRESS);
/* PG.6(FSMC_INT2) connect to R/!B of NAND flash */
while( GPIO_ReadInputDataBit(GPIOG, GPIO_Pin_6) == 0 );
/* total number of write operation */
size = (NAND_SPARE_AREA_SIZE+NAND_PAGE_SIZE) + ((NAND_SPARE_AREA_SIZE+NAND_PAGE_SIZE) * numsparesreawritten);
/* Write the data */
for(; index < size; index++)
{
if (index < size - NAND_SPARE_AREA_SIZE)
*(vu8 *)(Bank_NAND_ADDR | DATA_AREA) = page_data[index - (NAND_PAGE_SIZE + NAND_SPARE_AREA_SIZE)*numsparesreawritten];
else
*(vu8 *)(Bank_NAND_ADDR | DATA_AREA) = pBuffer[index - NAND_PAGE_SIZE * (numsparesreawritten+1)];
}
*(vu8 *)(Bank_NAND_ADDR | CMD_AREA) = NAND_CMD_WRITE_TRUE1;
/* Check status for successful operation */
status = FSMC_NAND_GetStatus();
if(status == NAND_READY)
{
numsparesreawritten++;
NumSpareAreaTowrite--;
/* Calculate Next page Address */
addressstatus = FSMC_NAND_AddressIncrement(&Address);
}
}
return (status | addressstatus);
}
u32 FSMC_NAND_ReadSpareArea(u8 *pBuffer, NAND_ADDRESS Address, u32 NumSpareAreaToRead)
{
u32 numsparearearead = 0x00, index = 0x00, addressstatus = NAND_VALID_ADDRESS;
u32 status = NAND_READY, size = 0x00;
while((NumSpareAreaToRead != 0x0) && (addressstatus == NAND_VALID_ADDRESS))
{
/* Page Read command and page address */
*(vu8 *)(Bank_NAND_ADDR | CMD_AREA) = NAND_CMD_AREA_A; // no area B/C for HY
*(vu8 *)(Bank_NAND_ADDR | ADDR_AREA) = 0x00;
*(vu8 *)(Bank_NAND_ADDR | ADDR_AREA) = 0x00;
*(vu8 *)(Bank_NAND_ADDR | ADDR_AREA) = ADDR_1st_CYCLE(ROW_ADDRESS);
*(vu8 *)(Bank_NAND_ADDR | ADDR_AREA) = ADDR_2nd_CYCLE(ROW_ADDRESS);
*(vu8 *)(Bank_NAND_ADDR | CMD_AREA) = NAND_CMD_AREA_TRUE1;
/* PG.6(FSMC_INT2) connect to R/!B of NAND flash */
while( GPIO_ReadInputDataBit(GPIOG, GPIO_Pin_6) == 0 );
/* total number of write operation */
size = (NAND_SPARE_AREA_SIZE+NAND_PAGE_SIZE) + ((NAND_SPARE_AREA_SIZE+NAND_PAGE_SIZE) * numsparearearead);//
/* Get page data into temp-space and get spare data into Buffer */
for ( ;index < size; index++)
{
if (index < size - NAND_SPARE_AREA_SIZE)
page_data_tmp = *(vu8 *)(Bank_NAND_ADDR | DATA_AREA);
else
pBuffer[index - NAND_PAGE_SIZE * (numsparearearead+1)] = *(vu8 *)(Bank_NAND_ADDR | DATA_AREA);
}
numsparearearead++;
NumSpareAreaToRead--;
/* Calculate page address */
addressstatus = FSMC_NAND_AddressIncrement(&Address);
}
status = FSMC_NAND_GetStatus();
return (status | addressstatus);
}
u32 FSMC_NAND_EraseBlock(NAND_ADDRESS Address)
{
*(vu8 *)(Bank_NAND_ADDR | CMD_AREA) = NAND_CMD_ERASE0;
*(vu8 *)(Bank_NAND_ADDR | ADDR_AREA) = ADDR_1st_CYCLE(ROW_ADDRESS);
*(vu8 *)(Bank_NAND_ADDR | ADDR_AREA) = ADDR_2nd_CYCLE(ROW_ADDRESS);
*(vu8 *)(Bank_NAND_ADDR | CMD_AREA) = NAND_CMD_ERASE1;
/* PG.6(FSMC_INT2) connect to R/!B of NAND flash */
while( GPIO_ReadInputDataBit(GPIOG, GPIO_Pin_6) == 0 );
return (FSMC_NAND_GetStatus());
}
u32 FSMC_NAND_Reset(void)
{
*(vu8 *)(Bank_NAND_ADDR | CMD_AREA) = NAND_CMD_RESET;
return (NAND_READY);
}
u32 FSMC_NAND_GetStatus(void)
{
u32 timeout = 0x1000000, status = NAND_READY;
status = FSMC_NAND_ReadStatus();
/* Wait for a NAND operation to complete or a TIMEOUT to occur */
while ((status != NAND_READY) &&( timeout != 0x00))
{
status = FSMC_NAND_ReadStatus();
timeout --;
}
if(timeout == 0x00)
{
status = NAND_TIMEOUT_ERROR;
}
/* Return the operation status */
return (status);
}
u32 FSMC_NAND_ReadStatus(void)
{
u32 data = 0x00, status = NAND_BUSY;
/* Read status operation ------------------------------------ */
*(vu8 *)(Bank_NAND_ADDR | CMD_AREA) = NAND_CMD_STATUS;
data = *(vu8 *)(Bank_NAND_ADDR);
if((data & NAND_ERROR) == NAND_ERROR)
{
status = NAND_ERROR;
}
else if((data & NAND_READY) == NAND_READY)
{
status = NAND_READY;
}
else
{
status = NAND_BUSY;
}
return (status);
}
u32 FSMC_NAND_AddressIncrement(NAND_ADDRESS* Address)
{
u32 status = NAND_VALID_ADDRESS;
Address->Page++;
if(Address->Page == NAND_BLOCK_SIZE)
{
Address->Page = 0;
Address->Block++;
if(Address->Block == NAND_MAX_BLOCK)
{
status = NAND_INVALID_ADDRESS;
}
}
return (status);
}
void Fill_Buffer(u8 *pBuffer, u16 BufferLenght, u32 Offset)
{
u16 IndexTmp = 0;
/* Put in global buffer same values */
for (IndexTmp = 0; IndexTmp < BufferLenght; IndexTmp++ )
{
pBuffer[IndexTmp] = IndexTmp + Offset;
}
}
void fmain(void)
{
RCC_HSEConf(9);//72M
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOF, ENABLE);
/* Configure PF.06, PF.07 and PF.08 as Output push-pull */
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7 | GPIO_Pin_8;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_Init(GPIOF, &GPIO_InitStructure);
/* Enable the FSMC Clock */
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_FSMC, ENABLE);
/* FSMC Initialization */
FSMC_NAND_Init();
/* NAND read ID command */
FSMC_NAND_ReadID(&NAND_ID);
/* Verify the NAND ID */
if((NAND_ID.Maker_ID == NAND_HY_ManufactureCode) && (NAND_ID.Device_ID == NAND_HY_DeviceCode))
{
/* NAND memory address to write to */
WriteReadAddr.Block = 0x00;
WriteReadAddr.Page = 0x00;
/* Erase the NAND first Block */
status = FSMC_NAND_EraseBlock(WriteReadAddr);
/* Write data to FSMC NAND memory */
/* Fill the buffer to send */
Fill_Buffer(TxBuffer, BUFFER_SIZE , 0x66);
status = FSMC_NAND_WriteSpareArea(TxBuffer, WriteReadAddr, PageNumber);
/* Read back the written data */
status = FSMC_NAND_ReadSpareArea(RxBuffer, WriteReadAddr, PageNumber);
/* Verify the written data */
for(j = 0; j < BUFFER_SIZE; j++)
{
if(TxBuffer[j] != RxBuffer[j])
{
WriteReadStatus++;
}
}
if (WriteReadStatus == 0)
{
GPIO_SetBits(GPIOF, GPIO_Pin_6);//执行结果
}
else
{
GPIO_SetBits(GPIOF, GPIO_Pin_7);
}
}
else
{
GPIO_SetBits(GPIOF, GPIO_Pin_8);
}
}
#endif
/******************* (C) COPYRIGHT 2008 STMicroelectronics *****END OF FILE****/

复制代码

赞评论

Dylan疾风闪电回答时间：2016-1-7 15:19:38

/**
******************************************************************************
* @file /SPI_Example.h
* @author xd.wu
* @version V1.0
* @date 2012-5-16
* @brief SPI：
******************************************************************************
*用途：
*/
/*实例应用步骤：
//1."main.cpp"调用fmain()
//2.Watch中观察
Tx_Buffer:Rx_Buffer
*/
#ifndef __SPI_EXAMPLE_H
#define __SPI_EXAMPLE_H
/* Includes ------------------------------------------------------------------*/
#include "std32periph.h"
/* Private typedef -----------------------------------------------------------*/
typedef enum {FAILED = 0, PASSED = !FAILED} TestStatus;
/* Private define ------------------------------------------------------------*/
#define GPIO_CS GPIOB
#define RCC_CS RCC_APB2Periph_GPIOB
#define Pin_CS GPIO_Pin_2
#define SPI_FLASH_CS_LOW() GPIO_ResetBits(GPIO_CS, Pin_CS)
#define SPI_FLASH_CS_HIGH() GPIO_SetBits(GPIO_CS, Pin_CS)
#define FLASH_WriteAddress 0x700000
#define FLASH_ReadAddress FLASH_WriteAddress
#define FLASH_SectorToErase FLASH_WriteAddress
#define M25P64_FLASH_ID 0x202017
#define BufferSize (countof(Tx_Buffer)-1)
#define SPI_FLASH_PageSize 0x100
#define WRITE 0x02 /* Write to Memory instruction */
#define WRSR 0x01 /* Write Status Register instruction */
#define WREN 0x06 /* Write enable instruction */
#define READ 0x03 /* Read from Memory instruction */
#define RDSR 0x05 /* Read Status Register instruction */
#define RDID 0x9F /* Read identification */
#define SE 0xD8 /* Sector Erase instruction */
#define BE 0xC7 /* Bulk Erase instruction */
#define WIP_Flag 0x01 /* Write In Progress (WIP) flag */
#define Dummy_Byte 0xA5
/* Private macro -------------------------------------------------------------*/
#define countof(a) (sizeof(a) / sizeof(*(a)))
/* Private variables ---------------------------------------------------------*/
u8 Tx_Buffer[] = "STM32F10x SPI Firmware Library Example: communication with an M25P64 SPI FLASH";
u8 Index, Rx_Buffer[BufferSize];
volatile TestStatus TransferStatus1 = FAILED, TransferStatus2 = PASSED;
vu32 FLASH_ID = 0;
/* Private functions ---------------------------------------------------------*/
TestStatus Buffercmp(u8* pBuffer1, u8* pBuffer2, u16 BufferLength);
/*----- High layer function -----*/
void SPI_FLASH_Init(void);
void SPI_FLASH_SectorErase(u32 SectorAddr);
void SPI_FLASH_BulkErase(void);
void SPI_FLASH_PageWrite(u8* pBuffer, u32 WriteAddr, u16 NumByteToWrite);
void SPI_FLASH_BufferWrite(u8* pBuffer, u32 WriteAddr, u16 NumByteToWrite);
void SPI_FLASH_BufferRead(u8* pBuffer, u32 ReadAddr, u16 NumByteToRead);
u32 SPI_FLASH_ReadID(void);
void SPI_FLASH_StartReadSequence(u32 ReadAddr);
/*----- Low layer function -----*/
u8 SPI_FLASH_ReadByte(void);
u8 SPI_FLASH_SendByte(u8 byte);
u16 SPI_FLASH_SendHalfWord(u16 HalfWord);
void SPI_FLASH_WriteEnable(void);
void SPI_FLASH_WaitForWriteEnd(void);
void fmain(void)
{
RCC_HSEConf(9);//72M
/* Initialize the SPI FLASH driver */
SPI_FLASH_Init();
/* Perform a write in the Flash followed by a read of the written data */
/* Erase SPI FLASH Sector to write on */
SPI_FLASH_SectorErase(FLASH_SectorToErase);
/* Write Tx_Buffer data to SPI FLASH memory */
SPI_FLASH_BufferWrite(Tx_Buffer, FLASH_WriteAddress, BufferSize);
/* Read data from SPI FLASH memory */
SPI_FLASH_BufferRead(Rx_Buffer, FLASH_ReadAddress, BufferSize);
/* Check the corectness of written dada */
TransferStatus1 = Buffercmp(Tx_Buffer, Rx_Buffer, BufferSize);
/* TransferStatus1 = PASSED, if the transmitted and received data by SPI1
are the same */
/* TransferStatus1 = FAILED, if the transmitted and received data by SPI1
are different */
/* Perform an erase in the Flash followed by a read of the written data */
/* Erase SPI FLASH Sector to write on */
SPI_FLASH_SectorErase(FLASH_SectorToErase);
/* Read data from SPI FLASH memory */
SPI_FLASH_BufferRead(Rx_Buffer, FLASH_ReadAddress, BufferSize);
/* Check the corectness of erasing operation dada */
for (Index = 0; Index < BufferSize; Index++)
{
if (Rx_Buffer[Index] != 0xFF)
{
TransferStatus2 = FAILED;
}
}
/* TransferStatus2 = PASSED, if the specified sector part is erased */
/* TransferStatus2 = FAILED, if the specified sector part is not well erased */
}
void SPI_FLASH_Init(void)
{
RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1 | RCC_APB2Periph_GPIOA |
RCC_CS, ENABLE);
GPIO_InitTypeDef GPIO_InitStructure;
/* Configure SPI1 pins: SCK, MISO and MOSI */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
/* Configure I/O for Flash Chip select */
GPIO_InitStructure.GPIO_Pin = Pin_CS;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_Init(GPIO_CS, &GPIO_InitStructure);
/* Deselect the FLASH: Chip Select high */
SPI_FLASH_CS_HIGH();
/* SPI1 configuration */
SPI_InitTypeDef SPI_InitStructure;
SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;
SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;
SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_4;
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
SPI_InitStructure.SPI_CRCPolynomial = 7;
SPI_Init(SPI1, &SPI_InitStructure);
/* Enable SPI1 */
SPI_Cmd(SPI1, ENABLE);
}
void SPI_FLASH_SectorErase(u32 SectorAddr)
{
/* Send write enable instruction */
SPI_FLASH_WriteEnable();
/* Sector Erase */
/* Select the FLASH: Chip Select low */
SPI_FLASH_CS_LOW();
/* Send Sector Erase instruction */
SPI_FLASH_SendByte(SE);
/* Send SectorAddr high nibble address byte */
SPI_FLASH_SendByte((SectorAddr & 0xFF0000) >> 16);
/* Send SectorAddr medium nibble address byte */
SPI_FLASH_SendByte((SectorAddr & 0xFF00) >> 8);
/* Send SectorAddr low nibble address byte */
SPI_FLASH_SendByte(SectorAddr & 0xFF);
/* Deselect the FLASH: Chip Select high */
SPI_FLASH_CS_HIGH();
/* Wait the end of Flash writing */
SPI_FLASH_WaitForWriteEnd();
}
void SPI_FLASH_BulkErase(void)
{
/* Send write enable instruction */
SPI_FLASH_WriteEnable();
/* Bulk Erase */
/* Select the FLASH: Chip Select low */
SPI_FLASH_CS_LOW();
/* Send Bulk Erase instruction */
SPI_FLASH_SendByte(BE);
/* Deselect the FLASH: Chip Select high */
SPI_FLASH_CS_HIGH();
/* Wait the end of Flash writing */
SPI_FLASH_WaitForWriteEnd();
}
void SPI_FLASH_PageWrite(u8* pBuffer, u32 WriteAddr, u16 NumByteToWrite)
{
/* Enable the write access to the FLASH */
SPI_FLASH_WriteEnable();
/* Select the FLASH: Chip Select low */
SPI_FLASH_CS_LOW();
/* Send "Write to Memory " instruction */
SPI_FLASH_SendByte(WRITE);
/* Send WriteAddr high nibble address byte to write to */
SPI_FLASH_SendByte((WriteAddr & 0xFF0000) >> 16);
/* Send WriteAddr medium nibble address byte to write to */
SPI_FLASH_SendByte((WriteAddr & 0xFF00) >> 8);
/* Send WriteAddr low nibble address byte to write to */
SPI_FLASH_SendByte(WriteAddr & 0xFF);
/* while there is data to be written on the FLASH */
while (NumByteToWrite--)
{
/* Send the current byte */
SPI_FLASH_SendByte(*pBuffer);
/* Point on the next byte to be written */
pBuffer++;
}
/* Deselect the FLASH: Chip Select high */
SPI_FLASH_CS_HIGH();
/* Wait the end of Flash writing */
SPI_FLASH_WaitForWriteEnd();
}
void SPI_FLASH_BufferWrite(u8* pBuffer, u32 WriteAddr, u16 NumByteToWrite)
{
u8 NumOfPage = 0, NumOfSingle = 0, Addr = 0, count = 0, temp = 0;
Addr = WriteAddr % SPI_FLASH_PageSize;
count = SPI_FLASH_PageSize - Addr;
NumOfPage = NumByteToWrite / SPI_FLASH_PageSize;
NumOfSingle = NumByteToWrite % SPI_FLASH_PageSize;
if (Addr == 0) /* WriteAddr is SPI_FLASH_PageSize aligned */
{
if (NumOfPage == 0) /* NumByteToWrite < SPI_FLASH_PageSize */
{
SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumByteToWrite);
}
else /* NumByteToWrite > SPI_FLASH_PageSize */
{
while (NumOfPage--)
{
SPI_FLASH_PageWrite(pBuffer, WriteAddr, SPI_FLASH_PageSize);
WriteAddr += SPI_FLASH_PageSize;
pBuffer += SPI_FLASH_PageSize;
}
SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumOfSingle);
}
}
else /* WriteAddr is not SPI_FLASH_PageSize aligned */
{
if (NumOfPage == 0) /* NumByteToWrite < SPI_FLASH_PageSize */
{
if (NumOfSingle > count) /* (NumByteToWrite + WriteAddr) > SPI_FLASH_PageSize */
{
temp = NumOfSingle - count;
SPI_FLASH_PageWrite(pBuffer, WriteAddr, count);
WriteAddr += count;
pBuffer += count;
SPI_FLASH_PageWrite(pBuffer, WriteAddr, temp);
}
else
{
SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumByteToWrite);
}
}
else /* NumByteToWrite > SPI_FLASH_PageSize */
{
NumByteToWrite -= count;
NumOfPage = NumByteToWrite / SPI_FLASH_PageSize;
NumOfSingle = NumByteToWrite % SPI_FLASH_PageSize;
SPI_FLASH_PageWrite(pBuffer, WriteAddr, count);
WriteAddr += count;
pBuffer += count;
while (NumOfPage--)
{
SPI_FLASH_PageWrite(pBuffer, WriteAddr, SPI_FLASH_PageSize);
WriteAddr += SPI_FLASH_PageSize;
pBuffer += SPI_FLASH_PageSize;
}
if (NumOfSingle != 0)
{
SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumOfSingle);
}
}
}
}
void SPI_FLASH_BufferRead(u8* pBuffer, u32 ReadAddr, u16 NumByteToRead)
{
/* Select the FLASH: Chip Select low */
SPI_FLASH_CS_LOW();
/* Send "Read from Memory " instruction */
SPI_FLASH_SendByte(READ);
/* Send ReadAddr high nibble address byte to read from */
SPI_FLASH_SendByte((ReadAddr & 0xFF0000) >> 16);
/* Send ReadAddr medium nibble address byte to read from */
SPI_FLASH_SendByte((ReadAddr& 0xFF00) >> 8);
/* Send ReadAddr low nibble address byte to read from */
SPI_FLASH_SendByte(ReadAddr & 0xFF);
while (NumByteToRead--) /* while there is data to be read */
{
/* Read a byte from the FLASH */
*pBuffer = SPI_FLASH_SendByte(Dummy_Byte);
/* Point to the next location where the byte read will be saved */
pBuffer++;
}
/* Deselect the FLASH: Chip Select high */
SPI_FLASH_CS_HIGH();
}
u32 SPI_FLASH_ReadID(void)
{
u32 Temp = 0, Temp0 = 0, Temp1 = 0, Temp2 = 0;
/* Select the FLASH: Chip Select low */
SPI_FLASH_CS_LOW();
/* Send "RDID " instruction */
SPI_FLASH_SendByte(0x9F);
/* Read a byte from the FLASH */
Temp0 = SPI_FLASH_SendByte(Dummy_Byte);
/* Read a byte from the FLASH */
Temp1 = SPI_FLASH_SendByte(Dummy_Byte);
/* Read a byte from the FLASH */
Temp2 = SPI_FLASH_SendByte(Dummy_Byte);
/* Deselect the FLASH: Chip Select high */
SPI_FLASH_CS_HIGH();
Temp = (Temp0 << 16) | (Temp1 << 8) | Temp2;
return Temp;
}
void SPI_FLASH_StartReadSequence(u32 ReadAddr)
{
/* Select the FLASH: Chip Select low */
SPI_FLASH_CS_LOW();
/* Send "Read from Memory " instruction */
SPI_FLASH_SendByte(READ);
/* Send the 24-bit address of the address to read from -----------------------*/
/* Send ReadAddr high nibble address byte */
SPI_FLASH_SendByte((ReadAddr & 0xFF0000) >> 16);
/* Send ReadAddr medium nibble address byte */
SPI_FLASH_SendByte((ReadAddr& 0xFF00) >> 8);
/* Send ReadAddr low nibble address byte */
SPI_FLASH_SendByte(ReadAddr & 0xFF);
}
u8 SPI_FLASH_ReadByte(void)
{
return (SPI_FLASH_SendByte(Dummy_Byte));
}
u8 SPI_FLASH_SendByte(u8 byte)
{
/* Loop while DR register in not emplty */
while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET);
/* Send byte through the SPI1 peripheral */
SPI_I2S_SendData(SPI1, byte);
/* Wait to receive a byte */
while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET);
/* Return the byte read from the SPI bus */
return SPI_I2S_ReceiveData(SPI1);
}
u16 SPI_FLASH_SendHalfWord(u16 HalfWord)
{
/* Loop while DR register in not emplty */
while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET);
/* Send Half Word through the SPI1 peripheral */
SPI_I2S_SendData(SPI1, HalfWord);
/* Wait to receive a Half Word */
while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET);
/* Return the Half Word read from the SPI bus */
return SPI_I2S_ReceiveData(SPI1);
}
void SPI_FLASH_WriteEnable(void)
{
/* Select the FLASH: Chip Select low */
SPI_FLASH_CS_LOW();
/* Send "Write Enable" instruction */
SPI_FLASH_SendByte(WREN);
/* Deselect the FLASH: Chip Select high */
SPI_FLASH_CS_HIGH();
}
void SPI_FLASH_WaitForWriteEnd(void)
{
u8 FLASH_Status = 0;
/* Select the FLASH: Chip Select low */
SPI_FLASH_CS_LOW();
/* Send "Read Status Register" instruction */
SPI_FLASH_SendByte(RDSR);
/* Loop as long as the memory is busy with a write cycle */
do
{
/* Send a dummy byte to generate the clock needed by the FLASH
and put the value of the status register in FLASH_Status variable */
FLASH_Status = SPI_FLASH_SendByte(Dummy_Byte);
}
while ((FLASH_Status & WIP_Flag) == SET); /* Write in progress */
/* Deselect the FLASH: Chip Select high */
SPI_FLASH_CS_HIGH();
}
TestStatus Buffercmp(u8* pBuffer1, u8* pBuffer2, u16 BufferLength)
{
while (BufferLength--)
{
if (*pBuffer1 != *pBuffer2)
{
return FAILED;
}
pBuffer1++;
pBuffer2++;
}
return PASSED;
}
#endif
/******************* (C) COPYRIGHT 2008 STMicroelectronics *****END OF FILE****/

复制代码

赞评论

Dylan疾风闪电回答时间：2016-1-7 15:14:08

/**
******************************************************************************
* @file /I2C_M24C02EEPROM.h
* @author xd.wu
* @version V1.0
* @date 2012-4-17
* @brief I2C：(ST的I2C问题很多，建议不用，选择IO口模拟)--测试不通过，待调整《申明：这里只是老的资料，描述也是以前的。故对存在问题的代码也不进行优化！》
******************************************************************************
*用途：
*/
/*实例应用步骤：
//1."main.cpp"调用fmain()
//2.Watch中观察
Tx1_Buffer == Rx1_Buffer
Tx2_Buffer == Rx2_Buffer
TransferStatus1,TransferStatus2
*/
#ifndef __I2C_M24C02EEPROM_H
#define __I2C_M24C02EEPROM_H
/* Includes ------------------------------------------------------------------*/
#include "std32periph.h"
/* Private typedef -----------------------------------------------------------*/
typedef enum {FAILED = 0, PASSED = !FAILED} TestStatus;
typedef struct
{
u8 *Tx,*Rx;
u16 Address,count,Max;
}I2CTYPE;
/* Private define ------------------------------------------------------------*/
#define EEPROM_WriteAddress1 0x05
#define EEPROM_ReadAddress1 0x05
#define BufferSize1 (countof(Tx1_Buffer)-1)
#define BufferSize2 (countof(Tx2_Buffer)-1)
#define EEPROM_WriteAddress2 (EEPROM_WriteAddress1 + BufferSize1)
#define EEPROM_ReadAddress2 (EEPROM_ReadAddress1 + BufferSize1)
#define I2C_Speed 400000
#define I2C1_SLAVE_ADDRESS7 0xA0
#define I2C_PageSize 8 /* page size of the I2C M24C02 EEPROM */
/* implemented on the STM3210E-LK board*/
/* Private macro -------------------------------------------------------------*/
#define countof(a) (sizeof(a) / sizeof(*(a)))
/* Private variables ---------------------------------------------------------*/
u8 Tx1_Buffer[] = "LLKKMMJJ";//"/* STM32F10x I2C Firmware ";
u8 Tx2_Buffer[] = "Library Example */";
u8 Rx1_Buffer[BufferSize1], Rx2_Buffer[BufferSize2];
volatile TestStatus TransferStatus1 = FAILED, TransferStatus2 = FAILED;
const u16 EEPROM_ADDRESS = 0xA0;//#define EEPROM_Block0_ADDRESS 0xA0 /* A1 = 0 A2 = 0 A3 = 0*/
I2CTYPE msgI2C;
bool status = false;
/* Private functions ---------------------------------------------------------*/
bool I2C_Event(I2CTYPE &msg)
{
//#define I2CMode_Slave
//Read SR1 and SR2,then save as I2CdwSR
u32 SR32 = I2C1->SR1 & 0x4FF;
SR32 |= (I2C1->SR2 & 0x7)<<16;
switch (SR32)
{
#ifdef I2CMode_Slave
//Slave Mode处理事件的优先级 EV2=EV3 > EV4=EV3_2 > EV1=EV3_1
case 0x00020040://I2C_SR_EV2: // BUSY and RXNE flags
msg.Rx[msg.count++] = I2C1->DR;
break;
case 0x00060080://I2C_ST_EV3: // TRA, BUSY and TXE flags
case 0x00060084://I2C_ST_EV3_1: // TRA, BUSY, TXE and BTF flags
I2C1->DR = msg.Tx[msg.count++];
break;
case 0x00000010://I2C_SR_EV4: // STOPF flag
I2C1->CR1 |= 0x0001;
break;
case 0x00000400://I2C_ST_EV3_2: // AF flag
I2C1->SR1 &= 0xFBFF;
break;
case 0x00060082://I2C_ST_EV1: // TRA, BUSY, TXE and ADDR flags
msg.count = 0;
break;
case 0x00020002://I2C_SR_EV1: // BUSY and ADDR flags
msg.count = 0;
break;
#else
//Master Mode处理事件的优先级 EV8=EV6_1=EV7_1 > EV7= > EV5=EV6=EV8_1=EV8_2
case 0x00070080://I2C_MT_EV8: // TRA, BUSY, MSL, TXE flags
if (msg.count < msg.Max)
{
I2C1->DR = msg.Tx[msg.count++];
}
else
{
I2C1->CR2 &= 0xF9FF;
I2C1->CR1 |= 0x0200;//STOP
}
break;
case 0x00030002://I2C_MR_EV6(EV6_1): // BUSY, MSL and ADDR flags
msg.count = 0;
if (msg.Max == 1)//只接收1个字节的情况
{
I2C1->CR1 &= 0xFBFF;//ACK=0
I2C1->CR1 |= 0x0200;//STOP
}
break;
case 0x00030040://I2C_MR_EV7:(EV7_1): // BUSY, MSL and RXNE flags
msg.Rx[msg.count++] = I2C1->DR;
if (msg.count == (msg.Max-1))
{
I2C1->CR1 &= 0xFBFF;//ACK=0
I2C1->CR1 |= 0x0200;//STOP
}
break;
case 0x00030001://I2C_MTR_EV5: // BUSY, MSL and SB flag
I2C1->DR = msg.Address;
break;
case 0x00070082://I2C_MT_EV6: // BUSY, MSL, ADDR, TXE and TRA flags
msg.count = 0;
break;
case 0x00070084://I2C_MT_EV8_2: // TRA, BUSY, MSL, TXE and BTF flags
I2C1->CR1 |= 0x0200;//STOP
break;
#endif
default:
return false;//异常状态
}
return true;
}
void I2C_EE_WaitEepromStandbyState(void)
{
vu16 SR1_Tmp = 0;
do
{
/* Send START condition */
I2C_GenerateSTART(I2C1, ENABLE);
/* Read I2C1 SR1 register */
SR1_Tmp = I2C1->SR1;
I2C1->DR = EEPROM_ADDRESS & 0xFE;/* Send EEPROM address for write */
}while(!(I2C1->SR1 & 0x0002));
if(I2C_GetFlagStatus(I2C1, I2C_FLAG_AF))
{
/* Clear AF flag */
I2C_ClearFlag(I2C1, I2C_FLAG_AF);
}
/* STOP condition */
I2C_GenerateSTOP(I2C1, ENABLE);
/* While the stop bit is set */
while (I2C1->CR1 & 0x200);
}
bool I2C_EE_PageWrite(u8* pBuffer, u8 WriteAddr, u8 NumByteToWrite)
{
u16 Timeout = 0x2000;
while((I2C1->SR2 & 0x2) && Timeout)// While the bus is busy
Timeout--;
if (Timeout==0)
return false;
msgI2C.Address = EEPROM_ADDRESS & 0xFE;
msgI2C.Tx = &WriteAddr;
I2C1->CR1 |= 0x0100;// Send START condition
//EV5
Timeout = 0x2000;
while(!I2C_Event(msgI2C) && Timeout)
{
Timeout--;
}
if (Timeout==0)
return false;
msgI2C.Tx = pBuffer;
msgI2C.Max = NumByteToWrite;
//EV6
Timeout = 0x2000;
while(!I2C_Event(msgI2C) && Timeout)
{
Timeout--;
}
if (Timeout==0)
return false;
//EV8
Timeout = 0x2000;
while(!I2C_Event(msgI2C) && Timeout)
{
Timeout--;
}
if (Timeout==0)
return false;
/* While there is data to be written */
while(NumByteToWrite--)
{
//EV8
Timeout = 0x2000;
while(!I2C_Event(msgI2C) && Timeout)
{
Timeout--;
}
if (Timeout==0)
return false;
}
I2C1->CR1 |= 0x0200;/* Send STOP condition */
return true;
}
void I2C_EE_BufferWrite(u8* pBuffer, u8 WriteAddr, u16 NumByteToWrite)
{
u8 NumOfPage = 0, NumOfSingle = 0, Addr = 0, count = 0;
Addr = WriteAddr % I2C_PageSize;
count = I2C_PageSize - Addr;
NumOfPage = NumByteToWrite / I2C_PageSize;
NumOfSingle = NumByteToWrite % I2C_PageSize;
/* If WriteAddr is I2C_PageSize aligned */
if(Addr == 0)
{
/* If NumByteToWrite < I2C_PageSize */
if(NumOfPage == 0)
{
status = I2C_EE_PageWrite(pBuffer, WriteAddr, NumOfSingle);
I2C_EE_WaitEepromStandbyState();
}
/* If NumByteToWrite > I2C_PageSize */
else
{
while(NumOfPage--)
{
status = I2C_EE_PageWrite(pBuffer, WriteAddr, I2C_PageSize);
I2C_EE_WaitEepromStandbyState();
WriteAddr += I2C_PageSize;
pBuffer += I2C_PageSize;
}
if(NumOfSingle!=0)
{
status = I2C_EE_PageWrite(pBuffer, WriteAddr, NumOfSingle);
I2C_EE_WaitEepromStandbyState();
}
}
}
/* If WriteAddr is not I2C_PageSize aligned */
else
{
/* If NumByteToWrite < I2C_PageSize */
if(NumOfPage== 0)
{
status = I2C_EE_PageWrite(pBuffer, WriteAddr, NumOfSingle);
I2C_EE_WaitEepromStandbyState();
}
/* If NumByteToWrite > I2C_PageSize */
else
{
NumByteToWrite -= count;
NumOfPage = NumByteToWrite / I2C_PageSize;
NumOfSingle = NumByteToWrite % I2C_PageSize;
if(count != 0)
{
status = I2C_EE_PageWrite(pBuffer, WriteAddr, count);
I2C_EE_WaitEepromStandbyState();
WriteAddr += count;
pBuffer += count;
}
while(NumOfPage--)
{
status = I2C_EE_PageWrite(pBuffer, WriteAddr, I2C_PageSize);
I2C_EE_WaitEepromStandbyState();
WriteAddr += I2C_PageSize;
pBuffer += I2C_PageSize;
}
if(NumOfSingle != 0)
{
status = I2C_EE_PageWrite(pBuffer, WriteAddr, NumOfSingle);
I2C_EE_WaitEepromStandbyState();
}
}
}
}
bool I2C_EE_BufferRead(u8* pBuffer, u8 ReadAddr, u16 NumByteToRead)
{
u16 Timeout = 0x2000;
while((I2C1->SR2 & 0x2) && Timeout)// While the bus is busy
Timeout--;
if (Timeout==0)
return false;
msgI2C.Address = EEPROM_ADDRESS & 0xFE;/* Send EEPROM address for write */
msgI2C.Tx = &ReadAddr;/* Send the EEPROM's internal address to write to */
msgI2C.Max = 1;
I2C1->CR1 |= 0x0100;// Send START condition
//EV5
Timeout = 0x2000;
while(!I2C_Event(msgI2C) && Timeout)
{
Timeout--;
}
if (Timeout==0)
return false;
//EV6
Timeout = 0x2000;
while(!I2C_Event(msgI2C) && Timeout)
{
Timeout--;
}
if (Timeout==0)
return false;
I2C_Cmd(I2C1, ENABLE);/* Clear EV6 by setting again the PE bit */
//EV8
Timeout = 0x2000;
while(!I2C_Event(msgI2C) && Timeout)
{
Timeout--;
}
if (Timeout==0)
return false;
msgI2C.Address = EEPROM_ADDRESS | 0x01;/* Send EEPROM address for read */
msgI2C.Tx = pBuffer;
msgI2C.Max = NumByteToRead;
I2C1->CR1 |= 0x0100;/* Send STRAT condition a second time */
//EV5
Timeout = 0x2000;
while(!I2C_Event(msgI2C) && Timeout)
{
Timeout--;
}
if (Timeout==0)
return false;
//EV6
Timeout = 0x2000;
while(!I2C_Event(msgI2C) && Timeout)
{
Timeout--;
}
if (Timeout==0)
return false;
/* While there is data to be read */
while(NumByteToRead)
{
//EV7
Timeout = 0x2000;
while(!I2C_Event(msgI2C) && Timeout)
{
Timeout--;
}
if (Timeout==0)
return false;
NumByteToRead--;
}
/* Enable Acknowledgement to be ready for another reception */
I2C_AcknowledgeConfig(I2C1, ENABLE);
return true;
}
TestStatus Buffercmp(u8* pBuffer1, u8* pBuffer2, u16 BufferLength)
{
while(BufferLength--)
{
if(*pBuffer1 != *pBuffer2)
{
return FAILED;
}
pBuffer1++;
pBuffer2++;
}
return PASSED;
}
void fmain(void)
{
RCC_HSEConf(9);//72M
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, ENABLE);
//复位I2C
RCC_APB2PeriphResetCmd(RCC_APB1Periph_I2C1, ENABLE);
/* Initialize the I2C EEPROM driver ----------------------------------------*/
/* Configure I2C1 pins: SCL and SDA */
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_OD;
GPIO_Init(GPIOB, &GPIO_InitStructure);
/* I2C configuration */
I2C_InitTypeDef I2C_InitStructure;
I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;
I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2;
I2C_InitStructure.I2C_OwnAddress1 = I2C1_SLAVE_ADDRESS7;
I2C_InitStructure.I2C_Ack = I2C_Ack_Enable;
I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
I2C_InitStructure.I2C_ClockSpeed = I2C_Speed;
/* I2C Peripheral Enable */
I2C_Cmd(I2C1, ENABLE);
/* Apply I2C configuration after enabling it -----注意点：先使能后初始化*/
I2C_Init(I2C1, &I2C_InitStructure);
/* First write in the memory followed by a read of the written data --------*/
/* Write on I2C EEPROM from EEPROM_WriteAddress1 */
I2C_EE_BufferWrite(Tx1_Buffer, EEPROM_WriteAddress1, BufferSize1);
status = false;
/* Read from I2C EEPROM from EEPROM_ReadAddress1 */
status = I2C_EE_BufferRead(Rx1_Buffer, EEPROM_ReadAddress1, BufferSize1);
TransferStatus1 = Buffercmp(Tx1_Buffer, Rx1_Buffer, BufferSize1);
/* Wait for EEPROM standby state */
I2C_EE_WaitEepromStandbyState();
/* Second write in the memory followed by a read of the written data -------*/
/* Write on I2C EEPROM from EEPROM_WriteAddress2 */
I2C_EE_BufferWrite(Tx2_Buffer, EEPROM_WriteAddress2, BufferSize2);
/* Read from I2C EEPROM from EEPROM_ReadAddress2 */
I2C_EE_BufferRead(Rx2_Buffer, EEPROM_ReadAddress2, BufferSize2);
TransferStatus2 = Buffercmp(Tx2_Buffer, Rx2_Buffer, BufferSize2);
}
#endif
/******************* (C) COPYRIGHT 2008 STMicroelectronics *****END OF FILE****/

复制代码

赞评论

Dylan疾风闪电回答时间：2016-1-7 14:26:10

本帖最后由 Dylan疾风闪电于 2016-1-8 11:20 编辑

为了大家学习、测试的便利，在这将IAR平台的工程文件打包上传。（文字描述部分不一定正确，毕竟是早期的个人理解。希望不要产生误导信息。）

STM32F103ZEä¾åå®æ½.rar (403.32 KB, 下载次数: 96)

2016-1-8 11:18 上传

点击文件名下载附件

/**
******************************************************************************
* @file /3ADCs_DMA.h
* @author xd.wu
* @version V1.0
* @date 2012-4-12
* @brief ADC1,2,3：独立模式、单通道、连续转换
ADC1：通过 DMA1_Channel1 将数据存入 ADC1ConvertedValue 变量地址
ADC2：用中断 ADC1_2_IRQn 将数据存入 ADC2ConvertedValue 变量
ADC3：通过 DMA2_Channel5 将数据存入 ADC3ConvertedValue 变量地址
******************************************************************************
*用途：大量数据收集
*/
/*实例应用步骤：
//1."main.cpp"调用fmain()
//2."stm32f10x_it.cpp"拷贝
#if defined __3ADCs_DMA
vu16 ADC2ConvertedValue;
#endif
void ADC1_2_IRQHandler(void)
{
#if defined __3ADCs_DMA
ADC2ConvertedValue = ADC2->DR;//由软件清除ADC2->SR &= 0xFFFD;或由读取ADC_DR时清除
#endif
}
//3."stm32f10x_it.h"声明
#define __3ADCs_DMA
void ADC1_2_IRQHandler(void);
//4.Watch中观察
ADC1ConvertedValue
ADC2ConvertedValue
ADC3ConvertedValue
*/
#ifndef __ADCS_DMA_H
#define __ADCS_DMA_H
/* Includes ------------------------------------------------------------------*/
#include "std32periph.h"
/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
vu16 ADC1ConvertedValue = 0, ADC3ConvertedValue = 0;
/* Private functions ---------------------------------------------------------*/
void fmain(void)
{
RCC_HSEConf(7);//56M
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1 | RCC_AHBPeriph_DMA2, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_ADC2 |
RCC_APB2Periph_ADC3 | RCC_APB2Periph_GPIOA, ENABLE);
//复位ADC
RCC_APB2PeriphResetCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_ADC2 |
RCC_APB2Periph_ADC3 , ENABLE);
RCC_APB2PeriphResetCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_ADC2 |
RCC_APB2Periph_ADC3 , DISABLE);
/* PA.01,02,03(ADC Channel11,2,3) as analog input --------------------------*/
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;
GPIO_Init(GPIOA, &GPIO_InitStructure);
//NVIC for ADC2
NVIC_GroupSet(NVIC_PriorityGroup_0, ADC1_2_IRQn, 0);
//DMA Public Setting
DMA_InitTypeDef DMA_InitStructure;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
DMA_InitStructure.DMA_BufferSize = 1;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Disable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
DMA_InitStructure.DMA_Priority = DMA_Priority_High;
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
// Private for DMA1 channel1
DMA_InitStructure.DMA_PeripheralBaseAddr = ((u32)0x4001244C);//ADC1_DR_Address;
DMA_InitStructure.DMA_MemoryBaseAddr = (u32)&ADC1ConvertedValue;
DMA_Init(DMA1_Channel1, &DMA_InitStructure);
DMA_Cmd(DMA1_Channel1, ENABLE);
// Private for DMA2 channel5
DMA_InitStructure.DMA_PeripheralBaseAddr = ((u32)0x40013C4C);//ADC3_DR_Address;
DMA_InitStructure.DMA_MemoryBaseAddr = (u32)&ADC3ConvertedValue;
DMA_Init(DMA2_Channel5, &DMA_InitStructure);
DMA_Cmd(DMA2_Channel5, ENABLE);
//ADC Public Setting
ADC_InitTypeDef ADC_InitStructure;
ADC_InitStructure.ADC_Mode = ADC_Mode_Independent;//独立模式
ADC_InitStructure.ADC_ScanConvMode = DISABLE;
ADC_InitStructure.ADC_ContinuousConvMode = ENABLE;
ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;
ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
ADC_InitStructure.ADC_NbrOfChannel = 1;
// ADC1
ADC_Init(ADC1, &ADC_InitStructure);
ADC_RegularChannelConfig(ADC1, ADC_Channel_1, 1, ADC_SampleTime_28Cycles5);
ADC_DMACmd(ADC1, ENABLE);
// ADC2
ADC_Init(ADC2, &ADC_InitStructure);
ADC_RegularChannelConfig(ADC2, ADC_Channel_2, 1, ADC_SampleTime_28Cycles5);
ADC_ITConfig(ADC2, ADC_IT_EOC, ENABLE);
// ADC3
ADC_Init(ADC3, &ADC_InitStructure);
ADC_RegularChannelConfig(ADC3, ADC_Channel_3, 1, ADC_SampleTime_28Cycles5);
ADC_DMACmd(ADC3, ENABLE);
// Enable ADC1
ADC_Cmd(ADC1, ENABLE);
ADC_ResetCalibration(ADC1);
while(ADC_GetResetCalibrationStatus(ADC1));
ADC_StartCalibration(ADC1);
while(ADC_GetCalibrationStatus(ADC1));
// Enable ADC2
ADC_Cmd(ADC2, ENABLE);
ADC_ResetCalibration(ADC2);
while(ADC_GetResetCalibrationStatus(ADC2));
ADC_StartCalibration(ADC2);
while(ADC_GetCalibrationStatus(ADC2));
// Enable ADC3
ADC_Cmd(ADC3, ENABLE);
ADC_ResetCalibration(ADC3);
while(ADC_GetResetCalibrationStatus(ADC3));
ADC_StartCalibration(ADC3);
while(ADC_GetCalibrationStatus(ADC3));
// Start ADC1,2,3
ADC_SoftwareStartConvCmd(ADC1, ENABLE);
ADC_SoftwareStartConvCmd(ADC2, ENABLE);
ADC_SoftwareStartConvCmd(ADC3, ENABLE);
}
#endif
/******************* (C) COPYRIGHT 2008 STMicroelectronics *****END OF FILE****/

复制代码

赞评论

Dylan疾风闪电回答时间：2016-1-7 14:26:36

/**
******************************************************************************
* @file /ADC_AnalogWatchdog.h
* @author xd.wu
* @version V1.0
* @date 2012-4-12
* @brief ADC1：独立模式、单通道、连续转换
如果ADC转换的模拟电压超出阀值范围，SR的AWD置1可产生中断.
阀值位于ADC_HTR和ADC_LTR寄存器的最低12个有效位中.
阀值独立于由ADC_CR2寄存器上的ALIGN位选择的数据对齐模式. 比较是在对齐之前完成的.
******************************************************************************
*用途：报警、指示灯
*/
/*实例应用步骤：
//1."main.cpp"调用fmain()
//2."stm32f10x_it.cpp"拷贝
void ADC1_2_IRQHandler(void)
{
GPIO_WriteBit(GPIO_LED, GPIO_Pin_6, Bit_SET);// Toggle LED
GPIO_WriteBit(GPIO_LED, GPIO_Pin_6, Bit_RESET);
ADC_ClearITPendingBit(ADC1, ADC_IT_AWD);// Clear ADC1 AWD pending interrupt bit
}
//3."stm32f10x_it.h"声明
void ADC1_2_IRQHandler(void);
//4.Watch中观察
LED变化
*/
#ifndef __ADC_ANALOGWATCHDOG_H
#define __ADC_ANALOGWATCHDOG_H
/* Includes ------------------------------------------------------------------*/
#include "std32periph.h"
/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
#define GPIO_LED GPIOF
#define RCC_LED RCC_APB2Periph_GPIOF
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/* Private functions ---------------------------------------------------------*/
void fmain(void)
{
RCC_HSEConf(7);//56M
RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_GPIOA | RCC_LED, ENABLE);
//复位ADC
RCC_APB2PeriphResetCmd(RCC_APB2Periph_ADC1 , ENABLE);
RCC_APB2PeriphResetCmd(RCC_APB2Periph_ADC1 , DISABLE);
GPIO_InitTypeDef GPIO_InitStructure;
/* Configure GOIO_LED pin 6 as output push-pull ----------------------------*/
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_Init(GPIO_LED, &GPIO_InitStructure);
/* Configure PA.01 (ADC Channel1) as analog input --------------------------*/
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;
GPIO_Init(GPIOA, &GPIO_InitStructure);
//NVIC for ADC1
NVIC_GroupSet(NVIC_PriorityGroup_0, ADC1_2_IRQn, 0);
ADC_InitTypeDef ADC_InitStructure;
ADC_InitStructure.ADC_Mode = ADC_Mode_Independent;
ADC_InitStructure.ADC_ScanConvMode = DISABLE;
ADC_InitStructure.ADC_ContinuousConvMode = ENABLE;
ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;
ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
ADC_InitStructure.ADC_NbrOfChannel = 1;
ADC_Init(ADC1, &ADC_InitStructure);
ADC_RegularChannelConfig(ADC1, ADC_Channel_1, 1, ADC_SampleTime_13Cycles5);
//AnalogWatchdogThresholds 模拟看门狗高低阈yu值
ADC1->LTR = 0x0300;
ADC1->HTR = 0x0800;//0x0B00;//设成远大于实际波动的值0x0FF0;便不会超限了//
ADC_AnalogWatchdogSingleChannelConfig(ADC1, ADC_Channel_1); //本例重点设置：对单个ADC通道设置模拟看门狗
ADC_AnalogWatchdogCmd(ADC1, ADC_AnalogWatchdog_SingleRegEnable);
ADC_ITConfig(ADC1, ADC_IT_AWD, ENABLE);
ADC_Cmd(ADC1, ENABLE);
ADC_ResetCalibration(ADC1);
while(ADC_GetResetCalibrationStatus(ADC1));
ADC_StartCalibration(ADC1);
while(ADC_GetCalibrationStatus(ADC1));
ADC_SoftwareStartConvCmd(ADC1, ENABLE);
}
#endif
/******************* (C) COPYRIGHT 2008 STMicroelectronics *****END OF FILE****/

复制代码

赞评论

Dylan疾风闪电回答时间：2016-1-7 14:29:07

/**
******************************************************************************
* @file /ADC_RegSimulDualMode.h
* @author xd.wu
* @version V1.0
* @date 2012-4-12
* @brief ADC1,2：双ADC同步规则模式
注意1：不要在2个ADC上转换相同的通道(如果转换两个ADC的相同通道，不可能提供重叠的采样时间)。
注意2： ADC2的外部触发必须使能，否则只能采集一个数据。
******************************************************************************
*用途：同步采样
*/
/*实例应用步骤：
//1."main.cpp"调用fmain()
//4.Watch中观察
LED变化
*/
#ifndef __ADC_REGSIMULDUALMODE_H
#define __ADC_REGSIMULDUALMODE_H
/* Includes ------------------------------------------------------------------*/
#include "std32periph.h"
/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
vu32 ADC_DualConvertedValueTab[16];
/* Private functions ---------------------------------------------------------*/
void fmain(void)
{
RCC_HSEConf(7);//56M
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_ADC2 |
RCC_APB2Periph_GPIOA, ENABLE);
//复位ADC
RCC_APB2PeriphResetCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_ADC2 , ENABLE);
RCC_APB2PeriphResetCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_ADC2 , DISABLE);
/* PA.01,02,03,04(ADC Channel11,2,3,4) as analog input ---------------------*/
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3 | GPIO_Pin_4;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;
GPIO_Init(GPIOA, &GPIO_InitStructure);
/* DMA1 channel1 configuration ----------------------------------------------*/
DMA_InitTypeDef DMA_InitStructure;
DMA_InitStructure.DMA_PeripheralBaseAddr = ((u32)0x4001244C);//(u32)ADC1_DR_Address;
DMA_InitStructure.DMA_MemoryBaseAddr = (u32)&ADC_DualConvertedValueTab;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
DMA_InitStructure.DMA_BufferSize = 16;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Word;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Word;
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
DMA_InitStructure.DMA_Priority = DMA_Priority_High;
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
DMA_Init(DMA1_Channel1, &DMA_InitStructure);
DMA_Cmd(DMA1_Channel1, ENABLE);
//ADC Public Setting
ADC_InitTypeDef ADC_InitStructure;
ADC_InitStructure.ADC_Mode = ADC_Mode_RegSimult;//本例重点：双ADC同步规则模式
ADC_InitStructure.ADC_ScanConvMode = ENABLE;
ADC_InitStructure.ADC_ContinuousConvMode = ENABLE;
ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;
ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
ADC_InitStructure.ADC_NbrOfChannel = 2;
/* ADC1 configuration ------------------------------------------------------*/
ADC_Init(ADC1, &ADC_InitStructure);
ADC_RegularChannelConfig(ADC1, ADC_Channel_1, 1, ADC_SampleTime_239Cycles5);
ADC_RegularChannelConfig(ADC1, ADC_Channel_2, 2, ADC_SampleTime_239Cycles5);
ADC_DMACmd(ADC1, ENABLE);
/* ADC2 configuration ------------------------------------------------------*/
ADC_Init(ADC2, &ADC_InitStructure);
ADC_RegularChannelConfig(ADC2, ADC_Channel_3, 1, ADC_SampleTime_239Cycles5);
ADC_RegularChannelConfig(ADC2, ADC_Channel_4, 2, ADC_SampleTime_239Cycles5);
ADC_ExternalTrigConvCmd(ADC2, ENABLE);
ADC_Cmd(ADC1, ENABLE);
/* Enable Vrefint channel17 */
ADC_TempSensorVrefintCmd(ENABLE);//启用温度传感器
ADC_ResetCalibration(ADC1);//重置校准寄存器
while(ADC_GetResetCalibrationStatus(ADC1));
ADC_StartCalibration(ADC1);
while(ADC_GetCalibrationStatus(ADC1));
/* Enable ADC2 */
ADC_Cmd(ADC2, ENABLE);
ADC_ResetCalibration(ADC2);
while(ADC_GetResetCalibrationStatus(ADC2));
ADC_StartCalibration(ADC2);
while(ADC_GetCalibrationStatus(ADC2));
ADC_SoftwareStartConvCmd(ADC1, ENABLE);
while(!DMA_GetFlagStatus(DMA1_FLAG_TC1));
DMA_ClearFlag(DMA1_FLAG_TC1);
}
#endif
/******************* (C) COPYRIGHT 2008 STMicroelectronics *****END OF FILE****/

复制代码

赞评论

Dylan疾风闪电回答时间：2016-1-7 14:53:45

/**
******************************************************************************
* @file /ADC_TIMTrigAutoInjection.h ##此程序有瑕疵：会进入HardFault_Handler中断，疑似程序执行过快跑飞
* @author xd.wu
* @version V1.0
* @date 2012-4-13
* @brief ADC1：独立模式、单通道、单次转换、外部触发、自动注入
自动注入如果设置了JAUTO位，在规则组通道之后，注入组通道被自动转换。
******************************************************************************
*用途：滞后1个特定转换周期的连续转换
*/
/*实例应用步骤：
//1."main.cpp"调用fmain()
//2."stm32f10x_it.cpp"拷贝
extern vu16 ADC_InjectedConvertedValueTab[32];
vu32 Index;
void ADC1_2_IRQHandler(void)
{
GPIO_WriteBit(GPIOF, GPIO_Pin_6, Bit_SET);
ADC_InjectedConvertedValueTab[Index++] = ADC_GetInjectedConversionValue(ADC1, ADC_InjectedChannel_1);
ADC_ClearITPendingBit(ADC1, ADC_IT_JEOC);
GPIO_WriteBit(GPIOF, GPIO_Pin_6, Bit_RESET);
}
//3."stm32f10x_it.h"声明
void ADC1_2_IRQHandler(void);
//4.Watch中观察
LED
ADC_RegularConvertedValueTab
ADC_InjectedConvertedValueTab
*/
#ifndef __ADC_TIMTRIGAUTOINJECTION_H
#define __ADC_TIMTRIGAUTOINJECTION_H
/* Includes ------------------------------------------------------------------*/
#include "std32periph.h"
/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
#define GPIO_LED GPIOF
#define RCC_LED RCC_APB2Periph_GPIOF
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
vu16 ADC_RegularConvertedValueTab[32], ADC_InjectedConvertedValueTab[32];
/* Private functions ---------------------------------------------------------*/
void fmain(void)
{
RCC_HSEConf(7);//56M
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_LED |
RCC_APB2Periph_ADC1 | RCC_APB2Periph_TIM1, ENABLE);
//复位ADC
RCC_APB2PeriphResetCmd(RCC_APB2Periph_ADC1 , ENABLE);
RCC_APB2PeriphResetCmd(RCC_APB2Periph_ADC1 , DISABLE);
GPIO_InitTypeDef GPIO_InitStructure;
/* PA.01,02,03,04(ADC Channel11,2,3,4) as analog input ---------------------*/
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1 | GPIO_Pin_2;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;
GPIO_Init(GPIOA, &GPIO_InitStructure);
/* Configure TIM1_CH1 (PA8) as alternate function push-pull */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_Init(GPIOA, &GPIO_InitStructure);
// LED
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_Init(GPIO_LED, &GPIO_InitStructure);
//NVIC for ADC2
NVIC_GroupSet(NVIC_PriorityGroup_0, ADC1_2_IRQn, 0);
/* DMA1 Channel1 Configuration ----------------------------------------------*/
DMA_InitTypeDef DMA_InitStructure;
DMA_InitStructure.DMA_PeripheralBaseAddr = ((u32)0x4001244C);//ADC1_DR_Address;
DMA_InitStructure.DMA_MemoryBaseAddr = (u32)&ADC_RegularConvertedValueTab;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
DMA_InitStructure.DMA_BufferSize = 32;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
DMA_InitStructure.DMA_Priority = DMA_Priority_High;
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
DMA_Init(DMA1_Channel1, &DMA_InitStructure);
DMA_Cmd(DMA1_Channel1, ENABLE);
/* ADC1 configuration ------------------------------------------------------*/
ADC_InitTypeDef ADC_InitStructure;
ADC_InitStructure.ADC_Mode = ADC_Mode_Independent;
ADC_InitStructure.ADC_ScanConvMode = DISABLE;
ADC_InitStructure.ADC_ContinuousConvMode = DISABLE;
ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_T1_CC1;//本例重点
ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
ADC_InitStructure.ADC_NbrOfChannel = 1;
ADC_Init(ADC1, &ADC_InitStructure);
ADC_RegularChannelConfig(ADC1, ADC_Channel_1, 1, ADC_SampleTime_13Cycles5);
ADC_DMACmd(ADC1, ENABLE);
ADC_ExternalTrigConvCmd(ADC1, ENABLE);
ADC_InjectedSequencerLengthConfig(ADC1, 1);
ADC_InjectedChannelConfig(ADC1, ADC_Channel_2, 1, ADC_SampleTime_71Cycles5);
ADC_ExternalTrigInjectedConvConfig(ADC1, ADC_ExternalTrigInjecConv_None);
ADC_AutoInjectedConvCmd(ADC1, ENABLE);
ADC_ITConfig(ADC1, ADC_IT_JEOC, ENABLE);
// TIM1_channel1：PWM mode、 TIM输出比较极性低、0x7F
// F = TIMxCLK/(PSC+1)/(ARR+1) (56/2*2)/4=14M *0x7F
TIM1->PSC = 3;
TIM1->ARR = 0xFF;
TIM1->CR1 = 0x0000;
TIM1->CCMR1 &= 0xFF00;
TIM1->CCMR1 |= 0x0060;
TIM1->CCER &= 0xFFF0;
TIM1->CCER |= 0x0003;
TIM1->CCR1 = 0x7F;
ADC_Cmd(ADC1, ENABLE);
ADC_ResetCalibration(ADC1);
while(ADC_GetResetCalibrationStatus(ADC1));
ADC_StartCalibration(ADC1);
while(ADC_GetCalibrationStatus(ADC1));
TIM_Cmd(TIM1, ENABLE);
TIM_CtrlPWMOutputs(TIM1, ENABLE); //TIM1刹车和死区寄存器：主输出使能
while(!DMA_GetFlagStatus(DMA1_FLAG_TC1));
DMA_ClearFlag(DMA1_FLAG_TC1);
TIM_Cmd(TIM1, DISABLE);
}
#endif
/******************* (C) COPYRIGHT 2008 STMicroelectronics *****END OF FILE****/

复制代码

赞评论

Dylan疾风闪电回答时间：2016-1-7 14:54:02

/**
******************************************************************************
* @file /BKP_Tamper.h
* @author xd.wu
* @version V1.0
* @date 2012-4-13
* @brief BKP：保存VBAT掉电前的数据
当TAMPER引脚上的信号从’0’变成’1’或者从’1’变成’0’
(取决于备份控制寄存器BKP_CR的TPAL位)，BKP_TamperPinLevelConfig(BKP_TamperPinLevel_Low);//设置侵入检测管脚的有效电平
会产生一个侵入检测事件。
侵入检测事件将所有数据备份寄存器内容清除。
在一个侵入事件被检测到并被清除后，侵入检测引脚TAMPER应该被禁止。
然后，在再次写入备份数据寄存器前重新用TPE位启动侵入检测功能。
这样，可以阻止软件在侵入检测引脚上仍然有侵入事件时对备份数据寄存器进行写操作。这相当于对侵入引脚TAMPER进行电平检测。
******************************************************************************
*用途：“保密”，即一旦受到意外的侵入，STM32将毁灭数据。这是通过Tamper机制来实现的。
只要仍有VBAT，那么Tamper检测仍是有效的.
注意：这个引脚的上拉电阻必须接到VBAT而不是接到VDD。
否则，如果电源断开（VDD变低），也会引发一次Tamper事件，而这往往并不是设计都的本意。
*/
/*实例应用步骤：
//1."main.cpp"调用fmain()
//2."stm32f10x_it.cpp"拷贝
#define GPIO_LED GPIOF
extern u32 IsBackupRegReset(void);
void TAMPER_IRQHandler(void)
{
if(BKP_GetITStatus() != RESET)
{
if(IsBackupRegReset() == 0)// Check if Backup registers are cleared
{
GPIO_WriteBit(GPIO_LED, GPIO_Pin_8, Bit_SET);
}
else
{
GPIO_WriteBit(GPIO_LED, GPIO_Pin_9, Bit_SET);
}
BKP_ClearITPendingBit();// Clear Tamper pin interrupt pending bit
BKP_ClearFlag();// Clear Tamper pin Event(TE) pending flag
}
}
//3."stm32f10x_it.h"声明
void TAMPER_IRQHandler(void);
//4.Watch中观察
LED
*/
#ifndef __BKP_TAMPER_H
#define __BKP_TAMPER_H
/* Includes ------------------------------------------------------------------*/
#include "std32periph.h"
/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
#define GPIO_LED GPIOF
#define RCC_LED RCC_APB2Periph_GPIOF
#define BKP_DR_NUMBER 42
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
u16 BKPDataReg[BKP_DR_NUMBER] =
{
BKP_DR1, BKP_DR2, BKP_DR3, BKP_DR4, BKP_DR5, BKP_DR6, BKP_DR7, BKP_DR8,
BKP_DR9, BKP_DR10, BKP_DR11, BKP_DR12, BKP_DR13, BKP_DR14, BKP_DR15, BKP_DR16,
BKP_DR17, BKP_DR18, BKP_DR19, BKP_DR20, BKP_DR21, BKP_DR22, BKP_DR23, BKP_DR24,
BKP_DR25, BKP_DR26, BKP_DR27, BKP_DR28, BKP_DR29, BKP_DR30, BKP_DR31, BKP_DR32,
BKP_DR33, BKP_DR34, BKP_DR35, BKP_DR36, BKP_DR37, BKP_DR38, BKP_DR39, BKP_DR40,
BKP_DR41, BKP_DR42
};
/* Private functions ---------------------------------------------------------*/
u32 IsBackupRegReset(void)
{
for (u8 index = 0; index < BKP_DR_NUMBER; index++)
{
if (BKP_ReadBackupRegister(BKPDataReg[index]) != 0x0000)
return (index + 1);
}
return 0;
}
u32 CheckBackupReg(u16 FirstBackupData)
{
for (u8 index = 0; index < BKP_DR_NUMBER; index++)
{
if (BKP_ReadBackupRegister(BKPDataReg[index]) != (FirstBackupData + (index * 0x5A)))
return (index + 1);
}
return 0;
}
void fmain(void)
{
RCC_HSEConf(9);//72M
RCC_APB2PeriphClockCmd(RCC_LED, ENABLE);
/* Configure GPIO_LED Pin 6, Pin 7, Pin 8 and Pin 9 as Output push-pull ----*/
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7 | GPIO_Pin_8 | GPIO_Pin_9;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_Init(GPIO_LED, &GPIO_InitStructure);
//NVIC for ADC2
NVIC_GroupSet(NVIC_PriorityGroup_0, TAMPER_IRQn, 0);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);
PWR_BackupAccessCmd(ENABLE);//使能RTC和后备寄存器访问
BKP_ClearFlag();
BKP_TamperPinLevelConfig(BKP_TamperPinLevel_Low);//设置侵入检测管脚的有效电平
BKP_ITConfig(ENABLE);
BKP_TamperPinCmd(ENABLE);
u16 FirstBackupData = 0xA53C;
for (u8 index = 0; index < BKP_DR_NUMBER; index++)
{
BKP_WriteBackupRegister(BKPDataReg[index], FirstBackupData + (index * 0x5A));
}
if(CheckBackupReg(0xA53C) == 0x00)
{
GPIO_Write(GPIO_LED, GPIO_Pin_6);
}
else
{
GPIO_Write(GPIO_LED, GPIO_Pin_7);
}
}
#endif
/******************* (C) COPYRIGHT 2008 STMicroelectronics *****END OF FILE****/

复制代码

赞评论

Dylan疾风闪电回答时间：2016-1-7 14:55:06

本帖最后由 Dylan疾风闪电于 2016-1-7 15:02 编辑

/**
******************************************************************************
* @file /CAN_Example.h
* @author xd.wu
* @version V1.0
* @date 2012-4-13
* @brief CAN：
收发寄存器 RDLR,RDHR,TDLR,TDHR
例如 CANx->sFIFOMailBox[FIFONumber].RDLR;
******************************************************************************
*
*/
/*实例应用步骤：
//1."main.cpp"调用fmain()
//2."stm32f10x_it.cpp"拷贝
extern vu32 ret;
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;
}
//3."stm32f10x_it.h"声明
void USB_LP_CAN1_RX0_IRQHandler(void);
//4.Watch中观察
LED
*/
#ifndef __CAN_EXAMPLE_H
#define __CAN_EXAMPLE_H
/* Includes ------------------------------------------------------------------*/
#include "std32periph.h"
/* Private typedef -----------------------------------------------------------*/
typedef enum {FAILED = 0, PASSED = !FAILED} TestStatus;
/* Private define ------------------------------------------------------------*/
#define GPIO_LED GPIOF
#define RCC_LED RCC_APB2Periph_GPIOF
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
vu32 ret = 0; /* for return of the interrupt handling */
volatile TestStatus TestRx;
/* Private functions ---------------------------------------------------------*/
TestStatus CAN_Polling(void)
{
CAN_InitTypeDef CAN_InitStructure;
CAN_FilterInitTypeDef CAN_FilterInitStructure;
CanTxMsg TxMessage;
CanRxMsg RxMessage;
u32 i = 0;
u8 TransmitMailbox = 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=5;
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 */
}
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;
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;
}
void fmain(void)
{
RCC_HSEConf(9);//72M
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_LED, ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);
//复位CAN
RCC_APB1PeriphResetCmd(RCC_APB1Periph_CAN1 , ENABLE);
RCC_APB1PeriphResetCmd(RCC_APB1Periph_CAN1 , DISABLE);
GPIO_InitTypeDef GPIO_InitStructure;
/* Configure GPIO_LED pin6, pin7, pin8 and pin9 as Output push-pull */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7 | GPIO_Pin_8 | GPIO_Pin_9;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIO_LED, &GPIO_InitStructure);
/* Configure CAN pin: RX */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
GPIO_Init(GPIOA, &GPIO_InitStructure);
/* Configure CAN pin: TX */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_Init(GPIOA, &GPIO_InitStructure);
//NVIC for ADC2
NVIC_GroupSet(NVIC_PriorityGroup_0, USB_LP_CAN1_RX0_IRQn, 0);
TestRx = CAN_Polling();/* CAN transmit at 100Kb/s and receive by polling in loopback mode */
if (TestRx == FAILED)
{
GPIO_SetBits(GPIO_LED, GPIO_Pin_8);
}
else
{
GPIO_SetBits(GPIO_LED, GPIO_Pin_6);
}
TestRx = CAN_Interrupt();/* CAN transmit at 500Kb/s and receive by interrupt in loopback mode */
if (TestRx == FAILED)
{
GPIO_SetBits(GPIO_LED, GPIO_Pin_9);
}
else
{
GPIO_SetBits(GPIO_LED, GPIO_Pin_7);
}
}
#endif
/******************* (C) COPYRIGHT 2008 STMicroelectronics *****END OF FILE****/

复制代码

赞评论

zhangdaijin 回答时间：2016-1-7 14:59:19

这个牛！！！

赞评论

Dylan疾风闪电回答时间：2016-1-7 15:03:34

/**
******************************************************************************
* @file /CM3_BitBand.h
* @author xd.wu
* @version V1.0
* @date 2012-4-13
* @brief CM3：BitBand(别名区域)
use CortexM3 Bit-Band access to perform atomic read-modify-write and read operations on a varaible in SRAM.
对Bit-band区域某个字节的写操作，Cortex-M3都将自动转换成对相对应比特位的读－修改－写操作。
对Bit-band区域某个字节的读操作则将转换成相对应比特位的读操作。
公式：Bit-Band地址= Bit-Band域首地址 + (操作字节的偏移量× 32) + (操作位的偏移量× 4)
= Bit-Band域首地址 | (操作字节的偏移量<<5) | (操作位的偏移量<<2)
内置SRAM区的Bit-Band域首地址为0x22000000
外设寄存器区的Bit-Band域首地址为0x42000000
******************************************************************************
*用途：通过宏BitBand_GetAddr()计算得到别名区域的地址，从而简化位操作
由"stm32f10x_flash.icf"文件可知，实际可用的Flash空间不是无限的
ROM = 0x08000000 ~ 0x080FFFFF;
RAM = 0x20000000 ~ 0x2000FFFF;//64KB
cstack = 0x800;
heap = 0x200;
place in ROM_region { readonly };//1024KB = u16(2Byte)*512*1024
place in RAM_region { readwrite,//61.5KB = u16*123*256=u16*31488
block CSTACK,//2KB = u16*1024
block HEAP };//512Byte = u16*256
*/
/*实例应用步骤：
//1."main.cpp"调用fmain()
//2.Watch中观察
LED
*/
#ifndef __CM3_BITBAND_H
#define __CM3_BITBAND_H
/* Includes ------------------------------------------------------------------*/
#include "std32periph.h"
/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
#define RAM_BASE 0x20000000
#define RAM_BB_BASE 0x22000000
/* Private macro -------------------------------------------------------------*/
#define Var_ResetBit_BB(VarAddr, BitNumber) \
(*(vu32 *) (RAM_BB_BASE | ((VarAddr - RAM_BASE) << 5) | ((BitNumber) << 2)) = 0)
#define Var_SetBit_BB(VarAddr, BitNumber) \
(*(vu32 *) (RAM_BB_BASE | ((VarAddr - RAM_BASE) << 5) | ((BitNumber) << 2)) = 1)
#define Var_GetBit_BB(VarAddr, BitNumber) \
(*(vu32 *) (RAM_BB_BASE | ((VarAddr - RAM_BASE) << 5) | ((BitNumber) << 2)))
//自添加BitBand原始公式
#define BitBand_SetVal(PPP, Offset, BitNo, Val)\
(*(vu32*) (0x42000000 | ((PPP & 0x0FFFFFFF)<<5) | (Offset<<5) | (BitNo<<2)) = (Val))
#define BitBand_GetAddr(PPP, Offset, BitNo)\
(0x42000000 | ((PPP & 0x0FFFFFFF)<<5) | (Offset<<5) | (BitNo<<2))
/* Private variables ---------------------------------------------------------*/
vu32 Var, VarAddr = 0, VarBitValue = 0;
/* Private functions ---------------------------------------------------------*/
void fmain(void)
{
Var = 0x00005AA5;
RCC_HSEConf(9);//72M
/* A mapping formula shows how to reference each word in the alias region to a corresponding
bit in the bit-band region. The mapping formula is:
bit_word_addr = bit_band_base + (byte_offset x 32) + (bit_number ?4)
where:
- bit_word_addr: is the address of the word in the alias memory region that maps to the
targeted bit.
- bit_band_base is the starting address of the alias region
- byte_offset is the number of the byte in the bit-band region that contains the targeted bit
- bit_number is the bit position (0-7) of the targeted bit */
/* Get the variable address --------------------------------------------------*/
VarAddr = (u32)&Var;
/* Modify variable bit using bit-band access ---------------------------------*/
/* Modify Var variable bit 0 -----------------------------------------------*/
Var_ResetBit_BB(VarAddr, 0); /* Var = 0x00005AA4 */
Var_SetBit_BB(VarAddr, 0); /* Var = 0x00005AA5 */
/* Modify Var variable bit 11 -----------------------------------------------*/
Var_ResetBit_BB(VarAddr, 11); /* Var = 0x000052A5 */
/* Get Var variable bit 11 value */
VarBitValue = Var_GetBit_BB(VarAddr, 11); /* VarBitValue = 0x00000000 */
Var_SetBit_BB(VarAddr, 11); /* Var = 0x00005AA5 */
/* Get Var variable bit 11 value */
VarBitValue = Var_GetBit_BB(VarAddr, 11); /* VarBitValue = 0x00000001 */
/* Modify Var variable bit 31 -----------------------------------------------*/
Var_SetBit_BB(VarAddr, 31); /* Var = 0x80005AA5 */
/* Get Var variable bit 31 value */
VarBitValue = Var_GetBit_BB(VarAddr, 31); /* VarBitValue = 0x00000001 */
Var_ResetBit_BB(VarAddr, 31); /* Var = 0x00005AA5 */
/* Get Var variable bit 31 value */
VarBitValue = Var_GetBit_BB(VarAddr, 31); /* VarBitValue = 0x00000000 */
//自己添加的程序：点亮LED(PF.06)
(*(vu32*)0x4242031C) = 1;//RCC_APB2...IOFEN
(*(vu32*)0x42238060) = 1;//GPIOF_CRL...MODE6_0(0x4223806?)
(*(vu32*)0x42238064) = 1;//GPIOF_CRL...MODE6_1
(*(vu32*)0x42238068) = 0;//GPIOF_CRL...CNF6_0
(*(vu32*)0x4223806C) = 0;//GPIOF_CRL...CNF6_1
(*(vu32*)0x42238070) = 1;//GPIOF_CRL...MODE7_0(0x4223807?)
(*(vu32*)0x42238074) = 1;//GPIOF_CRL...MODE7_1
(*(vu32*)0x42238078) = 0;//GPIOF_CRL...CNF7_0
(*(vu32*)0x4223807C) = 0;//GPIOF_CRL...CNF7_1
(*(vu32*)0x42238080) = 1;//GPIOF_CRH...MODE8_0(0x4223808?)
(*(vu32*)0x42238084) = 1;//GPIOF_CRH...MODE8_1
(*(vu32*)0x42238088) = 0;//GPIOF_CRH...CNF8_0
(*(vu32*)0x4223808C) = 0;//GPIOF_CRH...CNF8_1
(*(vu32*)0x42238090) = 1;//GPIOF_CRH...MODE9_0(0x4223809?)
(*(vu32*)0x42238094) = 1;//GPIOF_CRH...MODE9_1
(*(vu32*)0x42238098) = 0;//GPIOF_CRH...CNF9_0
(*(vu32*)0x4223809C) = 0;//GPIOF_CRH...CNF9_1
u8 ms_1 = 10, ms = 100;
u32 base = 1500;//100~1000
s8 is = 1;
while(1)
{
(*(vu32*)0x42238198) = 1;//GPIOF_ODR...Pin6
(*(vu32*)0x4223819C) = 0;//GPIOF_ODR...Pin7
(*(vu32*)0x422381A0) = 1;//GPIOF_ODR...Pin8
(*(vu32*)0x422381A4) = 0;//GPIOF_ODR...Pin9
Delay_us(ms_1*base,72);
(*(vu32*)0x42238198) = 0;//GPIOF_ODR...Pin6
(*(vu32*)0x4223819C) = 1;//GPIOF_ODR...Pin7
(*(vu32*)0x422381A0) = 0;//GPIOF_ODR...Pin8
(*(vu32*)0x422381A4) = 1;//GPIOF_ODR...Pin9
Delay_us((ms-ms_1)*base,72);
ms_1 += 10*is;
if(ms_1 <= 10)
is = 1;
else if(ms_1 >= 90)
is = -1;
}
/*同上：区别是，上面直接用已知的地址操作位，下面宏计算地址并操作位
BitBand_SetVal(RCC_BASE, 0x18, 7, 1); //RCC_APB2ENR_IOPFEN
BitBand_SetVal(GPIOF_BASE, 0, 27, 0);//GPIOF_CRL
BitBand_SetVal(GPIOF_BASE, 0, 26, 0);
BitBand_SetVal(GPIOF_BASE, 0, 25, 1);
BitBand_SetVal(GPIOF_BASE, 0, 24, 1);
BitBand_SetVal(GPIOF_BASE, 0, 31, 0);//GPIOF_CRL
BitBand_SetVal(GPIOF_BASE, 0, 30, 0);
BitBand_SetVal(GPIOF_BASE, 0, 29, 1);
BitBand_SetVal(GPIOF_BASE, 0, 28, 1);
BitBand_SetVal(GPIOF_BASE, 4, 3, 0);//GPIOF_CRH
BitBand_SetVal(GPIOF_BASE, 4, 2, 0);
BitBand_SetVal(GPIOF_BASE, 4, 1, 1);
BitBand_SetVal(GPIOF_BASE, 4, 0, 1);
BitBand_SetVal(GPIOF_BASE, 4, 7, 0);//GPIOF_CRH
BitBand_SetVal(GPIOF_BASE, 4, 6, 0);
BitBand_SetVal(GPIOF_BASE, 4, 5, 1);
BitBand_SetVal(GPIOF_BASE, 4, 4, 1);
while(1)
{
BitBand_SetVal(GPIOF_BASE, 0xC, 6, 1);//GPIOF_ODR
BitBand_SetVal(GPIOF_BASE, 0xC, 7, 0);//GPIOF_ODR
BitBand_SetVal(GPIOF_BASE, 0xC, 8, 1);//GPIOF_ODR
BitBand_SetVal(GPIOF_BASE, 0xC, 9, 0);//GPIOF_ODR
Delay_us(2e5,72);
BitBand_SetVal(GPIOF_BASE, 0xC, 6, 0);//GPIOF_ODR
BitBand_SetVal(GPIOF_BASE, 0xC, 7, 1);//GPIOF_ODR
BitBand_SetVal(GPIOF_BASE, 0xC, 8, 0);//GPIOF_ODR
BitBand_SetVal(GPIOF_BASE, 0xC, 9, 1);//GPIOF_ODR
Delay_us(2e5,72);
}*/
}
#endif
/******************* (C) COPYRIGHT 2008 STMicroelectronics *****END OF FILE****/

复制代码

赞评论

Dylan疾风闪电回答时间：2016-1-7 15:04:51

/**
******************************************************************************
* @file /CM3_ModePrivilege.h
* @author xd.wu
* @version V1.0
* @date 2012-4-14
* @brief CM3：特殊模式 (此例未验证成功：__set_PSP()等宏未定义)
******************************************************************************
*用途：
*/
/*实例应用步骤：
//1."main.cpp"调用fmain()
//2."stm32f10x_it.cpp"修改系统中断
void SVCHandler(void)
{
__set_CONTROL(2);// Switch back Thread mode to privileged
}
//3.Watch中观察
*/
#ifndef __CM3_MODEPRIVILEGE_H
#define __CM3_MODEPRIVILEGE_H
/* Includes ------------------------------------------------------------------*/
#include "std32periph.h"
#include "core_cm3.h"//宏__...
/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
#define SP_PROCESS_SIZE 0x200 /* Process stack size */
#define SP_PROCESS 0x02 /* Process stack */
#define SP_MAIN 0x00 /* Main stack */
#define THREAD_MODE_PRIVILEGED 0x00 /* Thread mode has privileged access */
#define THREAD_MODE_UNPRIVILEGED 0x01 /* Thread mode has unprivileged access */
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
vu8 PSPMemAlloc[SP_PROCESS_SIZE];
vu32 Index = 0, PSPValue = 0, CurrentStack = 0, ThreadMode = 0;
/* Private functions ---------------------------------------------------------*/
void fmain(void)
{
RCC_HSEConf(9);//72M
/* Switch Thread mode Stack from Main to Process -----------------------------*/
/* Initialize memory reserved for Process Stack */
for(Index = 0; Index < SP_PROCESS_SIZE; Index++)
{
PSPMemAlloc[Index] = 0x00;
}
/* Set Process stack value */
__set_PSP((u32)PSPMemAlloc + SP_PROCESS_SIZE);
/* Select Process Stack as Thread mode Stack */
__set_CONTROL(SP_PROCESS);
/* Get the Thread mode stack used */
if((__get_CONTROL() & 0x02) == SP_MAIN)
{
/* Main stack is used as the current stack */
CurrentStack = SP_MAIN;
}
else
{
/* Process stack is used as the current stack */
CurrentStack = SP_PROCESS;
/* Get process stack pointer value */
PSPValue = __get_PSP();
}
/* Switch Thread mode from privileged to unprivileged ------------------------*/
/* Thread mode has unprivileged access */
__set_CONTROL(THREAD_MODE_UNPRIVILEGED | SP_PROCESS);
/* Unprivileged access mainly affect ability to:
- Use or not use certain instructions such as MSR fields
- Access System Control Space (SCS) registers such as NVIC and SysTick */
/* Check Thread mode privilege status */
if((__get_CONTROL() & 0x01) == THREAD_MODE_PRIVILEGED)
{
/* Thread mode has privileged access */
ThreadMode = THREAD_MODE_PRIVILEGED;
}
else
{
/* Thread mode has unprivileged access*/
ThreadMode = THREAD_MODE_UNPRIVILEGED;
}
/* Switch back Thread mode from unprivileged to privileged -------------------*/
/* Try to switch back Thread mode to privileged (Not possible, this can be
done only in Handler mode) */
__set_CONTROL(THREAD_MODE_PRIVILEGED | SP_PROCESS);
/* Generate a system call exception, and in the ISR switch back Thread mode
to privileged */
//__SVC();
/* Check Thread mode privilege status */
if((__get_CONTROL() & 0x01) == THREAD_MODE_PRIVILEGED)
{
/* Thread mode has privileged access */
ThreadMode = THREAD_MODE_PRIVILEGED;
}
else
{
/* Thread mode has unprivileged access*/
ThreadMode = THREAD_MODE_UNPRIVILEGED;
}
}
#endif
/******************* (C) COPYRIGHT 2008 STMicroelectronics *****END OF FILE****/

复制代码

赞评论

Dylan疾风闪电回答时间：2016-1-7 15:05:09

/**
******************************************************************************
* @file /CRC_Example.h
* @author xd.wu
* @version V1.0
* @date 2012-4-14
* @brief CRC：以多项式(0x4C11DB7)进行CRC计算得到一个32位的值
use CRC calculation unit to get a CRC code of a given buffer of data word,
based on a fixed generator polynomial(0x4C11DB7).
使用循环冗余校验(CRC) 以CRC-32(以太网)多项式(0x4C11DB7)为基础得到一个32位的CRC计算结果
CRC技术主要应用于核实数据传输或者数据存储的正确性和完整性。
******************************************************************************
*用途：校验一组数据
CRC->DR:写操作时，作为输入寄存器，可以输入要进行CRC计算的新数据。
读操作时，返回上一次CRC计算的结果。
每一次写入数据寄存器，其计算结果是前一次CRC计算结果和新计算结果的组合(对整个32位字进行CRC计算，而不是逐字节地计算)。
*/
/*实例应用步骤：
//1."main.cpp"调用fmain()
//2.Watch中观察
LED
*/
#ifndef __CRC_EXAMPLE_H
#define __CRC_EXAMPLE_H
/* Includes ------------------------------------------------------------------*/
#include "std32periph.h"
/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
#define BUFFER_SIZE 114
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
static uc32 DataBuffer[BUFFER_SIZE] =//const uint32_t
{
0x00001021, 0x20423063, 0x408450a5, 0x60c670e7, 0x9129a14a, 0xb16bc18c,
0xd1ade1ce, 0xf1ef1231, 0x32732252, 0x52b54294, 0x72f762d6, 0x93398318,
0xa35ad3bd, 0xc39cf3ff, 0xe3de2462, 0x34430420, 0x64e674c7, 0x44a45485,
0xa56ab54b, 0x85289509, 0xf5cfc5ac, 0xd58d3653, 0x26721611, 0x063076d7,
0x569546b4, 0xb75ba77a, 0x97198738, 0xf7dfe7fe, 0xc7bc48c4, 0x58e56886,
0x78a70840, 0x18612802, 0xc9ccd9ed, 0xe98ef9af, 0x89489969, 0xa90ab92b,
0x4ad47ab7, 0x6a961a71, 0x0a503a33, 0x2a12dbfd, 0xfbbfeb9e, 0x9b798b58,
0xbb3bab1a, 0x6ca67c87, 0x5cc52c22, 0x3c030c60, 0x1c41edae, 0xfd8fcdec,
0xad2abd0b, 0x8d689d49, 0x7e976eb6, 0x5ed54ef4, 0x2e321e51, 0x0e70ff9f,
0xefbedfdd, 0xcffcbf1b, 0x9f598f78, 0x918881a9, 0xb1caa1eb, 0xd10cc12d,
0xe16f1080, 0x00a130c2, 0x20e35004, 0x40257046, 0x83b99398, 0xa3fbb3da,
0xc33dd31c, 0xe37ff35e, 0x129022f3, 0x32d24235, 0x52146277, 0x7256b5ea,
0x95a88589, 0xf56ee54f, 0xd52cc50d, 0x34e224c3, 0x04817466, 0x64475424,
0x4405a7db, 0xb7fa8799, 0xe75ff77e, 0xc71dd73c, 0x26d336f2, 0x069116b0,
0x76764615, 0x5634d94c, 0xc96df90e, 0xe92f99c8, 0xb98aa9ab, 0x58444865,
0x78066827, 0x18c008e1, 0x28a3cb7d, 0xdb5ceb3f, 0xfb1e8bf9, 0x9bd8abbb,
0x4a755a54, 0x6a377a16, 0x0af11ad0, 0x2ab33a92, 0xed0fdd6c, 0xcd4dbdaa,
0xad8b9de8, 0x8dc97c26, 0x5c644c45, 0x3ca22c83, 0x1ce00cc1, 0xef1fff3e,
0xdf7caf9b, 0xbfba8fd9, 0x9ff86e17, 0x7e364e55, 0x2e933eb2, 0x0ed11ef0
};
vu32 CRCValue = 0;
/* Private functions ---------------------------------------------------------*/
void fmain(void)
{
RCC_HSEConf(9);//72M
/* Enable CRC clock */
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_CRC, ENABLE);
/* Compute the CRC of "DataBuffer" */
//CRCValue = CRC_CalcBlockCRC((u32 *)DataBuffer, BUFFER_SIZE);//此行代码的实现如下
CRC->CR = 0x1;//复位CRC->DR：如不进行复位，可能残留DR值，导致计算过程不是预期的
for(u8 index = 0; index < BUFFER_SIZE; index++)
{
CRC->DR = DataBuffer[index];
}
CRCValue = CRC->DR;
}
#endif

复制代码

赞评论

Dylan疾风闪电回答时间：2016-1-7 15:05:25

/**
******************************************************************************
* @file /DAC_2ChTriangleWave.h
* @author xd.wu
* @version V1.0
* @date 2012-4-14
* @brief DAC：使用不同三角波发生器的同时触发
******************************************************************************
*
*/
/*实例应用步骤：
//1."main.cpp"调用fmain()
//4.Watch中观察
DAC_DOR1
DAC_DOR2
*/
#ifndef __DAC_2CHTRIANGLEWAVE_H
#define __DAC_2CHTRIANGLEWAVE_H
/* Includes ------------------------------------------------------------------*/
#include "std32periph.h"
/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/* Private functions ---------------------------------------------------------*/
void fmain(void)
{
RCC_HSEConf(7);//56M
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_DAC | RCC_APB1Periph_TIM2, ENABLE);
//复位DAC
RCC_APB1PeriphResetCmd(RCC_APB1Periph_DAC, ENABLE);
RCC_APB1PeriphResetCmd(RCC_APB1Periph_DAC, DISABLE);
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4 | GPIO_Pin_5;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;
GPIO_Init(GPIOA, &GPIO_InitStructure);
/* TIM2 Configuration */
TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
TIM_TimeBaseStructInit(&TIM_TimeBaseStructure);
TIM_TimeBaseStructure.TIM_Period = 0xF;
TIM_TimeBaseStructure.TIM_Prescaler = 0xF;
TIM_TimeBaseStructure.TIM_ClockDivision = 0x0;
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);
/* TIM2 TRGO selection */
TIM_SelectOutputTrigger(TIM2, TIM_TRGOSource_Update);
/* DAC channel1 Configuration */
DAC_InitTypeDef DAC_InitStructure;
DAC_InitStructure.DAC_Trigger = DAC_Trigger_T2_TRGO;
DAC_InitStructure.DAC_WaveGeneration = DAC_WaveGeneration_Triangle;
DAC_InitStructure.DAC_LFSRUnmask_TriangleAmplitude = DAC_TriangleAmplitude_2047;
DAC_InitStructure.DAC_OutputBuffer = DAC_OutputBuffer_Disable;
DAC_Init(DAC_Channel_1, &DAC_InitStructure);
/* DAC channel2 Configuration */
DAC_InitStructure.DAC_LFSRUnmask_TriangleAmplitude = DAC_TriangleAmplitude_1023;
DAC_Init(DAC_Channel_2, &DAC_InitStructure);
DAC_Cmd(DAC_Channel_1, ENABLE);
DAC_Cmd(DAC_Channel_2, ENABLE);
DAC_SetDualChannelData(DAC_Align_12b_R, 0x100, 0x100);/* Set DAC dual channel DHR12RD register */
TIM_Cmd(TIM2, ENABLE);
}
#endif

复制代码

赞评论

Dylan疾风闪电回答时间：2016-1-7 15:05:40

/**
******************************************************************************
* @file /DAC_DMAEscalator.h
* @author xd.wu
* @version V1.0
* @date 2012-4-14
* @brief DAC：DMA输出梯形波
******************************************************************************
*
*/
/*实例应用步骤：
//1."main.cpp"调用fmain()
//4.Watch中观察
DAC_DHR12RD
*/
#ifndef __DAC_DMAESCALATOR_H
#define __DAC_DMAESCALATOR_H
/* Includes ------------------------------------------------------------------*/
#include "std32periph.h"
/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
uc8 Escalator8bit[6] = {0x0, 0x33, 0x66, 0x99, 0xCC, 0xFF};
/* Private functions ---------------------------------------------------------*/
void fmain(void)
{
RCC_HSEConf(7);//56M
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA2, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_DAC | RCC_APB1Periph_TIM6, ENABLE);
//复位DAC
RCC_APB1PeriphResetCmd(RCC_APB1Periph_DAC, ENABLE);
RCC_APB1PeriphResetCmd(RCC_APB1Periph_DAC, DISABLE);
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;
GPIO_Init(GPIOA, &GPIO_InitStructure);
/* TIM6 Configuration */
TIM_PrescalerConfig(TIM6, 0xF, TIM_PSCReloadMode_Update);
TIM_SetAutoreload(TIM6, 0xFF);
/* TIM6 TRGO selection */
TIM_SelectOutputTrigger(TIM6, TIM_TRGOSource_Update);
// DAC channel1 Configuration：MAMP1[]=0111、WAVE1[]=10、TSEL1[]=000、TEN1=1、BOFF1=1
DAC->CR &= 0xFFFFF000;
DAC->CR |= 0x00000786;
/* DMA2 channel3 configuration */
DMA_InitTypeDef DMA_InitStructure;
DMA_InitStructure.DMA_PeripheralBaseAddr = 0x40007410;//DAC_DHR8R1_Address;
DMA_InitStructure.DMA_MemoryBaseAddr = (u32)&Escalator8bit;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
DMA_InitStructure.DMA_BufferSize = 6;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
DMA_InitStructure.DMA_Priority = DMA_Priority_High;
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
DMA_Init(DMA2_Channel3, &DMA_InitStructure);
DMA_Cmd(DMA2_Channel3, ENABLE);
DAC_Cmd(DAC_Channel_1, ENABLE);
DAC_DMACmd(DAC_Channel_1, ENABLE);
TIM_Cmd(TIM6, ENABLE);
}
#endif

复制代码

赞评论

Dylan疾风闪电回答时间：2016-1-7 15:05:55

/**
******************************************************************************
* @file /DAC_DualModeDMASineWave.h
* @author xd.wu
* @version V1.0
* @date 2012-4-14
* @brief DAC：双DAC通道转换
DAC集成了3个供双DAC模式使用的寄存器：DHR8RD、DHR12RD和DHR12LD，
只需要访问一个寄存器即可完成同时驱动2个DAC通道的操作。
******************************************************************************
*用途：双路波形输出，可做简易示波器
*/
/*实例应用步骤：
//1."main.cpp"调用fmain()
//4.Watch中观察
DAC_DHR12RD
*/
#ifndef __DAC_DUALMODEDMASINEWAVE_H
#define __DAC_DUALMODEDMASINEWAVE_H
/* Includes ------------------------------------------------------------------*/
#include "std32periph.h"
/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
uc16 Sine12bit[32] =
{
0x0026, 0x009B, 0x0158, 0x0257, 0x038D, 0x04EF, 0x066F, 0x07FF, 0x098F, 0x0B0F, 0x0C71, 0x0DAA, 0x0EA6, 0x0F63, 0x0FD8, 0x0FFF,
0x0FD8, 0x0F63, 0x0EA6, 0x0DAA, 0x0C71, 0x0B0F, 0x098F, 0x07FF, 0x066F, 0x04EF, 0x038D, 0x0257, 0x0158, 0x009B, 0x0026, 0x0000
};
u32 DualSine12bit[32];
/* Private functions ---------------------------------------------------------*/
void fmain(void)
{
RCC_HSEConf(7);//56M
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA2, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_TIM8, ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_DAC, ENABLE);
//复位DAC
RCC_APB1PeriphResetCmd(RCC_APB1Periph_DAC, ENABLE);
RCC_APB1PeriphResetCmd(RCC_APB1Periph_DAC, DISABLE);
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4 | GPIO_Pin_5;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;
GPIO_Init(GPIOA, &GPIO_InitStructure);
/* TIM8 Configuration */
TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
TIM_TimeBaseStructInit(&TIM_TimeBaseStructure);
TIM_TimeBaseStructure.TIM_Period = 0x19;
TIM_TimeBaseStructure.TIM_Prescaler = 0x0;
TIM_TimeBaseStructure.TIM_ClockDivision = 0x0;
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseInit(TIM8, &TIM_TimeBaseStructure);
/* TIM8 TRGO selection */
TIM_SelectOutputTrigger(TIM8, TIM_TRGOSource_Update);
// DAC channel1,2 Configuration：WAVE1/2[]=00、TSEL1/2[]=001、TEN1/2=1、BOFF1/2=1
DAC->CR &= 0xFF00FF00;
DAC->CR |= 0x000E000E;
/* Fill Sine32bit table */
for (u8 Idx= 0; Idx<32; Idx++)
{
DualSine12bit[Idx] = (Sine12bit[Idx] << 16) + (Sine12bit[Idx]);
}
/* DMA2 channel4 configuration */
DMA_InitTypeDef DMA_InitStructure;
DMA_InitStructure.DMA_PeripheralBaseAddr = 0x40007420;//DAC_DHR12RD_Address;
DMA_InitStructure.DMA_MemoryBaseAddr = (u32)&DualSine12bit;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
DMA_InitStructure.DMA_BufferSize = 32;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Word;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Word;
DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
DMA_InitStructure.DMA_Priority = DMA_Priority_High;
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
DMA_Init(DMA2_Channel4, &DMA_InitStructure);
DMA_Cmd(DMA2_Channel4, ENABLE);
DAC_Cmd(DAC_Channel_1, ENABLE);
DAC_Cmd(DAC_Channel_2, ENABLE);
/* Enable DMA for DAC Channel2 */
DAC_DMACmd(DAC_Channel_2, ENABLE);//最终DAC->CR = 0x100F000F;
TIM_Cmd(TIM8, ENABLE);
}
#endif

复制代码

赞评论

Dylan疾风闪电回答时间：2016-1-7 15:06:13

/**
******************************************************************************
* @file /DAC_NoiseWave.h
* @author xd.wu
* @version V1.0
* @date 2012-4-14
* @brief DAC：噪声生成
可以利用线性反馈移位寄存器(Linear Feedback Shift Register LFSR)产生幅度变化的伪噪声。
设置WAVE[1:0]位为’01’选择DAC噪声生成功能。
寄存器LFSR的预装入值为0xAAA。
按照特定算法，在每次触发事件后3个APB1时钟周期之后更新该寄存器的值。
******************************************************************************
*用途：伪噪声生成器
*/
/*实例应用步骤：
//1."main.cpp"调用fmain()
//4.Watch中观察
DAC_DHR12LD
*/
#ifndef __DAC_NOISEWAVE_H
#define __DAC_NOISEWAVE_H
/* Includes ------------------------------------------------------------------*/
#include "std32periph.h"
/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/* Private functions ---------------------------------------------------------*/
void fmain(void)
{
RCC_HSEConf(7);//56M
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_DAC, ENABLE);
//复位DAC
RCC_APB1PeriphResetCmd(RCC_APB1Periph_DAC, ENABLE);
RCC_APB1PeriphResetCmd(RCC_APB1Periph_DAC, DISABLE);
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;
GPIO_Init(GPIOA, &GPIO_InitStructure);
// DAC channel1 Configuration：MAMP1[]=1000、WAVE1[]=01、TSEL1[]=111、TEN1=1、BOFF1=0、EN1=0
DAC->CR &= 0xFFFFF000;
DAC->CR |= 0x0000087C; //设置WAVE[1:0]位为’01’选择DAC噪声生成功能。
DAC_Cmd(DAC_Channel_1, ENABLE);
DAC_SetChannel1Data(DAC_Align_12b_L, 0x7FF0);/* Set DAC Channel1 DHR12L register */
while(1)
{
DAC_SoftwareTriggerCmd(DAC_Channel_1, ENABLE);/* Start DAC Channel1 conversion by software */
}
}
#endif

复制代码

赞评论

12 3 4 5 / 5 页下一页

所属标签

STM32F1

陈酿！四年陈的STM32F103外设测试代码！希望对你有帮助~~~ 精华

所属标签

相似分享

官网相关资源