Funny – 第 82 页 – WWW.LAB-Z.COM

用示波器“看” arduino (2)

有一个网友提出一个问题“现在要进行一个0.4us的延时，发现不管怎么调都只能调到15us，根本达不到要求，我用的芯片是MEGA32U4-AU，外部晶振是16MHz，求见解！！！！！”
我试验了一下，最终的程序如下：

const int PinA =  13;      
void setup() {
  pinMode(PinA, OUTPUT);
  digitalWrite(PinA,LOW);
}

void loop() {
  PORTB = B100000; //digitalWrite(PinA,HIGH); 
  PORTB = B000000; //digitalWrite(PinA,LOW);  
    for (long zdelay=0;zdelay<9; zdelay++) {
    __asm__("nop\n\t");
  }
  PORTB = B100000; //digitalWrite(PinA,HIGH);
  PORTB = B000000; //digitalWrite(PinA,LOW);
  PORTB = B100000; //digitalWrite(PinA,HIGH);  
  PORTB = B000000;  //digitalWrite(PinA,LOW);  
}

这个程序运行之后的波形如下

可以看到中间的延时差不多有4.1331us（我用游标对齐，右下角显示x=4.1331）. 让然这个值中还包括了一个拉GPIO的指令周期，大约会有 62.1ns的影响。此外，如果要求特别精确，在使用时还要考虑周期性中断的影响。这里就不说了…….

下面我们继续实验，尝试找到循环次数和实际delay时间的关系（因为涉及到编译器优化， long int的计算和判断，直接尝试计算机器周期不可行）。
首先尝试zdelay<8，测量结果是3.7013us

根据上述值结合循环简单猜测一下，对于这个循环体，固定部分耗时0.2469us （比如给变量赋初始值），循环部分每次耗时0.4318us
就是 T= 0.2469 + n *0.4318
根据这个计算循环zdelay<5应该是 2.4059us测量结果是2.3722us 加入我们打算delay 100us 根据上述公式应该循环 231次代码：

const int PinA =  13;      
void setup() {
  pinMode(PinA, OUTPUT);
  digitalWrite(PinA,LOW);
}

void loop() {
  PORTB = B100000; //digitalWrite(PinA,HIGH); 
  PORTB = B000000; //digitalWrite(PinA,LOW);  
  
  for (long zdelay=0;zdelay<231; zdelay++) {
    __asm__("nop\n\t");
  }

  PORTB = B100000; //digitalWrite(PinA,HIGH);
  PORTB = B000000; //digitalWrite(PinA,LOW);
  PORTB = B100000; //digitalWrite(PinA,HIGH);  
  PORTB = B000000;  //digitalWrite(PinA,LOW);  
}

实际测试结果符合理论…….

最后，“极客工坊”的 sanyouhi 朋友指出，精确延时可以用写好的库来直接完成【参考1】

#define F_CPU 16000000
#include <util/delay.h>

void setup()
{
  DDRB = 0X20;
}

void loop()
{
PORTB = 0X20;
_delay_us(0.4);
PORTB = 0;
}

对应的头文件在 \arduino-1.6.3\hardware\tools\avr\avr\include\util\delay.h 有机会的时候再研究一下。

后记，比较有意思，如果我把代码写为下面的形式

const int PinA =  13;      
void setup() {
  pinMode(PinA, OUTPUT);
  digitalWrite(PinA,LOW);
}

void loop() {
  PORTB = B100000; //digitalWrite(PinA,HIGH); 
  for (long zdelay=0;zdelay<17; zdelay++) {
  }
  PORTB = B000000; //digitalWrite(PinA,LOW);  
  PORTB = B100000; //digitalWrite(PinA,HIGH);
  PORTB = B000000; //digitalWrite(PinA,LOW);
  PORTB = B100000; //digitalWrite(PinA,HIGH);  
  PORTB = B000000;  //digitalWrite(PinA,LOW);  
}

中间delay 的周期和不写 for 循环是相同的，猜测原因是编译器的自动优化，当编译器发现空循环时会自动移除循环代码。

参考：

1.http://www.geek-workshop.com/thread-24982-1-1.html

用示波器“看” arduino (1)

实验设备是一块 Arduino Uno 16M （是那种没有品牌的兼容版）,示波器是 Teledyne Lecory Wave Runner 606Zi 600Mhz 20GS/s。

第一个实验：只使用DigitalWrite 能制造出来的最大频率是多少？

首先试试最通用的 digitalWrite 的方法不断在高低之间反转

const int PinA =  13;      

void setup() {
  pinMode(PinA, OUTPUT);
  digitalWrite(PinA,LOW);
}

void loop() {
  digitalWrite(PinA,HIGH);
  digitalWrite(PinA,LOW);
  digitalWrite(PinA,HIGH);
  digitalWrite(PinA,LOW);
  digitalWrite(PinA,HIGH);  
  digitalWrite(PinA,LOW);  
  delay(500);
}

使用示波器抓图如下（下面的所有介绍都是具体解说在上，抓取波形在下）：
我们设置的Delay 是500ms, 然后示波器的水平方向每一格也是500ms，垂直方向是电压，当前选择每格2V，因此看起来差不多是5v左右，符合预期。

我选择了了Stop功能，放大波形进行查看。可以看到，最上面波形中黄色竖线实际上是一组波形，就是对应我们的拉高拉低。

示波器有测量功能，直接调用该功能进行测试：可以看到幅度是4.946V，示波器还标记出来具体的测试方法，这在测量一些不是那么“规整”的波形时非常有用。

再用示波器自动测量一下频率：是100kHz。

可以在菜单中选择测试的具体方法（比如，测试频率通用的方法是波形上升沿50%的位置）

再测量周期（其实给出来了频率，周期是可以直接换算出来的）

结论：如果我们用 DigitalWrite拼命上下拉，最高是可以输出100Khz频率的。

之后，我们再试试使用PortB赋值直接拉出来的频率是多少？关于 PortB 指令可以在【参考1】看到。

const int PinA =  13;      
void setup() {
  pinMode(PinA, OUTPUT);
  digitalWrite(PinA,LOW);
}

void loop() {
  PORTB = B100000; //digitalWrite(PinA,HIGH); 
  PORTB = B000000; //digitalWrite(PinA,LOW);  
  PORTB = B100000; //digitalWrite(PinA,HIGH);
  PORTB = B000000; //digitalWrite(PinA,LOW);
  PORTB = B100000; //digitalWrite(PinA,HIGH);  
  PORTB = B000000;  //digitalWrite(PinA,LOW);  
  
  delay(500);
}

看起来下面波形感觉畸变比较严重（这里：解释一下，前面图看起来平滑的原因是采样时间导致的。比如，我的示波器单位时间可以采样500个点，如果我采样1s，放大之后，在1ms范围内只有5个点。如果我直接采样1ms，那么会有500个点来描绘波形，看起来自然“平滑”得多）

测试幅度，会达到5.248v

同样，使用自带功能测试频率：惊人的 7.99590Mhz

因为一个周期里面实际上是有两条指令的（拉上拉下），已经非常接近主芯片的16Mhz了。

根据上面的结果引申的问题：如何同时拉高两个Port？

首先我们尝试一下 DigitalWrite的方法

