深海游弋的鱼 – 第 167 页 – 智障儿童欢乐多

Subclipse 1.6 卸载后Team菜单仍然存在的解决

最近从Ubuntu 12.04 升级到了 12.10，发现以前在Eclipse下面的SVN Subclipse 插件不能正常运行了。看了看原因，发现系统自带的SVN从1.6X升级到1.7X 了，当年哥在12.04下面折腾了半天，也没能方便升级到1.7X 啊，想不到，想不到。

去Subclipse官网看了下，似乎这个插件N久未曾更新，至少是人气不旺盛啊。于是想更换成Eclipse自带的subversion，没想到卸载了所有的名字与subversion 相关的东西之后，竟然在Team菜单中仍然存在快捷方式，另外就是装完subversion 以后在Window->Preferences->Team下面竟然有两个SVN ，明显是Subclipse 没有卸载干净。

找了半天，终于找到一个叫 CollabNet Merge Client 的东东，看名字，没有任何关系与 Subclipse，不过他的简介里面暴露了他，原来这个东东就算与Eclipse菜单对应的东东，吧这个卸载就可以了。

感觉是Eclipse自带的subversion 好些，当时是不知道怎么安装这个，才安装的Subclipse。这个安装完成后会提示安装相应的SVNkit 等等的依赖库，比较方便安装和使用。呵呵，强烈推荐这个。

安装方法：

Run Eclipse and select Help > Install New Software... from the main menu.
On the dialog that appears, select a pre-configured simultaneous release update site in the Work with combo-box. For example, for the Juno release, select the "Juno - http://download.eclipse.org/releases/juno" update site.
Wait a few seconds until the content of the selected update site is displayed under the combo-box.
Expand the Collaboration group and select the Subversive features that you would like to install. Certain Subversive features are required if you want to work with SVN, others are optional and offer some additional functionality. You can skip the optional features, if you wish.
Follow the next steps to install the selected Subversive features using the standard plug-in installation procedure. Reboot Eclipse after installation is complete.

当下图出现的时候，强烈建议选择SVNkit,请注意 SVNKit 1.3.8 对应的SVN 是 1.6X 的版本，SVNKit 1.7.X 是对应的SVN 1.7X的版本，JavaHL似乎跟不上Java的更新步伐，问题比较多，不推荐。

Arduino PWM控制逻辑

对于直流电机的速度控制，目前流行的控制逻辑是PWM，关于 Arduino 的PWM，看看图片

板子上标注了“PWM”的区域就是管脚均可以用于这种输出。使用的函数是：

analogWrite(pin, value);

1	analogWrite(pin, value);

注意value值的范围是0~255。

PWM　英文是“Pulse-width modulation”　，PWM是用占空比不同的方波，来模拟“模拟输出”的一种方式。简而言之就是电脑只会输出0和1，那么想输出0.5怎么办呢？于是输出01010101….，平均之后的效果就是0.5了。

现在看看电机的常规驱动电路，H桥

使用单片机来控制直流电机的变速，一般采用调节电枢电压的方式，通过单片机控制PWM1，PWM2,产生可变的脉冲，这样电机上的电压也为宽度可变的脉冲电压。根据公式

U=aVCC

其中：U为电枢电压；a为脉冲的占空比（0<a<1）；VCC直流电压源，这里为5V。

电动机的电枢电压受单片机输出脉冲控制，实现了利用脉冲宽度调制技术（PWM）进行直流电机的变速。

因为在H桥电路中，只有PWM1与PWM2电平互为相反时电机才能驱动，也就是PWM1与PWM2同为高电平或同为低电平时，都不能工作，所以上图中的实际脉冲宽度为B，

我们把PWM波的周期定为1ms，占空比分100级可调（每级级差为10%），这样定时器T0每0.01ms产生一次定时中断，每100次后进入下一个 PWM波的周期。上图中，占空比是60%，即输出脉冲的为0.6ms，断开脉冲为0.4ms，这样电枢电压为5*60%=3V。

我们讨论的是可以正转反转的，如果只按一个方向转，我们就只要把PWM1置为高电平或低电平，只改变另一个PWM2电平的脉冲变化即可，，如下图（Q4导通，Q3闭合，电机只能顺时针调整转动速度）

下面看看摘抄的部分原理

直流电动机转速n=(U-IR)/Kφ

其中U为电枢端电压，I为电枢电流，R为电枢电路总电阻，φ为每极磁通量，K为电动机结构参数。

直流电机转速控制可分为励磁控制法与电枢电压控制法。励磁控制法是控制磁通，其控制功率小，低速时受到磁饱和限制，高速时受到换向火花和换向器结构强度的限制，而且由于励磁线圈电感较大动态响应较差，所以这种控制方法用得很少。大多数应用场合都使用电枢电压控制法。随着电力电子技术的进步，改变电枢电压可通过多种途径实现，其中PWM(脉宽调制)便是常用的改变电枢电压的一种调速方法。

PWM调速控制的基本原理是按一个固定频率来接通和断开电源，并根据需要改变一个周期内接通和断开的时间比(占空比)来改变直流电机电枢上电压的"占空比"，从而改变平均电压，控制电机的转速。在脉宽调速系统中，当电机通电时其速度增加，电机断电时其速度减低。只要按照一定的规律改变通、断电的时间，即可控制电机转速。而且采用PWM技术构成的无级调速系统．启停时对直流系统无冲击，并且具有启动功耗小、运行稳定的特点。

设电机始终接通电源时，电机转速最大为Vmax，且设占空比为D=t／T，则电机的平均速度Vd为：

Vd=VmaxD

由公式可知，当改变占空比D=t／T时，就可以得到不同的电机平均速度Vd，从而达到调速的目的。严格地讲，平均速度与占空比D并不是严格的线性关系，在一般的应用中，可将其近似地看成线性关系。在直流电机驱动控制电路中，PWM信号由外部控制电路提供，并经高速光电隔离电路、电机驱动逻辑与放大电路后，驱动H桥下臂MOSFET的开关来改变直流电机电枢上平均电压，从而控制电机的转速，实现直流电机PWM调速。

原理知道了，那么看看　Arduino Mega 2560 的PWM控制端口信息

1) Arduino 2560 has 12 pins supporting PWM. They are from 2 to 13 included.
2) the PWM default frequency is 490 Hz for all pins, with the exception of pin 13 and 4,whose frequency is 980 Hz (I checked with an oscilloscope).
3) In order to change frequency on pin 'A', we have to change some value in the timer (or register), controlling pin 'A'. This is the list of timers in Arduino Mega 2560:
timer 0 (controls pin 13, 4);
timer 1 (controls pin 12, 11);
timer 2 (controls pin 10, 9);
timer 3 (controls pin 5, 3, 2);
timer 4 (controls pin 8, 7, 6);

As you can see, a given timer controls more than one pin (every change about a timer will affect all pins depending on it!).

4) You can access a timer simply changing in your code (tipically in the setup()), the value of variable TCCRnB, where 'n' is the number of register. So, if we want to change the PWM frequency of pins 10 and 9, we will have to act on TCCR2B .

5) The TCCRnB is a 8 bit number. The first three bits (from right to left!) are called CS02, CS01, CS00, and they are the bits we have to change.
Those bits in fact represent an integer number (from 0 to 7) called 'prescaler' , that Arduino uses to generate the frequency for PWM.

6) First of all, we have to clear these three bits, i.e they must be all set to 0:

int myEraser = 7;             // this is 111 in binary and is used as an eraser
TCCR2B &= ~myEraser;   // this operation (AND plus NOT),  set the three bits in TCCR2B to 0

1 2	int myEraser = 7; // this is 111 in binary and is used as an eraser TCCR2B &= ~myEraser; // this operation (AND plus NOT), set the three bits in TCCR2B to 0

7) now that CS02, CS01, CS00 are clear, we write on them a new value:

int myPrescaler = 3;         // this could be a number in [1 , 6]. In this case, 3 corresponds in binary to 011.
TCCR2B |= myPrescaler;  //this operation (OR), replaces the last three bits in TCCR2B with our new value 011

