本文介绍: 0xFFFF)) // 大于1M的存储,实际中发现了:0xFFFF,而且一个可能的STM32F1假芯片发现了这个问题addressTmp9 += 0x400 ) // 清除程序区。#define SWD_AUTO_ADDRESS_ADD_VALUE 0x400 // 特别警告:STM32F0系列地址自动增加大小为:1024个,而不是F1和F4的4096个!

#include “SWD_Module.h

vu8 slowModeEnable = 0;  // 默认不使能。0:不使能。1:使能!
vu8 AutoDownloadEnable = 0;
void SWD_Delay( void )  
{
    for( vu32 i=0;i<=3;i++ );   // 用于方便移植操作
}
/**
 *  @B 初始化SWD引脚需要功能
 *
 */

void SWDInit( void )
{
    { // IO引脚初始化
        { // 警告:使用了PB3/PB4,而这个是调试接口默认是这个功能,所以需要去掉
            RCC-&gt;APB2ENR.AFIOClockEnable_RW = ENABLE;     // 使能时钟
            AFIO-&gt;MAPR.SerialWireJTAGConfiguration_W = 2; // 只启用SWD引脚
        }
        
        if( HARDWARE_VERSION == LCD_VERSION )
        {
            RCC-&gt;APB2ENR.IOPBClockEnable_RW = ENABLE;
            SWD_SWDIO_MODE_OUT;  // 输出模式
            SWD_SWDIO_PIN_OUT = 1;  // 输出为1
            
            GPIOB-&gt;CRL.InOutMode6_RW = GPIO_CR_INOUNTMODE_OUTPUT_50MHZ;
            GPIOB-&gt;CRL.PinConfig6_RW = GPIO_CR_PINCONFG_OUT_GENERAL_PURPOSE_PUSHPULL;  // RESET
            SWD_RESET_PIN = 1;   // 低电平复位,所以不复位
            {  // SWCLK引脚控制:因为本身含有上拉电阻,所以使用开漏输出到1。
                RCC-&gt;APB2ENR.IOPAClockEnable_RW = ENABLE;
                GPIOA-&gt;CRH.InOutMode8_RW = GPIO_CR_INOUNTMODE_OUTPUT_50MHZ;
                GPIOA->CRH.PinConfig8_RW = GPIO_CR_PINCONFG_OUT_GENERAL_PURPOSE_PUSHPULL;  // 根据发现:使用开漏引脚,也会使输出0的能力降低,造成通信距离太短,出现dpID和错误过程中容易出错!
                SWD_SWCLK_PIN = 1;   // 默认高电平
                
                GPIOA->CRL.InOutMode0_RW = GPIO_CR_INOUNTMODE_OUTPUT_50MHZ;
                GPIOA->CRL.PinConfig0_RW = GPIO_CR_PINCONFG_OUT_GENERAL_PURPOSE_OPEN_DRAIN;  // 引脚开漏输出
                GPIOA->ODR.OutputData0_RW = 1;
                
                GPIOA->CRL.InOutMode1_RW = GPIO_CR_INOUNTMODE_OUTPUT_50MHZ;
                GPIOA->CRL.PinConfig1_RW = GPIO_CR_PINCONFG_OUT_GENERAL_PURPOSE_OPEN_DRAIN;  // 引脚开漏输出
                GPIOA->ODR.OutputData1_RW = 1;
            }
        }
        else
        {
            RCC->APB2ENR.IOPAClockEnable_RW = ENABLE;
            SWD_SWDIO_MODE_OUT;  // 输出模式
            SWD_SWDIO_PIN_OUT = 1;  // 输出为1
            
            GPIOB->CRL.InOutMode6_RW = GPIO_CR_INOUNTMODE_OUTPUT_50MHZ;
            GPIOB->CRL.PinConfig6_RW = GPIO_CR_PINCONFG_OUT_GENERAL_PURPOSE_PUSHPULL;  // RESET
            SWD_RESET_PIN = 1;   // 低电平复位,所以不复位
            { // 因为两个RESET引脚都用来复位,所以还需要PB1
                GPIOB->CRL.InOutMode1_RW = GPIO_CR_INOUNTMODE_OUTPUT_50MHZ;
                GPIOB->CRL.PinConfig1_RW = GPIO_CR_PINCONFG_OUT_GENERAL_PURPOSE_PUSHPULL;  // RESET
                GPIOB->ODR.OutputData1_RW = 1;
            }
            {  // SWCLK引脚控制:因为本身含有上拉电阻,所以使用开漏输出到1。
                RCC->APB2ENR.IOPAClockEnable_RW = ENABLE;
                GPIOA->CRL.InOutMode2_RW = GPIO_CR_INOUNTMODE_OUTPUT_50MHZ;
                GPIOA->CRL.PinConfig2_RW = GPIO_CR_PINCONFG_OUT_GENERAL_PURPOSE_PUSHPULL;  // 根据发现:使用开漏引脚,也会使输出0的能力降低,造成通信距离太短,出现dpID和错误过程中容易出错!
                SWD_SWCLK_PIN = 1;   // 默认为高电平
            }
        }
    }
}

