博客园_给我一杯酒

MSP430程序库<十六>总结

2011-10-01T11:21:00Z

全国电子设计竞赛结束已经有一段时间了，这个程序库也就到这儿了，程序库已经包含msp430f14x msp430f16x系列的单片机大多数的片内资源。目录如下：

MSP430程序库<一>综述
MSP430程序库<二>UART异步串口
MSP430程序库<三>12864液晶程序库
MSP430程序库<四>printf和scanf函数移植
MSP430程序库<五>SPI同步串行通信
MSP430程序库<六>通过SPI操作AD7708
MSP430程序库<七>按键
MSP430程序库<八>DAC12的使用
MSP430程序库<九>数码管显示
MSP430程序库<十>ADC12模块
MSP430程序库<十一>定时器TA的PWM输出
MSP430程序库<十二>SVS(电源电压监控器)模块
MSP430程序库<十三>硬件乘法器使用
MSP430程序库<十四>DMA程序库
MSP430程序库<十五>Flash控制器
MSP430程序库<十六>总结

这个程序库的程序和有关资料可以用svn check-out 地址为：svn://www.oksvn.com/msp430，这里；也可以从程序库下载。完整（包含所有使用资料的版本）版本可以到http://dl.dbank.com/c04y2bbx4a下载。

程序库的内容就到这里了，多谢广大网友的支持啦；有什么不足之处，欢迎拍砖。

作者：给我一杯酒
出处：http://Engin.cnblogs.com/
本文版权归作者和博客园共有，欢迎转载，转载保留此段文字并且注明出处；谢谢。

本文链接

MSP430程序库<十五>Flash控制器

2011-08-31T03:42:00Z

一般，在单片机中的Flash存储器用于存放程序代码，属于只读型存储器。而在MSP430些列的单片机中，都可以通过内置的Flash控制器擦除或改写任何一段的内容。另外，msp430的单片机内部还专门留有一段Flash区域(information memory)，用于存放掉电后需要永久保存的数据。利用430内部的Flash控制器，可以完成较大容量的数据记录、用户设置参数在掉电后的保存等功能。

硬件介绍：
要对Flash读写，首先要了解MSP430的存储器组织。430单片机的存储器组织结构采用冯诺依曼结构，RAM和ROM统一编址在同一寻址空间中，没有代码空间和数据空间之分。

一般430的单片机都统一编址在0-64k地址范围中，只有少数高端的型号才能突破64k（如：FG461x系列）。绝大多数的msp430单片机都编址在64kB范围内。地址的大概编码方式如下：

这是msp430f425的存储器分配图，其他在64k范围内的存储器的单片机编址方式与此类似：低256B是寄存器区，然后是RAM；空白；1000H到10FFH是信息Flash区；大于1100H-0FFFFH是主存储器区(从0FFFFH开始往低地址有单片机的主Flash，多余的部分空白)。

MSP430F14x的Flash分布：

MSP430F16x的Flash分布：

主Flash部分和信息Flash部分如下(60kB Flash对应的单片机，如msp430f149、msp430f149)：

主Flash分为以512B为段的单位，0段是单片机中断向量等程序入口地址，使用时不要擦除此段或改写此段，若要擦除或是改写，请先保存内容到RAM或其他段；主Flash各段内容均要避免写入或擦除，以免造成不可预料的后果。

信息Flash分为两段：段A和段B，每段128B；可以保存用户自己的内容(主Flash也可以但是要避免与程序代码区冲突)；这里就把信息Flash的两段称为InfoA(1080H-10FFh)和InfoB(1000H-10FFH)。

Flash的操作包括：字或字节写入；块写入；段擦除；主Flash擦除；全部擦除。任何的Flash操作都可以从Flash或从RAM中运行。

Flash操作时需要时序发生器，Flash控制器内部含有时序发生器用以产生所需的Flash时钟，Flash时钟的范围必须在257kHz到476kHz之间。时序发生器的框图如下：

时序发生器可以选择ACLK、MCLK、SMCLK作为时钟源，通过分频获得所需的257kHz到476kHz之间的Flash操作时钟。如果时钟频率不再这个范围内，将会产生不可预料的结果。

擦除：擦除之后，存储器中的bit都变为1；Flash中的每一位都可以通过编程写入有1到0，但是要想由0变为1，必须通过擦除周期。擦除的最小单位是段。有三种擦除模式：
MERAS ERASE Erase Mode
0 1 Segment erase
1 0 Mass erase (all main memory segments)
1 1 Erase all flash memory (main and information .segments)

可以通过MERAS、ERASE 位来设置擦除的模式：段擦除，主Flash擦除，全部擦除。

对要擦除段内的一个地址空写入启动擦出周期：空写入可以启动时序发生器和擦除操作。空写入后BUSY位立即变高直到擦除周期结束，这一位变为低(0)。BUSY, MERAS和 ERASE位在擦除周期结束后会自动复位。擦除周期的时间和要擦出的Flash大小无关，每次擦除的时间对于MSP430F1xx系系列单片机来说，所需时间是一样的。擦除的时序如下：

当空写入到的地址不在要擦除的段地址范围内的时候，空写入无效，直接被忽略。在擦除周期内，应该关中断，直到擦除完成，重新开中断，擦除期间的中断已经置标志位，开中断后立即响应。

从Flash中启动的擦除操作：擦除操作可以从Flash中启动或是从RAM中启动。当操作是从Flash中启动的时候，Flash控制器控制了操作时序，CPU运行被暂停直到擦除结束。擦除周期结束后，CPU继续执行，从空写入之后的指令开始运行。当从Flash中启动擦除操作时，可以擦除即将运行的程序所在的段，如果擦除了即将运行的程序所在的Flash段时，擦除结束后，CPU的运行不可预料。

从Flash启动时擦除周期如下：

用户指南里面的示例汇编程序如下：
; Segment Erase from flash. 514 kHz < SMCLK < 952 kHz
; Assumes ACCVIE = NMIIE = OFIE = 0.
MOV #WDTPW+WDTHOLD,&WDTCTL ; Disable WDT
DINT //; Disable interrupts
MOV #FWKEY+FSSEL1+FN0,&FCTL2 ; SMCLK/2
MOV #FWKEY,&FCTL3 ; Clear LOCK
MOV #FWKEY+ERASE,&FCTL1 ; Enable segment erase
CLR &0FC10h ; Dummy write, erase S1
MOV #FWKEY+LOCK,&FCTL3 ; Done, set LOCK
... ; Re-enable WDT?
EINT ; Enable interrupts

从RAM中启动擦除操作：任意擦除周期都可以从RAM启动，这时CPU不再暂停而是继续从RAM中运行接下来的程序。CPU可以访问任何Flash地址之前，必须检查BUSY位以确定擦除周期结束。如果BUSY = 1访问Flash，这是一个访问冲突，这时ACCVIFG将被设置，而擦除的结果将是不可预测的的。

从RAM中启动擦除操作时，过程如下：

要在擦除之前确认没有访问Flash，然后擦除完成之前不允许访问Flash。
; Segment Erase from RAM. 514 kHz < SMCLK < 952 kHz
; Assumes ACCVIE = NMIIE = OFIE = 0.
MOV #WDTPW+WDTHOLD,&WDTCTL ; Disable WDT
DINT ; Disable interrupts
L1 BIT #BUSY,&FCTL3 ; Test BUSY
JNZ L1 ; Loop while busy
MOV #FWKEY+FSSEL1+FN0,&FCTL2; SMCLK/2
MOV #FWKEY,&FCTL3 ; Clear LOCK
MOV #FWKEY+ERASE,&FCTL1 ; Enable erase
CLR &0FC10h ; Dummy write, erase S1
L2 BIT #BUSY,&FCTL3 ; Test BUSY
JNZ L2 ; Loop while busy
MOV #FWKEY+LOCK,&FCTL3 ; Done, set LOCK
... ; Re-enable WDT?
EINT ; Enable interrupts

写Flash操作：写入的模式由WRT和BLKWRT位来确定：
BLKWRT WRT Write Mode
0 1 Byte/word write
1 1 Block write

这两种模式中块写入大约是字或字节写操作时的两倍快，因为在块写入完成之前，变成电压一直维持直到块写入完成。同一个位置不能在擦除周期之前写入两次或以上，否则将发生数据损坏。写操作时，BUSY位被置1，写入完成后，BUSY被自动清零。如果写操作是从RAM发起的，在BUSY=1时，程序不能访问Flash，否则会发生访问冲突，置位ACCVIFG，Flash写入操作不可以预料。

字或字节写入：字或字节写入可以从Flash内部发起，也可以从RAM中发起。如果是从Flash中启动的写操作，时序将由Flash控制，在写入完成之前CPU运行将被暂停。写入完成后CPU将继续运行。

操作时序如下：

若是从RAM中启动写Flash，程序将继续从RAM中运行。CPU再次访问Flash之前必须确认BUSY位已经清零，否则会发生访问冲突，置位ACCVIFG，写入的结果将不可预料。
字或字节写入模式下，内部产生的编程电压时适用于完整的64个字节块的写入
In byte/word mode, the internally-generated programming voltage is applied
to the complete 64-byte block, each time a byte or word is written, for 32 of the
35 fFTG cycles. With each byte or word write, the amount of time the block is
subjected to the programming voltage accumulates. The cumulative
programming time, tCPT, must not be exceeded for any block. If the cumulative
programming time is met, the block must be erased before performing any
further writes to any address within the block.

从Flash发起写字节或字时：

; Byte/word write from flash. 514 kHz < SMCLK < 952 kHz
; Assumes 0FF1Eh is already erased
; Assumes ACCVIE = NMIIE = OFIE = 0.
MOV #WDTPW+WDTHOLD,&WDTCTL ; Disable WDT
DINT ; Disable interrupts
MOV #FWKEY+FSSEL1+FN0,&FCTL2 ; SMCLK/2
MOV #FWKEY,&FCTL3 ; Clear LOCK
MOV #FWKEY+WRT,&FCTL1 ; Enable write
MOV #0123h,&0FF1Eh ; 0123h −> 0FF1Eh
MOV #FWKEY,&FCTL1 ; Done. Clear WRT
MOV #FWKEY+LOCK,&FCTL3 ; Set LOCK
... ; Re-enable WDT?
EINT ; Enable interrupts

从RAM中启动写入操作时：

; Byte/word write from RAM. 514 kHz < SMCLK < 952 kHz
; Assumes 0FF1Eh is already erased
; Assumes ACCVIE = NMIIE = OFIE = 0.
MOV #WDTPW+WDTHOLD,&WDTCTL ; Disable WDT
DINT ; Disable interrupts
L1 BIT #BUSY,&FCTL3 ; Test BUSY
JNZ L1 ; Loop while busy
MOV #FWKEY+FSSEL1+FN0,&FCTL2 ; SMCLK/2
MOV #FWKEY,&FCTL3 ; Clear LOCK
MOV #FWKEY+WRT,&FCTL1 ; Enable write
MOV #0123h,&0FF1Eh ; 0123h −> 0FF1Eh
L2 BIT #BUSY,&FCTL3 ; Test BUSY
JNZ L2 ; Loop while busy
MOV #FWKEY,&FCTL1 ; Clear WRT
MOV #FWKEY+LOCK,&FCTL3 ; Set LOCK
... ; Re-enable WDT?
EINT ; Enable interrupts

块写入：当需要写入连续的多个字或字节时，块写入能够能够提高Flash访问速度。块写入时，内部产生的编程电压一直存在在64个字节的块写入期间。块写入不能有Flash存储器内启动，必须从RAM中发起块写入操作。块写入期间，BUSY位被置位。在写入每个字节或字时必须检测WAIT位。下一个字或字节能够被写入时，WAIT位被置位。

块写入的过程如下：

; Write one block starting at 0F000h.
; Must be executed from RAM, Assumes Flash is already erased.
; 514 kHz < SMCLK < 952 kHz
; Assumes ACCVIE = NMIIE = OFIE = 0.
MOV #32,R5 ; Use as write counter
MOV #0F000h,R6 ; Write pointer
MOV #WDTPW+WDTHOLD,&WDTCTL ; Disable WDT
DINT ; Disable interrupts
L1 BIT #BUSY,&FCTL3 ; Test BUSY
JNZ L1 ; Loop while busy
MOV #FWKEY+FSSEL1+FN0,&FCTL2 ; SMCLK/2
MOV #FWKEY,&FCTL3 ; Clear LOCK
MOV #FWKEY+BLKWRT+WRT,&FCTL1 ; Enable block write
L2 MOV Write_Value,0(R6) ; Write location
L3 BIT #WAIT,&FCTL3 ; Test WAIT
JZ L3 ; Loop while WAIT=0
INCD R6 ; Point to next word
DEC R5 ; Decrement write counter
JNZ L2 ; End of block?
MOV #FWKEY,&FCTL1 ; Clear WRT,BLKWRT
L4 BIT #BUSY,&FCTL3 ; Test BUSY
JNZ L4 ; Loop while busy
MOV #FWKEY+LOCK,&FCTL3 ; Set LOCK
... ; Re-enable WDT if needed
EINT ; Enable interrupts

