## 基本模型

电机模型：

$$V_m=i_aR_a+L_a\frac{di_a}{dt}+E_b$$

反电动势 (emf) $$E_{b}$$ 与角速度 $$ \dot{\varphi} $$ 相关。

$$E_{b}=K_{b}\dot{\varphi}$$

因为：$$L_a<<R_a$$

所以：
$$i_a=\frac{V_m-K_b \dot{\varphi}}{R_a}$$

电机转矩 $\tau$ 和反电动势 (emf) 有关：

$$
\tau=K_t i_a=K_t \frac{V_m-K_b \dot{\varphi}}{R_a} (公式4)
$$


![image.png](/static/img/443e2914b6d6a197c25f86049b19c8d5.image.webp)





| 符号 | 单位 | 定义                           |
| ---- | ---- | ------------------------------ |
| θ    | rad  | 摆杆角度                       |
| φ    | rad  | 惯性轮角度                     |
| J₁   | kg.m²| 包括电机定子的摆杆转动惯量     |
| J₂   | kg.m²| 包括电机转子的轮子转动惯量     |
| c₁   | N.m.s/rad | 摆杆摩擦系数               |
| c₂   | N.m.s/rad | 轮子摩擦系数               |
| m₁   | kg   | 摆杆和定子的质量               |
| m₂   | kg   | 轮子和转子的质量               |
| l₁   | m    | 从原点到摆杆重心的长度         |
| l₂   | m    | 从原点到轮子重心的长度         |
| Kb   | V/(rad/s) | 反电动势常数               |
| Kt   | N.m/A | 电机扭矩常数                  |
| Ra   | Ω    | 电枢绕组电阻                   |

- 平动动能 Translational kinetic: 

$$
T_1=\frac{1}{2} m_1\left(l_1 \dot{\theta}\right)^2+\frac{1}{2} m_2\left(l_2 \dot{\theta}\right)^2 (公式6)
$$

- 转动动能 Rotational kinetic:

$$
T_2=\frac{1}{2} J_1 \dot{\theta}^2+\frac{1}{2} J_2(\dot{\theta}+\dot{\varphi})^2(公式7)
$$


系统的动能：

$$
\begin{aligned}
T & =T_1+T_2 \\
& =\frac{1}{2}\left(m_1 l_1^2+m_2 l_2^2+J_1+J_2\right) \dot{\theta}^2+J_2 \dot{\theta} \dot{\varphi}+\frac{1}{2} J_2 \dot{\varphi}^2
\end{aligned} (公式8)
$$

以O点作为势能的基准。因此，势能为：

$$
V=\left(m_1 l_1+m_2 l_2\right) g \cos (\theta)(公式9)
$$


平面倒立摆的拉格朗日函数为：

$$
\begin{aligned}
L & =T-V=\frac{1}{2}\left(m_1 l_1^2+m_2 l_2^2+J_1+J_2\right) \dot{\theta}^2 \\
& +J_2 \dot{\theta} \dot{\varphi}+\frac{1}{2} J_2 \dot{\varphi}^2-\left(m_1 l_1+m_2 l_2\right) g \cos (\theta)
\end{aligned}(公式10)
$$

耗散能量：

$$
R=\frac{1}{2} c_1 \dot{\theta}^2+\frac{1}{2} c_2 \dot{\varphi}^2(公式11)
$$


从拉格朗日方程得到的关于 θ 的旋转轴上的力矩为，这个公式是最后一个公式需要用的：

$$
\begin{gathered}
\frac{d}{d t}\left(\frac{\partial L}{\partial \dot{\theta}}\right)+\frac{\partial R}{\partial \dot{\theta}}-\frac{\partial L}{\partial \theta}=0 (公式12)\\ 
\Leftrightarrow\left(m_1 l_1^2+m_2 l_2^2+J_1+J_2\right) \ddot{\theta}+J_2 \ddot{\varphi}+c_1 \dot{\theta} -\left(m_1 l_1+m_2 l_2\right) g \sin (\theta)=0
(公式13)\end{gathered} 
$$


从拉格朗日方程得到的关于 φ 的旋转轴上的力矩为：

$$
\begin{aligned}
& \frac{d}{d t}\left(\frac{\partial L}{\partial \dot{\varphi}}\right)+\frac{\partial R}{\partial \dot{\varphi}}-\frac{\partial L}{\partial \varphi}=0 (公式14)\\
& \Leftrightarrow J_2(\ddot{\theta}+\ddot{\varphi})+c_2 \dot{\varphi}=\tau
(公式15)\end{aligned}
$$

$$\tau$$ 是电机的扭矩。

因为：

$$
\tau=K_t i_a=K_t \frac{V_m-K_b \dot{\varphi}}{R_a}(公式4)
$$

由公式4和公式15可以得到：

$$
J_2(\ddot{\theta}+\ddot{\varphi})+c_2 \dot{\varphi}=K_t \frac{V_m-K_b \dot{\varphi}}{R_a}(公式16)
$$


由公式13和公式16，平面倒立摆的非线性模型为：

$$
\begin{aligned}
& {\left[\begin{array}{cc}
m_1 l_1^2+m_2 l_2^2+J_1+J_2 & J_2 \\
J_2 & J_2
\end{array}\right]\left[\begin{array}{c}
\ddot{\theta} \\
\ddot{\varphi}
\end{array}\right]+\left[\begin{array}{cc}
c_1 & 0 \\
0 & \frac{K_t K_b}{R_a}+c_2
\end{array}\right]\left[\begin{array}{c}
\dot{\theta} \\
\dot{\varphi}
\end{array}\right]} \\
& +\left[\begin{array}{c}
-\left(m_1 l_1+m_2 l_2\right) g \sin (\theta) \\
0
\end{array}\right]=\left[\begin{array}{c}
0 \\
\frac{K_t}{R_a}
\end{array}\right] V_m (公式17)
\end{aligned}
$$