void RAISE( u32 test )
{
    GPIOC->ODR.OutputData8_RW = test&amp;0x1;  //
    if( AutoDownloadEnable != ENABLE )
    {
        BeepCtrol(2,200);
    }
}

/**
 *  @B 暂时的目标是要求稳定!所以其中的延时比较多!
 *  @Warning 在转换方向时候需要注意,因为自己加了缓冲器,方向需要注意!
 *  结尾后:SWCLK保持为1
 */
void WRITE_BIT( u8 bit )
{
    if( slowModeEnable == ENABLE )
    {
        SWD_Delay();
        SWD_SWDIO_PIN_OUT = bit;
        SWD_Delay();
        SWD_SWCLK_PIN = 0;
        SWD_Delay();
        SWD_SWCLK_PIN = 1;
        SWD_Delay();
    }
    else
    {
        SWD_SWDIO_PIN_OUT = bit;
        SWD_SWCLK_PIN = 0;
        SWD_SWCLK_PIN = 1;
    }
}

u8 READ_BIT( void )
{
    u8 bit;
    if( slowModeEnable == ENABLE)
    {
        SWD_Delay( );
        SWD_SWCLK_PIN = 0;
        SWD_Delay( );
        bit = SWD_SWDIO_PIN_IN;
        SWD_Delay( );
        SWD_SWCLK_PIN = 1;
        SWD_Delay( );
    }
    else
    {
        SWD_SWCLK_PIN = 0;
        bit = SWD_SWDIO_PIN_IN;
        SWD_SWCLK_PIN = 1;
    }
    return bit;
}
/**
 *  @B 可以理解为TurnAround
 *
 */
void SWCLK_CYCLE( void  )
{
    if( slowModeEnable == ENABLE)
    {
        SWD_Delay();
        SWD_SWCLK_PIN = 0;
        SWD_Delay();
        SWD_SWCLK_PIN = 1;
        SWD_Delay();
    }
    else
    {
        SWD_SWCLK_PIN = 0;
        SWD_SWCLK_PIN = 1;
    }
}

/**
 *  @B 可以理解为TurnAround
 *
 */
void SWDIO_CYCLE( void )
{
    if( slowModeEnable == ENABLE)
    {
        SWD_Delay();
        SWD_SWDIO_PIN_OUT = 0;
        SWD_Delay();
        SWD_SWDIO_PIN_OUT = 1;
        SWD_Delay();
    }
    else
    {
        SWD_SWDIO_PIN_OUT = 0;
        SWD_SWDIO_PIN_OUT = 1;
    }
}
/**
 *  @B 从AP或者DP寄存器里读出数据
 *     reg:显然只有4个(暂定的取值范围0-3)。  data为什么指针,因为这样才能改变传递值,也就是指针指向的值
 *  结尾后:SWCLK保持为1
 */
u32 readReg( u8 APnDPReg,u8 reg, u32 *data )
{
    u8 i = 0;
    u8 cb = 0;  //
    u8 parity;  // 校验
    u8 b = 0;                // 用于读ACK的位
    u8 ack = 0; // ACK的值
    u8 ret = SWD_ERROR_OK;
    
    *data = 0;
    
    int _APnDPReg = (int) APnDPReg;
  int _read = (int) 1;  // 读请求值为1
    
    u8 A2 = reg &amp; 0x01;
    u8 A3 = ( reg>>1 ) &amp; 0x01;
    
    parity = ( _APnDPReg + _read + A2 + A3 ) &amp; 0x01;
    
    SWD_SWDIO_MODE_OUT;   // 设置为输出模式
//    SWD_SWDIO_DIR_CTR2 = BUFFER_IC_DIR_OUT;  // 缓冲设置为输出模式
    
    {  // 启动发送序列
        // 发送序列问题发送后,可以看出,其中SWCLK保持为1:
        WRITE_BIT( 1 );
        WRITE_BIT( _APnDPReg );
        WRITE_BIT( _read );
        WRITE_BIT( A2 );
        WRITE_BIT( A3 );
        WRITE_BIT( parity );
        WRITE_BIT( 0 );
        WRITE_BIT( 1 );   // SWDIO = 1, SWCLK = 0, SWCLK = 1
    }
    { // TurnAround
        {
            SWD_SWDIO_MODE_IN;   // 设置输入模式
//            SWD_SWDIO_DIR_CTR2 = BUFFER_IC_DIR_IN;  // 缓冲设置输入模式
        }
        SWCLK_CYCLE();
    }
    {  // 读ACK
        for( i=0;i<3;i++ )
        {
            b = READ_BIT( );
            ack |= b<<i;
        }
          // 按照我的理解这里不是应该一个Trn的么?但是却没有
    }
    { // 判断ACK位
        if( ack == ACK_OK )
        {
            for( i=0;i<32;i++)
            {
                b = READ_BIT( );
                *data |= b<<i;
                if(b)
                    cb = !cb;  // cb之前已经初始化
            }
            parity = READ_BIT();  // 最后再读一下校验
                                  // 要使系统稳定的话,处理错误至关重要
            if( cb == parity )
            {
                ret = SWD_ERROR_OK;  // 系统正常
            }
            else
            {
                ret = SWD_ERROR_PARITY;  // 校验错误,检验错误就可能是位操作不对,当然这个概率是50%
            }
        }
        else if( ack == ACK_WAIT )
        {
            ret = SWD_ERROR_WAIT;
        }
        else if( ack == ACK_FAULT )
        {
            ret = SWD_ERROR_FAULT;
        }
        else
        {
            ret = SWD_ERROR_PROTOCOL;  //协议出错,这个要注意了
        }
    }
    
    { // Turnaround
        SWCLK_CYCLE();
    }
    { // 进入8个Idle状态,确保传输
        {
            SWD_SWDIO_MODE_OUT;   // 设置输入模式
//            SWD_SWDIO_DIR_CTR2 = BUFFER_IC_DIR_OUT;  // 缓冲设置输入模式
        }
        for( i=0;i<8;i++ )
        {
            WRITE_BIT(0);
        }
    }
    return ret;    // 返回值
}