当任何写或擦除操作是从RAM启动，而BUSY = 1，CPU不能读取或写入或从任何Flash位置。否则，发生访问冲突，ACCVIFG设置，结果是不可预知的。此外，如果闪存写入让WRT= 0，ACCVIFG中断标志设置，Flash不受影响。

如果写入或擦除操作时从Flash启动的，CPU访问下一条指令时(从Flash读取指令)，Flash控制器返回03FFFH给CPU；03FFFH是指令JMP PC，这让CPU一直循环直到Flash操作完成。Flash写入或擦除操作完成后，允许CPU继续访问接下来的指令。

当BUSY=1时，Flash访问时：

在开始Flash操作之前，需要停止所有的中断源。如果在Flash操作期间有中断响应，读中断服务程序的地址时，将收到03FFFH作为中断服务程序的地址。如果BUSY=1；CPU将一直执行难IMP PC指令；Flash操作完成后，将从03FFFH执行中断服务程序而不是正确的中断程序的地址。

停止写入或擦除：任何写入和擦除操作都可以在正常完成之前，通过设置紧急退出位EMEX退出操作。设置EMEX时，立即停止当前活动的操作，停止Flash控制器；所有的Flash操作停止，Flash返回可读模式，FCTL1的所有位复位；操作的结果不可预料。

设置和访问Flash控制器：FCTLx是16位的、密码保护的、可读写的寄存器。写入这些寄存器都必须在高位包含密码0A5H，如果写入的不是0A5H，将会引起复位。读寄存器时高位读出的是96H。

在擦除或写入字或字节时写FCTL1寄存器将会引起访问冲突，置位ACCVIFG.块写入时，WAIT=1时可以写FCTL1寄存器，当WAIT=0时写FCTL1寄存器是访问冲突，置位ACCVIFG。BUSY=1时，所有写入FCTL2寄存器都是访问冲突。BUSY=1时，所有的FCTLx都可以读操作，不会引起访问冲突。

Flash的中断：Flash控制器有两个中断源：KEYV, 和ACCVIFG。ACCVIFG在访问冲突的时候被置位。当ACCVIE在Flash操作完成后被重新使能后ACCVIFG会引起中断请求。ACCIFG和NMI同样的中断向量，所以这个中断不需要GIE位允许即可产生中断请求。必须通过软件检测ACCVIFG位，以确定发生了访问冲突；ACCVIFG位必须软件复位。KEYV是关键值错误当写Flash的寄存器时没有写正确的高位密码时被置位，这是会立刻引起PUC信号复位整个硬件。

编程Flash的硬件：编程430的Flash内容有三种选择，通过JTAG、通过BSL和用户定制。用户定制即是通过单片机的程序访问自己的Flash。

Flash的寄存器列表如下：
Register Short Form Register Type Address Initial State
Flash memory control register 1 FCTL1 Read/write 0128h 09600h with PUC
Flash memory control register 2 FCTL2 Read/write 012Ah 09642h with PUC
Flash memory control register 3 FCTL3 Read/write 012Ch 09618h with PUC
Interrupt Enable 1 IE1 Read/write 000h Reset with PUC

Flash的硬件部分就介绍这么多了，有什么不大懂的地方请参考TI提供的用户指南。
程序实现：
首先设置Flash的时钟，初始化Flash控制器：
void FlashInit()
{
FCTL2 = FWKEY + FSSEL_2 + FN1; // 默认 SMCLK/3 =333KHz
}
这个函数仅仅设置了时钟。

擦除函数：
void FlashErase(unsigned int Addr)
{
char *FlashPtr;
FlashPtr = (char *)Addr;
FCTL1 = FWKEY + ERASE; // Set Erase bit
FCTL3 = FWKEY; // Clear Lock bit
DINT;
*FlashPtr = 0; // Dummy write to erase Flash segment B
WaitForEnable(); //Busy
EINT;
FCTL1 = FWKEY; // Lock
FCTL3 = FWKEY + LOCK; // Set Lock bit
}
这个和上面给出的流程一样，参数是要被擦除的段的首地址。WaitForEnable函数等等待BUSY标志变回零即操作完成。
void WaitForEnable()
{
while((FCTL3 & BUSY) == BUSY); //Busy
}
写入字节：
void FlashWriteChar(unsigned int addr,char Data)
{
char *FlashPtr = (char *)addr; // Segment A pointer
FCTL1 = FWKEY + WRT; // Set WRT bit for write operation
FCTL3 = FWKEY; // Clear Lock bit
DINT;
*FlashPtr = Data; // Save Data
WaitForEnable(); //Busy
EINT;
FCTL1 = FWKEY; // Clear WRT bit
FCTL3 = FWKEY + LOCK; // Set LOCK bit
}
写入字：
void FlashWriteWord(unsigned int addr,unsigned int Data)
{
unsigned int *FlashPtr = (unsigned int *)addr;
FCTL1 = FWKEY + WRT; // Set WRT bit for write operation
FCTL3 = FWKEY; // Clear Lock bit
DINT;
*FlashPtr = Data; // Save Data
WaitForEnable(); //Busy
EINT;
FCTL1 = FWKEY; // Clear WRT bit
FCTL3 = FWKEY + LOCK; // Set LOCK bit
}
写入字或字节两个函数差别仅仅是指针类型不同。

读取字或字节：
char FlashReadChar(unsigned int Addr)
{
char Data;
char *FlashPtr = (char *) Addr;
Data = *FlashPtr;
return(Data);
}

unsigned int FlashReadWord(unsigned int Addr)
{
unsigned int Data;
unsigned int *FlashPtr = (unsigned int *)Addr;
Data = *FlashPtr;
return(Data);
}
这两个函数的差别也是仅仅指针类型不同。

这些函数和前面硬件介绍部分的程序流程相同，这里不再详细说明。
使用示例：
使用方法和之前的一样，工程中加入C文件，源代码文件中文件包含H文件，即可使用，具体参考示例项目：

演示主要程序主要如下：
#include <msp430x16x.h>
#include "Flash.h"

int a;
void main( void )
{
// Stop watchdog timer to prevent time out reset
WDTCTL = WDTPW + WDTHOLD;
ClkInit();
FlashInit();
FlashWriteChar(InfoB,0x25);
a=FlashReadChar (InfoB); //InfoB在H文件中有宏定义
FlashWriteWord(InfoB+2,0x5669);
a = FlashReadWord(InfoB+2);
FlashErase(InfoB);
LPM0;
}
这里向InfoB(1000h)首地址开始写数据，先写一个字节再写入一个字（注意写入字时，必须是偶数地址，奇数地址会写在这个地址所在的前一个偶数地址），读出，然后擦除。这里的程序都是在Flash中运行的，没有演示RAM中运行的程序。如果在RAM运行程序，则需要先把程序从Flash中移到RAM中，然后跳转到RAM中运行。

调试截图如下：

调试时，view-Memory菜单，调出存储器窗口；观察Flash内容。

这里写入的是Info Flash部分，观察这部分的结果，和写入的结果同。

Flash程序控制器的程序就到这儿了。Flash可以用于存储长期保存的数据。有什么不足之处，欢迎讨论。

附件：程序库

作者：给我一杯酒
出处：http://Engin.cnblogs.com/
本文版权归作者和博客园共有，欢迎转载，转载保留此段文字并且注明出处；谢谢。

本文链接

MSP430程序库<十四>DMA程序库

2011-08-29T07:50:00Z

直接存储器存取(DMADirect Memory Access)方式是用硬件实现存储器与存储器之间或存储器与I\O设备之间直接进行高速数据传送，不需要CPU的干预。这种方式通常用来传送数据块。MSP430f16x系列单片机内部含有DMA模块，而且几乎内部所有外设都可以触发DMA开始存取数据。这里实现了这个模块的程序通用的函数库，方便使用。

硬件介绍：

MSP430F15X/16X 系列单片机具有DMA 控制器，从而能够为数据高速传输提供保证。例如，通过DMA控制器可以直接将ADC 转换存贮器的内容传到RAM 单元。

MSP430系列单片机扩展的DMA具有来之所有外设的触发器，不需要CPU的干预即可提供先进的可配置的数据传输能力，从而加速了基于MCU的信号处理进程，DMA传输的触发来源对CPU 来说是完全透明的，DMA控制器可在内存与外部及外部硬件之间进行精确的传输控制。DMA 消除了数据传输延迟时间以及各种开销，从而可以解放16为RISC CPU，以便其将更多的时间用于处理数据，而非执行正在处理的任务。

MSP430F16x系列单片机的DMA模块有以下特点：数据传送不需要CPU介入，完全由DMA控制器自行管理。在整个地址空间范围内传输数据，块方式传输可达65536字节；能够提高片内外设数据吞吐能力，实现高速传输，每个字或者字节的传输仅需要2个MCLK；减少系统功耗，即使在片内外设进行数据输入或输出时，CPU也可以处于超低功耗模式而不需唤醒；字节和字数据可以混合传送：DMA传输可以是字节到字节、字到字、字节到字或者字到字节。当字到字节传输时，只有字中较低字节能够传输，当从字节到字传输时，传输到字的低字节，高字节被自动清零；四种传输寻址模式：固定地址到固定地址、固定地址到块地址、块地址到固定地址以及块地址到块地址；触发方式灵活：边沿或者电平触发。单个、块或突发块传输模式：每次触发DMA操作，可以根据需要传输不同规模的数据

DMA的四种寻址模式如下图所示：

DMA控制器模块：3个独立的传输通道：通道0、通道1和通道2。每个通道都有源地址寄存器、目的地址寄存器、传送数据长度寄存器和控制寄存器。每个通道的触发请求可以分别允许和禁止；可配置的通道优先权：优先权裁决模块，传输通道的优先级可以调整，对同时有触发请求的通道进行优先级裁决，确定哪个通道的优先级最高。MSP430的DMA控制器可以采用固定优先级，还可以采用循环优先级。程序命令控制模块，每个DMA通道开始传输之前，CPU要编程给定相关的命令和模式控制，以决定DMA通道传输的类型；可配置的传送触发器：触发源选择模块，DMAREQ（软件触发）、Timer_ACCR2输出、Timer_BCCR2输出、I2C 数据接收准备好、I2C 数据发送准备好、USART接收发送数据、DAC12模块DAC12IFG、ADC12模块的ADC12IFGx、DMAxIFG、DMAE0 外部触发源。并且还具有触发源扩充能力。

DMA有六种传输模式：单字或者单字节传输；块传输；突发块传输；重复单字或者单字节传输；重复块传输；重复突发块传输。前三个，传输完成后DMAEN自动复位；再次传输时需要重新置位DMAEN位以使能DMA通道。后三个为重复模式，一次传输完成后，DMAEN不复位；再次出发时，可以再次启动数据传输。六种传输模式通过DMADTx寄存器设置：

DMADTx Transfer Mode Description
000 Single transfer Each transfer requires a trigger. DMAEN is
automatically cleared when DMAxSZ transfers have
been made.
001 Block transfer A complete block is transferred with one trigger.
DMAEN is automatically cleared at the end of the
block transfer.
010, 011 Burst-block transfer CPU activity is interleaved with a block transfer.
DMAEN is automatically cleared at the end of the
burst-block transfer.
100 Repeated single transfer Each transfer requires a trigger. DMAEN remains
enabled.
101 Repeated block transfer A complete block is transferred with one trigger.
DMAEN remains enabled.
110, 111 Repeated burst-block CPU activity is interleaved with a block transfer.
transfer DMAEN remains enabled.

单字或者单字节传输：DMA 通道被定义为单字或者单字节传输模式，每个字或者字节的传输都要触发信号触发。设置DMADTx=0 就定义了单字或者单字节传输模式，规定的传输完毕后DMAEN 位自动清除，如果需要再次传输，必须重新置位DMAEN。如果设置DMADTx＝4 为重复单字或者单字节传输模式，DMAEN 位一直保持置位，每次触发伴随一次传输。DMAxSZ 寄存器保存传输的单元个数，如果该寄存器为0，则没有传输。传输之前DMAxSZ 寄存器的值写入到一个临时的寄存器中，每次操作之后DMAxSZ 做减操作。当DMAxSZ减为零的时候，它所对应的临时寄存器将原来的值重新置入DMAxSZ，同时相应的DMAIFG标志置位。

