2. 程式人生 > >利用JNI寫的安卓串列埠讀寫框架

利用JNI寫的安卓串列埠讀寫框架

阿新 • • 發佈：2019-02-16

C程式碼如下：

#include <termios.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <jni.h>

//#include "SerialPort.h"

#include "android/log.h"
static const char *TAG="serial_port";
#define LOGI(fmt, args...) __android_log_print(ANDROID_LOG_INFO,  TAG, fmt, ##args)
#define LOGD(fmt, args...) __android_log_print(ANDROID_LOG_DEBUG, TAG, fmt, ##args)
#define LOGE(fmt, args...) __android_log_print(ANDROID_LOG_ERROR, TAG, fmt, ##args)

static speed_t getBaudrate(jint baudrate)
{
	switch(baudrate)
	{
		case 0: return B0;
		case 50: return B50;
		case 75: return B75;
		case 110: return B110;
		case 134: return B134;
		case 150: return B150;
		case 200: return B200;
		case 300: return B300;
		case 600: return B600;
		case 1200: return B1200;
		case 1800: return B1800;
		case 2400: return B2400;
		case 4800: return B4800;
		case 9600: return B9600;
		case 19200: return B19200;
		case 38400: return B38400;
		case 57600: return B57600;
		case 115200: return B115200;
		case 230400: return B230400;
		case 460800: return B460800;
		case 500000: return B500000;
		case 576000: return B576000;
		case 921600: return B921600;
		case 1000000: return B1000000;
		case 1152000: return B1152000;
		case 1500000: return B1500000;
		case 2000000: return B2000000;
		case 2500000: return B2500000;
		case 3000000: return B3000000;
		case 3500000: return B3500000;
		case 4000000: return B4000000;
		default: return -1;
	}
}

/*
 * Class:     android_serialport_SerialPort
 * Method:    open
 * Signature: (Ljava/lang/String;II)Ljava/io/FileDescriptor;
 */
JNIEXPORT jobject JNICALL Java_com_cjz_jniserialtest_SerialUtil_open (JNIEnv *env, jclass thiz, jstring path, jint baudRate)
{
	int fd;
	speed_t speed;
	jobject mFileDescriptor;

	/* Check arguments */
	{
		speed = getBaudrate(baudRate);
		if (speed == -1) {
			/* TODO: throw an exception */
//			LOGE("Invalid baudrate");
			return NULL;
		}
	}

	/* Opening device */
	{
		jboolean iscopy;
		const char *path_utf = (*env)->GetStringUTFChars(env, path, &iscopy);
//		LOGD("Opening serial port %s with flags 0x%x", path_utf, O_RDWR | flags);
		fd = open(path_utf, O_RDWR/* | flags*/);
//		LOGD("open() fd = %d", fd);
		(*env)->ReleaseStringUTFChars(env, path, path_utf);
		if (fd == -1)
		{
			/* Throw an exception */
//			LOGE("Cannot open port");
			/* TODO: throw an exception */
			return NULL;
		}
	}

	/* Configure device */
	{
		struct termios cfg;
//		LOGD("Configuring serial port");
		if (tcgetattr(fd, &cfg))
		{
//			LOGE("tcgetattr() failed");
			close(fd);
			/* TODO: throw an exception */
			return NULL;
		}

		cfmakeraw(&cfg);
		cfsetispeed(&cfg, speed);
		cfsetospeed(&cfg, speed);

		if (tcsetattr(fd, TCSANOW, &cfg))
		{
//			LOGE("tcsetattr() failed");
			close(fd);
			/* TODO: throw an exception */
			return NULL;
		}
	}

	/* Create a corresponding file descriptor */
	{
		jclass cFileDescriptor = (*env)->FindClass(env, "java/io/FileDescriptor");
		jmethodID iFileDescriptor = (*env)->GetMethodID(env, cFileDescriptor, "<init>", "()V");
		jfieldID descriptorID = (*env)->GetFieldID(env, cFileDescriptor, "descriptor", "I");
		mFileDescriptor = (*env)->NewObject(env, cFileDescriptor, iFileDescriptor);
		(*env)->SetIntField(env, mFileDescriptor, descriptorID, (jint)fd);
	}

	return mFileDescriptor;
}

/*
 * Class:     cedric_serial_SerialPort
 * Method:    close
 * Signature: ()V
 */
