stm32实现1588协议

最新推荐文章于 2024-06-17 16:32:04 发布
最新推荐文章于 2024-06-17 16:32:04 发布
阅读量1.5w 收藏 66
点赞数 9
分类专栏： ARM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/iodoo/article/details/9785871
版权

1.引言

本文章基于stm32官方例程实现，详细代码可下载例程。

在RT-thread系统上实现1588协议，网络驱动上需要做较多的修改。 


2.代码修改


2.1驱动分析


当Accumulator register，溢出之后，会增加subsecond register一个步长，这个步长为constant value；每个时钟周期 Accumulator register会加上 addend register的值，这样做的目的是调整 subsecond register 增加的周期。
为Accumulator register提供clock的位系统时钟 HCLK，一般为72MHz，而 subsecond register 增加的频率需要为50MHz。
subsecond register的最大值为2^31，把2^31作为1秒钟，那么每20ns subsecond register需要增加 20ns  * (2^31) / 10^9ns = 43 ，即constant value 为43.。
Accumulator register 溢出时间为 49 *10^9 / (2^31) ~= 20.023ns
 Addend / 2^32 = (1 / 20ns) /72mhz    换算单位之后 Addend = 2979125334.90

2.2驱动层的修改

原代码的DMA描述符如下：

 static ETH_DMADESCTypeDef  DMARxDscrTab[ETH_RXBUFNB], DMATxDscrTab[ETH_TXBUFNB];

//STM32的MAC加入时间戳时，会将描述符的地址覆盖，
//所以需要将地址提前保存起来，MAC的时间戳读出来之后，再将地址写回去。 
//再创建两个描述符用于保存地址 

 ETH_DMADESCTypeDef DMAPTPRxDscrTab[ETH_RXBUFNB], DMAPTPTxDscrTab[ETH_TXBUFNB];/* Ethernet Rx & Tx PTP Helper Descriptors */


2.3发送函数的更改