const int PinA =  13;      
const int PinB =  8;   
void setup() {
  pinMode(PinA, OUTPUT);
  digitalWrite(PinA,LOW);
  
  pinMode(PinB, OUTPUT);
  digitalWrite(PinB,LOW);  
}

void loop() {
  digitalWrite(PinA,HIGH);
  digitalWrite(PinB,HIGH);
  digitalWrite(PinA,LOW);
  digitalWrite(PinB,LOW);
  
  delay(500);
}

下图可以看到，注意我设置两个信号起始电压不同，为了观测方便，所以会一个上一个下

放大之后查看

为了方便观看，我设置他们电压起点相同，可以看出他们差不多有1个水平格子的差别（5us）。对于这个差异可以在【参考2】初步了解一下。

再尝试PortB 直接赋值的方法

const int PinA =  13;      
const int PinB =  8;   
void setup() {
  pinMode(PinA, OUTPUT);
  digitalWrite(PinA,LOW);
  
  pinMode(PinB, OUTPUT);
  digitalWrite(PinB,LOW);  
}

void loop() {
  
  PORTB = B100001; //digitalWrite(PinA,HIGH); digitalWrite(PinB,HIGH);  
  PORTB = B000000; //digitalWrite(PinA,LOW); digitalWrite(PinB,LOW); 

  delay(500);
}

结果上可以看作是同时发出的

再放大查看，纠缠在一起，，波形上的细微差别可能是外围电路导致的。

补记：为了比对，额外实验 DFrobot 的 RomeoBLEV1.0 的板子为了看得清楚，修改程序如下，去掉了 delay

const int PinA =  13;      
void setup() {
  pinMode(PinA, OUTPUT);
  digitalWrite(PinA,LOW);
}

void loop() {
  PORTB = B100000; //digitalWrite(PinA,HIGH); 
  PORTB = B000000; //digitalWrite(PinA,LOW);  
  PORTB = B100000; //digitalWrite(PinA,HIGH);
  PORTB = B000000; //digitalWrite(PinA,LOW);
  PORTB = B100000; //digitalWrite(PinA,HIGH);  
  PORTB = B000000;  //digitalWrite(PinA,LOW);  
}

先看大范围的，每组3次上升，每组之间的间隔是void loop() { } 中的代码导致的

振幅上和之前的板子差不多 5.13v左右，实际多测试几次也会出现 5.2v。看起来由品牌的板子和无品牌的板子在这方便没有差别。

参考：

1.关于Port x的说明https://www.arduino.cc/en/Reference/PortManipulation

PORTD maps to Arduino digital pins 0 to 7

DDRD – The Port D Data Direction Register – read/write
PORTD – The Port D Data Register – read/write
PIND – The Port D Input Pins Register – read only
PORTB maps to Arduino digital pins 8 to 13 The two high bits (6 & 7) map to the crystal pins and are not usable

DDRB – The Port B Data Direction Register – read/write
PORTB – The Port B Data Register – read/write
PINB – The Port B Input Pins Register – read only
PORTC maps to Arduino analog pins 0 to 5. Pins 6 & 7 are only accessible on the Arduino Mini

DDRC – The Port C Data Direction Register – read/write
PORTC – The Port C Data Register – read/write
PINC – The Port C Input Pins Register – read only

同样，这篇文章中提到了如何同时拉Pin 的方法

Sometimes you might need to set multiple output pins at exactly the same time. Calling digitalWrite(10,HIGH); followed by digitalWrite(11,HIGH); will cause pin 10 to go HIGH several microseconds before pin 11, which may confuse certain time-sensitive external digital circuits you have hooked up. Alternatively, you could set both pins high at exactly the same moment in time using PORTB |= B1100;

2. Arduino 代码机制 http://blog.csdn.net/pinbodexiaozhu/article/details/42641273