/**
 *  @B 这里有个要注意:可以忽视Ack,因为清除错误需要访问内容寄存器
 *
 */
u32 writeReg( u8 APnDPReg,u8 reg,u32 data,u8 ignoreAck)
{
    u8 ack = 0;
    u8 i;
    u8 parity = 0;
    u8 b;
    u8 ret = SWD_ERROR_OK;
    
    u8 _APnDPReg = APnDPReg;
    u8 _read = 0;
    
    u8 A2 = reg&amp;0x1;
    u8 A3 = (reg>>1)&amp;0x1;
    
    parity = ( _APnDPReg + _read +A2 + A3 )&amp;0x1;  // 计算校验
    
    SWD_SWDIO_MODE_OUT;   // 设置为输出模式
//    SWD_SWDIO_DIR_CTR2 = BUFFER_IC_DIR_OUT;  // 缓冲器设置为输出模式
    
    {  // 启动发送序列
        // 发送序列问题发送后,可以看出,其中SWCLK保持为1:
        WRITE_BIT( 1 );
        WRITE_BIT( _APnDPReg );
        WRITE_BIT( _read );
        WRITE_BIT( A2 );
        WRITE_BIT( A3 );
        WRITE_BIT( parity );
        WRITE_BIT( 0 );
        WRITE_BIT( 1 );   // SWDIO = 1, SWCLK = 0, SWCLK = 1 (这个由主机驱动为1的!手册说是不用主机驱动,但是由于上拉总线上会为1)
    }
    {
        { // 发现一个特别奇葩的问题:就是如果把这一句,放到SWCLK_CYCLE();之后就会出现:ACK错误比较费解!
            // 可能的原因:就是从机这个时候要驱动SWDIO,但是发现驱动不下来!!
            // 最好的解决办法:就是通过读DP寄存器找到这个问题!
            SWD_SWDIO_MODE_IN;
//            SWD_SWDIO_DIR_CTR2 = BUFFER_IC_DIR_IN;
        }
        SWCLK_CYCLE();
    }
    {
        {
            
            // 读ACK
            for( i=0;i<3;i++ )
            {
                b = READ_BIT( );
                ack |= b<<i;
            }
                // 按照我的理解这里不是应该一个Trn的么?但是却没有,(最后发现读是没有的人,但是写是有的!写的在下面)
        }
    }
    { //
        if( (ack == ACK_OK) || ignoreAck )
        {
            
            { // 设置为输出
                SWD_SWDIO_MODE_OUT;   // 设置为输出模式
//                SWD_SWDIO_DIR_CTR2 = BUFFER_IC_DIR_OUT;  // 缓冲器设置为输出模式
            }
            SWCLK_CYCLE();  // 写的时候要用Trn一次。但是读的时候没有代码里面看到
            parity = 0;    // 这个函数有问题,当我改parity的时候,出现可以读状态说明给器件的值存在检验错误!!这个是不应该的。这个要检查
            for( i=0;i<32;i++ )
            {
                b = ( data >> i)&amp;0x1;
                WRITE_BIT(b);
                if(b)
                    parity = !parity;
            }
            WRITE_BIT(parity);
        }
        else if( ack == ACK_WAIT )
        {
            ret = SWD_ERROR_WAIT;
        }
        else if( ack == ACK_FAULT )
        {
            ret = SWD_ERROR_FAULT;
        }
        else
        {
            ret = SWD_ERROR_PROTOCOL;  //协议出错,这个要注意了
        }
        
        { // 进入8个Idle状态,确保传输,这个可以优化
            {  // 这个其实是多余的,一直是输出的,所以我都考虑这个源代码性能了。
                SWD_SWDIO_MODE_OUT;   // 设置为输入模式
//                SWD_SWDIO_DIR_CTR2 = BUFFER_IC_DIR_OUT;  // 缓冲器设置为输入模式
            }
            for( i=0;i<8;i++ )
            {
                WRITE_BIT(0);
            }
        }
    }
    return ret;
}

/**
 *  @B 上电执行JTAG转SWD的序列函数
 *
 */