给IWP的参数：

| Symbol | Value                | Symbol | Value               |
|--------|----------------------|--------|---------------------|
| J₁     | 0.01186 (kg·m²)      | l₁     | 0.1053 (m)          |
| J₂     | 0.0005711 (kg·m²)    | l₂     | 0.14 (m)            |
| c₁     | 0.04 (N·m·s/rad)     | K_b    | 0.0987 (V/(rad/s))  |
| c₂     | 0.0001 (N·m·s/rad)   | K_t    | 0.0987 (N·m/A)      |
| m₁     | 0.826 (kg)           | R_a    | 1.5562 (Ω)          |
| m₂     | 0.583 (kg)           |        |                     |

- 电压输入 $V_{\mathrm{m}}$ 是控制变量
- 四个状态变量分别是 $\theta, \dot{\theta}, \varphi$ 和 $\dot{\varphi}$
- 输出扭矩 $\tau$ 根据方程 (4) 计算


## 控制变量法-Vm 分析

从Simulink模型中，电压输入 $V_{\mathrm{m}}$ 以10V、15V和20V的步进形式施加。电压输入引起了车轮和摆锤的运动，如图8所示。

仿真结果表明：
- 在图8.a中，车轮的速度在约0.5秒时达到稳态。同时，直流电动机在车轮上产生一个力矩，如图8.b所示，惯性轮以一定的加速度旋转，如图8.c所示。摆锤被力矩驱动并围绕平衡位置摆动。从图8.d可以看出，较高的 $V_{\mathrm{m}}$ 使得摆锤角度的振幅更大，这表明在摆锤上生成的力更大。然而，摆锤的振荡频率在所有情况下都是相同的，这意味着 $V_{\mathrm{m}}$ 不影响摆锤的振荡频率。
- 当车轮速度进入稳态时，如图8.b所示，电机无法长时间维持转子力矩。在这个状态下，该力矩将等于摩擦力矩，车轮的加速度为零，摆锤仅受重力影响，并逐渐回到平衡位置 oscillates gradually back to equilibrium position。


![image.png](/static/img/a7f8cf356cde40cfba728c94bd90acaf.image.webp)

## 控制变量法-l2 分析
在图 9.a、9.b、9.c 中，所有情形的响应都是相同的，这意味着 l2 对惯性轮运动的响应没有影响。然而，当 l2 改变时，摆的角度是不同的。在给电机相同电压的情况下，较大的 l2 会导致摆角幅度较小，这意味着作用在摆上的总力较小。此外，振荡频率较低且更稳定。

摆的长度会影响作用于摆上的力。选择适合 l2 的电机是有用的。较大的 l2 对摆角响应有负面影响。


![image.png](/static/img/c5e6f22fccc804c33bd284f00bc32e4d.image.webp)

## 控制变量法-J2 分析

另一个重要的IWP参数是飞轮的惯性矩J2。与l2的情况相同，直流电机将接收到20V的阶跃输入Vm。J2的值在0.0005kg.m²、0.002kg.m²和0.005kg.m²之间变化。其他参数保持与表2中一致。仿真结果显示：

1. 在图10.a中，飞轮速度的定常时间随着J2的增加而变长，但稳态值在所有情况下都相同。在短时间内，电机扭矩在0秒时相同，但随着J2的增加，其影响时间也变长，如图10.b所示。在图10.c中，飞轮的加速度在0秒时不同：惯性矩较小的飞轮在起始时的加速度较高，但更快趋于零。

2. 因此，在图10.d中，摆角的振幅在J2较大时也较大，这是因为电机扭矩的影响时间更长。
3. J2对电机的加速过程有积极影响，因此较大的J2有助于保持摆动的动量，但系统的质量也会增加。


![image.png](/static/img/53e12dd23645b013e490f3c412df571b.image.webp)

## 控制变量法-质量m2分析

最后一个要模拟的参数是飞轮的质量m2。与l2、J2相似，直流电机将接收到20V的阶跃输入Vm，并将m2的值改变为0.5kg、0.8kg和1kg。其他参数保持不变。仿真结果显示：

1. 从图11.a、11.b、11.c可以看出，所有m2的情况下，飞轮的速度、加速度和电机扭矩相同。因此，飞轮的质量对上述物理参数的响应没有影响。
2. 从图11.d可以看出，较大的m2使得摆角的振幅较小，这是由于重力的影响。
3. m2对系统的性能有负面影响。


![image.png](/static/img/bfd4f1b4552573d2aa02b129242b0670.image.webp)


## 对公式17的理解


### 动能与势能公式：
$$
T = \frac{1}{2}\left(m_1 l_1^2 + m_2 l_2^2 + J_1 + J_2\right) \dot{\theta}^2 + J_2 \dot{\theta} \dot{\varphi} + \frac{1}{2} J_2 \dot{\varphi}^2
$$
$$
V = \left(m_1 l_1 + m_2 l_2\right) g \cos(\theta)
$$

