ldc1314芯片工作原理、引脚参数及其应用例程详解

inr999 2017-11-02 27986

电感器

75人已加入

描述

　　电感-数字转换器LDC1314是电子工程人员经常会接触的芯片，LDC1314是4-通道12位的电感-数字转换器（LDC），用于解决电感检测问题。采用多个信道和遥感的支持，LDC1314以最低的成本与最小的功耗来获得电感感测的性能和可靠性。此类产品使用简便，仅需要传感器频率处于 1kHz 至 10MHz 的范围内即可开始工作。由于支持的传感器频率范围 1kHz 至 10MHz 较宽，因此还支持使用非常小的 PCB 线圈，从而进一步降低感测解决方案的成本和尺寸。

　　ldc1314工作原理

　　导体在与交变电磁（EM）场接触时将引起磁场变化，可以采用传感器中的电感传感器进行检测。一个电感器与一个电容器可以构造一个L-C振荡器，可以用来产生电磁场。在一个LC振荡器中，当电磁场收到干扰时，可以观察到电感发生微小的偏移，与共振频率存在一定关系。

　　利用这个原理，在LDC1314是一个电感-数字转换器（LDC），通过测量LC谐振器的振荡频率。该器件输出数字值与振荡频率成比例关系。此频率测量值可以被转换为一个等效电感。

LDC1314

　　LDC1314特征参数

　　*合格的汽车应用

　　*符合AEC-Q100的结果如下：

　　-设备温度等级1：- 40°C至125°C环境工作温度范围

　　-设备HBM的ESD等级分类2

　　-装置CDM ESD分类等级C

　　*易于使用的最低配置要求

　　*测量多达4个传感器与一个集成电路

　　*多渠道支持环境和老龄化补偿

　　*多通道遥感提供最低系统成本

　　*引脚兼容的介质和高分辨率选项

　　-LDC1312-Q1/LDC1314-Q1： 2/4-ch 12-bit LDC

　　-LDC1612-Q1/LDC1614-Q1： 2/4-ch 28-bit LDC

　　*支持广泛的传感器频率范围10MHz 1KHz

　　*35μ低功耗的睡眠模式 -200钠关断模式 *3.3V的操作

　　*支持内部或外部参考时钟 *对直流磁场和磁铁的免疫

LDC1314

　　ldc1314引脚图

　　 LDC1314

　　ldc1314引脚定义

　 LDC1314

LDC1314

　　说明：DAP不能做地使用，可以悬空，为获得最佳性能对DAP应连接到相同的电位作为设备的GND管脚。

编辑推荐：LDC1314中文手册

　　典型ldc1314应用电路一：

　　 LDC1314

　　典型ldc1314应用电路二：

　　系统以MSP430F169单片机为控制核心，采用可充电锂电池为电源，以L298N为驱动芯片，结合PWM技术实现对4个直流减速机速度控制，从而实现小车的前进、转向等功能。在本系统中，单片机通过LDC1314芯片实现对赛道表面金属丝和硬币的识别与小车位置的判定，利用电机尾部的霍尔传感器与编码器实现对小车行进路程的计算，并使用LCD12864液晶实时显示小车行进路程与所用时间。

　　 LDC1314

　　电机驱动芯片L298N原理图如下

　　 LDC1314

　　主程序

　　void main（ void ）

