读《计算机科学概论》-1. 数据存储-总结

     摘要: 我们首先要学习的是在计算机科学中信息如何编码和存储。第一步，我们要讨论计算机数据存储设备的基础知识，然后进一步研究如何进行信息编码并存储到系统内部。我们还将探讨现如今数据存储系统的各个分支，以及如何用数据压缩、纠错等技术来克服其不足。  阅读全文

posted @ 2012-07-08 22:10 钟谢伟 阅读(1292) | 评论 (0) | 编辑 收藏

【转】static_cast、dynamic_cast、reinterpret_cast和const_cast之间的区别

原文出处

C-style cast举例：

 int i;

 double d;

 i = (int) d;

 

上面的代码就是本来为double类型的d，通过(int)d将其转换成整形值，并将该值赋给整形变量i (注意d本身的值并没有发生改变)。这就是典型的c-style类型转换。

 

下面是一个简单的程序：

#include <iostream>

using namespace std;

 

int main(void)

{

         int i;

         double d = 11.29;

 

         i = (int)d;

         cout << i << endl;

         cout << d << endl;

 

         return 0;

}

输出结果：

11

11.29

 

我们发现d值本身并没有发生任何变化。

 

在简单的情况下，上面这种类型转换可以很好地工作，但在C++中往往还是不够的，为此ANSI-C++新标准定义的四个转换符，即static_cast、dynamic_cast、reinterpret_cast和const_cast。同时在C++环境中，原先的C-Style的类型转换仍旧可以使用。

 

1) static_cast

    用法：static_cast <typeid> (expression)

    说明：该运算符把expression转换为typeid类型，但没有运行时类型检查来确保转换的安全性。

    用途：

    a) 用于类层次结构中基类和派生类之间指针或者引用的转换。up-casting (把派生类的指针或引用转换成基类的指针或者引用表示)是

    安全的；down-casting(把基类指针或引用转换成子类的指针或者引用)是不安全的。

    b) 用于基本数据类型之间的转换，如把int转换成char，这种转换的安全性也要由开发人员来保证。

    c) 可以把空指针转换成目标类型的空指针(null pointer)。

    d) 把任何类型的表达式转换成void类型。

    注意： static_cast不能转换掉expression的const、volitale或者__unaligned属性。

 

2) dynamic_cast

    用法：dynamic_cast <typeid> (expression)

    说明：该运算符把expression转换成typeid类型的对象。typeid必须是类的指针、类的引用或者void*。如果typeid是类的指针类型，

        那么expression也必须是指针，如果typeid是一个引用，那么expression也必须是一个引用。一般情况下，dynamic_cast用

        于具有多态性的类(即有虚函数的类)的类型转换。

 

               dynamic_cast依赖于RTTI信息，其次，在转换时，dynamic_cast会检查转换的source对象是否真的可以转换成target类型，

       这种检查不是语法上的，而是真实情况的检查。先看RTTI相关部分，通常，许多编译器都是通过vtable找到对象的RTTI信息

       的，这也就意味着，如果基类没有虚方法，也就无法判断一个基类指针变量所指对象的真实类型，这时候，dynamic_cast只能

       用来做安全的转换,例如从派生类指针转换成基类指针。而这种转换其实并不需要dynamic_cast参与。也就是说,dynamic_cast

       是根据RTTI记载的信息来判断类型转换是否合法的。

 

   用途：主要用于类层次之间的up-casting和down-casting，还可以用于类之间的交叉转换。在进行down-casting时，dynamic_cast

        具有类型检查的功能，比static_cast更安全。检测在运行时进行。如果被转换的指针不是一个被请求的有效完整的对象指针，

        返回值为NULL。当用于多态类型时，它允许任意的隐式类型转换以及相反过程。不过，与static_cast不同，在后一种情况里

        （注：即隐式转 换的相反过程），dynamic_cast会检查操作是否有效。也就是说，它会检查转换是否会返回一个被请求的有

        效的完整对象。

    注意：dynamic_cast不能转换掉expression的const、volitale或者__unaligned属性。

 

3)   reinterpret_cast

     用法：reinterpret_cast <typeid>(expression)

     说明：转换一个指针为其他类型的指针，也允许将一个指针转换为整数类型，反之亦然。这个操作符能够在非相关的类型之间进行

        转换。操作结果只是简单的从一个指针到别的指针的值的二进制拷贝，在类型之间指向的内容不做任何类型的检查和转换。这

        是一个强制转换。使用时有很大的风险，慎用之。

     注意：reinterpret _cast不能转换掉expression的const、volitale或者__unaligned属性。

 