块传输模式：在块传输模式，每次触发可以传输一个数据块。设置DMADTx=1 为块传输模式，每个数据块传输完毕，DMAEN 位自动清除，在触发传输下一个数据块之前，该位要被重新置位。在传输某个数据块期间，其他的传输请求将被忽略。设置DMADTx=5 为重复块传输模式，某个数据块传输完毕，DMAEN 位仍然保持置位，之后，新的触发可以引起又一次数据块传送。DMAxSZ 寄存器保存数据块所包含的单元个数。DMASRCINCR 和DMADSTINCR 反映在数据块传输过程中的目的地址和源地址的变化情况。在块传输或者重复块传输过程中，DMAxSA，DMAxDA，DMAxSZ 寄存器的值写入到对应的临时寄存器中，DMAxSA，DMAxDA寄存器所对应的临时值在块传输过程中增加或者减少，而DMAxSZ 在块传输过程中减计数，始终反映当前数据块还有多少单元没有传输完毕，当DMAxSZ 减为0，它所对应的临时寄存器将原来的值重新置入DMAxSZ，同时相应的DMAIFG被置位。在块传输过程中，CPU 暂停工作，不参与数据的传输。数据块需要2×MCLK×DMAxSZ 个时钟周期。当每个数据块传输完毕，CPU 按照暂停前的状态重新开始执行。

突发块传输模式：这个和块传输模式类似，只不过每传输4个字或字节，DMA释放内部总线，CPU运行2个MCLK周期；在传输过程中CPU有20%的执行时间，而块传输需要等DMA完全传送完之后，CPU方能运行。

DMA触发源：每个通道的触发源有DMAxTSELx位进行控制的，这些位必须在DMAEN位为0是进行设置，否则可能出现不可预料的DMA触发。

DMAxTSELx Operation
0000 DMAREQ bit (software trigger)
0001 TACCR2 CCIFG bit
0010 TBCCR2 CCIFG bit
0011 URXIFG0 (UART/SPI mode), USART0 data received (I2C mode)
0100 UTXIFG0 (UART/SPI mode), USART0 transmit ready (I2C mode)
0101 DAC12_0CTL DAC12IFG bit
0110 ADC12 ADC12IFGx bit
0111 TACCR0 CCIFG bit
1000 TBCCR0 CCIFG bit
1001 URXIFG1 bit
1010 UTXIFG1 bit
1011 Multiplier ready
1100 No action
1101 No action
1110 DMA0IFG bit triggers DMA channel 1
DMA1IFG bit triggers DMA channel 2
DMA2IFG bit triggers DMA channel 0
1111 External trigger DMAE0

另外，单片机的中断程序不影响DMA的传输，当DMA传输过程中，单片机不响应中外部NMI中断(必须DMA的控制位ENNMI位为1时响应NMI中断，否则不予处理)外的所有中断；必须等待DMA数据传送结束之后才运行系统的中断处理程序。

DMA的中断：数据传送过程中，DMAxSZ寄存器值减为0时，DMA置位DMAIFG，DMA的中断和DAC12模块共享中断向量，使用中断时需要软件判断具体是那个中断。中断响应后DMAIFG不会自动复位，使用时必须软件清零DMAIFG位。

DMA的寄存器如下：

Register Short Form Register Type Address Initial State
DMA control 0 DMACTL0 Read/write 0122h Reset with POR
DMA control 1 DMACTL1 Read/write 0124h Reset with POR
DMA channel 0 control DMA0CTL Read/write 01E0h Reset with POR
DMA channel 0 source address DMA0SA Read/write 01E2h Unchanged
DMA channel 0 destination address DMA0DA Read/write 01E4h Unchanged
DMA channel 0 transfer size DMA0SZ Read/write 01E6h Unchanged
DMA channel 1 control DMA1CTL Read/write 01E8h Reset with POR
DMA channel 1 source address DMA1SA Read/write 01EAh Unchanged
DMA channel 1 destination address DMA1DA Read/write 01ECh Unchanged
DMA channel 1 transfer size DMA1SZ Read/write 01EEh Unchanged
DMA channel 2 control DMA2CTL Read/write 01F0h Reset with POR
DMA channel 2 source address DMA2SA Read/write 01F2h Unchanged
DMA channel 2 destination address DMA2DA Read/write 01F4h Unchanged
DMA channel 2 transfer size DMA2SZ Read/write 01F6h Unchanged

有关每个寄存器的详细内容参考ti提供的用户指南。

程序实现：

DMA的使用主要是DMA寄存器的初始设置，设置完成后，DMA接到触发信号即可自动传输数据。

设置函数如下：

void

char

unsigned int

//DMA收到触发请求时，等待当前指令执行完成后

switch

//选择当前设置哪个DMA通道

case

unsigned int

break

//指针 = 0通道控制

case

unsigned int

break

//指针 = 1通道控制

case

unsigned int

break

//指针 = 2通道控制

switch

//设置DMA通道的传输模式

case

'S'

break

//单次传输

case

's'

break

//重复单次传输

case

'B'

break

//块传输

case

'b'

break

//重复块传输

case

'I'

break

//突发块传输交错

case

'i'

break

//重复突发块传输交错

//源字或字节

//源地址改变方式

//目的字或字节

//目的地址改变方式

//DMA使能

函数比较麻烦，函数内容按参数设置每个寄存器。DMACTL0 = trigger << (channel << 2); 这个是设置对应channel通道的的参考源，不大明白的可以看下DMACTL0的寄存器内容；switch (channel)语句则根据通道设置对应指针指向的寄存器；然后对应设置参数即可。

当设置成非重复模式时，需要重新置位DMAEN，本程序就函数DMAReEnable实现：

void

char

switch

//使能对应通道

case

break

//0通道

case

break

//1通道

case

break

//2通道

这个函数比较简单，只是根据传入参数设置对应通道的DMAEN位。

当设置为软件触发时，需要软件启动DMA程序如下：

void

char

switch

//使能对应通道

case

break

//0通道

case

break

//1通道

case

break

//2通道

这个和上个函数类似：仅仅设置一个控制位，函数很简单，不再解释啦。

程序实现就这么多了，有关详细内容可以下载附件里的程序库，程序的注释很详细。

使用示例：

使用这个程序时，步骤和原来的相同：工程中加入DMA.c文件，然后源文件中包含DMA.h头文件即可。

示例程序主要如下：

#include

<msp430x16x.h>

#include

"DMA.h"

unsigned int

void

// Stop watchdog timer to prevent time out reset

//块传输，5个字（16位） a->b

'B'

unsigned int

//如果需要再次传输而不改变设置，只需调用DMAReEnable再次启动传输即可
// 如果是重复块传输，则不需要重新使能DMAReEnable 直接启动即可
//这里仅仅演示了使用方法，实际应用中，应根据需要选择适当的触发源。
//

示例程序完成功能很简单，仅仅把一个数组的值赋给另外一个数组。数组地址即是数组名强制转换为所需类型(无符号16位)，传入函数初始化设置。这里为了简便，设置为软件启动。

运行效果如下：

单步运行完启动DMA传输后，结果即出来了；说明DMA传输数据的速度是很快的。

DMA可以用于对速度要求比较高的程序中。例如：DMA配合硬件乘法器和ADC12模块，可以很容易的实现比较高频率的数字滤波方案。

附件：程序库

作者：给我一杯酒
出处：http://Engin.cnblogs.com/
本文版权归作者和博客园共有，欢迎转载，转载保留此段文字并且注明出处；谢谢。

本文链接

MSP430程序库<十三>硬件乘法器使用

2011-08-28T11:54:00Z

硬件乘法器不占用CPU周期，有硬件实现，速度比软件实现的乘法速度快很多。msp430f14x、msp430f16x中都含有硬件乘法器模块，方便用户需要速度的时候使用。

硬件介绍：
在MSP430系列单片机中，硬件乘法器是外围模块，而不是CPU内核的一部分；所以它的活动与否与CPU的活动与否无关，它的寄存器和其他的外围寄存器一样通过CPU指令读写。

硬件乘法器模块支持一下功能：无符号乘法、有符号乘法、无符号乘加、有符号乘加；可以支持16*16 16*8 8*16 8*8bits的乘法。

硬件乘法器的模块框图如下：

硬件乘法器模块的四种操作类型(无符号乘法、有符号乘法、无符号乘加、有符号乘加)是由写入的第一个操作数的位置决定的。这个模块有两个操作数寄存器：OP1和OP2、三个结果寄存器RESLO, RESHI, 和SUMEXT。RESLO寄存器存储结果的低字(低16位)；RESHI寄存器存储结果的高字(高16位)；SUMEXT寄存器存储结果的有关信息。结果在3个时钟周期后即可完成；写入OP2后的下一条指令即可读取结果，有一种情况例外：用间接寻址方式访问结果。用间接寻址方式访问结果时，读取结果之前需要有一条NOP指令。

操作数OP1有四个地址(MPY:0130h MPYS:0132h MAC:0134h MACS:0136h)，这四个寄存器用来选择乘法的操作模式。写入第一个操作数寄存器决定用哪种操作：无符号用符号等，但是不启动相乘操作；写入第二个操作数寄存器启动相乘的操作。计算完成后结果存入寄存器RESLO,RESHI, 和SUMEXT。

操作数1的四个地址对应的操作：
OP1 Address Register Name Operation
0130h MPY Unsigned multiply（无符号乘法）
0132h MPYS Signed multiply（有符号乘法）
0134h MAC Unsigned multiply accumulate（无符号乘加）
0136h MACS Signed multiply accumulate（有符号乘加）

四种操作模式下高位结果寄存器的内容如下：
Mode RESHI Contents
MPY Upper 16-bits of the result
MPYS The MSB is the sign of the result. The remaining bits are the upper
15-bits of the result. Two’s complement notation is usedfor the result.
MAC Upper 16-bits of the result
MACS Upper 16-bits of the result. Two’s complement notation is used for the result.

四种操作模式SUMEXT 寄存器的内容：
Mode SUMEXT
MPY SUMEXT is always 0000h
MPYS SUMEXT contains the extended sign of the result
00000h Result was positive or zero
0FFFFh Result was negative
MAC SUMEXT contains the carry of the result
0000h No carry for result
0001h Result has a carry
MACS SUMEXT contains the extended sign of the result
00000h Result was positive or zero
0FFFFh Result was negative

连续乘法运算时，如果操作数1不需改变就可以运算，则可以不需要重新写入和以保存内容相同的数；但OP2必须重新写入以启动乘法运算。

MACS Underflow and Overflow（MACS时的上溢和下溢）：硬件乘法器不检测有符号乘加时运算结果的上溢出和下溢出。结果的正数范围：0到7FFF FFFFh；负数范围：0FFFF FFFFh到8000 0000h。下溢出是两个负数的和结果寄存器得到的是正数，上溢出是两个正数的和结果寄存器得到的是负数。SUMEXT寄存器存储有结果的符号，可以根据它判断是否溢出（0000h 负数和则上溢 0FFFFh 正数和则下溢）。使用时程序必须合适的检测、处理MACS的溢出情况。

程序示例(用户指南上给出的汇编示例)：

所有乘数模式的例子如下。所有的8x8模式使用的寄存器的绝对地址，因为汇编器将不允许B访问到字寄存器时使用标准定义的文件标签。
; 16x16 Unsigned Multiply
MOV #01234h,&MPY ; Load first operand
MOV #05678h,&OP2 ; Load second operand
; ... ; Process results
; 8x8 Unsigned Multiply. Absolute addressing.
MOV.B #012h,&0130h ; Load first operand
MOV.B #034h,&0138h ; Load 2nd operand
; ... ; Process results
; 16x16 Signed Multiply
MOV #01234h,&MPYS ; Load first operand
MOV #05678h,&OP2 ; Load 2nd operand
; ... ; Process results
; 8x8 Signed Multiply. Absolute addressing.
MOV.B #012h,&0132h ; Load first operand
SXT &MPYS ; Sign extend first operand
MOV.B #034h,&0138h ; Load 2nd operand
SXT &OP2 ; Sign extend 2nd operand
; (triggers 2nd multiplication)
; ... ; Process results
; 16x16 Unsigned Multiply Accumulate
MOV #01234h,&MAC ; Load first operand
MOV #05678h,&OP2 ; Load 2nd operand
; ... ; Process results
; 8x8 Unsigned Multiply Accumulate. Absolute addressing
MOV.B #012h,&0134h ; Load first operand
MOV.B #034h,&0138h ; Load 2nd operand
; ... ; Process results
; 16x16 Signed Multiply Accumulate
MOV #01234h,&MACS ; Load first operand
MOV #05678h,&OP2 ; Load 2nd operand
; ... ; Process results
; 8x8 Signed Multiply Accumulate. Absolute addressing
MOV.B #012h,&0136h ; Load first operand
SXT &MACS ; Sign extend first operand
MOV.B #034h,R5 ; Temp. location for 2nd operand
SXT R5 ; Sign extend 2nd operand
MOV R5,&OP2 ; Load 2nd operand
; ... ; Process results

