瑞芯微Rockchip开发者社区
直播中

ALSET

4年用户 286经验值
擅长:可编程逻辑,电源/新能源,嵌入式技术,处理器/DSP
私信 关注
[经验]

【吉方工控G-3288-02开发板试用体验】吉方工控G-3288-02串口通信开发与开发板刷机

吉方工控G-3288-02串口通信开发测试
作者：大信 8125036
串口开发测试
      G-RK3288工控板有丰富的接口，作为工业数据采集，现场控制是很好的硬件产品。在工业控制方面用的比较多的是通过串口采集数据或者传输数据，控制设备等作用。因此作为工控板支持串口通信是最基础也是最重要的功能。
       联盛德的W801开发板是一款基于平头哥80X的核心的MCU，具有200M主频，288K RAM,2MFlash有I2C,SPI,UART，AD等接口，用于做前端传感器的数据采集和控制功能。W801的Uart0串口通过CH340N芯片转为USB接口。
11.jpg
       串口通信，这里使用G-RK3288作为中控，联盛德的W801开发板作为下位机，两个设备采用USB的串口相连，即USB转串的方式进行连接，连接如下图所示：
1.jpg
                              


Andrioid NDK开发环境准备
       对这个测试，需要在G-RK3288上开发一个串口的应用程序，用来与W801设备进行连接并进行通讯，这里需要G-RK3288支持CH340X的USB驱动，通过查询资料得知在Rk3288的android系统里已经对CH34X系列芯片有支持，在应用程序中需要打开这个USB设备并进行相应的操作即可。但这部分的接口是系统的原生接口，即不属于Android的SDK部分，那么就需要在Android应用里面通过 c/c++代码调用底层系统的接口来进行通讯。因此在Android开发环境中安装 NDK来支持C/C++对系统底层的调用。在AndroidStudio开发软件的菜单 Tools->SDK Manager里点开当前的SDK包，勾选上NDK选项，确定后即补充安装NDK安装包。如下图所示：
2.jpg
查看系统的串口设备
      安装完毕后，然后再把串口工程 Android_serialport_sample
代码复制进去。在调试程序之前，需要了解设备在系统中的文件句柄。这时只要通过ADB 工具等到系统下，查看安USB设备结构如下：
3.jpg
      即可以看到 /dev/u*** 下所有的设备目录。在代码工程里需要遍历这些设备即可，找到我们的外设了。
串口通信程序实现
      串口通信的工程由C/C++和Android两部分，C++部分主要完成设备的打开，关闭，以及相关对设备句柄的设置等操作。