### 拉格朗日方程导出：
$$
(m_1 l_1^2 + m_2 l_2^2 + J_1 + J_2) \ddot{\theta} + J_2 \ddot{\varphi} + c_1 \dot{\theta} - \left(m_1 l_1 + m_2 l_2\right) g \sin(\theta) = 0
$$
$$
J_2(\ddot{\theta} + \ddot{\varphi}) + c_2 \dot{\varphi} = \tau
$$
$$
\tau = K_t \frac{V_m - K_b \dot{\varphi}}{R_a}
$$

### 矩阵方程：
$$
\begin{aligned}
 & \left[\begin{array}{cc}
m_1 l_1^2 + m_2 l_2^2 + J_1 + J_2 & J_2 \\
J_2 & J_2
\end{array}\right] \left[\begin{array}{c}
\ddot{\theta} \\
\ddot{\varphi}
\end{array}\right] + \left[\begin{array}{cc}
c_1 & 0 \\
0 & \frac{K_t K_b}{R_a} + c_2
\end{array}\right] \left[\begin{array}{c}
\dot{\theta} \\
\dot{\varphi}
\end{array}\right] \\
& + \left[\begin{array}{c}
- \left(m_1 l_1 + m_2 l_2\right) g \sin(\theta) \\
0
\end{array}\right] = \left[\begin{array}{c}
0 \\
\frac{K_t}{R_a} V_m
\end{array}\right]
\end{aligned}
$$

结合矩阵形式，含有状态方程 $\theta$ 和 $\varphi$ 的运动方程可以理解为：

### 使用矩阵表示：
$$
A \left[\begin{array}{c}
\ddot{\theta} \\
\ddot{\varphi}
\end{array}\right] = -B \left[\begin{array}{c}
\dot{\theta} \\
\dot{\varphi}
\end{array}\right] + C
$$

其中：
$$
A = \left[\begin{array}{cc}
m_1 l_1^2 + m_2 l_2^2 + J_1 + J_2 & J_2 \\
J_2 & J_2
\end{array}\right]
$$
$$
B = \left[\begin{array}{cc}
c_1 & 0 \\
0 & \frac{K_t K_b}{R_a} + c_2
\end{array}\right]
$$
$$
C = \left[\begin{array}{c}
- (m_1 l_1 + m_2 l_2) g \sin(\theta) \\
\frac{K_t}{R_a} V_m
\end{array}\right]
$$

将 $\tau$ 代入第二个方程：
$$
J_2 (\ddot{\theta} + \ddot{\varphi}) + c_2 \dot{\varphi} = K_t \frac{V_m - K_b \dot{\varphi}}{R_a}
$$

将矩阵形式重写：
$$
A \ddot{X} = -B \dot{X} + C
$$


## 代码里acceleration是什么

在 MATLAB 中，`A \ b` 表示将线性方程组 $A x = b$ 解出 $x$，即 $x = A^{-1} b$。这个操作称为“左除”运算符，用于求解涉及矩阵的线性方程。

现在详细解释这行代码：

```matlab
acceleration = A \ (-B * [theta_dot; phi_dot] + C);
```

### 背景和公式推导

我们原来推导的系统方程是：
$$
A \ddot{X} = -B \dot{X} + C
$$

其中:
- $\ddot{X}$ 表示系统的加速度
- $\dot{X}$ 表示系统的速度
- $A$、$B$ 和 $C$ 是系统的参数矩阵和向量

### 分解解释

1. **矩阵定义:**
    - $A$:
    $$
    A = \begin{pmatrix}
    m_1 l_1^2 + m_2 l_2^2 + J_1 + J_2 & J_2 \\
    J_2 & J_2
    \end{pmatrix}
    $$
    
    - $B$:
    $$
    B = \begin{pmatrix}
    c_1 & 0 \\
    0 & \frac{K_t K_b}{R_a} + c_2
    \end{pmatrix}
    $$
   
    - $C$:
    $$
    C = \begin{pmatrix}
    - (m_1 l_1 + m_2 l_2) g \sin(\theta) \\
    \frac{K_t}{R_a} V_m
    \end{pmatrix}
    $$

2. **速度向量 $\dot{X}$:**
    $$ \dot{X} = \begin{pmatrix} \dot{\theta} \\ \dot{\varphi} \end{pmatrix} $$

3. **公式运算:**
    - 计算 $-B \dot{X} + C$:
    $$
    -B \begin{pmatrix} \dot{\theta} \\ \dot{\varphi} \end{pmatrix} + C
    = - \begin{pmatrix}
    c_1 & 0 \\
    0 & \frac{K_t K_b}{R_a} + c_2
    \end{pmatrix}
    \begin{pmatrix} \dot{\theta} \\ \dot{\varphi} \end{pmatrix}
    + \begin{pmatrix}
    - (m_1 l_1 + m_2 l_2) g \sin(\theta) \\
    \frac{K_t}{R_a} V_m
    \end{pmatrix}
    $$

4. **线性方程求解:**
    - 我们需要解出 $\ddot{X}$:
    $$
    A \ddot{X} = -B \dot{X} + C
    $$
    - 由此，得到加速度 $\ddot{X}$:
    $$
    \ddot{X} = A^{-1} \left( -B \dot{X} + C \right)
    $$