rt_err_t rt_stm32_eth_tx( rt_device_t dev, struct pbuf* p)
{
    struct pbuf* q;
    rt_uint32_t offset = 0;
    unsigned char * buffer;
    
    
    /* get free tx buffer */
	{
        rt_err_t result;
        result = rt_sem_take(&tx_buf_free, 2);
        if (result != RT_EOK) return -RT_ERROR;
    }
#if LWIP_PTP
    unsigned int timeout = 0;
    struct ptptime_t timestamp;
    
    DMATxDescToSet->Buffer1Addr = DMAPTPTxDescToSet->Buffer1Addr;   //保存地址
    DMATxDescToSet->Buffer2NextDescAddr = DMAPTPTxDescToSet->Buffer2NextDescAddr;
#endif
    
    buffer = (unsigned char *)DMATxDescToSet->Buffer1Addr;
    
    for (q = p; q != NULL; q = q->next)
    {
        rt_uint8_t* ptr;
        rt_uint32_t len;
        
        len = q->len;
        ptr = q->payload;
        
        /**Copy the frame to be sent into memory pointed by the current ETHERNET DMA Tx descriptor*/
        memcpy((void *)(&buffer[offset] ), ptr, len);
        offset += len;
    }
    
#ifdef ETH_TX_DUMP
.......
#endif
    
	/* Setting the Frame Length: bits[12:0] */
	DMATxDescToSet->ControlBufferSize = (p->tot_len & ETH_DMATxDesc_TBS1);
	/* Setting the last segment and first segment bits (in this case a frame is transmitted in one descriptor) */
	DMATxDescToSet->Status |= ETH_DMATxDesc_LS | ETH_DMATxDesc_FS;
    /* Enable TX Completion Interrupt */
    DMATxDescToSet->Status |= ETH_DMATxDesc_IC;
#ifdef CHECKSUM_BY_HARDWARE
........
#endif
    /* Set Own bit of the Tx descriptor Status: gives the buffer back to ETHERNET DMA */
    DMATxDescToSet->Status |= ETH_DMATxDesc_OWN;
    /* When Tx Buffer unavailable flag is set: clear it and resume transmission */
    if ((ETH->DMASR & ETH_DMASR_TBUS) != (uint32_t)RESET)
    {
        /* Clear TBUS ETHERNET DMA flag */
        ETH->DMASR = ETH_DMASR_TBUS;
        /* Transmit Poll Demand to resume DMA transmission*/
        ETH->DMATPDR = 0;
    }
#if LWIP_PTP
    /* Wait for ETH_DMATxDesc_TTSS flag to be set */
    do
    {
        timeout++;
    } while (!(DMATxDescToSet->Status & ETH_DMATxDesc_TTSS) && (timeout < PHY_READ_TO));  //等待加入时间戳
    /* Return ERROR in case of timeout */
    if(timeout == PHY_READ_TO)
    {
        return ETH_ERROR;
    }
    
    timestamp.tv_nsec = ETH_PTPSubSecond2NanoSecond(DMATxDescToSet->Buffer1Addr);
    timestamp.tv_sec = DMATxDescToSet->Buffer2NextDescAddr;
    
    /* Clear the DMATxDescToSet status register TTSS flag */
    DMATxDescToSet->Status &= ~ETH_DMATxDesc_TTSS;
    
    DMATxDescToSet->Buffer1Addr = DMAPTPTxDescToSet->Buffer1Addr;
    DMATxDescToSet->Buffer2NextDescAddr = DMAPTPTxDescToSet->Buffer2NextDescAddr;   //还原地址
    
    /* Update the ETHERNET DMA global Tx descriptor with next Tx decriptor */
    /* Chained Mode */
    /* Selects the next DMA Tx descriptor list for next buffer to send */
    DMATxDescToSet = (ETH_DMADESCTypeDef*) (DMATxDescToSet->Buffer2NextDescAddr);
    
    if(DMAPTPTxDescToSet->Status != 0)
    {
        DMAPTPTxDescToSet = (ETH_DMADESCTypeDef*) (DMAPTPTxDescToSet->Status);
    }
    else
    {
        DMAPTPTxDescToSet++;
    }
#else
    
    /* Update the ETHERNET DMA global Tx descriptor with next Tx decriptor */
    /* Chained Mode */
    /* Selects the next DMA Tx descriptor list for next buffer to send */
    DMATxDescToSet = (ETH_DMADESCTypeDef*) (DMATxDescToSet->Buffer2NextDescAddr);
    
#endif
    
#if LWIP_PTP
    p->time_sec = timestamp.tv_sec;
    p->time_nsec = timestamp.tv_nsec;
#endif
    /* Return SUCCESS */
    return RT_EOK;
}

2.4其他

接收函数也做类似的更改，还有中断函数直接参照例程修改就可以。

3.协议分析

1588协议中，定义了两种报文，事件报文和通用报文；

事件报文时间概念报文，进出设备端口时打上精确的时间戳，PTP根据事件报文携带的时间戳，计算链路延迟。事件报文包含以下4种：Sync、Delay_Req、Pdelay_Req和Pdelay_Resp。

通用报文：非时间概念报文，进出设备不会产生时间戳，用于主从关系的建立、时间信息的请求和通告。通用报文包含以下6种：Announce、Follow_Up、Delay_Resp、Pdelay_Resp_Follow_Up、Management和Signaling，目前设备不支持Management、Signaling报文。


时钟同步的实现主要包括3个步骤：

  1. 建立主从关系，选取最优时钟、协商端口主从状态等。
  2. 频率同步，实现从节点频率与主节点同步。
  3. 时间同步，实现从节点时间与主节点同步。

协议初始化之后，开始监听网络，master会主动发送sync、Announce包，slave收到Announce后，添加主机（addForeign函数实现），并对其进行最佳主时钟算法（BMC）比较。

3.1建立主从关系