void JTAG_To_SWD_Sequence( void )
{
  int i;
  int b;
 
    SWD_SWDIO_MODE_OUT;   // 设置为输出模式
//    SWD_SWDIO_DIR_CTR2 = BUFFER_IC_DIR_OUT;  // 缓冲器设置为输出模式
    {
        SWD_SWDIO_PIN_OUT = 1;   // 先输出为1
        for( i=0;i<80;i++ )
        {
                SWCLK_CYCLE();
        }
    }
    for( i=0;i<16;i++ )
    {
        b = ( JTAG_TO_SWD_VALUE>>i )&amp;0x1;
        WRITE_BIT(b);
    }
    {
        SWD_SWDIO_PIN_OUT = 1;
        for( i=0;i<60;i++ )
        {
                SWCLK_CYCLE();
        }
    }
    { // 执行16个空闲周期
        SWD_SWDIO_PIN_OUT = 0;
        for( i=0;i<16;i++ )
        {
            SWCLK_CYCLE();
        }
        SWD_SWDIO_PIN_OUT = 1;  // 实际中,因为少了,这一句导致只能下载F1,F4/F2总是出现问题。
    }
        
}

/**
 *  @B 写AP寄存器,在当前选择的APBANK。
 *
 */

void writeAP( u8 reg,u32 data)
{
    u8 forFault = 0;
    forWait:
    {
        u8 swdStatus;
        u8 retry = 1;  // 这个是重试次数,但是日后应该做下载器,则这个变量是一定要提取出来的
        do
        {
            swdStatus = writeReg(1,reg,data,FALSE);
            retry–;
        }while( (swdStatus == SWD_ERROR_WAIT) &amp;&amp; retry>0 );
        if( swdStatus != SWD_ERROR_OK )
        {
            if( swdStatus == SWD_ERROR_WAIT )
            {
                goto forWait;  // 在测试F2的时候,出现了不定时的这个问题,所以才用这个方法
            }
            else if( swdStatus == SWD_ERROR_FAULT )
            {
                if( forFault == 0 ) // 重试次数超出
                {
                    forFault ++;
                    writeDP( DP_ABORT,0x1F);
                    goto forWait;
                }
                else
                {
                    RAISE( swdStatus );
                }
            }
            else
            {
                RAISE( swdStatus );  // 根据查询源码,这个函数的操作相对比较麻烦,需要自己日后重新定义
            }
        }
    }
}

/**
 *  @B 写DP寄存器
 *
 */
void writeDP( u8 reg,u32 data )
{
    u8 forFault = 0;
    forWait:
    {
        u8 swdStatus;
        u8 retry = 10;  // 重试次数
        do
        {
            swdStatus = writeReg(0,reg,data,FALSE);
            retry–;
        }while( (swdStatus == SWD_ERROR_WAIT) &amp;&amp; retry>0 );
        if( swdStatus != SWD_ERROR_OK )
        {
            if( swdStatus == SWD_ERROR_WAIT )
                {
                    goto forWait;  // 在测试F2的时候,出现了不定时的这个问题,所以才用这个方法
                }
                else if( swdStatus == SWD_ERROR_FAULT )
                {
                    if( forFault == 0 ) // 重试次数超出
                    {
                        forFault ++;
                        writeDP( DP_ABORT,0x1F);
                        goto forWait;
                    }
                    else
                    {
                        RAISE( swdStatus );
                    }
                }
                else
                {
                    RAISE( swdStatus );
                }
        }
    }
}

/**
 *  @B 写DP寄存器但是忽略ACK位,这个显然是出错之后的操作!
 *
 */
void writeDPIgnoreAck( u8 reg,u32 data )
{
    u8 forFault = 0;
    forWait:
    {
        u8 swdStatus;
        u8 retry = 10;  // 重试次数
        do
        {
            swdStatus = writeReg(0,reg,data,TRUE);
            retry–;
        }while( (swdStatus == SWD_ERROR_WAIT) &amp;&amp; retry>0 );
        if( swdStatus != SWD_ERROR_OK )
        {
            if( swdStatus == SWD_ERROR_WAIT)
                {
                    goto forWait;  // 在测试F2的时候,出现了不定时的这个问题,所以才用这个方法
                }
                else if( swdStatus == SWD_ERROR_FAULT )
                {
                    if( forFault == 0 ) // 重试次数超出
                    {
                        forFault ++;
                        writeDP( DP_ABORT,0x1F);
                        goto forWait;
                    }
                    else
                    {
                        RAISE( swdStatus );
                    }
                }
                else
                {
                    RAISE( swdStatus );  // 出错处理特别重要!
                }
        }
    }
}

/**
 *  @B 读AP
 *
 */