在 MATLAB 中，我们使用左除运算符 `\` 直接求解这个逆矩阵乘法，因此：
```matlab
acceleration = A \ (-B * [theta_dot; phi_dot] + C);
```
这行代码计算的是系统当前状态下的加速度 $\ddot{\theta}$ 和 $\ddot{\varphi}$，它们存储在 `acceleration` 向量中。

用简单的话来说，这行代码的目的是根据速度 $\dot{\theta}$ 和 $\dot{\varphi}$ 以及其他参数，计算系统在当前状态下的角加速度 $\ddot{\theta}$ 和 $\ddot{\varphi}$。


## 加入PID控制器

![image.png](/static/img/bacfa793241e44d2270562b7c08a69f0.image.webp)

自平衡自行车matlab

如何问ChatGPT公式

## JNI 简介

JNI（Java Native Interface）是“Java 本地接口”的缩写，用于指使用 C 和 C++ 语言开发的接口。由于 JNI 是 JVM 规范的一部分，所以我们编写的 JNI 程序可以在任何实现了 JNI 规范的 Java 虚拟机上运行。这一特性允许我们复用大量用 C/C++ 编写的代码。

然而，开发 JNI 程序会受到系统环境的限制，因为用 C/C++ 编写的代码在编译时依赖于操作系统提供的库函数，并需要链接到本地库上。因此，编译后的二进制代码只能在特定操作系统环境下运行。由于不同操作系统有各自的本地库和 CPU 指令集，各平台对标准 C/C++ 规范和库函数的实现方式也有所不同。这使得使用了 JNI 接口的 Java 程序不再具备完全的跨平台能力。如果要实现跨平台，需要在不同操作系统下编译出相应的动态库。



JNI 开发流程主要包括以下六步：

1. 编写声明了 `native` 方法的 Java 类。
2. 将 Java 源代码编译成 `.class` 字节码文件。
3. 使用 `javah -jni` 命令生成 `.h` 头文件（`javah` 是 JDK 自带的命令，`-jni` 参数用于生成符合 JNI 规范的函数声明）。
4. 用本地代码实现 `.h` 头文件中的函数。
5. 将本地代码编译成动态库（Windows: `.dll`, Linux/Unix: `.so`, Mac OS X: `.jnilib`）。
6. 将动态库拷贝到 `java.library.path` 本地库搜索目录下，并运行 Java 程序。

通过以上步骤，可以成功创建并运行 JNI 程序，实现 Java 与本地代码的交互。


![image.png](/static/img/b7f03d9199f788beab84c0aa41a1af44.image.webp)


## NDK简介

（英语：Native Development Kit，简称NDK）是一种基于原生程序接口的软件开发工具。通过此工具开发的程序直接以本地语言运行，而非依赖虚拟机。因此，只有像Java这样基于虚拟机运行的语言才需要使用原生开发工具包。

NDK提供了一系列工具，帮助开发者快速开发C或C++的动态库，并能自动将.so文件和Java应用一起打包成APK。这些工具极大地简化了开发过程。NDK集成了交叉编译器，并提供了相应的.mk文件，用于处理CPU、平台和ABI等差异。开发人员只需简单修改.mk文件（例如指定需要编译的文件和编译特性要求），就可以创建出.so文件。

NDK可以自动将.so文件和Java应用一起打包，显著减轻了开发人员的工作量。

在Android NDK的`platforms\<android版本>\arch-arm\usr\include\jni.h`头文件中，声明了所有可用的JNI接口函数。该文件包含两个重要的结构体：JNINativeInterface和JNIInvokeInterface。JNINativeInterface是JNI本地接口，实际上是一个接口函数指针表，包含所有JNI接口函数的指针，所有原生代码都可以调用这些接口函数。而JNIInvokeInterface是JNI调用接口，包含3个保留项和5个函数指针，这些函数用于访问全局的JNI接口，常用于原生多线程程序开发。

```c++
#if defined(__cplusplus)
typedef _JNIEnv JNIEnv;
typedef _JavaVM JavaVM;
#else
typedef const struct JNINativeInterface* JNIEnv;
typedef const struct JNIInvokeInterface* JavaVM;
#endif
```

如果使用C++代码调用JNI接口函数，JNIEnv被定义为 `_JNIEnv` 结构体，该结构体的第一个字段是一个JNINativeInterface结构体的指针。如果是C代码调用JNI接口函数，JNIEnv直接定义为JNINativeInterface结构体的指针。因此，可以将JNIEnv的首地址解释为JNINativeInterface的首地址使用，通过首地址和索引值即可找到需要调用的JNI接口函数。每个函数地址占用4个字节的空间。

## NDK两种开发模式

在 Android 开发中，NDK（Native Development Kit）提供了两种主要的开发模式：`ndk-build` 和 `CMake`。本文将详细介绍这两种模式的特点和使用场景。

## 1. ndk-build 模式

`ndk-build` 是 Android Studio 2.2 之前主流的 NDK 开发模式，主要特点包括:

- **脚本化构建**：使用 `Android.mk` 和 `Application.mk` 文件定义构建过程。
- **成熟稳定**：长时间使用，有较多的社区资源和支持。
- **直接集成**：无需额外配置，适合已有项目及偏好命令行工具的开发者。

## 2. CMake 模式

自 Android Studio 2.2 起，NDK 开发开始原生支持 `CMake`。主要特点包括:

- **跨平台支持**：CMake 是一种跨平台构建工具，能简化跨平台项目配置。
- **CLion 支持**：与 JetBrains 的 CLion 编辑器无缝整合，提升 C/C++ 开发体验。
- **现代构建系统**：利用 CMake 的现代功能，如自动依赖管理和更简洁的配置语法。

Android Studio 在 2.2 版本整合了 CLion 的代码，使其全面支持通过 CMake 进行 NDK 开发，提升了项目配置和管理的灵活性和便捷性。



## 为何要用到NDK

概括来说主要分为以下几种情况：

1. **代码的保护**：
   - APK的Java层代码很容易被反编译。
   - C/C++库的反汇编难度较大。

2. **调用第三方C/C++库**：
   - 大部分开源库是用C/C++代码编写的。

3. **便于移植**：
   - 用C/C++编写的库可以方便地在其他嵌入式平台上再次使用。

下面介绍一下Android NDK的入门学习过程：

入门的最好办法就是学习Android自带的例子。这里通过学习Android NDK自带的demo程序：`hello-jni` 来达到这个目的。

## 一、 开发环境的搭建

我用的windwos的AS软件，安装即可。
 
## 二、代码的编写

### 1.首先是写java代码

建立一个Android应用工程`HelloJni`创建HelloJni.java文件：


![image.png](/static/img/2f4a9e6d1961498f4bae99ab31bb76f7.image.webp)


![image.png](/static/img/fb25b20ffecce6730127776a5c2c7a8d.image.webp)



HelloJni.java :
``` java
/*
 * 版权所有 (C) 2009 The Android Open Source Project
 *
 * 根据 Apache License 2.0 版（“许可证”）授权；
 * 除非遵守此许可证，否则您不得使用此文件。
 * 您可以在以下网址获得许可证副本：
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * 除非适用法律要求或书面同意，按“原样”分发的许可软件
 * 不得附带任何明示或暗示的保证或条件。
 * 有关许可证下特定语言管理权限的详细信息，请参阅许可证。
 */