JNIEXPORT void JNICALL Java_com_cjz_jniserialtest_SerialUtil_close(JNIEnv *env, jobject thiz)
{
	jclass SerialPortClass = (*env)->GetObjectClass(env, thiz);
	jclass FileDescriptorClass = (*env)->FindClass(env, "java/io/FileDescriptor");

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

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

//	LOGD("close(fd = %d)", descriptor);
	close(descriptor);
}
JAVA部分：

記得開一個com.cjz.jniserialtest的包去放這些類，否則JNI無法聯絡到類和C程式碼介面，導致出錯

SerialUtil：

package com.cjz.jniserialtest;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileDescriptor;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.util.LinkedList;

import android.util.Log;

import com.hanlion.cardofclass.utils.CommUtils;
import com.hanlion.cardofclass.utils.LogUtils;

/**
 * @author 陳杰柱
 * @version 串列埠讀寫框架 1.0
 *
 * 當觀察者模式開啟時，最好不要使用其他單獨方法，否則容易因為
 * 爭奪資料的原因導致出錯
 ***/

public class SerialUtil
{

	private FileDescriptor mFd;
	private FileInputStream mFileInputStream;
	private FileOutputStream mFileOutputStream;
	private ThreadTimeCount threadTimeCount;
	private Thread threadReadData;
	private boolean observerMode = false;
	private static final String TAG = "SerialPortMsg";

	/**波特率列表類**/
	public class BaudRateList
	{
		public static final int B50 = 50;
		public static final int B75 = 75;
		public static final int B110 = 110;
		public static final int B134 = 134;
		public static final int B150 = 150;
		public static final int B200 = 200;
		public static final int B300 = 300;
		public static final int B600 = 600;
		public static final int B1200 = 1200;
		public static final int B1800 = 1800;
		public static final int B2400 = 2400;
		public static final int B4800 = 4800;
		public static final int B9600 = 9600;
		public static final int B19200 = 19200;
		public static final int B38400 = 38400;
		public static final int B57600 = 57600;
		public static final int B115200 = 115200;
		public static final int B230400 = 230400;
		public static final int B460800 = 460800;
		public static final int B500000 = 500000;
		public static final int B576000 = 576000;
		public static final int B921600 = 921600;
		public static final int B1000000 = 1000000;
		public static final int B1152000 = 1152000;
		public static final int B1500000 = 1500000;
		public static final int B2000000 = 2000000;
		public static final int B2500000 = 2500000;
		public static final int B3000000 = 3000000;
		public static final int B3500000 = 3500000;
		public static final int B4000000 = 4000000;
	}

	/**開啟對應視窗內IO裝置，支援USB轉串列埠
	 * @param path 裝置檔案位置(inux把所有裝置視為一個一維檔案，不過按照圖靈機概念本來計算機就是“紙帶+讀寫頭”)
	 * @param baudRate 波特率設定，**/
	public native static synchronized FileDescriptor open(String path, int baudRate);

	/**關閉對應視窗內IO裝置**/
	public native static synchronized FileDescriptor close();
	static
	{
		System.loadLibrary("JNISerialCtrl");
	}

	/**開啟對應視窗內IO裝置，支援USB轉串列埠
	 * @param path 裝置檔案位置(Linux把所有裝置視為一個一維檔案，不過按照圖靈機概念本來計算機就是“紙帶+讀寫頭”)
	 * @param baudRate 波特率設定，**/
	public SerialUtil(String devicePath, int baudrate)
	{

		/* Check access permission */
		File device = new File(devicePath);
		if(!device.exists()) return ;
		if (!device.canRead() || !device.canWrite())
		{
			try
			{
				/* Missing read/write permission, trying to chmod the file */
				Process su;
				su = Runtime.getRuntime().exec(CommUtils.getSuPath());
				String cmd = "chmod 666 " + device.getAbsolutePath() + "\n" + "exit\n";
				su.getOutputStream().write(cmd.getBytes());
				if ((su.waitFor() != 0) || !device.canRead() || !device.canWrite())
				{
					LogUtils.logE("串列埠開啟失敗");
				}
			} catch (Exception e)
			{
				e.printStackTrace();
			}
		}

		mFd = open(device.getAbsolutePath(), baudrate);
		if (mFd == null)
		{
			Log.e(TAG, "native open returns null");
			//throw new IOException();
			return ;
		}
		mFileInputStream = new FileInputStream(mFd);
		mFileOutputStream = new FileOutputStream(mFd);
	}