4)   const_cast

     用法：const_cast<typeid>(expression)

     说明：这个类型操纵传递对象的const属性，或者是设置或者是移除。如：

           Class C{…}

           const C* a = new C;

           C* b = const_cast<C*>(a);

           如果将上面的const_cast转换成其他任何其他的转换，编译都不能通过，出错的信心大致如下：

           “…cannot convert from 'const class C *' to 'class C *'”。

  

     下面的代码是4中casting方法的典型用法示例：

     #include <iostream>

     using namespace std;

 

     class Base

     {

     public:

         int _base;

         virtual void printinfo()

         {

              cout << _base << endl;

         }

     };

 

     class Derived : public Base

     {

     public:

         int _derived;

         virtual void printinfo()

         {

              cout << _derived << endl;

         }

     };

 

     int main(void)

     {

         Base b1;

         Derived d1;

         int aInt = 10;

         long aLong = 11;

         float aFloat = 11.11f;

         double aDouble = 12.12;

 

         Derived* pd = static_cast<Derived*>(&b1);                           // down-casting          不安全

         Base* pb = static_cast<Base*>(&d1);                                   // up-casting                安全

         Derived& d = static_cast<Derived&>(b1);                             // down-casting          不安全

         Base& b = static_cast<Base&>(d1);                                      // up-casting                安全

 

         aInt = static_cast<int>(aFloat);                                                // 基本数据类型转换

         void* sth = static_cast<void*>(&aDouble);                            // 将double指针类型转换成void指针类型

         double* bDouble = static_cast<double*>(sth);                    // 将void指针类型转换成double指针类型

         cout << *bDouble << endl;

 

         Base* pb1 = dynamic_cast<Base*>(&d1);

         //Derived* pd1 = dynamic_cast<Derived*>(&b1);                 // 编译时有warning，运行时出错

 

         int bInt = reinterpret_cast<int>(pb1);                                       // 将地址或指针转换成整数

         cout << bInt << endl;

         pb1 = reinterpret_cast<Base*>(bInt);                                     // 将整数转换成地址或指针

 

         int* cInt = reinterpret_cast<int*>(&aFloat);                             // 这个转换的结果会出乎意料

         cout << (int)*cInt << endl;

 

         const Base* bBase = new Base();

         Base* cBase = const_cast<Base*>(bBase);

         //Base* dBase = dynamic_cast<Base*>(bBase);                // 不能通过编译

         //Base* eBase = static_cast<Base*>(bBase);                     // 不能通过编译

         //Base* fBase = reinterpret_cast<Base*>(bBase);             // 不能通过编译

 

         return 0;

}

posted @ 2012-07-07 10:06 钟谢伟 阅读(1152) | 评论 (1) | 编辑 收藏

【转】详解C中volatile关键字

原文

volatile提醒编译器它后面所定义的变量随时都有可能改变，因此编译后的程序每次需要存储或读取这个变量的时候，都会直接从变量地址中读取数 据。如果没有volatile关键字，则编译器可能优化读取和存储，可能暂时使用寄存器中的值，如果这个变量由别的程序更新了的话，将出现不一致的现象。 下面举例说明。在DSP开发中，经常需要等待某个事件的触发，所以经常会写出这样的程序：
short flag;
void test()
{
do1();
while(flag==0);
do2();
}

    这段程序等待内存变量flag的值变为1(怀疑此处是0,有点疑问,)之后才运行do2()。变量flag的值由别的程序更改，这个程序可能是某个硬件中 断服务程序。例如：如果某个按钮按下的话，就会对DSP产生中断，在按键中断程序中修改flag为1，这样上面的程序就能够得以继续运行。但是，编译器并 不知道flag的值会被别的程序修改，因此在它进行优化的时候，可能会把flag的值先读入某个寄存器，然后等待那个寄存器变为1。如果不幸进行了这样的 优化，那么while循环就变成了死循环，因为寄存器的内容不可能被中断服务程序修改。为了让程序每次都读取真正flag变量的值，就需要定义为如下形 式：
volatile short flag;
    需要注意的是，没有volatile也可能能正常运行，但是可能修改了编译器的优化级别之后就又不能正常运行了。因此经常会出现debug版本正常，但是 release版本却不能正常的问题。所以为了安全起见，只要是等待别的程序修改某个变量的话，就加上volatile关键字。