package com.example.hellojni;

import android.app.Activity;
import android.widget.TextView;
import android.os.Bundle;

public class HelloJni extends Activity {
    /**
     * 活动首次创建时调用。
     */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        /* 创建一个TextView并设置其内容。
         * 文本是通过调用本地函数检索的。
         */
        TextView tv = new TextView(this);
        tv.setText(stringFromJNI());
        setContentView(tv);
    }

    /* 本地方法，由 'hello-jni' 本地库实现，
     * 此库与此应用一起打包。
     */
    public native String stringFromJNI();

    /* 这是另一个本地方法声明，*未*由 'hello-jni' 实现。
     * 这只是为了显示您可以在Java代码中声明任意多的本地方法，
     * 它们的实现仅在首次调用它们时在当前加载的本地库中搜索。
     *
     * 尝试调用此函数将导致 java.lang.UnsatisfiedLinkError 异常！
     */
    public native String unimplementedStringFromJNI();

    /* 在应用启动时加载 'hello-jni' 库。
     * 库已在安装时由包管理器解压到
     * /data/data/com.example.HelloJni/lib/libhello-jni.so。
     */
    static {
        System.loadLibrary("hello-jni");
    }
}

```

这段代码逻辑简单，注释也十分清晰，这里只需指出两点：

1. 
```java
static { 
    System.loadLibrary("hello-jni"); 
}
```
这段代码会在程序启动时加载 `hello-jni` 库。由于它在 `static` 块中，代码会在任何类的 `onCreate` 方法执行之前运行。如果程序中存在多个类，且 `HelloJni` 不是应用程序的入口类，那么库 `libhello-jni.so` 会在首次使用 `HelloJni` 类时加载。

2.
```java
public native String stringFromJNI(); 
public native String unimplementedStringFromJNI();
```
这两段代码中的 `native` 关键字表明这些方法是本地方法，即它们由本地代码（C/C++）实现，Java代码中仅仅是声明。

在使用 Eclipse 编译工程时，生成相应的 `.class` 文件。这一步必须在下一步生成 `.h` 文件之前完成，因为生成 `.h` 文件需要对应的 `.class` 文件。

### 2. 编写相应的C/C++代码

刚开始学的时候，有个问题会让人很困惑，相应的C/C++代码如何编写，函数名如何定义？ 这里讲一个方法，利用javah这个工具生成相应的.h文件，然后根据这个.h文件编写相应的C/C++代码。

#### 2.1 生成相应.h文件：

就拿我这的环境来说，首先在终端下进入刚刚建立的HelloJni工程的目录：

`braincol@ubuntu:~$ cd workspace/android/NDK/hello-jni/`

ls查看工程文件
```
braincol@ubuntu:~/workspace/android/NDK/hello-jni$ ls 
AndroidManifest.xml  assets  bin  default.properties  gen  res  src 
```
可以看到目前仅仅有几个标准的android应用程序的文件（夹）。

首先我们在工程目录下建立一个jni文件夹：
```
braincol@ubuntu:~/workspace/android/NDK/hello-jni$ mkdir jni 
braincol@ubuntu:~/workspace/android/NDK/hello-jni$ ls 
AndroidManifest.xml  assets  bin  default.properties  gen  jni  res  src 
```
下面就可以生成相应的.h文件了：

`braincol@ubuntu:~/workspace/android/NDK/hello-jni$ javah -classpath bin -d jni com.example.hellojni.HelloJni `

-classpath bin：表示类的路径

-d jni: 表示生成的头文件存放的目录

`com.example.hellojni.HelloJni` 则是完整类名

这一步的成功要建立在已经在 bin/com/example/hellojni/  目录下生成了 HelloJni.class的基础之上。

现在可以看到jni目录下多了个.h文件：
```
braincol@ubuntu:~/workspace/android/NDK/hello-jni$ cd jni/ 
braincol@ubuntu:~/workspace/android/NDK/hello-jni/jni$ ls 
com_example_hellojni_HelloJni.h
```
我们来看看`com_example_hellojni_HelloJni.h`的内容：

com_example_hellojni_HelloJni.h :
``` c
 /* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class com_example_hellojni_HelloJni */