	/**獲取裝置輸入流（主動捕獲模式）**/
	public InputStream getInputStream()
	{
		return mFileInputStream;
	}

	/**獲取裝置輸出流（主動捕獲模式）**/
	public OutputStream getOutputStream()
	{
		return mFileOutputStream;
	}

	/**獲取Reader，以文字方式讀取（當回車時結束）（主動捕獲模式，不關閉）**/
	public BufferedReader getBufferedReader()
	{
		try {
			return new BufferedReader(new InputStreamReader(getInputStream()));
		} catch (Exception e) {
			return null;
		}
	}

	/**以Byte連結串列方式讀取（主動捕獲模式）
	 * @param spiltTimeLengthMS 隔多久沒收到資料就視為本次接收結束，由使用者自定義**/
	public LinkedList<Byte> getByteLinkedList(long spiltTimeLengthMS)
	{
		final LinkedList<Byte> linkedListDataPool = new LinkedList<Byte>();
		threadTimeCount = new ThreadTimeCount();
		threadTimeCount.setEndTimeConut(spiltTimeLengthMS);
		threadReadData = new Thread(new Runnable()
		{
			private byte temp;
			@Override
			public void run()
			{
				//加鎖，以防函式返回空值
				synchronized (linkedListDataPool)
				{
					try
					{
						//如果read返回值為-1或者isInterrupted()接收到結束訊號則跳出迴圈
						while( ((temp = (byte) (getInputStream().read() & 0xFF) != -1) && !threadReadData.isInterrupted())
						{
							linkedListDataPool.add(temp);
							//超過某個毫秒數沒輸入，就將連結串列丟擲到變成陣列，然後清空，再接收
							threadTimeCount.stillInputing();
						}
					}
					catch (IOException e)
					{
						e.printStackTrace();
					}
				}
				//Log.i(TAG, "collect Byte Finished");
			}
		});
		threadTimeCount.threadBabySitting(threadReadData);
		threadTimeCount.start();

		synchronized (linkedListDataPool)
		{
			return linkedListDataPool;
		}
	}

	/**以StringBuffer連結串列方式讀取（主動捕獲模式）
	 * @param spiltTimeLengthMS 隔多久沒收到資料就視為本次接收結束，由使用者自定義**/
	public StringBuffer getStringBuffer(long spiltTimeLengthMS)
	{
		StringBuffer buffer = new StringBuffer();
		for(byte temp : getByteLinkedList(spiltTimeLengthMS)) buffer.append((char)temp);
		return buffer;
	}

	/**以位元組陣列方式讀取（主動捕獲模式）
	 * @param spiltTimeLengthMS 隔多久沒收到資料就視為本次接收結束，由使用者自定義**/
	public byte[] getByteArray(long spiltTimeLengthMS)
	{
		LinkedList<Byte> bytes = getByteLinkedList(spiltTimeLengthMS);
		int position = 0;
		byte byteArray[] = new byte[bytes.size()];
		for(byte temp : bytes) byteArray[position++] = temp;
		return byteArray;
	}

	/**以位元組陣列方式輸出到串列埠（主動捕獲模式）**/
	public void outputByteArray(byte[] data) throws IOException
	{
		getOutputStream().write(data);
		getOutputStream().flush();
	}

	/**以字串方式輸出到串列埠（主動捕獲模式）**/
	public void outputString(String data) throws IOException
	{
		outputByteArray(data.getBytes());
	}

	/**觀察者模式，通過回撥，檢測到資料就呼叫使用者自定義函式，被動捕獲模式
	 * 強烈推薦使用觀察者模式**/
	public abstract class SerialObserver
	{
		private LinkedList<Byte> linkedListSerialData = new LinkedList<Byte>();
		private long spiltTimeLengthMS;
		private long serialDataSize = 0;
		/** @param spiltTimeLengthMS 隔多久沒收到資料就視為本次接收結束，由使用者自定義**/
		public SerialObserver(long spiltTimeLengthMS)
		{
			observerMode = true;
			SerialObserver.this.spiltTimeLengthMS = spiltTimeLengthMS;
			//資料採集執行緒：
			new Thread(new Runnable()
			{
				@Override
				public void run()
				{
					byte temp = 0;
					try
					{
						if(getInputStream() == null){
							Log.e("SerialUtil", "讀取視窗識別失敗");
							return;
						}
						while( ((temp = (byte) getInputStream().read()) != -1) && observerMode)
						{
							synchronized (linkedListSerialData)
							{
								linkedListSerialData.add(temp);
								serialDataSize ++ ;
							}

						}
					}
					catch (IOException e) {
						e.printStackTrace();
					}
				}
			}).start();
			//停頓檢查執行緒：
			new Thread(new Runnable()
			{

				@SuppressWarnings("unchecked")
				@Override
				public void run()
				{
					while(observerMode)
					{
						try
						{
							long oldSerialDataSize = serialDataSize;
							Thread.sleep(SerialObserver.this.spiltTimeLengthMS);
							if(oldSerialDataSize == serialDataSize)
							{
								synchronized (linkedListSerialData)
								{
									serialData((LinkedList<Byte>)linkedListSerialData.clone());
								}
								linkedListSerialData.clear();
								serialDataSize = 0;
							}

						}
						catch (InterruptedException e)
						{
							e.printStackTrace();
						}
					}
				}
			}).start();
		}

		public void turnOffObserverMode(){observerMode = false;}
		public void turnOnObserverMode(){observerMode = true;}

		public abstract void serialData(LinkedList<Byte> data);
	}
}


ThreadTimeCount：

package com.cjz.jniserialtest;


public class ThreadTimeCount extends Thread
{
	/**迴圈控制開關**/
	private boolean runSwitch = true;
	/**控制多少毫秒沒資料流入就代表這次資料傳入結束，預設100**/
	private long endTimeCountMs = 100;
	private long inputTimes;
	private Thread threadIntoMe = null;