1 2	int myPrescaler = 3; // this could be a number in [1 , 6]. In this case, 3 corresponds in binary to 011. TCCR2B \|= myPrescaler; //this operation (OR), replaces the last three bits in TCCR2B with our new value 011

now we have a new PWM frequency on pin 9 and 10!

I registered those values on all PWM pins, changing the value of prescaler (the only exception are pins 13 and 14, see later):

prescaler = 1 ---> PWM frequency is 31000 Hz
prescaler = 2 ---> PWM frequency is 4000 Hz
prescaler = 3 ---> PWM frequency is 490 Hz (default value)
prescaler = 4 ---> PWM frequency is 120 Hz
prescaler = 5 ---> PWM frequency is 30 Hz
prescaler = 6 ---> PWM frequency is <20 Hz

(prescalers equal t 0 or 7 are useless).

Those prescaler values are good for all timers (TCCR1B, TCCR2B, TCCR3B, TCCR4B) except for timer 0 (TCCR0B). In this case the values are:

prescaler = 1 ---> PWM frequency is 62000 Hz
prescaler = 2 ---> PWM frequency is 7800 Hz
prescaler = 3 ---> PWM frequency is 980 Hz (default value)
prescaler = 4 ---> PWM frequency is 250 Hz
prescaler = 5 ---> PWM frequency is 60 Hz
prescaler = 6 ---> PWM frequency is <20 Hz

Note that timer 0 is the one on which rely all time functions in Arduino: i.e., if you change this timer, function like delay() or millis() will continue to work but at a different timescale (quicker or slower!!!)

明天修改一下电机的控制代码，把小车代码修改一下，哈哈

Android查看源代码的版本号

确认Android源代码的版本号：

1. 编译的时候在终端中一开始就会打印出来：

    PLATFORM_VERSION：2.3.1

1	PLATFORM_VERSION：2.3.1

2. 直接去make文件中去看：

    build\core\version_defaults.mk  // 搜索该文件中的 PLATFORM_VERSION值

1	build\core\version_defaults.mk // 搜索该文件中的 PLATFORM_VERSION值

编写Arduino支持的C++类库

以下为摘抄的例子，已经亲自验证过，例子是正确的

我们在上一讲中实现了一个TN901红外温度传感器51程序到Arduino程序的转换，如果代码越来越多这样程序的可维护性会随之降低，也不适合团度开发。我们应该把常用的文件封装成C++库，这样在复用的时候就会方便很多。
首先让我们来看下官方的C++类库是怎样的结构，以官方的LCD类库为例，如下图所示：

上面的文件大体是这样的结构：

文件名	文件类型	文件说明
keywords.txt	keywords.txt	Arduino库色标文件
LiquidCrystal.h	.h	C++头文件
LiquidCrystal.cpp	.cpp	C++程序文件

以下几种文件的作用如下：

.h 头文件：头文件作为一种包含功能函数、数据接口声明的载体文件，用于保存程序的声明(declaration)，而定义文件用于保存程序的实现 (implementation)。

.cpp 文件：C++程序源文件主要的逻辑写在这里。

keywords.txt 文件：用来定义库在程序中显示关键字的颜色。

首先我们来尝试下头文件的编写

#ifndef TH901_H  //根据条件进行编译
#define TH901_H

//我们在这中间添加程序主体的代码部分，首先来添加程序的头文件，需要引用什么都可以加进来
#include <inttypes.h> //引用相关的头文件

//之后我们可以预定义一些需要的常量，这样维护起来比较方便，如果常量值改变只要统一修改这里就好
#define TN901_OTADDRESS 0x4c
#define TN901_ETADDRESS 0x66
#define TN901_ENDADDRESS 0x0d

//接下来我们来定义变量和声明程序的方法，需要外部调用和访问的就声明成public,不需要外部访问的就声明为private

class TN901     //定义类主体及类名
{
public:  //以下定义为公共方法
short ET;   //环境温度输出
short OT;   //目标温度输出
void Init(int TN_Data,int TN_Clk,int TN_ACK); //程序初始化
void Read();  //读取方法
void ReadData(char flag); //读取指定地址的数据
int  GetData(); //获取数据
private:  //以下定义为私有方法
int _dataPin;  //数据引脚
int _clkPin;   //时钟引脚
int _ackPin;   //反馈引脚
unsigned char  Data[5];  //数据数组
};
#endif//程序结束

#ifndef TH901_H //根据条件进行编译

#define TH901_H

//我们在这中间添加程序主体的代码部分，首先来添加程序的头文件，需要引用什么都可以加进来

#include <inttypes.h> //引用相关的头文件

//之后我们可以预定义一些需要的常量，这样维护起来比较方便，如果常量值改变只要统一修改这里就好

#define TN901_OTADDRESS 0x4c

#define TN901_ETADDRESS 0x66

#define TN901_ENDADDRESS 0x0d

//接下来我们来定义变量和声明程序的方法，需要外部调用和访问的就声明成public,不需要外部访问的就声明为private

class TN901 //定义类主体及类名

{

public: //以下定义为公共方法

short ET; //环境温度输出

short OT; //目标温度输出

void Init(int TN_Data,int TN_Clk,int TN_ACK); //程序初始化

void Read(); //读取方法

void ReadData(char flag); //读取指定地址的数据

int GetData(); //获取数据

private: //以下定义为私有方法

int _dataPin; //数据引脚

int _clkPin; //时钟引脚

int _ackPin; //反馈引脚

unsigned char Data[5]; //数据数组

};

#endif//程序结束

这样我们一个头文件就写好了.

接下来我们来书写程序的主体，就是CPP文件。

//首先我们引用已经写好的程序头文件
#include "TN901.h"
//之后我们引用一些需要的库文件
#include "TN901.h"
#include <stdio.h>
#include <string.h>
#include <inttypes.h>
#include "Arduino.h"

//首先我们引用已经写好的程序头文件

#include "TN901.h"

//之后我们引用一些需要的库文件

#include "TN901.h"

#include <stdio.h>

#include <string.h>

#include <inttypes.h>

#include "Arduino.h"

然后我们逐一实现在头文件中定义的方法，注意类型要与定义类型相对应。所有的方法都要属于你定义的类名，格式如下

类名::方法名

另外i啊我们要为程序的封装考虑程序应有的结构，总之是怎样使你的库使用起来最方便，在一般的逻辑中尽量减少调用的次数。我们可以把程序的逻辑分割为几个部分来书写。如：

1.初始化
2.实现功能
3.显示数据

当然这个逻辑以具体的程序为准。

我们来尝试写第一个初始化的方法，这样我们可以自己定义程序的端口。

//初始化TN901传感器
void TN901::Init(int TN_Data,int TN_Clk,int TN_ACK)
{
//定义私有端口
_dataPin=TN_Data;
_clkPin=TN_Clk;
_ackPin=TN_ACK;

pinMode(_clkPin, INPUT);
pinMode(_ackPin, OUTPUT);
digitalWrite(_ackPin,HIGH);
}

//初始化TN901传感器

void TN901::Init(int TN_Data,int TN_Clk,int TN_ACK)

{

//定义私有端口

_dataPin=TN_Data;

_clkPin=TN_Clk;

_ackPin=TN_ACK;

pinMode(_clkPin, INPUT);

pinMode(_ackPin, OUTPUT);

digitalWrite(_ackPin,HIGH);

}

然后我们书写程序的主要逻辑部分

//读取数据
void TN901::Read()
{
digitalWrite(_ackPin,LOW);
ReadData(TN901_OTADDRESS);//目标温度的第一个字节为0x4c
if((Data[0]==TN901_OTADDRESS)&&
(Data[4]==TN901_ENDADDRESS))//每帧的最后一个字节为0x0d
{
GetData_OT();
}

delay(1); //等待1毫秒

digitalWrite(_ackPin,LOW);
ReadData(TN901_ETADDRESS);//环境温度的第一个字节为0x66

if((Data[0]==TN901_ETADDRESS)&&
(Data[4]==TN901_ENDADDRESS))//每帧的最后一个字节为0x0d
{
GetData_ET();
}
}