volatile的本意是“易变的”
      由于访问寄存器的速度要快过RAM，所以编译器一般都会作减少存取外部RAM的优化。比如：
static int i=0;
int main(void)
{
...
while (1)
{
if (i) do_something();
}
}
/* Interrupt service routine. */
void ISR_2(void)
{
i=1;
}
    程序的本意是希望ISR_2中断产生时，在main当中调用do_something函数，但是，由于编译器判断在main函数里面没有修改过i，因此可 能只执行一次对从i到某寄存器的读操作，然后每次if判断都只使用这个寄存器里面的“i副本”，导致do_something永远也不会被调用。如果变量 加上volatile修饰，则编译器保证对此变量的读写操作都不会被优化（肯定执行）。此例中i也应该如此说明。
    一般说来，volatile用在如下的几个地方：
1、中断服务程序中修改的供其它程序检测的变量需要加volatile；
2、多任务环境下各任务间共享的标志应该加volatile；
3、存储器映射的硬件寄存器通常也要加volatile说明，因为每次对它的读写都可能由不同意义；
另外，以上这几种情况经常还要同时考虑数据的完整性（相互关联的几个标志读了一半被打断了重写），在1中可以通过关中断来实现，2中可以禁止任务调度，3中则只能依靠硬件的良好设计了。
二、volatile 的含义
     volatile总是与优化有关，编译器有一种技术叫做数据流分析，分析程序中的变量在哪里赋值、在哪里使用、在哪里失效，分析结果可以用于常量合并，常量传播等优化，进一步可以死代码消除。但有时这些优化不是程序所需要的，这时可以用volatile关键字禁止做这些优化，volatile的字面含义是易变的，它有下面的作用： 
 1 不会在两个操作之间把volatile变量缓存在寄存器中。在多任务、中断、甚至setjmp环境下，变量可能被其他的程序改变，编译器自己无法知道，volatile就是告诉编译器这种情况。
2 不做常量合并、常量传播等优化，所以像下面的代码：
volatile int i = 1;
if (i > 0) ...
if的条件不会当作无条件真。 
3 对volatile变量的读写不会被优化掉。如果你对一个变量赋值但后面没用到，编译器常常可以省略那个赋值操作，然而对Memory Mapped IO的处理是不能这样优化的。 
    前面有人说volatile可以保证对内存操作的原子性，这种说法不大准确，其一，x86需要LOCK前缀才能在SMP下保证原子性，其二，RISC根本不能对内存直接运算，要保证原子性得用别的方法，如atomic_inc。 
    对于jiffies，它已经声明为volatile变量，我认为直接用jiffies++就可以了，没必要用那种复杂的形式，因为那样也不能保证原子性。 
    你可能不知道在Pentium及后续CPU中，下面两组指令 
inc jiffies 
;;
mov jiffies, %eax
inc %eax
mov %eax, jiffies
作用相同，但一条指令反而不如三条指令快。
三、编译器优化 → C关键字volatile → memory破坏描述符zz

    “memory”比较特殊，可能是内嵌汇编中最难懂部分。为解释清楚它，先介绍一下编译器的优化知识，再看C关键字volatile。最后去看该描述符。 
1、编译器优化介绍 
     内存访问速度远不及CPU处理速度，为提高机器整体性能，在硬件上引入硬件高速缓存Cache，加速对内存的访问。另外在现代CPU中指令的执行并不一 定严格按照顺序执行，没有相关性的指令可以乱序执行，以充分利用CPU的指令流水线，提高执行速度。以上是硬件级别的优化。再看软件一级的优化：一种是在 编写代码时由程序员优化，另一种是由编译器进行优化。编译器优化常用的方法有：将内存变量缓存到寄存器；调整指令顺序充分利用CPU指令流水线，常见的是重新排序读写指令。对 常规内存进行优化的时候，这些优化是透明的，而且效率很好。由编译器优化或者硬件重新排序引起的问题的解决办法是在从硬件（或者其他处理器）的角度看必须 以特定顺序执行的操作之间设置内存屏障（memory barrier），linux 提供了一个宏解决编译器的执行顺序问题。 
void Barrier(void)
     这个函数通知编译器插入一个内存屏障，但对硬件无效，编译后的代码会把当前CPU寄存器中的所有修改过的数值存入内存，需要这些数据的时候再重新从内存中读出。 