void readAP( u8 reg,u32 *data )
{
    u8 forFault = 0;
    forWait:
    {
        u8 swdStatus;
        u8 retry = 10;  // 重试次数
        do
        {
            swdStatus = readReg( 1,reg,data );
            retry–;
        }while( (swdStatus == SWD_ERROR_WAIT) &amp;&amp; retry>0 );
        if( swdStatus != SWD_ERROR_OK )
        {
            if( swdStatus == SWD_ERROR_WAIT)
                {
                    goto forWait;  // 在测试F2的时候,出现了不定时的这个问题,所以才用这个方法
                }
                else if( swdStatus == SWD_ERROR_FAULT )
                {
                    if( forFault == 0 ) // 重试次数超出
                    {
                        forFault ++;
                        writeDP( DP_ABORT,0x1F);
                        goto forWait;
                    }
                    else
                    {
                        RAISE( swdStatus );
                    }
                }
                else
                {
                    RAISE( swdStatus );  // 出错处理特别重要!
                }
        }
    }
}

/**
 *  @B 读DP
 *
 */
void readDP( u8 reg,u32 * data )
{
    u8 forFault = 0;
    forWait:
    {
        u8 swdStatus;
        u8 retry = 10;  // 重试次数
        do
        {
            swdStatus = readReg( 0,reg,data );
            retry–;
        }while( (swdStatus == SWD_ERROR_WAIT) &amp;& retry>0 );
        if( swdStatus != SWD_ERROR_OK )
        {
            if( swdStatus == SWD_ERROR_WAIT)
                {
                    goto forWait;  // 在测试F2的时候,出现了不定时的这个问题,所以才用这个方法
                }
                else if( swdStatus == SWD_ERROR_FAULT )
                {
                    if( forFault == 0 ) // 重试次数超出
                    {
                        forFault ++;
                        writeDP( DP_ABORT,0x1F);
                        goto forWait;
                    }
                    else
                    {
                        RAISE( swdStatus );
                    }
                }
                else
                {
                    RAISE( swdStatus );  // 出错处理特别重要!
                }
        }
    }
}

/**
 *  @B 初始化DP,先发送一个转换序列,然后读出IDCode的值。
 *
 */
u32 initDp( void )
{
    u32 dpId;
    JTAG_To_SWD_Sequence(  );
    readDP(DP_IDCODE,&dpId);  //
    
    //Debug power up request,这个应该打开调试组件电源,方便调试
    writeDP( DP_CTRL, DP_CTRL_CSYSPWRUPREQ | DP_CTRL_CDBGPWRUPREQ );
    
    // Wait until we receive powerup ACK
    int retry = 300;
    u32 status;
    while( retry>0 )
    {
        readDP(DP_CTRL,&status);
        // 下面的这个是什么意思?
        if ( ( status & ( DP_CTRL_CDBGPWRUPACK | DP_CTRL_CSYSPWRUPACK ) )
      == ( DP_CTRL_CDBGPWRUPACK | DP_CTRL_CSYSPWRUPACK ) )
    {
      break;
    }
    retry–;
    }
    
    /* Throw error if we failed to power up the debug interface */
  if ( ( status & ( DP_CTRL_CDBGPWRUPACK | DP_CTRL_CSYSPWRUPACK ) )
    != ( DP_CTRL_CDBGPWRUPACK | DP_CTRL_CSYSPWRUPACK ) )
  {
//    RAISE( SWD_ERROR_DEBUG_POWER );  // 这个出错不好管理
        RAISE( status );
  }
 
  /* Select first AP bank */
  writeDP( DP_SELECT, 0x00 );
 
  return dpId;  // 应该是1BA01477(F4读出的值为:2BA01477)  F2测试也是:2BA01477
}

/**
 *  @B 这个可能是针对EMF32单片机的,但是有一定的参考价值!这也能读出来东西,但是不知道什么含义!
 */
u32 readApID( void )
{
    u32 apId;
    /* Select last AP bank */
  writeDP( DP_SELECT, 0xf0 );  // 写DP寄存器中的APBBANKSEL位为0xF
//    writeDP( DP_SELECT, 0x08000003 );
 
  /* Dummy read AP ID */
  readAP( AP_IDR, &apId );
 
  /* Read AP ID */
  readDP( DP_RDBUFF, &apId );
 
  /* Select first AP bank again */
  writeDP( DP_SELECT, 0x00 );
 
  return apId; // EMF手册说明这个值应该是:0x24770011(F4读出的值是这个!),但是实际读出来是0x14770011(F103)。不知道这是什么含义!
}

/**
 *  @B 不明觉厉
 *
 */
/**********************************************************
 * Sends the AAP Window Expansion Sequence. This sequence
 * should be sent on SWDIO/SWCLK when reset is held low.
 * This will cause the AAP window to be 255 times longer
 * when reset is released.
 **********************************************************/
void aapExtensionSequence( void )
{
  int i;
 
    SWD_RESET_PIN = 0;
    
  SWD_SWCLK_PIN = 1;
 
  for ( i = 0; i < 4; i++ )
  {
    SWDIO_CYCLE( );
  }
 
  SWD_SWCLK_PIN = 0;
 
  for ( i = 0; i < 4; i++ )
  {
    SWDIO_CYCLE( );
  }
 
  SWD_SWCLK_PIN = 0;
    
    SWD_RESET_PIN = 1;
}