	@Override
	public void run()
	{
		while(runSwitch)
		{
			long oldUpdateCount = inputTimes;
			try
			{
				Thread.sleep(endTimeCountMs);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			if(inputTimes == oldUpdateCount)
			{
				if(this.threadIntoMe != null) this.threadIntoMe.interrupt();
				close();
			}
		}
	}

	@Override
	public void interrupt()
	{
		super.interrupt();
		close();
	}

	/**告訴執行緒其實我還在寫資料**/
	public void stillInputing()
	{
		inputTimes ++;
	}

	public void close()
	{
		runSwitch = false;
	}

	/**設定多少毫秒沒收到資料就代表已完成一次接收
	 * @param timeCount 毫米級時間**/
	public void setEndTimeConut(long timeCount)
	{
		this.endTimeCountMs = timeCount;
	}


	/**執行緒託管**/
	public void threadBabySitting(Thread thread)
	{
		this.threadIntoMe = thread;
		if(this.threadIntoMe != null) this.threadIntoMe.start();

	}
}
CommonUtil：
public class CommUtils {


    private static Activity currentActivity = null;
    private static String suPath = "/system/xbin/su";


    public static String getSuPath() {
        return suPath;
    }

    public static void setSuPath(String suPath) {
        CommUtils.suPath = suPath;
    }

}



使用方法示例（擷取自己工程的一部分）：

通過繼承抽象類SerialUtil.SerialObserver，splitTimeLengthMS代表超過多少毫秒沒有新位元組發過來，就當是接受完了一份資料，預設是100ms的間隔時間。然後內容會以Byte連結串列的形式回撥給serialData方法，這裡寫自己要用的程式碼即可。例子程式碼的是我自己安卓工程的一個內部類，把收到的卡號資料（小端）整理到一個long變數中，然後給打卡卡號處理方法進一步處理。就像流水線一樣。