Step to UEFI (66） —– Decompress的使用

这里介绍一下解压缩 EFI_DECOMPRESS_PROTOCOL 的使用。

首先是 GetInfo 函数【参考1】。通过它我们能够获得压缩文件的一些基本信息，比如：解压后的大小，解压过程需要的临时内存空间的大小。

之后就是具体的解压函数 Decompress 【参考2】

根据上面的信息，编写一个简单的测试程序，首先将压缩格式的文件读取到内存中，再使用 GetInfo 取得必要的信息，最后，根据必须要的信息创建内存 Buffer ，使用 Decompress 解压即可。

代码如下

#include  <Uefi.h>
#include  <Library/UefiLib.h>
#include  <Library/ShellCEntryLib.h>
#include <Protocol/Decompress.h>
#include <Library/BaseMemoryLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Protocol/EfiShell.h>
#include <Library/ShellLib.h>

extern EFI_BOOT_SERVICES         *gBS;
extern EFI_SYSTEM_TABLE			 *gST;
extern EFI_RUNTIME_SERVICES 	 *gRT;

int
EFIAPI
main (
  IN int Argc,
  IN CHAR16 **Argv
  )
{
	EFI_DECOMPRESS_PROTOCOL       *Decompress;
    VOID                          *ImageBuffer=NULL;
	UINT32                        ImageLength=0;
    UINT32                        DestinationSize;
    UINT8                         *Scratch;
    UINT32                        ScratchSize;
    VOID                          *DecompressedImageBuffer=NULL;
    EFI_STATUS                    Status;
	EFI_FILE_HANDLE   			  FileHandle;
	EFI_FILE_INFO     			  *FileInfo = NULL;  
	UINTN  				    	  ReadSize;  
	EFI_HANDLE       			 *HandleBuffer=NULL;
	
    Status = gBS->LocateProtocol (&gEfiDecompressProtocolGuid,
									NULL, (VOID**)&Decompress);

    if (EFI_ERROR (Status)) {
		Print(L"Can't find Decompress Protocol! \n");	
    } else {
			//Open the file given by the parameter
			Status = ShellOpenFileByName(
							Argv[1], 
							(SHELL_FILE_HANDLE *)&FileHandle,
                            EFI_FILE_MODE_READ, 
							0);

			if(Status != RETURN_SUCCESS) {
				Print(L"OpenFile failed!\n");
				return EFI_SUCCESS;
			}//if(Status != RETURN_SUCCESS) {			

			//Get file size	  
			FileInfo = ShellGetFileInfo((SHELL_FILE_HANDLE)FileHandle);	

			//Allocate a memory buffer
			HandleBuffer = AllocateZeroPool((UINTN) FileInfo->FileSize);
			if (HandleBuffer == NULL) {
				return (SHELL_OUT_OF_RESOURCES);   }

			ReadSize=(UINTN) FileInfo-> FileSize;
  
			//Load the whole file to the buffer
			Status = ShellReadFile(FileHandle,&ReadSize,HandleBuffer);
  
			//Close the source file
			ShellCloseFile(&FileHandle);
			
            Status = Decompress->GetInfo (
                                  Decompress,
                                  HandleBuffer,
                                  ReadSize,
                                  &DestinationSize,
                                  &ScratchSize
                                 );
            if (!EFI_ERROR (Status)) {
			  Print(L"[GetInfo] Destination Size %d\n",DestinationSize);					 
			  Print(L"[GetInfo] Scratch Size %d\n",ScratchSize);	
			  
              DecompressedImageBuffer = AllocateZeroPool (DestinationSize);
              if (DecompressedImageBuffer != NULL) {
                Scratch = AllocateZeroPool (ScratchSize);
                if (Scratch != NULL) {
                  Status = Decompress->Decompress(
                                        Decompress,
                                        HandleBuffer,	//Source
                                        ReadSize,	    //Source Size
                                        DecompressedImageBuffer,//Destination
                                        DestinationSize,	//DestinationSize
                                        Scratch,
                                        ScratchSize
                                       );
                  if (!EFI_ERROR (Status)) {
                    ImageBuffer = DecompressedImageBuffer;
                    ImageLength = DestinationSize;
			
					//Create a new file
					Status = ShellOpenFileByName(L"decomp.bmp", 
                               (SHELL_FILE_HANDLE *)&FileHandle,
                               EFI_FILE_MODE_READ |
							   EFI_FILE_MODE_WRITE|
							   EFI_FILE_MODE_CREATE, 
							   0);  
					if(Status != RETURN_SUCCESS) {
						Print(L"CreatFile failed [%r]!\n",Status);
						return EFI_SUCCESS;
					}	
					
					Status = ShellWriteFile(FileHandle,
						&DestinationSize,
						ImageBuffer
						);
			
					//Close the source file
					ShellCloseFile(&FileHandle);
                  } //if (!EFI_ERROR (Status)) {
				  else
					{
						Print(L"Decompress error [%r] \n",Status);	
					}
                  FreePool (Scratch);
                } // if (Scratch != NULL) {
              } //if (ImageBuffer != NULL) {
            } //if (!EFI_ERROR (Status)) {
 			
			else	{
				Print(L"Read compressed file error!\n",ScratchSize);	
			}
			
          } //if (EFI_ERROR (Status)) {
  
  return EFI_SUCCESS;
}

运行结果

完整程序下载

CompTest

特别注意：

1.本文测试使用的压缩文件是 UEFI 下面生成的，具体命令是

eficompress testc.bmp compressed.z

我尝试使用 BaseTools 里面的压缩工具，生成的文件格式会出现不兼容，无法正常解压的情况。

2.根据我自己的理解 Scratch Buffer 是解压过程中解压算法使用的内存区域，不同压缩文件对于这片区域的大小要求不同。

参考：

1. UEFI Spec 2.4 P883
2. UEFI Spec 2.4 P885
3. ShellPkg 中的 EfiDecompress 程序是非常好的参考例子。

Arduino打造USB蓝牙键盘转接器

本文介绍如何使用 Arduino 打造一个设备，能够将你的USB键盘转化为蓝牙键盘。

键盘可以算作PC上最古老的设备了，他的出现使得人类可以用非常简单的方法与电脑进行交互。同样的，由于各种历史原因，键盘也是PC上最复杂，兼容性问题最多的设备之一（类似的还有硬盘，不过从IDE到SATA的进化过程中，标准明确，兼容性问题少多了）。

网上流传着一篇DIY USB键盘转换为无线的文章，非常不幸的是，那篇文章是错误的，很明显的错误是作者认为键盘是单向传输，而实际上传输是双向的。比如，USB每次通讯都需要HOST和SLAVE的参与，即便是PS2键盘的通讯也同样如此。此外，大小写键之类切换是主机端进行控制的。

硬件部分Arduino UNO , USB Host Shield 和 HID 蓝牙芯片。强调一下这里使用的是 HID 蓝牙芯片，并非普通的蓝牙串口透传芯片【特别注意是“蓝牙键盘芯片”也不是“蓝牙条码模块”】。关于这个模块可以参考我在【参考1】中的实验。
硬件连接很简单，USB HOST Shield插在 Arduino上，然后VCC/GND/TX/RX将Arduino 和 HID蓝牙模块连接在一起。

原理：首先，为了通用性和编程简单，我们用USB HOST发送命令把键盘切换到 Boot Protocol 模式下。这样即使不同的键盘，每次发出来的数据也都是统一的格式。然后，我们直接读取缓冲数据就可以解析出按键信息了。最后，将取下来的按键信息（Scan Code）按照HID蓝牙模块的格式要求通过串口送到模块上，主机端就收到了。

上述连接就可以正常工作了，但是为了美观和提高可靠性，我找到之前买的一个面包板Shield。

插好之后就是这样

具体代码：

/* MAX3421E USB Host controller LCD/keyboard demonstration */
//#include <Spi.h>
#include "Max3421e.h"
#include "Usb.h"

/* keyboard data taken from configuration descriptor */
#define KBD_ADDR        1
#define KBD_EP          1
#define KBD_IF          0
#define EP_MAXPKTSIZE   8
#define EP_POLL         0x0a
/**/
//******************************************************************************
//  macros to identify special charaters(other than Digits and Alphabets)
//******************************************************************************
#define BANG        (0x1E)
#define AT          (0x1F)
#define POUND       (0x20)
#define DOLLAR      (0x21)
#define PERCENT     (0x22)
#define CAP         (0x23)
#define AND         (0x24)
#define STAR        (0x25)
#define OPENBKT     (0x26)
#define CLOSEBKT    (0x27)

#define RETURN      (0x28)
#define ESCAPE      (0x29)
#define BACKSPACE   (0x2A)
#define TAB         (0x2B)
#define SPACE       (0x2C)
#define HYPHEN      (0x2D)
#define EQUAL       (0x2E)
#define SQBKTOPEN   (0x2F)
#define SQBKTCLOSE  (0x30)
#define BACKSLASH   (0x31)
#define SEMICOLON   (0x33)
#define INVCOMMA    (0x34)
#define TILDE       (0x35)
#define COMMA       (0x36)
#define PERIOD      (0x37)
#define FRONTSLASH  (0x38)
#define DELETE      (0x4c)
/**/
/* Modifier masks. One for both modifiers */
#define SHIFT       0x22
#define CTRL        0x11
#define ALT         0x44
#define GUI         0x88
/**/
/* "Sticky keys */
#define CAPSLOCK    (0x39)
#define NUMLOCK     (0x53)
#define SCROLLLOCK  (0x47)
/* Sticky keys output report bitmasks */
#define bmNUMLOCK       0x01
#define bmCAPSLOCK      0x02
#define bmSCROLLLOCK    0x04
/**/
EP_RECORD ep_record[ 2 ];  //endpoint record structure for the keyboard

char buf[ 8 ] = { 0 };      //keyboard buffer
char old_buf[ 8 ] = { 0 };  //last poll
/* Sticky key state */
bool numLock = false;
bool capsLock = false;
bool scrollLock = false;
bool line = false;

void setup();
void loop();

MAX3421E Max;
USB Usb;

void setup() {
  Serial.begin( 9600 );
  Serial.println("Start");
  Max.powerOn();
  delay( 200 );
}

void loop() {
    Max.Task();
    Usb.Task();
    if( Usb.getUsbTaskState() == USB_STATE_CONFIGURING ) {  //wait for addressing state
        kbd_init();
        Usb.setUsbTaskState( USB_STATE_RUNNING );
    }
    if( Usb.getUsbTaskState() == USB_STATE_RUNNING ) {  //poll the keyboard  
        kbd_poll();
    }
}
/* Initialize keyboard */
void kbd_init( void )
{
 byte rcode = 0;  //return code
/**/
    /* Initialize data structures */
    ep_record[ 0 ] = *( Usb.getDevTableEntry( 0,0 ));  //copy endpoint 0 parameters
    ep_record[ 1 ].MaxPktSize = EP_MAXPKTSIZE;
    ep_record[ 1 ].Interval  = EP_POLL;
    ep_record[ 1 ].sndToggle = bmSNDTOG0;
    ep_record[ 1 ].rcvToggle = bmRCVTOG0;
    Usb.setDevTableEntry( 1, ep_record );              //plug kbd.endpoint parameters to devtable
    /* Configure device */
    rcode = Usb.setConf( KBD_ADDR, 0, 1 );                    
    if( rcode ) {
        Serial.print("Error attempting to configure keyboard. Return code :");
        Serial.println( rcode, HEX );
        while(1);  //stop
    }
    /* Set boot protocol */
    rcode = Usb.setProto( KBD_ADDR, 0, 0, 0 );
    if( rcode ) {
        Serial.print("Error attempting to configure boot protocol. Return code :");
        Serial.println( rcode, HEX );
        while( 1 );  //stop
    }
    delay(2000);
    Serial.println("Keyboard initialized");
}

/* Poll keyboard and print result */
/* buffer starts at position 2, 0 is modifier key state and 1 is irrelevant */
void kbd_poll( void )
{
 char i;
 boolean samemark=true;
 static char leds = 0;
 byte rcode = 0;     //return code
    /* poll keyboard */
    rcode = Usb.inTransfer( KBD_ADDR, KBD_EP, 8, buf );
    if( rcode != 0 ) {
        return;
    }//if ( rcode..

    for( i = 2; i < 8; i++ ) {
     if( buf[ i ] == 0 ) {  //end of non-empty space
        break;
     }
      if( buf_compare( buf[ i ] ) == false ) {   //if new key
        switch( buf[ i ] ) {
          case CAPSLOCK:
            capsLock =! capsLock;
            leds = ( capsLock ) ? leds |= bmCAPSLOCK : leds &= ~bmCAPSLOCK;       // set or clear bit 1 of LED report byte
            break;
          case NUMLOCK:
            numLock =! numLock;
            leds = ( numLock ) ? leds |= bmNUMLOCK : leds &= ~bmNUMLOCK;           // set or clear bit 0 of LED report byte
            break;
          case SCROLLLOCK:
            scrollLock =! scrollLock;
            leds = ( scrollLock ) ? leds |= bmSCROLLLOCK : leds &= ~bmSCROLLLOCK;   // set or clear bit 2 of LED report byte

          Serial.write(0x0c);  //BYTE1      
          Serial.write(0x00);  //BYTE2
          Serial.write(0xA1);  //BYTE3
          Serial.write(0x01);  //BYTE4
          Serial.write(00);  //BYTE5          
          Serial.write(0x00);  //BYTE6          
          Serial.write(0x1e);  //BYTE7
          Serial.write(0);  //BYTE8
          Serial.write(0);  //BYTE9
          Serial.write(0);  //BYTE10          
          Serial.write(0);  //BYTE11
          Serial.write(0);  //BYTE12
          delay(500);            
          Serial.write(0x0c);  //BYTE1      
          Serial.write(0x00);  //BYTE2
          Serial.write(0xA1);  //BYTE3
          Serial.write(0x00);  //BYTE4
          Serial.write(0);  //BYTE5          
          Serial.write(0x00);  //BYTE6          
          Serial.write(0);  //BYTE7
          Serial.write(0);  //BYTE8
          Serial.write(0);  //BYTE9
          Serial.write(0);  //BYTE10          
          Serial.write(0);  //BYTE11
          Serial.write(0);  //BYTE12

            break;
          case DELETE:
            line = false;
            break;
          case RETURN:
            line =! line;
            break;  
          //default:
            //Serial.print(HIDtoA( buf[ i ], buf[ 0 ] ));
          //  break;
        }//switch( buf[ i ...

        rcode = Usb.setReport( KBD_ADDR, 0, 1, KBD_IF, 0x02, 0, &leds );
        if( rcode ) {
          Serial.print("Set report error: ");
          Serial.println( rcode, HEX );
        }//if( rcode ...
     }//if( buf_compare( buf[ i ] ) == false ...
    }//for( i = 2...

    i=0;
    while (i<8)
      {
        if (old_buf[i]!=buf[i]) { i=12; }
        i++;
      }
    if (i==13) {
     // for (i=0;i<8;i++) {      
          //  Serial.print(buf[ i ],HEX);
          //  Serial.print(']');      
     //  }  
     // Serial.println(' ');          

          Serial.write(0x0c);  //BYTE1      
          Serial.write(0x00);  //BYTE2
          Serial.write(0xA1);  //BYTE3
          Serial.write(0x01);  //BYTE4
          //Labz_Debug Serial.write(buf[1]);  //BYTE5          
          Serial.write(buf[0]);  //BYTE5     //Labz_Debug
          Serial.write(0x00);  //BYTE6          
          Serial.write(buf[2]);  //BYTE7
          Serial.write(buf[3]);  //BYTE8
          Serial.write(buf[4]);  //BYTE9
          Serial.write(buf[5]);  //BYTE10          
          Serial.write(buf[6]);  //BYTE11
          Serial.write(buf[7]);  //BYTE12
    }  

    //Labz_Debug for( i = 2; i < 8; i++ ) {                    //copy new buffer to old
     for( i = 0; i < 8; i++ ) {                    //copy new buffer to old //Labz_Debug
      old_buf[ i ] = buf[ i ];
    }
}
/* compare byte against bytes in old buffer */
bool buf_compare( byte data )
{
 char i;
 for( i = 2; i < 8; i++ ) {
   if( old_buf[ i ] == data ) {
     return( true );
   }
 }
 return( false );
}

我在处理SCROLLLOCK 键的地方插入了一个测试代码，理论上按下这个键的时候，主机还会收到 1 这个字符，这样是为了测试工作是否正常。
我在 x86 台式机上实测过，工作正常；小米4手机上实测过，工作正常； iPad 上是测过，工作也正常。
在iPad上工作的视频在下面：

完整代码下载

BKC2COM

特别注意：
1. 因为我们使用的是最简单的Boot Protocol，所以如果你的键盘上有音量键之类的有可能失效；
2. 我不确定是否所有的键盘都会支持 Boot Protocol ，从之前玩USB鼠标的经验来看，确实有可能；
3. 供电部分没有经过优化，不知道电力消耗如何，不确定一个充电宝能够工作的时间；

最后讲一个小故事：有一次我去实验室，发现他们在折腾键盘。那是一款带着音量控制功能的键盘。系统测试的时候发现，按一下键盘音量键之后，屏幕上显示的音量会跳2格。从原理上说，按下那个键之后，键盘发出特定的Scan Code，系统中还有个专门响应这个Scan Code的程序然后在屏幕上绘制音量指示方块。蛮有意思的一件事情是：很多人认为大公司有操控供应商的能力，供应商在大厂面前会唯唯诺诺，这也是高层会有的想法，问题是底层人员未必吃这一套。每次想起这个事情，我都要想起敏感字关于矛盾的辩证法的论证。这个事情就是双方的下层在不停的扯，更准确的说，是键盘厂商，软件开发商和我们在一起纠缠，键盘厂商说同样的键盘在其他人家用起来没问题，软件开发商说我的软件在之前的机型上一直用，我们的人说，少扯淡，赶紧解决，前后一个多月都没有搞定…….那时候，组里刚买了一个usb逻辑分析仪，我用着感觉很好玩。于是，我就用逻辑分析仪测试了一下键盘，测试的结果是，键盘发出来的 Scan Code没有问题，每次按键都是一个Press一个Release，所以真相肯定是写上位机程序的软件厂商搞错了什么。截图附带着数据包一起丢给三方。这是最底层的传输，如果依然嘴硬，那只能落下笑柄而已。然后很快软件厂商就服软自己去修改了。只是说说我经历的事情，如果非要说出一些道理的话这个故事是为了说明：USB逻辑分析仪很有用……

就是这样.

=========================2017年5月11日更新=========================
有朋友说 Win ，Shift，Alt 都不工作，今天正好有空研究了一下，是我的代码有问题。解析出来的USB 键盘按键信息中 Buf[0] 是这些Key 的标志位，我没有正确Pass给模块。因此，修正下面2处代码，一个是发送，一个是每次保存当前的按键状态的位置：

          Serial.write(0x0c);  //BYTE1      
          Serial.write(0x00);  //BYTE2
          Serial.write(0xA1);  //BYTE3
          Serial.write(0x01);  //BYTE4
          Serial.write(buf[0]);  //BYTE5          
          Serial.write(0x00);  //BYTE6          
          Serial.write(buf[2]);  //BYTE7
          Serial.write(buf[3]);  //BYTE8
          Serial.write(buf[4]);  //BYTE9
          Serial.write(buf[5]);  //BYTE10          
          Serial.write(buf[6]);  //BYTE11
          Serial.write(buf[7]);  //BYTE12
          
    }  
 
    for( i = 0; i < 8; i++ ) {                    //copy new buffer to old
      old_buf[ i ] = buf[ i ];
    }

