Red de conocimiento informático - Material del sitio web - Cómo usar hackrf en un teléfono Android

Cómo usar hackrf en un teléfono Android

libusb1.0.mk

libusb1.0.mk

libusb1.0.mk se puede conectar al proyecto a través de libhackrf.mk.

2) Inicialice hackrf y registre la función de recepción.

Interfaz JNI

[cpp] Ver texto sin formato

JNIEXPORT jstring JNICALL Java_com_pagekpang_hackrftouch_HackRFTouch_test(

JNIEnv * env, jclass cls) {

int resultado = HACKRF_SUCCESS;

resultado = hackrf_init();

if (resultado == HACKRF_SUCCESS) {

return env-> .NewStringUTF("OK!");

} else {

return env->NewStringUTF("¡Error!");

}

JNIEXPORT jstring JNICALL Java_ com_pagekpang_hackrftouch_HackRFTouch_init(

JNIEnv *env, jobject thiz) {

int resultado = HACKRF_SUCCESS

uint8_t board_id = BOARD_ID_INVALID;

char pbuf[2048] = { 0 };

resultado = hackrf_init();

if (resultado!= HACKRF_SUCCESS) {

sprintf(pbuf, "hackrf_init() falló: %s (%d)\n",

hackrf_error_name((hackrf_error) resultado), resultado

);

return env->NewStringUTF(pbuf);

}

resultado = hackrf_open(&device);

if (resultado! = HACKRF_SUCCESS) {

sprintf(pbuf, "hackrf_open() falló: %s (%d)\n",

hackrf_error_name((hackrf_error) resultado),

return env->NewStringUTF(pbuf);

}

resultado = hackrf_board_id_read(dispositivo, &board_id); = HACKRF_SUCCESS) {

sprintf(pbuf, "hackrf_board_id_read() falló: %s (%d)\n",

hackrf_error_name((hackrf_error) resultado), resultado ); /p>

return env->NewStringUTF(pbuf);

}

sprintf(pbuf, "Número de identificación de la placa: %d (%s)\n", board_id ,

hackrf_board_id_ nombre((hackrf_board_id) boa

rd_id);

return env->NewStringUTF(pbuf);

}

JNIEXPORT jstring JNICALL Java_com_pagekpang_ hackrftouch_HackRFTouch_setSampleRateManual(

JNIEnv *env , jobject thiz, jlong ​​​​freq, jint divi) {

int resultado = HACKRF_SUCCESS

char pbuf[2048] = { 0 }; = hackrf_set_sample_rate_manual (dispositivo, frecuencia, divi);

if (resultado!= HACKRF_SUCCESS) {

sprintf(pbuf, "hackrf_set_sample_rate_manual() falló: %s (%d)\n ",

hackrf_error_name((hackrf_error) resultado), resultado);

return env->NewStringUTF(pbuf);

}

Return env->NewStringUTF("ok");

}

JNIEXPORT jstring JNICALL Java_com_pagekpang_hackrftouch_HackRFTouch_setVgaGain(

JNIEnv *env, jobject thiz, jint vga) {

p>

int resultado = HACKRF _SUCCESS;

char pbuf[2048] = { 0 };

resultado = hackrf_set_vga_gain(dispositivo, vga); p>

if (resultado != HACKRF_SUCCESS) {

sprintf(pbuf, "hackrf_set_vga_gain() falló: %s (%d)\n",

hackrf_error_name(( hackrf_error) resultado), resultado);

return env->NewStringUTF(pbuf);

}

Return env->NewStringUTF("ok");

}

JNIEXPORT jstring JNICALL Java_com_pagekpang_hackrftouch_HackRFTouch_setLnaGain(

JNIEnv *env, jobject thiz, jint lna) {

int resultado = HACKRF_SUCCESS;

char pbuf[2048] = { 0 };

resultado = hackrf_set_lna_gain(dispositivo, lna);

if (resultado! = HACKRF_SUCCESS) {

sprintf(pbuf, "hackrf_set_lna_gain() falló: %s (%d

)\n",

hackrf_error_name((hackrf_error) resultado), resultado);

return env->NewStringUTF(pbuf);

}

Return env->NewStringUTF("ok");

}

JNIEXPORT jstring JNICALL Java_com_pagekpang_hackrftouch_HackRFTouch_setFreq(

JNIEnv *env, jobject thiz, jlong frecuencia) {

int resultado = HACKRF_SUCCESS;

char pbuf[2048] = { 0 };

resultado = hackrf_set_freq(dispositivo, frecuencia

p>

if (resultado != HACKRF_SUCCESS) {

sprintf(pbuf, "hackrf_set_freq() falló: %s (%d)\n",

hackrf_error_name(( hackrf_error) resultado), resultado);

return env->NewStringUTF(pbuf);

}

Return env->NewStringUTF( "ok");

}

JNIEXPORT jstring JNICALL Java_ com_pagekpang_hackrftouch_HackRFTouch_setAmpEnable(

JNIEnv *env, jobject thiz, jint b) {

int resultado = HACKRF_SUCCESS ;

char pbuf[2048] = { 0 };

resultado = hackrf_set_amp_enable(dispositivo, b == 0 ?falso : verdadero

);

if ( resultado ! = HACKRF_SUCCESS) {

sprintf(pbuf, "hackrf_set_amp_enable() falló: %s (%d)\n",

hackrf_error_name((hackrf_error) resultado), resultado) ;

return env->NewStringUTF(pbuf);

}

Return env->NewStringUTF("ok"); p>

}

JNIEXPORT jstring JNICALL Java_com_pagekpang_hackrftouch_HackRFTouch_startRX(

JNIEnv *env, jobject thiz) {

int resultado = HACKRF_SUCCESS

<; p> char pbuf[ 2048] = { 0 };

resultado = hackrf_start_rx(dispositivo, hackrf_rx_cb, env->NewGlobalRef(thiz));

if (resultado! = HACKRF_SUCCESS) {

sprintf(pbuf, "hackrf_start_rx() falló: %s (%d)\n",

hackrf_error_name((hackrf_error) resultado), resultado);

return env->NewStringUTF(pbuf);

}

Return env->NewStringUTF("ok"); p>}

JNIEXPORT jstring JNICALL Java_ com_pagekpang_hackrftouch_HackRFTouch_stopRX(

JNIEnv *env, jobject thiz) {

int resultado = HACKRF_SUCCESS

char pbuf[2048] = { 0 };

resultado = hackrf_stop_rx(dispositivo);

if (resultado!= HACKRF_SUCCESS) {

sprintf(pbuf, "hackrf_stop_rx() falló: %s (%d)\n",

hackrf_error_name((hackrf_error) resultado), resultado

return env->NewStringUTF(pbuf);

}

return env->NewStringUTF("ok");

}

Vincula la capa java a la interfaz JNI

[java] Ver copia pura

paquete com.pagekpang.hackrftouch

clase pública HackRFTouch {

estática {

System.loadLibrary("usb");

System.loadLibrary("usb");

System.loadLibrary("usb")

System.loadLibrary("usb1.0"); <

System.loadLibrary("hackrf");

System.loadLibrary("HackrfTouch"); > }

prueba de cadena nativa estática pública ();

init de cadena nativa privada ();

cadena nativa privada setSampleRateManual (frecuencia larga, int divi);

cadena nativa privada setVgaGain(int g);

cadena nativa privada setLnaGain(int g);

cadena nativa privada setFreq(frecuencia larga); p>

p>

cadena nativa privada setAmpEnable (int f);

cadena nativa pública

g startRX();

cadena nativa pública stopRX();

flotante nativa pública[] readRx()

cadena privada retString = ""; /p>

private Boolean isOpen = false

private ReadRxThread mReadRxThread = null

public HackRFTouch() {

// TODO constructor generado automáticamente Código auxiliar de función

retString = init();

if (!retString.contains("failed")) {

isOpen = true;

mReadRxThread = nuevo ReadRxThread(este);

}

}

}

}

class ReadRxThread extends Thread {

HackRFTouch mThisHisHackRFTouch = null

public ReadRxThread(HackRFTouch t) {

// TODO genera automáticamente un código auxiliar de constructor

mThisHisHackRFTouch = t;

}

@ Anular (sobrecarga).

@ Override

public void run() {

// TODO genera automáticamente códigos auxiliares de método

super.run(); /p>

while(true){

mThisHackRFTouch.readRx());

prueba {

Thread.sleep(100); p>

Thread.sleep(100);

p>

} catch (InterruptedException e) {

// TODO Bloque de captura generado automáticamente

e.printStackTrace();

} // TODO Bloque de captura generado automáticamente.

}

}

}

}

