基于TINY4412的Andorid开发-------简单的LED灯控制

参考资料：

《Andriod系统源代码情景分析》

《嵌入式Linux系统开发完全手册_基于4412_上册》

作者：彭东林

邮箱：pengdonglin137@163.com

平台介绍：

主机：Win7 32位

虚拟机：VMware10 + ubuntu-12.04.2-desktop-amd64

Android版本:  android-4.2.2_r1

Linux内核版本：linux-3.5.0

Bootloader:  友善之臂提供的Superboot4412.bin

目标平台：tiny4412ADK+S700 4GB Flash

 

目的： 在Tiny4412上运行的Android系统上，通过点击屏幕上的Button来控制Tiny4412的核心板上的四个LED灯的亮灭。一个有八个Button，每个灯的亮灭通过两个灯来控制，点击ON，相应的LED亮；点击OFF，相应的LED灯灭。

 

下面分几步完成：

1、编写驱动程序

2、测试驱动程序

3、编写HAL代码

4、编写framework代码

5、编写JNI代码

6、编写App

下面开始：

回到顶部

一、编写驱动程序

分析tiny4412的原理图，看一下LED灯的位置：

可以知道，LED是低电平亮，高电平灭。

看一下，接到了Exynos4412的哪些引脚上了：

可以看到：

LED1  --------- GPM4_0

LED2  --------- GPM4_1

LED3  --------- GPM4_2

LED4  --------- GPM4_3

看一下Exynos4412的芯片手册，看一下GPM4的相关寄存器：

图中第二列表示的相对于基地址的偏移量，这里基地址是：0x11000000.

在芯片手册的Page288 ~ Page291对这些寄存器有更详细的介绍。

以GPM4_0引脚为例：

为了控制灯，[3:0]应设置为0x01，即输出模式

向GPM4DAT的第0位写0，GPM4_0引脚输出低电平，LED1亮；

向GPM4DAT的第0位写1，GPM4_0引脚输出高电平，LED1灭；

接下来，开始写驱动程序，用友善之臂自带的Linux3.5.0内核

在android_led/下创建led_demo.c和led_demo.h文件：

touch  led_demo.c led_demo.h

再在其中创建Makefile和Kconfig文件

touch Makefile Kconfig

• 修改Kconfig:

• 修改Makefile:

obj-$(CONFIG_LED_DEMO) += led_demo.o

• 修改drivers/Kconfig，添加 source “drivers/android_led/Kconfig”

• 修改drivers/Makefile:

• 在内核顶层目录下执行make  menuconfig，进入Device Drivers，将 Android Led Demo选择为*，然后保存配置退出。

 

注：执行上面这些操作之前，确保已经按照友善之臂的手册，成功编译了Android上用的Linux内核，并且在arch/arm/boot下生成了zImage等文件。

在前期开发的时候，时不时要编译，可以将drivers/android_led/Makefile修改为：

编译的时候，可以使用：

make M=drivers/android_led modules

目的是提高编译速度,最后再将Makfile改回原样。临时测试，可以在Wind7的命令行下，使用adb push将led_demo.ko上传到/data/local下，然后用adb shell登陆板子，进行测试。

• 修改led_demo.h和led_demo.c

led_demo.h：

 

led_demo.c：

 

编写完成后，在内核源码的顶层目录执行make zImage –jN，然后就会在arch/arm/boot/生成zImage文件，利用友善之臂提供的Minitools将zImage烧写到板子上。具体步骤，参考友善之臂提供的PDF文档：《Tiny4412用户手册》

回到顶部

二、编写代码测试驱动程序

在android-4.2.2_r1源码顶层目录下

即，在external/下创建led_demo目录，并在其中创建Android.mk、led_demo.c以及led_demo.h文件.

Android.mk:

led_demo.h:

led_demo.c:

编写完成后，在android-4.2.2_r1源码顶层目录下执行：

然后将顶层目录下新生成的system.img利用友善之臂提供的Minitools烧写到板子上。

烧写完成后，重启板子。

使用串口终端登陆板子，使用su命令进入root用户模式，然后进入/system/bin目录下，执行./led_demo_test，观察现象，可以看到，TINY4412的核心板上的四个LED灯循环亮灭。也可以使用wind7下的控制终端，用adb shell登陆板子，进行测试。

