Tiny4412 LED 硬件服务

1.Android系统中启动框架

2.首先实现驱动程序

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/miscdevice.h>
#include <linux/device.h>
#include <linux/fs.h>
#include <linux/types.h>
#include <linux/moduleparam.h>
#include <linux/slab.h>
#include <linux/ioctl.h>
#include <linux/cdev.h>
#include <linux/delay.h>

#include <linux/gpio.h>
#include <mach/gpio.h>
#include <plat/gpio-cfg.h>

static int led_gpios[] = {
    EXYNOS4212_GPM4(),
    EXYNOS4212_GPM4(),
    EXYNOS4212_GPM4(),
    EXYNOS4212_GPM4(),
};

static int led_open(struct inode *inode, struct file *file)
{
    /* 配置GPIO为输出引脚 */
    int i;
    for (i = ; i < ; i++)
        s3c_gpio_cfgpin(led_gpios[i], S3C_GPIO_OUTPUT);

    return ;
}

/* app : ioctl(fd, cmd, arg) */
static long led_ioctl(struct file *filp, unsigned int cmd,
        unsigned long arg)
{
    /* 根据传入的参数设置GPIO */
    /* cmd : 0-off, 1-on */
    /* arg : 0-3, which led */

    if ((cmd != ) && (cmd != ))
        return -EINVAL;

    if (arg > )
        return -EINVAL;

    gpio_set_value(led_gpios[arg], !cmd);

    return ;
}

static struct file_operations leds_ops = {
    .owner  =   THIS_MODULE,    /* 这是一个宏，推向编译模块时自动创建的__this_module变量 */
    .open   =   led_open,
    .unlocked_ioctl    = led_ioctl,

};

static int major;
static struct class *cls;

int leds_init(void)
{
    major = register_chrdev(, "leds", &leds_ops);

    /* 为了让系统udev,mdev给我们创建设备节点 */
    /* 创建类, 在类下创建设备 : /sys */
    cls = class_create(THIS_MODULE, "leds");
    device_create(cls, NULL, MKDEV(major, ), NULL, "leds"); /* /dev/leds */

    return ;
}

void leds_exit(void)
{
    device_destroy(cls, MKDEV(major, ));
    class_destroy(cls);
    unregister_chrdev(major, "leds");
}