/* 从下面开始,就是移植的另外一个程序–在SRAM中编程具有不错的参考价值 */
/**
 *  @B 对于程序,务必要停止运行后,再写FLash操作!所以这个函数存在
 *
 */
void connect_and_halt_core( void )
{
    u32 rw_data;
    rw_data = CHIPAP_BANK_F;
    
    
    if( rw_data != 0x2430002 )
    {
        return;
    }
    
    
}

/*以上,就是移植的另外一个程序–在SRAM中编程具有不错的参考价值 */

/* 从下面开始,是自己测试程序 */
u32 readMemoryFormStm32( void )
{
    u32 apId = 0;
    vu32 address = 0x08000000;
    /* Select last AP bank */
//    while(1)
    {  // 按照下面的程序测试,速度大约是:4MHZ左右(3.7MHZ)测试一次!还是比较给力的。
        writeDP( DP_SELECT, 0x00 );  // 访问寄存器
    //    writeDP( DP_SELECT, 0x08000003 );
        
        writeAP( AP_CSW,0x2);   // 长度为32bit
        
        writeAP( AP_TAR,address);   // 写目标地址
        readAP( AP_DRW,&apId);
        
        /* Read AP ID */
        readDP( DP_RDBUFF, &apId );
        address++;
  }
 
  return apId;
}

/**
 *  @B 测试
 *
 */

void testFlashChearAndWrite( void )
{
    {    // 清空Flash
        
    }
    { // 写Flash
        
    }
}

#define CMX_AIRCR 0xE000ED0C
#define RUN_CMD_CRJ 0x05FA0007  // 这个是从:DAP中提取出来的,不知道行不行!!

#define CM3_DHCSR 0xE000EDF0
#define CM3_DEMCR 0xE000EDFC
/* Write these to DHCSR */
#define RUN_CMD  0xA05F0001
#define STOP_CMD 0xA05F0003
#define STEP_CMD 0xA05F0005
#define DEBUG_EVENT_TIMEOUT 200
/**
 *  @B Halting the MCU
 *
 */
void haltTarget(void)
{
    u32 tmp;
    writeAP(AP_TAR, CM3_DEMCR);
    readAP(AP_DRW, &tmp);
    readDP(DP_RDBUFF, &tmp);
    
    
    writeAP( AP_CSW,0x23000002);   // 一定要先提前写上这个,不仅仅表示是32位,同时表明访问方向是写访问!否则会报错!!
  int timeout = DEBUG_EVENT_TIMEOUT;
  writeAP(AP_TAR, CM3_DHCSR);
  writeAP(AP_DRW, STOP_CMD);
    
    writeAP(AP_TAR, CM3_DEMCR);
  writeAP(AP_DRW, 0x01000401);  // Write 1 to bit VC_CORERESET in DEMCR. This will enable halt-onreset
    

  uint32_t dhcrState;
  do {
    writeAP(AP_TAR, CM3_DHCSR);
    readAP(AP_DRW, &dhcrState);
    readDP(DP_RDBUFF, &dhcrState);
    timeout–;
  } while ( !(dhcrState & CoreDebug_DHCSR_S_HALT_Msk) && timeout > 0 );
 
  if ( !(dhcrState & CoreDebug_DHCSR_S_HALT_Msk) ) {
//        RAISE(dhcrState);
  }
    { // 手册给的建议是:使能一个断点!!
    }
}

/**
 *  @B 测试成功,可以启动程序!但是要注意CSW的值,需要设置为:0x23000002(暂时不明白含义,这个要注意!日后再做!)
 *
 */
void runTarget(void)
{
    uint32_t i;
    writeAP( AP_CSW,0x23000002);
    
    writeAP(AP_TAR, CM3_DEMCR);
  writeAP(AP_DRW, 0x01000400);  // 避免复位停在Reset
    for (i=0; i<100; i++);
  writeAP(AP_TAR, CM3_DHCSR);
  writeAP(AP_DRW, RUN_CMD);
    
    
    
    for (i=0; i<100; i++);
    writeAP(AP_TAR, CMX_AIRCR);
  writeAP(AP_DRW, RUN_CMD_CRJ);
    for (i=0; i<100; i++);
    writeAP(AP_TAR, CMX_AIRCR);
  writeAP(AP_DRW, RUN_CMD_CRJ);
}

/**********************************************************
 * Reads one word from internal memory
 *
 * @param addr
 *    The address to read from
 *
 * @returns
 *    The value at @param addr
 **********************************************************/
uint32_t readMem(uint32_t addr)
{
  uint32_t ret;
  writeAP(AP_TAR, addr);
  readAP(AP_DRW, &ret);
  readDP(DP_RDBUFF, &ret);
  return ret;
}
/**********************************************************
 * Writes one word to internal memory
 *
 * @param addr
 *    The address to write to
 *
 * @param data
 *    The value to write
 *
 * @returns
 *    The value at @param addr
 **********************************************************/
void writeMem(uint32_t addr, uint32_t data)
{
  writeAP(AP_TAR, addr);
  writeAP(AP_DRW, data);
}
/**********************************************************
 * Resets the target CPU by using the AIRCR register.
 * The target will be halted immediately when coming
 * out of reset. Does not reset the debug interface.
 **********************************************************/
