最新日志

发表于:2008-5-18 13:37:46
标签:无标签

0

C语言中强制数据类型转换的总结

● 字符型变量的值实质上是一个8位的整数值,因此取值范围一般是-128~127,char型变量也可以加修饰符unsigned,则unsigned char 型变量的取值范围是0~255(有些机器把char型当做unsighed char型对待, 取值范围总是0~255)。
● 如果一个运算符两边的运算数类型不同,先要将其转换为相同的类型,即较低类型转换为较高类型,然后再参加运算,转换规则如下图所示。
double ←── float 高

long

unsigned

int ←── char,short 低
● 图中横向箭头表示必须的转换,如两个float型数参加运算,虽然它们类型相同,但仍要先转成double型再进行运算,结果亦为double型。 纵向箭头表示当运算符两边的运算数为不同类型时的转换,如一个long 型数据与一个int型数据一起运算,需要先将int型数据转换为long型, 然后两者再进行运算,结果为long型。所有这些转换都是由系统自动进行的, 使用时你只需从中了解结果的类型即可。这些转换可以说是自动的,但然,C语言也提供了以显式的形式强制转换类型的机制。
● 当较低类型的数据转换为较高类型时,一般只是形式上有所改变, 而不影响数据的实质内容, 而较高类型的数据转换为较低类型时则可能有些数据丢失。

赋值中的类型转换

当赋值运算符两边的运算对象类型不同时,将要发生类型转换, 转换的规则是:把赋值运算符右侧表达式的类型转换为左侧变量的类型。具体的转换如下:
(1) 浮点型与整型
● 将浮点数(单双精度)转换为整数时,将舍弃浮点数的小数部分, 只保留整数部分。
将整型值赋给浮点型变量,数值不变,只将形式改为浮点形式, 即小数点后带若干个0。注意:赋值时的类型转换实际上是强制的。
(2) 单、双精度浮点型
● 由于C语言中的浮点值总是用双精度表示的,所以float 型数据只是在尾部加0延长为doub1e型数据参加运算,然后直接赋值。doub1e型数据转换为float型时,通过截尾数来实现,截断前要进行四舍五入操作。
(3) char型与int型
● int型数值赋给char型变量时,只保留其最低8位,高位部分舍弃。
● chr型数值赋给int型变量时, 一些编译程序不管其值大小都作正数处理,而另一些编译程序在转换时,若char型数据值大于127,就作为负数处理。对于使用者来讲,如果原来char型数据取正值,转换后仍为正值;如果原来char型值可正可负,则转换后也仍然保持原值, 只是数据的内部表示形式有所不同。
(4) int型与1ong型
● long型数据赋给int型变量时,将低16位值送给int型变量,而将高16 位截断舍弃。(这里假定int型占两个字节)。
将int型数据送给long型变量时,其外部值保持不变,而内部形式有所改变。
(5) 无符号整数
● 将一个unsigned型数据赋给一个占据同样长度存储单元的整型变量时(如:unsigned→int、unsigned long→long,unsigned short→short) ,原值照赋,内部的存储方式不变,但外部值却可能改变。
● 将一个非unsigned整型数据赋给长度相同的unsigned型变量时, 内部存储形式不变,但外部表示时总是无符号的。
/*例:赋值运算符举例 */
main()
{ unsigned a,b;
  int i,j;
  a="65535";
  i="-1";
  j="a";
  b="i";
  printf("(unsigned)%u→(int)%d\n",a,j);
  printf("(int)%d→(unsigned)%u\n",i,b);
}
运行结果为:
(unsigned)65535→(int)-1
(int)-1→(unsigned)65535

● 计算机中数据用补码表示,int型量最高位是符号位,为1时表示负值,为0时表示正值。如果一个无符号数的值小于32768则最高位为0,赋给 int型变量后、得到正值。如果无符号数大于等于32768,则最高位为1, 赋给整型变量后就得到一个负整数值。反之,当一个负整数赋给unsigned 型变量时,得到的无符号值是一个大于32768的值。
● C语言这种赋值时的类型转换形式可能会使人感到不精密和不严格,因为不管表达式的值怎样,系统都自动将其转为赋值运算符左部变量的类型。
● 而转变后数据可能有所不同,在不加注意时就可能带来错误。 这确实是个缺点,也遭到许多人们批评。但不应忘记的是:c面言最初是为了替代汇编语言而设计的,所以类型变换比较随意。当然, 用强制类型转换是一个好习惯,这样,至少从程序上可以看出想干什么。
 

点击此处查看原文 >>

系统分类: 软件开发   |    用户分类:    |    来源: 转贴

评论(0) | 阅读(363)
发表于:2008-5-18 11:36:35
标签:无标签

0

MSP430的软硬件C延时程序设计