修改后可以正常工作的代码：

bkc2com1.1

参考：
1. http://www.lab-z.com/btkeyboard/ 蓝牙键盘模块的实验

蓝牙键盘模块的实验

之前介绍过两种Arduino 模拟键盘的方法，一种是普通的Uno加上电阻之类的元件；一种是使用自带 USB 功能的 Arduino ，比如 Leonardo ,内部集成了USB Slave控制器。这里再介绍蓝牙方案。

我们最常见的就是蓝牙透传模块，用蓝牙搜索安装之后能在系统中模拟出来一个串口，上位机直接按照串口方式即可进行通讯。这次介绍一款蓝牙键盘模块（实际上是键盘鼠标模块）。

外观和普通蓝牙透传模块一样（蓝牙芯片真正有用的都是内部Firmware）

用法非常类似，在蓝牙中搜索连接之后系统中会出现键盘设备。

然后数据是从串口送到蓝牙设备中的。根据说明我用 Arduino 编写了一个简单的测试程序，每隔5秒发送 “1” 字符。

输入 1：
按下数据 1 数据包为： 0C 00 A1 01 00 00 1E 00 00 00 00 00
按键弹起： 0C 00 A1 01 00 00 00 00 00 00 00 00

程序如下：

char KeyPress[]={0x0C,0x00,0xA1,0x01,0x00,0x00,0x1E,0x00,0x00,0x00,0x00,0x00};
char KeyRelease[]={0x0C,0x00,0xA1,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
void setup() {
  // put your setup code here, to run once:
    Serial1.begin(9600);      //设置串口波特率
}

void loop() {
   for (byte i=0;i<sizeof(KeyPress);i++)
    {
     Serial1.write(KeyPress[i]);
    } 
   for (byte i=0;i<sizeof(KeyRelease);i++)
    {
     Serial1.write(KeyRelease[i]);
    }
  delay(5000);  
}

测试结果，每隔5秒我的电脑上就可以收到一个 1 的输入。

更多的好玩还在研究中。有模拟键盘需要的朋友不妨考虑这样的蓝牙模块，顺便说一下，这种模块在35元左右，比普通透传模块贵多了（通常20左右）。当然，你可以看看国外类似的产品，Adafruit出品的“EZ-Key BT HID Keyboard Controller纸模块”价格在180元，感觉就不那么贵了……

==================================================================
2016年3月13日更新
我一直以为在文章中放出来过购买链接，昨天有朋友问检查了一下才发现我忘记了。~~这个模块的购买链接是 https://item.taobao.com/item.htm?spm=a1z09.2.0.0.V7mzul&id=521222818182&_u=dkf8s9fbec~~
卖家名字是 “重庆翔码电子工厂店”。买的时候你不妨问一下卖家，说你要做蓝牙HID设备，这个和普通常用的蓝牙串口透传模块之类的是不同的。
再放一下这个模块的说明书：BTHID

特别注意：之前我一直以为蓝牙键盘模块和蓝牙扫描枪模块是同一个东西，结果有朋友买成了“蓝牙扫描枪模块”，结果无法使用。他们之间的差别在于，键盘模块可以发送 shift/alt/ctrl 等等。蓝牙扫描枪模块只能发送可见的 ascii。
所以一定要询问清楚（估计是当时我和卖家说了，然后虽然拍下的是蓝牙扫描枪模块，但是给我的是蓝牙键盘模块）。

攀藤 G3

之前一直在使用攀藤 G1 ，前面提到 G1 都坏掉了郁闷无比。然后入手了一个 G3 。之所以还选择攀藤的产品最主要是考虑尽可能的复用之前的代码……

下面图是 G1 和 G3 外观，可以看出 G3 要小一点：

数据上和G1稍微有些差别，主要是送出来的数据短了一些。

下面是串口实际获得的数据

具体解读（来自说明书）

最后修改一下之前给 G1 写的 APP 即可

完整的代码
G3Ver1source

编译后的程序
Project2

Processing 做一个输入的文本框

根据网上搜到的结果，在【参考1】下载了 controlP5 的库，然后使用下面的程序

import controlP5.*;

ControlP5 cp5;

String[] textfieldNames = {"tf1", "tf2", "tf3", "tf4", "tf5"};

void setup() {
  size(700,400);

  PFont font = createFont("arial",20);

  cp5 = new ControlP5(this);

  int y = 20;
  int spacing = 60;
  for(String name: textfieldNames){
    cp5.addTextfield(name)
       .setPosition(20,y)
       .setSize(100,40)
       .setFont(font)
       .setFocus(true)
       .setColor(color(255,0,0))
       ;
     y += spacing;
  }

  textFont(font);
}

void draw() {
  background(0);
}

void controlEvent(ControlEvent theEvent) {
  if(theEvent.isAssignableFrom(Textfield.class)) {
    println("controlEvent: accessing a string from controller '"
            +theEvent.getName()+"': "
            +theEvent.getStringValue()
            );
  }
}

运行结果

参考：

1. http://www.sojamo.de/libraries/controlP5/

Step to UEFI (60） —– GUID和UUID

了解了一下 UUID 和 GUID , 资料上来看，这两个是同一个东西。GUID 是 MS 定义的 UUID 的一种实现方法. 两者在写法上稍微有些差别【参考1】【参考2】：

GUID:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx (8-4-4-4-12)

UUID:xxxxxxxx-xxxx-xxxx-xxxxxxxxxxxxxxxx (8-4-4-16)

在 UEFI 中，我们经常看到类似下面的定义

“cf8e16a5-c1e8-4e25-b712-4f54a96702c8”

#define EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID \
{ \
0x964e5b22, 0x6459, 0x11d2, {0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b } \
}

UUID PadFileGuid;

对于 GUID ,可以在 \MdePkg\Include\Base.h 看到下面的定义

///
/// 128 bit buffer containing a unique identifier value.
/// Unless otherwise specified, aligned on a 64 bit boundary.
///
typedef struct {
  UINT32  Data1;
  UINT16  Data2;
  UINT16  Data3;
  UINT8   Data4[8];
} GUID;

同时，在 \MdePkg\Include\Uefi\UefiBaseType.h 有下面的定义

///
/// 128-bit buffer containing a unique identifier value.
///
typedef GUID                      EFI_GUID;

在 \BaseTools\Source\C\Common\CommonLib.c 有一个打印输出的例子可以直接拿出来用


EFI_STATUS
PrintGuid (
  IN EFI_GUID *Guid
  )
/*++

Routine Description:

  This function prints a GUID to STDOUT.

Arguments:

  Guid    Pointer to a GUID to print.

Returns:

  EFI_SUCCESS             The GUID was printed.
  EFI_INVALID_PARAMETER   The input was NULL.

--*/
{
  if (Guid == NULL) {
    Error (NULL, 0, 2000, "Invalid parameter", "PrintGuidToBuffer() called with a NULL value");
    return EFI_INVALID_PARAMETER;
  }

  printf (
    "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x\n",
    (unsigned) Guid->Data1,
    Guid->Data2,
    Guid->Data3,
    Guid->Data4[0],
    Guid->Data4[1],
    Guid->Data4[2],
    Guid->Data4[3],
    Guid->Data4[4],
    Guid->Data4[5],
    Guid->Data4[6],
    Guid->Data4[7]
    );
  return EFI_SUCCESS;
}

最后，写一个输出的例子

#include  <Uefi.h>
#include  <Library/UefiLib.h>
#include  <Library/ShellCEntryLib.h>

#include  <stdio.h>
#include  <stdlib.h>
#include  <wchar.h>

#include <Protocol/EfiShell.h>
#include <Library/ShellLib.h>


extern EFI_BOOT_SERVICES         *gBS;
extern EFI_SYSTEM_TABLE			 *gST;
extern EFI_RUNTIME_SERVICES 	 *gRT;

#define GUID1 \
  { \
    0x964e5b22, 0x6459, 0x11d2, {0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b } \
  }

#define GUID2 \
  { \
    0x33221100, 0x5544, 0x7766, {0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF } \
  }
  
EFI_STATUS
PrintGuid (
  IN EFI_GUID *Guid
  )
  
/*++

Routine Description:

  This function prints a GUID to STDOUT.

Arguments:

  Guid    Pointer to a GUID to print.

Returns:

  EFI_SUCCESS             The GUID was printed.
  EFI_INVALID_PARAMETER   The input was NULL.

--*/
{
  if (Guid == NULL) {
	printf("Parameter error!\n");
    return EFI_INVALID_PARAMETER;
  }

  printf (
    "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x\n",
    (unsigned) Guid->Data1,
    Guid->Data2,
    Guid->Data3,
    Guid->Data4[0],
    Guid->Data4[1],
    Guid->Data4[2],
    Guid->Data4[3],
    Guid->Data4[4],
    Guid->Data4[5],
    Guid->Data4[6],
    Guid->Data4[7]
    );
  return EFI_SUCCESS;
}

int
EFIAPI
main (
  IN int Argc,
  IN CHAR16 **Argv
  )
{
  EFI_GUID T1=GUID1;
  EFI_GUID T2=GUID2;
  
  PrintGuid(&T1);
  PrintGuid(&T2);
  
  return EFI_SUCCESS;
}

运行结果

完整代码下载

GUIDTest

参考：
1.http://baike.baidu.com/view/1052579.htm UUID
2.http://blog.csdn.net/forlong401/article/details/7580147 UUID 和 GUID 的区别
3.https://en.wikipedia.org/wiki/Globally_unique_identifier Globally unique identifier
4.https://en.wikipedia.org/wiki/Universally_unique_identifier Universally unique identifier

拆了攀登 G1 PM 2.5 传感器

上次买了攀藤 G1 PM2.5 传感器了，这次有需要又拿了出来使用【参考1】。很不幸，经常不工作，探究原因似乎与接线有关系，于是我又重新做了一个线（上次和卖家多要了一根线），用上之后现象稍微有些改善，但是移动之类的还会导致失灵，具体现象就是风扇不转，碰碰插头之类的就好了。一怒之下，拆开研究：

首先，外面是一层壳子，这个可以直接撬开（蓝色的是外面的塑料膜，我基本上没有用，所以这层薄膜还在的）

然后，需要拧掉周围四个固定外壳的螺丝，此外还要拧下固定风扇的三个螺丝才能继续拆解。螺丝居然生锈了，我很惊奇。基本上没怎么用，也都是一直放在家里不知道为什么会这样，观察另外一只（好吧，其实我是买个2个的），同样也有生锈的情况

最后，用螺丝刀之类的撬开即可

主板上有一颗CY8C 的单片机。更惊奇的是：主板上固定的螺丝竟然也有锈蚀！

背面是关键，可以看出有一个激光头样子的东西，这应该是这个传感器的关键部件，配合风扇和壳子内部形成的风道，可以计量单位时间颗粒物的数量。

研究发现插头不紧的原因是：他选用的那种连接件不是自锁样式的。比如：在拆开上面状态下，无法插入接线然后保持卡住的状态。连接件只是让金属接触上，然后卡住是外壳的功劳。这样，如果外壳出现松动或者接头磨损之类的，就根本无法卡住，就会出现我遇到的问题。

前几个月，我在实验点亮各种 MIPI 屏幕，然后发现接口卡具没多久就坏掉了，我去和硬件工程师说，你们做的时候不能选点好的连接器么，他回答是：这个东西装上基本上不会再拆了，像你这样拆来拆去的属于特殊情况，从成本角度考虑我们不会有选择结实一点的需求，估计这个传感器也是本着这样的思路设计的。

最后的结论：东西不错，但是连接设计太差，如果你要像我这样做 DIY 有经常插拔的需求，不建议选择这款。如果你是做毕业设计之类的展示性工作，最好再多买一个备份。

后面的话我想找个 HW 帮着焊接出来一根永久固定的线吧。

参考：

1.http://www.lab-z.com/g1pm25/ 攀藤 G1 PM2.5传感器

Arduino 控制USB设备（6）解析USB鼠标的例子（上）

前面介绍了USB键盘的使用，这里介绍一下USB鼠标的调用。根据【参考1】的文章进行实验，这次我们的目标是：获得鼠标移动按键信息，串口输出之。

首先运行一下之前的取得描述符的工具抓取一下描述符：

Descriptor of HP Mouse
Start
Device addressed… Requesting device descriptor.
Device descriptor:

Descriptor Length: 12
USB version: 2.0
Class: 00 Use class information in the Interface Descriptor
Subclass: 00
Protocol: 00
Max.packet size: 08
Vendor ID: 046D
Product ID: C077
Revision ID: 6700
Mfg.string index: 01 Length: 18 Contents: Logitech
Prod.string index: 02 Length: 36 Contents: USB Optical Mouse
Serial number index: 00
Number of conf.: 01

Configuration number 0
Total configuration length: 34 bytes

Configuration descriptor:
Total length: 0022
Number of interfaces: 01
Configuration value: 01
Configuration string: 00
Attributes: A0 Remote Wakeup
Max.power: 31 98ma

Interface descriptor:
Interface number: 00
Alternate setting: 00
Endpoints: 01
Class: 03 HID (Human Interface Device)
Subclass: 01
Protocol: 02
Interface string: 00

HID descriptor:
Descriptor length: 09 9 bytes
HID version: 1.11
Country Code: 0 Not Supported
Class Descriptors: 1
Class Descriptor Type: 22 Report
Class Descriptor Length:67 bytes

HID report descriptor:

Length: 1 Type: Global Tag: Usage Page Generic Desktop Controls Data: 01
Length: 1 Type: Local Tag: Usage Data: 02
Length: 1 Type: Main Tag: Collection Application (mouse, keyboard) Data: 01
Length: 1 Type: Local Tag: Usage Data: 01
Length: 1 Type: Main Tag: Collection Physical (group of axes) Data: 00
Length: 1 Type: Global Tag: Usage Page Button Data: 09
Length: 1 Type: Local Tag: Usage Minimum Data: 01
Length: 1 Type: Local Tag: Usage Maximum Data: 08
Length: 1 Type: Global Tag: Logical Minimum Data: 00
Length: 1 Type: Global Tag: Logical Maximum Data: 01
Length: 1 Type: Global Tag: Report Size Data: 01
Length: 1 Type: Global Tag: Report Count Data: 08
Length: 1 Type: Main Tag: Input Data,Variable,Absolute………
Length: 1 Type: Global Tag: Usage Page Generic Desktop Controls Data: 01
Length: 2 Type: Global Tag: Logical Minimum Data: 01 Data: F8
Length: 2 Type: Global Tag: Logical Maximum Data: FF Data: 07
Length: 1 Type: Global Tag: Report Size Data: 0C
Length: 1 Type: Global Tag: Report Count Data: 02
Length: 1 Type: Local Tag: Usage Data: 30
Length: 1 Type: Local Tag: Usage Data: 31
Length: 1 Type: Main Tag: Input Data,Variable,Relative………
Length: 1 Type: Global Tag: Logical Minimum Data: 81
Length: 1 Type: Global Tag: Logical Maximum Data: 7F
Length: 1 Type: Global Tag: Report Size Data: 08
Length: 1 Type: Global Tag: Report Count Data: 01
Length: 1 Type: Local Tag: Usage Data: 38
Length: 1 Type: Main Tag: Input Data,Variable,Relative………
Length: 1 Type: Global Tag: Usage Page Consumer Data: 0C
Length: 2 Type: Local Tag: Usage Data: 38 Data: 02
Length: 1 Type: Global Tag: Report Count Data: 01
Length: 1 Type: Main Tag: Input Data,Variable,Relative………
Length: 0 Type: Main Tag: End Collection
Length: 0 Type: Main Tag: End Collection

Endpoint descriptor:
Endpoint address: 01 Direction: IN
Attributes: 03 Transfer type: Interrupt
Max.packet size: 0006
Polling interval: 0A 10 ms

根据上面的结果，计算长度应该是1×8+Cx2+8×1=40 bits= 5 bytes ,修改【参考1】的代码如下：

#include "Max3421e.h"
#include "Usb.h"

 
#define DEVADDR 1
#define CONFVALUE 1
 
void setup();
void loop();
 
MAX3421E Max;
USB Usb;
 
void setup()
{
    Serial.begin( 115200 );
    Serial.println("Start");
    Max.powerOn();
    delay( 200 );
}
 
void loop()
{
 byte rcode;
    Max.Task();
    Usb.Task();
    if( Usb.getUsbTaskState() == USB_STATE_CONFIGURING ) {
        mouse0_init();
    }//if( Usb.getUsbTaskState() == USB_STATE_CONFIGURING...
    if( Usb.getUsbTaskState() == USB_STATE_RUNNING ) {  //poll the keyboard
        rcode = mouse0_poll();
        if( rcode ) {
          Serial.print("Mouse Poll Error: ");
          Serial.println( rcode, HEX );
        }//if( rcode...
    }//if( Usb.getUsbTaskState() == USB_STATE_RUNNING...
}
/* Initialize mouse */
void mouse0_init( void )
{
 byte rcode = 0;  //return code
  /**/
  Usb.setDevTableEntry( 1, Usb.getDevTableEntry( 0,0 ) );              //copy device 0 endpoint information to device 1
  /* Configure device */
  rcode = Usb.setConf( DEVADDR, 0, CONFVALUE );
  if( rcode ) {
    Serial.print("Error configuring mouse. Return code : ");
    Serial.println( rcode, HEX );
    while(1);  //stop
  }//if( rcode...

  Usb.setUsbTaskState( USB_STATE_RUNNING );
  return;
}
/* Poll mouse using Get Report and print result */
byte mouse0_poll( void )
{
  byte rcode,i;
  char buf[ 4 ] = { 0 };      //mouse buffer
  static char old_buf[ 4 ] = { 0 };  //last poll
    /* poll mouse */
    rcode = Usb.getReport( DEVADDR, 0, 4, 0, 1, 0, buf );
    if( rcode ) {  //error
      return( rcode );
    }
    for( i = 0; i < 4; i++) {  //check for new information
      if( buf[ i ] != old_buf[ i ] ) { //new info in buffer
        break;
      }
    }
    if( i == 4 ) {
      return( 0 );  //all bytes are the same
    }
    /* print buffer */
    if( buf[ 0 ] & 0x01 ) {
      Serial.print("Button1 pressed ");
    }
    if( buf[ 0 ] & 0x02 ) {
      Serial.print("Button2 pressed ");
    }
    if( buf[ 0 ] & 0x04 ) {
      Serial.print("Button3 pressed ");
    }
    Serial.println("");
    Serial.print("X-axis: ");
    Serial.println( buf[ 1 ], DEC);
    Serial.print("Y-axis: ");
    Serial.println( buf[ 2 ], DEC);
    Serial.print("Wheel: ");
    Serial.println( buf[ 3 ], DEC);
    
    for( i = 0; i < 4; i++ ) {
      old_buf[ i ] = buf[ i ];  //copy buffer
    }
    Serial.println("");
    return( rcode );
}

运行结果

完整代码下载

mouse0

看起来按键和X Y都已经正确，但是 wheel 并不正常。再仔细研究代码，取出来的信息长度和描述符中的不一致。就是说，程序虽然能够运行也能够取到变化的值，但是解读有误。

再进一步研读 Descriptor
Length: 1 Type: Global Tag: Usage Page Generic Desktop Controls Data: 01
Length: 2 Type: Global Tag: Logical Minimum Data: 01 Data: F8 //最小 F801 = 1111 1000 0000 0001 = -2047
Length: 2 Type: Global Tag: Logical Maximum Data: FF Data: 07//最大 07FF = 0000 0111 1111 1111 = 2047
Length: 1 Type: Global Tag: Report Size Data: 0C //这里指出了上面数值的大小是 12位
Length: 1 Type: Global Tag: Report Count Data: 02
Length: 1 Type: Local Tag: Usage Data: 30 // X
Length: 1 Type: Local Tag: Usage Data: 31 // Y

应该是意味着2个12bits长度的数值,对应X Y 分配如下，其中 X[B] 和Y[B]应该是最高的符号位

根据这个改写程序，按照上面的表格取值再拼接起来，特别需要注意的是，我发现Arduino在不同尺寸的数据转换上似乎有一些bug，我只能把值放在 unsigned long int中然后才能进行拼接和输出的动作。

    Serial.print("X-axis: ");
    x=((libuf[2] & 0xF)<<8)+(libuf[1] & 0xFF );
    if (x & 0x800) {
      Serial.print("-");
      x = ((~x) & 0x7FF) +1;
    }
   
    Serial.println(x, HEX);
    
    Serial.print("Y-axis: ");    
    y=(((libuf[2]>>4) & 0xF) +((libuf[3] & 0xFF )<<4));
    if (y & 0x800) {
      Serial.print("-");
      y = ((~y) & 0x7FF) +1;
    }    
Serial.println(y, HEX);

最终，程序可以正常执行。

工作正常的程序如下：

#include "Max3421e.h"
#include "Usb.h"

 
#define DEVADDR 1
#define CONFVALUE 1
 
void setup();
void loop();
 
MAX3421E Max;
USB Usb;
 
void setup()
{
    Serial.begin( 115200 );
    Serial.println("Start");
    Max.powerOn();
    delay( 200 );
}
 
void loop()
{
 byte rcode;
    Max.Task();
    Usb.Task();
    if( Usb.getUsbTaskState() == USB_STATE_CONFIGURING ) {
        mouse0_init();
    }//if( Usb.getUsbTaskState() == USB_STATE_CONFIGURING...
    if( Usb.getUsbTaskState() == USB_STATE_RUNNING ) {  //poll the keyboard
        rcode = mouse0_poll();
        if( rcode ) {
          Serial.print("Mouse Poll Error: ");
          Serial.println( rcode, HEX );
        }//if( rcode...
    }//if( Usb.getUsbTaskState() == USB_STATE_RUNNING...
}
/* Initialize mouse */
void mouse0_init( void )
{
 byte rcode = 0;  //return code
  /**/
  Usb.setDevTableEntry( 1, Usb.getDevTableEntry( 0,0 ) );              //copy device 0 endpoint information to device 1
  /* Configure device */
  rcode = Usb.setConf( DEVADDR, 0, CONFVALUE );
  if( rcode ) {
    Serial.print("Error configuring mouse. Return code : ");
    Serial.println( rcode, HEX );
    while(1);  //stop
  }//if( rcode...

  Usb.setUsbTaskState( USB_STATE_RUNNING );
  return;
}
/* Poll mouse using Get Report and print result */
byte mouse0_poll( void )
{
  byte rcode,i;
  char buf[ 5 ] = { 0 };      //mouse buffer
  static char old_buf[ sizeof(buf) ] = { 0 };  //last poll
  unsigned long int libuf[ sizeof(buf) ];
  unsigned long int x;
  unsigned long int y;
  
    /* poll mouse */
    rcode = Usb.getReport( DEVADDR, 0, sizeof(buf), 0, 1, 0, buf );
    if( rcode ) {  //error
      return( rcode );
    }
    for( i = 0; i < sizeof(buf); i++) {  //check for new information
      if( buf[ i ] != old_buf[ i ] ) { //new info in buffer
        break;
      }
    }
    if( i == sizeof(buf)) {
      return( 0 );  //all bytes are the same
    }
    /* print buffer */
    if( buf[ 0 ] & 0x01 ) {
      Serial.print("Button1 pressed ");
    }
    if( buf[ 0 ] & 0x02 ) {
      Serial.print("Button2 pressed ");
    }
    if( buf[ 0 ] & 0x04 ) {
      Serial.print("Button3 pressed ");
    }
    
    for( i = 0; i < sizeof(buf); i++ ) {
      old_buf[ i ] = buf[ i ];  //copy buffer
      libuf[ i] = buf[i];
    }

    //Serial.print(libuf[0],HEX); Serial.print("  "); 
    //Serial.print(libuf[1],HEX); Serial.print("  "); 
    //Serial.print(libuf[2],HEX); Serial.print("  "); 
    //Serial.print(libuf[3],HEX); Serial.print("  ");     
    //Serial.println("");
    
    Serial.print("X-axis: ");
    x=((libuf[2] & 0xF)<<8)+(libuf[1] & 0xFF );
    if (x & 0x800) {
      Serial.print("-");
      x = ((~x) & 0x7FF) +1;
    }
   
    Serial.println(x, HEX);
    
    Serial.print("Y-axis: ");    
    y=(((libuf[2]>>4) & 0xF) +((libuf[3] & 0xFF )<<4));
    if (y & 0x800) {
      Serial.print("-");
      y = ((~y) & 0x7FF) +1;
    }    
    Serial.println(y, HEX);

    Serial.print("Wheel: ");    
    Serial.println(buf [4] & 0xFF, HEX);    
    return( rcode );
}

完整代码下载：

mousea

补遗：在运行中，我还发现了一个奇怪的问题：当使用 Get_Report取得数据时，鼠标向一个方向移动，会出现最大值。意思是：比如，向右一直移动鼠标，输出达到 7FF 之后，继续右移，输出值会维持在 7FF 而不会变化。没有找到直接描述这个问题的资料，不过有一些类似的介绍【参考2】，上面提到USB鼠标在送出数据的时候，会有两种方式，一种是Relative ，一种是Absolute。差别在于，比如前者输出（1，1），意思是告诉系统鼠标移动了(1,1)；而后者如果输出 (1,1)则是告诉系统，鼠标移动到(1,1)。看起来，我这个鼠标描述符中提到的是Relative，但是实际输出是 Absolute。

Length: 1 Type: Global Tag: Report Size Data: 0C
Length: 1 Type: Global Tag: Report Count Data: 02
Length: 1 Type: Local Tag: Usage Data: 30
Length: 1 Type: Local Tag: Usage Data: 31
Length: 1 Type: Main Tag: Input Data,Variable,Relative………

于此可以形成对照的是 Wheel，每次滚动之后，很快会再次输出一个 0 的位置，下次再给出新的滚动值。
至于Windows 下，根据资料，系统会自动根据鼠标信息计算出一个大概范围方便使用（比如，屏幕是 1024×768，鼠标是Relative -100到+100的话，如果不做优化，从左上到右下需要做几次才行）。而我用的这个鼠标，声明自己是Relative，但是实际上发出Absolute，只是因为自己的范围很大（-7FF到+7FF）,所以也不会有什么感觉。

上述只是猜测，是目前已知的最合理的解释而已。使用逻辑分析仪分析USB鼠标信息得到的结果相同。

逻辑分析仪抓取的结果，Windows使用 Interrupt 方式来和鼠标通讯

下面展示一下USB逻辑分析仪抓到的启动时的一些信息，首先是 Overview

不清楚为什么VendorID 居然是罗技的，一种可能是因为这个是假的HP鼠标，乱写一个ID；另外的可能是HP 找罗技代工的。

可以看到，MaxPower确实是一个很古怪的数值：98ma

接下来是最重要的HID 描述符

参考：
1.https://www.circuitsathome.com/communicating-arduino-with-hid-devices-part-1
2.http://www.microchip.com/forums/m482197.aspx MOUSE HID / Resolution problem