回到顶部

三、编写HAL代码

在hardware/libhardware/include/hardware/下创建文件led_demo_hal.h

在hardware/libhardware/modules/下创建目录led_demo_hal，然后进入led_demo_hal，创建两个文件，分别是Android.mk和

led_demo_hal.cpp。

下面是文件内容：

hardware/libhardware/include/hardware/led_demo_hal.h

 

hardware/libhardware/modules/led_demo_hal/led_demo_hal.cpp

   1:  #define LOG_TAG "LED_DEMO_HALSTUB"   //将来可以用DDMS的LogCat工具进行调试，便于查看打印信息

   2:   

   3:  #include <hardware/hardware.h>

   4:  #include <hardware/led_demo_hal.h>

   5:   

   6:  #include <fcntl.h>

   7:  #include <errno.h>

   8:   

   9:  #include <utils/Log.h>

  10:  #include <cutils/atomic.h>

  11:   

  12:   

  13:  #define DEVICE_NAME    "/dev/led_demo"    //设备结点，有Linux驱动程序自动创建

  14:  #define MODULE_NAME    "led_demo"

  15:  #define MODULE_AUTHOR  "pengdonglin137@163.com"

  16:   

  17:  #define LED_ON  0x40044c00     //点灯的命令，其实就是_IOW('L', 0, int)的值，_IOW在编译时无法识别，待以后解决

  18:  #define LED_OFF 0x40044c01     //灭灯命令，其实就是_IOW('L', 1, int)的值，可以在上面的led_demo.c中加打印，看一下这个值是多少

  19:   

  20:   

  21:  static int led_demo_open(const struct hw_module_t* module, const char* id,

  22:          struct hw_device_t** device);

  23:   

  24:  static int led_demo_close(struct hw_device_t* device);

  25:   

  26:  static int led_demo_set_on(struct led_demo_device_t *dev, int val);

  27:   

  28:  static int led_demo_set_off(struct led_demo_device_t *dev, int val);

  29:   

  30:   

  31:  static hw_module_methods_t led_demo_module_methods =

  32:  {

  33:      open:led_demo_open,

  34:  };

  35:   

  36:  struct led_demo_module_t HAL_MODULE_INFO_SYM = 

  37:  {

  38:      common:{

  39:          tag:HARDWARE_MODULE_TAG,

  40:          version_major:1,

  41:          version_minor:0,

  42:          id:LED_DEMO_HARDWARE_MODULE_ID,

  43:          name:MODULE_NAME,

  44:          author:MODULE_AUTHOR,

  45:          methods:&led_demo_module_methods,

  46:      }

  47:  };

  48:   

  49:  static int led_demo_open(const struct hw_module_t* module, const char* id,

  50:          struct hw_device_t** device)

  51:  {

  52:      if(!strcmp(id, LED_DEMO_HARDWARE_DEVICE_ID))

  53:      {

  54:          struct led_demo_device_t *dev;

  55:   

  56:          dev = (struct led_demo_device_t *)malloc(sizeof(struct led_demo_device_t));

  57:          if(!dev)

  58:          {

  59:              ALOGE("Failed to alloc space for struct led_demo_device_t.");

  60:              return -EFAULT;

  61:          }

  62:   

  63:          memset(dev, 0, sizeof(struct led_demo_device_t));

  64:   

  65:          dev->common.tag = 

HARDWARE_DEVICE_TAG

;

  66:          dev->common.version = 0;

  67:          dev->common.module = (struct hw_module_t *)module;

  68:          dev->common.close = led_demo_close;

  69:          dev->set_on = led_demo_set_on;

  70:          dev->set_off = led_demo_set_off;

  71:   

  72:          if((dev->fd = open(DEVICE_NAME, O_RDWR)) == -1)

  73:          {

  74:              ALOGE("Failed to open device %s ---- %s\n.", DEVICE_NAME, strerror(errno));

  75:              free(dev);

  76:              return -EFAULT;

  77:          }

  78:   

  79:          *device = &(dev->common);

  80:   

  81:          ALOGE("Open device file %s successfully.", DEVICE_NAME);

  82:   

  83:      }

  84:   

  85:      return -EFAULT;

  86:  }

  87:   

  88:  static int led_demo_close(struct hw_device_t* device)

  89:  {

  90:      struct led_demo_device_t *led_device = (struct led_demo_device_t *)device;

  91:      if(led_device)

  92:      {

  93:          close(led_device->fd);

  94:          free(led_device);

  95:      }

  96:   

  97:      return 0;

  98:  }

  99:   

 100:  static int led_demo_set_on(struct led_demo_device_t *dev, int val)

 101:  {

 102:      if(!dev)

 103:      {

 104:          ALOGE("Null dev pointer.");

 105:          return -EFAULT;

 106:      }

 107:      

 108:      if(ioctl(dev->fd, LED_ON, val) < 0)

 109:      {

 110:          ALOGE("ioctl error --- %s.", strerror(errno));

 111:          return -EFAULT;

 112:      }

 113:   

 114:      return 0;

 115:      

 116:  }

 117:   

 118:  static int led_demo_set_off(struct led_demo_device_t *dev, int val)

 119:  {

 120:      if(!dev)

 121:      {

 122:          ALOGE("Null dev pointer.");

 123:          return -EFAULT;

 124:      }

 125:      

 126:      if(ioctl(dev->fd, LED_OFF, val) < 0)

 127:      {

 128:          ALOGE("ioctl error --- %s.", strerror(errno));

 129:          return -EFAULT;

 130:      }

 131:   

 132:      return 0;

 133:      

 134:  }

 135:   

 