上面的程序虽然和标准的汇编差异比较大，但是有一定汇编基础的人还是很容易就能够看懂。这里的程序给出了多种方式写入操作数寄存器。

间接寻址结果寄存器时，在写入OP2操作数启动乘法后，至少需要一个指令的延迟后才能访问结果寄存器RESLO等；直接寻址时可以写入OP2后，下一条指令即可读取结果。示例程序（汇编）：
; Access multiplier results with indirect addressing
MOV #RESLO,R5 ; RESLO address in R5 for indirect
MOV &OPER1,&MPY ; Load 1st operand
MOV &OPER2,&OP2 ; Load 2nd operand
NOP ; Need one cycle 写入两个操作数乘法运算开始后需要一个NOP
MOV @R5+,&xxx ; Move RESLO
MOV @R5,&xxx ; Move RESHI

如果在写入OP1和写入OP2之间产生了中断，中断响应后，源操作数的计算模式丢失；运算结果不确定。为了避免这种情况的发生，在写入操作数时禁止中断或在中断响应函数中不使用硬件乘法器。如：
; Disable interrupts before using the hardware multiplier
DINT ; Disable interrupts
NOP ; Required for DINT
MOV #xxh,&MPY ; Load 1st operand
MOV #xxh,&OP2 ; Load 2nd operand
EINT ; Interrupts may be enable before
; Process results

硬件部分就说这么多了，有什么不大明白的可以参考用户指南。
使用示例：
我的程序仅仅是用C语言演示硬件乘法器的使用。程序主要内容如下：
#include <msp430x16x.h>
/****************************************************************************
* 名称：main主程序
* 功能：硬件乘法器程序库使用演示
* 入口参数：无
* 出口参数：无
****************************************************************************/
void main( void )
{
// Stop watchdog timer to prevent time out reset
WDTCTL = WDTPW + WDTHOLD;
ClkInit();

/*把硬件乘法器的寄存器放到watch窗口观察是否变化
int a = 0;
a= 5*6;
*/
//测试无符号乘法
MPY = 65535;
OP2 = 2;
//有符号乘法
MPYS = 65535;
OP2 = 2;
//无符号乘加
MAC = 65535;
OP2 = 2;
//有符号乘加
MACS = 65535;
OP2 = 2;
LPM0;
}
程序演示了4中乘法模式：使用时单步调试，观察硬件乘法器的有关寄存器。如：

硬件乘法器运算速度很快，只需3个时钟周期；这里IAR单步调试时，OP2赋值结束，在watch窗口马上就可以看到运算结果。其他三种模式类似。

注释掉的这部分是我用来检测IAR编译程序是否使用硬件乘法器进行测试。默认情况下，乘法应该是用硬件乘法器运算的。默认的设置如下：

硬件乘法器是选中的，这时应该是使用硬件乘法器的，但是我的调试结果显示它没有使用硬件乘法器，截图下：

运行后乘法器相关位没有对应变化，如果使用的话，应该变化。

硬件乘法器不选中时，寄存器也没有相应变化，从这看，IAR没有使用硬件乘法器；也许程序没有优化太多或是debug版本不使用硬件乘法器。

如果需要直接使用硬件乘法器，有必要时把设置的硬件乘法器去掉，以防冲突。

下面是直接使用硬件乘法器的一个实例：
#include "msp430x16x.h"
unsigned int Result[7];
unsigned char Data1[7];
unsigned char Data2[7];
void main(void)
{
unsigned char i;
WDTCTL = WDTPW + WDTHOLD; // 关看门狗
for(i=0; i<7; i++)
{
Data1[i] = 10 * i; // 对两数组赋值
Data2[i] = 25 * i;
}
for(i=0; i<7; i++)
{
MPY = Data1[i];
OP2 = Data2[i];
_NOP(); // 延迟
_NOP();
_NOP();
Result[i] = RESLO; // 保存结果，由于是8×8型，所以未用到RESHI；
}
}
这个程序用无符号乘法运算，结果存入结果数组中。值的注意的是程序中的3个NOP，这里NOP不需要，根据头文件推测，IAR编译器应该使用的是直接寻址方式，可以不要。如果不太放心，一个NOP即可，即便用的是间接寻址，一个NOP的延迟已经足够。

硬件乘法器一般不会像上面的程序那么使用，如果这样就太浪费了；还不如直接用 *操作符来的简便；硬件乘法器主要用来对时间要求苛刻的情况。如：用430进行数字滤波，快速傅里叶变换等。ti有一篇应用笔记介绍的就是用msp430f169实现数字滤波方案。

硬件乘法器就到这里了，希望对大家有所帮助。有什么不足之处，欢迎拍砖讨论。

附件：程序库

作者：给我一杯酒
出处：http://Engin.cnblogs.com/
本文版权归作者和博客园共有，欢迎转载，转载保留此段文字并且注明出处；谢谢。

本文链接

MSP430程序库<十二>SVS(电源电压监控器)模块

2011-08-28T03:38:00Z

电源电压监控对于单片机来说，也是经常要用的模块。当需要稳定的工业级产品时，经常要对电源电压监控，以保证单片机系统工作于正常环境或范围中。MSP430F16x提供了一个现成的电源电压监控器模块SVS，方便检测电源电压或者是外部电压，可以设置为电压过低时复位或置标志位。本程序即完成SVS的设置使用的程序库(msp430f14x没有此模块)。

硬件介绍：
MSP430单片机含有的SVS模块可以很方便的监控电源电压或外部电压。
电源电压监控器（SVS）是用于监控AVCC电源电压或外部电压。 SVS的可配置当电源电压或外部电压下降到低于用户选择的电压级别时设置一个标志，或产生POR复位。
SVS模块有以下特点：可以监控AVCC电压；可选择产生复位信号；可软件设置SVS比较器输出信号；低电压标志可以被锁定或被用户程序访问；有14个可供选择的电压门限；可以监控外部输入电压。SVS模块可以很方便的监控电源电压或系统的其他电压，可以产生复位信号或是置标志位。
SVS模块仅有一个8位的寄存器，使用十分方便。寄存器SVSCTL：
高四位VLDx用来设置监控电源电压的门限、关闭SVS或者选择监控外部输入电压。具体含义如下：
0000 SVS is off 0001 1.9 V 检测AVCC是否低于1.9v,以下类似
0010 2.1 V 0011 2.2 V
0100 2.3 V 0101 2.4 V
0110 2.5 V 0111 2.65 V
1000 2.8 V 1001 2.9 V
1010 3.05 1011 3.2 V
1100 3.35 V 1101 3.5 V
1110 3.7 V
1111 检测由SVSIN引脚输入的电压是否低于1.2 V.

当高四位是 0时，SVS模块是关闭的；1-14分别是对电源电压监控的14个门限电压；15时，监控外部电压，门限电压是1.2v。
PORON位设置是否启动电压低于门限时，单片机复位：1 复位 0 置标志位SVSFG
SVSON位，这位和其他模块的ON位不太一样，SVSON位仅仅指示当前SVS模块是否打开，而不是用来开关模块的。
SVSOP位，这位是设置SVS内部比较器输出值：0 输出低电平 1 输出高电平。
SVSFG位，标志位指示是否检测到低电压仅PORON 为0时有效出现低电压后置1；改为不会自动清零，必须软件清零。
另外，SVS模块值得一提的是：SVS门限电压已经设置回差带：每个SVS的水平已经滞后AVCC，接近临界值时，以减少小型电源电压的变化的敏感性。 SVS的操作和SVS /掉电互操作如图：
如图：为防止电压在门限附近变动时，SVS过于敏感，每个门限附近都有回差带。这样SVS模块用起来更好用。
程序实现：
程序主要是对SVS模块寄存器SVSCTL的设置和检测。首先是设置SVS函数：
void SVSSetup(char voltageLevel,char reset)
{
SVSCTL = voltageLevel << 4;
/*if(voltageLevel == 0x15) //外部输入打开对应功能口
{
P6SEL |= BIT7; //不需要，当用SVSIN时，自动从此脚检测
}*/
if(reset <= 1)
{
SVSCTL |= reset << 3;
}
}
voltageLevel：这个参数和寄存器SVSCTL的高四位VLDx意思完全一样，程序仅仅是把它移动到高四位赋值给寄存器SVSCTL，reset参数对应PORON位，也是直接赋值给对应位完成设置。
检测是否有低于门限电压的情况出现：
char SvsFlg()
{
return (SVSCTL&SVSFG);
}
这个函数更简单，仅仅把标志位SVSFG的值返回，以便用户判断是否出现了低于门限的情况出现。
标志位清零：
/****************************************************************************
* 名称：ClearSvs
* 功能：电源电压监控器的过低标志
* 入口参数：sync：同步 1：阻塞运行直到该函数电压恢复正常 0:不阻塞,清除即返回
* 出口参数：无
* 说明: 若传入参数为0 不阻塞则如果电压没有恢复到正常范围则标志会立即被
单片机重新置位(1)
****************************************************************************/
void ClearSvs(char sync)
{
if(!sync)
{
SVSCTL &=~ SVSFG;
return;
}
while(SVSCTL&SVSFG)
SVSCTL &=~ SVSFG; //清除标志直到电压正常
}
由于SVSFG标志位不会在处理后自动被清除，所以必须软件清零。这个函数有两种工作方式，同步阻塞等待，直到电压恢复正常后才返回和清零后即返回。
程序实现比较简单，但能够完成SVS的功能。下面介绍如何使用本程序库。
使用示例：
使用程序库的方式还是和以前一样：工程中加入SVS.c文件，源文件中加入对SVS.h的文件包含。
main.c主要内容如下：
#include <msp430x16x.h> //430寄存器头文件
#include <stdio.h>
#include "Lcd12864.h"
#include "SVS.h"

/****************************************************************************
* 名称：main主程序
* 功能：设置串口，输出信息，从串口读计算机键盘输入数据，测试串口收发
* 入口参数：无
* 出口参数：无
* 说明：复位测试时每次电压调低再调正常液晶显示的数据加1
不复位时每次调低输出一个电压过低。
****************************************************************************/
void main()
{
// Stop watchdog timer to prevent time out reset
WDTCTL = WDTPW + WDTHOLD;
ClkInit();
LcdInit();

/*//======== 电压过低时复位测试============
__no_init char ff; //复位不初始化

SVSSetup(0x0A,1); //检测电源电压 3.05v 低于3.05v时单片机复位
ff++; //此变量每次复位加1
printf("%d",ff); // 电压调低（<3.05v）再调高，显示变量将加1
*/
SVSSetup(0x0A,0); //测电源电压 3.05v 低于3.05v时单片机不复位
//0x0A 改为0x0f 则对P6.7电压监控检测是否低于1.2v
while(1)
{
if(SvsFlg())
printf("电压过低");
//SVSFG位必须软件清零，如果电压没有回到3.05以上，
//位的值立即被单片机置为1
ClearSvs(1); //清除标志直到恢复正常电压
}
}
本程序使用12864液晶来显示电压过低的情况：复位时，设置一个__no_init变量，每次复位加1，可以看到电压调低后，显示数字被加1.不复位置，显示电压过低。这里使用的是12864的底层驱动和printf函数移植，比之前做了稍微更改，这些在注释中说明的已经很详细了，这里不在细说。有关液晶和printf参考：MSP430程序库<三>12864液晶程序库和MSP430程序库<四>printf和scanf函数移植。

SVS模块就到这里了，有什么不足，欢迎拍砖。

附件：程序库

作者：给我一杯酒
出处：http://Engin.cnblogs.com/
本文版权归作者和博客园共有，欢迎转载，转载保留此段文字并且注明出处；谢谢。

本文链接

MSP430程序库<十一>定时器TA的PWM输出

2011-08-27T09:37:00Z

定时器是单片机常用的其本设备，用来产生精确计时或是其他功能；msp430的定时器不仅可以完成精确定时，还能产生PWM波形输出，和捕获时刻值(上升沿或是下降沿到来的时候)。这里完成一个比较通用的PWM波形产生程序。

硬件介绍：
MSP430系列单片机的TimerA结构复杂，功能强大，适合应用于工业控制，如数字化电机控制，电表和手持式仪表的理想配置。它给开发人员提供了较多灵活的选择余地。当PWM 不需要修改占空比和时间时，TimerA 能自动输出PWM，而不需利用中断维持PWM输出。