#ifndef _Included_com_example_hellojni_HelloJni
#define _Included_com_example_hellojni_HelloJni
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     com_example_hellojni_HelloJni
 * Method:    stringFromJNI
 * Signature: ()Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_com_example_hellojni_HelloJni_stringFromJNI
  (JNIEnv *, jobject);

/*
 * Class:     com_example_hellojni_HelloJni
 * Method:    unimplementedStringFromJNI
 * Signature: ()Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_com_example_hellojni_HelloJni_unimplementedStringFromJNI
  (JNIEnv *, jobject);

#ifdef __cplusplus
}
#endif
#endif
```
上面代码中的JNIEXPORT 和 JNICALL 是jni的宏，在android的jni中不需要，当然写上去也不会有错。

从上面的源码中可以看出这个函数名那是相当的长，不过还是很有规律的， 完全按照：`java_pacakege_class_mathod` 形式来命名。

也就是说：
```
Hello.java中 stringFromJNI() 方法对应于 C/C++中的 Java_com_example_hellojni_HelloJni_stringFromJNI() 方法

HelloJni.java中的 unimplementedStringFromJNI() 方法对应于 C/C++中的 Java_com_example_hellojni_HelloJni_unimplementedStringFromJNI() 方法 
```
注意下其中的注释：
```
Signature: ()Ljava/lang/String; 

()Ljava/lang/String;
```
()表示函数的参数为空（这里为空是指除了`JNIEnv *, jobject` 这两个参数之外没有其他参数，`JNIEnv*, jobject`是所有jni函数必有的两个参数，分别表示jni 环境和对应的java类（或对象）本身），

`Ljava/lang/String;` 表示函数的返回值是java的String对象。

 

#### 2.2 编写相应的.c文件：

hello-jni.c :
``` c
 /*
 * Copyright (C) 2009 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */
#include <string.h>
#include <jni.h>

/* This is a trivial JNI example where we use a native method
 * to return a new VM String. See the corresponding Java source
 * file located at:
 *
 *   apps/samples/hello-jni/project/src/com/example/HelloJni/HelloJni.java
 */
jstring
Java_com_example_hellojni_HelloJni_stringFromJNI( JNIEnv* env,
                                                  jobject thiz )
{
    return (*env)->NewStringUTF(env, "Hello from JNI !");
}
```
这里只是实现了`Java_com_example_hellojni_HelloJni_stringFromJNI`方法，而 `Java_com_example_hellojni_HelloJni_unimplementedStringFromJNI` 方法并没有实现，因为在HelloJni.java中只调用了`stringFromJNI()`方法，所以`unimplementedStringFromJNI()`方法没有实现也没关系，不过建议最好还是把所有java中定义的本地方法都实现了，写个空函数也行，有总比没有好。

`Java_com_example_hellojni_HelloJni_stringFromJNI()` 函数只是简单的返回了一个内容为 `"Hello from JNI !"` 的jstring对象（对应于java中的String对象）。

hello-jni.c文件已经编写好了，现在可以把`com_example_hellojni_HelloJni.h`文件给删了，当然留着也行，只是我还是习惯把不需要的文件给清理干净了。

### 3. 编译hello-jni.c 生成相应的库

#### 3.1 编写Android.mk文件

在jni目录下（即hello-jni.c 同级目录下）新建一个Android.mk文件，Android.mk 文件是Android 的 makefile文件，内容如下：
``` makefile
# Copyright (C) 2009 The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)

LOCAL_MODULE    := hello-jni
LOCAL_SRC_FILES := hello-jni.c