主从关系建立步骤

PTP是通过端口接收到和发送Announce报文，实现端口数据集和端口状态机信息的交互。BMC（Best Master Clock）算法通过比较端口数据集和端口状态机，实现时钟主从跟踪关系。一般按照下面几个步骤来建立：

  1. 接收和处理来自对端设备端口的Announce报文。

  2. 利用BMC算法决策出最优时钟和端口的推荐状态，包括Master、Slave或者Passive状态。

  3. 根据端口推荐状态，更新端口数据集合。

  4. 按照推荐状态和状态决策事件，根据端口状态机决定端口的实际状态，实现时钟同步网络的建立。状态决策事件包括Announce报文的接收事件和接收Announce报文的超时时间结束事件，当接口接收Announce报文的时间间隔大于超时时间间隔时，将此PTP接口状态置为Master。


BMC算法

（bmc函数实现），简单的来说就是依次比较每个主机的参数，这几个参数为：gPriority1、clockClass、clockAccuracy、offsetScaledLogVariance、Priority2。这里做一些比较，得出最佳主时钟。

  • Priority1：时钟优先级1，支持用户配置，取值范围是0～255，取值越小优先级越高。
  • ClockClass：时钟级别，定义时钟的时间或频率的国际原子时TAI（International Atomic Time）跟踪能力。
  • ClockAccuracy：时钟精度，取值越低精确度越高。
  • OffsetScaledLogVariance：时钟稳定性。
  • Priority2：时钟优先级2，支持用户配置，取值范围是0～255，取值越小优先级越高。

最优时钟可以通过手工配置静态指定，也可以通过最佳主时钟BMC（Best Master Clock）算法动态选举。

 3.2 PTP频率同步


在主从关系建立后，即可以进行频率同步和时间同步。PTP本来只是用户设备之间的高精度时间同步，但也可以被用来进行设备之间的频率同步。

PTP通过记录主从设备之间事件报文交换时产生的时间戳，计算出主从设备之间的路径延迟和时间偏移，实现主从设备之间的时间和频率同步，设备支持两种携带时间戳的模式，分别为：

  • 单步时钟模式(One step)，指事件报文Sync和Pdelay_Resp带有本报文发送时刻的时间戳，报文发送和接收的同时也完成了时间信息的通告。
  • 两步时钟模式(Two step)，指事件报文Sync和Pdelay_Resp不带有本报文发送时刻的时间戳，而分别由后续的通用报文Follow_Up和Pdelay_Resp_Follow_Up带上该Sync和PDelay_Resp报文的发送时间信息。两步时钟模式中，时间信息的产生和通告分两步完成，这样可以兼容一些不支持给事件报文打时间戳的设备。

 3.3  PTP时间同步

PTP时间同步有两种不同的同步方式：Delay方式和Pdelay方式，如此划分主要是由于PTP计算路径延时有两种机制。

  • 延时请求-请求响应机制E2E（End to End）：根据主从时钟之间的整体路径延时时间计算时间差。
  • 对端延时机制P2P（Peer to Peer）：根据主从时钟之间的每一条链路延时时间计算时间差。

fg

对端延时机制P2P(Peer to Peer)

    P2P机制是利用延时请求Pdelay_Req报文、延时回答Pdelay_Resp报文和可能的Pdelay_Resp_Follow_Up报文，计算两个支持P2P机制的通信端口之间测量端口到端口的传播时间，也就是路径延时。与延时请求-响应机制相比，路径延时测量原理并无不同，只是路径延时测量在每段链路之间进行，主从节点间每段链路的链路延时累计在Pdelay_Resp或Pdelay_Resp_Follow_Up报文中，向下游传递，同时传递信息还包括同步报文在透明时钟TC上的驻留时间。从节点每段链路的链路延时和在透明时钟TC上的驻留时间，计算主从节点的平均路径延时。

在对端延时机制中，延时测量和端口的主从属性无关，在支持Pdelay机制的两个相连端口之间进行。

 Pdelay机制原理