hardware/libhardware/modules/led_demo_hal/Android.mk

 

编写完成后，在Android源码的顶层目录执行：

mmm ./hardware/libhardware/modules/led_demo_hal/

最终out/target/product/tiny4412/system/lib/hw/目录下得到一个led_demo_hal.default.so文件。

下面处理一下硬件设备访问权限问题

在硬件抽象层模块中，我们是调用open函数来打开对应的设备文件的，在默认情况下，只有root用户才有权限访问系统的设备文件。但是一般的应用程序是没有root用户权限的。

解决办法，赋予root之外的其他用户访问设别文件/dev/led_demo的权限。做法如下：

在Android源码顶层目录下，修改system/core/rootdir/ueventd.rc，添加如下内容：

/dev/led_demo             0666   root       root

修改了ueventd.rc文件后，需要重新编译Android源代码工程，编译时，文件system/core/rootdir/ueventd.rc会拷贝到out/target/product/tiny4412/root/下，并且最终打包在ramdisk.img中。对于友善之臂，执行完make -jN后，还需要执行./gen-img.sh脚本，然后在Android源码顶层目录中会生成ramdisk-u.img文件，利用MiniTools将其烧写到板子上。

回到顶部

四、编写Framework代码

• 定义硬件访问服务接口

在frameworks/base/core/java/android/os/创建文件ILed_demo_service.aidl，内容如下：

然后，修改frameworks/base/Android.mk

最后，在Android源码顶层目录下执行

mmm ./frameworks/base/

编译后得到的framework.jar文件就包含了ILed_demo_service接口。

• 实现硬件访问服务

在frameworks/base/services/java/com/android/server/创建文件Led_demo_Service.java，内容如下：

编写完成后，在Android源码顶层目录下执行：

mmm ./frameworks/base/services/java/

编译后得到的services.jar文件就包含有Led_demo_Service类。

 

回到顶部

五、编写JNI代码

