Freescale 9S12 系列单片机应用笔记（SCI）3-电子工程世界

分享到: 微博; QQ; 微信; LinkedIn

这次介绍如何在 uC/OS-II 上实现串口驱动。

/*sci_ucos.h*/
#ifndef _SCI_RTOS_H_
#define _SCI_RTOS_H_

#define SCI_RX_BUF_SIZE 64 /* Number of characters in Rx ring buffer */
#define SCI_TX_BUF_SIZE 64 /* Number of characters in Tx ring buffer */
/*
*********************************************************************************************************
* CONSTANTS
*********************************************************************************************************
*/
#ifndef NUL
#define NUL 0x00
#endif
/* ERROR CODES */
#define SCI_NO_ERR 0 /* Function call was successful */
#define SCI_BAD_CH 1 /* Invalid communications port channel */
#define SCI_RX_EMPTY 2 /* Rx buffer is empty, no character available */
#define SCI_TX_FULL 3 /* Tx buffer is full, could not deposit character */
#define SCI_TX_EMPTY 4 /* If the Tx buffer is empty. */
#define SCI_RX_TIMEOUT 5 /* If a timeout occurred while waiting for a character*/
#define SCI_TX_TIMEOUT 6 /* If a timeout occurred while waiting to send a char.*/
#define SCI_PARITY_NONE 0 /* Defines for setting parity */
#define SCI_PARITY_ODD 1
#define SCI_PARITY_EVEN 2
/*
*********************************************************************************************************
* DATA TYPES
*********************************************************************************************************
*/
typedef struct {
short RingBufRxCtr; /* Number of characters in the Rx ring buffer */
OS_EVENT *RingBufRxSem; /* Pointer to Rx semaphore */
unsigned char *RingBufRxInPtr; /* Pointer to where next character will be inserted */
unsigned char *RingBufRxOutPtr; /* Pointer from where next character will be extracted */
unsigned char RingBufRx[SCI_RX_BUF_SIZE]; /* Ring buffer character storage (Rx) */
short RingBufTxCtr; /* Number of characters in the Tx ring buffer */
OS_EVENT *RingBufTxSem; /* Pointer to Tx semaphore */
unsigned char *RingBufTxInPtr; /* Pointer to where next character will be inserted */
unsigned char *RingBufTxOutPtr; /* Pointer from where next character will be extracted */
unsigned char RingBufTx[SCI_TX_BUF_SIZE]; /* Ring buffer character storage (Tx) */
} SCI_RING_BUF;
/**
* To obtain a character from the communications channel.
* @param port, port can be SCI0 / SCI1
* @param to, is the amount of time (in clock ticks) that the calling function is willing to
* wait for a character to arrive. If you specify a timeout of 0, the function will
* wait forever for a character to arrive.
* @param err, is a pointer to where an error code will be placed:
* *err is set to SCI_NO_ERR if a character has been received
* *err is set to SCI_RX_TIMEOUT if a timeout occurred
* *err is set to SCI_BAD_CH if you specify an invalid channel number
* @return The character in the buffer (or NUL if a timeout occurred)
*/
unsigned char SCIGetCharB (unsigned char ch, unsigned short to, unsigned char *err);
/**
* This function is called by your application to send a character on the communications
* channel. The function will wait for the buffer to empty out if the buffer is full.
* The function returns to your application if the buffer doesn't empty within the specified
* timeout. A timeout value of 0 means that the calling function will wait forever for the
* buffer to empty out. The character to send is first inserted into the Tx buffer and will
* be sent by the Tx ISR. If this is the first character placed into the buffer, the Tx ISR
* will be enabled.
*
* @param port, port can be SCI0 / SCI1
* @param c is the character to send.
* @param to is the timeout (in clock ticks) to wait in case the buffer is full. If you
* specify a timeout of 0, the function will wait forever for the buffer to empty.
* @return SCI_NO_ERR if the character was placed in the Tx buffer
* SCI_TX_TIMEOUT if the buffer didn't empty within the specified timeout period
* SCI_BAD_CH if you specify an invalid channel number
*/
unsigned char SCIPutCharB (unsigned char port, unsigned char c, unsigned short to);
/**
* To initialize the communications module.
* You must call this function before calling any other functions.
*/
void SCIBufferInit (void);
/**
* To see if any character is available from the communications channel.
*
* @param port, port can be SCI0 / SCI1
* @return If at least one character is available, the function returns
* FALSE(0) otherwise, the function returns TRUE(1).
*/
unsigned char SCIBufferIsEmpty (unsigned char port);
/**
* To see if any more characters can be placed in the Tx buffer.
* In other words, this function check to see if the Tx buffer is full.
*
* @param port, port can be SCI0 / SCI1
* @return If the buffer is full, the function returns TRUE
* otherwise, the function returns FALSE.
*/
unsigned char SCIBufferIsFull (unsigned char port);
#endif