MSP430的软硬件C延时程序设计
      MSP430是超低功耗16位单片机,越来越受到电子工程师亲睐并得到广泛应用。C程序直观,可读性好,易于移植和维护,已被很多单片机编程人员所采用。MSP430集成开发环境(如IAR Embedded Workbench和AQ430)都集成了C编译器和C语言级调试器C—SPY。但是C语言难以实现精确延时,这一直困扰着很多MSP430单片机程序员。笔者在实际项目开发过程中,遇到很多需要严格时序控制的接口器件,如单总线数字温度传感器DSl8820、实时时钟芯片PCF8563(需要用普通]/o模拟12C总线时序)、三线制数字电位器AD8402、CF卡(Compact Flash Card)等都需要μs级甚至纳ns级精确延时;而一些慢速设备只需要ms到s级的延时。为此,笔者提出了适合于不同延时级别需要的软件或硬件精确延时方法,并已实际应用,效果良好,大大缩短了开发周期。  

      1  硬件延时 

      MSP430单片机系统程序多采用事件驱动机制,即在没有外部事件触发的情况下CPU休眠于低功耗模式中。当外部事件到来时,产生中断激活CPU,进入相应的中断服务程序(ISR)中。中断响应程序只完成两个任务,一是置位相应事件的标志,二是使MCU退出低功耗模式。主程序负责使MCU在低功耗模式和事件处理程序之间切换,即在主程序中设一个无限循环,系统初始化以后直接进入低功耗模式。MCU被唤醒后,判断各标志是否置位。如果是单一标志置位,那么MCU执行相应的事件处理程序,完成后转入低功耗模式;若是有多个标志同时置位,主程序按照事先排好的消息队列对它们依次判别并进行处理,所有事件处理完毕以后MCU休眠,系统进入低功耗状态(该消息队列的顺序是按照任务的重要性设定的优先级)。在这种前后台系统中,由于主程序是无限循环,就必须关闭看门狗,与其闲置,不如用其定时器的功能作硬件延时。使用MSP430单片机看门狗定时器实现任意时长精确延时,既满足了系统实时低功耗的要求,也弥补了使用无限循环延时的时间难确定和占用CPU时间长的缺点。通过下例,讲解在同一WDT ISR中完成不同时长延时的技巧。

      #pragma vector=WD_r_VECTOR

      interrupt void WDT_Delay(void){

      //看门狗中断服务程序

      if((DelayTime&Delay500ms)==Delay500ms){

      //判断需要500 ms延时的标志是否置位

      static unsigned int n250MS=O;

      n250MS++;

      if(n250MS==2){      //延时250ms×2=500ms

      n250MS=0;      //清零计数器

      DelayTime&=~Delay500ms;//复位标志位

      WDTCTL=WDTHOLD+WDTPW;

      1El&=~WDTlE;//关闭看门狗定时器并禁止其中断

      }

      }

      if((DelayTime&Delay30s)==Delay30s){

      //判断需要的30 s延时标志是否置位

      static unsigned int nS=0;

      nS++;

      if(nS==30){      //延时1 s×30=30 s

      nS=0;      //清零计数器

      DelayTime&=~Delay30s;//复位标志位

      WDTCTL=WDTHOLD+WDTPW;

      IEl&=~WDTlE;  //关闭看门狗定时器并禁止其中断

      }

      }

      }

      如果任务1需要500 ms的延时,只需在需要延时处执行如下语句:

      WDTCTL=WDT_ADLY_250;

      IE┃ =WDTIE;      //①

      DelayTime┃=Delay500ms      //②

      while((DelayTime&Delay500ms)==Delay500ms);  //③

      ①处是配置看门狗工作在定时器模式,WDT每隔250 ms产生一次中断请求。可以根据需要改变时钟节拍,在使用32768 Hz晶振作为时钟源时,可以产生1.9ms、16 ms、250 ms和1000 ms的延时基数。在头文件msp430xl4x.h中,将这4种翻转时间的WDT配置宏定义为:WDT_ADLY_1_9、WDT_ADLY_16、WDT_ADLY_250和WDT_ADLY_1000。如果用DCOCLK作为SMCLK的时钟源,WDT选择SMCLK=1 MHz为时钟源,这样可以有O.064 ms、0.5 ms、8 ms和32 ms延时基数可供使用。

      ②处设置一个标志位,方便WDT ISR判别并进入相应的延时分支。

      ③处一直判别DelayTime标志组中的Delay500ms位,如果处于置位状态,说明所需的延时未到,执行空操作,直到延时时间到,在WDTISR中将Delay500ms复位,跳出while()循环,执行下一条指令。
   
      同理,如果任务2需要30 s延时,通过WDTCTL=WDT_ADLY_1000激活WDT中断,每隔1 s进中断一次,在WDT ISR中判别标志发现是Delay30s置位而不是Delay500ms执行30 s延时程序分支。每中断一次,计数器nS加l,直到计到30,说明30 s延时完成,清零计数器,停止看门狗(WETCTL=WE)THOLD+WDTPW;)可停止产生中断,并复位该延时标志,以通知任务延时时间到,可以执行下面的指令了。
      
      在WDT ISR中可以根据延时基数和计数器的搭配实现任意长度的时间延时。在系统程序设计时,先确定所需的不同延时时间,然后在WDT。ISR中添加相应的延时分支即可。嵌入式实时操作系统μC/OS—II移植于MSP430单片机就是使用看门狗定时器产生时钟节拍的。
      
      对于系统比较简单,只需要单一时长的延时.而又要考虑系统功耗时,介绍另一种使用看门狗定时器中断完成延时的方法。若要延时1 s,则设定WDT每250 ms中断一次。在需要延时处,启动看门狗定时器并允许其中断,系统进入低功耗模式3(共有5种.模式)休眠。在中断服务程序中对延时时间累加,当达到1 s时唤醒CPU,并停止看门狗定时器中断。实例代码如下:

      vold main(vold){

      WDTCTL=WDT_ADT_ADLY_250)

      //启动WDT,每250 ms中断一次

      IEII=WDTIE)//使能看门狗定时器中断

      _BIS_SR(LPM3_bitS+GIE);

      //系统休眠于低功耗模式3,开总中断

      }

      #pragrna vector=WDT_VECTOR

      —interrupt void WDT_Delay(void){  //看门狗中断服务程序

      statlc unsigned charn=4;

      if(一一n==O){      //延时4×250 ms=1 s

      —BlC_SR_IRQ(LPM3_blts);

      //将CPU从低功耗模式3唤醒

      WDTCTL=WDTHOLD+WDTPW:

      IEl&=~WDTIE;)

      //关闭看门狗定时器并禁止其中断

      }
       
      这种方法充分发挥了MSP430系列的超低功耗特性,在等待延时的过程中,CPU不需要一直判断标志位以得知延时结束,而是进入省电模式。等待过程中,只有极短的时间会在中断服务程序中累计时间并进行判断。可以根据需要设置CPU进入不同的低功耗模式LPMx。如果系统使用了多种外设中断,并在其他中断服务程序中也有唤醒CPU的语句,这种方法便不再适用了。
      
      μs级延时不宜使用硬件延时,因为频繁的进出中断会使CPU用大量时间来响应中断和执行中断返回等操作。硬件延时的方法适用于ms级以上的长时间延时。 

      2  软件延时 

      在对数字温度传感器DS18820的操作中,用到的延时有:15 μs、90μs、270 μs、540 μs等。这些延时短暂,占用CPU时间不是太多,所以比较适合软件延时的方法。通过汇编语言编写的程序,很容易控制时间,我们知道每条语句的执行时间,每段宏的执行时间及每段子程序加调用的语句所消耗的时间。因此,要用C语言编制出较为精确的延时程序,就必须研究该段C程序生成的汇编代码。
   
      循环结构延时:延时时间等于指令执行时间与指令循环次数的乘积,举例来讲,对如下延时程序进行实验分析。

      void delay(unsigned int time){

      while(time一一){};
      
      在main()中调用延时函数delayr(n);得到的延时时间是多少,需要在MSP430单片机的集成编译环境IAR Em—bedded Wclrkbeneh IDE 3.10A中编制测试。
      
      使用C430写好一段可执行代码,在其中加入延时函数,并在主函数中调用,以delay(1OO)为例。设置工程选项Options,在Debugger栏中将Drivet选为Simulator,进行软件仿真。在仿真环境C—SPY Debugger中,从菜单View中调出Disassembly和Register窗口,前者显示编程软件根据C语言程序编译生成的汇编程序,在后者窗口中打开CPU Register子窗体,观察指令周期计数器CYCLE—COUNTER。可以看到,delay()编译得到如下代码段:

      delav:

      001112  OF4C mov.w R12,R15

      OOlll4  0C4F mov.w  R15.R12

      001116      3C53  add.w  #0xFFFF.R12

      001118  0F93  tst.w  R15

      00111A  FB23  jne      deIay
      
      单步执行,观察CYCI正COUNTER,发现每执行一条指令,CYCLECOUNTER的值加1,说明这5条指令各占用1个指令周期,循环体while()每执行一次需要5个指令周期,加上函数调用和函数返回各占用3个指令周期,delay(100)延时了5×100+6—506个指令周期。只要知道指令周期,就能容易的计算出延时时长了。延时函数因循环语句和编译器的不同,执行时间也有所不同,依照上述方法具体分析,可以达到灵活编程的目的。
      
      MSP430的指令执行速度即指令所用的周期数,这里的时钟周期指主系统时钟MCLK的周期。单片机上电后,如果不对时钟系统进行设置,默认800 kHz的DCOCLK为MCLK和SMCLK的时钟源,LFXTl接32768 Hz晶体,工作在低频模式(XTS=O)作为ACLK的时钟源。CPU的指令周期由MCLK决定,所以默认的指令周期就是1/800 kHz=1.25μs。要得到lμs的指令周期需要调整DCO频率,即MCLK=1 MHz,只需进行如下设置:BCSCTLl=XT20FF+RSEL2;

      //关闭XT2振荡器,设定DCO频率为1 MHz

      DCOCTL=DCO2

      //使得单指令周期为lμs
   
      并不是说MSP430单片机软件延时最小的延时基准是lμs,当开启XT2=8 MHz高频振荡器,指令周期可以达到125 ns。MSP430F4XX系列的单片机由于采用了增强型锁频环技术FLL+,可以将DCO频率倍增到40MHz,从而得到最快25 ns的指令周期。
  
      调用延时函数的方法适合于100 μs~1 ms之间的延时,100μs以下的短延时最好通过空操作语句_NoP()或其任意个组合来实现。可使用宏定义实现需要的延时,如要延时3 μs,则:

      #define DELAY5US{_NOP();_NOP();_NOP();} 

      结语 

      本文提出的基于MSP430片内看门狗定时器的硬件延时方案和软件延时方法满足了不同时宽级别的延时需求,尤其软件延时,采用汇编程序分析法得到了延时函数准确的延时时间,大大提高了软件延时精确度和程序调试效率,并在多种芯片接口程序中应用,运行效果良好。

点击此处查看原文 >>

系统分类: 软件开发   |    用户分类:    |    来源: 无分类

评论(0) | 阅读(125)
发表于:2008-5-18 11:22:23
标签:无标签

0

利用Keil Cx51实现T0的精确定时

利用89C51设计一个简易日历时钟系统,时钟系统硬件主要由单片机控制的计时电路、复位等辅助电路、按键电路、数码管显示电路、电源系统等组成。日历时钟可以显示年、月、时、分、秒;可以设置年、月、时、分。其中计时控制电路由AT89C51单片机控制;按键电路包含时间设置;时间显示屏电路由7个数码管组成;电源系统由小功率整流滤波稳压电路组成,输出直流电压5 V,向主电路及显示电路供电。系统框图如图1所示。

    在计时过程中,系统利用89C51自身的计时器T0作为时钟基准,计时器中断的准确度直接关系到整个系统的精度,因此获取精确的定时时钟信号成为该系统的关键。MCS-51单片机内有2个可编程的16位定时器/计数器,在本系统设计中采用AT89C51的定时器T0,并工作在方式l下,晶振频率为12MHz。

1 T0定时中断
    定时器/计数器T0工作方式1的电路逻辑结构如图2所示。TO定时特性功能寄存器由TL0(低8位)和TH0(高8位)构成。特殊功能寄存器TMOD控制定时寄存器的工作方式;TCON则用于控制定时器T0和T1的启动和停止计数,同时管理定时器TO和T1的溢出标志等。程序开始时需对TL0和TH0进行初始化编程,以定义它们的工作方式,并控制T0和T1的计数。在系统的设计中,计时单位以s为基准,并要求日误差≤10 s,如果用循环去做,无法满足精度要求。选用12 MHz的晶体可得到lμs的精度,经分析确定使用定时器0的方式l。这个方式下 定时器0是16位定时器,也就是最大定时值为jFFFFH,12 MHz晶体的每个定时周期为1 μs,最多可以定时FFFFH×1 μs=65635 μs,即使使用最大值也无法一次定时1 s,设计中使用1次定时20 ms,50次定时中断得到1 s。20 ms定时中断的定时值为:FFFFH-20 ms/l μs=B1DFH[1]. 

2 程序测试与调整
在Keil uVision3平台下利用C语言实现如下代码:
#include<reg52.h>
#define uehar unsigned char
uehar data MScond="0"; //ms
uchar data Scond="0"; //s
uchar data Minure="0"; //rain
uchar data Hollr="0"; //h
void main(void){
EA=1; //允许CPU中断
ET0=1; //定时器0中断打开
TMOD=0xl; //设定时器0为方式1
TH0=0xBl:
TL0=0xDF~ //设定时值为20 000 μs(20 ms)
TR0=1; //开始定时
while(1);
}
void Time0(void)interrupt 1 using 1
{TH0=0xBl; //20 ms断点 (1)
TL0=0xDF; //设定时值
MScond=MScond+1 ;
if(MScond==50)
{MScond=0;
Scond=Scond+1;
if(Seond==60)
{Scond=0;
Minute=Minute+1; //分断点 (2)
if(Minute==60)
{Minute=0;
Hour=Hour+1; //d,时断点 (3)
if(Hour==24)
{Hour=0;}}}}

    首先调试每20 ms中断时的精度,在选项中设定调试晶振为12 MHz,在(1)处设置一个断点再运行,这时记录下每次中断时的时间,如图3所示。在初始化中费时为551 μs,每一次中断时间应该考虑该项的影响。在实际处理中可以利用两次中断时间的差来作为定时器的中断时间间隔。

点击看大图

    通过测试,得到第一次为0.020 568 00 s,第二次为0.040 580 00 s,第三次为0.060 59Z 00 s。可以看出,每中断一次会比定时值长了12 μs。如果将断点设定在(2)处,并通过Logic Analyzer tool,得到分钟第一次中断的时间为60.036 57 s,第二次中断的时间为120.072 57 s,则每分钟的实际时间为60.036 s。再将断点设定在(3)处,得到小时第一次中断的时间为3 602.160 576 s,第二次中断的时间为7 204.320 576 s,可以得到小时的实际时间为3 602.16 s,如图4所示。

点击看大图


    为什么会产生这些误差呢?通过对中断程序的汇编源码进行分析,实际上中断程序入堆栈时使用了两条语句:PUSH ACC和PUSH PSW。执行人栈指令花费了4个机器周期,加上重新对TH0和TL0的加载又用去2个机器周期,计数值加1花费了2个机器周期,中断返回约4个机器周期共约12个机器周期。为了消除这些因素的影响,需要在对T0设置计数值时减去12个机器周期,将计算得到的初始值B1DFH加上12(0CH)得到:B1DFH+12=B1EBH作为新的定时器初值,修改后的程序为:
#include<reg52.h>
#define uchar unsigned char
uchar data MScond="0";//ms
uehar data Seond="0"; //s
uchar data Minute:0; //rain
uchar data Hour="0"; //h
void main(void){
EA=1; //允许CPU中断
ET0=1; //定时器0中断打开
TMOD=Oxl; //设定时器0为方式1
TH0=0xBl;
TL0=OxEB; //设定时值为20 000 μs(20 ms)减去12 μs
TR0=1; //开始定时
while(1);
void Time0(void)interrupt 1 using 1
{TH0=0xBl; //20 ms断点 (1)
TL0=0xDF‘ //设定时值
MSeond=MScond+1:
if(MSeond==50)
{MScond=0;
Seond=Seond+1 ;
if(Scond==60)
{Scond=0;
Minute=Minute+1;//分断点 (2)
if(Minute==60)
{Minure=0;
Hour=Hour+1; I/d,时断点 (3)
if(Hour==24)
{Hour=0;}}}}

    重新调试程序,仍然在选项中设定调试晶振为12 MHz,重新测试20 ms定时器的实际时间,在(1)处设置一个断点后运行,重新记录下每次中断时的时间,如图5所示。初始化时间为556 μs,为消除其影响,使用两次中断时间间隔来作为定时器实际获得的基准时钟。

点击看大图


    得到第一次中断时的时间为0.020 556。O s,第二次为O.040 556 000 s,第三次为0.060 556。O s,可以看出每次中断间隔刚好20 ms。如果将断点设定在(2)处,并通过Logle Analyzer tool,得到第一次中断时时间为60.000 57 s,第二次为120.000 57 s,间隔刚好60 s。将断点设定在(3)处,得到第一次中断的时间为3 600.000 578 s,第二次中断时间为7 200.000 578 s,时间间隔为3 600 s,测试结果如图6所示,完全可以满足系统设计的需要。

点击看大图

3 总结
    通过对定时器的误差分析和校正,可以提高系统的精确度。当然,上面的分析是在软环境下理想晶振频率下实现的,在现实中会因晶振偏差等因素而造成误差[2]。在该测试中,主程序没有进行其他处理,而在日历设计中还要涉及到计时器T1的中断来完成对扫描显示电路的处理,还包括外部中断对时钟进行了调整,加上一些闹钟功能,这必然会对T0的定时精确性产生影响。另外,当中断程序中语句越多,占用的机器周期也越多,因此在设计中应充分利用Keil uVIsion3的分析工具,通过多次调整计数初值以获取精确的时钟信号,这对于要求精确时钟信号的应用具有重要的意义。

点击此处查看原文 >>

系统分类: 软件开发   |    用户分类:    |    来源: 转贴

评论(0) | 阅读(128)
发表于:2008-5-16 17:23:37
标签:无标签

1

一种简捷、可靠、廉价的贴片元件焊接方法——拉焊


说明: 本文是参考《电子产品环境适应与可靠性》——电装工艺(贴片焊接)(挑战者2003年8月著)一文和其他网友提供的焊接方法,同时结合自己的实践写出来的。我从网上学到很多东西,也很乐意把自己的一点经验拿出来和大家一起分享,如有不足之处请大虾们指点,多谢!

一 工具
1 普通温控烙铁(最好带ESD保护)
2 酒精
3 脱脂棉
4 镊子
5 防静电腕带
6 焊锡丝
7 松香焊锡膏
8 放大镜
9 吸锡带(选用)
10 注射器(选用)
11 洗板水(选用)
12 硬毛刷(选用)
13 吹气球(选用)
14 胶水(选用)

说明:
1 电烙铁的烙铁头不一定要很尖的那种,但焊接的时候一定要将烙铁头擦干净再用。温控烙铁的焊台上有海绵,倒点水让海绵泡起来,供擦烙铁头用。
2 防静电腕带据挑战者的说法可以用优质导线代替。我的做法是: 将2米左右同轴电缆的两头剥皮露出里面的铜芯,铜芯长度约25厘米。剥皮的时候不要破坏同轴电缆的屏蔽铜线,将屏蔽铜线压扁可以代替吸锡带用!
3 买不到松香焊锡膏的话,也可以将固体松香溶解到酒精中代替。
4 焊锡丝不必很细,1.0mm的即可。以前以为焊锡丝要很细就买了0.5mm的,现在觉得用这种方法没有必要。
5 放大镜最小为4倍,头戴式和台式都可以,我用的是台式放大镜(里面带日光灯)。
6 吹气球的具体名字我不太清楚,我用的是带尖嘴的橡皮小球,用来使酒精快速蒸发。


二 操作步骤
1 将脱脂棉团成若干小团,大小比IC的体积略小。如果比芯片大了焊接的时候棉团会碍事。
2 用注射器抽取一管酒精,将脱脂棉用酒精浸泡,待用。
3 电路板不干净的话,先用洗板水洗净。将电路板焊接芯片的地方涂上一点点胶水,用于粘住芯片。
4 将自制的防静电导线戴到拿镊子的那只手腕上,另一端放于地上。用镊子(最好不要用手直接拿芯片)将芯片放到电路板上,目视将芯片的引脚和焊盘精确对准,目视难分辨时还可以放到放大镜下观察有没有对准。电烙铁上少量焊锡并定位芯片(不用考虑引脚粘连问题),定为两个点即可(注意:不是相邻的两个引脚)。
5 将适量的松香焊锡膏涂于引脚上,并将一个酒精棉球放于芯片上,使棉球与芯片的表面充分接触以利于芯片散热。
6 擦干净烙铁头并蘸一下松香使之容易上锡。给烙铁上锡,焊锡丝融化并粘在烙铁头上,直到融化的焊锡呈球状将要掉下来的时候停止上锡,此时,焊锡球的张力略大于自身重力。
7 将电路板倾斜放置,倾斜角度大于70度,小于90度,倾斜角度太小不利于焊锡球滚下。在芯片引脚未固定那边,用电烙铁拉动焊锡球沿芯片的引脚从上到下慢慢滚下,同时用镊子轻轻按酒精棉球,让芯片的核心保持散热;滚到头的时候将电烙铁提起,不让焊锡球粘到周围的焊盘上。至此,芯片的一边已经焊完,按照此方法在焊接其他的引脚。
8 用酒精棉球将电路板上有松香焊锡膏的地方擦干净,可以用硬毛刷蘸上酒精将芯片的引脚之间的松香刷干,可以用吹气球加速酒精蒸发。
9 放到放大镜下观察有没有虚焊和粘焊的,可以用镊子拨动引脚看有没有松动的(注意防静电,要带上防静电腕带)。其实熟练此方法后,焊接效果不亚于机器!(挑战者)

说明:
1 电路板倾斜靠在某个东西上,并不要让电路板滑动,不要用手拿着倾斜,不然的话就没有空手去按动酒精棉球了。

三 几种焊接方法的比较
1 点焊:需要用比较尖的烙铁头对着每个引脚焊接,对电烙铁的要求较高,而且焊接速度慢,还有可能虚焊和粘焊。

2拖焊:比点焊速度快,个人感觉焊接效果没有拉焊好,有时候引脚上的焊锡不均匀,
而且可能会粘焊。
3 拉焊:需要的工具都很一般,特别是电烙铁,在焊接过程中烙铁头并没有接触焊盘而是焊锡球。由于焊锡球的张力,各个引脚上的焊锡很均匀且不多,很美观!速度嘛,熟练以后相对拖焊要快一点。此方法可谓是一种简捷可靠而又廉价的焊接方法!

四小结
根据实践,个人认为此方法很适合超密间距贴片元件的焊接。对于像SO这类引脚间距相对大一点的芯片,似乎引脚上会有点锯齿点,可能是我操作不熟练的缘故吧。我是先拿我的44B0开发板上MAX202-SO8做实验的,然后用此方法焊接了PDIUSBD12, HY29LV160, HY57V641620效果都很好。44B0芯片还没到啊。

点击此处查看原文 >>

系统分类: 模拟技术   |    用户分类:    |    来源: 转贴

评论(3) | 阅读(170)
发表于:2008-1-7 20:44:56
标签:无标签

0

Keil和Proteus之间的通信设置

如何在keil中调用proteus进行MCU外围器件的仿真!
         proteus 6.9以前的版本
  1、安装keil c51 与 proteus
  2、把proteus安装目录下MODELS文件夹里 VDM51.dll文件复制到Keil安装目录的 \C51\BIN
   目录中。
  3、修改keil安装目录下 Tools.ini文件,在C51字段加入TDRV5=BIN\VDM51.DLL
   ("Proteus VSM Monitor-51 Driver"),保存
   注意:不一定要用TDRV5,根据原来字段选用一个不重复的数值就可以了。引号内的
   名字随意~
  4、打开proteus,画出相应电路(这个自己摸索吧。注意:proteus中mouse的左右键与
   一般程序是相反的样子)。在proteus的tools菜单中选中use remote debug monitor
  5、在keil中编写MCU的程序(keil不会,那先学学吧,比medwin难学些哦!)。
  6、进入KEIL的project菜单option for target '工程名'。在DEBUG选项中右栏上部的下
   拉菜选中 Proteus VSM Monitor-51 Driver
   在进入seting,如果同一台机IP 名为127.0.0.1,如不是同一台机则填另一
   台的IP地址。端口号一定为8000
   注意:可以在一台机器上运行keil,另一台中运行proteus进行远程仿真哦~
  7、在keil中进行debug吧,同时在proteus中查看直观的结果(如LCD显示…) 
 
        proteus 6.9以后的版本
 

proteus 7.12与 keil 8.0的联调方法
    对于proteus 6.9以后的版本,在安装盘里或LABCENTER公司有vdmagdi插件,安装该插件即可实现与KEIL的联调。
    首先安装vdmagdi软件,然后再进行以下设置:

Keil设置
    在Keil软件上单击“Project菜单/Options for Target”选项或者点击工具栏的“option for ta rget”按钮 ,弹出窗口,点击“Debug”按钮,出现如图所示页面。
点击看大图 
在出现的对话框里在右栏上部的下拉菜单里选中“Proteus VSM Monitor-51 Driver”。并且还要点击一下“Use”前面表明选中的小圆点。再点击“Setting”按钮,设置通信接口,在“Host”后面添上“127.0.0.1”,如果使用的不是同一台电脑,则需要在这里添上另一台电脑的IP地址(另一台电脑也应安装Proteus)。在“Port”后面添加“8000”。设置好的情形如图所示,点击“OK”按钮即可。最后将工程编译,进入调试状态,并运行。  

Proteus的设置
进入Proteus的ISIS,鼠标左键点击菜单“Debug”,选中“use romote debuger monitor”,如图所示。此后,便可实现KeilC与Proteus连接调试。
 

点击此处查看原文 >>

系统分类: 软件开发   |    用户分类:    |    来源: 转贴

评论(0) | 阅读(507)
发表于:2008-1-7 20:42:06
标签:无标签

0

Proteus 自建元件库

一、Proteus VSM仿真模型简介

    在使用Proteus仿真单片机系统的过程中,经常找不到所需的元件,这就需要自己编写。Proteus VSM的一个主要特色是使用基于DLL组件模型的可扩展性。这些模型分为两类:电气模型(Electrical Model)和绘图模型(Graphical Model)。电气模型实现元件的电气特性,按规定的时序接收数据和输出数据;绘图模型实现仿真时与用户的交互,例如LCD的显示。一个元件可以只实现电气模型,也可以都实现电气和绘图模型。
    Proteus为VSM模型提供了一些C++抽象类接口,用户创建元件时需要在DLL中实现相应的抽象类。VSM模型和Proteus系统通信的原理如下图: 
点击看大图0 && image.height>0){if(image.width>=510){this.width=510;this.height=image.height*510/image.width;}}" border="0"> 

绘图模型接口抽象类:

ICOMPONENT――ISIS内部一个活动组件对象,为VSM模型提供在原理图上绘图和用户交互的服务。
IACTIVEMODEL――用户实现的VSM绘图模型要继承此类,并实现相应的绘图和键盘鼠标事件处理。

电气模型接口抽象类:

IINSTANCE――一个PROSPICE仿真原始模型,为VSM模型提供访问属性、模拟节点和数据引脚的服务,还允许模型通过仿真日志发出警告和错误信息。
ISPICECKT(模拟)――SPICE拥有的模拟元件,提供的服务:访问、创建和删除节点,在稀疏矩阵上分配空间,同时还允许模型在给定时刻强制仿真时刻点的发生和挂起仿真。
ISPICEMODEL(模拟)――用户实现的VSM模拟元件要继承此类,并实现相应的载入数据,在完成的时间点处理数据等。
IDSIMCKT(数字)――DSIM拥有的数字元件,提供的服务:访问数字系统的变量,创建回调函数和挂起仿真。
IDSIMMODEL(数字)――用户实现的VSM数字元件要继承此类,并实现相应的引脚状态变化的判断和回调事件的处理。
IDSIMPIN(数字)――数字组件的引脚,提供检测引脚状态和创建输出事务事件的服务。
IDBUSPIN(数字)――数字组件的数据或地址总线,提供检测总线状态和创建总线输出事务事件的服务。
IMIXEDMODEL(混合)――同时继承了ISPICEMODEL 和 IDSIMMODEL,元件既有模拟特性,又有数字特性。

       为了让Proteus访问用户模型中的成员函数,必须创建用户模型的一个实例。这不能通过类的接口来实现,只能通过从DLL中导出几个C函数来实现,在用户模型中必须实现这些C函数,达到构造和析构用户模型实例的效果。

(1)构造和析构绘图模型实例:
IACTIVEMODEL *createactivemodel (CHAR *device, ILICENCESERVER *ils)
VOID deleteactivemodel (IACTIVEMODEL *model)

(2)构造和析构模拟电气模型实例:
ISPICEMODEL *createspicemodel (CHAR *device, ILICENCESERVER *ils)
VOID deletespicemodel (ISPICEMODEL *model)

(3)构造和析构数字电气模型实例:
IDSIMMODEL *createdsimmodel (CHAR *device, ILICENCESERVER *ils)
VOID deletedsimmodel (IDSIMMODEL *model)

(4)构造和析构混合电气模型实例:
IMIXEDMODEL *createmixedmodel (CHAR *device, ILICENCESERVER *ils)
VOID deletemixedmodel (IDSIMMODEL *model)

二、Proteus VSM仿真模型开发流程
1.绘制元件图形、引脚和相关符号。
2.制作元件,设置元件属性。
3.用C++编写元件,实现电气和绘图模型,编译生成DLL。
4.搭建电路仿真测试。

三、VSM模型开发实例
下面以TG19264A点阵式液晶显示元件的开发为实例详细讲解开发过程。

1.打开Proteus,选择菜单 查看>>Snap 10 th,选择左边绘图工具栏的2D graphics box,绘制如图所示的三个图形。


点击看大图0 && image.height>0){if(image.width>=510){this.width=510;this.height=image.height*510/image.width;}}" border="0"> 

2.选择2D graphics line,给出两条直线,设置width为36th,颜色为灰色。选择2D graphics circle,给四个角绘制安装孔。选择Markers for component origin,给三个图形分别绘图符号原点(图中红色部分)。


点击看大图0 && image.height>0){if(image.width>=510){this.width=510;this.height=image.height*510/image.width;}}" border="0"> 

3.选择Device pin,顺时针旋转90度,放置20个引脚,如图所示。GND、VCC、V0、Vee、LED+的电气类型选择PP-Power Pin,D/I、R/W、E、CS1、RET、CS2、CS3的电气类型选择IP-Input,D0~D7的电气类型选择IO- Bidirectional。


点击看大图0 && image.height>0){if(image.width>=510){this.width=510;this.height=image.height*510/image.width;}}" border="0"> 

 