主要代码如下：
  1. /*
  2. * Copyright 2009-2011 Cedric Priscal
  3. *
  4. * Licensed under the Apache License, Version 2.0 (the "License");
  5. * you may not use this file except in compliance with the License.
  6. * You may obtain a copy of the License at
  7. *
  8. * http://www.apache.org/licenses/LICENSE-2.0
  9. *
  10. * Unless required by applicable law or agreed to in writing, software
  11. * distributed under the License is distributed on an "AS IS" BASIS,
  12. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13. * See the License for the specific language governing permissions and
  14. * limitations under the License.
  15. */

  17. #include
  18. #include
  19. #include
  20. #include
  21. #include
  22. #include
  23. #include

  25. #include "SerialPort.h"

  27. #include "android/log.h"

  29. static const char *TAG = "serial_port";
  30. #define LOGI(fmt, args...) __android_log_print(ANDROID_LOG_INFO,  TAG, fmt, ##args)
  31. #define LOGD(fmt, args...) __android_log_print(ANDROID_LOG_DEBUG, TAG, fmt, ##args)
  32. #define LOGE(fmt, args...) __android_log_print(ANDROID_LOG_ERROR, TAG, fmt, ##args)

  34. static speed_t getBaudrate(jint baudrate) {
  35.     switch (baudrate) {
  36.         case 0:
  37.             return B0;
  38.         case 50:
  39.             return B50;
  40.         case 75:
  41.             return B75;
  42.         case 110:
  43.             return B110;
  44.         case 134:
  45.             return B134;
  46.         case 150:
  47.             return B150;
  48.         case 200:
  49.             return B200;
  50.         case 300:
  51.             return B300;
  52.         case 600:
  53.             return B600;
  54.         case 1200:
  55.             return B1200;
  56.         case 1800:
  57.             return B1800;
  58.         case 2400:
  59.             return B2400;
  60.         case 4800:
  61.             return B4800;
  62.         case 9600:
  63.             return B9600;
  64.         case 19200:
  65.             return B19200;
  66.         case 38400:
  67.             return B38400;
  68.         case 57600:
  69.             return B57600;
  70.         case 115200:
  71.             return B115200;
  72.         case 230400:
  73.             return B230400;
  74.         case 460800:
  75.             return B460800;
  76.         case 500000:
  77.             return B500000;
  78.         case 576000:
  79.             return B576000;
  80.         case 921600:
  81.             return B921600;
  82.         case 1000000:
  83.             return B1000000;
  84.         case 1152000:
  85.             return B1152000;
  86.         case 1500000:
  87.             return B1500000;
  88.         case 2000000:
  89.             return B2000000;
  90.         case 2500000:
  91.             return B2500000;
  92.         case 3000000:
  93.             return B3000000;
  94.         case 3500000:
  95.             return B3500000;
  96.         case 4000000:
  97.             return B4000000;
  98.         default:
  99.             return -1;
  100.     }
  101. }

  103. /*
  104. * Class:     android_serialport_SerialPort
  105. * Method:    open
  106. * Signature: (Ljava/lang/String;II)Ljava/io/FileDescriptor;
  107. */
  108. JNIEXPORT jobject JNICALL Java_android_serialport_SerialPort_open
  109.         (JNIEnv *env, jobject thiz, jstring path, jint baudrate, jint dataBits, jint parity,
  110.          jint stopBits,
  111.          jint flags) {

  113.     int fd;
  114.     speed_t speed;
  115.     jobject mFileDescriptor;

  117.     /* Check arguments */
  118.     {
  119.         speed = getBaudrate(baudrate);
  120.         if (speed == -1) {
  121.             /* TODO: throw an exception */
  122.             LOGE("Invalid baudrate");
  123.             return NULL;
  124.         }
  125.     }

  127.     /* Opening device */
  128.     {
  129.         ***oolean iscopy;
  130.         const char *path_utf = (*env)->GetStringUTFChars(env, path, &iscopy);
  131.         LOGD("Opening serial port %s with flags 0x%x", path_utf, O_RDWR | flags);
  132.         fd = open(path_utf, O_RDWR | flags);
  133.         LOGD("open() fd = %d", fd);
  134.         (*env)->ReleaseStringUTFChars(env, path, path_utf);
  135.         if (fd == -1) {
  136.             /* Throw an exception */
  137.             LOGE("Cannot open port");
  138.             /* TODO: throw an exception */
  139.             return NULL;
  140.         }
  141.     }

  143.     /* Configure device */
  144.     {
  145.         struct termios cfg;
  146.         LOGD("Configuring serial port");
  147.         if (tcgetattr(fd, &cfg)) {
  148.             LOGE("tcgetattr() failed");
  149.             close(fd);
  150.             /* TODO: throw an exception */
  151.             return NULL;
  152.         }

  154.         cfmakeraw(&cfg);
  155.         cfsetispeed(&cfg, speed);
  156.         cfsetospeed(&cfg, speed);


  159.         cfg.c_cflag &= ~CSIZE;
  160.         switch (dataBits) {
  161.             case 5:
  162.                 cfg.c_cflag |= CS5;    //使用5位数据位
  163.                 break;
  164.             case 6:
  165.                 cfg.c_cflag |= CS6;    //使用6位数据位
  166.                 break;
  167.             case 7:
  168.                 cfg.c_cflag |= CS7;    //使用7位数据位
  169.                 break;
  170.             case 8:
  171.                 cfg.c_cflag |= CS8;    //使用8位数据位
  172.                 break;
  173.             default:
  174.                 cfg.c_cflag |= CS8;
  175.                 break;
  176.         }

  178.         switch (parity) {
  179.             case 0:
  180.                 cfg.c_cflag &= ~PARENB;    //无奇偶校验
  181.                 break;
  182.             case 1:
  183.                 cfg.c_cflag |= (PARODD | PARENB);   //奇校验
  184.                 break;
  185.             case 2:
  186.                 cfg.c_iflag &= ~(IGNPAR | PARMRK); // 偶校验
  187.                 cfg.c_iflag |= INPCK;
  188.                 cfg.c_cflag |= PARENB;
  189.                 cfg.c_cflag &= ~PARODD;
  190.                 break;
  191.             default:
  192.                 cfg.c_cflag &= ~PARENB;
  193.                 break;
  194.         }

  196.         switch (stopBits) {
  197.             case 1:
  198.                 cfg.c_cflag &= ~CSTOPB;    //1位停止位
  199.                 break;
  200.             case 2:
  201.                 cfg.c_cflag |= CSTOPB;    //2位停止位
  202.                 break;
  203.             default:
  204.                 cfg.c_cflag &= ~CSTOPB;    //1位停止位
  205.                 break;
  206.         }

  208.         if (tcsetattr(fd, TCSANOW, &cfg)) {
  209.             LOGE("tcsetattr() failed");
  210.             close(fd);
  211.             /* TODO: throw an exception */
  212.             return NULL;
  213.         }
  214.     }

  216.     /* Create a corresponding file descriptor */
  217.     {
  218.         jclass cFileDescriptor = (*env)->FindClass(env, "java/io/FileDescriptor");
  219.         jmethodID iFileDescriptor = (*env)->GetMethodID(env, cFileDescriptor, "", "()V");
  220.         jfieldID descriptorID = (*env)->GetFieldID(env, cFileDescriptor, "descriptor", "I");
  221.         mFileDescriptor = (*env)->NewObject(env, cFileDescriptor, iFileDescriptor);
  222.         (*env)->SetIntField(env, mFileDescriptor, descriptorID, (jint) fd);
  223.     }

  225.     return mFileDescriptor;
  226. }

  228. /*
  229. * Class:     cedric_serial_SerialPort
  230. * Method:    close
  231. * Signature: ()V
  232. */
  233. JNIEXPORT void JNICALL Java_android_serialport_SerialPort_close
  234.         (JNIEnv *env, jobject thiz) {
  235.     jclass SerialPortClass = (*env)->GetObjectClass(env, thiz);
  236.     jclass FileDescriptorClass = (*env)->FindClass(env, "java/io/FileDescriptor");

  238.     jfieldID mFdID = (*env)->GetFieldID(env, SerialPortClass, "mFd", "Ljava/io/FileDescriptor;");
  239.     jfieldID descriptorID = (*env)->GetFieldID(env, FileDescriptorClass, "descriptor", "I");

  241.     jobject mFd = (*env)->GetObjectField(env, thiz, mFdID);
  242.     jint descriptor = (*env)->GetIntField(env, mFd, descriptorID);

  244.     LOGD("close(fd = %d)", descriptor);
  245.     close(descriptor);
  246. }


      Android部分的代码主要完成简单的一个UI的实现，完成收发数据的展示，编码格式的转换以及输入，发送按钮等人机交互部分。