/**
* SCI(Serial Communication Interface) Buffered Serial I/O
* @file sci_ucos.c
* @author Li Yuan
* @platform mc9s12XX
* @date 2012-7-22
* @version 1.0.1
*/
#include "derivative.h" /* derivative-specific definitions */
#include
#include "includes.H"
#include "sci.h"
#include "sci_rtos.h"
/**
* GLOBAL VARIABLES
*/
SCI_RING_BUF SCI0Buf;
SCI_RING_BUF SCI1Buf;
/**
* To obtain a character from the communications channel.
* @param port, port can be SCI0 / SCI1
* @param to, is the amount of time (in clock ticks) that the calling function is willing to
* wait for a character to arrive. If you specify a timeout of 0, the function will
* wait forever for a character to arrive.
* @param err, is a pointer to where an error code will be placed:
* *err is set to SCI_NO_ERR if a character has been received
* *err is set to SCI_RX_TIMEOUT if a timeout occurred
* *err is set to SCI_BAD_CH if you specify an invalid channel number
* @return The character in the buffer (or NUL if a timeout occurred)
*/
unsigned char SCIGetCharB (unsigned char port, unsigned short to, INT8U *err)
{
#if OS_CRITICAL_METHOD == 3u /* Allocate storage for CPU status register */
OS_CPU_SR cpu_sr = 0u;
#endif
unsigned char c;
unsigned char oserr;
SCI_RING_BUF *pbuf;
switch (port)
{ /* Obtain pointer to communications channel */
case SCI0:
pbuf = &SCI0Buf;
break;
case SCI1:
pbuf = &SCI1Buf;
break;
default:
*err = SCI_BAD_CH;
return (0);
}
OSSemPend(pbuf->RingBufRxSem, to, &oserr); /* Wait for character to arrive */
if (oserr == OS_TIMEOUT)
{ /* See if characters received within timeout*/
*err = SCI_RX_TIMEOUT; /* No, return error code */
return (NUL);
}
else
{
OS_ENTER_CRITICAL();
pbuf->RingBufRxCtr--; /* Yes, decrement character count */
c = *pbuf->RingBufRxOutPtr++; /* Get character from buffer */
if (pbuf->RingBufRxOutPtr == &pbuf->RingBufRx[SCI_RX_BUF_SIZE]) { /* Wrap OUT pointer */
pbuf->RingBufRxOutPtr = &pbuf->RingBufRx[0];
}
OS_EXIT_CRITICAL();
*err = SCI_NO_ERR;
return (c);
}
}
/**
* This function is called by your application to send a character on the communications
* channel. The function will wait for the buffer to empty out if the buffer is full.
* The function returns to your application if the buffer doesn't empty within the specified
* timeout. A timeout value of 0 means that the calling function will wait forever for the
* buffer to empty out. The character to send is first inserted into the Tx buffer and will
* be sent by the Tx ISR. If this is the first character placed into the buffer, the Tx ISR
* will be enabled.
*
* @param port, port can be SCI0 / SCI1
* @param c is the character to send.
* @param to is the timeout (in clock ticks) to wait in case the buffer is full. If you
* specify a timeout of 0, the function will wait forever for the buffer to empty.
* @return SCI_NO_ERR if the character was placed in the Tx buffer
* SCI_TX_TIMEOUT if the buffer didn't empty within the specified timeout period
* SCI_BAD_CH if you specify an invalid channel number
*/
unsigned char SCIPutCharB (unsigned char port, unsigned char c, unsigned short to)
{
#if OS_CRITICAL_METHOD == 3u /* Allocate storage for CPU status register */
OS_CPU_SR cpu_sr = 0u;
#endif
SCI_RING_BUF *pbuf;
unsigned char oserr;
switch (port)
{ /* Obtain pointer to communications channel */
case SCI0:
pbuf = &SCI0Buf;
break;
case SCI1:
pbuf = &SCI1Buf;
break;
default:
return (SCI_BAD_CH);
}
OSSemPend(pbuf->RingBufTxSem, to, &oserr); /* Wait for space in Tx buffer */
if (oserr == OS_TIMEOUT)
{
return (SCI_TX_TIMEOUT); /* Timed out, return error code */
}
OS_ENTER_CRITICAL();
pbuf->RingBufTxCtr++; /* No, increment character count */
*pbuf->RingBufTxInPtr++ = c; /* Put character into buffer */
if (pbuf->RingBufTxInPtr == &pbuf->RingBufTx[SCI_TX_BUF_SIZE])
{
pbuf->RingBufTxInPtr = &pbuf->RingBufTx[0]; /* Wrap IN pointer */
}
if (pbuf->RingBufTxCtr == 1) /* See if this is the first character */
{
SCIEnableTxInt(port); /* Yes, Enable Tx interrupts */
}
OS_EXIT_CRITICAL();
return (SCI_NO_ERR);
}
/**
* To initialize the communications module.
* You must call this function before calling any other functions.
*/
void SCIBufferInit (void)
{
SCI_RING_BUF *pbuf;
pbuf = &SCI0Buf; /* Initialize the ring buffer for SCI0 */
pbuf->RingBufRxCtr = 0;
pbuf->RingBufRxInPtr = &pbuf->RingBufRx[0];
pbuf->RingBufRxOutPtr = &pbuf->RingBufRx[0];
pbuf->RingBufRxSem = OSSemCreate(0);
pbuf->RingBufTxCtr = 0;
pbuf->RingBufTxInPtr = &pbuf->RingBufTx[0];
pbuf->RingBufTxOutPtr = &pbuf->RingBufTx[0];
pbuf->RingBufTxSem = OSSemCreate(SCI_TX_BUF_SIZE);
pbuf = &SCI1Buf; /* Initialize the ring buffer for SCI1 */
pbuf->RingBufRxCtr = 0;
pbuf->RingBufRxInPtr = &pbuf->RingBufRx[0];
pbuf->RingBufRxOutPtr = &pbuf->RingBufRx[0];
pbuf->RingBufRxSem = OSSemCreate(0);
pbuf->RingBufTxCtr = 0;
pbuf->RingBufTxInPtr = &pbuf->RingBufTx[0];
pbuf->RingBufTxOutPtr = &pbuf->RingBufTx[0];
pbuf->RingBufTxSem = OSSemCreate(SCI_TX_BUF_SIZE);
}
/**
* To see if any character is available from the communications channel.
*
* @param port, port can be SCI0 / SCI1
* @return If at least one character is available, the function returns
* FALSE(0) otherwise, the function returns TRUE(1).
*/
unsigned char SCIBufferIsEmpty (unsigned char port)
{
#if OS_CRITICAL_METHOD == 3u /* Allocate storage for CPU status register */
OS_CPU_SR cpu_sr = 0u;
#endif
unsigned char empty;
SCI_RING_BUF *pbuf;
switch (port)
{ /* Obtain pointer to communications channel */
case SCI0:
pbuf = &SCI0Buf;
break;
case SCI1:
pbuf = &SCI1Buf;
break;
default:
return (0xff);
break;
}
OS_ENTER_CRITICAL();
if (pbuf->RingBufRxCtr > 0)
{ /* See if buffer is empty */
empty = 0; /* Buffer is NOT empty */
}
else
{
empty = 1; /* Buffer is empty */
}
OS_EXIT_CRITICAL();
return (empty);
}
/**
* To see if any more characters can be placed in the Tx buffer.
* In other words, this function check to see if the Tx buffer is full.
*
* @param port, port can be SCI0 / SCI1
* @return If the buffer is full, the function returns TRUE
* otherwise, the function returns FALSE.
*/
unsigned char SCIBufferIsFull (unsigned char port)
{
#if OS_CRITICAL_METHOD == 3u /* Allocate storage for CPU status register */
OS_CPU_SR cpu_sr = 0u;
#endif
char full;
SCI_RING_BUF *pbuf;
switch (port)
{ /* Obtain pointer to communications channel */
case SCI0:
pbuf = &SCI0Buf;
break;
case SCI1:
pbuf = &SCI1Buf;
break;
default:
return (255);
}
OS_ENTER_CRITICAL();
if (pbuf->RingBufTxCtr < SCI_TX_BUF_SIZE) { /* See if buffer is full */
full = 0; /* Buffer is NOT full */
} else {
full = 1; /* Buffer is full */
}
OS_EXIT_CRITICAL();
return (full);
}
// This function is called by the Rx ISR to insert a character into the receive ring buffer.
static void SCIPutRxChar (unsigned char port, unsigned char c)
{
SCI_RING_BUF *pbuf;
switch (port)
{ /* Obtain pointer to communications channel */
case SCI0:
pbuf = &SCI0Buf;
break;
case SCI1:
pbuf = &SCI1Buf;
break;
default:
return;
}
if (pbuf->RingBufRxCtr < SCI_RX_BUF_SIZE) { /* See if buffer is full */
pbuf->RingBufRxCtr++; /* No, increment character count */
*pbuf->RingBufRxInPtr++ = c; /* Put character into buffer */
if (pbuf->RingBufRxInPtr == &pbuf->RingBufRx[SCI_RX_BUF_SIZE]) { /* Wrap IN pointer */
pbuf->RingBufRxInPtr = &pbuf->RingBufRx[0];
}
(void)OSSemPost(pbuf->RingBufRxSem); /* Indicate that character was received */
}
}
// This function is called by the Tx ISR to extract the next character from the Tx buffer.
// The function returns FALSE if the buffer is empty after the character is extracted from
// the buffer. This is done to signal the Tx ISR to disable interrupts because this is the
// last character to send.
static unsigned char SCIGetTxChar (unsigned char port, unsigned char *err)
{
unsigned char c;
SCI_RING_BUF *pbuf;
switch (port)
{ /* Obtain pointer to communications channel */
case SCI0:
pbuf = &SCI0Buf;
break;
case SCI1:
pbuf = &SCI1Buf;
break;
default:
*err = SCI_BAD_CH;
return (0);
}
if (pbuf->RingBufTxCtr > 0) { /* See if buffer is empty */
pbuf->RingBufTxCtr--; /* No, decrement character count */
c = *pbuf->RingBufTxOutPtr++; /* Get character from buffer */
if (pbuf->RingBufTxOutPtr == &pbuf->RingBufTx[SCI_TX_BUF_SIZE]) { /* Wrap OUT pointer */
pbuf->RingBufTxOutPtr = &pbuf->RingBufTx[0];
}
(void)OSSemPost(pbuf->RingBufTxSem); /* Indicate that character will be sent */
*err = SCI_NO_ERR;
return (c); /* Characters are still available */
} else {
*err = SCI_TX_EMPTY;
return (NUL); /* Buffer is empty */
}
}
void SCI0_ISR_Handler(void)
{
char status;
char data;
unsigned char err;
status = SCI0SR1;
if(status & 0x0F) // 0x1F = 0001 1111, if status is not Receive Data Reg Full Flag
{
// See if we have some kind of error
// Clear interrupt (do nothing about it!)
data = SCI0DRL;
}
else if(status & 0x20) //Receive Data Reg Full Flag
{
data = SCI0DRL;
SCIPutRxChar(SCI0, data); // Insert received character into buffer
}
else if(status & 0x80)
{
data = SCIGetTxChar(SCI0, &err); // Get next character to send.
if (err == SCI_TX_EMPTY)
{ // Do we have anymore characters to send ?
// No, Disable Tx interrupts
SCIDisTxInt(SCI0);
}
else
{
SCI0DRL = data; // Yes, Send character
}
}
}
void SCI1_ISR_Handler (void)
{
char status;
char data;
unsigned char err;
status = SCI1SR1;
if(status & 0x0F) // 0x1F = 0001 1111, if status is not Receive Data Reg Full Flag
{
// See if we have some kind of error
// Clear interrupt (do nothing about it!)
data = SCI1DRL;
}
else if(status & 0x20) //Receive Data Reg Full Flag
{
data = SCI1DRL;
SCIPutRxChar(SCI1, data); // Insert received character into buffer
}
else if(status & 0x80)
{
data = SCIGetTxChar(SCI1, &err); // Get next character to send.
if (err == SCI_TX_EMPTY)
{ // Do we have anymore characters to send ?
// No, Disable Tx interrupts
SCIDisTxInt(SCI1);
}
else
{
SCI1DRL = data; // Yes, Send character
}
}
}