//读取数据

void TN901::Read()

{

digitalWrite(_ackPin,LOW);

ReadData(TN901_OTADDRESS);//目标温度的第一个字节为0x4c

if((Data[0]==TN901_OTADDRESS)&&

(Data[4]==TN901_ENDADDRESS))//每帧的最后一个字节为0x0d

{

GetData_OT();

}

delay(1); //等待1毫秒

digitalWrite(_ackPin,LOW);

ReadData(TN901_ETADDRESS);//环境温度的第一个字节为0x66

if((Data[0]==TN901_ETADDRESS)&&

(Data[4]==TN901_ENDADDRESS))//每帧的最后一个字节为0x0d

{

GetData_ET();

}

最后我们逐一实现程序的运算过程

//读取数据
void TN901::ReadData(char flag)
{
char i,j,k;
byte BitState = 0;          //每次发七帧
for(k=0;k<7;k++)
{
for(j=0;j<5;j++)        //每帧5个字节
{
for(i=0;i<8;i++)
{
int temp= digitalRead(_clkPin);
while(temp)
{
temp = digitalRead(_clkPin);
}
temp= digitalRead(_clkPin);
BitState= digitalRead(_dataPin);
Data[j]= Data[j]<<1;
Data[j]= Data[j]|BitState;

while(!temp)
{
temp = digitalRead(_clkPin);
}
}
}
if(Data[0]==flag)  k=8;
}

digitalWrite(_ackPin,HIGH);
}

//计算环境温度
void TN901::GetData_ET()
{
ET=(Data[1]<<8)|Data[2];
ET = int(((float)ET/16 - 273.15)*100);
}

//计算目标温度
void TN901::GetData_OT()
{
OT=(Data[1]<<8)|Data[2];
OT = int(((float)OT/16 - 273.15)*100);
}

//读取数据

void TN901::ReadData(char flag)

{

char i,j,k;

byte BitState = 0; //每次发七帧

for(k=0;k<7;k++)

{

for(j=0;j<5;j++) //每帧5个字节

{

for(i=0;i<8;i++)

{

int temp= digitalRead(_clkPin);

while(temp)

{

temp = digitalRead(_clkPin);

}

temp= digitalRead(_clkPin);

BitState= digitalRead(_dataPin);

Data[j]= Data[j]<<1;

Data[j]= Data[j]|BitState;

while(!temp)

{

temp = digitalRead(_clkPin);

}

if(Data[0]==flag) k=8;

}

digitalWrite(_ackPin,HIGH);

}

//计算环境温度

void TN901::GetData_ET()

{

ET=(Data[1]<<8)|Data[2];

ET = int(((float)ET/16 - 273.15)*100);

}

//计算目标温度

void TN901::GetData_OT()

{

OT=(Data[1]<<8)|Data[2];

OT = int(((float)OT/16 - 273.15)*100);

}

之后我们来尝试为我们的库编写一个范例程序来测试我们的程序是否运行正常。

#include <TN901.h>  //引用库文件
TN901 tn;           //实 例 化
void setup()
{
Serial.begin(9600);
tn.Init(7,9,8);  //初 始 化
}

void loop()
{
tn.Read();        //数据读取
SerialValue();
delay(200);
}

void SerialValue()
{
Serial.print("OT: ");
Serial.print(tn.OT, DEC);  //输出目标温度
Serial.println(" C");
Serial.print("ET: ");
Serial.print(tn.ET, DEC);  //输出环境温度
Serial.println(" C");
}

#include <TN901.h> //引用库文件

TN901 tn; //实例化

void setup()

{

Serial.begin(9600);

tn.Init(7,9,8); //初始化

}

void loop()

{

tn.Read(); //数据读取

SerialValue();

delay(200);

}

void SerialValue()

{

Serial.print("OT: ");

Serial.print(tn.OT, DEC); //输出目标温度

Serial.println(" C");

Serial.print("ET: ");

Serial.print(tn.ET, DEC); //输出环境温度

Serial.println(" C");

}

好了，我们看到虽然我们花了一点时间编写了库文件，但是在我们使用程序的时候可以非常方便的调用，而且这样逻辑会比较清晰。呵呵。

最后送给大家一个小礼物，就是如何为我们的库编写色标文件，色标文件就是定义你的库中的方法在编译器中显示的颜色
没有色标文件的库显示起来是这样的：

我们可以看到库文件的类名和方法名都是黑色的这样看起来不是很清楚。加上色标文件之后是这样的

我们可以看到TN901这样的类名都被加亮了这样看起来要清楚许多。

实现这个需要定义一个色标文件放在库文件的目录中，格式如下

#######################################
# Syntax Coloring Map For 你的类名
#######################################

#######################################
# Datatypes (KEYWORD1) 数据类型关键字
#######################################

TN901        KEYWORD1

#######################################
# Methods and Functions (KEYWORD2) 方法类型关键字
#######################################

Init        KEYWORD2
Read        KEYWORD2
ReadData        KEYWORD2
GetData        KEYWORD2

#######################################
# Constants (LITERAL1)  常量类型关键字
#######################################

ET        LITERAL1
OT        LITERAL1

#######################################

# Syntax Coloring Map For 你的类名

#######################################

# Datatypes (KEYWORD1) 数据类型关键字

#######################################

TN901 KEYWORD1

#######################################

# Methods and Functions (KEYWORD2) 方法类型关键字

#######################################

Init KEYWORD2

Read KEYWORD2

ReadData KEYWORD2

GetData KEYWORD2

#######################################

# Constants (LITERAL1) 常量类型关键字

#######################################

ET LITERAL1

OT LITERAL1

这样我们的色标文件就写好了，我们把它保存成文件名为keywords.txt的文件放在库文件目录下就可以了。

当我们些库文件全部做好了之后我们就可以把这些文件放在，这样的目录下

energia：energia-0101E0008\hardware\msp430\libraries\
arduino：arduino-1.0.1-windows\arduino-1.0.1\libraries\

这样当你重新打开官方编译器的时候可以看到如下的内容

python在windows的cmd中打印彩色文字

#!/usr/bin/env python
#encoding: utf-8
import ctypes

STD_INPUT_HANDLE = -10
STD_OUTPUT_HANDLE= -11
STD_ERROR_HANDLE = -12

FOREGROUND_BLACK = 0x0
FOREGROUND_BLUE = 0x01 # text color contains blue.
FOREGROUND_GREEN= 0x02 # text color contains green.
FOREGROUND_RED = 0x04 # text color contains red.
FOREGROUND_INTENSITY = 0x08 # text color is intensified.

BACKGROUND_BLUE = 0x10 # background color contains blue.
BACKGROUND_GREEN= 0x20 # background color contains green.
BACKGROUND_RED = 0x40 # background color contains red.
BACKGROUND_INTENSITY = 0x80 # background color is intensified.

class Color:
 ''' See http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winprog/winprog/windows_api_reference.asp
 for information on Windows APIs.'''
 std_out_handle = ctypes.windll.kernel32.GetStdHandle(STD_OUTPUT_HANDLE)

 def set_cmd_color(self, color, handle=std_out_handle):
   """(color) -> bit
Example: set_cmd_color(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY)
"""
  bool = ctypes.windll.kernel32.SetConsoleTextAttribute(handle, color)
  return bool

def reset_color(self):
  self.set_cmd_color(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE)

def print_red_text(self, print_text):
  self.set_cmd_color(FOREGROUND_RED | FOREGROUND_INTENSITY)
  print print_text
  self.reset_color()

def print_green_text(self, print_text):
  self.set_cmd_color(FOREGROUND_GREEN | FOREGROUND_INTENSITY)
  print print_text
  self.reset_color()

def print_blue_text(self, print_text):
  self.set_cmd_color(FOREGROUND_BLUE | FOREGROUND_INTENSITY)
  print print_text
  self.reset_color()

def print_red_text_with_blue_bg(self, print_text):
  self.set_cmd_color(FOREGROUND_RED | FOREGROUND_INTENSITY| BACKGROUND_BLUE | BACKGROUND_INTENSITY)
  print print_text
  self.reset_color()

if __name__ == "__main__":
 clr = Color()
 clr.print_red_text('red')
 clr.print_green_text('green')
 clr.print_blue_text('blue')
 clr.print_red_text_with_blue_bg('background')

#!/usr/bin/env python

#encoding: utf-8

import ctypes

STD_INPUT_HANDLE = -10

STD_OUTPUT_HANDLE= -11

STD_ERROR_HANDLE = -12

FOREGROUND_BLACK = 0x0

FOREGROUND_BLUE = 0x01 # text color contains blue.

FOREGROUND_GREEN= 0x02 # text color contains green.

FOREGROUND_RED = 0x04 # text color contains red.

FOREGROUND_INTENSITY = 0x08 # text color is intensified.

BACKGROUND_BLUE = 0x10 # background color contains blue.

BACKGROUND_GREEN= 0x20 # background color contains green.

BACKGROUND_RED = 0x40 # background color contains red.

BACKGROUND_INTENSITY = 0x80 # background color is intensified.

class Color:

''' See http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winprog/winprog/windows_api_reference.asp

for information on Windows APIs.'''

std_out_handle = ctypes.windll.kernel32.GetStdHandle(STD_OUTPUT_HANDLE)

def set_cmd_color(self, color, handle=std_out_handle):

"""(color) -> bit

Example: set_cmd_color(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY)

"""

bool = ctypes.windll.kernel32.SetConsoleTextAttribute(handle, color)

return bool

def reset_color(self):

self.set_cmd_color(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE)

def print_red_text(self, print_text):

self.set_cmd_color(FOREGROUND_RED | FOREGROUND_INTENSITY)

print print_text

self.reset_color()

def print_green_text(self, print_text):

self.set_cmd_color(FOREGROUND_GREEN | FOREGROUND_INTENSITY)

print print_text

self.reset_color()

def print_blue_text(self, print_text):

self.set_cmd_color(FOREGROUND_BLUE | FOREGROUND_INTENSITY)

print print_text

self.reset_color()

def print_red_text_with_blue_bg(self, print_text):

self.set_cmd_color(FOREGROUND_RED | FOREGROUND_INTENSITY| BACKGROUND_BLUE | BACKGROUND_INTENSITY)

print print_text

self.reset_color()

if __name__ == "__main__":

clr = Color()

clr.print_red_text('red')

clr.print_green_text('green')

clr.print_blue_text('blue')

clr.print_red_text_with_blue_bg('background')

通过PPA仓库为ubuntu安装Oracle Java 7

首先先介绍一下什么叫PPA

PPA，表示 Personal Package Archives，也就是个人软件包集。

有很多软件因为种种原因，不能进入官方的 Ubuntu 软件仓库。为了方便 Ubuntu 用户使用，launchpad.net 提供了 ppa，允许用户建立自己的软件仓库，自由的上传软件。PPA 也被用来对一些打算进入 Ubuntu 官方仓库的软件，或者某些软件的新版本进行测试。

在ubuntu系统中，和OpenJDK比起来，如果你更偏爱Oracle JDK（前 Sun JDK），我推荐一种很简便的方法给你。通过一个PPA仓库，你可以很容易的进行安装Oracle JDK（包括JRE）并始终保持最新的版本。

Oracle JDK7本身并不存在于该PPA中，这是因为新的Java授权许可证并不允许这么做（这也是Oracle JDK7从ubuntu官方软件仓库中移除的原因）。PPA中的软件程序自动从Oracle官方网站下载Oracle Java JDK7并把它安装到你的电脑中，就像flashplugin-installer软件包那样。

需要注意的是，该软件包当前还是alpha 版本，可能在有些情况下不能正常工作！该软件包支持代理，但是如果你的ISP或者路由器封禁了一些非标准端口，这可能导致安装失败，这是由于Oracle 在Java7二进制安装包的下载链接中使用了许多重定向！如果因此而导致下载失败，亦或你的电脑在防火墙保护之下，你就需要手动安装 Oracle Java 7了。

安装Oracle Java 7

该软件包提供安装Oracle Java JDK 7 (包括 Java JDK, JRE 和 the Java 浏览器插件)，如果你只需要安装Oracle JRE，请不要使用该PPA。

运行下述命令，即可完成添加PPA、安装最新版本的Oracle Java 7（支持Ubuntu 12.10,12.04, 11.10, 11.04 and 10.04）:

sudo add-apt-repository ppa:webupd8team/java
sudo apt-get update
sudo apt-get install oracle-java7-installer

sudo add-apt-repository ppa:webupd8team/java

sudo apt-get update

sudo apt-get install oracle-java7-installer

安装完成之后，如果你想看看是否真的安装成功了，你只需运行下面的命令：

java -version

1	java -version

命令输出应该包含和下面类似的内容：

java version "1.7.0_04"Java(TM) SE Runtime Environment (build 1.7.0_04-20)Java HotSpot(TM) Server VM (build 23.0-b21, mixed mode)

1	java version "1.7.0_04"Java(TM) SE Runtime Environment (build 1.7.0_04-20)Java HotSpot(TM) Server VM (build 23.0-b21, mixed mode)

注：版本号中的”_04″部分可能会与你的不同，这是由于该PPA总是安装最新的Oracle Java 7版本。

如果由于一些其它的原因，当前的Java版本不是1.7.0，你可以尝试运行下面的命令：

sudo update-java-alternatives -s java-7-oracle

1	sudo update-java-alternatives -s java-7-oracle

卸载 Oracle Java 7

如果你不再想使用Oracle Java (JDK) 7，想回归OpenJDK了，你只需卸载Oracle JDK7 Installer，这样OpenJDK就又变成当前使用的java了：

sudo apt-get remove oracle-java7-installer

1	sudo apt-get remove oracle-java7-installer

import-module的注意事项与NDK_MODULE_PATH的配置

引用 http://blog.sina.com.cn/s/blog_4057ab62010197z8.html

import-module的功能
导入外部模块的.mk文件，和 include基本一样。
概念上的区别是include导入的是由我们自己写的.mk。而import-module导入的是外部库、外部模块提供的.mk。
用法上：include的路径是.mk文件的绝对路径。
而import是设置的路径指定到模块的.mk所在目录，是相对于NDK_MODULE_PATH中的路径列表的相对路径。

import-module的使用
$(call import-module,相对路径)

-----------------场景重现---------------------------
比如我的当前模块要调用 cocosdenshion模块。
1\找到模块名字和路径
找到cocosdenshion模块的android.mk的位置。F:\cocos2d-x\CocosDenshion\android\android.mk
打开看到:
LOCAL_MODULE := cocosdenshion_shared
...
include $(BUILD_STATIC_LIBRARY)
那么cocosdenshion模块在我自己的android.mk中引用它是应该叫它cocosdenshion_shared。而且他是个静态库。

2\在Android.mk中引用模块
就像普通代码中引用头文件一样。
在android.mk的最后一行调用
$(call import-module,CocosDenshion/android)
来导入模块。
注意：我的NDK_MODULE_PATH=/cygdrive/f/cocos2d-x 是已经设置好了的。
如果引用的模块里面也有import-module,他的相对路径也要加到NDK_MODULE_PATH中。如果它没被加进去的话。
然后
LOCAL_WHOLE_STATIC_LIBRARIES += cocos_jpeg_static
声明我这模块要引用该静态库模块。
-------------------------------------------------------

import-module的使用注意
1、设置路径时，注意与NDK_MODULE_PATH中的路径相互配合。
1、导入模块的.mk中如果也有import-module，则注意其相对路径也要在NDK_MODULE_PATH中。
2、上面说了import-module和include一样。如果import-module和Include包含了同一个.mk,会报重复包含的错误。

NDK_MODULE_PATH的配置

NDK_MODULE_PATH的作用
NDK_MODULE_PATH是一个很重要的变量，当android.mk中使用了$(call import-module,XXX)函数引入外部库文件时会用到，用以指示该往哪里去找这个文件。
如果NDK_MODULE_PATH 没有设置或者设置不正确。编译时都是报错 Are you sure your NDK_MODULE_PATH variable is properly defined。
NDK_MODULE_PATH的设置与格式
NDK_MODULE_PATH 是一个环境变量，不是android.mk中设置的变量。
NDK_MODULE_PATH多个路径用冒号分割。不是分号！且整个字符串中间不能有空格。格式不正确也会报错上面的错误的。
设置NDK_MODULE_PATH的方法
1、在系统环境里手动添加这个环境变量，
2、在build_native.sh中运行ndk-build之前使用export命令定义环境变量NDK_MODULE_PATH。
如：export NDK_MODULE_PATH=路径1:路径2:路径3
3、直接将NDK_MODULE_PATH=路径1:路径2 加到 ndk-build命令的参数后面。ndk-build的参数最终会直接传给make.
如：$NDK_ROOT_LOCAL/ndk-build -C $HELLOWORLD_ROOT NDK_MODULE_PATH=路径1:路径2
(命令 make aaa=213 //在编译makefile之前将aaa当作环境变量设置为213.)

4、还可以在android.mk中设置NDK_MODULE_PATH
在import语句之前加入，
$(call import-add-path,$(LOCAL_PATH)/platform/third_party/android/prebuilt)
将一个新的路径加入NDK_MODULE_PATH变量。

Android.mk简介

引用 http://blog.csdn.net/hudashi/article/details/7059006

Android.mk文件是GNU Makefile的一小部分，它用来对Android程序进行编译。
因为所有的编译文件都在同一个 GNU MAKE 执行环境中进行执行，而Android.mk中所有的变量都是全局的。因此，您应尽量少声明变量，不要认为某些变量在解析过程中不会被定义。
一个Android.mk文件可以编译多个模块，每个模块属下列类型之一：
1）APK程序
一般的Android程序，编译打包生成apk文件
2）JAVA库
java类库，编译打包生成jar文件
3)C\C++应用程序
可执行的C\C++应用程序
4）C\C++静态库
编译生成C\C++静态库，并打包成.a文件
5）C\C++共享库
编译生成共享库（动态链接库），并打包成.so文，有且只有共享库才能被安装/复制到您的应用软件（APK）包中。
可以在每一个Android.mk file 中定义一个或多个模块，你也可以在几个模块中使用同一个
源代码文件。编译系统为你处理许多细节问题。例如，你不需要在你的 Android.mk 中列出头文件和依
赖文件。编译系统将会为你自动处理这些问题。这也意味着，在升级 NDK 后，你应该
得到新的toolchain/platform支持，而且不需要改变你的 Android.mk 文件。
注意，NDK的Anroid.mk语法同公开发布的Android平台开源代码的Anroid.mk语法很接近，然而编译系统实现他们的
方式却是不同的，这是故意这样设计的，可以让程序开发人员重用外部库的源代码更容易。
在描述语法细节之前，咱们来看一个简单的"hello world"的例子，比如，下面的文件：
sources/helloworld/helloworld.c
sources/helloworld/Android.mk
'helloworld.c'是一个 JNI 共享库，实现返回"hello world"字符串的原生方法。相应的
Android.mk 文件会象下面这样：
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE:= helloworld
LOCAL_SRC_FILES := helloworld.c
include $(BUILD_SHARED_LIBRARY)
解释一下几行代码：
LOCAL_PATH := $(call my-dir)
一个Android.mk file首先必须定义好LOCAL_PATH变量。它表示是当前文件的路径。
在这个例子中，宏函数‘my-dir’, 由编译系统提供，用于返回当前路径(即包含Android.mk file
文件的目录)。
include $(CLEAR_VARS)
CLEAR_VARS 由编译系统提供(可以在 android 安装目录下的/build/core/config.mk 文件看到其定义，为 CLEAR_VARS:=$(BUILD_SYSTEM)/clear_vars.mk)，指定让GNU MAKEFILE该脚本为你清除许多 LOCAL_XXX 变量 ( 例如 LOCAL_MODULE ， LOCAL_SRC_FILES ，LOCAL_STATIC_LIBRARIES，等等…)，除 LOCAL_PATH。这是必要的，因为所有的编译文件都在同一个 GNU MAKE 执行环境中，所有的变量都是全局的。所以我们需要先清空这些变量（LOCAL_PATH除外）。又因为LOCAL_PATH总是要求在每个模块中都要进行设置，所以并需要清空它。
另外注意，该语句的意思就是把CLEAR_VARS变量所指向的脚本文件包含进来。
LOCAL_MODULE := helloworld
LOCAL_MODULE 变量必须定义，以标识你在 Android.mk 文件中描述的每个模块。名称必须是唯一的，而且不包含任何空格。注意编译系统会自动产生合适的前缀和后缀，换句话说，一个被命名为'foo'的共享库模块，将会生成'libfoo.so'文件。
注意：如果把库命名为‘libhelloworld’，编译系统将不会添加任何的 lib 前缀，也会生成 libhelloworld.so。
LOCAL_SRC_FILES := helloworld.c
LOCAL_SRC_FILES 变量必须包含将要编译打包进模块中的 C 或 C++源代码文件。不用
在这里列出头文件和包含文件，编译系统将会自动找出依赖型的文件，当然对于包含文件，你包含时指定的路径应该正确。
注意，默认的 C++源码文件的扩展名是‘.cpp’ 。指定一个不同的扩展名也是可能的，只要定义LOCAL_DEFAULT_CPP_EXTENSION 变量，不要忘记开始的小圆点(也就是定义为 ‘.cxx’,而不是‘cxx’)
include $(BUILD_SHARED_LIBRARY)
BUILD_SHARED_LIBRARY 是编译系统提供的变量，指向一个 GNU Makefile 脚本(应该
就是在 build/core 目录下的 shared_library.mk) ，将根据LOCAL_XXX系列变量中的值，来编译生成共享库（动态链接库）。
如果想生成静态库，则用BUILD_STATIC_LIBRARY
在NDK的sources/samples目录下有更复杂一点的例子，写有注释的 Android.mk 文件。
二、自定义变量
以下是在 Android.mk中依赖或定义的变量列表，可以定义其他变量为自己使用，但是NDK编译系统保留下列变量名：
-以 LOCAL_开头的名字（例如 LOCAL_MODULE）
-以 PRIVATE_, NDK_ 或 APP_开头的名字（内部使用）
-小写名字（内部使用，例如‘my-dir’）
如果为了方便在 Android.mk 中定义自己的变量，建议使用 MY_前缀，一个小例子：
MY_SOURCES := foo.c
ifneq ($(MY_CONFIG_BAR),)
MY_SOURCES += bar.c
endif
LOCAL_SRC_FILES += $(MY_SOURCES)
注意：‘:=’是赋值的意思；'+='是追加的意思；‘$’表示引用某变量的值。
三、GNU Make系统变量
这些 GNU Make变量在你的 Android.mk 文件解析之前，就由编译系统定义好了。注意在
某些情况下，NDK可能分析 Android.mk 几次，每一次某些变量的定义会有不同。
（1）CLEAR_VARS: 指向一个编译脚本，几乎所有未定义的 LOCAL_XXX 变量都在"Module-description"节中列出。必须在开始一个新模块之前包含这个脚本：include$(CLEAR_VARS)，用于重置除LOCAL_PATH变量外的，所有LOCAL_XXX系列变量。
（2）BUILD_SHARED_LIBRARY: 指向编译脚本，根据所有的在 LOCAL_XXX 变量把列出的源代码文件编译成一个共享库。
注意，必须至少在包含这个文件之前定义 LOCAL_MODULE 和 LOCAL_SRC_FILES。
（3） BUILD_STATIC_LIBRARY: 一个 BUILD_SHARED_LIBRARY 变量用于编译一个静态库。静态库不会复制到的APK包中，但是能够用于编译共享库。
示例：include $(BUILD_STATIC_LIBRARY)
注意，这将会生成一个名为 lib$(LOCAL_MODULE).a 的文件
（4）TARGET_ARCH: 目标 CPU平台的名字, 和 android 开放源码中指定的那样。如果是
arm，表示要生成 ARM 兼容的指令，与 CPU架构的修订版无关。
（5）TARGET_PLATFORM: Android.mk 解析的时候，目标 Android 平台的名字.详情可参考/development/ndk/docs/stable- apis.txt.
android-3 -> Official Android 1.5 system images
android-4 -> Official Android 1.6 system images
android-5 -> Official Android 2.0 system images
（6）TARGET_ARCH_ABI: 暂时只支持两个 value，armeabi 和 armeabi-v7a。在现在的版本中一般把这两个值简单的定义为 arm，通过 android 平台内部对它重定义来获得更好的匹配。其他的 ABI 将在以后的 NDK 版本中介绍，它们会有不同的名字。注意虽然所有基于
ARM的ABI都会把 'TARGET_ARCH'定义成‘arm’，但是会有不同的‘TARGET_ARCH_ABI’。
（ 7 ） TARGET_ABI: 目标平台和 ABI 的组合，它事实上被定义成$(TARGET_PLATFORM)-$(TARGET_ARCH_ABI) ，在想要在真实的设备中针对一个特别的目标系统进行测试时，会有用。在默认的情况下，它会是'android-3-arm'。
五、模块描述变量
下面的变量用于向编译系统描述你的模块。你应该定义在'include $(CLEAR_VARS)'和'include $(BUILD_XXXXX)'之间。正如前面描写的那样，$(CLEAR_VARS)是一个脚本，清除所有这些变量。
（1） LOCAL_PATH: 这个变量用于给出当前文件的路径。必须在 Android.mk 的开头定义，可以这样使用：LOCAL_PATH := $(call my-dir) 这个变量不会被$(CLEAR_VARS)清除，因此每个 Android.mk 只需要定义一次(即使在一个文件中定义了几个模块的情况下)。
（2）LOCAL_MODULE: 这是模块的名字，它必须是唯一的，而且不能包含空格。必须在包含任一的$(BUILD_XXXX)脚本之前定义它。模块的名字决定了生成文件的名字。例如，如果一个一个共享库模块的名字是，那么生成文件的名字就是 lib.so。但是，在的 NDK 生成文
件中(或者 Android.mk 或者 Application.mk)，应该只涉及(引用)有正常名字的其他模块。
（3）LOCAL_SRC_FILES: 这是要编译的源代码文件列表。只要列出要传递给编译器的文件，因为编译系统自动计算依赖。注意源代码文件名称都是相对于 LOCAL_PATH的，你可以使用路径部分，例如：
LOCAL_SRC_FILES := foo.c toto/bar.c\
Hello.c
文件之间可以用空格或Tab键进行分割,换行请用"\".如果是追加源代码文件的话，请用LOCAL_SRC_FILES +=
注意：在生成文件中都要使用UNIX风格的斜杠(/).windows风格的反斜杠不会被正确的处理。
注意：可以LOCAL_SRC_FILES := $(call all-subdir-java-files)这种形式来包含local_path目录下的所有java文件。
（4） LOCAL_CPP_EXTENSION: 这是一个可选变量，用来指定C++代码文件的扩展名，默认是'.cpp',但是可以改变它，比如：
LOCAL_CPP_EXTENSION := .cxx
（5） LOCAL_C_INCLUDES: 可选变量，表示头文件的搜索路径。默认的头文件的搜索路径是LOCAL_PATH目录。
示例:LOCAL_C_INCLUDES := sources/foo或LOCAL_C_INCLUDES := $(LOCAL_PATH)/../foo
LOCAL_C_INCLUDES需要在任何包含LOCAL_CFLAGS/LOCAL_CPPFLAGS标志之前进行设置。
（6）LOCAL_CFLAGS: 可选的编译器选项，在编译 C 代码文件的时候使用。这可能是有
用的，指定一个附加的包含路径(相对于NDK的顶层目录)，宏定义，或者编译选项。
注意：不要在 Android.mk 中改变 optimization/debugging 级别，只要在 Application.mk 中指定合适的信息，就会自动地为你处理这个问题，在调试期间，会让 NDK自动生成有用的数据文件。
（7）LOCAL_CXXFLAGS: 与 LOCAL_CFLAGS同理，针对 C++源文件。
（8）LOCAL_CPPFLAGS: 与 LOCAL_CFLAGS同理，但是对 C 和 C++ source files都适用。
（9）LOCAL_STATIC_LIBRARIES: 表示该模块需要使用哪些静态库，以便在编译时进行链接。
（10）LOCAL_SHARED_LIBRARIES: 表示模块在运行时要依赖的共享库（动态库），在链接时就需要，以便在生成文件时嵌入其相应的信息。注意：它不会附加列出的模块到编译图，也就是仍然需要在Application.mk 中把它们添加到程序要求的模块中。
（11）LOCAL_LDLIBS: 编译模块时要使用的附加的链接器选项。这对于使用‘-l’前缀传递指定库的名字是有用的。
例如，LOCAL_LDLIBS := -lz表示告诉链接器生成的模块要在加载时刻链接到/system/lib/libz.so
可查看 docs/STABLE-APIS.TXT 获取使用 NDK发行版能链接到的开放的系统库列表。
（12） LOCAL_ALLOW_UNDEFINED_SYMBOLS: 默认情况下，在试图编译一个共享库时，任何未定义的引用将导致一个“未定义的符号”错误。这对于在源代码文件中捕捉错误会有很大的帮助。然而，如果因为某些原因，需要不启动这项检查，可把这个变量设为‘true’。
注意相应的共享库可能在运行时加载失败。(这个一般尽量不要去设为 true)。
（13） LOCAL_ARM_MODE: 默认情况下， arm目标二进制会以 thumb 的形式生成(16 位)，你可以通过设置这个变量为 arm如果你希望你的 module 是以 32 位指令的形式。
'arm' (32-bit instructions) mode. E.g.:
LOCAL_ARM_MODE := arm
注意：可以在编译的时候告诉系统针对某个源码文件进行特定的类型的编译
比如，LOCAL_SRC_FILES := foo.c bar.c.arm 这样就告诉系统总是将 bar.c 以arm的模式编译。
(14)LOCAL_MODULE_PATH 和 LOCAL_UNSTRIPPED_PATH
在 Android.mk 文件中，还可以用LOCAL_MODULE_PATH 和LOCAL_UNSTRIPPED_PATH指定最后的目标安装路径.
不同的文件系统路径用以下的宏进行选择：
TARGET_ROOT_OUT：表示根文件系统。
TARGET_OUT：表示 system文件系统。
TARGET_OUT_DATA：表示 data文件系统。
用法如：LOCAL_MODULE_PATH :=$(TARGET_ROOT_OUT)
至于LOCAL_MODULE_PATH 和LOCAL_UNSTRIPPED_PATH的区别，暂时还不清楚。
七、GNU Make‘功能’宏
GNU Make‘功能’宏，必须通过使用'$(call )'来调用，调用他们将返回文本化的信息。
（1）my-dir:返回当前 Android.mk 所在的目录的路径，相对于 NDK 编译系统的顶层。这是有用的，在 Android.mk 文件的开头如此定义：
LOCAL_PATH := $(call my-dir)
（2）all-subdir-makefiles: 返回一个位于当前'my-dir'路径的子目录中的所有Android.mk的列表。
例如，看下面的目录层次：
sources/foo/Android.mk
sources/foo/lib1/Android.mk
sources/foo/lib2/Android.mk
如果 sources/foo/Android.mk 包含一行：
include $(call all-subdir-makefiles)
那么它就会自动包含 sources/foo/lib1/Android.mk 和 sources/foo/lib2/Android.mk。
这项功能用于向编译系统提供深层次嵌套的代码目录层次。
注意，在默认情况下，NDK 将会只搜索在 sources/*/Android.mk 中的文件。
（3）this-makefile: 返回当前Makefile 的路径(即这个函数调用的地方)
（4）parent-makefile: 返回调用树中父 Makefile 路径。即包含当前Makefile的Makefile 路径。
（5）grand-parent-makefile：返回调用树中父Makefile的父Makefile的路径
八、 Android.mk 使用模板
在一个 Android.mk 中可以生成多个APK应用程序，JAVA库，C\C++可执行程序,C\C++动态库和C\C++静态库。
（1）编译APK应用程序模板。
关于编译APK应用程序的模板请参照《Android.mk编译APK范例》
（2）编译JAVA库模板
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
# Build all java files in the java subdirectory
LOCAL_SRC_FILES := $(call all-subdir-java-files)
# Any libraries that this library depends on
LOCAL_JAVA_LIBRARIES := android.test.runner
# The name of the jar file to create
LOCAL_MODULE := sample
# Build a static jar file.
include $(BUILD_STATIC_JAVA_LIBRARY)
注：LOCAL_JAVA_LIBRARIES := android.test.runner表示生成的JAVA库的jar文件名
（3）编译C/C++应用程序模板如下：
LOCAL_PATH := $(call my-dir)
#include $(CLEAR_VARS)
LOCAL_SRC_FILES := main.c
LOCAL_MODULE := test_exe
#LOCAL_C_INCLUDES :=
#LOCAL_STATIC_LIBRARIES :=
#LOCAL_SHARED_LIBRARIES :=
include $(BUILD_EXECUTABLE)
注：‘:=’是赋值的意思，'+='是追加的意思，‘$’表示引用某变量的值
LOCAL_SRC_FILES中加入源文件路径，LOCAL_C_INCLUDES中加入需要的头文件搜索路径
LOCAL_STATIC_LIBRARIES 加入所需要链接的静态库(*.a)的名称，
LOCAL_SHARED_LIBRARIES 中加入所需要链接的动态库(*.so)的名称，
LOCAL_MODULE表示模块最终的名称，BUILD_EXECUTABLE 表示以一个可执行程序的方式进行编译。
（4）编译C\C++静态库
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_SRC_FILES := \
helloworld.c
LOCAL_MODULE:= libtest_static
#LOCAL_C_INCLUDES :=
#LOCAL_STATIC_LIBRARIES :=
#LOCAL_SHARED_LIBRARIES :=
include $(BUILD_STATIC_LIBRARY)
和上面相似，BUILD_STATIC_LIBRARY 表示编译一个静态库。
（5）编译C\C++动态库的模板
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_SRC_FILES := helloworld.c
LOCAL_MODULE := libtest_shared
TARGET_PRELINK_MODULES := false
#LOCAL_C_INCLUDES :=
#LOCAL_STATIC_LIBRARIES :=
#LOCAL_SHARED_LIBRARIES :=
include $(BUILD_SHARED_LIBRARY)
和上面相似，BUILD_SHARED_LIBRARY 表示编译一个共享库。
以上三者的生成结果分别在如下目录中，generic 依具体 target 会变：
out/target/product/generic/obj/APPS
out/target/product/generic/obj/JAVA_LIBRARIES
out/target/product/generic/obj/EXECUTABLE
out/target/product/generic/obj/STATIC_LIBRARY
out/target/product/generic/obj/SHARED_LIBRARY
每个模块的目标文件夹分别为：
1）APK程序：XXX_intermediates
2）JAVA库程序：XXX_intermediates
这里的XXX
3）C\C++可执行程序：XXX_intermediates
4）C\C++静态库： XXX_static_intermediates
5）C\C++动态库： XXX_shared_intermediates

Android NDK 在小米2 中的调试

近几天一直在捣鼓Eclipse下面直接调试NDK ,以前都是从命令行中直接调试，现在听说现在Google已经发布了新的支持Eclipse直接调试的SDK ，心中甚为欣喜，本以为可以很快解决问题，没想到折腾了许久。

1. Android ADT的BUG

ADT 的Eclipse插件从r20 开始就已经支持通过CDT 直接调试NDK ，但是有一个问题，他只支持CDT 8.01以下的版本，原因在于CDT 升级到8.1的时候，修改了文件索引器部分的逻辑，也就是我们按F3可以来回跳转到制定文件的那个东东，导致Android的ADT不能与CDT进行很好的配合，于是编译的时候报告一堆的文件找不到。实际上直接编译是没有问题的，问题不是编译器的问题。

关于这个问题的基本描述在 http://tools.android.com/recent 这个链接上面，因为经常会被墙，索性截图，如下

这个页面中比较详细的描述了怎么使用NDK ，但是请注意从下面的这个 BUG 33788 这个就是讨论了不能在最新的Eclipse 4.2 和CDT8.1上不能正确使用的原因。了解详情的，可以看看这个链接里面的详细讨论。

不过比较欣慰的是，在 ADT 21 Preview 2 中修复了这个问题。但是目前这个版本还没有发布，因此我们要配置ADT到Preview通道。具体的配置信息链接 http://tools.android.com/preview-channel 同样配置一下截图

配置完成之后，最好重建一下工程，基本上提示错误的情况发生的不会太频繁，但是似乎仍旧会发生。也就是这个补丁还不怎么稳定。

一旦还是发生找不到JNI之类的问题，一般可以通过如下图操作来暂时处理掉

2. run-as: Package '<PACKAGE_NAME>' has corrupt installation

根据提示信息，貌似软件包没有正确安装造成的，反复安装调试了很多次，结果照旧，于是怀疑是不是某些其他原因。

好在Android是开源的，那么就比较好处理了，从 4.01的源代码中提取出 run-as部分的源代码，然后调整编译，在可能出问题的地方增加输出，看看到底是什么原因造成的，结果还真找到了。分离出来的源代码以及在此下载 run-as.zip

出问题的代码位置如下

/* must not be readable or writable by others */
if ((st.st_mode & (S_IROTH|S_IWOTH)) != 0)

1 2	/* must not be readable or writable by others */ if ((st.st_mode & (S_IROTH\|S_IWOTH)) != 0)

这句话，意思是目录的权限中，others用户是不能有读写权限的，这个目录就是 /data

源代码的编译是在run-as目录下面执行NDK-Build即可生成的可执行文件run-as在 obj/local/armeabi 目录下面。通过 adb push run-as /system/bin/run-as-log 命令把这个文件放到手机，如果提示没有权限或者只读，请参考这个小米 2 adb remount failed解决办法

注意千万不要动系统自带的run-as 否则系统重启之后，往往起不来。

然后执行

adb shell run-as-log com.aa.bb

1	adb shell run-as-log com.aa.bb

来看看他的输出

"path ="/data" must not be readable or writable by others st.st_mode = 71ff ,S_IROTH= 4 S_IWOTH =2"

1	"path ="/data" must not be readable or writable by others st.st_mode = 71ff ,S_IROTH= 4 S_IWOTH =2"

也就是 run-as 要求 /data目录是不能有others用户的读写权限的。否则就会失败。根本就不是安装错误。

解决方法

adb shell
su #使用root权限（手机已root）
ls -l /data

adb shell

su #使用root权限（手机已root）

ls -l /data

权限信息如下：

4、修改权限

chmod 771 /data
chown system.system /data

1 2	chmod 771 /data chown system.system /data

5、再次执行

ls -l /data

1	ls -l /data

注意，似乎手机重启之后，设置又会还原掉，因此到时候还是需要重新设置。

简单描述一下图中的 chmod函数的参数，注意这个 drwxrwxrwx root root .其中 r = read 定义为 0x004 ,w = write 定义为 0x002 ,x = execute 定义为 0x001 , 那么 rwx 都拥有的话，就是 r | w|x = 7

rwxrwxrwx 分为三组用户依次为，文件拥有者的权限，文件拥有者所在用户组的权限，其他用户的权限

因此 chmod 771 就表示文件拥有者的权限有 r|w|x的全部权限，而其他用户只有执行权限。

java中的native关键字

转载 http://www.blogjava.net/shiliqiang/articles/287920.html

JNI 是Java Native Interface的缩写。从Java 1.1开始，Java Native Interface (JNI)标准成为java平台的一部分，它允许Java代码和其他语言写的代码进行交互。JNI一开始是为了本地已编译语言，尤其是C和C++而设计的，但是它并不妨碍你使用其他语言，只要调用约定受支持就可以了。

使用java与本地已编译的代码交互，通常会丧失平台可移植性。但是，有些情况下这样做是可以接受的，甚至是必须的，比如，使用一些旧的库，与硬件、操作系统进行交互，或者为了提高程序的性能。JNI标准至少保证本地代码能工作在任何Java 虚拟机实现下。

JNI（Java Native Interface）的书写步骤

·编写带有native声明的方法的java类
·使用javac命令编译所编写的java类
·使用javah ?jni java类名生成扩展名为h的头文件
·使用C/C++（或者其他编程想语言）实现本地方法
·将C/C++编写的文件生成动态连接库

1) 编写java程序：
这里以HelloWorld为例。
代码1：

class HelloWorld {
public native void displayHelloWorld();

static {
System.loadLibrary("hello");
}

public static void main(String[] args) {
new HelloWorld().displayHelloWorld();
}
}

class HelloWorld {

public native void displayHelloWorld();

static {

System.loadLibrary("hello");

}

public static void main(String[] args) {

new HelloWorld().displayHelloWorld();

}

声明native方法：如果你想将一个方法做为一个本地方法的话，那么你就必须声明改方法为native的，并且不能实现。其中方法的参数和返回值在后面讲述。

Load 动态库：System.loadLibrary("hello");加载动态库（我们可以这样理解：我们的方法displayHelloWorld()没有实现，但是我们在下面就直接使用了，所以必须在使用之前对它进行初始化）这里一般是以static块进行加载的。同时需要注意的是 System.loadLibrary();的参数“hello”是动态库的名字。
main()方法
2) 编译没有什么好说的了

javac HelloWorld.java

1	javac HelloWorld.java

3) 生成扩展名为h的头文件

javah /jni HelloWorld

1	javah /jni HelloWorld

头文件的内容：

/* DO NOT EDIT THIS FILE - it is machine generated */
#include
/* Header for class HelloWorld */

#ifndef _Included_HelloWorld
#define _Included_HelloWorld
#ifdef __cplusplus
extern "C" {
#endif
/*
* Class: HelloWorld
* Method: displayHelloWorld
* Signature: ()V
*/
JNIEXPORT void JNICALL Java_HelloWorld_displayHelloWorld
(JNIEnv *, jobject);

#ifdef __cplusplus
}
#endif
#endif

/* DO NOT EDIT THIS FILE - it is machine generated */

#include

/* Header for class HelloWorld */

#ifndef _Included_HelloWorld

#define _Included_HelloWorld

#ifdef __cplusplus

extern "C" {

#endif

* Class: HelloWorld

* Method: displayHelloWorld

* Signature: ()V

JNIEXPORT void JNICALL Java_HelloWorld_displayHelloWorld

(JNIEnv *, jobject);

#ifdef __cplusplus

}

#endif

（这里我们可以这样理解：这个h文件相当于我们在java里面的接口，这里声明了一个Java_HelloWorld_displayHelloWorld (JNIEnv *, jobject);方法，然后在我们的本地方法里面实现这个方法，也就是说我们在编写C/C++程序的时候所使用的方法名必须和这里的一致）。

4) 编写本地方法
实现和由javah命令生成的头文件里面声明的方法名相同的方法。
代码2：