module_init(leds_init);
module_exit(leds_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("www.100ask.net");

放入内核 drivers/char
修改 drivers/char/Makefile，添加：
obj-y += leds_4412.o

重新编译内核

或者将其编译成模块

#Makefile
obj-m := leds_4412.o
KDIR := /home/cent/work/androidL_Tiny4412/linux-3.0.
all:
    make -C $(KDIR) M=$(PWD) modules CROSS_COMPILE=arm-linux- ARCH=arm
.PHONY: clean
clean:
    rm  -f  *.ko  *.o  *.mod.c  *.bak  *.order *.symvers *~

执行 make后 用adb push 命令将其上传到开发板的/data/local 目录，adb shell 使用 insmod 命令将驱动模块加载到内核。

3.实现HAL层

//led_hal.h

#ifndef ANDROID_LED_INTERFACE_H
#define ANDROID_LED_INTERFACE_H

#include <stdint.h>
#include <sys/cdefs.h>
#include <sys/types.h>

#include <hardware/hardware.h>

__BEGIN_DECLS

struct led_device_t {
    struct hw_device_t common;

    int (*led_open)(struct led_device_t* dev);
    int (*led_ctrl)(struct led_device_t* dev, int which, int status);
};

__END_DECLS

#endif  // ANDROID_LED_INTERFACE_H

//led_hal.c

#define LOG_TAG "LedHal"

/* 1. 实现一个名为HMI的hw_module_t结构体 */

/* 2. 实现一个open函数, 它返回led_device_t结构体 */

/* 3. 实现led_device_t结构体 */

/* 参考 hardware\libhardware\modules\vibrator\vibrator.c
 */

#include <hardware/vibrator.h>
#include <hardware/hardware.h>

#include <cutils/log.h>

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>

#include <hardware/led_hal.h>

#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <utils/Log.h>

static int fd;

/** Close this device */
static int led_close(struct hw_device_t* device)
{
    close(fd);
    return ;
}

static int led_open(struct led_device_t* dev)
{
    fd = open("/dev/leds", O_RDWR);
    ALOGI("led_open : %d", fd);
    if (fd >= )
        return ;
    else
        return -;
}

static int led_ctrl(struct led_device_t* dev, int which, int status)
{
    int ret = ioctl(fd, status, which);
    ALOGI("led_ctrl : %d, %d, %d", which, status, ret);
    return ret;
}

static struct led_device_t led_dev = {
    .common = {
        .tag   = HARDWARE_DEVICE_TAG,
        .close = led_close,
    },
    .led_open  = led_open,
    .led_ctrl  = led_ctrl,
};

static int led_device_open(const struct hw_module_t* module, const char* id,
        struct hw_device_t** device)
{
    *device = &led_dev;
    return ;
}

static struct hw_module_methods_t led_module_methods = {
    .open = led_device_open,
};

struct hw_module_t HAL_MODULE_INFO_SYM = {
    .tag = HARDWARE_MODULE_TAG,
    .id = "led",
    .methods = &led_module_methods,
};

#Android.mk
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE := led.default
LOCAL_MODULE_RELATIVE_PATH := hw
LOCAL_C_INCLUDES := hardware/libhardware
LOCAL_SRC_FILES := led_hal.c
LOCAL_SHARED_LIBRARIES := liblog
LOCAL_MODULE_TAGS := eng

include $(BUILD_SHARED_LIBRARY)

把新文件放到Android源码中, 所在目录:

hardware/libhardware/include/hardware/led_hal.h

hardware/libhardware/modules/led/led_hal.c

hardware/libhardware/modules/led/Android.mk

 

编译：

$ mmm hardware/libhardware/modules/led

 

4.实现JAVA硬件服务JNI层

//com_android_server_LedService.cpp

#define LOG_TAG "LedService"

#include "jni.h"
#include "JNIHelp.h"
#include "android_runtime/AndroidRuntime.h"

#include <utils/misc.h>
#include <utils/Log.h>

#include <stdio.h>

#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <hardware/led_hal.h>

namespace android
{

static led_device_t* led_device;

jint ledOpen(JNIEnv *env, jobject cls)
{
    jint err;
    hw_module_t* module;
    hw_device_t* device;

    ALOGI("native ledOpen ...");

    /* 1. hw_get_module */
    err = hw_get_module("led", (hw_module_t const**)&module);
    if (err == ) {
        /* 2. get device : module->methods->open */
        err = module->methods->open(module, NULL, &device);
        if (err == ) {
            /* 3. call led_open */
            led_device = (led_device_t *)device;
            return led_device->led_open(led_device);
        } else {
            return -;
        }
    }

    return -;
}

void ledClose(JNIEnv *env, jobject cls)
{
    //ALOGI("native ledClose ...");
    //close(fd);
}

jint ledCtrl(JNIEnv *env, jobject cls, jint which, jint status)
{
    ALOGI("native ledCtrl %d, %d", which, status);
    return led_device->led_ctrl(led_device, which, status);
}

static const JNINativeMethod methods[] = {
    {"native_ledOpen", "()I", (void *)ledOpen},
    {"native_ledClose", "()V", (void *)ledClose},
    {"native_ledCtrl", "(II)I", (void *)ledCtrl},
};

int register_android_server_LedService(JNIEnv *env)
{
    return jniRegisterNativeMethods(env, "com/android/server/LedService",
            methods, NELEM(methods));
}

}

放到Android源码frameworks/base/services/core/jni/com_android_server_LedService.cpp位置

修改frameworks/base/services/core/jni/onload.cpp

添加：

int register_android_server_Watchdog(JNIEnv* env);
+int register_android_server_LedService(JNIEnv *env);

register_android_server_VibratorService(env);
+register_android_server_LedService(env);

修改 frameworks/base/services/core/jni/Android.mk :

  $(LOCAL_REL_DIR)/com_android_server_VibratorService.cpp \

+ $(LOCAL_REL_DIR)/com_android_server_LedService.cpp \

 

5.实现AIDL代码

package android.os;

/** {@hide} */
interface ILedService
{
    int ledCtrl(int which, int status);
}

把 ILedService.aidl 放入 frameworks/base/core/java/android/os

 修改 frameworks/base/Android.mk  添加一行

         core/java/android/os/IVibratorService.aidl \

+        core/java/android/os/ILedService.aidl \

 

 

 mmm frameworks/base

它会生成: ./out/target/common/obj/JAVA_LIBRARIES/framework_intermediates/src/core/java/android/os/ILedService.java

 

6.实现LedService JAVA层代码

package com.android.server;
import android.os.ILedService;

public class LedService extends ILedService.Stub {
    private static final String TAG = "LedService";

    /* call native c function to access hardware */
    public int ledCtrl(int which, int status) throws android.os.RemoteException
    {
        return native_ledCtrl(which, status);
    }

    public LedService() {
        native_ledOpen();
    }

    public static native int native_ledOpen();
    public static native void native_ledClose();
    public static native int native_ledCtrl(int which, int status);
}

frameworks/base/services/java/com/android/server/SystemServer.java中注册LedService

Slog.i(TAG, "Vibrator Service");
vibrator = new VibratorService(context);
ServiceManager.addService("vibrator", vibrator);

+Slog.i(TAG, "Led Service");
+ServiceManager.addService("led", new LedService());

上传到Android源码目录中

frameworks/base/services/java/com/android/server/SystemServer.java

 

不需要修改 frameworks/base/services/core/Android.mk

它的内容里已经把该目录下所有JAVA文件自动包含进去了：

LOCAL_SRC_FILES += \

    $(call all-java-files-under,java)

 

编译：

$ mmm frameworks/base/services

 

7.Android应用程序中使用

 

package cc.icen.leddemo;

import android.os.RemoteException;
import android.app.Activity;
import android.os.Bundle;
import android.widget.Button;
import android.view.View;
import android.widget.CheckBox;
import android.widget.Toast;
import android.os.ILedService;
import android.os.ServiceManager;
import android.util.Log;

public class MainActivity extends Activity {

    private boolean ledon = false;
    private Button button = null;
    private CheckBox checkBoxLed1 = null;
    private CheckBox checkBoxLed2 = null;
    private CheckBox checkBoxLed3 = null;
    private CheckBox checkBoxLed4 = null;
    private ILedService iLedService = null;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        button = (Button) findViewById(R.id.BUTTON);

        iLedService = ILedService.Stub.asInterface(ServiceManager.getService("led"));
        if(iLedService == null)
            Log.d("tian","iLedService is null!!!!");

        checkBoxLed1 = (CheckBox)findViewById(R.id.LED1);
        checkBoxLed2 = (CheckBox)findViewById(R.id.LED2);
        checkBoxLed3 = (CheckBox)findViewById(R.id.LED3);
        checkBoxLed4 = (CheckBox)findViewById(R.id.LED4);

        button.setOnClickListener(new MyButtonListener());

    }

    class MyButtonListener implements View.OnClickListener {
        @Override
        public void onClick(View v) {
            ledon = !ledon;
            if (ledon) {
                button.setText("ALL OFF");
                checkBoxLed1.setChecked(true);
                checkBoxLed2.setChecked(true);
                checkBoxLed3.setChecked(true);
                checkBoxLed4.setChecked(true);

                try {
                    for (int i = 0; i < 4; i++)
                        iLedService.ledCtrl(i, 1);
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
            else {
                button.setText("ALL ON");
                checkBoxLed1.setChecked(false);
                checkBoxLed2.setChecked(false);
                checkBoxLed3.setChecked(false);
                checkBoxLed4.setChecked(false);

                try {
                    for (int i = 0; i < 4; i++)
                        iLedService.ledCtrl(i, 0);
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public void onCheckboxClicked(View view) {
        // Is the view now checked?
        boolean checked = ((CheckBox) view).isChecked();

        try {
            // Check which checkbox was clicked
            switch(view.getId()) {
                case R.id.LED1:
                    if (checked) {
                        // Put some meat on the sandwich
                        Log.d("tian","1");
                        //Toast.makeText(getApplicationContext(), "LED1 on", Toast.LENGTH_SHORT).show();
                        iLedService.ledCtrl(0, 1);
                        Log.d("tian","2");
                    }
                    else {
                        // Remove the meat
                        //Toast.makeText(getApplicationContext(), "LED1 off", Toast.LENGTH_SHORT).show();
                        iLedService.ledCtrl(0, 0);
                    }
                    break;
                case R.id.LED2:
                    if (checked) {
                        // Put some meat on the sandwich
                        //Toast.makeText(getApplicationContext(), "LED2 on", Toast.LENGTH_SHORT).show();
                        iLedService.ledCtrl(1, 1);
                    }
                    else {
                        // Remove the meat
                        //Toast.makeText(getApplicationContext(), "LED2 off", Toast.LENGTH_SHORT).show();
                        iLedService.ledCtrl(1, 0);
                    }
                    break;

                case R.id.LED3:
                    if (checked) {
                        // Put some meat on the sandwich
                        //Toast.makeText(getApplicationContext(), "LED3 on", Toast.LENGTH_SHORT).show();
                        iLedService.ledCtrl(2, 1);
                    }
                    else {
                        // Remove the meat
                        //Toast.makeText(getApplicationContext(), "LED3 off", Toast.LENGTH_SHORT).show();
                        iLedService.ledCtrl(2, 0);
                    }
                    break;

                case R.id.LED4:
                    if (checked) {
                        // Put some meat on the sandwich
                        //Toast.makeText(getApplicationContext(), "LED4 on", Toast.LENGTH_SHORT).show();
                        iLedService.ledCtrl(3, 1);
                    }
                    else {
                        // Remove the meat
                        //Toast.makeText(getApplicationContext(), "LED4 off", Toast.LENGTH_SHORT).show();
                        iLedService.ledCtrl(3, 0);
                    }
                    break;
                // TODO: Veggie sandwich
            }
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    }

}

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent"
    android:layout_height="match_parent" android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    android:paddingBottom="@dimen/activity_vertical_margin" tools:context=".MainActivity"
    android:orientation="vertical"
    >

    <Button
        android:id="@+id/BUTTON"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:text="@string/app_name"
        />

    <CheckBox
        android:id="@+id/LED1"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:text="@string/app_name"
        android:onClick="onCheckboxClicked"
        />

    <CheckBox
        android:id="@+id/LED2"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:text="@string/app_name"
        android:onClick="onCheckboxClicked"
        />

    <CheckBox
        android:id="@+id/LED3"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:text="@string/app_name"
        android:onClick="onCheckboxClicked"
        />

    <CheckBox
        android:id="@+id/LED4"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:text="@string/app_name"
        android:onClick="onCheckboxClicked"
        />

</LinearLayout>

#Android.mk
LOCAL_PATH := $(call my-dir)
  include $(CLEAR_VARS)

  # Build all java files in the java subdirectory
  LOCAL_SRC_FILES := $(call all-subdir-java-files)

  # Name of the APK to build
  LOCAL_PACKAGE_NAME := LEDDemo

  # Tell it to build an APK
  include $(BUILD_PACKAGE)

 

 

android应用如何访问C库

安卓应用是由java编写的，而在android底层，如安卓底层的硬件驱动程序，都是由C/C++编写的，那应用层java是必须通过某种手段才能使用底层提供的硬件资源。毫无疑问，在java看要调用底层C实现的代码，中间必须要有一层接口，那就是JNI。本例要实现的就是JAVA如何访问底层C库。

假设JAVA应用需要实现的功能是控制底层硬件LED设备，包括开，关及控制操作。需要实现下述流程：

1 实现一个JAVA硬件控制类，声明本地的Native方法（操作硬件的接口），并使用static模块加载C的动态库。实现代码如下

public class HardControl{
    //声明本地的Native方法
    public static native int ledCtrl(int which, int status);
    public static native int ledOpen();
    public static native void ledClose();

    //我们要在这个java程序里面加载C库,定义一个static模块
    static {
        //用System方法来加载C库
        try { //添加捕获异常代码的快捷键为：ctrl+alt+T(前提先用鼠标选中需要捕获的代码)
            System.loadLibrary("hardcontrol"); //参数为C库的库名
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

注意，加载C库的方法为System.loadLibrary.

 

 2 JAVA本地native方法与C库接口的关联

 

 

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

#include <android/log.h> /* liblog */

jint ledOpen(JNIEnv *env, jobject cls)
{

    __android_log_print(ANDROID_LOG_DEBUG, "LEDDemo",  "native_ledOpen"); //调用这句就可以打印了。

    return ;
}

void ledClose(JNIEnv *env, jobject cls)
{
    __android_log_print(ANDROID_LOG_DEBUG, "LEDDemo",  "native_ledClose"); //调用这句就可以打印了。

}

void ledCtrl(JNIEnv *env, jobject cls, jint which, jint status)
{
    __android_log_print(ANDROID_LOG_DEBUG, "LEDDemo",  "native_ledCtrl:%d %d", which, status); //调用这句就可以打印了。

    return ;
}

static const JNINativeMethod methods[] = {
        {"ledOpen", "()I", (void *)ledOpen}, //() inside empty=> no params, 'I' means: return type is int
        {"ledClose", "()V", (void *)ledClose},//() inside empty=> no params, 'V' means: return type is void
        {"ledCtrl", "(II)I", (void *)ledCtrl}, //()inside two I => means two params, types is int, ouside () is 'I' ==> return type is int

};

/* System.LoadLibrary */
JNI_OnLoad(JavaVM *jvm, void *reserved)
{
    JNIEnv *env;
    jclass cls;
    if((*jvm)->GetEnv(jvm, (void**)&env, JNI_VERSION_1_4) != JNI_OK) {
        return JNI_ERR;; //jni version not supported
    }

    //find the class that realize the local native method: *.java, here is HardControl
    //PS:here need to indification the package & class name.
    // "." --> "/"
    cls = (*env)->FindClass(env, "com/example/zhm/hardlibrary/HardControl");
    if( cls == NULL )
    {
        return JNI_ERR;
    }

    //find the class then register their methods .  Java's method <==correspond with ==> C's method
    if((*env)->RegisterNatives(env, cls, methods, sizeof(methods)/sizeof(methods[])) <  ) // 3: means there are 3 funcs in methods.
    {

    }

}

如果某个硬件资源只能被某一个应用使用，可以使用下面的方法访问硬件：JAVA APP--->JNI_OnLoad（）加载C库---->将JAVA三个地方法与C库函数进行关联并注册---->调用JAVA本地Native方法就可以访问C库的C接口------>进而访问硬件驱动中的open, read, write，从进访问硬件。但是，以上场景仅限于只有一个APP使用这个硬件资源，如果有多个应用想要使用某个硬件时，如果还按上面方法，必须会造成硬件资源的冲突，所以此时需要有一种框架来解决这个问题。解决方案就是访问硬件资源的程序只能并且只有一个，我们称之为System Server, 其它要访问这个硬件资源的APP必须要给Server发请求，由Server间接的操作硬件，从而实现资源的访问。这个就称之为硬件访问服务。

关于硬件访问服务需要注意以下几点：

1 System Server是由JAVA编写的，所以它要想访问硬件，必须要加载JNI的C库(Loadlibrary).

2 C库的JNI_Onload函数里要注册本地方法，分别调用各个硬件的函数来注册本地方法。比如LED，振动器，有串口。。。等等。。

3 System Server：

(1)对每个硬件都要添加服务,add service

 前提需要实现的是：对每个硬件构造service,使用本地Native方法

(2)对于(1)添加的服务就是向service_manager.c注册，比如serialservice, vibratorservice, ledservice等。如果JAVA应用程序需要使用某些Service的时候，就需要通过这个Service_manager查询及获取相应的Service。

4 最终APP怎么使用？

(1)APP使用之前需要获得这个服务getService

(2)最后就是使用这个服务了。执行Service的方法

以后修改硬件驱动的时候，把驱动文件放在hal里面,如hal_led.c，有几个好处：

(1)容易修改

(2)很多公司不愿意开放其硬件操作，他们只提供so文件，出于保密的目的。试想一下，如果把硬件操作源代码放到JNI文件里，如果要修改，需要编译整个工程，此外，硬件源代码暴露出来了,保密性不好。

分析一下：

以上操作涉及到三个进程， 

1 SystemServer进程：它提供的功能如下：

---a: 它向service_manager.c注册服务

---b: 加载硬件Service JNI 的C库

---C: 接收其它app的硬件操作请求，访问硬件资源

2 Service_Manager进程：负责硬件资源各种Service的注册添加,以及接怍JAVA应用app的各种service查询请求及资源的获取。

3 JAVA应用APP进程，它其实是一个客户端，它首先向Service_Manager查询获得某一个Service, 最后，把这个Service发送给SystemServer进程以请求相应的服务，

  而以上三个进程之间的内部通信，主要依靠Android内核的Binder Driver系统进行内部进程间通信。这个Binder并不是linux内核自带的，是google公司对linux内核进行修改添加的一个驱动程序，可实现更加高效的进程间通信。

 

思考：如何实现一个硬件访问服务。

1 编写JNI和HAL,以led为例，先编写com_android_server_ledservice.cpp，用于注册JNI本地方法。再编写hal_led.c，里面就是实现open,read,write等硬件访问接口。

2 修改onload.cpp,调它调用com_android_server_ledservice.cpp内实现的函数，

3 修改system server.java, 

   new ledservice()

   add ledservice()

4 编写LEDService.java,用于调用本地方法，实现硬件操作

5 编写ILEDService.java接口给app使用。

 

Android硬件抽象层模块开发

 

 

Android硬件访问服务开发