MSP430F16x和MSP430F14x单片机内部均含有两个定时器，TA和TB；TA有三个模块，CCR0-CCR2；TB含有CCR0-CCR67个模块；其中CCR0模块不能完整的输出PWM波形(只有三种输出模式可用);TA可以输出完整的2路PWM波形；TB可以输出6路完整的PWM波形。

定时器的PWM输出有有8种模式：

输出模式0 输出模式：输出信号OUTx由每个捕获/比较模块的控制寄存器CCTLx中的OUTx位定义，并在写入该寄存器后立即更新。最终位OUTx直通。
输出模式1 置位模式：输出信号在TAR等于CCRx时置位，并保持置位到定时器复位或选择另一种输出模式为止。
输出模式2 PWM翻转/复位模式：输出在TAR的值等于CCRx时翻转，当TAR的值等于CCR0时复位。
输出模式3 PWM置位/复位模式：输出在TAR的值等于CCRx时置位，当TAR的值等于CCR0时复位。
输出模式4 翻转模式：输出电平在TAR的值等于CCRx时翻转，输出周期是定时器周期的2倍。
输出模式5复位模式：输出在TAR的值等于CCRx时复位，并保持低电平直到选择另一种输出模式。
输出模式6PWM翻转/置位模式：输出电平在TAR的值等于CCRx时翻转，当TAR值等于CCR0时置位。
输出模式7PWM复位/置位模式：输出电平在TAR的值等于CCRx时复位，当TAR的值等于CCR0时置位。

下图是增计数模式下的输出波形(本程序使用的是增模式3和7)：

计数模式：

增计数模式
捕获/比较寄存器CCR0用作Timer_A增计数模式的周期寄存器，因为CCR0为16位寄存器，所以该模式适用于定时周期小于65 536的连续计数情况。计数器TAR可以增计数到CCR0的值，当计数值与CCR0的值相等(或定时器值大于CCR0的值)时，定时器复位并从0开始重新计数。

连续计数模式
在需要65 536个时钟周期的定时应用场合常用连续计数模式。定时器从当前值计数到0FFFFH后，又从0开始重新计数

增/减计数模式
需要对称波形的情况经常可以使用增/减计数模式，该模式下，定时器先增计数到CCR0的值，然后反向减计数到0。计数周期仍由CCR0定义，它是CCR0计数器数值的2倍。

TA定时器有比较、捕获两种工作方式；比较可以产生PWM波形等，捕获可以精确的测量时间；这里用的是比较输出。

硬件介绍就这么多了，其他的可以参考msp430x1xx_family_users_guide(用户指南)。
程序实现：
本程序是直接从msp430f42x移植的，只改动了端口就能正常使用了。由此，430的模块在不同的系列中是通用的，有关寄存器是一样的；只是也许外部端口不太一样。

程序初始化部分：完成TA相关寄存器的初始化。
char TAPwmInit(char Clk,char Div,char Mode1,char Mode2)
{
TACTL = 0; //清除以前设置
TACTL |= MC_1; //定时器TA设为增计数模式
switch(Clk) //选择时钟源
{
case 'A': case 'a': TACTL|=TASSEL_1; break; //ACLK
case 'S': case 's': TACTL|=TASSEL_2; break; //SMCLK
case 'E': TACTL|=TASSEL_0; break; //外部输入(TACLK)
case 'e': TACTL|=TASSEL_3; break; //外部输入(TACLK取反)
default : return(0); //参数有误
}
switch(Div) //选择分频系数
{
case 1: TACTL|=ID_0; break; //1
case 2: TACTL|=ID_1; break; //2
case 4: TACTL|=ID_2; break; //4
case 8: TACTL|=ID_3; break; //8
default : return(0); //参数有误
}
switch(Mode1) //设置PWM通道1的输出模式。
{
case 'P':case 'p': //如果设置为高电平模式
TACCTL1 = OUTMOD_7; //高电平PWM输出
P1SEL |= BIT2; //从P1.2输出 (不同型号单片机可能不一样)
P1DIR |= BIT2; //从P1.2输出 (不同型号单片机可能不一样)
break;
case 'N':case 'n': //如果设置为低电平模式
TACCTL1 = OUTMOD_3; //低电平PWM输出
P1SEL |= BIT2; //从P1.2输出 (不同型号单片机可能不一样)
P1DIR |= BIT2; //从P1.2输出 (不同型号单片机可能不一样)
break;
case '0':case 0: //如果设置为禁用
P1SEL &= ~BIT2; //P1.2恢复为普通IO口
break;
default : return(0); //参数有误
}
switch(Mode2) //设置PWM通道1的输出模式。
{
case 'P':case 'p': //如果设置为高电平模式
TACCTL2 =OUTMOD_7; //高电平PWM输出
P1SEL |= BIT3; //从P1.3输出 (不同型号单片机可能不一样)
P1DIR |= BIT3; //从P1.3输出 (不同型号单片机可能不一样)
break;
case 'N':case 'n': //如果设置为低电平模式
TACCTL2 =OUTMOD_3; //低电平PWM输出
P1SEL |= BIT3; //从P1.3输出 (不同型号单片机可能不一样)
P1DIR |= BIT3; //从P1.3输出 (不同型号单片机可能不一样)
break;
case '0':case 0: //如果设置为禁用
P1SEL &= ~BIT3; //P1.3恢复为普通IO口
break;
default : return(0); //参数有误
}
return(1);
}

主要是设置TACTL寄存器，让TA工作于增模式，设置时钟源和分频；CCTLx设置对应的输出模式；并且打开相应端口的第二功能。

设置周期函数：设置PWM波形的周期，单位是多少个TACLK周期。
void TAPwmSetPeriod(unsigned int Period)
{
TACCR0 = Period;
}
工作于增模式时，TA计数到TACCR0,设CCR0就完成了周期的设置。

设置占空比：设置TA的PWM输出的有效电平的时间。
void TAPwmSetDuty(char Channel,unsigned int Duty)
{
switch(Channel)
{
case 1: TACCR1=Duty; break;
case 2: TACCR2=Duty; break;
}
}
根据参数分别设置每一路的参数。

设置占空比，用千分比设置：
* 入口参数：Channel: 当前设置的通道号 1/2
Percent: PWM有效时间的千分比 (0~1000)
* 出口参数：无
* 说明: 1000=100.0% 500=50.0% ，依次类推
* 范例: TAPwmSetPermill(1,300)设置PWM通道1方波的占空比为30.0%
TAPwmSetPermill(2,825)设置PWM通道2方波的占空比为82.5%
*/
void TAPwmSetPermill(char Channel,unsigned int Percent)
{
unsigned long int Period;
unsigned int Duty;
Period = TACCR0;
Duty = Period * Percent / 1000;
TAPwmSetDuty(Channel,Duty);
}
这个函数用千分比来设置PWM输出的有效时间。方便程序的使用。

有关定时器，TI提供的大量的例程，这些历程都很简洁、清晰。需要其他功能可以自己根据例程编写对应的程序。程序实现就这么多了，下面说下本程序的使用方法。
使用示例：
使用方式：依然是在工程中加入c文件；文件包含h头文件；然后就可以正常使用本函数了。详细参考示例工程和main.c。

main主要程序如下：
#include "msp430x16x.h" //430寄存器头文件
#include "TAPwm.h" //TA PWM输出程序库头文件

void main()
{
// Stop watchdog timer to prevent time out reset
WDTCTL = WDTPW + WDTHOLD;
ClkInit();

TAPwmInit('A',1,'P','P'); //将定时器TA初始化成为PWM发生器
//时钟源=ACLK ; 无分频; 通道1和通道2均设为高电平模式。
TAPwmSetPeriod(500); //通道1/2的PWM方波周期均设为500个时钟周期
TAPwmSetDuty(1,200); //1通道有效200个时钟周期
TAPwmSetPermill(2,200); //2通道 20.0%

LPM0;
}
本程序调用程序库，产生两路PWM波形。

TA的PWM输出就到这儿了，如果需要更多路的PWM波，可以使用TB，他可以产生6路完整的PWM波形；可以参考本程序编写TB的波形输出程序。有什么不足之处，欢迎评论，讨论。

附件：程序库

作者：给我一杯酒
出处：http://Engin.cnblogs.com/
本文版权归作者和博客园共有，欢迎转载，转载保留此段文字并且注明出处；谢谢。

本文链接

MSP430程序库<十>ADC12模块

2011-08-26T07:38:00Z

msp430内部含有ADC12模块，可以完成12位的模数转换，当对精度或其他指标要求不高时，可以选用430单片机内部的ADC12完成模数转换工作。这里主要实现了一个比较通用的ADC12模块初始化程序，具体的数据存储和处理需要自己在中断处理函数中添加。

硬件介绍：
msp430单片机内的ADC12模块的特点如下：12位转换精度，1位非线形误差，1位非线形积分误差；多种时钟源给ADC12模块，切本身自带时钟发生器；内置温度传感器；TimerA/TimerB硬件触发器；8路外部通道和4路内部通道；内置参考电压源和6种参考电压组合；4种模式的模数转换；16bit的转换缓存；ADC12关闭支持超低功耗；采用速度快，最高200Kbps；自动扫描和DMA使能。430内部的ADC12功能还是蛮强大的，可以有定时器触发模数转换开始，还可以和内部的DMA模块共同使用，完成高速的采样转储等高级功能。

这个AD的转化公式如下，可以根据它计算采样的模拟电压值：

使用AD是还要注意采样时间，430单片机的模数ADC12模块的等效模拟电压输入电路如下：

其中V_S是信号源电压，R_S是信号源内阻，V_I在Ax(ADC12模块模拟输入端)上的电压，R_I单片机内多路开关等效电阻，V_C是保持电容上的电压(ADC12模块采样的电压)，C_I是电容的值。需要根据这些值计算采样时间：

代入单片机上的参数后公式如下：

我的程序中采样时间设的是4us，可以算出如果用我的程序(不更改采样时间)的话，最大信号源内阻可以是6.8k，当信号源内阻更大时，可以自己按要求设采样时间(在程序的初始化函数内的寄存器设置部分)。

还有，ADC模数转换时要求参考电压等很稳定，为了达到这个要求，德州仪器要求这部分的电路如下：

即：所有参考源和电源均并联一组 0.1uF和10uF的电容。

硬件部分就说这么多了；如果需要更详细的说明，参考用户指南。
程序实现：
程序主要实现的是一个比较通用的初始化程序，内容如下：
char ADC12Init(char n,char channels[],char rep)
{
if(n>15)
return 0;
//SHT0_0
ADC12CTL0 = ADC12ON + MSC + SHT0_0 + REFON + REF2_5V;// 开启ad,参考电压2.5v
ADC12CTL1 = SHP + ADC12SSEL_3; //Use sampling timer, SMCLK

for(int i = 0;i < n;i++)
{
if(channels[i] >= 0x80)
return 0;
*(char*)(ADC12MCTL0_ + i) = channels[i]; //每个MCTL设置
}
*(char*)(ADC12MCTL0_ + n - 1) |= EOS; //序列结束

if(rep != 0) //多次转换
{
ADC12CTL1 |= CONSEQ_3;
}
else
{
ADC12CTL1 |= CONSEQ_1;
}

ADC12IE = 1<<(n-1); // Enable ADC12IFG.n-1
return 1;
}
程序先判断n 通道总数是否超过了可用的个数，超过则返回零然后设置ADC12CTL0和ADC12CTL1中不需要特殊设置的部分，然后在设置通道模式(根据rep参数的值)；for循环设置的是每个存储寄存器的设置ADC12MCTLx ；*(char*)(ADC12MCTL0_ + n - 1) |= EOS; //序列结束这句加入序列结束标志；最后设置中断寄存器并返回成功设置标志。其中比较特殊的是ADC12MCTL0_，这个是430提供的头文件中定义的ADC12MCTL0的地址值，以其为指针首址操作ADCMCTLx寄存器，从而利用循环设置寄存器的内容，大量减少了代码行数。

参数channels[]是每个存储寄存器的设置(除EOS位之外的)，含义如下：
channels[]:对应通道设置，高四位，参考源选择；
低四位，通道选择。具体如下：
SREFx Bits
6-4
Select reference
000 VR+ = AVCC and VR. = AVSS
001 VR+ = VREF+ and VR. = AVSS
010 VR+ = VeREF+ and VR. = AVSS
011 VR+ = VeREF+ and VR. = AVSS
100 VR+ = AVCC and VR. = VREF./ VeREF.
101 VR+ = VREF+ and VR. = VREF./ VeREF.
110 VR+ = VeREF+ and VR. = VREF./ VeREF.
111 VR+ = VeREF+ and VR. = VREF./ VeREF.
INCHx Bits
3-0
Input channel select
0000 A0
0001 A1
0010 A2
0011 A3
0100 A4
0101 A5
0110 A6
0111 A7
1000 VeREF+
1001 VREF./VeREF.
1010 Temperature sensor
1011 (AVCC – AVSS) / 2
1100 (AVCC – AVSS) / 2
1101 (AVCC – AVSS) / 2
1110 (AVCC – AVSS) / 2
1111 (AVCC – AVSS) / 2