时间戳t1和t2是Pdelay_Req消息发送时间戳和接收时间戳，时间戳t3和t4是Pdelay_Resp消息的发送时间戳和接收时间戳。计算单段链路延时的公式如下所示：

单段链路延时=[(t2-t1) + (t4-t3)]/2 = [(t2-t3) + (t4-t1)]/2。

4.协议代码分析

 4.1  handle(PtpClock *ptpClock)函数：


/* check and handle received messages */
static void handle(PtpClock *ptpClock)
{

    int ret;
    Boolean isFromSelf;
    TimeInternal time = { 0, 0 };
//**********************************************************************检查是否收到数据
    if (FALSE == ptpClock->messageActivity)
    {
        ret = netSelect(&ptpClock->netPath, 0);

        if (ret < 0)							//接收出错
        {
            ERROR("handle: failed to poll sockets\n");
            toState(ptpClock, PTP_FAULTY);
            return;
        }
        else if (!ret)							//没有收到数据，直接返回
        {
          //  DBGVV("handle: nothing\n");
            return;
        }
    }
//**********************************************************************
  //  DBGVV("handle: something\n");

    ptpClock->msgIbufLength = netRecvEvent(&ptpClock->netPath, ptpClock->msgIbuf, &time);
	/* local time is not UTC, we can calculate UTC on demand, otherwise UTC time is not used */
    /* time.seconds += ptpClock->timePropertiesDS.currentUtcOffset; */


    if (ptpClock->msgIbufLength < 0)
    {
        ERROR("handle: failed to receive on the event socket\n");
        toState(ptpClock, PTP_FAULTY);
        return;
    }
    else if (!ptpClock->msgIbufLength)
    {                                 //读取数据，接收时MAC层加入的时间戳保存在time中；数据保存在msgIbuf中
        ptpClock->msgIbufLength = netRecvGeneral(&ptpClock->netPath, ptpClock->msgIbuf, &time); 

        if (ptpClock->msgIbufLength < 0)
        {
            ERROR("handle: failed to receive on the general socket\n");
            toState(ptpClock, PTP_FAULTY);
            return;
        }
        else if (!ptpClock->msgIbufLength)
            return;
    }

    ptpClock->messageActivity = TRUE;

    if (ptpClock->msgIbufLength < HEADER_LENGTH)
    {
        ERROR("handle: message shorter than header length\n");
        toState(ptpClock, PTP_FAULTY);
        return;
    }

    msgUnpackHeader(ptpClock->msgIbuf, &ptpClock->msgTmpHeader);//将数据包解析后放在ptpClock->msgTmpHeader中。

    if (ptpClock->msgTmpHeader.versionPTP != ptpClock->portDS.versionNumber)
    {
        DBGV("handle: ignore version %d message\n", ptpClock->msgTmpHeader.versionPTP);
        return;
    }

    if (ptpClock->msgTmpHeader.domainNumber != ptpClock->defaultDS.domainNumber)
    {
        DBGV("handle: ignore message from domainNumber %d\n", ptpClock->msgTmpHeader.domainNumber);
        return;
    }

    /*Spec 9.5.2.2*/
    isFromSelf = isSamePortIdentity(
		&ptpClock->portDS.portIdentity,
		&ptpClock->msgTmpHeader.sourcePortIdentity);  //判断是否是同一个主机

    /* subtract the inbound latency adjustment if it is not a loop back and the
       time stamp seems reasonable */
    if (!isFromSelf && time.seconds > 0)
        subTime(&time, &time, &ptpClock->inboundLatency);

    switch (ptpClock->msgTmpHeader.messageType)
    {

    case ANNOUNCE:
        handleAnnounce(ptpClock, isFromSelf);
        break;

    case SYNC:
        handleSync(ptpClock, &time, isFromSelf);
        break;

    case FOLLOW_UP:
        handleFollowUp(ptpClock, isFromSelf);
        break;

    case DELAY_REQ:
        handleDelayReq(ptpClock, &time, isFromSelf);
        break;

    case PDELAY_REQ:
        handlePDelayReq(ptpClock, &time, isFromSelf);
        break;

    case DELAY_RESP:
        handleDelayResp(ptpClock, isFromSelf);
        break;

    case PDELAY_RESP:
        handlePDelayResp(ptpClock, &time, isFromSelf);
        break;

    case PDELAY_RESP_FOLLOW_UP:
        handlePDelayRespFollowUp(ptpClock, isFromSelf);
        break;

    case MANAGEMENT:
        handleManagement(ptpClock, isFromSelf);
        break;

    case SIGNALING:
        handleSignaling(ptpClock, isFromSelf);
        break;

    default:
        DBG("handle: unrecognized message %d\n", ptpClock->msgTmpHeader.messageType);
        break;
    }
}
 

