优化代码

main
Matthew 1 year ago
parent 68a627d6af
commit 883b5d7e8b

@ -49,4 +49,5 @@ dependencies {
testImplementation 'junit:junit:4.13.2'
androidTestImplementation 'androidx.test.ext:junit:1.1.3'
androidTestImplementation 'androidx.test.espresso:espresso-core:3.4.0'
implementation files('libs/devapi.aar')
}

Binary file not shown.

@ -21,10 +21,9 @@ add_library( # Sets the name of the library.
SHARED
# Provides a relative path to your source file(s).
SpiPort.cpp
#spi-test-random.cpp
# NRSEC3000ctl.cpp
SpiLib.cpp
NrsecPort.cpp
GPIOControl.cpp
native-lib.cpp)
# Searches for a specified prebuilt library and stores the path as a

@ -0,0 +1,135 @@
//
// Created by Matthew on 2023/12/27.
//
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <unistd.h>
#include "GPIOControl.h"
#ifdef _DEBUG
#include <AndroidHelper.h>
#endif
#define IOT_PARAM_WRITE 0xAE
#define IOT_PARAM_READ 0xAF
#define MAX_STRING_LEN 32
typedef struct
{
int cmd;
int value;
int result;
long value2;
char str[MAX_STRING_LEN];
}IOT_PARAM;
void GpioControl::setInt(int cmd, int value)
{
int fd = open("/dev/mtkgpioctrl", O_RDONLY);
IOT_PARAM param;
param.cmd = cmd;
param.value = value;
// LOGE("set_int fd=%d,cmd=%d,value=%d\r\n",fd, cmd, value);
if( fd > 0 )
{
int res = ioctl(fd, IOT_PARAM_WRITE, &param);
// LOGE("set_int22 cmd=%d,value=%d,result=%d\r\n",param.cmd, param.value, param.result);
close(fd);
}
return;
}
int GpioControl::getInt(int cmd)
{
int fd = open("/dev/mtkgpioctrl", O_RDONLY);
// LOGE("get_int fd=%d,cmd=%d\r\n",fd, cmd);
if( fd > 0 )
{
IOT_PARAM param;
param.cmd = cmd;
ioctl(fd, IOT_PARAM_READ, &param);
#ifdef _DEBUG
ALOGI("getInt cmd=%d,value=%d,result=%d\r\n",param.cmd, param.value, param.result);
#endif
close(fd);
return param.value;
}
return -1;
}
void GpioControl::setLong(int cmd, long value)
{
int fd = open("/dev/mtkgpioctrl", O_RDONLY);
IOT_PARAM param;
param.cmd = cmd;
param.value2 = value;
// LOGE("set_long fd=%d,cmd=%d,value2=%ld\r\n",fd, param.cmd, param.value2);
if( fd > 0 )
{
ioctl(fd, IOT_PARAM_WRITE, &param);
// LOGE("set_long22 cmd=%d,value2=%ld,result=%d\r\n",param.cmd, param.value2, param.result);
close(fd);
}
}
long GpioControl::getLong(int cmd)
{
int fd = open("/dev/mtkgpioctrl", O_RDONLY);
// LOGE("get_long fd=%d,cmd=%d\r\n",fd, cmd);
if( fd > 0 )
{
IOT_PARAM param;
param.cmd = cmd;
ioctl(fd, IOT_PARAM_READ, &param);
// LOGE("get_long22 cmd=%d,value2=%ld,result=%d\r\n",param.cmd, param.value2, param.result);
close(fd);
return param.value2;
}
return -1;
}
void GpioControl::setString(int cmd, const std::string& value)
{
IOT_PARAM param;
// char *pval = jstringToChars(env, value);
int fd = open("/dev/mtkgpioctrl", O_RDONLY);
int len = MAX_STRING_LEN < value.size() ? MAX_STRING_LEN : value.size();
param.cmd = cmd;
memset(param.str, 0, MAX_STRING_LEN);
memcpy(param.str, value.c_str(), len);
// LOGE("set_string fd=%d,cmd=%d,str=%s\r\n",fd, param.cmd, param.str);
if( fd > 0 )
{
ioctl(fd, IOT_PARAM_WRITE, &param);
// LOGE("set_string22 cmd=%d,str=%s,result=%d\r\n",param.cmd, param.str, param.result);
close(fd);
}
return;
}
std::string GpioControl::getString(int cmd)
{
int fd = open("/dev/mtkgpioctrl", O_RDONLY);
// LOGE("get_string fd=%d,cmd=%d\r\n",fd, cmd);
if( fd > 0 )
{
IOT_PARAM param;
param.cmd = cmd;
ioctl(fd, IOT_PARAM_READ, &param);
// LOGE("get_string22 cmd=%d,str=%s,result=%d\r\n",param.cmd, param.str, param.result);
close(fd);
return std::string(param.str);
}
return "";
}