在frameworks/base/services/jni/下创建文件com_android_server_led_demo_service.cpp，内容如下：

   1:  #define LOG_TAG  "LED_DEMO_Service_JNI"   //方便LogCat调试工具查看打印信息

   2:   

   3:  #include "jni.h"

   4:  #include "JNIHelp.h"

   5:  #include "android_runtime/AndroidRuntime.h"

   6:   

   7:  #include <utils/misc.h>

   8:  #include <utils/Log.h>

   9:  #include <hardware/hardware.h>

  10:  #include <hardware/led_demo_hal.h>

  11:   

  12:  #include <stdio.h>

  13:   

  14:   

  15:  namespace android

  16:  {

  17:   

  18:      static void led_demo_setOFF(JNIEnv *env, jobject clazz, jint ptr, jint value)

  19:      {

  20:          led_demo_device_t *device = (led_demo_device_t *)ptr;

  21:          if(!device)

  22:          {

  23:              ALOGE("Device led demo is not open.");

  24:              return ;

  25:          }

  26:   

  27:          int val = value;

  28:   

  29:          ALOGI("Set value %d to device led demo.", val);

  30:   

  31:          device->set_off(device, value);

  32:      }

  33:   

  34:      static void led_demo_setON(JNIEnv *env, jobject clazz, jint ptr, jint value)

  35:      {

  36:          led_demo_device_t *device = (led_demo_device_t *)ptr;

  37:          if(!device)

  38:          {

  39:              ALOGE("Device led demo is not open.");

  40:              return ;

  41:          }

  42:   

  43:          int val = value;

  44:   

  45:          ALOGI("Set value %d to device led demo.", val);

  46:   

  47:          device->set_on(device, value);

  48:      }

  49:      

  50:   

  51:      static inline int led_demo_device_open(const hw_module_t *module, struct led_demo_device_t **device)

  52:      {

  53:          return module->methods->open(module, LED_DEMO_HARDWARE_DEVICE_ID, (struct hw_device_t **)device);    

  54:      }

  55:   

  56:   

  57:   

  58:      static jint led_demo_init(JNIEnv *env, jclass clazz)

  59:      {

  60:          struct led_demo_module_t *module;

  61:          struct led_demo_device_t *device;

  62:   

  63:   

  64:          ALOGI("Initializing HAL stub led ......");

  65:   

  66:          if(hw_get_module(

LED_DEMO_HARDWARE_MODULE_ID

, (const struct hw_module_t **)&module) == 0)

  67:          {

  68:              ALOGE("Device led demo found.");

  69:   

  70:              if(led_demo_device_open(&(module->common), &device))

  71:              {

  72:                  ALOGI("Device led demo is open.");

  73:                  return (jint)device;

  74:              }

  75:   

  76:              ALOGE("Failed to open device led.");

  77:   

  78:              return 0;

  79:          }

  80:   

  81:          ALOGE("Failed to get HAL stub led demo.");

  82:          return 0;

  83:      }

  84:   

  85:      static const JNINativeMethod  method_table[] =

  86:      {

  87:          {"init_native", "()I", (void *)led_demo_init},

  88:          {"set_OFF_native", "(II)V", (void *)led_demo_setOFF},

  89:          {"set_ON_native", "(II)V", (void *)led_demo_setON},

  90:      };

  91:   

  92:      int register_android_server_led_demo_service(JNIEnv *env)

  93:      {

  94:          return jniRegisterNativeMethods(env, "com/android/server/Led_demo_Service", 

  95:              method_table, NELEM(method_table));

  96:      }

  97:   

  98:  };

  99:   

 100:   

 

修改frameworks/base/services/jni/onload.cpp文件：

 

修改frameworks/base/services/jni/Android.mk文件，内容如下：

最后，在Android源码顶层目录下执行：

mmm ./frameworks/base/services/jni/

• 启动硬件服务

修改frameworks/base/services/java/com/android/server/SystemServer.java文件

 

编写完成后，在Android源码顶层目录下执行：

mmm ./frameworks/base/services/java/ 

回到顶部

六、编写App

这个app是在Win7下用eclipse开发的，如下图：

 

上面的错误是因为Win7下的SDK开发包中并没有我们编写的ILed_demo_service，这个不要紧。导出方法：在工程Tiny4412_led_demo上右键单击，点击Export，选择General----> File System ，选择导出路径，最后点击Finish。将导出的工程Tiny4412_led_demo拷贝到packages/experimental/目录下，然后进入packages/experimental/Tiny4412_led_demo，在其中创建一个Android.mk文件：

下面是最终的效果图：

 

完成操作后，在Android源码顶层目录下执行

mmm ./packages/experimental/Tiny4412_led_demo/

然后再执行

./gen-img.sh

将生成的system.img利用MiniTools提供的烧写工具烧写到板子上。

 

最后，附上源代码：

 

http://pan.baidu.com/s/1ntwTz1B

完！！

 

原文：http://www.cnblogs.com/pengdonglin137/p/3857724.html