void resetAndHaltTarget(void)
{
  uint32_t dhcsr;
  int timeout = DEBUG_EVENT_TIMEOUT;
 
  /* Halt target first. This is necessary before setting
   * the VECTRESET bit */
  haltTarget();
 
  /* Set halt-onreset bit */
  writeMem(DEMCR, CoreDebug_DEMCR_VC_CORERESET_Msk);
 
  /* Clear exception state and reset target */
  writeAP(AP_TAR, AIRCR);
  writeAP(AP_DRW, (0x05FA << SCB_AIRCR_VECTKEY_Pos) |
                  SCB_AIRCR_VECTCLRACTIVE_Msk |
                  SCB_AIRCR_VECTRESET_Msk);
    
  /* Wait for target to reset */
  do {
    TimeDelayOfSoftAtMs(1);
    timeout–;
    dhcsr = readMem(DHCSR);
  } while ( dhcsr & CoreDebug_DHCSR_S_RESET_ST_Msk );
 
 
  /* Check if we timed out */
  dhcsr = readMem(DHCSR);
  if ( dhcsr & CoreDebug_DHCSR_S_RESET_ST_Msk )
  {
//    RAISE(SWD_ERROR_TIMEOUT_WAITING_RESET);
        RAISE(1);
  }
 
  /* Verify that target is halted */
  if ( !(dhcsr & CoreDebug_DHCSR_S_HALT_Msk) )
  {
//    RAISE(SWD_ERROR_TARGET_NOT_HALTED);
        RAISE(1);
  }
}

/**
 *  @B 清空STM32 Flash操作
 *
 */
void clearAllFlash( void )
{
    OS_ERR err;
    writeAP( AP_CSW,0x23000002);   // 一定要先提前写上这个,不仅仅表示是32位,同时表明访问的方向是写访问!否则会报错!!
    
  writeAP(AP_TAR, (u32)&FLASH->KEYR.FlashProgramAndEraseControllerKey_W);
  writeAP(AP_DRW, FLASH_KEY1);
    
    writeAP(AP_TAR, (u32)&FLASH->KEYR.FlashProgramAndEraseControllerKey_W);
  writeAP(AP_DRW, FLASH_KEY2);
    
    { // 清除错误
            writeAP(AP_TAR, (u32)&FLASH->SR.All ) ;
            writeAP(AP_DRW, _0b00110100);
    }
    
    writeAP( AP_CSW,0x00000002);   // 读
    u32 readWord0 = 0;
    do
    {
        writeAP(AP_TAR, (u32)&FLASH->SR.All);
        readAP(AP_DRW,&readWord0);
        readDP(DP_RDBUFF,&readWord0);
    }while(readWord0&0x1); // 当为1的时候说明没有操作完成!
    
    writeAP( AP_CSW,0x23000002);   // 一定要先提前写上这个,不仅仅表示是32位,同时表明访问的方向是写访问!否则会报错!!
    writeAP( AP_TAR, (u32)&FLASH->CR.All );
  writeAP( AP_DRW, _0b00000100 );  // 注意:擦除的时候要分开写。
    
    writeAP( AP_TAR, (u32)&FLASH->CR.All );
  writeAP( AP_DRW, _0b01000100 );  // 先写清除全片,再写开始位!!
    
    writeAP( AP_CSW,0x00000002);   // 读
    u32 readWord1 = 0;
    do
    {
        writeAP(AP_TAR, (u32)&FLASH->SR.All);
        readAP(AP_DRW,&readWord1);
        readDP(DP_RDBUFF,&readWord1);
    }while(readWord1&0x1); // 当为1的时候说明没有操作完成!
    { // 根据客户反应,全片擦除有可能存在没有完成的地方,所以本次严格的按照操作来操作!!
        //
            do
            {
                writeAP(AP_TAR, (u32)&FLASH->SR.All);
                readAP(AP_DRW,&readWord1);
                readDP(DP_RDBUFF,&readWord1);
            }while( ( readWord1&_0b00100000 ) != _0b00100000);
    }
    { // 清除错误
            writeAP( AP_CSW,0x23000002);   // 一定要先提前写上这个,不仅仅表示是32位,同时表明访问的方向是写访问!否则会报错!!
            writeAP(AP_TAR, (u32)&FLASH->SR.All);
              writeAP(AP_DRW, _0b00110100);
    }
    OSTimeDlyHMSM(0,0,0,1000,OS_OPT_TIME_HMSM_NON_STRICT,&err);
}

/**
 *  @B 写Flash程序操作!测试!
 *
 */

void writeFlash( void )
{
    
}

/**
 *  @B F0系列保护操作选项,注意:F0系列的FLASH编程也是16bit一次编程这个和F1的操作是一样的。
    @warning 实际中发现F0的寄存器分配和F1分配是一样的,所以选择用F1的寄存器进行操作。
 *  
 */