#pragma CODE_SEG NON_BANKED
interrupt VectorNumber_Vsci0 void SCI0_ISR(void)
{
#if defined( __BANKED__) || defined(__LARGE__) || defined(__PPAGE__)
__asm ldaa PPAGE; // 3~, Get current value of PPAGE register
__asm psha; // 2~, Push PPAGE register onto current task's stack
#endif
__asm inc OSIntNesting; //OSIntNesting++;
//if (OSIntNesting == 1)
//{
// OSTCBCur->OSTCBStkPtr = Stack Pointer ;
//}
__asm
{
ldab OSIntNesting
cmpb #$01
bne SCI0ISR1
ldx OSTCBCur
sts 0, x
SCI0ISR1:
}
#if defined( __BANKED__) || defined(__LARGE__) || defined(__PPAGE__)
__asm call SCI0_ISR_Handler;
__asm call OSIntExit;
#else
__asm jsr SCI0_ISR_Handler;
__asm jsr OSIntExit;
#endif
#if defined( __BANKED__) || defined(__LARGE__) || defined(__PPAGE__)
__asm pula; // 3~, Get value of PPAGE register
__asm staa PPAGE; // 3~, Store into CPU's PPAGE register
#endif
}
interrupt VectorNumber_Vsci1 void SCI1_ISR(void)
{
#if defined( __BANKED__) || defined(__LARGE__) || defined(__PPAGE__)
__asm ldaa PPAGE; // 3~, Get current value of PPAGE register
__asm psha; // 2~, Push PPAGE register onto current task's stack
#endif
__asm inc OSIntNesting; //OSIntNesting++;
//if (OSIntNesting == 1)
//{
// OSTCBCur->OSTCBStkPtr = Stack Pointer ;
//}
__asm
{
ldab OSIntNesting
cmpb #$01
bne SCI1ISR1
ldx OSTCBCur
sts 0, x
SCI1ISR1:
}
#if defined( __BANKED__) || defined(__LARGE__) || defined(__PPAGE__)
__asm call SCI1_ISR_Handler;
__asm call OSIntExit;
#else
__asm jsr SCI1_ISR_Handler;
__asm jsr OSIntExit;
#endif
#if defined( __BANKED__) || defined(__LARGE__) || defined(__PPAGE__)
__asm pula; // 3~, Get value of PPAGE register
__asm staa PPAGE; // 3~, Store into CPU's PPAGE register
#endif
}