4.右键拖出选择框选择第一个符号,选择菜单库>>制作符号,命名为LCD19264A_C,确定。同理,第二和第三个分别命名为LCD19264A_1 和LCD19264A_0。当用户调用drawsymbol (-1),将绘制LCD19264A_C,调用drawsymbol (1),将绘制LCD19264A_1,调用drawsymbol (0),将绘制LCD19264A_0。


点击看大图0 && image.height>0){if(image.width>=510){this.width=510;this.height=image.height*510/image.width;}}" border="0"> 

 

5.右键拖出选择框选择符号LCD19264A_C,选择菜单库>>制作元件,Device Properties设置如图,
点击看大图0 && image.height>0){if(image.width>=510){this.width=510;this.height=image.height*510/image.width;}}" border="0"> 
点击Next>。跳过封装设置,点击Next>。组件属性设置如图,
点击看大图0 && image.height>0){if(image.width>=510){this.width=510;this.height=image.height*510/image.width;}}" border="0"> 
点击看大图

0 && image.height>0){if(image.width>=510){this.width=510;this.height=image.height*510/image.width;}}" border="0"> 
点击Next>。选择数据手册(可选),点击Next>。选择器件库,点击OK。

6.打开VC,新建工程,选择Win32 Dynamic-Link Library,给工程命名,建立空的DLL工程。从Proteus安装目录的INCLUDE文件夹中将VSM.HPP复制到当前工程目录,新建文件 LCD19264A.H和LCD19264A.CPP,编写如下代码。