void stm32f0Protection( u8 readProtectionEnable,u8 writeProtectionEnable )
{
    u32 readWord1 = 0;
//    if( (readProtectionEnable == 1) || (writeProtectionEnable == 1 ))  //
//    {
        {  // 解锁Flash操作
            writeAP( AP_CSW,0x23000002);   // 一定要先提前写上这个,不仅仅表示是32位,同时表明访问的方向是写访问!否则会报错!!
            
            writeAP(AP_TAR, (u32)&FLASH->KEYR.FlashProgramAndEraseControllerKey_W);
            writeAP(AP_DRW, FLASH_KEY1);
            
            writeAP(AP_TAR, (u32)&FLASH->KEYR.FlashProgramAndEraseControllerKey_W);
            writeAP(AP_DRW, FLASH_KEY2);
        }
        {
            do
            {
                writeAP(AP_TAR, (u32)&FLASH->SR.All);
                readAP(AP_DRW,&readWord1);
                readDP(DP_RDBUFF,&readWord1);
            }while(readWord1&0x1); // 当为1的时候说明没有操作完成!
        }        
        { // 解锁OptionsByte操作
            writeAP(AP_TAR, (u32)&FLASH->OPTKEYR.OptionByteKey_W);
            writeAP(AP_DRW, FLASH_KEY1);
            
            writeAP(AP_TAR, (u32)&FLASH->OPTKEYR.OptionByteKey_W);
            writeAP(AP_DRW, FLASH_KEY2);
        }
        {
            writeAP(AP_TAR, (u32)&FLASH->CR.All);
            writeAP(AP_DRW, _0b00100000 + 0x200 );  // 清除选项字节,注意:此时读保护依然在,写保护被清除,用户字节被清除
            
            writeAP(AP_TAR, (u32)&FLASH->CR.All);
            writeAP(AP_DRW, _0b01100000 + 0x200 );  // 开始操作
            
            do
            {
                writeAP(AP_TAR, (u32)&FLASH->SR.All);
                readAP(AP_DRW,&readWord1);
                readDP(DP_RDBUFF,&readWord1);
            }while(readWord1&0x1); // 忙时卡住
        }
        { // 先不要置位读保护
            
        }
        {
            writeAP(AP_TAR, (u32)&FLASH->CR.All);
            writeAP(AP_DRW, _0b00000000 + 0x200 );  // 恢复现
            
            writeAP(AP_TAR, (u32)&FLASH->CR.All);
            writeAP(AP_DRW, _0b00010000 + 0x200 );  // 选项字节编程使能!
        }
        {
            if( readProtectionEnable == ENABLE )  // 默认状态下就是读保护使能的!(因为清除了!)
            {
//                writeAP(AP_TAR, (u32)&OB->RDP);
//                writeAP(AP_DRW, 0x00);  // 0x00也是读保护
            }
            else
            {
                writeAP( AP_CSW,0x23000001 ); // 长度为16bit,写(操作Flash必须用u16形式,否则会出问题!)
                writeAP( AP_TAR, (u32)&OB->RDP );
                if( ((u32)&OB->RDP)%4 != 0 )
                {
                    writeAP( AP_DRW, 0xAA<<16 );  // 清除读保护,当值为0xAA时,关读保护!
                }
                else
                {
                    writeAP( AP_DRW, 0xAA);  // 清除读保护
                }
            }
            if( writeProtectionEnable == ENABLE )
            {
                writeAP( AP_CSW,0x23000001 ); // 长度为16bit,写(操作Flash必须用u16形式,否则会出问题!)
                writeAP( AP_TAR, (u32)&OB->WRP0 );
                writeAP( AP_DRW, 0x00 );
                
                writeAP( AP_TAR, (u32)&OB->WRP1 );
                writeAP( AP_DRW, 0x00 );
                
                writeAP( AP_TAR, (u32)&OB->WRP2 );
                writeAP( AP_DRW, 0x00 );
                
                writeAP( AP_TAR, (u32)&OB->WRP3 );
                writeAP( AP_DRW, 0x00 );
                
            }
            else // 之前已经清除了,所以不需要管!
            {
//                writeAP(AP_TAR, (u32)&OB->RDP);
//                writeAP(AP_DRW, 0xFFFFFFFF);  // 清除读保护
            }
            
            writeAP( AP_CSW,0x23000002 ); // 恢复为32位
            
            do
            {
                writeAP(AP_TAR, (u32)&FLASH->SR.All);
                readAP(AP_DRW,&readWord1);
                readDP(DP_RDBUFF,&readWord1);
            }while(readWord1&0x1); // 忙时卡住
            
        }
        {
            writeAP(AP_TAR, (u32)&FLASH->CR.All);
            writeAP(AP_DRW, _0b00000000 + 0x200 );  // 恢复现
            
            writeAP(AP_TAR, (u32)&FLASH->CR.All);
            writeAP(AP_DRW, _0b10000000);      // 锁定操作
        }
}

原文地址:https://blog.csdn.net/lbaihao/article/details/134744675

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任

如若转载,请注明出处:http://www.7code.cn/show_23728.html

如若内容造成侵权/违法违规/事实不符,请联系代码007邮箱suwngjj01@126.com进行投诉反馈,一经查实,立即删除

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注