4.2 handleSync

static void handleSync(PtpClock *ptpClock, TimeInternal *time, Boolean isFromSelf)
{
    TimeInternal originTimestamp;
    TimeInternal correctionField;

    Boolean isFromCurrentParent = FALSE;
    DBGV("handleSync: received\n");

    if (ptpClock->msgIbufLength < SYNC_LENGTH)
    {
        ERROR("handleSync: short message\n");
        toState(ptpClock, PTP_FAULTY);
        return;
    }

    switch (ptpClock->portDS.portState)
    {
    case PTP_INITIALIZING:
    case PTP_FAULTY:
    case PTP_DISABLED:

        DBGV("handleSync: disreguard\n");
        break;

    case PTP_UNCALIBRATED:
    case PTP_SLAVE:

        if (isFromSelf)
        {
            DBGV("handleSync: ignore from self\n");
            break;
        }

        isFromCurrentParent = isSamePortIdentity(
			&ptpClock->parentDS.parentPortIdentity,
			&ptpClock->msgTmpHeader.sourcePortIdentity);

        if (!isFromCurrentParent)
        {
            DBGV("handleSync: ignore from another master\n");
            break;
        }

        ptpClock->timestamp_syncRecieve = *time;    //保存接收sync报文时，本机的时间戳

        scaledNanosecondsToInternalTime(&ptpClock->msgTmpHeader.correctionfield, &correctionField); //保存sync报文的修正时间

        if (getFlag(ptpClock->msgTmpHeader.flagField[0], FLAG0_TWO_STEP))  //采用TWO_STEP方式，也就是说发送sync报文主机的时间，通过follow_up报文发送过来而不是包含在sync报文中。
        {
            ptpClock->waitingForFollowUp = TRUE;  
            ptpClock->recvSyncSequenceId = ptpClock->msgTmpHeader.sequenceId;  //用于识别
            /* Save correctionField of Sync message for future use */
            ptpClock->correctionField_sync = correctionField;
        }
        else
        {
            msgUnpackSync(ptpClock->msgIbuf, &ptpClock->msgTmp.sync);
            ptpClock->waitingForFollowUp = FALSE;
            /* Synchronize  local clock */
            toInternalTime(&originTimestamp, &ptpClock->msgTmp.sync.originTimestamp);
            /* use correctionField of Sync message for future use */
            updateOffset(ptpClock, &ptpClock->timestamp_syncRecieve, &originTimestamp, &correctionField);
            updateClock(ptpClock);
        
            issueDelayReqTimerExpired(ptpClock);
        }

        break;


    case PTP_MASTER: //如果本机是主机

        if (!isFromSelf)
        {
            DBGV("handleSync: from another master\n");
            break;
        }
        else
        {
            DBGV("handleSync: ignore from self\n");
            break;
        }

//      if waitingForLoopback && TWO_STEP_FLAG
//        {
//            /*Add latency*/
//            addTime(time, time, &rtOpts->outboundLatency);
//
//            issueFollowup(ptpClock, time);
//            break;
//        }
    case PTP_PASSIVE:
        issueDelayReqTimerExpired(ptpClock);
        DBGV("handleSync: disreguard\n");
        break;

    default:
        DBGV("handleSync: disreguard\n");

        break;
    }
}