#include "jni.h"
#include "HelloWorld.h"

JNIEXPORT void JNICALL Java_HelloWorld_displayHelloWorld(JNIEnv *env, jobject obj)
{
printf("Hello world!\n");
return;
}

#include "jni.h"

#include "HelloWorld.h"

JNIEXPORT void JNICALL Java_HelloWorld_displayHelloWorld(JNIEnv *env, jobject obj)

{

printf("Hello world!\n");

return;

}

注意代码2中的第1行，需要将jni.h（该文件可以在%JAVA_HOME%/include文件夹下面找到）文件引入，因为在程序中的JNIEnv、 jobject等类型都是在该头文件中定义的；另外在第2行需要将HelloWorld.h头文件引入（我是这么理解的：相当于我们在编写java程序的时候，实现一个接口的话需要声明才可以，这里就是将HelloWorld.h头文件里面声明的方法加以实现。当然不一定是这样）。然后保存为 HelloWorldImpl.c就 ok了。

5) 生成动态库
这里以在Windows中为例，需要生成dll文件。在保存HelloWorldImpl.c文件夹下面，使用VC的编译器cl成。

cl -I%java_home%\include -I%java_home%\include\win32 -LD HelloWorldImp.c -Fehello.dll

1	cl -I%java_home%\include -I%java_home%\include\win32 -LD HelloWorldImp.c -Fehello.dll