@ -0,0 +1,162 @@
//
// Created by Matthew on 2023/12/27.
//
#ifndef MICROPHOTO_GPIOCONTROL_H
#define MICROPHOTO_GPIOCONTROL_H
#include <string>
#define CMD_GET_LIGHT_ADC 101
#define CMD_SET_LIGHT_ADC 102
#define CMD_GET_KEY_LOCKSTATE 103
#define CMD_GET_BAT_ADC 104
#define CMD_SET_FLASH_LED 105
#define CMD_SET_NETWORK_STATE 106
#define CMD_SET_OTG_STATE 107
#define CMD_GET_OTG_STATE 108
#define CMD_GET_CHARGING_VOL_STATE 110
#define CMD_GET_CHARGING_SHUNT_VOLTAGE_STATE 111
#define CMD_GET_CHARGING_BUS_VOLTAGE_STATE 112
#define CMD_GET_CHARGING_POWER_STATE 113
#define CMD_GET_CHARGING_CURRENT_STATE 114
#define CMD_GET_BAT_VOL_STATE 115
#define CMD_GET_BAT_SHUNT_VOLTAGE_STATE 116
#define CMD_GET_BAT_BUS_VOLTAGE_STATE 117
#define CMD_GET_BAT_POWER_STATE 118
#define CMD_GET_BAT_CURRENT_STATE 119
#define CMD_SET_485_STATE 121
#define CMD_SET_SPI_MODE 123
#define CMD_SET_SPI_BITS_PER_WORD 124
#define CMD_SET_SPI_MAXSPEEDHZ 125
#define CMD_SET_PWM_BEE_STATE 126
#define CMD_SET_ALM_MODE 128
#define CMD_SET_485_EN_STATE 131
#define CMD_SET_CAM_3V3_EN_STATE 132
#define CMD_SET_12V_EN_STATE 133
#define CMD_SET_SYSTEM_RESET 202
class GpioControl
{
public:
static void setInt(int cmd, int value);
static int getInt(int cmd);
static void setLong(int cmd, long value);
static long getLong(int cmd);
static void setString(int cmd, const std::string& value);
static std::string getString(int cmd);
static void setOtgState(bool on)
{
setInt(CMD_SET_OTG_STATE, on ? 1 : 0);
}
static bool getOtgState()
{
return getInt(CMD_SET_OTG_STATE) != 0;
}
static void setCam3V3Enable(bool enabled)
{
setInt(CMD_SET_CAM_3V3_EN_STATE, enabled ? 1 : 0);
}
static void reboot()
{
setInt(CMD_SET_SYSTEM_RESET, 1);
}
static void setLightAdc(int i)
{
setInt(CMD_SET_LIGHT_ADC, i);
}
static int getLightAdc()
{
return getInt(CMD_GET_LIGHT_ADC);
}
static int getChargingVoltage()
{
return getInt(CMD_GET_CHARGING_VOL_STATE);
}
static int getChargingShuntVoltage()
{
return getInt(CMD_GET_CHARGING_SHUNT_VOLTAGE_STATE);
}
static int getChargingBusVoltage() {
return getInt(CMD_GET_CHARGING_BUS_VOLTAGE_STATE);
}
static int getChargingPower() {
return getInt(CMD_GET_CHARGING_POWER_STATE);
}
static int getChargingCurrent() {
return getInt(CMD_GET_CHARGING_CURRENT_STATE);
}
static int getBatteryVoltage() {
return getInt(CMD_GET_BAT_VOL_STATE);
}
static int getBatteryShuntVoltage() {
return getInt(CMD_GET_BAT_SHUNT_VOLTAGE_STATE);
}
static int getBatteryBusVoltage() {
return getInt(CMD_GET_BAT_BUS_VOLTAGE_STATE);
}
static int getBatteryPower() {
return getInt(CMD_GET_BAT_POWER_STATE);
}
static int getBatteryCurrent() {
return getInt(CMD_GET_BAT_CURRENT_STATE);
}
static void set485WriteMode() {
setInt(CMD_SET_485_STATE, 1);
}
static void set485ReadMode() {
setInt(CMD_SET_485_STATE, 0);
}
static void setSpiMode(int i) {
setInt(CMD_SET_SPI_MODE, i);
}
static void setSpiBitsPerWord(int i) {
setInt(CMD_SET_SPI_BITS_PER_WORD, i);
}
static void setSpiMaxSpeedHz(long j) {
setLong(CMD_SET_SPI_MAXSPEEDHZ, j);
}
static void setBeeOn(bool z) {
setInt(CMD_SET_PWM_BEE_STATE, z ? 1 : 0);
}
static void setJidianqiState(bool z) {
setInt(CMD_SET_ALM_MODE, z ? 1 : 0);
}
static void setRS485Enable(bool z) {
setInt(CMD_SET_485_EN_STATE, z ? 1 : 0);
}
static void set12VEnable(bool z) {
setInt(CMD_SET_12V_EN_STATE, z ? 1 : 0);
}
};
#endif //MICROPHOTO_GPIOCONTROL_H