主要代码如下：
  1. /*
  2. * Copyright 2009 Cedric Priscal
  3. *
  4. * Licensed under the Apache License, Version 2.0 (the "License");
  5. * you may not use this file except in compliance with the License.
  6. * You may obtain a copy of the License at
  7. *
  8. * http://www.apache.org/licenses/LICENSE-2.0
  9. *
  10. * Unless required by applicable law or agreed to in writing, software
  11. * distributed under the License is distributed on an "AS IS" BASIS,
  12. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13. * See the License for the specific language governing permissions and
  14. * limitations under the License.
  15. */

  17. package android.serialport.sample;

  19. import android.app.Activity;
  20. import android.app.AlertDialog;
  21. import android.content.DialogInterface;
  22. import android.content.DialogInterface.OnClickListener;
  23. import android.os.Bundle;
  24. import android.serialport.SerialPort;
  25. import java.io.IOException;
  26. import java.io.InputStream;
  27. import java.io.OutputStream;
  28. import java.security.InvalidParameterException;

  30. public abstract class SerialPortActivity extends Activity {

  32.     protected Application mApplication;
  33.     protected SerialPort mSerialPort;
  34.     protected OutputStream mOutputStream;
  35.     private InputStream mInputStream;
  36.     private ReadThread mReadThread;

  38.     private class ReadThread extends Thread {

  40.         @Override
  41.         public void run() {
  42.             super.run();
  43.             while (!isInterrupted()) {
  44.                 int size;
  45.                 try {
  46.                     byte[] buffer = new byte[64];
  47.                     if (mInputStream == null) return;
  48.                     size = mInputStream.read(buffer);
  49.                     if (size > 0) {
  50.                         onDataReceived(buffer, size);
  51.                     }
  52.                 } catch (IOException e) {
  53.                     e.printStackTrace();
  54.                     return;
  55.                 }
  56.             }
  57.         }
  58.     }

  60.     private void DisplayError(int resourceId) {
  61.         AlertDialog.Builder b = new AlertDialog.Builder(this);
  62.         b.setTitle("Error");
  63.         b.setMessage(resourceId);
  64.         b.setPositiveButton("OK", new OnClickListener() {
  65.             public void onClick(DialogInterface dialog, int which) {
  66.                 SerialPortActivity.this.finish();
  67.             }
  68.         });
  69.         b.show();
  70.     }

  72.     @Override
  73.     protected void onCreate(Bundle savedInstanceState) {
  74.         super.onCreate(savedInstanceState);
  75.         mApplication = (Application) getApplication();
  76.         try {
  77.             mSerialPort = mApplication.getSerialPort();
  78.             mOutputStream = mSerialPort.getOutputStream();
  79.             mInputStream = mSerialPort.getInputStream();

  81.                         /* Create a receiving thread */
  82.             mReadThread = new ReadThread();
  83.             mReadThread.start();
  84.         } catch (SecurityException e) {
  85.             DisplayError(R.string.error_security);
  86.         } catch (IOException e) {
  87.             DisplayError(R.string.error_unknown);
  88.         } catch (InvalidParameterException e) {
  89.             DisplayError(R.string.error_configuration);
  90.         }
  91.     }

  93.     protected abstract void onDataReceived(final byte[] buffer, final int size);

  95.     @Override
  96.     protected void onDestroy() {
  97.         if (mReadThread != null) mReadThread.interrupt();
  98.         mApplication.closeSerialPort();
  99.         mSerialPort = null;
  100.         super.onDestroy();
  101.     }
  102. }