2、C语言关键字volatile 
     C语言关键字volatile（注意它是用来修饰变量而不是上面介绍的__volatile__）表明某个变量的值可能在外部被改变，因此对这些变量的 存取不能缓存到寄存器，每次使用时需要重新存取。该关键字在多线程环境下经常使用，因为在编写多线程的程序时，同一个变量可能被多个线程修改，而程序通过 该变量同步各个线程，例如： 
DWORD __stdcall threadFunc(LPVOID signal)
{
int* intSignal=reinterpret_cast<int*>(signal);
*intSignal=2;
while(*intSignal!=1)
sleep(1000);
return 0;
}
     该线程启动时将intSignal 置为2，然后循环等待直到intSignal 为1 时退出。显然intSignal的值必须在外部被改变，否则该线程不会退出。但是实际运行的时候该线程却不会退出，即使在外部将它的值改为1，看一下对应 的伪汇编代码就明白了： 
mov ax,signal
label:
if(ax!=1)
goto label
     对于C编译器来说，它并不知道这个值会被其他线程修改。自然就把它cache在寄存器里面。记住，C 编译器是没有线程概念的！这时候就需要用到volatile。volatile 的本意是指：这个值可能会在当前线程外部被改变。也就是说，我们要在threadFunc中的intSignal前面加上volatile关键字，这时 候，编译器知道该变量的值会在外部改变，因此每次访问该变量时会重新读取，所作的循环变为如下面伪码所示： 
label:
mov ax,signal
if(ax!=1)
goto label
3、Memory 
      有了上面的知识就不难理解Memory修改描述符了，Memory描述符告知GCC： 
1）不要将该段内嵌汇编指令与前面的指令重新排序；也就是在执行内嵌汇编代码之前，它前面的指令都执行完毕
2）不要将变量缓存到寄存器，因为这段代码可能会用到内存变量，而这些内存变量会以不可预知的方式发生改变，因此GCC插入必要的代码先将缓存到寄存器的变量值写回内存，如果后面又访问这些变量，需要重新访问内存。
     如果汇编指令修改了内存，但是GCC 本身却察觉不到，因为在输出部分没有描述，此时就需要在修改描述部分增加“memory”，告诉GCC 内存已经被修改，GCC 得知这个信息后，就会在这段指令之前，插入必要的指令将前面因为优化Cache 到寄存器中的变量值先写回内存，如果以后又要使用这些变量再重新读取。 
     使用“volatile”也可以达到这个目的，但是我们在每个变量前增加该关键字，不如使用“memory”方便。

posted @ 2012-07-07 09:57 钟谢伟 阅读(1004) | 评论 (0) | 编辑 收藏

wxWidget实现连续绘图并能够控制绘图的开始与结束

     摘要: 在用CCD相机拍照的图像进行实时成像的时候遇到这么一个问题: 1: RunCamera(); 2: while (1) { 3: GetImg(); 4: ShowImg(); 5: } 6: CloseCamera(); 想要对获取的图像进行实时成像，最先想到的是采用while(1)的方式，但是这样的方式会带来一些问题，除了终止程序，没有办法使得循环...  阅读全文

posted @ 2012-07-06 11:17 钟谢伟 阅读(1516) | 评论 (0) | 编辑 收藏

codelite悲剧了

拾起才一个月的时间，codelite在今晚这个时候开机突然间无法打开了，开启了后在任务管理器中会出现codelite，然后过一会儿就自动消失了，悲剧呀，算了还是用code::block了，最讨厌的是莫名奇妙的错误，让人不知所措诶

posted @ 2012-07-05 19:44 钟谢伟 阅读(404) | 评论 (1) | 编辑 收藏

CCD camera类设计及简易实现

     摘要: 上一篇文章中介绍了关于CCD camera实现的一般流程CCD camera的一般控制流程及些许困惑，现在想用类来实现这个过程。该类设计以及实现的目的是用于相机拍照，成像，存储。目前仅考虑拍照与实时成像两个过程。由于从简单上进行设计，实现的一般流程中的一些步骤能够省略。具体代码如下： 1: // ccd_class.h 2: class CCDClass 3: { 4: pri...  阅读全文

posted @ 2012-07-04 11:16 钟谢伟 阅读(1012) | 评论 (0) | 编辑 收藏

CCD camera的一般控制流程及些许困惑

1. 声明变量

PCO_General        strGeneral;

PCO_CameraType strCamType;