CODE:

/*****************************************************************
* 文件:LCD19264A.H
* 说明:不支持以下特性
* (1) 不支持显示开关控制
* (2) 不支持设置显示起始行
*****************************************************************/
#i nclude "vsm.hpp"

//LCD常量
#define LCD_BLK_NUM  3  //lcd block number
#define LCD_BLK_LEN  64  //lcd block length
#define LCD_LINE_NUM 8  //lcd line number
#define LCD_LENGTH  (LCD_BLK_LEN*LCD_BLK_NUM)  //lcd length
#define LCD_WIDTH  64  //lcd width
#define BLANK_WIDTH  50  //the width of blank
#define SYM_LINEWIDTH 28  //the width of symbol line
//LCD命令掩码
#define CMD_MASK  0xc0
//LCD命令
#define DISP_ONOFF  0x00 //开关背光
#define SET_STARTLINE 0xc0 //设置起始行
#define SET_XADDRESS 0x80 //设置X地址
#define SET_YADDRESS 0x40 //设置Y地址
//延时常量
#define DELAY_1s  1000000000000
#define DELAY_1ms 1000000000
#define DELAY_1us 1000000
#define DELAY_1ns 1000
#define DELAY_1ps 1

/*
LCD元件既有数字电气特性,也有绘图特性,所以要继承IACTIVEMODEL和IDSIMMODEL
*/
class LCD19264A : public IACTIVEMODEL,public IDSIMMODEL
{
public:
/* 电气模型成员函数 */
//数字电路总是返回TRUE
INT isdigital (CHAR *pinname);
//当创建模型实例时被调用,做初始化工作
VOID setup (IINSTANCE *inst, IDSIMCKT *dsim);
//仿真运行模式控制,交互仿真中每帧开始时被调用
VOID runctrl (RUNMODES mode);

//交互仿真时用户改变按键等的状态时被调用
VOID actuate (REALTIME time, ACTIVESTATE newstate);
//交互仿真时每帧结束时被调用,通过传递ACTIVEDATA数据与绘图模型通信,从而调用animate()进行绘图
BOOL indicate (REALTIME time, ACTIVEDATA *data);
//当引脚状态变化时被调用,主要用来处理数据输入和输出
VOID simulate (ABSTIME time, DSIMMODES mode);
//可通过setcallback()设置在给定时间调用的回调函数
VOID callback (ABSTIME time, EVENTID eventid);

/* 绘图模型成员函数 */
//当创建模型实例时被调用,做初始化工作
VOID initialize (ICOMPONENT *cpt);
//被PROSPICE调用,返回模拟电气模型
ISPICEMODEL *getspicemodel (CHAR *device);
//被PROSPICE调用,返回数字电气模型
IDSIMMODEL *getdsimmodel (CHAR *device);
//当原理图需要重绘时被调用
VOID plot (ACTIVESTATE state);
//当相应的电气模型产生活动事件时被调用,常用来更新图形
VOID animate (INT element, ACTIVEDATA *newstate);
//用来处理键盘和鼠标事件
BOOL actuate (WORD key, INT x, INT y, DWORD flags);
private:
IINSTANCE *instance; //PROSPICE仿真原始模型
IDSIMCKT *ckt;   //DSIM的数字元件
ICOMPONENT *component; //ISIS内部一个活动组件对象
//引脚定义
IDSIMPIN *di; //D/I
IDSIMPIN *rw; //R/W
IDSIMPIN *en; //E
IDSIMPIN *cs1; //CS1
IDSIMPIN *cs2; //CS2
IDSIMPIN *cs3; //CS3
IDSIMPIN *d[8]; //D0~D7
IBUSPIN *databus; //D[0..7]
//LCD参数
BYTE x_addr; //X地址(见手册)
BYTE y_addr; //Y地址(见手册)
BYTE status; //状态(见手册)
BYTE cur_blk; //当前块号(总共分3块,见手册)
BYTE DDRAM[LCD_BLK_NUM][LCD_BLK_LEN*LCD_WIDTH/8]; //LCD显示RAM
BOOL new_flag; //新数据到达标志
//显示参数
BOX lcdarea; //LCD显示区域
float pix_width, pix_height; //每象素对应矩形的宽和高
};