测试通信结果
      通过Android编译，连接，选择目标板运营，则程序将会自动安装到开发板上，并在板上运行，
      首次运营时根据下位机的设置，同步设置串口参数，波特率为：115200，无校验，停止位1。设置好后，选择发现的USB串口设备，点击打开，则可以看到下位机传输过来的内容了，如下图：
  
5.jpg 6.jpg 4.jpg
开发板刷机方法
      在开发调试中，因为在Android系统中打开了开发者调试模式，并且打开了root权限，在调试中会出损害系统文件的情况，导致系统异常甚至不能正常运行，此时则需要刷机，恢复到出厂状态。
      相关下载工具已放到百度云盘，分享连接放在这里，需要的朋友自取：

提取码: kynu
       刷机方法如下，首先下载瑞芯微开发工具 RkDevtools.exe首次启动如果是英文界面可以在设置里选择中文，则出现中文。 7.jpg
       把开发板与PC连接好后，打开瑞芯微工具，启动后界面如下图，首先检查硬件相关信息，可以点击高级功能，分别能够读取到flash id ,ChipUnfo信息等。
8.jpg
       进入升级固件选项，点击切换，底部的 “发现一个ADB设备”的提示会变成“发现一个LOADER设备”的提示，再点固件选择相应的出现固件文件，再点击升级即可完成升级了，升级过程在右侧信息输出框里出现相应提示。
        升级完将会自动重启，又回到出厂的原始系统了。
   9.jpg 10.jpg
   

更多回帖

0 0 0

相关帖子

RK3288 Android
发帖
电子发烧友APP
|投诉反馈|电子发烧友网
© 2021 bbs.elecfans.com
湘ICP备2023018690号
×
20
完善资料，
赚取积分