   public NormalModeController(ModeActivity act) {
		//其他過程...
		...
		...
		...
		class SerialReader extends SerialUtil.SerialObserver {

				public SerialReader(SerialUtil serialUtil, long spiltTimeLengthMS) {
					serialUtil.super(spiltTimeLengthMS);
				}

				@Override
				public void serialData(LinkedList<Byte> data) {
					long cardNumber = 0;
					String strCardNumber = null;
					if(data == null) return;
					if(data.size() < 4) return;
					LogUtils.logI("serialData:" +   String.format("%X", (data.get(0) & 0xFF)) + "," +
													String.format("%X", (data.get(1) & 0xFF)) + "," +
													String.format("%X", (data.get(2) & 0xFF)) + "," +
													String.format("%X", (data.get(3) & 0xFF))
								);

					//方法1：
					/*cardNumber = cardNumber | ((data.get(3) & 0xFF) << 24);
					cardNumber = cardNumber | ((data.get(2) & 0xFF) << 16);
					cardNumber = cardNumber | ((data.get(1) & 0xFF) << 8);
					cardNumber = cardNumber | ((data.get(0) & 0xFF) << 0);*/

					//方法2：抽象成了一個迴圈搞定（注意是小端資料格式，所以要反向迴圈。因為超過了4位元組，怕影響符號位，所以用long來儲存位移數）
					for(int i = data.size() - 1; i >= 0; i--){
						cardNumber = cardNumber | (data.get(i) & 0xFF);
						if(i > 0) cardNumber = cardNumber << 8;
					}

					if(cardNumber == 0) return ;
					//將其定長為10位整數：
					strCardNumber = String.format("%010d", cardNumber);
					Log.i("Content:", strCardNumber);
					//把卡號傳送到主執行緒
					Message msg = new Message();
					msg.what = NormalModeControllerConstant.SEND_CARD_MSG;
					msg.obj = strCardNumber;
					handler.sendMessage(msg);
				}

			}
			//建立SerialUtil物件，傳入串列埠裝置號，還有波特率。
			SerialUtil serialUtil = new SerialUtil("/dev/ttyS3", SerialUtil.BaudRateList.B9600);
			//建立繼承抽象類後實現了serialData方法的SerialReader類物件，傳入serialUtil打通上下文，設50ms為分割時間
			SerialReader serialReader = new SerialReader(serialUtil, 50);
			//開啟觀察者模式（回撥資料模式）
			serialReader.turnOnObserverMode();
    }


注意Gradle的App指令碼要加點程式碼（abiFilters可以自己增刪指令集型別）


Android.mk內容如下：


LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)

LOCAL_MODULE    := JNISerialCtrl
LOCAL_SRC_FILES := SerialCtrl.c

include $(BUILD_SHARED_LIBRARY)


找到你放SerialCtrl.c的資料夾，然後在裡面輸入ndk-build，把得到的各種如以armeabi為名的so資料夾，複製到libs資料夾即可。但SerialCtrl.c可以不必放入安卓工程中，只要編譯好的庫資料夾放進去就行。

相關推薦

利用JNI寫的安卓串列埠讀寫框架

C程式碼如下：#include <termios.h> #include <unistd.h> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h&

linux/安卓的spi讀寫ADS1256出現讀寫錯誤

這是因為寫的時候要求單個位元組寫的，不能把一個數組裡存多個位元組然後統一一起傳送出去，這樣可能會在傳送忙的時候出錯 ret = write(fd, TxBuf1, 1); if (ret < 0) printf("spi:SPI Write error\n"); ret

C API方式串列埠讀寫

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！        

C API方式串列埠讀寫

                在除錯ICU通訊裝置的時候，由於串列埠通訊老出現故障，所以就懷疑CF實現的SerialPort類是否有問題，所以最後決定用純API函式實現串列埠讀寫。先從網上搜索相關程式碼（關鍵字：C# API 串列埠），發現網上相關的資料大約來源於一個版本，那就是所謂的msdn提供的樣例程式

2018最新串列埠讀寫程式簡化版傻瓜式教程

附：Visual Studio更改程式圖示傻瓜式教程   Microsoft Visual Studio 2015 目錄 點選檔案-新建-專案​ 點選Visual C#-WPF應用程式，在下方自定義相關資訊。點確定。​ 介面介紹​ 建立圖示資料夾​。

在安卓系統中讀寫資料

0.安卓儲存空間： 目錄結構在FileExplorer中檢視，可通過Windows/Show View/Others/FileExplorer開啟 內部儲存空間（internal storage）：自帶的，必須有的 RAM記憶體：執行記憶體（電腦記憶體） ROM記憶體：儲存空間（電腦

Linux下用C實現串列埠讀寫