下面给个简单的例子：

#include /* common defines and macros */
#include "derivative.h" /* derivative-specific definitions */
#include "INCLUDES.H"
#include "crg.h"
#include "sci.h"
#include  "sci_rtos.h"
OS_STK  AppStartTaskStk[64];
static void  AppStartTask (void *pdata);
void main(void)
{
/* put your own code here */
OS_CPU_SR cpu_sr;
CRGInit();
CRGSetRTIFreqency(0x54); // 200Hz
EnableInterrupts;
OS_ENTER_CRITICAL() ;
SCIInit(SCI0) ;
SCIInit(SCI1) ;
OS_EXIT_CRITICAL() ;
OSInit();
SCISetIEBit(SCI0, SCI_RIE) ;
SCISetIEBit(SCI1, SCI_RIE) ;
SCIBufferInit();
(void) OSTaskCreate(AppStartTask, (void *)0x4321, (void *)&AppStartTaskStk[63], 0);
(void)OSStart();
for(;;)
{
_FEED_COP(); /* feeds the dog */
} /* loop forever */
/* please make sure that you never leave main */
}
static void AppStartTask (void *pdata)
{
INT8U err;
char C;
(void) pdata;
for(;;)
{
C = SCIGetCharB(SCI1, 0, &err);
if(err == SCI_NO_ERR)
(void) SCIPutCharB (SCI1, C, 0);
}
}