4.3 handleFollowUp


static void handleFollowUp(PtpClock *ptpClock, Boolean isFromSelf)
{
    TimeInternal preciseOriginTimestamp;
    TimeInternal correctionField;
    Boolean isFromCurrentParent = FALSE;

    DBGV("handleFollowup: received\n");


    if (ptpClock->msgIbufLength < FOLLOW_UP_LENGTH)
    {
        ERROR("handleFollowup: short message\n");
        toState(ptpClock, PTP_FAULTY);
        return;
    }

    if (isFromSelf)
    {
        DBGV("handleFollowup: ignore from self\n");
        return;
    }

    switch (ptpClock->portDS.portState)
    {
    case PTP_INITIALIZING:
    case PTP_FAULTY:
    case PTP_DISABLED:
    case PTP_LISTENING:

        DBGV("handleFollowup: disreguard\n");
        break;

    case PTP_UNCALIBRATED:
    case PTP_SLAVE:

        isFromCurrentParent = isSamePortIdentity(
			&ptpClock->parentDS.parentPortIdentity,
			&ptpClock->msgTmpHeader.sourcePortIdentity);

        if (!ptpClock->waitingForFollowUp)
        {
            DBGV("handleFollowup: not waiting a message\n");
            break;
        }

        if (!isFromCurrentParent)
        {
            DBGV("handleFollowup: not from current parent\n");
            break;
        }


        if (ptpClock->recvSyncSequenceId !=  ptpClock->msgTmpHeader.sequenceId)
        {
            DBGV("handleFollowup: SequenceID doesn't match with last Sync message\n");
            break;
        }

        msgUnpackFollowUp(ptpClock->msgIbuf, &ptpClock->msgTmp.follow); //从msgIbuf中 34 36 40位置，获取时间戳，也就是sync的master时间。参考协议

        ptpClock->waitingForFollowUp = FALSE;
        /* synchronize local clock */
        toInternalTime(&preciseOriginTimestamp, &ptpClock->msgTmp.follow.preciseOriginTimestamp);//
        scaledNanosecondsToInternalTime(&ptpClock->msgTmpHeader.correctionfield, &correctionField);//handle中赋值msgTmpHeader.correctionfield。这里是follow_up  的修正值
        addTime(&correctionField, &correctionField, &ptpClock->correctionField_sync);//handleSync中赋值。这里是sync的修正值。两个修正值叠加
        updateOffset(ptpClock, &ptpClock->timestamp_syncRecieve, &preciseOriginTimestamp, &correctionField);//sync接收到时间timestamp_syncRecieve，主机发送sync时间preciseOriginTimestamp，修正时间correctionField
        updateClock(ptpClock);
        
        issueDelayReqTimerExpired(ptpClock);
        break;

    case PTP_MASTER:
        DBGV("handleFollowup: from another master\n");

        break;

    case PTP_PASSIVE:
        issueDelayReqTimerExpired(ptpClock);
        DBGV("handleFollowup: disreguard\n");
        break;
    
    default:
        DBG("handleFollowup: unrecognized state\n");

        break;
    }//Switch on (port_state)

}