include $(BUILD_SHARED_LIBRARY)
```
这个Androd.mk文件很短，下面我们来逐行解释下：  
`LOCAL_PATH := $(call my-dir)`  

一个Android.mk 文件首先必须定义好LOCAL_PATH变量。它用于在开发树中查找源文件。在这个例子中，宏函数’my-dir’, 由编译系统提供，用于返回当前路径（即包含Android.mk file文件的目录）。  

`include $( CLEAR_VARS)`  

CLEAR_VARS由编译系统提供，指定让GNU MAKEFILE为你清除许多LOCAL_XXX变量（例如 LOCAL_MODULE, LOCAL_SRC_FILES, LOCAL_STATIC_LIBRARIES, 等等...), 除了LOCAL_PATH 。这是必要的，因为所有的编译控制文件都在同一个GNU MAKE执行环境中，所有的变量都是全局的。  
 
`LOCAL_MODULE := hello-jni`  

编译的目标对象，LOCAL_MODULE变量必须定义，以标识你在Android.mk文件中描述的每个模块。名称必须是唯一的，而且不包含任何空格。  

注意：编译系统会自动产生合适的前缀和后缀，换句话说，一个被命名为'hello-jni'的共享库模块，将会生成'libhello-jni.so'文件。  

**重要注意事项**：

如果你把库命名为‘libhello-jni’，编译系统将不会添加任何的lib前缀，也会生成 'libhello-jni.so'，这是为了支持来源于Android平台的源代码的Android.mk文件，如果你确实需要这么做的话。

`LOCAL_SRC_FILES := hello-jni.c`

LOCAL_SRC_FILES变量必须包含将要编译打包进模块中的C或C++源代码文件。注意，你不用在这里列出头文件和包含文件，因为编译系统将会自动为你找出依赖型的文件；仅仅列出直接传递给编译器的源代码文件就好。

注意，默认的C++源码文件的扩展名是’.cpp’. 指定一个不同的扩展名也是可能的，只要定义LOCAL_DEFAULT_CPP_EXTENSION变量，不要忘记开始的小圆点（也就是’.cxx’,而不是’cxx’）

`include $(BUILD_SHARED_LIBRARY)`

BUILD_SHARED_LIBRARY表示编译生成共享库，是编译系统提供的变量，指向一个GNU Makefile脚本，负责收集自从上次调用`include $(CLEAR_VARS)`以来，定义在LOCAL_XXX变量中的所有信息，并且决定编译什么，如何正确地去做。还有 BUILD_STATIC_LIBRARY变量表示生成静态库：lib$(LOCAL_MODULE).a；BUILD_EXECUTABLE 表示生成可执行文件，可以直接把可执行文件 adb push 到某目录并chmod 给予执行权限，然后 adb shell 直接执行它。

 
#### 3.2 生成.so共享库文件
Andro文件已经编写好了，现在可以用android NDK开发包中的 ndk-build脚本生成对应的.so共享库了，方法如下：
```
braincol@ubuntu:~/workspace/android/NDK/hello-jni/jni$ cd .. 
braincol@ubuntu:~/workspace/android/NDK/hello-jni$ ls 
AndroidManifest.xml  assets  bin  default.properties  gen  jni  libs  obj  res  src 
braincol@ubuntu:~/workspace/android/NDK/hello-jni$ ndk-build 
Gdbserver      : [arm-linux-androideabi-4.4.3] libs/armeabi/gdbserver 
Gdbsetup       : libs/armeabi/gdb.setup 
Install        : libhello-jni.so => libs/armeabi/libhello-jni.so 
```
可以看到已经正确的生成了libhello-jni.so共享库了， 我们去 libs/armeabi/ 目录下看看：
```
braincol@ubuntu:~/workspace/android/NDK/hello-jni$ cd libs/ 
braincol@ubuntu:~/workspace/android/NDK/hello-jni/libs$ ls 
armeabi 
braincol@ubuntu:~/workspace/android/NDK/hello-jni/libs$ cd armeabi/ 
braincol@ubuntu:~/workspace/android/NDK/hello-jni/libs/armeabi$ ls 
gdbserver  gdb.setup  libhello-jni.so
```
### 4. 在eclipse重新编译HelloJni工程，生成apk

eclipse中刷新下HelloJni工程，重新编译生成apk，libhello-jni.so共享库会一起打包在apk文件内。

在模拟器中看看运行结果：  

hello-jni  
![](../pictures/hellojni.png)

## 附：使用 android 脚本生成android 工程
在使用 ndk-build 工具前，需要先有一个Android 工程，这个工程可以从Android NDK 的 samples 目录下随便复制一份，也可以使用Android SDK 开发包 tools 目录下的 android 脚本生成。  
android 脚本可以用来管理 AVD、android 工程，完整命令可以 “android --help” 查看。  
`android create project -n hellojni -p hellojni -t android-19 -k com.example.hellojni -a HelloJni`  
命令行解释如下：  
"-n" 指定android 工程的名称；"-t" 指定生成android 工程的平台版本，也就是`android list` 列出的版本之一；"-p" 指定生成工程的目录名；"-k" 指定 android 工程的包名；"-a" 指定默认activity的名称；`android create project` 会根据默认activity 文件名自动生成相应的java 文件，并生成AndroidManifest.xml。    


## Reference
http://www.cnblogs.com/hibraincol/archive/2011/05/30/2063847.html

【Android Java】Android NDK 开发基础

# Android 工程项目结构解析


## 工程关键部分

以 Android Studio（或 Eclipse + ADT）为例，大部分开发工作集中在以下几个目录：

- **java**：存放业务功能的 Java 代码。
- **res**：存放各种资源文件，如图片、字符串、动画、音频以及各种 XML 文件。



## res 资源文件夹介绍

`res` 目录用于存放各种资源文件：

- **drawable**：存放位图文件（.png, .jpg, .9.png, .gif 等）。
- **mipmap**：比 `drawable` 更适合存放启动图标，同样支持不同分辨率（hdpi, mdpi, xhdpi, xxhdpi）。
- **layout**：存放各种布局文件（XML 格式）。
- **menu**：存放菜单相关的 XML 文件。
- **values**：存放常量资源，如 `strings.xml`、`colors.xml` 等。

`assets` 目录需要手动创建，区别在于资源文件不会在 `R.java` 中生成 id。

### 图片资源

- **drawable**：存放各种位图文件，以及其他 `drawable` 类型的 XML 文件。
- **mipmap**：存放不同分辨率的启动图标。
  - mipmap-hdpi（高分辨率）
  - mipmap-mdpi（中等分辨率）
  - mipmap-xhdpi（超高分辨率）
  - mipmap-xxhdpi（超超高分辨率）

### 布局资源

`layout` 目录存放布局文件，通过为特定屏幕适配创建相应的文件夹，如 `layout-480x320`。

### 菜单资源

`menu` 目录用于存放菜单项相关的资源 XML。现在实体菜单按钮减少，用途变少。

### values 目录

- `demens.xml`：定义尺寸资源。
- `string.xml`：定义字符串资源。
- `styles.xml`：定义样式资源。
- `colors.xml`：定义颜色资源。
- `arrays.xml`：定义数组资源。
- `attrs.xml`：自定义控件的属性。

### raw 目录

存放原生资源（音频、视频、XML 等），通过 `openRawResource(int id)` 获取资源的二进制流。

### 动画资源

- **animator**：存放属性动画的 XML 文件。
- **anim**：存放补间动画的 XML 文件。

## 使用资源文件

资源文件在 `R.java` 下生成对应的资源 id，通过资源 id 进行访问：

### 在 Java 代码中使用

```java
txtName.setText(getResources().getText(R.string.name));
imgIcon.setBackgroundResource(R.drawable.icon);
txtName.setTextColor(getResources().getColor(R.color.red));
setContentView(R.layout.main);
txtName = (TextView) findViewById(R.id.txt_name);
```

### 在 XML 代码中使用

```xml
<TextView
    android:text="@string/hello_world"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:background="@drawable/img_back"/>