　　{

　　P2SEL &=~ BIT7; //蜂鸣器

　　P2DIR |= BIT7;

　　P2OUT &=~ BIT7;

　　InitSys（）;

　　InitLDC1314（）;

　　Ini_Lcd（）;

　　P6SEL=0;P6DIR|=BIT0+BIT1;P6OUT&=~（BIT0+BIT1）; //电机旋转方向

　　_EINT（）;

　　int i;

　　InitPWM（0x03E8）; //PWM初始化，采用TB输出2路PWM波

　　TBCCR1=TBCCR2=0;

　　for（i=0;i《1500;i++） // 电感传感器自校准

　　{

　　D1=LDC1314_Result（1）;

　　D2=LDC1314_Result（2）;

　　D3=LDC1314_Result（3）;

　　}

　　initTA（）; // 定时器A初始化，用于计时

　　go（）; //直行

　　Time=mc=sx=0; //开始执行时间路程清零

　　while（1）

　　{

　　Component_Display（4，0，Time）;//时间

　　sl=（int）（（float）sx*3.0）;

　　Component_Display（4，4，sl）; //路程

　　if（sl》800）{while（1）;_DINT（）;TBCCR1=TBCCR2=0;} //到达终点结束

　　value1 = LDC1314_Result（1）; Component_Display（1，1，value1）;//显示通道1

　　value2 = LDC1314_Result（2）; Component_Display（2，1，value2）;

　　value3 = LDC1314_Result（3）; Component_Display（3，1，value3）;//显示

　　// 硬币的检测

　　if （（value1》（2+D1））|| （value2》（2+D2））|| （value3》（2+D3）） || （abs（value2-D2）》20）|| （abs（value1-D1）》20）|| （abs（value3-D3）》20））

　　P2OUT |=BIT7;

　　else

　　P2OUT &=~BIT7;

　　//循迹

　　if（（abs（value3-D3）《20）&&（D3》value3）） { turn_r（）; }

　　else if（（abs（value1-D1）《20）&&（D1》value1）） { turn_l（）; }

　　else go（）;

　　}

　　ldc1314例程

　　ldc1314例程一：

　　MSP430F149/169驱动LDC1314程序，可用于金属的检测，已给出各个文件名称，自建工程添加文件即可使用。显示程序较为普遍，未给出。

　　MAIN.C文件

　　#include 《msp430f169.h》

　　#include “config.h”

　　#include “12864.h”

　　extern uint LDC1314_Result（uchar Channal）;

　　extern void InitLDC1314（void）;

　　/***************************************************

　　系统初始化，MCLK=8MHz，SMCLK=1MHz

　　*************************************************/

　　void InitSys（）

　　{

　　unsigned int iq0;

　　_DINT（）; // 关中断，本可以不必这样小心

　　WDTCTL = WDTPW + WDTHOLD;

　　BCSCTL1 &=~XT2OFF;

　　{

　　IFG1 &= ~OFIFG; // 清除振荡器失效标志

　　for （iq0 = 0xFF; iq0 》 0; iq0--）; // 延时，等待XT2起振

　　}

　　while （（IFG1 & OFIFG）！= 0）; // 判断XT2是否起振

　　BCSCTL2 =SELM_2+SELS+DIVS_3; //MCLK，SMCLK时钟为XT2，SMCLK8分频1MHz

　　}

　　void main（ void ）

　　{

　　uint value = 0;

　　InitSys（）;

　　InitLDC1314（）;

　　Ini_Lcd（）;

　　Component_Display（4，0，134）;//显示

　　while（1）

　　{

　　value = LDC1314_Result（0）;//通道0

　　Component_Display（1，0，value）;//显示

　　delay_ms（200）;

　　}

　　_NOP（）;

　　}

　　LDC1314.C文件

　　#include “LDC1314.h”

　　/*I2C总线初始化*/

　　void I2C_Init（）

　　{

　　LDC_SCL_L（）; //拉低时钟线

　　delay_us（5）; //延时

　　I2C_Stop（）;

　　}

　　//**************************************

　　//I2C起始信号

　　//**************************************

　　void I2C_Start（）

　　{

　　LDC_SCL_OUT（）; // SCL设置为输出

　　LDC_SDA_OUT（）; // SDA设置为输出

　　LDC_SDA_H（）; //拉高数据线

　　LDC_SCL_H（）; //拉高时钟线

　　delay_us（5）; //延时

　　LDC_SDA_L（）; //产生下降沿

　　delay_us（5）; //延时

　　LDC_SCL_L（）; //拉低时钟线

　　}

　　//**************************************

　　//I2C停止信号

　　//**************************************

　　void I2C_Stop（）

　　{

　　LDC_SCL_OUT（）; // SCL设置为输出

　　LDC_SDA_OUT（）; // SDA设置为输出

　　LDC_SDA_L（）; //拉低数据线

　　LDC_SDA_H（）; //产生上升沿

　　delay_us（5）; //延时

　　}

　　//**************************************

　　//I2C发送应答信号

　　//入口参数：ack （0:ACK 1:NAK）

　　//**************************************

　　void I2C_SendACK（uchar ack）

　　{

　　if（ack）

　　LDC_SDA_H（）;

　　else

　　LDC_SDA_L（）;

　　// SDA = ack; //写应答信号

　　LDC_SCL_H（）; //拉高时钟线

　　delay_us（5）; //延时

　　LDC_SCL_L（）; //拉低时钟线

　　delay_us（5）; //延时

　　}

　　//**************************************

　　//I2C接收应答信号，0有效，1无效

　　//**************************************

　　uchar I2C_RecvACK（）

　　{

　　uchar cy;

　　LDC_SCL_OUT（）; // SCL设置为输出

　　LDC_SCL_H（）; //拉高时钟线

　　delay_us（5）; //延时

　　if（LDC_SDA_DAT（））

　　{

　　cy=1;

　　}

　　else

　　{

　　cy=0;

　　}

　　// cy = SDA; //读应答信号

　　LDC_SCL_L（）; //拉低时钟线

　　delay_us（5）; //延时

　　LDC_SDA_OUT（）; // SDA设置为输出

　　return cy;

　　}

　　/*向I2C总线发送一个字节数据*/

　　uchar I2C_SendByte（uchar dat）

　　{

　　uchar i，temp;

　　LDC_SCL_OUT（）; // SCL设置为输出

　　LDC_SDA_OUT（）; // SDA设置为输出

　　for （i=0; i《8; i++） //8位计数器

　　{

　　if（（dat《《i））

　　{

　　LDC_SDA_H（）;

　　}

　　else

　　{

　　LDC_SDA_L（）;

　　}

　　LDC_SCL_H（）; //拉高时钟线

　　delay_us（5）; //延时

　　LDC_SCL_L（）; //拉低时钟线

　　delay_us（5）; //延时

　　}

　　temp=I2C_RecvACK（）;

　　return temp;

　　}

　　/*从I2C总线接收一个字节数据*/

　　uchar I2C_RecvByte（）

　　{

　　uchar i;

　　uchar dat = 0，cy;

　　LDC_SCL_OUT（）; // SCL设置为输出

　　LDC_SDA_OUT（）; // SDA设置为输出

　　LDC_SDA_H（）; //使能内部上拉，准备读取数据，

　　LDC_SDA_IN（）; // SDA设置为输入，准备向主机输入数据

　　for （i=0; i《8; i++） //8位计数器

　　{

　　dat 《《= 1;

　　LDC_SCL_H（）; //拉高时钟线

　　delay_us（5）; //延时

　　if（LDC_SDA_DAT（））

　　{

　　cy=1;

　　}

　　else

　　{

　　cy=0;

　　}

　　dat |= cy; //读数据

　　LDC_SCL_L（）; //拉低时钟线

　　delay_us（5）; //延时

　　}

　　LDC_SDA_OUT（）;

　　return dat;

　　}

　　/*向I2C设备写入一个字节数据*/

　　void ByteWrite1314（uchar REG_Address，uchar REG_data）

　　{

　　I2C_Start（）; //起始信号

　　I2C_SendByte（SlaveAddress）; //发送设备地址+写信号

　　I2C_SendByte（REG_Address）; //内部寄存器地址，

　　I2C_SendByte（REG_data）; //内部寄存器数据，

　　I2C_Stop（）; //发送停止信号

　　}

　　//**************************************

　　//从I2C设备读取一个字节数据

　　//**************************************

　　uchar ByteRead1314（uchar REG_Address）

　　{

　　uchar REG_data;

　　I2C_Start（）; //起始信号

　　I2C_SendByte（SlaveAddress）; //发送设备地址+写信号

　　I2C_SendByte（REG_Address）; //发送存储单元地址，从0开始

　　I2C_Start（）; //起始信号

　　I2C_SendByte（SlaveAddress+1）; //发送设备地址+读信号

　　REG_data=I2C_RecvByte（）; //读出寄存器数据

　　I2C_SendACK（1）; //接收应答信号

　　I2C_Stop（）; //停止信号

　　return REG_data;

　　}

　　//**************************************

　　//向I2C设备写入一个字数据

　　//**************************************

　　void WordWrite1314（uchar REG_Address，uint REG_data）

　　{

　　uchar REG_data_H，REG_data_L;

　　REG_data_L=（uchar）（REG_data&0xFF）;

　　REG_data_H=（uchar）（（REG_data&0xFF00）》》8）;

　　I2C_Start（）; //起始信号

　　I2C_SendByte（SlaveAddress）; //发送设备地址+写信号

　　I2C_SendByte（REG_Address）; //内部寄存器地址

　　I2C_SendByte（REG_data_H）; //发送内部寄存器数据，高8位

　　I2C_SendByte（REG_data_L）; //发送内部寄存器数据，低8位

　　I2C_Stop（）; //发送停止信号

　　}

　　/*从I2C设备读取一个字数据*/

　　uint WordRead1314（uchar REG_Address）

　　{

　　uint REG_data;

　　uchar REG_data_H，REG_data_L;

　　I2C_Start（）; //起始信号

　　I2C_SendByte（SlaveAddress）; //发送设备地址+写信号

　　I2C_SendByte（REG_Address）; //发送存储单元地址，从0开始

　　I2C_Start（）; //起始信号，？？原因不明

　　I2C_SendByte（SlaveAddress+1）; //发送设备地址+读信号

　　REG_data_H=I2C_RecvByte（）; //读出寄存器数据

　　I2C_SendACK（0）; //接收应答信号

　　REG_data_L=I2C_RecvByte（）; //读出寄存器数据

　　I2C_SendACK（1）; //接收应答非信号

　　I2C_Stop（）; //发送停止信号

　　REG_data=REG_data_H;

　　REG_data《《=8;

　　REG_data|=REG_data_L;

　　return REG_data;

　　}

　　/*初始化LDC1314*/

　　void InitLDC1314（void）

　　{

　　I2C_Init（）;

　　while（WordRead1314（DEVICE_ID）！=0x3025）;//等待，I2C正常

　　//WordWrite1314（RESET_DEV，0x8800）;

　　/*重启LDC1314*/

　　WordWrite1314（CONFIG，0x2451）;

　　/*默认值，睡眠模式开，方便配置*/

　　WordWrite1314（CLOCK_DIVIDERS_CH0，0X500a）;//fSENSOR不分频，fCLK 2分频

　　/* 时钟源分频选择，分频系数1，1

　　Using L and C，得fSENSOR = 1/2π×sqrt（L ×C）

　　注意fSENSOR须小于8.75 MHz，fSENSOR分频系数才能置1

　　注意fREF0须至少大于 4 × fSENSOR，以决定fREF0分频系数

　　fin0 = fSENSOR0/CH0_FIN_DIVIDER

　　fREF0 = fCLK / CH0_FREF_DIVIDER

　　WordWrite1314（SETTLECOUNT_CH0，0x0A60）;

　　/* 建立（Settling）时间设置

　　计算得Q=Rp*sqrt（C/L）

　　寄存器值小于10取10，大于10取其值，且应满足以下条件：

　　CHx_SETTLECOUNT ≥ QSENSORx × fREFx / （16 × fSENSORx）（10进制）

　　（1）fSENSORx:x通道传感器频率

　　（2）fREFx:x通道参考频率

　　（3）QSENSORx：品质因数，Q=Rp ×sqrt（C/L）

　　注意，不等式右边算出有小数则向上取整

　　建立时间tSx = （CH0_SETTLECOUNT*16） / fREF0

　　通道切换时间tCsd = Channel Switch Delay = 692 ns + 5 / fref （us）

　　WordWrite1314（RCOUNT_CH0，0xFFFF）;

　　/*转换时间设置

　　得转换时间tCx = TSAMPLE（采样时间） – tSx – tCsd （us）

　　由下式算出寄存器的值（有小数则向下取整（舍去））：

　　转换时间tCx = （CHx_RCOUNT × 16） / fREFx （10进制）

　　注意寄存器的值化为16进制

　　/*使用ERROR_CONFIG默认值，错误中断关闭*/

　　WordWrite1314（DRIVE_CURRENT_CH0，0x9800）;

　　/*传感器驱动电流设置，使用请同时注意CONFIG寄存器相关配置

　　查数据手册的Figure 15，得IDRIVE值（10进制），INIT_DRIVE值不使用，保持默认

　　使用CH0_IDRIVE［15:11］时，Rp Override须打开

　　使用CH0_INIT_IDRIVE［10:6］时，保证AUTO_AMP_DIS位不置位

　　//WordWrite1314（MUX_CONFIG，0x801）;

　　/* 多通道转换选择，输入尖峰脉冲滤波器带宽选择，使用请同时注意CONFIG寄存器相关配置！

　　（a）置AUTOSCAN_EN位为b1使能连续模式（sequential mode）

　　（b）置RR_SEQUENCE位为b00使能两个通道的数据转换（channel 0，channel 1）

　　（c）置DEGLITCH位为b100设定输入尖峰脉冲滤波器带宽，此值必须高于谐振频率fTank！

　　//WordWrite1314（OFFSET_CH0，0x00）;

　　/*频率偏移（补偿）设置

　　可以设置从每个数据值中减去偏移值，以补偿频率偏移或最大化动态范围的样本数据

　　fOFFSET0 = CH0_OFFSET * （fREF0/2^16）

　　且偏移值应小于 fSENSORx_MIN / fREFx

　　//WordWrite1314（RESET_DEV，0x00）;

　　/*输出增益设置，［10:9］，对所有通道有效

　　对于传感器信号变化量小于满量程25％的系统，设置输出增益可以提供更高的分辨率（精度）

　　状态寄存器：STATUS，ERROR_CONFIG

　　WordWrite1314（CONFIG，0x1501）;

　　/*默认连续转换（单）通道0，睡眠模式关，Rp Override开

　　低功耗模式关，传感器自动幅度校正（AUTO_AMP）关，Ref时钟源选外部时钟源

　　INTB中断开，高电流驱动关*/

　　}

　　/*读取LDC1314转换结果，输入参数为选择通道数*/

　　uint LDC1314_Result（uchar Channal）

　　{

　　uint temp=0;

　　switch（Channal）

　　{

　　case 0x00：

　　temp=WordRead1314（DATA_CH0）; //通道0

　　break;

　　case 0x01：

　　temp=WordRead1314（DATA_CH1）; //通道1

　　break;

　　case 0x02：

　　temp=WordRead1314（DATA_CH2）; //通道2

　　break;

　　case 0x03：

　　temp=WordRead1314（DATA_CH3）; //通道3

　　break;

　　default ：

　　break;

　　}

　　while（（temp&0xF000）！=0）;

　　/*有错误Flag！，有输出增益时注意此句，可能出错！

　　0x000 = under range，0xfff = over range

　　return temp;

　　}

　　LDC1314.H文件

　　#ifndef __LDC1314_H

　　#define __LDC1314_H

　　#include 《msp430f169.h》

　　#include “config.h”

　　static void I2C_Init（）;

　　static void I2C_Start（）;

　　static void I2C_Stop（）;

　　static void I2C_SendACK（uchar ack）;

　　static uchar I2C_RecvACK（）;

　　static uchar I2C_SendByte（uchar dat）;

　　static uchar I2C_RecvACK（）;

　　static void WordWrite1314（uchar REG_Address，uint REG_data）;

　　static uint WordRead1314（uchar REG_Address）;

　　void InitLDC1314（void）;

　　uint LDC1314_Result（uchar Channal）;

　　//****定义LDC1314硬件接口（不同硬件修改此处即可）***********

　　#define LDC1314DIR P1DIR

　　#define LDC1314OUT P1OUT

　　#define LDC1314IN P1IN

　　#define LDC_SCL BIT2

　　#define LDC_SDA BIT3

　　#define LDC_INTB BIT4//中断

　　#define LDC_SD BIT5//置高，则进入掉电模式

　　//*********I2C硬件相关接口函数**************

　　#define LDC_SCL_OUT（） LDC1314DIR |= LDC_SCL // SCL脚输出

　　#define LDC_SCL_H（） LDC1314OUT |= LDC_SCL // SCL拉高

　　#define LDC_SCL_L（） LDC1314OUT &= ~LDC_SCL // SCL拉低

　　#define LDC_SDA_OUT（） LDC1314DIR |= LDC_SDA // SDA脚输出

　　#define LDC_SDA_H（） LDC1314OUT |= LDC_SDA // SDA拉高

　　#define LDC_SDA_L（） LDC1314OUT &= ~LDC_SDA // SDA拉低

　　#define LDC_SDA_IN（） LDC1314DIR &= ~LDC_SDA // SDA脚输入

　　#define LDC_SDA_DAT（）（LDC1314IN&LDC_SDA） // SDA输入数据

　　#define SlaveAddress 0x2A //IIC写入时的地址字节数据，+1为读取，ADDR接高电平，地址则为0x2B

　　#define DATA_CH0 0x00 //Channel 0 Conversion Result and Error Status

　　#define DATA_CH1 0x02

　　#define DATA_CH2 0x04

　　#define DATA_CH3 0x06

　　#define RCOUNT_CH0 0x08 //Reference Count setting for Channel 0

　　#define RCOUNT_CH1 0x09

　　#define RCOUNT_CH2 0x0A

　　#define RCOUNT_CH3 0x0B

　　#define OFFSET_CH0 0x0C //Offset value for Channel 0

　　#define OFFSET_CH1 0x0D

　　#define OFFSET_CH2 0x0E

　　#define OFFSET_CH3 0x0F

　　#define SETTLECOUNT_CH0 0x10 //Channel 0 Settling Reference Count

　　#define SETTLECOUNT_CH1 0x11

　　#define SETTLECOUNT_CH2 0x12

　　#define SETTLECOUNT_CH3 0x13

　　#define CLOCK_DIVIDERS_CH0 0x14

　　#define CLOCK_DIVIDERS_CH1 0x15

　　#define CLOCK_DIVIDERS_CH2 0x16

　　#define CLOCK_DIVIDERS_CH3 0x17

　　#define STATUS 0x18 //Device Status Report

　　#define ERROR_CONFIG 0x19 //Error Reporting Configuration

　　#define MUX_CONFIG 0x1A //Channel Multiplexing Configuration

　　#define CONFIG 0x1B //Conversion Configuration

　　#define RESET_DEV 0x1C //Reset Device

　　#define DRIVE_CURRENT_CH0 0x1E //Channel 0 sensor current drive configuration

　　#define DRIVE_CURRENT_CH1 0x1F

　　#define DRIVE_CURRENT_CH2 0x20

　　#define DRIVE_CURRENT_CH3 0x21

　　#define MANUFACTURER_ID 0x7E //厂商ID，默认值0x5449

　　#define DEVICE_ID 0x7F //设备ID，默认值0x3054

　　#endif

　　ldc1314例程二：

　　#include 《intrinsics.h》

　　#include 《string.h》

　　#include 《stdint.h》

　　#include 《cstring》

　　#include 《stdio.h》

　　#include “LDC13xx16xx_evm.h”

　　#include “scheduler.h”

　　#include “host_interface.h”

　　#include “host_packet.h”

　　#include “USB_API/USB_Common/device.h”

　　#include “USB_API/USB_Common/types.h” //Basic Type declarations

　　#include “USB_API/USB_Common/usb.h” //USB-specific functions

　　#include “F5xx_F6xx_Core_Lib/HAL_UCS.h”

　　#include “F5xx_F6xx_Core_Lib/HAL_PMM.h”

　　#include “USB_API/USB_CDC_API/UsbCdc.h”

　　#include “usbConstructs.h”

　　#include “USB_config/descriptors.h”

　　// prototypes

　　void InitMCU（void）;

　　void Init_Clock（void）;

　　void USBCommunicationTask（void）;

　　void LDC16_13_Evm_Test_Routine（）;

　　uint16_t L_Noise（uint16_t * t_buf， uint8_t ch_num）;

　　uint8_t L_Sample（uint16_t * t_buf， uint8_t ch_num）;

　　volatile uint8_t bCDCDataReceived_event = FALSE; //Indicates data has been received without an open rcv operation

　　volatile uint16_t usbEvents = （kUSB_VbusOnEvent + kUSB_VbusOffEvent + kUSB_receiveCompletedEvent

　　+ kUSB_dataReceivedEvent + kUSB_UsbSuspendEvent + kUSB_UsbResumeEvent +

　　kUSB_UsbResetEvent）;

　　// used as an edge-trigger for USB connect/disconnect

　　uint8_t usb_led_flag;

　　void main（void）

　　{

　　WDTCTL = WDTPW + WDTHOLD; //Stop watchdog timer

　　// hardware bootloader entry

　　EVM_SHUTDOWN_SEL &= ~EVM_SHUTDOWN_BIT; // gpio

　　EVM_SHUTDOWN_DIR &= ~EVM_SHUTDOWN_BIT; // input

　　EVM_SHUTDOWN_REN |= EVM_SHUTDOWN_BIT; // enable pull-down

　　EVM_SHUTDOWN_OUT &= ~EVM_SHUTDOWN_BIT; // pull low

　　__delay_cycles（36000）;

　　if （EVM_SHUTDOWN_IN & EVM_SHUTDOWN_BIT） {

　　_disable_interrupts（）;

　　（（void （*）（））0x1000）（）;

　　}

　　EVM_SHUTDOWN_REN &= ~EVM_SHUTDOWN_BIT; // disable pull-down

　　// InitMCU（）; //included in evm init

　　evm_init（）;

　　LDC16_13_Evm_Test_Routine（）;

　　_enable_interrupts（）;

　　// evm_LED_Set（ALLON）;

　　initHostInterface（）;

　　// evm_LED_Set（RED）; // red on only

　　usb_led_flag = 0;

　　while （1）

　　{

　　// USB Comms

　　USBCommunicationTask（）;

　　}

　　/** Initialze MCU

　　Initializes the MSP430 peripherals and modules.

　　void InitMCU（void）

　　{

　　__disable_interrupt（）; // Disable global interrupts

　　SetVCore（3）;

　　Init_Clock（）; //Init clocks

　　USB_init（）; //Init USB

　　USB_setEnabledEvents（（WORD）usbEvents）;

　　//Check if we‘re already physically attached to USB， and if so， connect to it

　　//This is the same function that gets called automatically when VBUS gets attached.

　　if （USB_connectionInfo（） & kUSB_vbusPresent）{

　　USB_handleVbusOnEvent（）;

　　}

　　__enable_interrupt（）; // enable global interrupts

　　}

　　/** USB Communication

　　Handles USB Comms

　　void USBCommunicationTask（void）

　　{

　　uint16_t bytesSent， bytesReceived;

　　uint8_t error=0， status;

　　switch （USB_connectionState（））

　　{

　　case ST_ENUM_ACTIVE：

　　if （！usb_led_flag） {

　　// evm_LED_Set（GREEN）; // green on only

　　usb_led_flag = 1;

　　}

　　status = USBCDC_intfStatus（CDC0_INTFNUM，&bytesSent， &bytesReceived）;

　　if （status & kUSBCDC_waitingForSend） {

　　error = 1;

　　}

　　if（bCDCDataReceived_event || （status & kUSBCDC_dataWaiting））

　　{

　　bCDCDataReceived_event = FALSE;

　　processCmdPacket （）;

　　}

　　else {

　　evm_processDRDY（）; // process DRDY added here for speed （not scheduler-assigned）

　　executeTasks（）;

　　}

　　break;

　　case ST_USB_DISCONNECTED： case ST_USB_CONNECTED_NO_ENUM：

　　case ST_ENUM_IN_PROGRESS： case ST_NOENUM_SUSPENDED： case ST_ERROR：

　　if （usb_led_flag） {

　　// evm_LED_Set（RED）; // red on only

　　usb_led_flag = 0;

　　}

　　removeAllTasks（）;

　　break;

　　default：;

　　} //end of switch-case sentence

　　if（error）

　　{

　　error = 0;

　　_nop（）;

　　//TO DO： User can place code here to handle error

　　}

　　/** Initialize Clock

　　Initializes all clocks： ACLK， MCLK， SMCLK.

　　void Init_Clock（void）

　　{

　　//Initialization of clock module

　　if （USB_PLL_XT == 2）{

　　#if defined （__MSP430F552x） || defined （__MSP430F550x）

　　P5SEL |= 0x0C; //enable XT2 pins for F5529

　　#elif defined （__MSP430F563x_F663x）

　　P7SEL |= 0x0C;

　　#endif

　　#if 0

　　//use REFO for FLL and ACLK

　　UCSCTL3 = （UCSCTL3 & ~（SELREF_7）） | （SELREF__REFOCLK）;

　　UCSCTL4 = （UCSCTL4 & ~（SELA_7）） | （SELA__REFOCLK）;

　　//MCLK will be driven by the FLL （not by XT2）， referenced to the REFO

　　Init_FLL_Settle（USB_MCLK_FREQ / 1000， USB_MCLK_FREQ / 32768）; //Start the FLL， at the freq indicated by the config

　　//constant USB_MCLK_FREQ

　　XT2_Start（XT2DRIVE_0）; //Start the “USB crystal”

　　#endif

　　// for USB2ANY which has XT2 crytstal = 24MHz

　　UCSCTL4 = SELA_5 + SELS_5 + SELM_5; // ACLK=XT2 SMCLK=XT2 MCLK=XT2

　　XT2_Start（XT2DRIVE_3）;

　　}

　　else {

　　#if defined （__MSP430F552x） || defined （__MSP430F550x）

　　P5SEL |= 0x10; //enable XT1 pins

　　#endif

　　//Use the REFO oscillator to source the FLL and ACLK

　　UCSCTL3 = SELREF__REFOCLK;

　　UCSCTL4 = （UCSCTL4 & ~（SELA_7）） | （SELA__REFOCLK）;

　　//MCLK will be driven by the FLL （not by XT2）， referenced to the REFO

　　Init_FLL_Settle（USB_MCLK_FREQ / 1000， USB_MCLK_FREQ / 32768）; //set FLL （DCOCLK）

　　XT1_Start（XT1DRIVE_0）; //Start the “USB crystal”

　　}

　　// L noise measurement

　　// take 16 sampling averages of size 1024

　　// returns noise measurement

　　uint16_t L_Noise（uint16_t * t_buf， uint8_t ch_num） {

　　uint8_t i;

　　uint32_t j，sample，min，max;

　　uint16_t avg = 0;

　　// if L noise is out of range after tuning return FALSE

　　for （i = 0; i 《 4; i++） {

　　// evm_LED_Set（ALLTOGGLE）;

　　min = 0xFFFFFFFF; //min

　　max = 0; //max

　　// measure L noise

　　for （j = 0; j 《 1024; j++） {

　　#ifdef SERIES_16

　　smbus_readWord（0x2A， ch_num， &t_buf［0］）;

　　smbus_readWord（0x2A， ch_num+1， &t_buf［1］）;

　　sample = （（uint32_t） t_buf［1］） | （（（uint32_t） t_buf［0］）《《 16）;

　　#endif

　　#ifdef SERIES_13

　　smbus_readWord（0x2A， ch_num， &t_buf［0］）;

　　sample = （（uint32_t） t_buf［0］）;

　　#endif

　　if （sample 《 min）

　　min = sample;

　　if （sample 》 max）

　　max = sample;

　　}

　　if （max 》 min） {

　　avg += （max - min）;

　　}

　　else if （min 》 max） {

　　return 0xFFFF;

　　}

　　avg /= 4; // should compile to right shift by 4

　　return avg;

　　}

　　// L sample range measurement

　　// take 64 sampling windows of size 16

　　// FALSE if no errors， TRUE otherwise

　　uint8_t L_Sample（uint16_t * t_buf， uint8_t ch_num） {

　　uint8_t i，j;

　　uint32_t avg;

　　for （i = 0; i 《 16; i++） {

　　// evm_LED_Set（ALLTOGGLE）;

　　avg = 0;

　　for （j = 0; j 《 16; j++） {

　　smbus_readWord（0x2A，ch_num， &t_buf［0］）;

　　avg += t_buf［0］;

　　}

　　avg = avg / 16;

　　#ifdef SERIES_16

　　if（avg 《0xC0 || avg 》0xD4 ） { //if（avg 《0x147 || avg 》0x1BA ） {

　　return TRUE;

　　}

　　#endif

　　#ifdef SERIES_13

　　if（avg 《0xC0 || avg 》0xD4 ） { //if（avg 《0x147 || avg 》0x1BA ） {

　　return TRUE;

　　}

　　#endif

　　}

　　return FALSE;

　　}

　　//LDC1000 Test Routine

　　void LDC16_13_Evm_Test_Routine（） {

　　uint16_t t_buf［2］ = {0x00， 0x00}， test_0=0， test_1=0， test_2=0， test_3=0;

　　//uint8_t rpmin，rpmax;

　　uint16_t i，j，thld;//，noise，min

　　for（i=0;i《10;i++）{

　　__delay_cycles（65000）;

　　}

　　#ifdef SERIES_16

　　thld=5000;

　　#endif

　　#ifdef SERIES_13

　　thld=32;

　　#endif

　　// test_0=L_Noise（&t_buf［0］，0）;

　　// test_1=L_Noise（&t_buf［0］，2）;

　　#ifdef CH_4

　　// test_2=L_Noise（&t_buf［0］，4）;

　　// test_3=L_Noise（&t_buf［0］，6）;

　　#endif

　　if（L_Sample（&t_buf［0］，0））{

　　evm_LED_Set（RED）;

　　}

　　// else if（test_0》thld）{

　　// evm_LED_Set（RED）;

　　// }

　　else if（L_Sample（&t_buf［0］，2））{

　　evm_LED_Set（RED）;

　　}

　　// else if（test_1》thld）{

　　// evm_LED_Set（RED）;

　　// }

　　#ifdef CH_4

　　else if（L_Sample（&t_buf［0］，4））{

　　evm_LED_Set（RED）;

　　}

　　// else if（test_2》thld）{

　　// evm_LED_Set（RED）;

　　// }

　　else if（L_Sample（&t_buf［0］，6））{

　　evm_LED_Set（RED）;

　　}

　　// else if（test_3》thld）{

　　// evm_LED_Set（RED）;

　　// }

　　#endif

　　else{

　　evm_LED_Set（GREEN）;

　　}

　　/** Oscillator

　　Disables USB if there is a problem with the oscillator

　　#pragma vector = UNMI_VECTOR

　　__interrupt VOID UNMI_ISR （VOID）

　　{

　　switch （__even_in_range（SYSUNIV， SYSUNIV_BUSIFG ））

　　{

　　case SYSUNIV_NONE：

　　__no_operation（）;

　　break;

　　case SYSUNIV_NMIIFG：

　　__no_operation（）;

　　break;

　　case SYSUNIV_OFIFG：

　　UCSCTL7 &= ~（DCOFFG + XT1LFOFFG + XT2OFFG）; //Clear OSC flaut Flags fault flags

　　SFRIFG1 &= ~OFIFG; //Clear OFIFG fault flag

　　break;

　　case SYSUNIV_ACCVIFG：

　　__no_operation（）;

　　break;

　　case SYSUNIV_BUSIFG：

　　SYSBERRIV = 0; //clear bus error flag

　　USB_disable（）; //Disable

　　}

打开APP阅读更多精彩内容