CODE:
/*****************************************************************
* 文件:LCD19264A.CPP
* 说明:不支持以下特性
* (1) 不支持显示开关控制
* (2) 不支持设置显示起始行
*****************************************************************/
#i nclude
#i nclude "LCD19264A.h"
//----------------------------------------------------------------------------
//电气模型的实现
//构造数字电气模型实例
extern "C" IDSIMMODEL __declspec(dllexport) * createdsimmodel (CHAR *device, ILICENCESERVER *ils)
{
//授权认证
ils->authorize(0x88888888, 0x69); //版本为6.9
return new LCD19264A; //创建模型实例
}

//析构数字电气模型实例
extern "C" VOID __declspec(dllexport) deletedsimmodel (IDSIMMODEL *model)
{
delete (LCD19264A *)model; //删除模型实例
}

//数字电路总是返回TRUE
INT LCD19264A::isdigital (CHAR *pinname)
{
return 1;
}

//当创建模型实例时被调用,做初始化工作
VOID LCD19264A::setup (IINSTANCE *inst, IDSIMCKT *dsim)
{
instance = inst; //PROSPICE仿真原始模型
ckt = dsim;  //DSIM的数字元件
//获取引脚
di = instance->getdsimpin("D/I,d/i", true);
di->setstate(FLT); //FLOAT
rw = instance->getdsimpin("R/W,r/w", true);
rw->setstate(FLT);
en = instance->getdsimpin("E,e", true);
en->setstate(FLT);
cs1 = instance->getdsimpin("CS1,cs1", true);
cs1->setstate(FLT);
cs2 = instance->getdsimpin("CS2,cs2", true);
cs2->setstate(FLT);
cs3 = instance->getdsimpin("CS3,cs3", true);
cs3->setstate(FLT);
d[0] = instance->getdsimpin("D0,d0", true);
d[0]->setstate(FLT);
d[1] = instance->getdsimpin("D1,d1", true);
d[1]->setstate(FLT);
d[2] = instance->getdsimpin("D2,d2", true);
d[2]->setstate(FLT);
d[3] = instance->getdsimpin("D3,d3", true);
d[3]->setstate(FLT);
d[4] = instance->getdsimpin("D4,d4", true);
d[4]->setstate(FLT);
d[5] = instance->getdsimpin("D5,d5", true);
d[5]->setstate(FLT);
d[6] = instance->getdsimpin("D6,d6", true);
d[6]->setstate(FLT);
d[7] = instance->getdsimpin("D7,d7", true);
d[7]->setstate(FLT);
//为方便操作,将D0~D7映射为8位总线
databus = instance->getbuspin("LCD_DBUS", d, 8);
databus->settiming(100,100,100); //设置时间延迟
databus->setstates(SHI,SLO,FLT); //设置总线逻辑为[1,0,三态]时的驱动状态

//lcd model
x_addr = 0; //X地址(见手册)
y_addr = 0; //Y地址(见手册)
status = 0; //状态(见手册)
new_flag = TRUE; //新数据到达标志
}