File diff suppressed because it is too large Load Diff

@ -0,0 +1,60 @@
#ifndef __NRSECPORT_H__
#define __NRSECPORT_H__
#include "SpiLib.h"
#define CMD_HEAD_SIZE 5
using namespace std;
typedef unsigned char uint8_t;
class NrsecPort : public SpiLIb {
public:
NrsecPort();
~NrsecPort();
bool Open(const char* path);
int Spirandom();
std::string Version();
int Indentify(unsigned char *to_idt, unsigned char *out_idt);
int SM2keypair(int index);
int SM2ExportPublicKey(int index, unsigned char result[]);
int SM2ExportPrivateKey(int index, unsigned char result[]);
int SM2InportPublicKey(int index, const unsigned char new_key[]);
int SM2InportPrivateKey(int index, const unsigned char new_key[]);
int SM3Hash(unsigned char *to_hash, int len, unsigned char *out_hash);
int sm3hash_tosm2(unsigned char *in, int inl, unsigned char *out, unsigned char *pubkey, unsigned char
*pucID, int idl);
int SM2Sign(int index, const unsigned char *to_sign, unsigned char *out_sign);
int SM2VerifySign(int index, unsigned char *hash, unsigned char *vs);
int SM2encrypt(int index, unsigned char *to_encrypt, unsigned char *out_encrypt);
int SM2decoder(int index, unsigned char *to_decoder, unsigned char *out_decoder);
int SM2cert(int type, int index, string cert, unsigned char *out_cert);
protected:
unsigned char get_crc7(const unsigned char *buff, int len);
void SendCMD(uint8_t *cmd, uint8_t *rxbuf);
void RcvINS(uint8_t *txbuf, uint8_t *buf, uint8_t ins);
void RcvLEN(uint8_t *txbuf, uint8_t *buf, uint8_t len);
void RcvData(uint8_t *txbuf, uint8_t *buf);
void RcvData(uint8_t *txbuf, uint8_t *buf, int len);
void RcvSW(uint8_t *txbuf, uint8_t *buf, uint8_t sw);
void SendEnd(uint8_t *txbuf, uint8_t *buf);
void SendId(uint8_t *txbuf, uint8_t *buf, uint8_t id);
void SendData(uint8_t *data, uint8_t *rxbuf, int data_size);
private:
std::string m_path;
int m_fd;
};
#endif // __NRSECPORT_H__