i0dooo
关注
  • 9
    点赞
  • 踩
  • 66
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
STM32跑html协议,stm32实现1588协议
weixin_36142226的博客
06-03 986
1.引言本文章基于stm32官方例程实现，详细代码可下载例程。在RT-thread系统上实现1588协议，网络驱动上需要做较多的修改。2.代码修改2.1驱动分析当Accumulator register，溢出之后，会增加subsecond register一个步长，这个步长为constant value；每个时钟周期 Accumulator register会加上 addend register的...
stm32 官方1588协议例程修改版
08-15
stm32 官方1588协议例程修改版 phy采用dm9161，测试通过，精确度在200ns之内。
RT-Thread ： IEEE1588/PTP 协议的实现
热门推荐
姚家湾博客
11-01 1万+
IEEE1588/PTP协议对于实时通信非常重要。可惜RT-Thread OS 没有支持IEEE1588/PTP 协议。尝试做一个。貌似简单，其实不易
STM32 简介
最新发布
if_clear的博客
06-17 1708
红色为电源相关的引脚，蓝色为最小系统相关的引脚，绿色为IO口功能口这些引脚S代表电源，I代表输入，O代表输出，IO代表输入输出。IO电平代表IO口所能容忍的电压，FT代表能容忍5V的电压，没有FT就只能容忍3.3V的电压。若没有FT又需要接5V的电平，就需要加装电平转换电路。主功能为上电后默认的功能，一般和引脚名称相同，默认复用功能是IO口上同时连接的外设功能引脚，配置IO口时可以选择是通用IO口还是复用功能。
stm32f107在rt-thread上实现1588协议 ptpv2
08-15
stm32f107在rt-thread上实现1588协议 ptpv2，目前不稳定。
以我的亲身经历，聊聊学python的流程，同时推荐学python的书
hsm_computer的博客
01-22 1190
因为干活要用到，所以我大概于19年5月开始学python，大概学了1个月后，我就能干公司的活了，而且这python项目还包含了机器学习等要素，大概3个月后，我还承担了项目里开发机器学习数据分析的任务。所以我感到，虽然python里包含了爬虫、机器学习和数据分析等热门要素，但python并不难学，而且如果方法得当，学到能干项目的程度也很快。在这篇文章里，就讲给出我学Python的流程，向大家展示如何高效学python。 1 搭建开发环境 由于我有学java的基础，所以我知道首先得搭建开发...
stm32f107 ieee1588
03-30
STM32F107 IEEE1588-2008 PTP精准对时
STM32F407移植1588v2(ptpd)
飞临云的博客
06-09 3411
硬件：STM32F407ZGT6开发板软件：VSCodeopenOCDst-link在github搜到一个在NUCLEO-F429ZI开发板上移植ptpd的example，因为和F407差别很小，所以就打算用这个demo移植到手头的开发板上。因为目前只需要slave，所以只调试了slave。据介绍，master好像原作者没有充分测试过。
PTP IEEE1588V2 STM32F107实现
02-16
标题中的“PTP IEEE1588V2 STM32F107实现”涉及到的是在微控制器STM32F107上实现精确时间协议（Precision Time Protocol, PTP）的第二版（IEEE 1588v2）。PTP是一种网络协议，用于在分布式系统中同步时钟，确保所有...
STM32 modbus协议实现例程
05-06
STM32 Modbus协议实现例程是一套专为STM32微控制器设计的代码库，旨在帮助开发者在项目中快速集成Modbus通信功能。Modbus是一种广泛应用的工业通信协议，尤其在PLC（可编程逻辑控制器）和嵌入式系统之间进行数据交换...
STM32单片机实现modbus通讯协议
06-16
软件：Keil uvision5 单片机：STM32F103C8T6 调试：XCOM V2.6、Modbus调试精灵 串口通信：波特率：9600 数据位：8 校验位：无 停止位：1 modbus：RTU模式下03功能码、06功能码实现
基于STM32F107VC的IEEE 1588精密时钟同步分析与实现.pdf
06-30
基于STM32F107VC的IEEE 1588精密时钟同步分析与实现.pdf
stm32_f4_ptpd-master_PTPD_ptp_ptp网络协议_stm32上实现ptp_stm32ptp配置_
09-28
实现PTP在STM32上的通信，作为PTP主机，发送PTP报文
STM32移植canard实现UVCAN协议源码
06-27
STM32移植Canard以实现UVCAN协议的源码是一项在嵌入式系统开发中的技术挑战，尤其对于那些在物联网(IoT)和汽车电子领域工作的工程师来说。STM32是意法半导体公司（STMicroelectronics）推出的一款基于ARM Cortex-M...
STM32输出可调相位的1PPS
难波儿万的博客
07-19 2213
在做晶振守时等项目时经常需要生成一个可调相位的1PPS，我最近就遇到了这样的问题。利用STM32的定时器定时1S，然后在TIM_IT_UPDATE中断时输出1PPS上升沿理论是可以的，但是移动相位很不方便，修改定时器的计数值是一个方法，但是这会引入很大的系统误差。 利用STM32定时器的输出比较模式输出1PPS并达到相位可调的目的是我目前想到的最好的方法，其实这种机制的原理很简单。STM32的定时器的众多寄存器中有几个是我们经常要使用到的，它们分别是： 预分频寄存器：配置它会将定时器的输入主频进行分频。假
STM32模拟GPS输出PPS、GPRMC与VLP16时钟同步
kaoyangs05的博客
08-24 6515
1.VLP16与GPS相关的管脚： GPS-RECEIVE 接收GPS的GPRMC语句，注意是RS232电平(high 3-15V，low 1.2V以下)，如TTL电平输出需要进行信号反转，没有RS232芯片的可以使用反相电路。 GPS PULSE 接收GPS的PPS信号，上升沿触发持续10us-200ms，与下一个PPS要大于300ms以上 GROUND 信号地 2.利用GPS信息完成时间同步 TimeSynchronization VLP16的TOH时间戳 VLP16有一个用于记录着TOH(to
使用STM32 MCU模拟实现PPS+TOD授时信号
就是个linux工程师的博客
03-31 2006
PPS+TOD是授时信号的一种，用来传递准确的时间信息。PPS，Pulse Per Second，是每秒一次的脉冲信号，其上升沿表示整秒的时刻。TOD，Time of Day，是时间信息。是跟随在每个PPS信号后的由串口发出的一句报文，报文内容包含UTC时间。通常在PPS信号后的几百个毫秒内发送完成。
stm32 iap modemy协议实现
09-10
STM32 IAP（In-Application Programming）是一种在应用程序中进行在线编程的技术。而Modem协议是用于数据交换的通信协议。将两者结合起来，可以实现在STM32芯片上进行在线编程的Modem通信协议。 通过STM32 IAP，可以在不使用外部编程器的情况下，对STM32芯片中的程序进行升级。而Modem协议则可以通过电话线或者网络等通信方式，实现数据的传输和通信。 在STM32 IAP Modem协议实现中，可以使用Modem模块将STM32芯片与外部设备（如电脑或服务器）连接起来。然后，利用Modem协议进行数据传输。 具体实现的基本流程如下： 1. STM32芯片连接Modem模块，确保它们之间的通信正常。 2. 通过Modem模块将STM32芯片与外部设备进行通信连接。可以使用串口通信、TCP/IP通信等方式，根据具体情况选择。 3. 编写STM32芯片的IAP程序，实现在应用程序中进行在线编程的功能。该程序可以接收从外部设备传输过来的升级数据，并根据升级需求对芯片进行编程。 4. 在外部设备上编写相应的应用程序，用于与STM32芯片进行通信，实现数据传输。根据Modem协议的规定，将升级数据按照一定的格式进行打包和传输。 5. 通过Modem连接，将升级数据发送给STM32芯片，实现在线编程的目的。在STM32芯片上解析和处理接收到的升级数据，完成升级操作。 6. 在升级过程中，注意进行错误处理和异常情况的处理，确保数据传输的稳定性和可靠性。 7. 在完成在线编程后，关闭连接，释放资源。 总之，通过结合STM32 IAP和Modem协议，可以实现在STM32芯片上进行在线编程的功能。这种方式可以方便、快捷地对芯片进行升级，提高了开发效率和可维护性。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值