//仿真运行模式控制,交互仿真中每帧开始时被调用
VOID LCD19264A::runctrl (RUNMODES mode)
{
}

//交互仿真时用户改变按键等的状态时被调用
VOID LCD19264A::actuate (REALTIME time, ACTIVESTATE newstate)
{

}

//交互仿真时每帧结束时被调用,通过传递ACTIVEDATA数据与绘图模型通信,从而调用animate()进行绘图
BOOL LCD19264A::indicate (REALTIME time, ACTIVEDATA *data)
{
if(new_flag){ //有新数据到达
  data->type = ADT_REAL; //call back animate() to refresh lcd
  data->realval = (float)time*DSIMTICK;
}
return TRUE;
}

//当引脚状态变化时被调用,主要用来处理数据输入和输出
VOID LCD19264A::simulate (ABSTIME time, DSIMMODES mode)
{
BYTE data;
if(en->isnegedge()){  //E的下降沿到达
  if((rw->istate()==SLO)||(rw->istate()==WLO)){ //R/W为低表示写
   //读块选择
   if((cs1->istate()==SLO)||(cs1->istate()==WLO))
    cur_blk = 0;
   else if((cs2->istate()==SLO)||(cs2->istate()==WLO))
    cur_blk = 1;
   else if((cs3->istate()==SLO)||(cs3->istate()==WLO))
    cur_blk = 2;
   else
    return; //not select block
  
   data = (BYTE)databus->getbusvalue(); //读数据
   if((di->istate()==SHI)||(di->istate()==WHI)){ //D/I为高表示数据
    DDRAM[cur_blk][x_addr*LCD_BLK_LEN+y_addr] = data; //写入数据
    new_flag = TRUE; //新数据到达标志
    y_addr = ((y_addr+1)%LCD_BLK_LEN);  //y地址自动加1
    if(y_addr==0)
     x_addr = ((x_addr+1)%LCD_LINE_NUM); //自动换行
   }else{  //D/I为低表示命令
    switch(data&CMD_MASK)
    {
    case DISP_ONOFF: //开关背光
     break;
    case SET_STARTLINE: //设置起始行
     break;
    case SET_XADDRESS: //设置X地址
     x_addr = (data&0x07); //bit2~bit0
     break;
    case SET_YADDRESS: //设置Y地址
     y_addr = (data&0x3f); //bit5~bit0
     break;
    default:
     break;
    }
   }
  }else{  //E的下降沿到达,R/W为高表示读结束
   databus->drivetristate(time); //驱动总线为三态
  }
}else if(en->isposedge()  //E的上升沿到达
   && ((rw->istate()==SHI)||(rw->istate()==WHI))){ //R/W为高表示读
  if((di->istate()==SHI)||(di->istate()==WHI)){ //D/I为高表示数据
   //读块选择
   if((cs1->istate()==SLO)||(cs1->istate()==WLO))
    cur_blk = 0;
   else if((cs2->istate()==SLO)||(cs2->istate()==WLO))
    cur_blk = 1;
   else if((cs3->istate()==SLO)||(cs3->istate()==WLO))
    cur_blk = 2;
   else
    return; //not select block
   data = DDRAM[cur_blk][x_addr*LCD_BLK_LEN+y_addr];
   databus->drivebusvalue(time, data);  //输出数据
   y_addr = ((y_addr+1)%LCD_BLK_LEN);  //y地址自动加1
   if(y_addr==0)
    x_addr = ((x_addr+1)%LCD_LINE_NUM); //自动换行
  }else{  //D/I为低表示命令
   databus->drivebusvalue(time, status); //输出状态
  }
}
}

//可通过setcallback()设置在给定时间调用的回调函数
VOID LCD19264A::callback (ABSTIME time, EVENTID eventid)
{
}