关键字：Freescale 9S12 系列单片机引用地址：Freescale 9S12 系列单片机应用笔记（SCI）3

上一篇：基于P89LPC922的多点温度采集系统
下一篇：Freescale 9S12 系列单片机应用笔记（SCI）2

推荐阅读最新更新时间：2024-03-16 14:53

e络盟提供Bulgin的Buccaneer系列连接器和压电式开关系列

这些环境密封连接器和开关是恶劣环境应用的理想之选。 e络盟日前宣布供应来自全球电源、防护及环境密封产品领先制造商Bulgin的全新Buccaneer 7000系列连接器和压电式开关，进一步丰富其已超过20多万种连接器的产品库存。Buccaneer系列防尘防水型连接器适用于工业机械和建筑自动化等恶劣环境下的各种电源总线应用。 Bulgin母公司Elektron Technology亚太区销售经理Ron Situ表示：我们很高兴通过e络盟平台为客户提供这些坚固耐用的连接器和高端开关产品。通过进一步扩充Bulgin的产品范围，我们将为客户在严苛应用的系统设计方面提供更大的灵活性。同时，我们的客户也

[工业控制]

e络盟提供Bulgin的Buccaneer<font color='red'>系列</font>连接器和压电式开关<font color='red'>系列</font>

ARM9微控制器LPC3180的软硬件平台设计