PCO_Sensor         strSensor;

PCO_Description   strDescription;

PCO_Timing         strTiming;

PCO_Storage       strStorage;

PCO_Recording    strRecording;

2. 设置变量大小

strGeneral.wSize = sizeof(strGeneral);
strGeneral.strCamType.wSize = sizeof(strGeneral.strCamType);
strCamType.wSize = sizeof(strCamType);
strSensor.wSize = sizeof(strSensor);
strSensor.strDescription.wSize = sizeof(strSensor.strDescription);
strSensor.strDescription2.wSize = sizeof(strSensor.strDescription2);
strDescription.wSize = sizeof(strDescription);
strTiming.wSize = sizeof(strTiming);
strStorage.wSize = sizeof(strStorage);
strRecording.wSize = sizeof(strRecording);

3. 打开相机，填写变量结构

PCO_OPENCAMERA(&hCam, iBoardNumber)

PCO_GETGENERAL(hCam, &strGeneral)

PCO_GETCAMERATYPE(hCam, &strCamType)

PCO_GETSENSORSTRUCT(hCam, &strSensor)

PCO_GETCAMERADESCRIPTION(hCam, &strDescription)

PCO_GETTIMINGSTRUCT(hCam, &strTiming)

PCO_GETRECORDINGSTRUCT(hCam, &strRecording)

4. 设置相机相关参数，曝光时间，触发模式，ROI区域大小等

5. arm the camera使相机准备好

6. 获取图片大小，分配buffer

PCO_GETSIZES(hCam, &actualsizex, &actualsizey, &ccdsizex, &ccdsizey)

PCO_ALLOCATEBUFFER(hCam, &bufferNr, actualsizex*actualsizey*sizeof(WORD), &data, &hEvent)

其中bufferNr是buffer的编号，actualsizex*actualsizey*sizeof(WORD)为data的大小，data用来存储图片数据。

7. 开始进行记录，并将图片数据添加到指定的buffer中

PCO_SetRecordingState(hCam,0x0001);

PCO_AddBufferEx(hCam,0,0,bufferNr,actualsizex,actualsizey,bitres);

原来不清楚data中的图片数据是怎么获取的，本来想将这个困惑写到这里，不过写着写着突然发现原来如此，它是通过bufferNr来制定第六步中分配相应大小的data的。写博客还是能够把问题给理清楚一点的。

8. 显示图像

这里可以采用原来的文章中提到的方法使用wxWidget中遇到的图片存储问题一二

9. 停止记录

PCO_SetRecordingState(hCam,0x000);

10. 从CamRAM中读取图片

PCO_GetNumberOfImagesInSegment(hCam, wActSeg, &dwValidImageCnt, &dwMaxImageCnt);

PCO_GetImageEx(hCam,wActSeg,dw1swImage,dwLastImage,bufferNr,actualsizex,actualsizey,bitres)

上述函数的应该与AddBufferEx有类似的功能。AddBufferEx直接在记录过程中将数据存储在data中，而GetImageEx是从ccd的寄存器中读取相应的数据赋值到data中。

11. 释放用于存储图像数据的buffer，关闭相机

