DSP实验报告 

一、综合实验内容和要求

1. 实验目的

(1) 学习掌握CCS3.3编译器的使用；

(2) 通过实验学习掌握TMS320F28335的GPIO ，浮点计算； (3) 学习并掌握A/D 模块的使用方法；

(4) 学习并掌握中断方式和查询方式的串口通信； (5) 学习并掌握28335DSP 的定时器相关的设置与运用； (6) 学习信号时域分析的方法，了解相关波形参数的计算方法； (7) 了解数字滤波的一些基本方法； (8) 学习数码管的驱动及运用。

(9) 学习MATLAB 串口以及画图的运用。 2. 实验设计内容与要求：

(1) 对给定的周期波形信号采用TI 公司的TMS320F28335DSP ，利用试验箱上的相关资源计算出波形的周期T ，波形的有效值rms V ，平均值avg V 。其中，有效值和平均值的计算公式(数字量的离散公式)如下：

rms V =

1()N

avg

i

V u i N

=∑

式中N 为一个周期采样点数，()u i 为采样序列中的第i 个采样点。

(2) 通过算法计算出波形的有效值和平均值，利用串口通信把测得的数据发送到串口助手查看，或者在MATLAB 上编写上位机程序，把发送的数据在MATLAB 上画出来。

(3) 把测得的数据实时显示在数码管上。

二、硬件电路

图1为试验系统的硬件图，硬件电路主要包括TMS320F28335DSP 实验箱，SEED-XDS510仿真器，数码管，SCI,信号发生器，电脑，串口线等。

图1 硬件电路图

三、实验原理

本试验主要是通过程序去测量一个周期波形的有效值、平均值、峰值等相关参数。计算离散数据的有效值可用公式rms V =

平均值可用公式1()N avg

i

V u i N

=∑。所以首先需要测出波形的周期，然后确定每个周期需要采样的

点数N ，最后去计算平均值和有效值。

v m

v 1

图2 理想输入采样波形

如图2所示为一个正弦输入波形，

m V 为输入波形的峰值，1V 是介于0~ m V 的

一个值。A 、B 、C 分别为1V 和输入波形相交的三点，则A 、C 两点之间为一个周期，只要测得A 、C 两点之间的时间就可以得到周期值，从而进行后面的计算。

本算法的主要核心是进行比较。当A/D 采样值大于1V 时，开启定时器，第二次A/D 采样值小于1V 时即B 点，第三次A/D 采样值大于1V 时即C 点时关闭定时器，读取定时器的值，从A-C 是一个周期，这样就可以通过程序测得波形的周期T 。每次A/D 采样间隔的时间一样为7.5 s μ，这样就可以算出来一个周期需要采集的点数N=T/7.5 s μ。

然后根据公式rms V =1()

N

avg

i

V u i N

=∑算出平均值和有效值。

v m v 1

图3 输入采样真实波形

如图3所示，在具体实验时遇到测周期不准的问题，后面发现是因为输入波形不是理想的，在和固定比较值比较的时候会有抖动，这样的话可能会在一个点重复比较好几次。后面在程序里面加了防抖动的程序，有效的解决了这个问题。在采样后与1V 比较一次在继续比较5个点，如果有5个点都比1V 大或者小才确认比较了一次，这样有效地解决了波形的抖动问题，使测得的周期准确稳定。

四、程序流程图

如图4所示，为程序的总流程图，包括DSP 的初始化，A/D 采样，比较通过定时器算出周期，然后根据上面所提的公式计算有效值和平均值，最后把得到的

值发送到上位机上实时画图显示并且在数码管上显示出来。

图4 程序流程图

五、实验结果和分析

1、试验平台

本试验实验平台为CCS3.3，主界面如图所示。

图5 CCS3.3平台主界面

2、试验步骤

(1) 实验准备：给实验板加电，启动CCS，打开工程，连接目标板。

(2) 通过键盘设置输入信号。

(3) 编写好程序，编译并下载程序。

(4) 在PC机上打开串口调试助手，在CCS中打开观察波形和一些变量的窗口，

启动程序，观察相关波形和参数。

3、试验波形和结果

通过键盘设置信号发生器输出的波形形状、幅值和频率，然后去观察测得的周期值，有效值和平均值来检测算法的正确性和通用性。

如图6所示输入1000Hz/1000mV的正弦波的采样波形，数码管有效值显示，

watch window相关变量值的照片如下所示。

图6 1000Hz/1000mV正弦波波形及参数