//----------------------------------------------------------------------------
//绘图模型的实现
// Exported constructor for active component models.
extern "C" IACTIVEMODEL __declspec(dllexport) * createactivemodel (CHAR *device, ILICENCESERVER *ils)
{
ils->authorize (0x88888888,0x69); //6.9
return new LCD19264A;
}

// Exported destructor for active component models.
extern "C" VOID  __declspec(dllexport) deleteactivemodel (IACTIVEMODEL *model)
{
delete (LCD19264A *)model;
}

//当创建模型实例时被调用,做初始化工作
VOID LCD19264A::initialize (ICOMPONENT *cpt)
{
//获取ICOMPONENT接口和初始化
component = cpt;
component->setpenwidth(0);
component->setpencolour(BLACK);
component->setbrushcolour(BLACK);
//获取显示区域
component->getsymbolarea(0,&lcdarea);
//计算每象素对应矩形的宽和高
pix_width = (float)(lcdarea.x2-lcdarea.x1-BLANK_WIDTH*2-SYM_LINEWIDTH*2)/LCD_LENGTH;
pix_height = (float)(lcdarea.y2-lcdarea.y1-BLANK_WIDTH*2-SYM_LINEWIDTH*2)/LCD_WIDTH;
}

//被PROSPICE调用,返回模拟电气模型
ISPICEMODEL *LCD19264A::getspicemodel (CHAR *)
{
return NULL;
}

//被PROSPICE调用,返回数字电气模型
IDSIMMODEL  *LCD19264A::getdsimmodel (CHAR *)
{
return this;
}

//当原理图需要重绘时被调用
VOID LCD19264A::plot (ACTIVESTATE state)
{
//绘制LCD19264A_C元件基本图形
component->drawsymbol(-1);
//刷新LCD数据显示
new_flag = TRUE;
animate (0, NULL);
}

//当相应的电气模型产生活动事件时被调用,常用来更新图形
VOID LCD19264A::animate (INT element, ACTIVEDATA *data)
{
BOX pix;
BYTE dat,block,line,byte_off,bit_off;
if(new_flag){ //当有新数据到达
  new_flag = FALSE;
  component->begincache (lcdarea); //打开缓冲
  component->drawsymbol(1);  //显示LCD19264_1符号
  //显示各点数据
  for(block=0; block   for(line=0; line    for(byte_off=0; byte_off     dat = DDRAM[block][line*LCD_BLK_LEN+byte_off]; //get byte data
     for(bit_off=0; bit_off<8; bit_off++){
      if(dat&(1<       pix.x1 = (int)(BLANK_WIDTH+(block*LCD_BLK_LEN+byte_off)*pix_width+0.5);
       pix.y1 = -(int)(BLANK_WIDTH+(line*8+bit_off)*pix_height+0.5);
       pix.x2 = pix.x1 + (int)(pix_width+0.5);
       pix.y2 = pix.y1 - (int)(pix_height+0.5);
       component->drawbox(pix); //绘制1个象素点
      }
     }
    }
   }
  }
  component->endcache(); //结束缓冲,显示数据
}
}

//用来处理键盘和鼠标事件
BOOL LCD19264A::actuate (WORD key, INT x, INT y, DWORD flags) 
{
return FALSE;
}

7.搭建电路如下电路,新建Keil C工程,编写代码测试元件。如下图:
点击看大图0 && image.height>0){if(image.width>=510){this.width=510;this.height=image.height*510/image.width;}}" border="0">

点击此处查看原文 >>

系统分类: 软件开发   |    用户分类:    |    来源: 转贴

评论(5) | 阅读(696)
发表于:2008-1-5 13:59:36
标签:IO口扫键  

0

绝对经典的“IO口扫键”法

堪称一绝的“IO口扫键”法

在做项目(工程)的时候,我们经常要用到比较多的按键,而且IO资源紧张,于是我们就想方设法地在别的模块中节省IO口,好不容易挤出一两个IO口,却发现仍然不够用,实在没办法了就添加一个IC来扫键。一个IC虽然价格不高,但对于大批量生产而且产品利润低的厂家来说,这是一笔不菲的开支!
那,我们能不能想到比较好的扫键方法:用最少的IO口,扫最多的键?可以吗?
举个例:给出5个IO口,能扫多少键?有人说是2*3=6个,如图一:   

点击在新窗口查看全图
                                   图一
对,大部分技术参考书都这么做,我们也经常这样做:用3个IO口作行扫描,2个IO作列检测(为方便描述,我们约定:设置某一IO口输出为“0”――称其为“扫某IO口”)。用行线输出扫键码,列线检测是否有按键的查询方法进行扫键。扫键流程:在行线依次输出011,101,110扫键值,行线每输出一个扫键值,列线检测一次。当列线检测到有按键时,结合输出的扫键值可以判断相应的按键。
但是,5个IO真的只能扫6个键吗?有人说可以扫9个,很聪明!利用行IO与地衍生3个键(要注意上拉电阻),如图二:
点击在新窗口查看全图
                          图二
扫键流程:先检测3个行IO口,对K1’,K2’,K3’进行扫键,之后如上述2*3扫键流程。5个IO口能扫9个键,够厉害吧,足足比6个键多了1/2!
动动脑,还能不能再多扫几个?就几个?一个也行!好,再想一下,硬是被逼出来了!如图三:
点击在新窗口查看全图
                                      图 三
不多不少,正好10个键!这种扫键方式比较少见吧!漂亮!扫键流程:设IO1输出为“0”,检测IO2…IO5,若判断有相应健按下,则可知有健;若无键,则继续扫键:设IO2输出为“0”,检测IO3,IO4,IO5,判断有无键按下,如此类推。这里应注意:当扫某一IO口(输出为“0”)时,不要去检测已经扫过的IO口。如:此时设置IO2输出为“0”,依次检测IO3,IO4,IO5,但不要去检测IO1,否则会出错(为什么,请思考)。
感觉怎么样?不错吧!让我们再看看图三,好有成就感!看着,看着……又看到了什么?快!见图四:
点击在新窗口查看全图
                               图四
真强!被您看出20个键!多了一个对称的三角形。可是,像这样的排列能正确扫20个键吗?回答是肯定的:不能!上下三角形相互对称,其对称扫出的键无法区别。有没有注意到分析图三时提到的注意点?(à“当扫某IO口时,不要去检测已经扫过的IO口,否则会出错”)
我们分析一下图四:当IO1输出“0”时,按下K11或K11’键都能被IO2检测到,但IO2检测却无法区别K11和K11’键!同理,不管扫哪个IO口,都有两个对称的键不能区分。
我们假想,如果能把对称键区分开来,我们就能正常地去判断按键。我们在思考:有没有单向导通性器件?有!见图五!
点击在新窗口查看全图
                    图 五

很巧妙的思路!利用二极管的单向导通性,区别两个对称键。扫键思路:对逐个IO口扫键,其他四个IO口可以分别检测其所在的四个按键。这样,就不会有分析图三时提到的注意点。
够酷吧!等等,大家先别满足现状,我们再看一下图二,是不是有点启发?对,我们再分析一下“用5个IO口对地衍生的5个键”。看图六:
   点击在新窗口查看全图
                                   图   六
25个键!5个IO口扫出25个键!先别激动,我们再分析一下它的可行性,分析通得过才能真正使用。假设扫键流程:先扫对地的5个键,再如图五扫键。先扫对地5个键,判断没有按键,接着对逐一对IO口进行扫键。但当对某一IO口扫键时,如果有对地的键按下,这时有可能会误判按键,因为对地键比其他键有更高的响应优先级。例如:扫IO1,IO1输出“0”,恰好此时K62按下,IO2检测到有按键,那就不能判断是K11还是K62。我们可以在程序上避免这种按键误判:若IO2检测到有按键,那下一步就去判断是否有对地键按下,如果没有,那就可以正确地判断是K11了。
我们小结扫键个数S:
S = (N-1)*N + N ――启用二极管
S = (N-1)*N /2 + N ――省掉二极管
           
经典吗?太经典了!!告诉大家一个小道消息:第一个设计出此电路的人是一个美国大佬,他(她?)还为此申请了专利!

点击此处查看原文 >>