这是从用户指南里复制来的，每一位和ADC12MCTLx的意义相同(去掉EOS位)，所以可用宏定义来制定这个参数，如：
char channels[3];
channels[0] = SREF_1+INCH_0;
channels[1] = SREF_1+INCH_1;
channels[2] = SREF_1+INCH_2;
ADC12Init(3,channels,1);
这是3个通道A0-A2采样，多次采样。

启动转换函数：
void ADC12Start()
{
ADC12CTL0 |= ENC;
ADC12CTL0 |= ADC12SC;
}

ADC初始化完成后，调用此函数开始AD转换，转换完成后(一个序列通道，如：刚才的0-2)，程序自动进入AD中断，用户需要在这里为自己的函数添加处理逻辑；这里只存储了转化的结果：
#pragma vector=ADC_VECTOR
__interrupt void ADC12ISR (void)
{
static int i;
results[0][i] = ADC12MEM0; // Move results, IFG is cleared
results[1][i] = ADC12MEM1; // Move results, IFG is cleared
results[2][i] = ADC12MEM2; // Move results, IFG is cleared
i++;
if(i>31) //多次转换时转换次数
{
//多次重复采样时，在这里方处理函数
ADC12CTL0 &=~ ENC; //停止转换
i=0;
}

}
该程序实现的是多次A0-A2 32次转换，把结果存入results数组。单次时，仅仅采样一次(A0-A2)可用自己更改处理函数。

程序部分就完成了，调用时注意要自己实现处理逻辑或存储逻辑。
使用示例：

本程序使用方式还是加入C文件，包含H文件；不过和之前的程序不同的是要自己实现中断处理逻辑。

使用示例参见程序库中的ADC12.

#include <msp430x16x.h>
#include "ADC12.h"
void main( void )
{
// Stop watchdog timer to prevent time out reset
WDTCTL = WDTPW + WDTHOLD;
ClkInit();
char channels[3];
channels[0] = SREF_1+INCH_0;
channels[1] = SREF_1+INCH_1;
channels[2] = SREF_1+INCH_2;
ADC12Init(3,channels,1);
_EINT();
ADC12Start();
LPM0;
}

这里实现的是3通道多次转换，参考电压都是内部参考电压。自己实现的处理逻辑参见前面的程序实现的最后一部分。

ADC12模块部分就到这里了，有什么不足之处，欢迎提出建议、讨论。

附件：程序库

作者：给我一杯酒
出处：http://Engin.cnblogs.com/
本文版权归作者和博客园共有，欢迎转载，转载保留此段文字并且注明出处；谢谢。

本文链接

MSP430程序库<九>数码管显示

2011-08-23T10:48:00Z

数码管也是单片机系统最常用的输出设备之一(还有液晶、发光二极管等)。七段(这里用的是8段，有小数点)数码管可以完成显示0-9数字和一部分的英文字符如：A、b。本文实现的程序完成显示数字和可显示的英文字符；同时完成数码管显示的printf函数的移植，以支持printf的格式化字符等好用的特点（我用的数码管8个排为一排，方便数字等的显示）。

硬件介绍：
这里所用到的硬件资源包括8个数码管、和msp430单片机的两个8位IO口(这里用的是P3和P5口，如有改变，可以通过宏定义更改)。
数码管是8个共阴的数码管，a-h 8段通过一个200Ω的电阻接到430单片机的P5口。共阴端是由单片机的P3口控制，单片机的一位IO通过一个三极管接到数码管的共阴端，以完成位选。
单片机的P3口时数码管的位选口，某位为高则选中；P5口时段选口；要数码管显示时，通过P3位选，选中某个数码管亮，P5段选选择8段（a-h）中的那些亮，从而控制某一位显示数字或字符。
要同时显示多个数码管，就要动态扫描；动态扫描时，本程序选用的是由看门狗的中断扫描显示：每1.9ms显示其中的一位，动态扫描显示每一位，从而让数码管看起来是同时亮的。
程序实现：
数码管显示首先要有一个数码管显示的断码表（完成数字和字符到数码管段值的表），程序中采用了《MSP430系列单片机系统工程设计与实践》这本书推荐的方式实现的这个数码表：先用宏定义定义每段对应的单片机要输出的段值，然后再实现是个表，当硬件改变时，只需更改前面的每段的段值定义即可，改动的地方少了很多，代码如下：
/*宏定义，数码管a-h各段对应的比特，更换硬件只用改动以下8行*/
#define a 0x01 // AAAA
#define b 0x02 // F B
#define c 0x04 // F B
#define d 0x08 // GGGG
#define e 0x10 // E C
#define f 0x20 // E C
#define g 0x40 // DDDD HH
#define h 0x80 //小数点

/*用宏定义自动生成段码表，很好的写法，值得学习*/
/*更换硬件无需重写段码表*/
const char Tab[] = {
a + b + c + d + e + f, // Displays "0"
b + c, // Displays "1"
a + b + d + e + g, // Displays "2"
a + b + c + d + g, // Displays "3"
b + c + f + g, // Displays "4"
a + c + d + f +g, // Displays "5"
a + c + d + e + f + g, // Displays "6"
a + b + c, // Displays "7"
a + b + c + d + e + f + g, // Displays "8"
a + b + c + d + f + g, // Displays "9"
a + b + c + e + f + g, // Displays "A"
c + d + e + f + g, // Displays "B"
a + d + e + f, // Displays "C"
b + c + d + e + g, // Displays "D"
a + d + e + f + g, // Displays "E"
a + e + f + g, // Displays "F"
a + c + d + e + f, // Displays "G"
b + c + e + f + g, // Displays "H"
e + f, // Displays "I"
b + c + d + e, // Displays "J"
b + d + e + f + g, // Displays "K"
d + e + f, // Displays "L"
a + c + e + g, // Displays "M"
a + b + c + e + f, // Displays "N"
c + e + g, // Displays "n"
c + d + e + g, // Displays "o"
a + b + c + d + e + f, // Displays "O"
a + b + e + f + g, // Displays "P"
a + b + c + f + g, // Displays "Q"
e + g, // Displays "r"
a + c + d + f +g, // Displays "S"
d + e + f + g, // Displays "t"
a + e + f , // Displays "T"
b + c + d + e + f, // Displays "U"
c + d + e, // Displays "v"
b + d + f + g, // Displays "W"
b + c + d + f + g, // Displays "Y"
a + b + d + e + g, // Displays "Z"
g, // Displays "-"
h, // Displays "."
0 // Displays " "
};
#undef a
#undef b
#undef c
#undef d
#undef e
#undef f
#undef g
0-9的位置对应显示0-9，之后的是A开始往后显示，为了方便访问这个表格，定义了AA等一系列的常量，方便访问这个表。
#define AA 10
#define BB AA+1
#define CC BB+1
#define DD CC+1
#define EE DD+1
#define FF EE+1
#define GG FF+1
#define HH GG+1
#define II HH+1
#define JJ II+1
#define KK JJ+1
#define LL KK+1
#define mm LL+1
#define NN mm+1
#define nn NN+1
#define oo nn+1
#define OO oo+1
#define PP OO+1
#define QQ PP+1
#define rr QQ+1
#define SS rr+1
#define tt SS+1
#define TT tt+1
#define UU TT+1
#define VV UU+1
#define WW VV+1
#define YY WW+1
#define ZZ YY+1
#define NEG ZZ+1 /* - */ //负号
#define DOT NEG+1 /* . */ //小数点
#define SP DOT+1 /* 空白 */ //空格

A从10开始访问这个表格，如果要显示A只需这样用Tab[AA]，即可得到需要的段值，AA-空格的宏定义放在H文件里，方便其他文件访问（当要调用显示函数的时候需要AA等宏定义）。为什么是AA而不是A呢？主要原因是单字母的有几个已经在单片机430的头文件里定义了，为了访问的时候一致，就都用两个字母的了。
为了动态扫描，这里定义了一个全局数组(数码管的程序可以访问)Nixie[8]在这个里面的8个char对应8个数码管要显示的段值。初始值是8个数码管都不显示：
char Nixie[8] = "\0\0\0\0\0\0\0\0"; //初始状态不显示

动态扫描时，函数每1.9ms(设的看门狗定时中断)调用一次显示函数，每次显示一位(为了让中断占用更少的时间，这样中断里只需赋值即可)。函数如下：
void Display()
{
static char i = 0; //记录扫描显示到哪位
CTRL_OUT = 1<<i;
DATA_OUT = Nixie[i];
i++;
if(i>7)
i = 0;
}
这个函数供中断调用，i用来保存要显示哪一位。CTRL_OUT 、DATA_OUT 是宏定义的位选和段选口。中断程序如下：
#pragma vector=WDT_VECTOR
__interrupt void WDT_ISR()
{
Display();
}
中断只调用了一个函数，这样很方便换其他中断来定时。
中断是必须初始设置的，还有IO口，要设为输出方向，初始化函数完成数码管用到的单片机资源的初始工作：
void NixiettubeInit()
{
WDTCTL = WDT_ADLY_1_9; //看门狗内部定时器模式16ms
IE1 |= WDTIE; //允许看门狗中断
CTRL_DIR_OUT;
DATA_DIR_OUT;
}
首先，设置中断并允许中断；然后设置位选和段选所用的端口为输出方向。CTRL_DIR_OUT; DATA_DIR_OUT; 和刚才用到的两个OUT的宏定义如下：
#define DATA_DIR_OUT P5DIR|=0XFF
#define CTRL_DIR_OUT P3DIR|=0XFF
#define DATA_OUT P5OUT
#define CTRL_OUT P3OUT
这样处理之后，要显示数字就很简单了:只需把要显示的数字或字符的段码值放入Nixie[8]数组对应的位置即可，如显示韩输入下：
void NixiettubeDisplayChar(char ch,char addr)
{
if(ch == DOT) //小数点,不需单独占一位
{
Nixie[addr] |= Tab[ch];
}
else
{
Nixie[addr] = Tab[ch];
}
}
如果是小数点，放入对应位置的h段即可，其他直接覆盖。
插入字符函数：在最右端插入数字或字符.
void NixiettubeInsertChar(char ch)
{
if(ch == DOT) ////小数点,不需单独占一位
{
Nixie[0] |= Tab[ch];
return;
}
for(int i = 7;i > 0;i--)
Nixie[i] = Nixie[i - 1]; //已显示字符左移一位
Nixie[0] = Tab[ch];
}
这个也是先判断小数点，小数点直接放到h段，其他的，则要已显示的左移再覆盖最右一位，源程序的注释很详细，可具体才、可以下载附件的程序库。
数码管清除函数，这个函数把数码管全部显示去掉，即把缓存数组内每项都置为0：
void NixiettubeClear()
{
for(int i = 0;i < 8;i++)
Nixie[i] = Tab[SP]; //显示空格
}
程序比较简单，这里就不多解释了。
数码管的程序就这么多了，所有函数都列出来了。下面开始介绍printf的移植，具体过程不再详细说了，详细过程参考：MSP430程序库<四>printf和scanf函数移植。这里主要介绍所需程序。
单片机printf使用需要用户提供底层驱动-putchar函数，printf完成格式化等一系列活动后调用putchar输出字符流。只要实现putchar，包含stdio.h文件，就可以使用printf函数。移植的数码管的putchar函数如下：
#include <stdio.h>
#include "ctype.h" /*isdigit函数需要该头文件*/
#include "Nixietube.h"