注意：生成的dll文件名在选项-Fe后面配置，这里是hello，因为在HelloWorld.java文件中我们loadLibary的时候使用的名字是hello。当然这里修改之后那里也需要修改。另外需要将-I%java_home%\include -I%java_home%\include\win32参数加上，因为在第四步里面编写本地方法的时候引入了jni.h文件。

6) 运行程序

java HelloWorld

1	java HelloWorld

JNI（Java Native Interface）调用中考虑的问题

在首次使用JNI的时候有些疑问，后来在使用中一一解决，下面就是这些问题的备忘：

1. java和c是如何互通的？
其实不能互通的原因主要是数据类型的问题，jni解决了这个问题，例如那个c文件中的jstring数据类型就是java传入的String对象，经过jni函数的转化就能成为c的char*。
对应数据类型关系如下表：
Java 类型本地c类型说明
boolean jboolean 无符号，8 位
byte jbyte 无符号，8 位
char jchar 无符号，16 位
short jshort 有符号，16 位
int jint 有符号，32 位
long jlong 有符号，64 位
float jfloat 32 位
double jdouble 64 位
void void N/A

2. 如何将java传入的String参数转换为c的char*，然后使用?
java 传入的String参数，在c文件中被jni转换为jstring的数据类型，在c文件中声明char* test，然后test = (char*)(*env)->GetStringUTFChars(env, jstring, NULL);注意：test使用完后，通知虚拟机平台相关代码无需再访问：(*env)->ReleaseStringUTFChars(env, jstring, test);