系统分类: 模拟技术   |    用户分类:    |    来源: 转贴

评论(1) | 阅读(600)
发表于:2007-10-29 19:56:53
标签:无标签

0

什么是字节对齐,为什么要对齐?

什么是字节对齐,为什么要对齐?

TragicJun 发表于 2006-9-18 9:41:00
现代计算机中内存空间都是按照byte划分的,从理论上讲似乎对任何类型的变量的访问可以从任何地址开始,但实际情况是在访问特定类型变量的时候经常在特定的内存地址访问,这就需要各种类型数据按照一定的规则在空间上排列,而不是顺序的一个接一个的排放,这就是对齐。
    对齐的作用和原因:各个硬件平台对存储空间的处理上有很大的不同。一些平台对某些特定类型的数据只能从某些特定地址开始存取。比如有些架构的CPU在访问一个没有进行对齐的变量的时候会发生错误,那么在这种架构下编程必须保证字节对齐.其他平台可能没有这种情况,但是最常见的是如果不按照适合其平台要求对数据存放进行对齐,会在存取效率上带来损失。比如有些平台每次读都是从偶地址开始,如果一个int型(假设为32位系统)如果存放在偶地址开始的地方,那么一个读周期就可以读出这32bit,而如果存放在奇地址开始的地方,就需要2个读周期,并对两次读出的结果的高低字节进行拼凑才能得到该32bit数据。显然在读取效率上下降很多。

二.字节对齐对程序的影响:

    先让我们看几个例子吧(32bit,x86环境,gcc编译器):
设结构体如下定义:
struct A
{
    int a;
    char b;
    short c;
};
struct B
{
    char b;
    int a;
    short c;
};
现在已知32位机器上各种数据类型的长度如下:
char:1(有符号无符号同)    
short:2(有符号无符号同)    
int:4(有符号无符号同)    
long:4(有符号无符号同)    
float:4    double:8
那么上面两个结构大小如何呢?
结果是:
sizeof(strcut A)值为8
sizeof(struct B)的值却是12

结构体A中包含了4字节长度的int一个,1字节长度的char一个和2字节长度的short型数据一个,B也一样;按理说A,B大小应该都是7字节。
之所以出现上面的结果是因为编译器要对数据成员在空间上进行对齐。上面是按照编译器的默认设置进行对齐的结果,那么我们是不是可以改变编译器的这种默认对齐设置呢,当然可以.例如:
#pragma pack (2) /*指定按2字节对齐*/
struct C
{
    char b;
    int a;
    short c;
};
#pragma pack () /*取消指定对齐,恢复缺省对齐*/
sizeof(struct C)值是8。
修改对齐值为1:
#pragma pack (1) /*指定按1字节对齐*/
struct D
{
    char b;
    int a;
    short c;
};
#pragma pack () /*取消指定对齐,恢复缺省对齐*/
sizeof(struct D)值为7。
后面我们再讲解#pragma pack()的作用.

三.编译器是按照什么样的原则进行对齐的?

    先让我们看四个重要的基本概念:


1.数据类型自身的对齐值:
  对于char型数据,其自身对齐值为1,对于short型为2,对于int,float,double类型,其自身对齐值为4,单位字节。
2.结构体或者类的自身对齐值:其成员中自身对齐值最大的那个值。
3.指定对齐值:#pragma pack (value)时的指定对齐值value。
4.数据成员、结构体和类的有效对齐值:自身对齐值和指定对齐值中小的那个值。
有了这些值,我们就可以很方便的来讨论具体数据结构的成员和其自身的对齐方式。有效对齐值N是最终用来决定数据存放地址方式的值,最重要。有效对齐N,就是表示“对齐在N上”,也就是说该数据的"存放起始地址%N=0".而数据结构中的数据变量都是按定义的先后顺序来排放的。第一个数据变量的起始地址就是数据结构的起始地址。结构体的成员变量要对齐排放,结构体本身也要根据自身的有效对齐值圆整(就是结构体成员变量占用总长度需要是对结构体有效对齐值的整数倍,结合下面例子理解)。这样就不能理解上面的几个例子的值了。
例子分析:
分析例子B;
struct B
{
    char b;
    int a;
    short c;
};
假设B从地址空间0x0000开始排放。该例子中没有定义指定对齐值,在笔者环境下,该值默认为4。第一个成员变量b的自身对齐值是1,比指定或者默认指定对齐值4小,所以其有效对齐值为1,所以其存放地址0x0000符合0x0000%1=0.第二个成员变量a,其自身对齐值为4,所以有效对齐值也为4,所以只能存放在起始地址为0x0004到0x0007这四个连续的字节空间中,复核0x0004%4=0,且紧靠第一个变量。第三个变量c,自身对齐值为2,所以有效对齐值也是2,可以存放在0x0008到0x0009这两个字节空间中,符合0x0008%2=0。所以从0x0000到0x0009存放的都是B内容。再看数据结构B的自身对齐值为其变量中最大对齐值(这里是b)所以就是4,所以结构体的有效对齐值也是4。根据结构体圆整的要求,0x0009到0x0000=10字节,(10+2)%4=0。所以0x0000A到0x000B也为结构体B所占用。故B从0x0000到0x000B共有12个字节,sizeof(struct B)=12;其实如果就这一个就来说它已将满足字节对齐了,因为它的起始地址是0,因此肯定是对齐的,之所以在后面补充2个字节,是因为编译器为了实现结构数组的存取效率,试想如果我们定义了一个结构B的数组,那么第一个结构起始地址是0没有问题,但是第二个结构呢?按照数组的定义,数组中所有元素都是紧挨着的,如果我们不把结构的大小补充为4的整数倍,那么下一个结构的起始地址将是0x0000A,这显然不能满足结构的地址对齐了,因此我们要把结构补充成有效对齐大小的整数倍.其实诸如:对于char型数据,其自身对齐值为1,对于short型为2,对于int,float,double类型,其自身对齐值为4,这些已有类型的自身对齐值也是基于数组考虑的,只是因为这些类型的长度已知了,所以他们的自身对齐值也就已知了.
同理,分析上面例子C:
#pragma pack (2) /*指定按2字节对齐*/
struct C
{
    char b;
    int a;
    short c;
};
#pragma pack () /*取消指定对齐,恢复缺省对齐*/
第一个变量b的自身对齐值为1,指定对齐值为2,所以,其有效对齐值为1,假设C从0x0000开始,那么b存放在0x0000,符合0x0000%1=0;第二个变量,自身对齐值为4,指定对齐值为2,所以有效对齐值为2,所以顺序存放在0x0002、0x0003、0x0004、0x0005四个连续字节中,符合0x0002%2=0。第三个变量c的自身对齐值为2,所以有效对齐值为2,顺序存放
在0x0006、0x0007中,符合0x0006%2=0。所以从0x0000到0x00007共八字节存放的是C的变量。又C的自身对齐值为4,所以C的有效对齐值为2。又8%2=0,C只占用0x0000到0x0007的八个字节。所以sizeof(struct C)=8.

四.如何修改编译器的默认对齐值?

1.在VC IDE中,可以这样修改:[Project]|[Settings],c/c++选项卡Category的Code Generation选项的Struct Member Alignment中修改,默认是8字节。
2.在编码时,可以这样动态修改:#pragma pack .注意:是pragma而不是progma.

五.针对字节对齐,我们在编程中如何考虑?
    如果在编程的时候要考虑节约空间的话,那么我们只需要假定结构的首地址是0,然后各个变量按照上面的原则进行排列即可,基本的原则就是把结构中的变量按照类型大小从小到大声明,尽量减少中间的填补空间.还有一种就是为了以空间换取时间的效率,我们显示的进行填补空间进行对齐,比如:有一种使用空间换时间做法是显式的插入reserved成员:
         struct A{
           char a;
           char reserved[3];//使用空间换时间
           int b;
}

reserved成员对我们的程序没有什么意义,它只是起到填补空间以达到字节对齐的目的,当然即使不加这个成员通常编译器也会给我们自动填补对齐,我们自己加上它只是起到显式的提醒作用.

六.字节对齐可能带来的隐患:

    代码中关于对齐的隐患,很多是隐式的