int putchar(int ch)
{
//'\f'表示走纸翻页，相当于清除显示
if(ch=='\n'||ch=='\r')
NixiettubeClear();

//数字和对应ASCII字母之间差0x30 '1'=0x31 '2'=0x32...
//isdigit也是C语言标准函数
if(isdigit(ch))
NixiettubeInsertChar(ch-0x30); //若字符是数字则显示数字
else //否则，不是数字，是字母
{
switch(ch) //根据字母选择程序分支
{
case 'A': case 'a': NixiettubeInsertChar(AA);break; //字符A
case 'B': case 'b': NixiettubeInsertChar(BB);break; //字符B
case 'C': case 'c': NixiettubeInsertChar(CC);break; //...
case 'D': case 'd': NixiettubeInsertChar(DD);break;
case 'E': case 'e': NixiettubeInsertChar(EE);break;
case 'F': case 'f': NixiettubeInsertChar(FF);break;
case 'G': case 'g': NixiettubeInsertChar(GG);break;
case 'H': case 'h': NixiettubeInsertChar(HH);break;
case 'I': case 'i': NixiettubeInsertChar(II);break;
case 'J': case 'j': NixiettubeInsertChar(JJ);break;
case 'K': case 'k': NixiettubeInsertChar(KK);break;
case 'L': case 'l': NixiettubeInsertChar(LL);break;
case 'M': case 'm': NixiettubeInsertChar(mm);break;
case 'N': NixiettubeInsertChar(NN);break;
case 'n': NixiettubeInsertChar(nn);break;
case 'O': NixiettubeInsertChar(OO);break;
case 'o': NixiettubeInsertChar(oo);break;
case 'P': case 'p': NixiettubeInsertChar(PP);break;
case 'Q': case 'q': NixiettubeInsertChar(QQ);break;
case 'R': case 'r': NixiettubeInsertChar(rr);break;
case 'S': case 's': NixiettubeInsertChar(SS);break;
case 'T': case 't': NixiettubeInsertChar(tt);break;
case 'U': case 'v': NixiettubeInsertChar(UU);break;
case 'V': case 'u': NixiettubeInsertChar(VV);break;
case 'W': case 'w': NixiettubeInsertChar(WW);break;
case 'Y': case 'y': NixiettubeInsertChar(YY);break; //...
case 'Z': case 'z': NixiettubeInsertChar(ZZ);break; //字符Z
case '-': NixiettubeInsertChar(NEG);break;//字符-
case '.': NixiettubeInsertChar(DOT);break;//小数点，直接显示在右下角
case ' ': NixiettubeInsertChar(SP);break; //空格
default : NixiettubeInsertChar(SP);break;//显示不出来的字母用空格替代
}
}
return(ch); //返回显示的字符(putchar函数标准格式要求返回显示字符)
}
头文件必须包含stdio.h，这样告诉编译器printf调用时，用这里的putchar函数。然后判断字符，分类进行显示，不能显示的空一格。
数码管的程序就完成了，如果需要可以自己添加改写函数，如：当和键盘共同使用时，如果键盘移植了scanf函数，并且支持退格；可以改写函数-让数码管的putchar支持退格操作。或者用的是我的键盘程序，需要10多ms调用一次键盘处理函数，这样可以和这个数码管扫描公用一个中断：
void Display()
{
static char i = 0; //记录扫描显示到哪位
CTRL_OUT = 1<<i;
DATA_OUT = Nixie[i];
i++;
if(i>7)
{
i = 0;
KeyProcess();
}
}
这样改写，然后把键盘的中断去掉(别忘了key.h包含和加入KeyProcess(); 的声明；如果程序中有两个指向同一个中断时，会编译错误)；这样就可以键盘、和数码管共同使用了。
使用示例：

使用方法还是和之前一样，工程中加入Nixietube.c文件，然后在要调用的地方加入Nixietube.h的包含；如puchr函数，和示例工程的main.c

main.c调用的方式如下：

#include <msp430x16x.h>
#include <stdio.h>
#include "Nixietube.h"

void ClkInit()
{
char i;
BCSCTL1 &= ~XT2OFF; //打开XT2振荡器
IFG1&=~OFIFG; //清除振荡错误标志
while((IFG1&OFIFG)!=0)
{
for(i=0;i<0xff;i++);
IFG1&=~OFIFG; //清除振荡错误标志
}
BCSCTL2 |= SELM_2+SELS+DIVS_3; //MCLK为8MHz，SMCLK为1MHz
}

void main( void )
{
// Stop watchdog timer to prevent time out reset
WDTCTL = WDTPW + WDTHOLD;
ClkInit();
NixiettubeInit();
_EINT();
//while(1)
{
NixiettubeDisplayChar(AA,5);
NixiettubeDisplayChar(DOT,5);
NixiettubeInsertChar(2);
NixiettubeInsertChar(DOT);
NixiettubeInsertChar(2);
printf("%1.2f",1.2);
}
}

包含msp430的头文件，以便使用430单片机的先关资源；加入stdio.h以使用printf函数；加入Nixietube.h使用数码管的相关程序。

还要注意，为了数码管正常显示，必须打开总中断，以使数码管动态扫描显示。另外，本程序单步调试看不到数码管正常显示，因为没有扫描。只有全速运行才可以看到数码管的显示情况。

数码管的程序就到这里，不足之处，欢迎讨论提出建议。

附件：程序库

作者：给我一杯酒
出处：http://Engin.cnblogs.com/
本文版权归作者和博客园共有，欢迎转载，转载保留此段文字并且注明出处；谢谢。

本文链接

MSP430程序库<八>DAC12的使用

2011-08-22T07:18:00Z

MSP430 带有的DAC12 模块，可以将运算处理的结果转换为模拟量，以便操作被控制对象的工作过程。DA是在控制操作过程中常用的器件之一；MSP430有些系列中含有DAC12模块，给需要使用DA的方案提供了许多方便。这里实现较为简单的DAC的驱动，方便以后使用。

硬件介绍：
MSP430x14x系列不含DAC12模块，所以本文的实现只能用于16系列等含有DAC12模块的单片机中。
MSP430F169 单片机的DAC12 模块有2 个DAC 通道，这两个通道在操作上是完全平等的。并且可以用DAC12GRP控制位将多个DAC12通道组合起来，实现同步更新，硬件还能确保同步更新独立于任何中断或者NMI事件。
这个DAC12模块有以下特点：8位或12位分辨率可调、可编程时间对能量的损耗、可选内部或外部参考源、支持二进制原码和补码输入、具有自校验功能、可以多路DAC同步更新、还可以用DMA等。
这里实现的是较为简化的版本，需要可以自己添加或改写功能，如：初始化函数内部调用自校验的函数，可以在每一次初始化时候均自校验。
DAC12每个模块只有两个寄存器：控制寄存和数据寄存器，控制寄存器用来初始化和设置模块的使用，数据寄存器用来存放要输出的电压数字量。169的DAC的寄存器如下：
DAC12_0控制寄存器    DAC12_0CTL
DAC12_0数据寄存器    DAC12_0DAT
DAC12_1控制寄存器    DAC12_1CTL
DAC12_1数据寄存器    DAC12_1DAT
控制寄存器每一位的功能如下：
DAC12REFx：选择DAC12的参考源
0，1 Vref+
2，3 Veref+
DAC12RES：选择DAC12分辨率
0 12位分辨率
1 8分辨率
DAC12LSELx：锁存器触发源选择
当 DAC12锁存器得到触发之后，能够将锁存器中的数据传送到DAC12的内核。
当 DAC12LSELx=0的时候，DAC数据更新不受DAC12ENC 的影响。
0 DAC12_XDAT执行写操作将触发（不考虑DAC12ENC 的状态）
1 DAC12_XDAT执行写操作将触发（考虑DAC12ENC 的状态）
2 Timer_A3.OUT1的上升沿
3 Timer_B7.OUT2的上升沿
DAC12CALON：DAC12校验操作控制
置位后启动校验操作，校验完成后自动被复位。校验操作可以校正偏移误差。
0 没有启动校验操作
1 启动校验操作
DAC12IR：DAC12输入范围
设定输入参考电压和输出的关系
0 DAC12的满量程为参考电压的3倍（不操作AVcc）
1 DAC12的满量程为参考电压
DAC12AMPx：DAC12运算放大器设置
0 输入缓冲器关闭，输出缓冲器关闭，高阻
1 输入缓冲器关闭，输出缓冲器关闭，0V
2 输入缓冲器低速低电流，输出缓冲器低速低电流
3 输入缓冲器低速低电流，输出缓冲器中速中电流
4 输入缓冲器低速低电流，输出缓冲器高速高电流
5 输入缓冲器中速中电流，输出缓冲器中速中电流
6 输入缓冲器中速中电流，输出缓冲器高速高电流
7 输入缓冲器高速高电流，输出缓冲器高速高电流
DAC12DF：DAC12的数据格式
0 二进制
1 二进制补码
DAC12IE：DAC12的中断允许
0 禁止中断
1 允许中断
DAC12IFG：DAC12的中断标志位
0 没有中断请求
1 有中断请求
DAC12ENC：DAC12转换控制位
DAC12LSEL>0的时候，DAC12ENC 才有效。
0 DAC12停止
1 DAC12转换
DAC12GRP：DAC12组合控制位
0 没有组合
1 组合
详细的有关DAC12的资料可以参考TI提供的用户指南。
程序实现：
DAC12模块的程序比较简单，因为每组只有一个寄存器用来控制；本程序实现的功能如下：DAC模块初始化，完成两个DAC模块的初始化，可以根据参数判断要是、初始化的是哪个模块或两个都初始化，或是两个一组同时更新；用参数传递DAC12AMPx的值，方便设置，程序中注释很详细，如果不理解，可以直接设AMPx为5或0x05；校准函数，完成DAC12模块的自校准，也是通过参数传递要校准的模块；电压输出函数，同样这个也是用参数传递要输出的模块。
初始化：
/********************************************************
* 函数名称：DAC12Init
* 功能：DAC12用到的相关资源初始化
* 参数：
* module模块 0:使用模块DAC12_0
* 1:使用模块DAC12_1
* 2:使用模块DAC12_0/1
* 3:使用模块DAC12_0/1 共同更新
* DAC12AMPx：DAC运算放大器设置：
* 0 输入缓冲器关闭，输出缓冲器关闭，高阻
* 1 输入缓冲器关闭，输出缓冲器关闭，0V
* 2 输入缓冲器低速/电流，输出缓冲器低速/电流
* 3 输入缓冲器低速/电流，输出缓冲器中速/电流
* 4 输入缓冲器低速/电流，输出缓冲器高速/电流
* 5 输入缓冲器中速/电流，输出缓冲器中速/电流
* 6 输入缓冲器中速/电流，输出缓冲器高速/电流
* 7 输入缓冲器高速/电流，输出缓冲器高速/电流
* 返回值：char，设置成功返回1，参数错误返回0
* 说明：其他默认为：12位方案、写入即更新输出，module模
* 块为3时，两个都写入更新；DAC12的满量程为参考电
* 压；内部2.5v参考电压：需要AD设置参考源打开2.5.
*********************************************************/
char DAC12Init(char module,char DAC12AMPx)
{
if(DAC12AMPx>7)
{
return(0);
}
//---------------------------设置模块-------------------------------
switch(module)
{
case 0:case'0': DAC12_0Init(DAC12AMPx); break; //模块0
case 1:case'1': DAC12_1Init(DAC12AMPx); break; //模块1
case 2:case'2':
DAC12_0Init(DAC12AMPx);
DAC12_1Init(DAC12AMPx);
break; //模块0、1
case 3:case'3':
DAC12_0Init(DAC12AMPx);
DAC12_1Init(DAC12AMPx);
DAC12_0CTL |= DAC12GRP;
break; //无校验
default : return(0); //参数错误
}
return (1);
}
这里参数无效返回0，设置完成返回1，不过要注意的是在使用DAC之前，必须开启内部参考源（在ADC模块里面，具体可以参考使用示例）。
DAC12_0Init和DAC12_1Init函数内容一样，只不过控制寄存器分别是DAC12_0CTL和DAC12_0CTL，这里只给出DAC12_0Init的函数，另一个参考源程序：
void DAC12_0Init(char DAC12AMPx)
{
// Internal ref gain 1
DAC12_0CTL = DAC12SREF_0 + DAC12IR;
DAC12_0CTL |= DAC12LSEL_1 + (DAC12AMPx << 5);
DAC12_0CTL |= DAC12ENC;
}
这个函数仅仅完成控制寄存器的设置。选内部参考源，输出满量程是参考电压的1倍，更新方式：写入即更新，如果group设置，则两个都写入才更新。
校准函数：完成DAC12模块自校准，
void DAC12Cal(char module)
{
switch(module)
{
case 0:case'0':
DAC12_0CTL |= DAC12CALON; // 启动效验DAC
while((DAC12_0CTL & DAC12CALON) != 0); // 等待效验完成
break; //模块0
case 1:case'1':
DAC12_1CTL |= DAC12CALON; // 启动效验DAC
while((DAC12_1CTL & DAC12CALON) != 0); // 等待效验完成
break; //模块1
case 2:case'2':
case 3:case'3':
DAC12_0CTL |= DAC12CALON; // 启动效验DAC
while((DAC12_0CTL & DAC12CALON) != 0); // 等待效验完成
DAC12_1CTL |= DAC12CALON; // 启动效验DAC
while((DAC12_1CTL & DAC12CALON) != 0); // 等待效验完成
break; //模块0、1
default : return; //参数错误
}
}
参数含义和前初始化的函数相同，为了使用函数时一致。
输出函数：
void DAC12Out(char module,int out)
{
switch(module)
{
case 0:case'0': DAC12_0DAT=out; break; //模块0
case 1:case'1': DAC12_1DAT=out; break; //模块1
case 2:case'2':
case 3:case'3': DAC12_0DAT=out; DAC12_1DAT=out; break; //模块0、1
default : return; //参数错误
}
}
输出函数的参数也和初始化的module参数含义相同，这个函数比较简单，只是按照要输出的值赋给DAT寄存器。
DAC12的程序库就这么多，DAC12还可以严格按时间更新数据，以输出一定频率的波形，可以设置为TA out1上升沿更新数据，或TB out2上升沿更新。另外还可以和DMA共同使用，完成更复杂的功能；这里均没有实现，需要的话可以根据寄存器功能来实现。
程序部分就到这了。
使用示例：
这里的使用方式依然和之前的程序一样，加入C文件，包含H文件即可，另外，使用本程序，必须开启内部AD参考源，为DAC12模块提供参考电压。
void main( void )
{
// Stop watchdog timer to prevent time out reset
WDTCTL = WDTPW + WDTHOLD;
ClkInit();
DAC12Init(3,5); //初始化
DAC12Cal(2); //校准
ADC12CTL0 = REF2_5V + REFON; //开启内部参考源 2.5v 必须有；以供DA使用
DAC12Out(2,0x666);
}
ADC12CTL0 = REF2_5V + REFON;这句即是开启参考电压2.5v以供DA使用。