摘要介绍以Philips LPC3180微控制器为核心的嵌入式软硬件平台设计；对系统设计的硬件部分和软件部分进行详细的分析，并针对LPC3180芯片特性着重讨论了其软件系统构建以及系统启动流程。实验结果表明，LPC3180嵌入式系统平台结合片内硬件浮点运算单元，具有高性能的浮点运算处理能力，可满足复杂的嵌入式应用场合的要求。关键词 LPC3180 ARM9 软硬件平台嵌入式应用系统设计包括硬件平台和软件平台两部分。前者是以嵌入式微控制器/微处理器为核心的硬件系统；后者则是围绕嵌入式操作系统构建的软件系统。两者在设计上是密不可分的，并且需要在设计之间进行权衡优化，根据实际应用进行外扩和裁剪。基于ARM92

[单片机]

Microchip重夺8位单片机销售额全球第一桂冠

Microchip Technology宣布根据权威行业分析机构Gartner最新发布的2014排名报告，Microchip重登全球8位单片机（MCU）销售额第一宝座。这一成绩充分印证了Microchip在8位PIC 单片机产品线方面所做出的坚定承诺和创新努力。尽管近年来许多MCU供应商逐渐降低8位MCU产品投入，Microchip仍继续坚持对其8位、16位和32位产品线进行全面创新。而Gartner 2014年度报告显示Microchip在这三大产品领域的市场占有率仍保持着持续增长的势头。在2014年度16位MCU市场排名前十位的供应商中，Microchip是增长速度最快的企业，其增速超过其他排名前十企业增速的