PCO_FreeBuffer(hCamera,sBufNr）

PCO_CloseCamera(hCamera);

 

上面的过程是获取单个图像的整个流程，如果要连续进行拍摄呢？思考中。。。。。。

posted @ 2012-07-02 17:42 钟谢伟 阅读(1249) | 评论 (0) | 编辑 收藏

小数的存储——选自《计算机科学概论》

这本书对于入门级的人来说是一个不错的选择，它囊括了很多关于计算机方面的知识，能够使你对这方面的知识有个广泛的了解。

对于小数的存储常用的是浮点记数法。

浮点记数法简介

对于知识的掌握，通过例子的学习是一个很好的方式。为了考虑到例子的简易型，用一个字节来存储浮点数。那么如01101011这样的二进制序列表示的是什么小数呢？

一个字节中浮点记数法有如下成分：

image

在01101011这么一个串中，符号位是0表示非负，1则表示负，指数为110，表示位数将乘以2^(指数)，也就是将小数点从尾数位的最左边移动指数个位，如果指数为正，向右移动；反之，向左移动指数位。110是用余码的方式进行记录的。对于余码，我采用的解析的方式是，将最高为取反，按照补码的方式进行读取。

110--->010，表示2；0100--->1100，表示-4；

既然提到了补码，就解释一下补码，最高位为零的补码其值直接读取，0110--->6；最高为为1的补码，其值的读取方式，从右往左遇到第一个1之后的所有位取反，读出值后加个负号，1101--->0011，则-3。当然对于0和最小的负数，不适合上述的方式，但是也很容易就能给出其值。

再让我们回到0,110,1011这个串中，尾数.1011最左断含有一个小数点，由于110--->2，因此小数点向右移动两位则10.11，此时读取值2+1/2+1/4=2又3/4。

至此，我们已经知道小数是如何存储在二进制串中，也知道了如何将其转换为10进制数值，那么该提出注意事项的时候了。

1. 规范化形式

    尾数最左端的一位必须是1，否则会出现多意的现象。如00111100，01000110，都可以解码为3/8。

2. 截断误差

    整型值会出现溢出现象，同样浮点数也会出现类似的现象。如利用一字节浮点记数法存储值2又5/8，先用二进制进行表示10.101，而尾数只有4位，因此会出现截断。

    还有一个需要注意的是浮点记数法表示的数值加法中，它们相加的顺序很重要。

    如，2+1/4+1/8+1/8+1/8+1/8,当到2(5/8)+1/8时，2(5/8)用二进制表示为10.101，这将发生截断，变成10.10，继续加1/8则会持续阶段。当反过来进行加法运算时，则不会出现截断的现象。

 

由于实际浮点数具有较长的位数，能够较好的运用于一般的浮点数运算中。但是这样的问题在一些应用中是很严重的(如航海系统),小的误差在不断的加法运算中累加，最终产生严重的后果，因此对于精度要求较好的运算中，可以选择采用分数表示法，分装一个表示分数的类。

posted @ 2012-06-30 20:50 钟谢伟 阅读(1221) | 评论 (0) | 编辑 收藏

科研级CCD照相机简介（1）——图像显示存储、曝光、触发

工作学习上由于需要编写一个能够控制CCD进行拍照的简易软件，因此需要对CCD照相机的基本原理有一个较为清楚的认识，于是参考DICAM-PRO Operating Instructions写下了这篇文章。

QQ截图20120629201447

上图显示了CCD相机不同的功能模块，其中主要的是Image Intensifier，CCD，12 Bit A/D，parallel/serial Converter，Logic Control。

那么在计算机内部相对应的软件是如何对从CCD相机传输进来的数据进行处理的呢。如下图所示：

image

 

可见对于图片数据进行存储的时候可以采用16bit的形式进行无损存储，但是在pc机的屏幕上进行显示的时候，一般需将16bit的数组转化为8bit的数组，然后采用8bit，24bit或32bit的形式将图形成像到屏幕上。由于屏幕成像的方式是采用RGB或加一个alpha通道进行成像的，即使采用8bit的方式进行成像，也是将其转化成了R=G=B的灰度图进行成像。

下面主要从CCD相机图像增强，曝光、触发方式两个方面进行阐述。

1. 图像增强

image

光子打到光电阴极上产生电子，通过MCP进行增益而后打到荧光粉上发出光。

该处需要注意的是：光子打到光电阴极上与CCD的使用寿命直接相关，另外，不允许强光照射到光电阴极板，这样有可能损坏光电阴极板，从而使CCD相机损坏。由于对光强有一定的要求，因此对于曝光时间也要小心设置，过长的曝光时间也有可能引起光电阴极板的损坏。

2. 曝光、触发

触发模式分为：Single Trigger Mode, Multi Trigger Mode, Double Trigger Mode;

a. single trigger mode

image

系统延时与脉冲延时是硬件上的延时是无法避免的，它们总共的时间在100ns以内，延时时间（Delay）（0-1000s）与曝光（Exposure）（x-1000s，x脉冲时序相关）时间是人为设定的。因为它是单触发模式，每一次触发都带有系统与脉冲上的延迟。在每次循环之间也需要额外的时间。

b. multi trigger mode

image

延迟时间0-999ms，曝光时间在20ns-999ms之间。

c. double trigger mode

image

posted @ 2012-06-29 21:46 钟谢伟 阅读(1580) | 评论 (0) | 编辑 收藏

简易定时器设计

需求：

      要运用番茄时间管理，没有像文中所说的定时器，用手机也怎么方便，因为本身就经常是在计算机前工作学习的。那么下一个软件呢？有那么一款PomoTime，既包含了定时的功能，又含有添加Todolist，统计当天的番茄时间等的功能，而我仅仅需要一个定时功能，因为对于Todolist还是希望采用纸笔的方式进行记录。原来尝试看桌面右下角的时间，还判断一个番茄时间是否结束，发现工作中，往往因为过于集中注意力或分散注意力浏览网页去了而忘记对时间的查看，同时又想将自己所学的知识进行运用，于是想到了这么个方式，自己编写一个简易的定时器吧。

功能描述：

1. 显示分，秒，处于桌面最前面；

2. 设定分，秒；

3. 当设定的时间消耗完后会弹出对话框，进行提醒；

（这里没有采用声音提醒的原因是若采用这种方式，会影响到别人的办公与学习。）

语言选择：

由于这仅仅是一个很简单的功能实现，对于语言没有很大的要求，选择了C++，库为wxWidget。

界面设计：

使用wxFormBuilder

关键点描述：

    在整个过程中遇到的问题的地方时，如何进行倒计时？最先想到的就是onTimer这样类似的功能，在wxWidget库中找到了具有该功能的wxTimer类，在手册中这么一句话 its precision is platform-dependent, but in general will not be better than 1ms nor worse than 1s. 也就是说采用该方法进行时间设定可能每一次都会造成1ms-1s时间上的误差，这个误差不是很大，对于整个的设计目的并没有太大的影响。

    全部源码在Simple timer source code

    关于时间处理的部分代码如下：

   1: // timer_app.h
   2: ////////////////////////////////////////////////////////////////////////////////
   3: // main application frame declaration
   4: ////////////////////////////////////////////////////////////////////////////////
   5:  
   6: class TimerFrame : public MainDialogBase
   7: {
   8: public:
   9:     TimerFrame( wxWindow *parent );
  10:     virtual ~TimerFrame();
  11:  
  12: protected:
  13:     // protected event handlers
  14:     virtual void OnCloseDialog( wxCloseEvent& event );
  15:     virtual void OnSetButtonClick( wxCommandEvent& event );
  16:     virtual void OnStartButtonClick( wxCommandEvent& event );
  17:     
  18: public:
  19:     void OnTimer( wxTimerEvent& event );
  20:     
  21: private:
  22:     int m_minute;
  23:     int m_second;
  24:     wxTimer *m_clock;
  25:     wxDECLARE_EVENT_TABLE();    
  26: };
  27:  
  28: // timer_app.cpp
  29: // event list, combine timer event with OnTimer function
  30: wxBEGIN_EVENT_TABLE(TimerFrame, MainDialogBase)
  31: EVT_TIMER(TIMER_ID, TimerFrame::OnTimer)
  32: wxEND_EVENT_TABLE()
  33:  
  34: //......some code......
  35:  
  36: TimerFrame::TimerFrame(wxWindow *parent) : MainDialogBase( parent )
  37: {
  38:     m_clock = new wxTimer();               // create a new wxTimer
  39:     m_clock->SetOwner(this, TIMER_ID);     // set owner, #define TIMER_ID 1000
  40:     m_minute = 25;
  41:     m_second = 0;
  42: }
  43:  
  44: //......some code......
  45:  
  46: // count down the time and show
  47: void TimerFrame::OnTimer(wxTimerEvent& event)
  48: {
  49:     // determine the minute and second wait to show
  50:     if (m_second == 0 && m_minute == 0) {
  51:         m_clock->Stop();
  52:         wxMessageBox(wxT("Time over"),wxT("Timer"));
  53:         return;
  54:     } else if (m_second ==0) {
  55:         m_second = 59;
  56:         m_minute -= 1;
  57:     } else {
  58:         m_second -= 1;
  59:     }
  60:     wxString sTmp;
  61:     sTmp.Printf(wxT("%d"),m_minute);
  62:     m_minuteTextCtrl->SetValue(sTmp);
  63:     sTmp.Printf(wxT("%d"),m_second);
  64:     m_secondTextCtrl->SetValue(sTmp);
  65: }
  66: 

posted @ 2012-06-28 15:35 钟谢伟 阅读(1428) | 评论 (3) | 编辑 收藏

仅列出标题
共4页: 1 2 3 4 
<2024年11月>
日一二三四五六
272829303112
3456789
10111213141516
17181920212223
24252627282930
1234567

导航

统计

常用链接

留言簿(1)

随笔档案

IT网站

My Friends

搜索

最新评论

阅读排行榜

评论排行榜