File diff suppressed because it is too large Load Diff

@ -18,103 +18,14 @@
using namespace std;
#define CMD_HEAD_SIZE 5
using namespace std;
typedef unsigned char u8;
class SpiLIb{
class SpiLIb {
public:
int Spirandom();
int Version();
int Indentify(unsigned char *to_idt,unsigned char *out_idt);
int SM2keypair(int index);
int SM2OutPub(int index,unsigned char result[]);
int SM2OutPri(int index,unsigned char result[]);
int SM2InPub(int index,const unsigned char new_key[]);
int SM2InPri(int index,const unsigned char new_key[]);
int SM3Hash(unsigned char *to_hash ,int len,unsigned char *out_hash);
int sm3hash_tosm2(unsigned char *in,int inl,unsigned char *out, unsigned char *pubkey, unsigned char
*pucID, int idl);
int SM2Sign(int index,const unsigned char *to_sign,unsigned char *out_sign);
int SM2VerifySign(int index,unsigned char *hash,unsigned char *vs);
int SM2encrypt(int index,unsigned char *to_encrypt ,unsigned char *out_encrypt);
int SM2decoder(int index,unsigned char *to_decoder ,unsigned char *out_decoder);
int SM2cert(int type,int index,string cert,unsigned char *out_cert);
private:
const unsigned char crc7_table[256]= {
0x00, 0x09, 0x12, 0x1b, 0x24, 0x2d, 0x36, 0x3f,
0x48, 0x41, 0x5a, 0x53, 0x6c, 0x65, 0x7e, 0x77,
0x19, 0x10, 0x0b, 0x02, 0x3d, 0x34, 0x2f, 0x26,
0x51, 0x58, 0x43, 0x4a, 0x75, 0x7c, 0x67, 0x6e,
0x32, 0x3b, 0x20, 0x29, 0x16, 0x1f, 0x04, 0x0d,
0x7a, 0x73, 0x68, 0x61, 0x5e, 0x57, 0x4c, 0x45,
0x2b, 0x22, 0x39, 0x30, 0x0f, 0x06, 0x1d, 0x14,
0x63, 0x6a, 0x71, 0x78, 0x47, 0x4e, 0x55, 0x5c,
0x64, 0x6d, 0x76, 0x7f, 0x40, 0x49, 0x52, 0x5b,
0x2c, 0x25, 0x3e, 0x37, 0x08, 0x01, 0x1a, 0x13,
0x7d, 0x74, 0x6f, 0x66, 0x59, 0x50, 0x4b, 0x42,
0x35, 0x3c, 0x27, 0x2e, 0x11, 0x18, 0x03, 0x0a,
0x56, 0x5f, 0x44, 0x4d, 0x72, 0x7b, 0x60, 0x69,
0x1e, 0x17, 0x0c, 0x05, 0x3a, 0x33, 0x28, 0x21,
0x4f, 0x46, 0x5d, 0x54, 0x6b, 0x62, 0x79, 0x70,
0x07, 0x0e, 0x15, 0x1c, 0x23, 0x2a, 0x31, 0x38,
0x41, 0x48, 0x53, 0x5a, 0x65, 0x6c, 0x77, 0x7e,
0x09, 0x00, 0x1b, 0x12, 0x2d, 0x24, 0x3f, 0x36,
0x58, 0x51, 0x4a, 0x43, 0x7c, 0x75, 0x6e, 0x67,
0x10, 0x19, 0x02, 0x0b, 0x34, 0x3d, 0x26, 0x2f,
0x73, 0x7a, 0x61, 0x68, 0x57, 0x5e, 0x45, 0x4c,
0x3b, 0x32, 0x29, 0x20, 0x1f, 0x16, 0x0d, 0x04,
0x6a, 0x63, 0x78, 0x71, 0x4e, 0x47, 0x5c, 0x55,
0x22, 0x2b, 0x30, 0x39, 0x06, 0x0f, 0x14, 0x1d,
0x25, 0x2c, 0x37, 0x3e, 0x01, 0x08, 0x13, 0x1a,
0x6d, 0x64, 0x7f, 0x76, 0x49, 0x40, 0x5b, 0x52,
0x3c, 0x35, 0x2e, 0x27, 0x18, 0x11, 0x0a, 0x03,
0x74, 0x7d, 0x66, 0x6f, 0x50, 0x59, 0x42, 0x4b,
0x17, 0x1e, 0x05, 0x0c, 0x33, 0x3a, 0x21, 0x28,
0x5f, 0x56, 0x4d, 0x44, 0x7b, 0x72, 0x69, 0x60,
0x0e, 0x07, 0x1c, 0x15, 0x2a, 0x23, 0x38, 0x31,
0x46, 0x4f, 0x54, 0x5d, 0x62, 0x6b, 0x70, 0x79
};
const unsigned char EK_CMD[5]={0x80,0xd4,0x01,0x00,0x10};
const unsigned char AK_CMD[5]={0x80,0xd4,0x02,0x00,0x10};
const unsigned char IV_CMD[5]={0x80,0xd4,0x04,0x00,0x10};
volatile unsigned char SM1encrpt_CMD[5]={0xa0,0xe0,0x80,0xff,0xff};
volatile unsigned char SM1decoder_CMD[5]={0xa0,0xe0,0x81,0xff,0xff};
volatile unsigned char SM2Keypair_CMD[5]={0x80,0xb2,0x00,0xff,0x00};
volatile unsigned char SM2OutPub_CMD[5]={0x80,0xb8,0x01,0xff,0x40};
volatile unsigned char SM2OutPri_CMD[5]={0x80,0xb8,0x02,0xff,0x20};
volatile unsigned char SM2InPub_CMD[5]={0x80,0xba,0x01,0xff,0x40};
volatile unsigned char SM2InPri_CMD[5]={0x80,0xba,0x02,0xff,0x20};
volatile unsigned char SM3Hash_CMD[5]={0x80,0xb5,0x00,0xff,0xff};
volatile unsigned char SM2Sign_CMD[5]={0x80,0xb4,0x00,0xff,0x20};
volatile unsigned char SM2VerifySign_CMD[5]={0x80,0xb6,0x00,0xff,0x60};
volatile unsigned char SM2encrypt_CMD[5]={0x80,0xb3,0x01,0xff,0x20};
volatile unsigned char SM2decoder_CMD[5]={0x80,0xb3,0x81,0xff,0x80};
volatile unsigned char SM2cert_CMD[5]={0x80,0xb7,0xff,0xff,0xff};
volatile unsigned char Random_CMD[5]={0x00,0x84,0x00,0x00,0xff};
const unsigned char Version_CMD[5]={0x00,0x5b,0x00,0x00,0x40};
const unsigned char Indentify_CMD[5]={0x80,0xb3,0x01,0x04,0x20};
int spi_transfer(int fd, unsigned char *txbuf, unsigned char *rxbuf, int bytes);
void spi_master_init(const char *name, int fd);
unsigned char get_crc7(const unsigned char *buff, int len);
void SendCmdHeader(int fd,u8 *cmd, u8 *rxbuf);
int delay(int x);
void RcvINS(int fd, u8 *txbuf, u8 *buf, u8 ins);
void RcvLEN(int fd, u8 *txbuf, u8 *buf, u8 len);
void RcvData(int fd, u8 *txbuf, u8 *buf);
void RcvData(int fd, u8 *txbuf, u8 *buf, int len);
void RcvSW(int fd, u8 *txbuf, u8 *buf, u8 sw);
void SendEnd(int fd, u8 *txbuf, u8 *buf);
void SendId(int fd, u8 *txbuf, u8 *buf, u8 id);
void SendData(int fd,u8 *data, u8 *rxbuf,int data_size);
};

@ -1,62 +0,0 @@
#include <termios.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <android/log.h>
#include <string>
#include "SpiPort.h"
SpiPort::SpiPort(const std::string& path) : m_path(path), m_fd(0)
{
}
SpiPort::~SpiPort()
{
if (m_fd > 0)
{
close(m_fd);
}
}
bool SpiPort::Open()
{
if(m_fd <= 0) m_fd = open(m_path.c_str(), O_RDWR/*|O_NDELAY|O_NOCTTY*/);
if(m_fd <= 0 ) {
int err = errno;
m_log = "open spi Error errno=" + std::to_string(err);
__android_log_print(ANDROID_LOG_INFO, "SPi", "open spi Error errno=%d", err);
return false;
}
else __android_log_print(ANDROID_LOG_INFO, "SPi", "open spi Success m_fd=%d",m_fd);
return true;
}
// write
int SpiPort::Write(unsigned char *buf, int len)
{
return write(m_fd, buf, len);
}
// read
int SpiPort::Read(unsigned char *buf, int len)
{
return read(m_fd, buf, len);
}
//close
bool SpiPort::Close()
{
if(m_fd > 0)
{
close(m_fd);
m_fd = 0;
}
return true;
}

@ -1,30 +0,0 @@
#ifndef _SPIPORT_H_
#define _SPIPORT_H_
#include <string>
class SpiPort
{
public:
SpiPort(const std::string& path);
~SpiPort();
bool Open();
int Write(unsigned char *buf, int len);
int Read(unsigned char *buf, int len);
bool Close();
std::string GetLog() const
{
return m_log;
}
protected:
std::string m_path;
std::string m_log;
int m_fd;
};
#endif

@ -1,8 +1,8 @@
#include <jni.h>
#include <string>
#include "SpiPort.h"
#include "SpiLib.h"
#include "NrsecPort.h"
#include "GPIOControl.h"
#include <fcntl.h>
#include <unistd.h>
@ -11,52 +11,6 @@
#include <android/log.h>
class NrsecSpiPort : public SpiPort {
public:
NrsecSpiPort(const std::string& path) : SpiPort(path) {
}
bool Open()
{
if (!SpiPort::Open())
{
return false;
}
uint8_t mode = SPI_MODE_3;
uint8_t bits = 8;
uint32_t speed = 33000000;
uint8_t lsb = 1;
// const char *device = "/dev/spidev32766.1";
if (ioctl(m_fd, SPI_IOC_WR_MODE, &mode) == -1 ||
ioctl(m_fd, SPI_IOC_WR_BITS_PER_WORD, &bits) == -1 ||
ioctl(m_fd, SPI_IOC_WR_MAX_SPEED_HZ, &speed) == -1 ||
ioctl(m_fd, SPI_IOC_WR_LSB_FIRST, &lsb) == -1)
{
Close();
return false;
}
return true;
}
bool GenKeyPair(int keyIdx) {
unsigned char header[] = {0x80, 0xb2, 0x00, (unsigned char)keyIdx, 0x00 };
int bytesWriten = Write(header, sizeof(header));
unsigned char buffer[2] = { 0 };
int bytesRead = Read(buffer, sizeof(buffer));
if (bytesRead > 0) {
int aa = 0;
} else {
int bb = 0;
}
return true;
}
};
extern "C" JNIEXPORT jstring JNICALL
Java_com_xinyingpower_testcomm_MainActivity_stringFromJNI(
JNIEnv* env,
@ -70,7 +24,13 @@ Java_com_xinyingpower_testcomm_MainActivity_testSpi(
JNIEnv* env,
jobject /* this */, jint port) {
//testSpi();
SpiLIb a;
GpioControl::setInt(23, 1);
const char* path = "/dev/spidevSE"; // DOWSE
NrsecPort a;
a.Open(path);
unsigned char newkey[32]={0xaf,0x0c,0xa9,0x40,0x1f,0xe6,0xee,0x0f,0x4c,
0xfb,0xf7,0x17,0x71,0xde,0x61,0x59
,0x0a,0x05,0x77,
@ -85,12 +45,14 @@ Java_com_xinyingpower_testcomm_MainActivity_testSpi(
unsigned char pucid[16]={0x01,0x01,0x01,0x01,0x01,0x01,0x01,
0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01};
string b="C=CN,ST=jiangsu,L=nanjing,O=GDD,OU=nari,CN=test001";
//a.SM2keypair(0x00);
a.Version();
a.SM2keypair(0x00);
//a.SM3Hash(newkey,16, outpub);
//a.sm3hash_tosm2(newkey,16,outpub,newkey,pucid,16);
//a.SM2Sign(0x00,outpub,outsign);
//a.SM2VerifySign(0x00,outpub,outsign);
a.SM2cert(0x00,0x00,b,outen);
// a.SM2cert(0x00,0x00,b,outen);
for (int i = 0; i < 32; i++) {
//sprintf(output, " %02x ", rxbuf[i]);
__android_log_print(ANDROID_LOG_INFO, "SPi", "%02x", outen[i]);
@ -107,41 +69,4 @@ Java_com_xinyingpower_testcomm_MainActivity_testSpi(
return env->NewStringUTF("End");
// NrsecSpiPort spi("/dev/mtkgpioctrl");
NrsecSpiPort spi("/dev/spidevSE");
// NrsecSpiPort spi("/dev/spidev0.0");
if (!spi.Open()) {
return env->NewStringUTF(spi.GetLog().c_str());
}
spi.GenKeyPair(0);
unsigned char header[] = { 0x00, 0x5b, 0x00, 0x00, 0x40 };
int bytesWriten = spi.Write(header, sizeof(header));
unsigned char buffer[1024] = { 0 };
int bytesRead = spi.Read(buffer, 1);
if (bytesRead > 0) {
int aa = 0;
} else {
int bb = 0;
}
int len = buffer[0];
bytesRead += spi.Read(&buffer[1], len);
spi.Close();
std::string result;
char buf[32] = { 0 };
for (int idx = 0; idx < 32; idx++)
{
sprintf(buf, "%X ", buffer[idx]);
result += buf;
}
return env->NewStringUTF(result.c_str());
}

@ -2,11 +2,20 @@ package com.xinyingpower.testcomm;
import androidx.appcompat.app.AppCompatActivity;
import android.content.Context;
import android.graphics.ImageFormat;
import android.hardware.camera2.CameraCharacteristics;
import android.hardware.camera2.CameraManager;
import android.hardware.camera2.CameraMetadata;
import android.hardware.camera2.params.StreamConfigurationMap;
import android.os.Bundle;
import android.os.Handler;
import android.util.Log;
import android.util.Size;
import android.view.View;
import android.widget.TextView;
import com.dev.devapi.api.SysApi;
import com.xinyingpower.testcomm.databinding.ActivityMainBinding;
public class MainActivity extends AppCompatActivity {
@ -32,6 +41,9 @@ public class MainActivity extends AppCompatActivity {
binding.btnSpi.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
// PrintCameraInfo();
// SysApi.set12VEnable(true);
String str = testSpi(0);
binding.sampleText.setText(str);
}
@ -48,6 +60,75 @@ public class MainActivity extends AppCompatActivity {
}
private void PrintCameraInfo() {
CameraManager cameraManager = (CameraManager) getSystemService(Context.CAMERA_SERVICE);
CameraCharacteristics cameraCharacteristics = null;
StringBuilder builder = new StringBuilder();
try {
cameraCharacteristics = cameraManager.getCameraCharacteristics("0");
} catch (Exception ex) {
ex.printStackTrace();
}
if (cameraCharacteristics != null) {
int[] capabilities = cameraCharacteristics.get(CameraCharacteristics.CONTROL_AF_AVAILABLE_MODES);
if (capabilities != null) {
for (int c : capabilities) {
builder.append("CONTROL_AF_AVAILABLE_MODES: (" + Integer.toString(c) + ")");
if (c == CameraMetadata.CONTROL_AF_MODE_OFF) {
builder.append(" CONTROL_AF_MODE_OFF");
} else if (c == CameraMetadata.CONTROL_AF_MODE_AUTO) {
builder.append(" CONTROL_AF_MODE_AUTO");
} else if (c == CameraMetadata.CONTROL_AF_MODE_MACRO) {
builder.append(" CONTROL_AF_MODE_MACRO");
} else if (c == CameraMetadata.CONTROL_AF_MODE_CONTINUOUS_VIDEO) {
builder.append(" CONTROL_AF_MODE_CONTINUOUS_VIDEO");
} else if (c == CameraMetadata.CONTROL_AF_MODE_CONTINUOUS_PICTURE) {
builder.append(" CONTROL_AF_MODE_CONTINUOUS_PICTURE");
} else if (c == CameraMetadata.CONTROL_AF_MODE_EDOF) {
builder.append(" CONTROL_AF_MODE_EDOF");
}
builder.append("\n");
}
}
float[] apertures = cameraCharacteristics.get(CameraCharacteristics.LENS_INFO_AVAILABLE_APERTURES);
if (apertures != null) {
if (apertures != null) {
for (float f : apertures) {
builder.append("LENS_INFO_AVAILABLE_APERTURES: " + Float.toString(f) + "\n");
}
}
}
Integer maxAf = cameraCharacteristics.get(CameraCharacteristics.CONTROL_MAX_REGIONS_AF);
builder.append("CONTROL_MAX_REGIONS_AF: " + Integer.toString(maxAf) + "\n");
float[] lengths = cameraCharacteristics.get(CameraCharacteristics.LENS_INFO_AVAILABLE_FOCAL_LENGTHS);
if (lengths != null) {
for (float f : lengths) {
builder.append("LENS_INFO_AVAILABLE_FOCAL_LENGTHS: " + Float.toString(f) + "\n");
}
}
Float dis = cameraCharacteristics.get(CameraCharacteristics.LENS_INFO_MINIMUM_FOCUS_DISTANCE);
builder.append("LENS_INFO_MINIMUM_FOCUS_DISTANCE: " + ((dis == null) ? "null" : dis.toString()) + "\n");
StreamConfigurationMap map = cameraCharacteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
Size[] sizes = map.getOutputSizes(ImageFormat.RAW_SENSOR);
for (int i = 0; i < sizes.length; i++) { //遍历所有Size
Size itemSize = sizes[i];
// Log.e(TAG, "当前itemSize 宽=" + itemSize.getWidth() + "高=" + itemSize.getHeight());
builder.append("Available Size: (" + itemSize.getWidth() + "," + itemSize.getHeight() + ")\n");
}
Log.i("CAM", builder.toString());
builder.append("");
}
}
/**
* A native method that is implemented by the 'testcomm' native library,

Loading…
Cancel
Save