público booleano isOpen() {

return isOpen

}

valor booleano público isOpen; () {

Retorno isOpen

}

}

public String getLastError() {

retorno; retString;

}

}

público booleano HsetSampleRateManual(frecuencia larga, int divi) {

if (!isOpen) {

devuelve falso;

}

p>

}

retString = setSampleRateManual(freq, divi

);

if (retString.contains("failed")) {

devuelve falso

} else {

Devuelve verdadero; p> }

}

público booleano HsetLnaGain(int g ) {

if (!isOpen) {

return false

}

retString = setLnaGain(g);

if (retString.contains("failed")) {

return false;

} else {

devuelve verdadero

}

}

público booleano HsetVgaGain(int g) {

if (!isOpen) {

return false

}

retString = setVgaGain(g);

if (retString.contains("failed")) {

devuelve falso

} else {

Devuelve verdadero

}

}

public Boolean HsetFreq(long freq ) {

if (!isOpen) {

return false

}

r

etString = setFreq(freq);

if (retString. contains("failed")) {

return false

} else {

Devuelve verdadero;

}

}

público booleano HstopRX() {

if (! isOpen) {

p>

return false

}

retString = stopRX();

if (retString.contains("falló" )) {

p>

Devuelve falso

} else {

Devuelve verdadero;

}

3) Operación FFT

[cpp] Ver copia pura

if (dispositivo! = NULL) {

float raw[1024];

int dalen = transferir->valid_length

float realF, imagF, maxF

uint8_t *pbuf = transferir-& gt; ;búfer;

while (dalen > 0 && runcount == 0) {

complejo* fdata = nuevo complejo<double> [1024]; p> complejo* fout = nuevo complejo [1024];

for (int i = 0; i < 2048; i += 2) {

fdata [i / 2] = complejo

p>

//dft(fdata, 10, 0

//fout = fdata; > maxF = 0.0;

for (int i = 0; i < 1024; i++) {

raw[i] = pow(pow(fout[i].real() , 2) + pow(fout[i].imag(), 2),

0.5

if (maxF < raw[i]) {

maxF = raw[i];

p>

}

}

para (int i = 0; i < 1024; i++ ) {

raw[i] = raw[i ] / maxF

}

}

sendBuf(raw); /p>

//send(g_client, (char *)&raw , 4*1024, 0); // envía datos

dalen -=

pbuf + = 2048;

ru

ncount = 2;

}

runcount --;

//printf("E"); /p>

printf("O");

}