[单片机]

基于TOPSwitch-GX系列的多输出开关电源

1 引言　　多路输出开关电源广泛应用在各种复杂小功率电子系统中，就多路输出而言，通常只有输出电压低、输出电流变化范围大的一路作为主电路进行反馈调节控制，以保证在输入电压及负载变化时保持输出电压稳定，由于受变压器各个绕组间的漏感和绕组电阻等的影响，辅助输出电压随输出负载的变化而变化，通常，当主输出满载和辅助输出轻载时，辅助输出电压将升高，而当主输出轻载和辅助输出满时，辅助输出电压将降低，这就是多路输出的负载交叉调整率问题，笔者基于 TOPSwitch-GX系列设计了一种多路输出开关电源，很好的解决了多路输出的负载交叉调整率问题，该电源在各种工况下都能稳定输出，主输出电压纹波小于3%，各路辅助输出纹波小于5%，负载交叉调整率小于

[电源管理]

单片机执行程序的过程

为了加深初学者对51单片机指令的理解，现在把指令执行的过程在此详细说明，希望对你有启发！单片机执行程序的过程，实际上就是执行我们所编制程序的过程。即逐条指令的过程。计算机每执行一条指令都可分为三个阶段进行。即取指令-----分析指令-----执行指令。取指令的任务是：根据程序计数器PC中的值从程序存储器读出现行指令，送到指令寄存器。分析指令阶段的任务是：将指令寄存器中的指令操作码取出后进行译码，分析其指令性质。如指令要求操作数，则寻找操作数地址。计算机执行程序的过程实际上就是逐条指令地重复上述操作过程，直至遇到停机指令可循环等待指令。一般计算机进行工作时，首先要通过外部设备把程序和数据通过输入接口电路和数据总线

[单片机]

51单片机学习笔记6 -- 定时器中断

1.引脚复用通过原理图可以发现定时器0（T0）和定时器1（T1）是P3.4引脚和P3.5引脚的复用功能，当将这两个引脚配置为定时器功能时，引脚外接的传感器（模块）将不能正常使用，即引脚同一时间只能作为一个功能使用（普通I/O或复用功能） T0、T1是两个16位定时器/计数器，每经过1个机器周期内部的16位计数寄存器的值加1，当计数器装满时会溢出，在定时模式时单次最大的定时时间是 65535*1.085us 的时间（单位us） 2.定时器配置定时器0配置需要用到的寄存器（TCON、TMOD、TL0、TH0） 1.定时器/计数器控制寄存器TCON TCON为定时器/计数器T0、T1的控制寄存器，同时也锁存T0、T1溢出

[单片机]

51单片机堆栈操作指令举例说明

堆栈操作指令有两条： PUSH direct POP direct 第一条指令称之为推入，就是将direct中的内容送入堆栈中，第二条指令称之为弹出，就是将堆栈中的内容送回到direct中。推入指令的执行过程是，首先将SP中的值加1，然后把SP中的值当作地址，将direct中的值送进以SP中的值为地址的RAM单元中。例： MOV SP，#5FH MOV A，#100 MOV B，#20 PUSH ACC PUSH B 则执行第一条PUSH ACC指令是这样的：将SP中的值加1，即变为60H，然后将A中的值送到60H单元中，因此执行完本条指令后，内存60H单元的值就是100，同样，执行PUSH B时，是将SP+

[单片机]

51单片机控制舵机实验

简介：这里用到PCF8591 ADDA芯片和51单片机和一个电位器。通过控制电位器，产生PWM波，控制舵机旋转。并在数码管上显示角度。电路图这是程序，、 /*----------------------------------------------- 名称：IIC协议 PCF8591ADDA转换内容：此程序通过IIC协议对DAAD芯片操作，读取电位器的电压，并输出模拟量，用LED亮度渐变指示,晶体选用12MHz ------------------------------------------------*/ #include reg52.h #include intrins.h //包

[单片机]