如图7所示输入1000Hz/2000mV的正弦波的采样波形，数码管有效值显示，watch window相关变量值的照片如下所示。

图7 1000Hz/2000mV正弦波波形及参数

如图8所示输入2000Hz/1000mV的正弦波的采样波形，数码管有效值显示，watch window相关变量值的照片如下所示。

图8 2000Hz/1000mV正弦波波形及参数

如图9所示输入1000Hz/1000mV的方波的采样波形，数码管有效值显示，watch window相关变量值的照片如下所示。

图9 1000Hz/1000mV方波波形及参数

如图10所示输入1000Hz/1000mV的三角波的采样波形，数码管有效值显示，watch window相关变量值的照片如下所示。

图10 1000Hz/1000mV三角波波形及参数

如图11所示为通过串口把有效值发送到串口助手的截图，可以看出DSP可以成功的通过SCI把测得的数据发送到上位机上。同时也可以把发送的数据用MATLAB画出来。

图11 串口发送有效值显示

4、试验结果分析

通过实验可以看出可以看出A/D采样显示正常，所用的程序可以较好的测得正弦波、方波、三角波的周期值、平均值。另外可以通过串口把需要测得的参数发送到串口助手上，或者自己编写的MATLAB上位机实时显示波形。通过键盘修改输入波形的频率和周期也可以很稳定的测得波形的周期、有效值、平均值，从而验证了算法正确性。

5、试验中的问题及解决

(1) 实验板加电后第二次烧写程序后，总是进不了A/D采样中断程序，每次运行

一次都要重启一下实验板。经过分析应该是程序在运行一次后，让程序停止后A/D中断的一些中断标志位没有清零。所以我在程序的一开始加上了清A/D中断标志位的程序，有效的解决了这个问题。

(2) 在想好测量周期算法后，写好程序验证时发现，测得的周期值很不稳定。经

过观察波形分析，是因为实际采样波形会有波动。加了防抖动算法后有效解决了这个问题。

(3) 在编写MATLAB上位机实时显示波形时，发现由于串口一次只能发送一个

字节，最大只能到255，而需要发送的参数值大于255。经过查询资料，我把每个参数分高八位和低八位发送，然后在上位机上再把这两个八位数据合并成一个十六位数据。

(4) 开始程序计算波形周期、有效值、平均值算法都放在A/D中断里面，结果发

现会影响A/D的采样，经过分析发现，因为算法计算量挺大，在中断里面算不完。所以我在A/D中断里面设置了一个标志位，当采样完一个周期以后置位，然后在main函数的for循环里面判断计算，提高了CPU的计算效率。

六、实验总结

通过这段时间的DSP的学习和实验，让我对TMS320F28335各个模块有了一定深度的理解和认识，让我更好的把握了这款DSP的相关知识，同时也让我对其他DSP的学习打好基础。通过这次实验，也遇到了很多问题，自己和同学仔细去分析，一步一步去解决问题，锻炼了我们分析DSP相关问题的能力。另外结合上学期学习的MATLAB知识，自己查询资料，在MATLAB里面写了串口的程序，把发送过来的数据通过画图画出来。感觉学习狠多。另外非常感谢崔

江老师和沈乐同学的指导和帮助。

七、DSP MAIN函数源程序清单（双栏）

#include "DSP2833x_Device.h" // DSP2833x Headerfile Include File

#include "DSP2833x_Examples.h" // DSP2833x Examples Include File

#include "math.h"

//#include "math.h"

#define SCI 1

#define UART_INT 0

// Prototype statements for functions found within this file.

interrupt void adc_isr(void);

interrupt void ISRTimer2(void);

interrupt void scicTxFifoIsr(void);

interrupt void scicRxFifoIsr(void);

interrupt void scibTxFifoIsr(void);

interrupt void scibRxFifoIsr(void);

void scib_fifo_init();

void scic_fifo_init();

void error(void);

#if (CPU_FRQ_150MHZ) // Default - 150 MHz SYSCLKOUT

#define ADC_MODCLK 0x3 // HSPCLK = SYSCLKOUT/2*ADC_MODCLK2 = 150/(2*3) = 25.0 MHz

#endif

#if (CPU_FRQ_100MHZ)

#define ADC_MODCLK 0x2 // HSPCLK = SYSCLKOUT/2*ADC_MODCLK2 = 100/(2*2) = 25.0 MHz

#endif