DAC12模块的程序库就到这里了，有什么不对的地方欢迎拍砖。

附件：程序库

作者：给我一杯酒
出处：http://Engin.cnblogs.com/
本文版权归作者和博客园共有，欢迎转载，转载保留此段文字并且注明出处；谢谢。

本文链接

MSP430程序库<七>按键

2011-08-21T03:31:00Z

按键是单片机系统最常用的输入设备之一；几乎是只要需要交互输入，就必须有键盘。这篇博客实现了一个通用的键盘程序，只要提供一个读取键值的函数(底层键值)，程序将完成消抖、存入队列等一些列处理。同时本程序提供最常用的4*4矩阵键盘的程序，和4个按键的程序。

硬件介绍：
本文主要实现了一个键盘的通用框架，可以很方便的改为不同的键盘函数，这里实现了两种按键4个单独按键和4*4行列扫描的键盘。

4个按键的是这样的：四个按键分别一端接地，另一端接上拉电阻后输入单片机的P1.0-P1.3口；这样，按键按下时，单片机接到低电平，松开时单片机输入信号有上拉电阻固定为高电平。

4*4的按键：行输入信号配有桑拉电阻，无按键时默认电平高电平；列扫描信号线直接接到按键列线；读键时，列扫描信号由单片机给出低电平信号(按列逐列扫描)，读取行信号，从而判断具体是哪个按键；电路图大概如下：

图中，IN是键盘的列扫描线，OUT是键盘的输出的行信号线。扫描是也可以按行扫描，这时IN是行扫描线，OUT的按键输出的列信号线。我的程序是按列扫描的（行列扫描原理一样，只是行列进行了交换）。

这里，同时实现了4*4按键的scanf函数的移植，同时，加入了之前实现的液晶的printf函数的移植，搭建了一个可以交互输入输出的完整的一个系统；液晶的printf又加入了函数，实现了退格；可以在输入错误数字的时候退格重新输入。

程序实现：

先说一下程序的结构，程序实现了一个循环队列，用来存放已按下的键值，可以保存最新的四个按键，可以防止按键丢失；程序使用的是中断的方式进行按键，每16ms(用的是看门狗的间隔中断)读一次按键，进行判断键值是否有效，有效则放入队列，等待读取。

循环队列的实现:用数组实现，为判断队满，数组的最后一个元素不用于存储键码值：

/**********************宏定义***********************/
#define KeySize 4 //键码值队列
#define Length KeySize+1 //队列数组元素个数
/***************************************************/

/**********************键值队列*********************/
//可KeySize(Length-1)个键码循环队列占用一个元素空间
char Key[Length];

入队函数：入队时，队满则出队一个，以保存最新的四个按键。

void AddKeyCode(char keyCode)
{
if((rear+1)%Length==front) //队满
{
front=(front+1)%Length; //出队一个
}
Key[rear] = keyCode;
rear=(rear+1)%Length;
}

出队函数：出队函数即是读取按键的函数，以供其他需要的地方调用。

char ReadKey()
{
char temp;
//if(rear==front) return '\0'; //无按键
while(rear==front);
temp = Key[front];
front=(front+1)%Length;
return temp;
}

KeyProcess:这个函数即是键盘处理函数，需要被每10ms-20ms的时间调用一次的函数，在这里把它放入了看门狗定时器16ms的中断中;函数流程图和函数内容如下：

void KeyProcess()
{
static char keyValue = 0xff; //按键标识，键值
static char addedFlag = 0; //加入队列标志
char keyVal = GetKey();
if(keyVal==0xff) //无按键
{
keyValue = 0xff;
addedFlag = 0;
return;
}
if(keyValue==0xff) //之前状态无按键
{
keyValue = keyVal;
return;
}
if(keyValue!=keyVal) //和前次按键不同
{
keyValue = keyVal; //保存新按键值
return;
}
if(addedFlag==1) //已加入队列
{
return;
}
addedFlag = 1;
AddKeyCode(KeyCode[keyVal]);
}

这个函数完成按键的判断，并和上次的比较，从而判断是否是有效按键，再根据是否已经入队保存，去判断是否要保存，入队列保存按键。

这个函数需要每10ms-20ms中断运行一次：

#pragma vector=WDT_VECTOR
__interrupt void WDT_ISR()
{
KeyProcess();
}

这是430看门狗的间隔定时中断，设置的是每16ms中断一次：

WDTCTL=WDT_ADLY_16; //看门狗内部定时器模式16ms
IE1 |= WDTIE; //允许看门狗中断

KeyProcess里调用了GetKey函数，这个函数需要用户提供，以满足特殊的按键需求，这里提供了两个实例：4个按键和4*4矩阵键盘。

4个按键的getkey函数：

char GetKey()
{
if((P1IN&0X0F)==0x0E)
{
return 0;
}
if((P1IN&0X0F)==0x0D)
{
return 1;
}
if((P1IN&0X0F)==0x0B)
{
return 2;
}
if((P1IN&0X0F)==0x07)
{
return 3;
}
return 0xff;
}

这里根据每个按键，输出按键原始键值，没有按键则输出0xff；当自己提供getkey函数时，也需要这样，无按键时返回0xff

把对应原始键值翻译成所需键码，用数组KeyCode：

char KeyCode[] = "0123"; /*4个按键时*/

这里把它转化成ASCII码输出，需要的话可以自行更改。

4*4矩阵键盘：getkey：

char GetKey()
{
P1DIR |= 0XF0; //高四位输出
for(int i=0;i<4;i++)
{
P1OUT = 0XEF << i;
for(int j=0;j<4;j++)
{
if((P1IN&(0x01<<j))==0)
{
return (i+4*j);
}
}
}
return 0xff;
}

这里是按列扫描，可以随意改成其他扫描方式，只要获取原始键值即可，无按键是须返回0xff。

KeyCode，翻译成ASCII码：

char KeyCode[] = "0123456789ABCDEF"

到这里，正常的键盘程序结束，调用时只需加入Key.c，包含Key.h即可使用，先调用KeyInit后，就可以正常的读键了。这里不再细说。

scanf移植：scanf移植时，需要的是ASCII码字符型设备，利用ASCII码输入数据还必须要有回车键，只有这样，才能用scanf输入数据，这里为了输入数据错误时，可以退格修改，按键还有一个退格键。

键盘结构：

1	2	3	退格
4	5	6	保留
7	8	9	保留
保留	0	保留	回车

保留键用字符’\0’,回车’\n’退格’\b’

所以：KeyCode：

char KeyCode[] = "123\b456\000789\0\0000\0\r"; /* 4*4,scanf移植*/

在字符串里，\0后面是数字时，必须用’\000’否则，c语言编译器认为\0和后面的数字组合为一个字符。

scanf的移植，需要实现getchar函数，这里和之前的getchar函数类似，把它放到了Getchar.c文件里，内容如下：

#include <stdio.h>
#include "Key.h"

#define LINE_LENGTH 20 //行缓冲区大小，决定每行最多输入的字符数

/*标准终端设备中，特殊ASCII码定义，请勿修改*/
#define InBACKSP 0x08 //ASCII <-- (退格键)
#define InDELETE 0x7F //ASCII <DEL> (DEL 键)
#define InEOL '\r' //ASCII <CR> (回车键)
#define InLF '\n' //ASCII <LF> (回车)
#define InSKIP '\3' //ASCII control-C
#define InEOF '\x1A' //ASCII control-Z

#define OutDELETE "\x8 \x8" //VT100 backspace and clear
#define OutSKIP "^C\n" //^C and new line
#define OutEOF "^Z" //^Z and return EOF

int getchar()
{
static char inBuffer[LINE_LENGTH + 2]; //Where to put chars
static char ptr; //Pointer in buffer
char c;

while(1)
{
if(inBuffer[ptr]) //如果缓冲区有字符
return (inBuffer[ptr++]); //则逐个返回字符
ptr = 0; //直到发送完毕，缓冲区指针归零
while(1) //缓冲区没有字符，则等待字符输入
{
c = ReadKey(); //等待接收一个字符==移植时关键
if(c == InEOF && !ptr) //==EOF== Ctrl+Z
{ //只有在未入其他字符时才有效
printf(OutEOF); //终端显示EOF符
return EOF; //返回 EOF（-1）
}
if(c==InDELETE || c==InBACKSP) //==退格或删除键==
{
if(ptr) //缓冲区有值
{
ptr--; //从缓冲区移除一个字符
printf(OutDELETE); //同时显示也删掉一个字符
}
}
else if(c == InSKIP) //==取消键 Ctrl+C ==
{
printf(OutSKIP); //终端显示跳至下一行
ptr = LINE_LENGTH + 1; //==0 结束符==
break;
}
else if(c == InEOL||c == InLF) //== '\r' 回车=='\n'回车
{
putchar(inBuffer[ptr++] = '\n');//终端换行
inBuffer[ptr] = 0; //末尾添加结束符（NULL）
ptr = 0; //指针清空
break;
}
else if(ptr < LINE_LENGTH) //== 正常字符 ==
{
if(c >= ' ') //删除 0x20以下字符
{
//存入缓冲区
putchar(inBuffer[ptr++] = c);
}
}
else //缓冲区已满
{
putchar('\7'); //== 0x07 蜂鸣符，PC回响一声
}
}
}
}

这里是支持退格等键的详细函数。

如果不需要支持退格，可以简化为：

int getchar()
{
return ReadKey();
}

要实现scanf调用，还需要设置，详细设置参考：MSP430程序库<四>printf和scanf函数移植；需要把库设置为CLIB；在Option-general option-library configuration里面。

这样，键盘的scanf移植完成，需要使用时，只需加入对stdio.h文件的包含，然后完成键盘的初始化即可。

使用示例：
这里，示例实现的是键盘和液晶的简单交互；键盘输入数据，液晶正常显示；就像c语言调试时键盘和屏幕一样；当然没有那个丰富啦。

液晶的部分，用的是原来实现的程序，在这里，为了支持输入错误时退格，对原来的printf函数加入了退格支持。具体参考：MSP430程序库<四>printf和scanf函数移植(已经更新)。

项目中接入液晶的c程序文件和printf的程序文件（Lcd12864.c、Printf.c），加入Lcd12864.h的文件包含；初始化液晶后，就可用printf向液晶输出要显示的内容了。

键盘：加入Key.c，包含Key.h，加入Getchar.c，程序中初始化键盘；然后设置所用的lib为CLIB，具体设置见：MSP430程序库<四>printf和scanf函数移植。之后就可以用键盘和液晶完成和430单片机简单的交互了。

详细参考示例工程和main.c。
#include <msp430x16x.h>
#include <stdio.h>
#include "Lcd12864.h"
#include "Key.h"

long a;
void main( void )
{
// Stop watchdog timer to prevent time out reset
WDTCTL = WDTPW + WDTHOLD;
ClkInit();
LcdInit();
KeyInit();
_EINT();
while(1)
{
printf("请输入数字：");
scanf("%ld",&a);
printf("输入的数字是：%ld",a);
_NOP();
}
}
这样，就可以用键盘向单片机输入数据，同时利用液晶可以很容易的知道数据输入的是否有问题。

键盘的程序库就到这里，有什么不足，欢迎讨论。

附件：程序库

作者：给我一杯酒
出处：http://Engin.cnblogs.com/
本文版权归作者和博客园共有，欢迎转载，转载保留此段文字并且注明出处；谢谢。

本文链接