 http://hi.baidu.com/weiweisuo1986/item/b33200134ceaac6871d5e81d         之前要做一個和串列埠相關的專案，才認真研究了下串列埠，首先就是要實現串列埠和PC機的通訊。          串列埠的驅動一般不需要我們寫，都是很成熟的驅動

Android串列埠通訊：串列埠讀寫例項

轉自：http://gqdy365.iteye.com/blog/2188906 在Android串列埠通訊：基本知識梳理（http://gqdy365.iteye.com/admin/blogs/2188846）的基礎上，我結合我專案中使用串列埠的例項，進行總結； An

Android串列埠通訊:串列埠讀寫

公司有個專案要用到串列埠通訊，同事有寫好一個DEMO，用的時候發現會有問題，從jni讀串列埠資料時，經常會被截斷，修改select延時還是無濟於事，於是想到用JAVA直接去讀/寫串列埠檔案，經過搜尋在iteye上的一篇部落格1可以滿足需求，但看到下面留言說有問題

安卓如何去讀寫word，pdf，elxs檔案

最近在專案中要生成Word的doc和docx檔案，一番百度google之後，發現通過java語言實現的主流是Apache的POI元件。除了POI，這裡還有另一種實現，不過我沒有去研究，有興趣的同學可以研究研究。 進入主題！  由於專案中只是用到了doc和docx的元件，下

我的小工具，java版串列埠讀寫卡測試工具

工作過程中，經常需要和卡片打交道，如何快速的讀寫卡，提高些工作效率呢？業餘時間，搞了個讀寫卡測試工具， 通過串列埠操作讀卡器。我把車載機改造為串列埠的讀卡器，配合這個工具就可以使用了。如果有網友想使用這個工具，得自己 做個下位機讀卡器了。指令是透傳的，監控發出來的指令

串列埠讀寫問題，需要加入'\r'才能讀到資料

英文原文 串列埠本身，標準和硬體 ? 串列埠是計算機上的序列通訊的物理介面。計算機歷史上，串列埠曾經被廣泛用於連線計算機和終端裝置和各種外部裝置。雖然乙太網介面和USB介面也是以一個序列流進行資料傳送的，但是串列埠連線通常特指那些與RS-232標準相容的硬體或者調變解調器的介面。雖然現在在很多

GD32或者STM32的串列埠燒寫軟體無法串列埠燒寫程式

最近在做M3系列的板子，由於在編譯程式時，HEX檔案太大，用st-link v2燒寫進去後，再次燒寫程式就無法識別，或者目標晶片非所選晶片，於是想用串列埠燒寫，我就用我平時除錯linux的RS232的

unity 讀寫安卓xml配置檔案——記錄貼

最近在研究安卓讀寫xml檔案，感覺被虐的死去活來的，找不到問題的原因，如今已順利解決，來記錄下來之不易的經驗。         我採用的方案是將檔案存入StreamingAssets資料夾下,然後執行的時候自動載入到安卓的持久化目錄下Application.persiste

三、Netty伺服器與多客戶連線利用廣播方式完全理解netty的讀寫機制

         本篇採用的編解碼是netty自帶的字串的格式的編解碼，使用者1可以控制檯發訊息（輸入完訊息要加換行符號，是一個訊息結束的分隔符，後面我會在編解碼中詳細講解）給伺服器，伺服器廣播給其他所有的客戶端，這個機制，我們遊戲開發伺服器中應

用C#寫個NBiot串列埠小工具

背景 做嵌入式這行剛剛開始入門基本就是流水燈跟串列埠這些了，一直用別人的工具（在此感謝那些前輩寫的很好用的工具），雖然很好，但是缺少一些定製化的開發。比如最近我在做NBiot的專案，在除錯NB模組的時候就需要手動複製貼上MsgID號碼，十分繁瑣，有時候還會因為超時，不得不從頭來走一遍

linux c poll 串列埠讀資料例程

epoll機制讀取linux串列埠資料 https://blog.csdn.net/coding__madman/article/details/51657944 com.c #include "com.h" int openSerial(char *cSerialName

如何利用LRUCache製作安卓端谷歌地圖的三級快取

第一個檔案，繼承ArcGIS的TileServerLayer /** * * @author wjf * @date 2018/09/30 */ public class GoogleMapLayer extends TiledServiceLayer {

WINCE5.0利用C#語言編寫的串列埠採集、顯示和儲存

          首先簡單說一下該程式實現的功能：定時採集現場的資料，在介面上實時顯示裝置資料，同時將採集到的裝置資料儲存到sqlite中，以方便第三方資料呼叫。該程式使用在wince5.0中，使用的是VS2008 C#語言。         內容涉及到wince同步的應

安卓日記——用Retrofit寫一個登入註冊APP

在上一篇文章 Python日記——做一套簡易的註冊登入系統中，我簡單介紹瞭如果做一個登入註冊系統，但最終還是要安卓或者網頁是實現這個登入註冊行為 這裡我用一個非常流行的安卓網路請求庫Retrofit去演示這個過程 首先寫網路的介面 public int