```

## 深入了解三个文件

#### 主体代码：`MainActivity.java`

```java
package jay.com.example.firstapp;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
}
```

#### 布局文件：`activity_main.xml`

```xml
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">
    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/hello_world" />
</RelativeLayout>
```

#### Android 配置文件：`AndroidManifest.xml`

```xml
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="jay.com.example.firstapp">
    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme">
        <activity android:name=".MainActivity" android:label="@string/app_name">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>
```

除了上述内容，`AndroidManifest.xml` 中还需声明权限和组件。

【Android Java】Android工程的相关文件说明

## 应用清单

每个应用的根目录中都必须包含一个 `AndroidManifest.xml` 文件（且文件名精确无误）。清单文件向 Android 系统提供应用的必要信息，系统必须具有这些信息方可运行应用的任何代码。

### 清单文件主要功能

此外，清单文件还可执行以下操作：
- **为应用的 Java 软件包命名**：软件包名称充当应用的唯一标识符。
- **描述应用的各个组件**：包括 Activity、服务、广播接收器和内容提供程序。它还为实现每个组件的类命名并发布其功能，如可以处理的 Intent 消息。
- **确定托管应用组件的进程**。
- **声明应用权限**：访问 API 中受保护部分所需的权限和与其他应用交互所需的权限。
- **列出 Instrumentation 类**：提供分析和其他信息（仅在开发阶段）。
- **声明应用所需的最低 Android API 级别**。
- **列出应用必须链接到的库**。



> **注**：准备在 Chromebook 上运行的 Android 应用时，要考虑一些重要的硬件和软件功能限制。详见 Chromebook 的应用清单兼容性文档。

## 清单文件结构

下面的代码段显示了清单文件的通用结构及其可包含的每个元素：
```xml
<?xml version="1.0" encoding="utf-8"?>
<manifest>
    <uses-permission />
    <permission />
    ...
    <application>
        <activity>
            <intent-filter>
                <action />
                <category />
                <data />
            </intent-filter>
            <meta-data />
        </activity>
        ...
    </application>
</manifest>
```

### 可包含的元素

按字母顺序列出的所有合法元素：
```xml
<action> <activity> <activity-alias> <application> <category> 
<data> <grant-uri-permission> <instrumentation>
<intent-filter> <manifest> <meta-data>
<permission> <permission-group> <permission-tree>
<provider> <receiver> <service>
<supports-screens> <uses-configuration>
<uses-feature> <uses-library> <uses-permission> <uses-sdk>
```
> **注**：这些是仅有的合法元素 – 无法添加自定义元素或属性。

## 文件约定

### 元素
- **必需元素**：`<manifest>` 和 `<application>`，每个只能出现一次。
- **顺序**：`<activity-alias>` 必须在别名所指的 `<activity>` 之后。`<application>` 元素必须是 `<manifest>` 内最后一个元素。

### 属性
- 所有属性名以 `android:` 前缀开头（除根 `<manifest>` 元素的某些属性外）。

### 声明类名
通过 `name` 属性声明子类：
```xml
<manifest package="com.example.project">
    <application>
        <service android:name=".SecretService" />
    </application>
</manifest>
```

### 多个值
通过重复元素指定多个值：
```xml
<intent-filter>
    <action android:name="android.intent.action.EDIT" />
    <action android:name="android.intent.action.INSERT" />
</intent-filter>
```

### 资源值
指定资源值：
```xml
<activity android:icon="@drawable/smallPic" />
```

## 文件功能

### Intent 过滤器
组件通过 intent 过滤器公布可响应的 intent 类型：
```xml
<activity>
    <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.LAUNCHER" />
    </intent-filter>
</activity>
```

### 权限
通过 `<uses-permission>` 声明应用需要的权限：
```xml
<manifest>
    <uses-permission android:name="android.permission.CALL_EMERGENCY_NUMBERS" />
</manifest>
```

通过 `<permission>` 声明应用定义的权限：
```xml
<manifest>
    <permission android:name="com.example.project.DEBIT_ACCT" />
    <uses-permission android:name="com.example.project.DEBIT_ACCT" />
    <application>
        <activity android:name="com.example.project.FreneticActivity"
                  android:permission="com.example.project.DEBIT_ACCT" />
    </application>
</manifest>
```

### 图标和标签
可设置图标和标签属性：
```xml
<application android:icon="@drawable/icon" android:label="@string/app_name">
    <activity android:label="@string/activity_name" />
</application>
```

### 库
通过 `<uses-library>` 声明应用使用的库：
```xml
<application>
    <uses-library android:name="com.example.SomeLibrary" android:required="true" />
</application>
```

## 参考
[Android 开发者文档](https://developer.android.google.cn/guide/topics/manifest/manifest-intro.html)

【Android Java】AndroidManifest.xml

我是一个专注技术分享的博主,尤其爱搞深度学习和单片机电子。你现在看到的是我的个人博客网站。