精华内容
下载资源
问答
  • 2022-01-21 09:10:04

    LIN收发器芯片SIT1021四种工作模式的转换

    芯力特LIN收发器芯片SIT1021有四种工作模式:分别为休眠模式、待机模式、正常模式和上电模式,工作模式转换图如下:

     

    应用时应注意,芯片上电后,需将SLP_N脚置高使芯片进入正常模式后,才能将其设置在休眠模式,如上电后直接将SLP_N脚置低,则无法进入休眠模式;另外休眠模式与正常模式可以通过设置SLP_N脚来回转换;如果在休眠模式下,通过本地唤醒或者远程唤醒后,SIT1021先进入待机模式,同时RXD输出唤醒标志(置低),TXD输出唤醒源标志(置低(弱下拉代表远程唤醒,强下拉代表本地唤醒));当MCU检测到唤醒标志后,通过唤醒源标志检测到唤醒源,控制SLP_N置高,进入正常模式,接收数据。

    SIT1021在待机模式、正常模式和上电模式下,INH脚输出都是高电平(电压幅值与VBAT相同),只有在休眠模式下输出才是浮空状态;如果需要INH脚控制外部电源管理模块,则需将此脚通过电阻下拉到地,如下图,考虑到功耗,下拉电阻R2推荐使用100K(如果电源管理模块使能脚内部未接下拉电阻,则需要外接下拉电阻,如果内部有接下拉电阻,则可根据实际应用来决定是否外部加下拉电阻);可根据电源管理模块使能脚耐压,调节R1和R2的阻值,以调节输出到电源管理模块的使能脚电压。如果不用此功能可以通过电阻上拉到VBAT,或者悬空。

    芯力特聚焦总线接口芯片,始终坚持自主创新,深耕汽车与工业领域,已大规模量产高性能车载5V/3.3V CAN总线收发器系列芯片,车载LIN总线收发器系列芯片,5V/3.3V 全双工/半双工RS485系列芯片,5V/3.3V 全双工/半双工RS422系列芯片,5V/3.3V RS232系列接口芯片,芯力特接口芯片系列齐全,欢迎广大用户交流选购。

    北京冠宇铭通 

     

    更多相关内容
  • 汽车总线LIN总线协议

    千次阅读 2021-12-11 10:10:48
    本质上就是串口+LIN驱动芯片 当然需要单片机串口支持lin模式,也就是能发出11bit的低电平 2、软件上 常用速率波特率:最大传输速率为20Kbps。建议的通信速率如下,低速2400bps,中速9600bps,高速19200bps 流程上 ...

    一、介绍
    LIN的全称为Local Interconnect Network,是一种汽车上用的总线,实现一根信号线和多台设备通信

    二、原理
    1、硬件原理
    本质上就是串口+LIN驱动芯片
    在这里插入图片描述
    当然需要单片机串口支持lin模式,也就是能发出11bit的低电平

    2、软件上
    常用速率波特率:最大传输速率为20Kbps。建议的通信速率如下,低速2400bps,中速9600bps,高速19200bps

    流程上
    和i2c类似,因为只有一根数据线,收发都是在上面,所以用的应答模式,分为lin主机和lin从机,一个网络里面只有一个主机,多个从机,上图中,mcu就是主机,其他就是从机

    帧协议
    在这里插入图片描述
    header:显性间隔break+同步场sync+标识符pid
    break就是11bit以上的低电平
    sync就是0x55
    pid就是id+校验,id 6bit,校验2bit
    在这里插入图片描述
    pid校验算法

    short pid_check(unsigned char LIN_ID)
    {
    	short PID=0x00;
    	short p0=0,p1=0;
    
    	p0 = (LIN_ID & 0x01) ^ ((LIN_ID & 0x02) >> 1) ^ ((LIN_ID & 0x04) >> 2) ^ ((LIN_ID & 0x10) >> 4); //按位异或
            p0 = p0 & 0x01; 
            p1 = ~(((LIN_ID & 0x02) >> 1) ^ ((LIN_ID & 0x08) >> 3) ^ ((LIN_ID & 0x10) >> 4) ^ ((LIN_ID & 0x20) >> 5));
            p1 = p1 & 0x01; 
    
    	PID = (p1 << 7) | (p0 << 6) | LIN_ID;
    	return PID;
    }
    

    所谓奇偶校验就是在发送的每一个字节后都加上一位,使得每个字节中1的个数为奇数个或偶数个。接收方通过计算数据中1的个数是否满足奇偶性来确定数据是否有错

    response:数据字节+校验和场
    数据字节:就是要发送的数据或者从机要回的数据
    校验和场:校验
    校验和算法:
    累加所有字节。对每次加和进行判断,如果和大于0xFF,那么就把高八位的1,与低八位相加,其实就是低八位加1(翻转八位和)。得到最后的结果后,取其反码,

    unsigned char Lin_Checksum(unsigned char id , unsigned char *data)
    {
    	unsigned char t ;
    	unsigned short sum ;
    
    	sum = data[0];
    	if(id == 0x3c)			// 如果是诊断帧,用经典校验
    	{
    		
    		for(t=1;t<8;t++)
    		{
    			sum += data[t];
    			if(sum&0xff00)
    			{
    				sum&=0x00ff;
    				sum+=1;
    			}
    		}
    		sum = ~sum;	
    		
    		return (u8)sum ;
    	}
    	
    	for(t=1;t<8;t++)
    	{
    		sum += data[t];
    		if(sum&0xff00)
    		{
    			sum&=0x00ff;
    			sum+=1;
    		}
    	}
    	sum+=Lin_CheckPID(id);
    	if(sum&0xff00)
    	{
    		sum&=0x00ff;
    		sum+=1;
    	}
    	sum = ~sum;	
    	return (u8)sum ;
    }
    

    分为header和响应,header是主机发出,响应是从机发或者主机发
    当主机给从机发送数据:主机发送header和响应
    当主机读从机数据:主机发header,从机收到header给出相应
    在这里插入图片描述

    展开全文
  • 使用电脑UART模拟LIN总线 串口通讯 使用电脑UART模拟LIN总线 串口通讯 使用电脑UART模拟LIN总线 串口通讯 使用电脑UART模拟LIN总线 串口通讯
  • 2.串口中断处理 3、同步间隔断中断处理 4、接收中断处理 验证测试 1、CANoe IG发送帧头 2、示波器观测波形 总结 前言 在汽车领域,CAN总线和LIN总线是应用比较多的总线,因此需要对LIN总线有深入的了解。 ...

    文章目录

    目录

    文章目录

    前言

    一、LIN总线是什么?

    1.LIN总线的标准

    2.LIN总线形式

    3、帧的构成

    二、UART模拟LIN从机的实现

    1.方案概述

    2.串口中断处理

    3、同步间隔断中断处理

    4、接收中断处理

    验证测试

    1、CANoe IG发送帧头

     2、示波器观测波形

    总结



    前言

    在汽车领域,CAN总线和LIN总线是应用比较多的总线,因此需要对LIN总线有深入的了解。

    本文主要梳理关键知识点,帮助大家建立整体的概念,重点在于知识体系的构建。


    一、LIN总线是什么?

    1.LIN总线的标准

    目前各大主机厂广泛会用的是LIN2.1,波特率采用19200。

    2.LIN总线形式

     LIN在总线上的展现形式,主机发帧头(对比CAN的ID),从机响应数据(对比CAN的8字节数据)

    3、帧的构成

     同步段为  0x55

     ID段为     帧ID+校验

    数据段为  帧的数据内容

    校验和    数据段字节和ID的校验和

    二、UART模拟LIN从机的实现

    1.方案概述

    用接收中断进行同步段验证、数据接收

    用发送中断进行数据和校验的发送

    2.串口中断处理

    在中断中处理

    同步间隔中断

    接收中断

    发送中断

    void UartLIN_Handler(void *device, uint32_t wpara, uint32_t lpara)
    {
        // Receive break field
        if (0 != (lpara & UART_LSR1_FBRK_Msk))
        {
            LIN_IfcAux();
            UART_LIN->LSR1 |= UART_LSR1_FBRK_Msk;   ///<write 1 to clear break status
        }
    
        // Receive data
        if (0 != (wpara & UART_LSR0_DR_Msk))
        {
            LIN_IfcRx();
        }
    
        // Transmit data done
        if (0 != (wpara & UART_LSR0_THRE_Msk))
        {
            LIN_IfcTx();
        }
    }

    3、同步间隔断中断处理

    void LIN_IfcAux(void)
    {
        if (g_mode == SLAVE_MODE)
        {
            if (g_state == LIN_STATE_IDLE)
            {
                g_state = g_autoBaud ? LIN_STATE_RECEIVE_IDENTIFIER : LIN_STATE_RECEIVE_SYNC;
                g_direction = DIR_RX;
                g_txCount = 0;
                g_rxCount = 0;
    
                USART_TXE_INT_Enable(USART1_SFR, FALSE);
            }
            else
            {
                //fprintf("Frame err\r\n");
                g_state = g_autoBaud ? LIN_STATE_RECEIVE_IDENTIFIER : LIN_STATE_RECEIVE_SYNC;
                g_direction = DIR_RX;
                g_txCount = 0;
                g_rxCount = 0;
    
                USART_TXE_INT_Enable(USART1_SFR, FALSE);
            }
        }
    }

    4、接收中断处理

    void LIN_IfcRx(void)
    {
        uint8_t data = 0, id = 0, index = 0, checksum = 0, frameNum = 0;
        FRAME_ID_TBL  *frameTable = 0, *frameInfo = 0;
    
        data = USART_ReceiveData(USART1_SFR);
        //fprintf("%02x ", data);
        if (g_direction == DIR_TX)
        {
    #if 0
            if (data != g_buffer[g_rxCount])
            {
                // Send error
                //fprintf("bit err\r\n");
            }
            g_rxCount++;
            // transmit done
            if (g_rxCount == g_tranByte)
            {
                frameInfo = &g_scheduleTable[g_schTblIdx].schedule[g_frameIdx];
                if (g_state == LIN_STATE_SEND_SYNC)
                {
                    // Start transmit or receive data
                    if (frameInfo->dir == DIR_TX)
                    {
                        g_state = LIN_STATE_SEND_DATA;
                        g_direction = DIR_TX;
    
                        g_tranByte = frameInfo->dtl + 1;
                        memcpy((void *)g_buffer, (const void *)frameInfo->data, (unsigned int)g_tranByte - 1);
                        checksum = LIN_MakeChecksum((frameInfo->cst == ENHANCED_CHECKSUM) ? g_protectId : 0,
                                                      frameInfo->dtl, frameInfo->data);
                        g_buffer[g_tranByte - 1] = checksum;
    
                        g_txCount = 0;
                        g_rxCount = 0;
    
                        //UART_SetTXEInterrupt(UART_LIN, ENABLE);
                        USART_Send(USART1_SFR, g_buffer, g_tranByte);
                    }
                    else
                    {
                        g_state = LIN_STATE_RECEIVE_DATA;
                        g_direction = DIR_RX;
                        g_recvByte = frameInfo->dtl + 1;
                        g_rxCount = 0;
                    }
                }
                else if (g_state == LIN_STATE_SEND_DATA)
                {
                    // Transmit frame done
                    g_state = LIN_STATE_IDLE;
                }
            }
    #endif
        }
        else
        {
            if (g_mode == SLAVE_MODE)
            {
                if (g_state == LIN_STATE_RECEIVE_SYNC)
                {
                    // Check sync field
                    if (data == 0x55)
                    {
                        g_state = LIN_STATE_RECEIVE_IDENTIFIER;
                    }
                    else
                    {
                        g_state = LIN_STATE_IDLE;
                        //fprintf("Sync err\r\n");
                    }
                }
                else if (g_state == LIN_STATE_RECEIVE_IDENTIFIER)
                {
                    // Check protect id
                    id = data & 0x3F;
                    if (data == LIN_MakeProtId(id))
                    {
                        frameTable = g_scheduleTable[g_schTblIdx].schedule;
                        frameNum = g_scheduleTable[g_schTblIdx].frameNum;
                        for (index = 0; index < frameNum; index++)
                        {
                            frameInfo = &frameTable[index];
                            // Find needed id
                            if (id == frameInfo->id)
                            {
                                g_frameIdx = index;
                                g_protectId = data;
                                //fprintf("%d\r\n", id);
                                // Start transmit or receive data
                                if (frameInfo->dir == DIR_TX)
                                {
                                    g_state = LIN_STATE_SEND_DATA;
                                    g_direction = DIR_TX;
    
                                    g_tranByte = frameInfo->dtl + 1;
                                    memcpy((void *)g_buffer, (const void *)frameInfo->data, g_tranByte - 1);
                                    checksum = LIN_MakeChecksum((frameInfo->cst == ENHANCED_CHECKSUM) ? g_protectId : 0,
                                                                  frameInfo->dtl, frameInfo->data);
                                    g_buffer[g_tranByte - 1] = checksum;
    
                                    g_txCount = 0;
                                    g_rxCount = 0;
    
    
                                    //UART_SetTXEInterrupt(UART_LIN, ENABLE);
                                    //USART_Send(USART1_SFR, g_buffer, g_tranByte);
                                    USART_TXE_INT_Enable(USART1_SFR, TRUE);
    
                                    //delay_us(2);
    
                                    //g_state = LIN_STATE_IDLE;
                                    //g_direction = DIR_RX;
                                    //g_txCount = 0;
                                    //g_rxCount = 0;
                                }
                                else
                                {
                                    g_state = LIN_STATE_RECEIVE_DATA;
                                    g_direction = DIR_RX;
                                    g_recvByte = frameInfo->dtl + 1;
                                    g_rxCount = 0;
                                }
    
                                break;
                            }
                        }
                        // Not needed id
                        if (index == frameNum)
                        {
                            g_state = LIN_STATE_IDLE;
                            //fprintf("Err Id:0x%x\r\n", data);
                        }
                    }
                    else
                    {
                        g_state = LIN_STATE_IDLE;
                        //fprintf("Pid:0x%x err\r\n", data);
                    }
                }
                else if (g_state == LIN_STATE_RECEIVE_DATA)
                {
                    if (g_rxCount < g_recvByte)
                    {
                        g_buffer[g_rxCount] = data;
                        g_rxCount++;
                    }
                    // Receive frame done
                    if (g_rxCount == g_recvByte)
                    {
                        frameInfo = &g_scheduleTable[g_schTblIdx].schedule[g_frameIdx];
                        checksum = LIN_MakeChecksum((frameInfo->cst == ENHANCED_CHECKSUM) ? g_protectId : 0,
                                                    g_recvByte - 1, g_buffer);
                        if (checksum == g_buffer[g_rxCount - 1])
                        {
                            // Checksum is successful.
                            // Save data
                            memcpy((void *)frameInfo->data, (const void *)g_buffer, g_rxCount - 1);
                        }
                        else
                        {
                            // Checksum is failed.
                            //fprintf("Cs err\r\n");
                        }
                        g_state = LIN_STATE_IDLE;
                    }
                }
                else
                {
                }
            }
        }
    }

    发送中断处理

    void LIN_IfcTx(void)
    {
        if (g_direction == DIR_TX)
        {
            if (g_mode == SLAVE_MODE)
            {
                if (g_state == LIN_STATE_SEND_DATA)
                {
                    // Send data
                    if (g_txCount < g_tranByte)
                    {
                        //UART_SendData(UART_LIN, g_buffer[g_txCount]);
                        USART_SendData(USART1_SFR, g_buffer[g_txCount]);
                        g_txCount++;
                        if (g_txCount == g_tranByte)
                        {
                            //UART_SetTXEInterrupt(UART_LIN, DISABLE);
                            USART_TXE_INT_Enable(USART1_SFR, FALSE);
                        }
                    }
                    else
                    {
                        //UART_SetTXEInterrupt(UART_LIN, DISABLE);
                    	USART_TXE_INT_Enable(USART1_SFR, FALSE);
    
                    	g_direction = DIR_RX;
    					g_txCount = 0;
    					g_rxCount = 0;
                    }
                }
                else
                {
                    //UART_SetTXEInterrupt(UART_LIN, DISABLE);
                    USART_TXE_INT_Enable(USART1_SFR, FALSE);
                }
            }
        }
    }

    数据结构和变量

    
    typedef enum
    {
        LIN_STATE_IDLE,                  ///< Idle state
        LIN_STATE_SEND_BREAK,            ///< Send break state
        LIN_STATE_RECEIVE_BREAK,         ///< Receive break state
        LIN_STATE_SEND_SYNC,             ///< Send sync state
        LIN_STATE_RECEIVE_SYNC,          ///< Receive sync state
        LIN_STATE_SEND_IDENTIFIER,       ///< Send identifier state
        LIN_STATE_RECEIVE_IDENTIFIER,    ///< Receive identifier state
        LIN_STATE_SEND_DATA,             ///< Send data state
        LIN_STATE_RECEIVE_DATA,          ///< Receive data state
        LIN_STATE_SEND_CHECKSUM,         ///< Send checksum state
        LIN_STATE_BUSSLEEP               ///< Bus sleep state
    } lin_ifcState;
    
    typedef struct {
        uint8_t  id;               ///< LIN message frame ID for this frame
        uint8_t  dir;              ///< Name of the node that publishes the data
        uint8_t  cst;              ///< Type of checksum to be used (enhanced or classic)
        uint8_t  dtl;              ///< Number of bytes in the data field
        uint16_t  delayTime;       ///< Actual slot time in ms for the frame
        uint8_t  *data;            ///< Address of the structure that lists the signals
    } FRAME_ID_TBL;
    
    typedef struct {
        uint8_t  frameNum;         ///< Number of frame slots in the schedule table
        FRAME_ID_TBL  *schedule;   ///< Address of the schedule table
    } SCHEDULE_TBL;
    
    //#define UART_LIN        UART1
    
    // Checksum type
    #define    ENHANCED_CHECKSUM    0    ///< Enhanced checksum type
    #define    CLASSIC_CHECKSUM     1    ///< Classic checksum type
    
    // Direction
    #define    DIR_RX               0    ///< receive direction
    #define    DIR_TX               1    ///< transmit direction
    
    // Node mode
    #define    MASTER_MODE          0    ///< master mode
    #define    SLAVE_MODE           1    ///< slave mode
    
    
    extern void LIN_IfcRx(void);
    extern void LIN_IfcAux(void);
    extern void LIN_IfcTx(void);
    extern void LinSlaveInit(void);
    
    void LinSlaveInit(void)
    {
    
    }
    
    
    uint8_t g_LinData[4][8] =
    {
        {0xA1,0xB2,0xC3,0xD4,0xE5,0xF6,0x97,0x88},
        {0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28},
        {0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08},
        {0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08},
    };
    
    ///< Master send header and receive data
    FRAME_ID_TBL g_frameTable1[] =
    {
        {0x23, 1, 0, 3, 60, g_LinData[0]},
        {0x21, 0, 0, 8, 60, g_LinData[1]}
    };
    
    ///< Schedule table
    SCHEDULE_TBL g_scheduleTable[] =
    {
        {2, &g_frameTable1[0]}
    };
    
    uint32_t g_sendTimes = 0xFFFF; ///< Send frame times
    
    uint8_t g_mode = SLAVE_MODE;          ///< Master or slave mode
    uint8_t g_state = 0;         ///< Lin state
    uint8_t g_schTblIdx = 0;     ///< Schedule table index
    uint8_t g_frameIdx = 0;      ///< Frame index
    uint8_t g_protectId = 0;     ///< Protect id
    uint8_t g_firstFlag = 1;     ///< First time flag
    
    uint8_t g_direction = 0;     ///< Send direction
    uint8_t g_tranByte = 0;      ///< Need transmit bytes
    uint8_t g_recvByte = 0;      ///< Need receive bytes
    uint8_t g_txCount = 0;       ///< Transmit data count
    uint8_t g_rxCount = 0;       ///< Receive data count
    uint8_t g_autoBaud = 0;      ///< Auto baud rate
    uint8_t g_breakThre = 1;     ///< Break threshold
    uint8_t g_buffer[20] = {0};  ///< Data buffer
    
    
    
    
    uint8_t LIN_MakeProtId(uint8_t idData)
    {
        union {
            uint8_t  byte;
            struct {
                uint8_t  d0: 1;
                uint8_t  d1: 1;
                uint8_t  d2: 1;
                uint8_t  d3: 1;
                uint8_t  d4: 1;
                uint8_t  d5: 1;
                uint8_t  p0: 1;
                uint8_t  p1: 1;
            } bit;
        } buf;
    
        /* Load the desired message frame ID into the LSBits of the buffer.  */
        buf.byte = idData & (uint8_t)0x3F;
        /* Set the two parity bits.  */
        buf.bit.p1 = ~(buf.bit.d1 ^ buf.bit.d3 ^ buf.bit.d4 ^ buf.bit.d5);
        buf.bit.p0 = buf.bit.d0 ^ buf.bit.d1 ^ buf.bit.d2 ^ buf.bit.d4;
    
        return buf.byte;
    }
    
    
    uint8_t LIN_MakeChecksum(uint8_t protectId, uint8_t length, uint8_t *data)
    {
        uint8_t i = 0, checksum = 0;
        uint16_t sum = protectId;
    
        for (i = 0; i < length; i++)
        {
            sum += data[i];
            if (sum >= 0x100)
            {
                sum -= 0xFF;
            }
        }
        checksum = ~(uint8_t)sum;
    
        return checksum;
    }
    
    

    验证测试

    1、CANoe IG发送帧头

     2、示波器观测波形


    总结

    利用串口可以完美模拟从机,发送和接收采用中断的形式有利于提高程序的执行效率。

    5.1的最后一天假,完美收官

    展开全文
  • USB 各种接口(ADC/CNT/IIC/LIN/OW/SPI/PWM/UART等)代码各种版本。 USB各种接口(ADC/CNT/IIC/LIN/OW/SPI/PWM/UART等)实例代码,安卓版、C++、java、QT、python、SDK、VB等各种版本 c++ java QT python SDK
  • 文章目录YDOOK:STM32: CH340G 芯片介绍 USB 串口芯片© YDOOK JY Lin1. 工作原理图:2. 芯片特点:3. 七大封装模式:G, C, N, B, T, K, E:4. 不同的封装形式的对比:要点与区别:5. 工作引脚:6. 应用1:USB 9线...

    YDOOK:STM32: CH340G 芯片介绍 USB 转串口芯片

    © YDOOK JY Lin



    1. 工作原理图:

    YDOOK


    2. 芯片特点:

    ● 全速 USB 设备接口,兼容 USB V2.0。
    ● 仿真标准串口,用于升级原串口外围设备,或者通过 USB 增加额外串口。
    ● 计算机端 Windows 操作系统下的串口应用程序完全兼容,无需修改。
    ● 硬件全双工串口,内置收发缓冲区,支持通讯波特率 50bps~2Mbps。
    ● 支持常用的 MODEM 联络信号 RTS、DTR、DCD、RI、DSR、CTS。
    ● 通过外加电平转换器件,提供 RS232、RS485、RS422 等接口。
    ● CH340R 芯片支持 IrDA 规范 SIR 红外线通讯,支持波特率 2400bps 到 115200bps。
    ● 内置固件,软件兼容 CH341,可以直接使用 CH341 的 VCP 驱动程序。
    ● 支持 5V 电源电压和 3.3V 电源电压甚至 3V 电源电压。
    ● CH340C/N/K/E 及 CH340B 内置时钟,无需外部晶振,CH340B 还内置 EEPROM 用于配置序列号等。
    ● 提供 SOP-16、SOP-8 和 SSOP-20 以及 ESSOP-10、MSOP-10 无铅封装,兼容 RoHS。


    3. 七大封装模式:G, C, N, B, T, K, E:

    YDOOK


    4. 不同的封装形式的对比:

    YDOOK

    要点与区别:

    CH340C、CH340N、CH340K 和 CH340E 以及 CH340B 内置时钟,无需外部晶振。
    CH340B 内置 EEPROM 用于配置序列号,以及部分功能可定制等。
    CH340K 内置三只二极管用于减少独立供电时与 MCU 的 I/O 引脚之间的电流倒灌。
    CH340K 的底板是 0#引脚 GND,是可选连接;3#引脚 GND 是必要连接。
    CH340R 提供反极性 TXD 和 MODEM 信号,已停产。


    5. 工作引脚:

    YDOOK
    YDOOK


    6. 应用1:USB 转9线串口:

    YDOOK


    7. 应用2:USB 转RS232线串口:

    YDOOK


    8. 应用3:USB 转RS232线串口:简化:

    YDOOK


    9. 应用4:连接单片机串口:

    YDOOK


    10. 应用5:连接单片机串口:各自供电:

    YDOOK




    展开全文
  • LIN总线uart形式实现lin通信

    千次阅读 2020-09-26 17:16:14
    LIN是Local Interconnect Network的缩写,是基于UART/SCI(Universal Asynchronous Receiver-Transmitter/Serial Communication Interface 通用异步收发器/串行通信接口)的低成本串行通信协议。可用于汽车、家电、...
  • TI的LIN收发器介绍12V系统LIN收发器单通道LIN收发器双通道LIN收发器四通道LIN收发器LIN SBC24V系统LIN收发器总结3. Infenion的LIN收发器介绍带LDO的LIN SBC单路LIN收发器双路/四路LIN收发器总结4. ON的CAN(FD)收发...
  • 文章目录YDOOK: USB TTL 模块 与 ESP8266 WiFi 串口通讯实验 连线实例教程© YDOOK JY Lin1. 首先安装 模块的芯片驱动:CH340G 驱动:2. 安装成功后,打开设备管理器:此时,CH340G 模块尚未连接电脑,只有一个...
  • MSP430 LIN总线编程

    2021-02-03 23:13:38
    MSP430 LIN总线编程 ...
  • USB串口线及相关芯片

    千次阅读 2014-01-22 07:32:33
    USB串口线及相关芯片USB串口/串口转USB芯片(1)FT232R:是FTDI(www.ftdichip.com)最近推出一颗USB接口转换芯片,实现USB到串行UART接口的转换,也可转换到同步,异步BIT-BANG接口模式。FT232是真正的跨平台的...
  • 将SCIGCR1寄存器中的ADAPT位置1来使能波特率...LIN标准协议规定11个Tbit作为从机节点检测间隙场的门限值(间隙场至少为13个Tbit的显性)。在第五个连续的下降沿,BAUD_count可以被测量出,至此,从机节点可以计算...
  • 文章目录YDOOK:STM32: USBTTL 串口工具与下载器© YDOOK JY Lin1. 为什么要使用USB串口?最简单的解释就是:`因为一般的硬件开发模块都是具有串口接口的与对应的串口程序烧录通信电路,而没有直接与USB接口通信...
  • 基于PIC的LIN总线设计

    2021-01-14 01:57:12
    收发芯片:MCP2012.从节点从节点资源:UART,CCP捕捉 首先用接收引脚状态判断是否同步间隔场,用定时器1进行计时判断同步间隔场是否合格,判断合格后,用CCP模块捕捉同步头55H,同时计算波特率,之后打开UART进行...
  • 基于S32DS+LIN_Stack_S12编写KEA的LIN例程 文章目录基于S32DS+LIN_Stack_S12编写KEA的LIN例程1.KEA基于S32DS的驱动和例程获取2.LIN Stack移植2.1添加文件以及目录2.2协议栈文件修改适配S32DS3.用户程序编写3.1准备...
  • 开发环境: MDK:Keil 5.30 开发板:GD32F207I-EVAL MCU:GD32F207IK 10.1串口简介 USART(Universal Synchronous Asynchronous ...它支持同步单向通信和半双工单线通信,也支持LIN(局部互连网),智能卡协议和IrDA
  • 文章目录YDOOK: USB TTL 模块 连线使用实例教程© YDOOK JY Lin1. 首先安装 模块的芯片驱动:CH340G 驱动:2. 安装成功后,打开设备管理器:此时,CH340G 模块尚未连接电脑,只有一个默认的端口1。3. 插上 USB...
  • LIN(LocalInterconnectNetwork)LIN(Local Interconnect Network)LIN(LocalInterconnectNetwork)是一种串行网络协议,它主要用于汽车上各个模块之间的通信。它提出的原因是随着汽车工业的发展如果汽车上的所有模块都...
  • 我在网上找了很多关与uart实现LIN通信的资料,很多是STM芯片的,还有一些是RT其他芯片的,具有参考意义,但是不能完全适用1064的开发,最开始是打算使用Flexio是实现LIN通信的,网上也找到一篇文章,链接:...
  • STM32串口通信简介

    2021-10-23 22:27:52
    2.2.2USB232串口线原理: USB接口>>>CH340>>>MAX232>>>9针接口 信号分析: 电脑USB接口>>>电脑输出USB电平信号>>>CH340>>>TTL电平>>>MAX232芯片>>>电脑串口接口 其实 RS232 串口和 (TTL串口)UART 串口,它们的...
  • LIN总线节点的设计

    2020-12-22 11:27:28
    lin总线节点的设计[日期:2005-5-11] 来源:电子技术应用 作者:宋开臣 陈 舒 [字体:大 中 小]摘要:介绍了汽车网络系统a类串行总线通信标准lin协议2.0版本(最新版本),设计了总线节点的硬件和通信程序,规划了电动...
  • LIN总线:汽车氛围灯控制

    千次阅读 2020-10-30 11:34:30
    高档车比如奔驰车,具有功能强大的氛围灯,采用单芯片聚合了MCU(据说是51内核)、LED控制器、LIN收发器、电源管理等硬件,整体就只有指甲盖那么大,应该说是集成度非常高。背面是PWM可调式三色LED,具备三基色(蓝绿红...
  • db9接口(lin接口db9定义)

    千次阅读 2021-07-26 08:17:46
    早期的计算机的串口与并口都是使用DB25针连接器,而人们则习惯把抄字母B与D合在一起记了下来,当作D型接口的共同名字。后来计算机.想问问各位大侠,DB9那9个接口的功能都是什么?我现在想把一个4BITS一。一般只要用 ...
  • 1.串口通信(

    千次阅读 2017-06-04 12:38:12
    (原文出处:http://www.cnblogs.com/firege/p/5805753.html... 第20章 USART—串口通讯 全套200集视频教程和1000页PDF教程请到秉火论坛下载:www.firebbs.cn 野火视频教程优酷观看网址:http://i.youku.com/firege
  • STM32CubeMX基于HAL库实现简单串口通信

    千次阅读 2021-10-25 23:25:41
    STM32CubeMX基于HAL库实现简单串口通信 板子:STM32F103C8 编译工具:Keil+STM32CubeMX 烧录工具:FlyMcu 串口调试程序:XCOM 实验要求: 1)设置波特率为115200,1位停止位,无校验位; 2)STM32系统给上位机(win...
  • 第20章 USART—串口通讯全套200集视频教程和1000页PDF教程请到秉火论坛下载:www.firebbs.cn野火视频教程优酷观看网址:http://i.youku.com/firege本章参考资料:《STM32F4xx中文参考手册》USART章节。学习本章时,...
  • LIN总线开发:STM32F0 TJA1020

    万次阅读 2018-04-15 21:10:43
    LIN的硬件比较简单,有些人认为LIN同RS232,485类似,直接用普通串口就能实现。但是这里要指出这是不同的,普通串口不完全能够支持LIN协议。因为LIN的帧结构中,对报文头的LIN Break时间长度有特别的要求:13bit长度...
  • 由于通过RS-232标准传输的电平信号到达设备后,不能直接被识别,所以会通过电平转换芯片转换成能识别的TTL电平信号,实现通讯。 相互通讯的两个设备间,一个设备发送数据,一个设备接收数据。一般情况下,发送数据的...
  • STM32之串口通信

    千次阅读 2022-01-13 22:51:12
    文章目录一、串口通信与USART二、程序编写输出Hello Windows三、GPIO波形参考链接 一、串口通信与USART 二、程序编写输出Hello Windows 串口通信 串口通信是一种设备间非常常用的串行通行方式,其简单便捷,大部分...
  • 16 . USART 串口通信实验

    千次阅读 2021-05-21 14:54:40
    USART 串口通信实验 我们知道STM32F1 内部含有非常多的通信接口,我们就来学习下USART 串口通信。要实现的功能是:STM32F1 ...我们知道STM32F1 芯片内含有非常多的通信接口,学习这些通信接口前,我们很有必要了解下通

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 730
精华内容 292
关键字:

串口转lin芯片