3. 将c中获取的一个char*的buffer传递给java？
这个char*如果是一般的字符串的话，作为string传回去就可以了。如果是含有’\0’的buffer，最好作为bytearray传出，因为可以制定copy的length，如果copy到string，可能到’\0’就截断了。
有两种方式传递得到的数据：
一种是在jni中直接new一个byte数组，然后调用函数(*env)->SetByteArrayRegion(env, bytearray, 0, len, buffer);将buffer的值copy到bytearray中，函数直接return bytearray就可以了。
一种是return错误号，数据作为参数传出，但是java的基本数据类型是传值，对象是传递的引用，所以将这个需要传出的byte数组用某个类包一下，如下：

class RetObj
{
public byte[] bytearray;
}

class RetObj

{

public byte[] bytearray;

}

这个对象作为函数的参数retobj传出，通过如下函数将retobj中的byte数组赋值便于传出。代码如下：

jclass cls;
jfieldID fid;
jbyteArray bytearray;
bytearray = (*env)->NewByteArray(env,len);
(*env)->SetByteArrayRegion(env, bytearray, 0, len, buffer);
cls = (*env)->GetObjectClass(env, retobj);
fid = (*env)->GetFieldID(env, cls, "retbytes", "[B"]);
(*env)->SetObjectField(env, retobj, fid, bytearray);

jclass cls;

jfieldID fid;

jbyteArray bytearray;

bytearray = (*env)->NewByteArray(env,len);

(*env)->SetByteArrayRegion(env, bytearray, 0, len, buffer);

cls = (*env)->GetObjectClass(env, retobj);

fid = (*env)->GetFieldID(env, cls, "retbytes", "[B"]);

(*env)->SetObjectField(env, retobj, fid, bytearray);

4. 不知道占用多少空间的buffer，如何传递出去呢？

在jni的c文件中new出空间，传递出去。java的数据不初始化，指向传递出去的空间即可。

2024 年 7 月
一	二	三	四	五	六	日
1	2	3	4	5	6	7
8	9	10	11	12	13	14
15	16	17	18	19	20	21
22	23	24	25	26	27	28
29	30	31