#define ADC_CKPS 0x1 // ADC module clock = HSPCLK/2*ADC_CKPS = 25.0MHz/(1*2) = 12.5MHz #define ADC_SHCLK 0xf // S/H width in ADC module periods = 16 ADC clocks

#define A VG 1000 // Average sample limit

#define ZOFFSET 0x00 // Average Zero offset

#define BUF_SIZE 160 // Sample buffer size

// Global variables used in this example:

// Global variables

Uint16 dataC; // Received data for SCI-A Uint16 dataB; // Rceived data for SCI-A Uint16 ConversionCount=0;

Uint16 Voltage1[1024];

Uint32 jifen=0;

Uint32 vrms=0;

Uint32 vavg=0;

Uint32 voltage=0;

Uint16 cnt=0;

Uint32 Vdc;

Uint32 ACpeak;

Uint32 peak[10];

int Led_Flag;

int Comp_Flag=0;

Uint32 Period=0;

Uint32 Freq=0;

Uint32 fangdoucnt=0;

Uint32 fangdou1cnt=0;

Uint32 plotnum=200;

int startflag=0;

int jifencnt=0;

int i=0;

void write();

void txnum(int a);

main()

{

// Step 1. Initialize System Control:

// PLL, WatchDog, enable Peripheral Clocks

// This example function is found in the DSP2833x_SysCtrl.c file.

InitSysCtrl();

// Step 2. Initialize GPIO:

// This example function is found in the DSP2833x_Gpio.c file and

// illustrates how to set the GPIO to it's default state.

InitGpio(); // Skipped for this example

InitSciGpio();

// Step 3. Clear all interrupts and initialize PIE vector table:

// Disable CPU interrupts

DINT;

// Initialize the PIE control registers to their default state.

// The default state is all PIE interrupts disabled and flags

// are cleared.

// This function is found in the DSP2833x_PieCtrl.c file.

InitPieCtrl();

// Disable CPU interrupts and clear all CPU interrupt flags:

IER = 0x0000;

IFR = 0x0000;

// Initialize the PIE vector table with pointers to the shell Interrupt

// Service Routines (ISR).

// This will populate the entire table, even if the interrupt

// is not used in this example. This is useful for debug purposes.

// The shell ISR routines are found in DSP2833x_DefaultIsr.c.

// This function is found in DSP2833x_PieVect.c.

InitPieVectTable();

#if UART_INT

// Interrupts that are used in this example are re-mapped to

// ISR functions found within this file.

EALLOW; // This is needed to write to EALLOW protected registers

#if SCI

PieV ectTable.SCIRXINTB = &scibRxFifoIsr;

PieV ectTable.SCITXINTB = &scibTxFifoIsr;

#else

PieV ectTable.SCIRXINTC = &scicRxFifoIsr;

PieV ectTable.SCITXINTC = &scicTxFifoIsr;

#endif

EDIS; // This is needed to disable write to EALLOW protected registers

#endif

// Step 4. Initialize all the Device Peripherals: // This function is found in DSP2833x_InitPeripherals.c

// InitPeripherals(); // Not required for this example

#if SCI

scib_fifo_init(); // Init SCI-B

#else

scic_fifo_init(); // Init SCI-C

#endif

// Step 5. User specific code, enable interrupts: #if UART_INT

// Enable interrupts required for this example PieCtrlRegs.PIECTRL.bit.ENPIE = 1;

// Enable the PIE block

#if SCI

PieCtrlRegs.PIEIER9.bit.INTx3=1;

// PIE Group 9, INT3 RE

PieCtrlRegs.PIEIER9.bit.INTx4=1;

// PIE Group 9, INT4 TX

IFR = 0x0000;

IER = 0x100; // Enable CPU INT

#else

PieCtrlRegs.PIEIER8.bit.INTx5=1;

// PIE Group 8, int5 RE

PieCtrlRegs.PIEIER8.bit.INTx6=1;

// PIE Group 8, INT6 TX

IFR = 0x0000;

IER = 0x080; // Enable CPU INT

#endif

EINT;

#endif

// Interrupts that are used in this example are re-mapped to

// ISR functions found within this file.

EALLOW; // This is needed to write to EALLOW protected register

PieV ectTable.ADCINT = &adc_isr;

PieV ectTable.TINT2 = &ISRTimer2;

EDIS; // This is needed to disable write to EALLOW protected registers

// Step 4. Initialize all the Device Peripherals: // This function is found in DSP2833x_InitPeripherals.c

// InitPeripherals(); // Not required for this example

InitXintf();

InitAdc(); // For this example, init the ADC

InitCpuTimers();

ConfigCpuTimer(&CpuTimer2, 150, 1000000);

StopCpuTimer2();

//StartCpuTimer2();

CpuTimer2Regs.TCR.all = 0x4001; // Use write-only instruction to set TSS bit = 0

// CpuTimer2Regs.TIM.all=0;

// Step 5. User specific code, enable interrupts:

max7219_data_send(0x090f);//设置译码方式寄存器，

max7219_data_send(0x0a05);//设置亮度调整寄存器

max7219_data_send(0x0b03);//设置扫描控制寄存器

max7219_data_send(0x0c01);//设置掉电模式寄存器

max7219_data_send(0x0f00);

DELAY_US(1000);

// Enable ADCINT in PIE

PieCtrlRegs.PIEIER1.bit.INTx6 = 1;

PieCtrlRegs.PIEIER1.bit.INTx7 = 1;

IER |= M_INT1; // Enable CPU Interrupt 1 IER |= M_INT14;

EINT; // Enable Global interrupt INTM

ERTM; // Enable Global realtime interrupt DBGM

LoopCount = 0;

ConversionCount = 0;

AdcRegs.ADCTRL1.bit.ACQ_PS = ADC_SHCLK;

AdcRegs.ADCTRL3.bit.ADCCLKPS = ADC_CKPS;

AdcRegs.ADCTRL1.bit.SEQ_CASC = 1;

// 0 Non-Cascaded Mode; 1 Cascaded Mode

AdcRegs.ADCTRL2.bit.INT_ENA_SEQ1 = 0x1;

AdcRegs.ADCTRL2.bit.RST_SEQ1 = 0x1;

AdcRegs.ADCCHSELSEQ1.bit.CONV00 = 0x6;

AdcRegs.ADCMAXCONV.bit.MAX_CO

NV1 = 15;

AdcRegs.ADCTRL2.bit.SOC_SEQ1 = 0x1 ;

// write(1234);

// Wait for ADC interrupt

AdcRegs.ADCTRL2.bit.RST_SEQ1 = 1;

// Reset SEQ1

AdcRegs.ADCST.bit.INT_SEQ1_CLR = 1;

// Clear INT SEQ1 bit

PieCtrlRegs.PIEACK.all = PIEACK_GROUP1; // Acknowledge interrupt to PIE

AdcRegs.ADCTRL2.bit.SOC_SEQ1 = 0x1 ;

//LoopCount=sqrt(199);

for(;;)

{

if(startflag==1)

{

jifen=0;

startflag=0;

for(i=0;i

{

voltage=V oltage1[i]*3/4;

vavg=vavg+voltage;

jifen+=voltage*voltage;

}

vrms=jifen/plotnum;

vrms=sqrt(vrms);

vavg=vavg/plotnum;

txnum(vrms);

write(vrms);

}

}

}

/*void txnum(int a)//串口发送

{

ScibRegs.SCITXBUF='0'+a/1000;

while(ScibRegs.SCIFFTX.bit.TXFFST != 0); ScibRegs.SCITXBUF='0'+a/100%10;

while(ScibRegs.SCIFFTX.bit.TXFFST != 0); ScibRegs.SCITXBUF='0'+a/10%10;

while(ScibRegs.SCIFFTX.bit.TXFFST != 0); ScibRegs.SCITXBUF='0'+a%10; while(ScibRegs.SCIFFTX.bit.TXFFST != 0); ScibRegs.SCITXBUF=',';

while(ScibRegs.SCIFFTX.bit.TXFFST != 0);

}*/

void txnum(int a)

{

ScibRegs.SCITXBUF=a>>8;

while(ScibRegs.SCIFFTX.bit.TXFFST !=

0);

ScibRegs.SCITXBUF=a&&0xff;

while(ScibRegs.SCIFFTX.bit.TXFFST !=

0);

}

interrupt void adc_isr(void)//7.5us进一次中断

{

//txnum(sqrt(900)*10);

V oltage1[ConversionCount] = AdcRegs.ADCRESULT0 >>4;

if((V oltage1[ConversionCount]>650)&&(

Comp_Flag==0))

{

//fangdou=ConversionCount;

fangdoucnt++;

if(fangdoucnt>5)

{

fangdoucnt=0;

Comp_Flag=1;

ReloadCpuTimer2();

StartCpuTimer2();//打开定时器

}

//CpuTimer2Regs.TIM.all=150000000;

}

if(Comp_Flag==1)

{

//if(ConversionCount>fangdou+4)

//{

// fangdou=0;

if(V oltage1[ConversionCount]<650) {

fangdou1cnt++;

if(fangdou1cnt>5)

{

fangdou1cnt=0;

Comp_Flag=2;

}

}

// }

}

if(Comp_Flag==2)

{

if(Voltage1[ConversionCount]>650) {

Comp_Flag=0;

fangdoucnt=0;

fangdou1cnt=0;

Period=150000000-CpuTimer2Regs.TIM. all;//周期时间

plotnum=Period/15/76;//一个周期采样次数

//startflag=1;

StopCpuTimer2();//关闭定时器

}

}

//voltage=Voltage1[ConversionCount]*3/4;

/* if(startflag==1)

{

jifencnt++;

jifen+=voltage*voltage;

if(jifencnt==plotnum)

{

jifencnt=0;

vrms=jifen/plotnum;

vrms=sqrt(vrms);

jifen=0;

plotnum=Period/15/74;

// txnum(vrms);

}

}*/

// If 40 conversions have been logged, start over

if(ConversionCount ==plotnum)

{

startflag=1;

ConversionCount = 0;

// vrms=sqart(vrms);

//write(vrms);

}

else ConversionCount++;

if(cnt==100)

{

write(vrms);

cnt=0;

}

// Reinitialize for next ADC sequence AdcRegs.ADCTRL2.bit.RST_SEQ1 = 1;

// Reset SEQ1

AdcRegs.ADCST.bit.INT_SEQ1_CLR = 1;

// Clear INT SEQ1 bit

PieCtrlRegs.PIEACK.all = PIEACK_GROUP1; // Acknowledge interrupt to PIE

AdcRegs.ADCTRL2.bit.SOC_SEQ1 = 0x1 ;

return;

}

interrupt void ISRTimer2(void)

{

CpuTimer2.InterruptCount++;

if(Led_Flag == 1)

{

GpioDataRegs.GPADAT.bit.GPIO0 =0;

Led_Flag = 0;

}

else

{

GpioDataRegs.GPADAT.bit.GPIO0 =1;

Led_Flag = 1;

}

}

void scib_fifo_init()

{

ScibRegs.SCICCR.all =0x0007; // 1 stop bit, No loopback

// No parity,8 char bits,

// async mode, idle-line protocol

ScibRegs.SCICTL1.all =0x0003; // enable TX, RX, internal SCICLK,

// Disable RX ERR, SLEEP, TXW AKE

#if UART_INT

ScibRegs.SCICTL2.bit.TXINTENA =1;

ScibRegs.SCICTL2.bit.RXBKINTENA

=1;

ScibRegs.SCIHBAUD =0x0001;

ScibRegs.SCILBAUD =0x00e7;

ScibRegs.SCICCR.bit.LOOPBKENA =0;

// disenable loop back

ScibRegs.SCIFFTX.all=0xC020;

ScibRegs.SCIFFRX.all=0x0021;

ScibRegs.SCIFFCT.all=0x00;

ScibRegs.SCICTL1.all =0x0023; // Relinquish SCI from Reset

ScibRegs.SCIFFTX.bit.TXFIFOXRESET

=1;

ScibRegs.SCIFFRX.bit.RXFIFORESET=

1;

#else

ScibRegs.SCICTL2.all =0x0003;

ScibRegs.SCICTL2.bit.TXINTENA =1;

ScibRegs.SCICTL2.bit.RXBKINTENA

=1;

ScibRegs.SCIHBAUD =0x0001;

ScibRegs.SCILBAUD =0x00e7;

ScibRegs.SCICCR.bit.LOOPBKENA =0;

// Disable loop back

ScibRegs.SCICTL1.all =0x0023; // Relinquish SCI from Reset

ScibRegs.SCIFFTX.bit.TXFIFOXRESET

=0;

ScibRegs.SCIFFRX.bit.RXFIFORESET=

0;

ScibRegs.SCIFFTX.all=0xE040;

ScibRegs.SCIFFRX.all=0x204f;

ScibRegs.SCIFFCT.all=0x0;

#endif

}

void scic_fifo_init()

{

ScicRegs.SCICCR.all =0x0007; // 1 stop bit, No loopback

// No parity,8 char bits,

// async mode, idle-line protocol

ScicRegs.SCICTL1.all =0x0003; // enable TX, RX, internal SCICLK,

// Disable RX ERR, SLEEP, TXW AKE

#if UART_INT

ScicRegs.SCICTL2.bit.TXINTENA =1;

ScicRegs.SCICTL2.bit.RXBKINTENA

=1;

ScicRegs.SCIHBAUD = 0x0001;

ScicRegs.SCILBAUD = 0x00e7;

ScicRegs.SCICCR.bit.LOOPBKENA =0;

// Disenable loop back

ScicRegs.SCIFFTX.all=0xC020;

ScicRegs.SCIFFRX.all=0x0021;

ScicRegs.SCIFFCT.all=0x00;

ScicRegs.SCICTL1.all =0x0023; // Relinquish SCI from Reset

ScicRegs.SCIFFTX.bit.TXFIFOXRESET

=1;

ScicRegs.SCIFFRX.bit.RXFIFORESET=1

;

#else

ScicRegs.SCICTL2.all =0x0003;

ScicRegs.SCICTL2.bit.TXINTENA =1;

ScicRegs.SCICTL2.bit.RXBKINTENA

=1;

ScicRegs.SCIHBAUD =0x0001;

ScicRegs.SCILBAUD =0x00e7;

ScicRegs.SCICCR.bit.LOOPBKENA =0;// Disable loop back

ScicRegs.SCICTL1.all =0x0023; // Relinquish SCI from Reset

ScicRegs.SCIFFTX.bit.TXFIFOXRESET

=0;

ScicRegs.SCIFFRX.bit.RXFIFORESET=0

;

ScicRegs.SCIFFTX.all=0xE040;

ScicRegs.SCIFFRX.all=0x204f;

ScicRegs.SCIFFCT.all=0x0;

#endif

}

interrupt void scibTxFifoIsr(void)

{

ScibRegs.SCIFFTX.bit.TXFFINTCLR=1;

// Clear Interrupt flag

PieCtrlRegs.PIEACK.all|=0x100; // Issue PIE ACK

}

interrupt void scibRxFifoIsr(void)

{

dataB=ScibRegs.SCIRXBUF.all; //

Read data

ScibRegs.SCITXBUF=dataB; // Send data

ScibRegs.SCIFFRX.bit.RXFFOVRCLR=

1; // Clear Overflow flag

ScibRegs.SCIFFRX.bit.RXFFINTCLR=1;

// Clear Interrupt flag

PieCtrlRegs.PIEACK.all|=0x100; //

Issue PIE ack

}

interrupt void scicTxFifoIsr(void)

{

ScicRegs.SCIFFTX.bit.TXFFINTCLR=1;

// Clear SCI Interrupt flag

PieCtrlRegs.PIEACK.all|=0x080; // Issue PIE ACK

}

interrupt void scicRxFifoIsr(void)

{

dataC=ScicRegs.SCIRXBUF.all; //

Read data

ScicRegs.SCITXBUF=dataC; // Send data

ScicRegs.SCIFFRX.bit.RXFFOVRCLR=1;

// Clear Overflow flag

ScicRegs.SCIFFRX.bit.RXFFINTCLR=1;

// Clear Interrupt flag

PieCtrlRegs.PIEACK.all|=0x080;

// Issue PIE ack

}

void error(void)

{

asm(" ESTOP0"); // Test failed!!

Stop!

for (;;);

}

//================================ ==============================

=============

// No more.

//================================ ==============================

=============

void write(Uint16 x) {

int qian=0;

int bai=0;

int shi=0;

int ge=0;

qian=x/1000; bai=x%1000/100;

shi=x%100/10;

ge=x%10;

max7219_data_send(0x0100+qian); max7219_data_send(0x0200+bai); max7219_data_send(0x0300+shi); max7219_data_send(0x0400+ge); }

八、MATLAB源程序

scom=serial('COM1');

scom.BaudRate = 9600;

scom.InputBufferSize = 1024;

scom.OutputBufferSize = 1024;

scom.ReadAsyncMode = 'continuous'; scom.BytesAvailableFcnMode = 'byte'; scom.BytesAvailableFcnCount = 100; scom.BytesAvailableFcn = @instrcallback; fopen(scom)

data=zeros(100,1);

dataout=zeros(50,1);

data=fread(obj,100,'uint8');

dataout=zeros(50,1);

for i=1:50

dataout(i)=256*data(2*i)+data(2*i-1); end

fid=fopen('G1.txt','a+');

fprintf(fid,'%5d',dataout);

fclose(fid);

speed=textread('G1.txt','%5d');

plot(speed);

grid on;

end