/* Copyright (C) 2021-2024 Daniel Dakhno
|
|
This file is part of Gadgetbridge.
|
|
Gadgetbridge is free software: you can redistribute it and/or modify
|
it under the terms of the GNU Affero General Public License as published
|
by the Free Software Foundation, either version 3 of the License, or
|
(at your option) any later version.
|
|
Gadgetbridge is distributed in the hope that it will be useful,
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
GNU Affero General Public License for more details.
|
|
You should have received a copy of the GNU Affero General Public License
|
along with this program. If not, see <https://www.gnu.org/licenses/>. */
|
package nodomain.freeyourgadget.gadgetbridge.service.devices.vesc;
|
|
import android.bluetooth.BluetoothGatt;
|
import android.bluetooth.BluetoothGattCharacteristic;
|
import android.bluetooth.BluetoothGattDescriptor;
|
import android.content.BroadcastReceiver;
|
import android.content.Context;
|
import android.content.Intent;
|
import android.content.IntentFilter;
|
import android.content.SharedPreferences;
|
|
import androidx.localbroadcastmanager.content.LocalBroadcastManager;
|
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
|
import java.nio.ByteBuffer;
|
import java.nio.ByteOrder;
|
import java.util.UUID;
|
|
import nodomain.freeyourgadget.gadgetbridge.GBApplication;
|
import nodomain.freeyourgadget.gadgetbridge.activities.devicesettings.DeviceSettingsPreferenceConst;
|
import nodomain.freeyourgadget.gadgetbridge.devices.vesc.VescCoordinator;
|
import nodomain.freeyourgadget.gadgetbridge.impl.GBDevice;
|
import nodomain.freeyourgadget.gadgetbridge.model.DeviceType;
|
import nodomain.freeyourgadget.gadgetbridge.service.btle.TransactionBuilder;
|
import nodomain.freeyourgadget.gadgetbridge.service.btle.actions.SetDeviceStateAction;
|
import nodomain.freeyourgadget.gadgetbridge.util.CheckSums;
|
|
public class VescDeviceSupport extends VescBaseDeviceSupport {
|
BluetoothGattCharacteristic serialWriteCharacteristic, serialReadCharacteristic;
|
|
public static final String COMMAND_SET_RPM = "nodomain.freeyourgadget.gadgetbridge.vesc.command.SET_RPM";
|
public static final String COMMAND_SET_CURRENT = "nodomain.freeyourgadget.gadgetbridge.vesc.command.SET_CURRENT";
|
public static final String COMMAND_SET_BREAK_CURRENT = "nodomain.freeyourgadget.gadgetbridge.vesc.command.SET_BREAK_CURRENT";
|
public static final String COMMAND_GET_VALUES = "nodomain.freeyourgadget.gadgetbridge.vesc.command.GET_VALUES";
|
public static final String EXTRA_RPM = "EXTRA_RPM";
|
public static final String EXTRA_CURRENT = "EXTRA_CURRENT";
|
public static final String EXTRA_VOLTAGE = "EXTRA_VOLTAGE";
|
|
public static final String ACTION_GOT_VALUES = "nodomain.freeyourgadget.gadgetbridge.vesc.action.GOT_VALUES";
|
|
private Logger logger = LoggerFactory.getLogger(getClass());
|
|
private DeviceType deviceType;
|
|
private ByteBuffer responseBuffer = ByteBuffer.allocate(100);
|
|
public VescDeviceSupport(DeviceType type) {
|
super();
|
responseBuffer.order(ByteOrder.BIG_ENDIAN);
|
|
deviceType = type;
|
addSupportedService(UUID.fromString(VescCoordinator.UUID_SERVICE_SERIAL_NRF));
|
addSupportedService(UUID.fromString(VescCoordinator.UUID_SERVICE_SERIAL_HM10));
|
}
|
|
@Override
|
public void onFetchRecordedData(int dataTypes) {
|
getValues();
|
}
|
|
@Override
|
protected TransactionBuilder initializeDevice(TransactionBuilder builder) {
|
logger.debug("initializing device");
|
|
builder.add(new SetDeviceStateAction(getDevice(), GBDevice.State.INITIALIZING, getContext()));
|
|
initBroadcast();
|
|
|
this.serialWriteCharacteristic = getCharacteristic(UUID.fromString(VescCoordinator.UUID_CHARACTERISTIC_SERIAL_TX_NRF));
|
this.serialReadCharacteristic = getCharacteristic(UUID.fromString(VescCoordinator.UUID_CHARACTERISTIC_SERIAL_RX_NRF));
|
if(this.serialWriteCharacteristic == null || this.serialReadCharacteristic == null){
|
this.serialWriteCharacteristic = getCharacteristic(UUID.fromString(VescCoordinator.UUID_CHARACTERISTIC_SERIAL_TX_HM10));
|
this.serialReadCharacteristic = getCharacteristic(UUID.fromString(VescCoordinator.UUID_CHARACTERISTIC_SERIAL_RX_HM10));
|
}
|
|
builder.notify(this.serialReadCharacteristic, true);
|
|
return builder.add(new SetDeviceStateAction(getDevice(), GBDevice.State.INITIALIZED, getContext()));
|
}
|
|
@Override
|
public boolean onDescriptorWrite(BluetoothGatt gatt, BluetoothGattDescriptor descriptor, int status) {
|
super.onDescriptorWrite(gatt, descriptor, status);
|
getValues();
|
|
return true;
|
}
|
|
@Override
|
public boolean onCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic) {
|
handleRxCharacteristic(characteristic);
|
|
return true;
|
}
|
|
private void handleRxCharacteristic(BluetoothGattCharacteristic characteristic) {
|
if (characteristic != serialReadCharacteristic) return;
|
|
responseBuffer.put(characteristic.getValue());
|
short length = 0;
|
int oldPosition = responseBuffer.position();
|
responseBuffer.position(0);
|
byte lengthType = responseBuffer.get();
|
if (lengthType == 2) {
|
length = responseBuffer.get();
|
} else if (lengthType == 3) {
|
length = responseBuffer.getShort();
|
} else {
|
return;
|
}
|
if (length == oldPosition - 5) {
|
// whole message transmitted
|
responseBuffer.position(oldPosition);
|
handleResponseBuffer(responseBuffer);
|
|
oldPosition = 0;
|
}
|
responseBuffer.position(oldPosition);
|
}
|
|
private void handleResponseBuffer(ByteBuffer responseBuffer) {
|
int bufferLength = responseBuffer.position();
|
int payloadStartPosition = responseBuffer.get(0);
|
|
byte[] payload = new byte[bufferLength - 3 - payloadStartPosition];
|
System.arraycopy(responseBuffer.array(), payloadStartPosition, payload, 0, payload.length);
|
|
int actualCrc = CheckSums.getCRC16(payload, 0);
|
int expectedCrc = responseBuffer.getShort(bufferLength - 3);
|
|
byte responseType = payload[0];
|
if (responseType == 0x04) {
|
handleResponseValues(responseBuffer);
|
}
|
}
|
|
private void handleResponseValues(ByteBuffer valueBuffer) {
|
valueBuffer.position(3);
|
float temp_mos = buffer_get_float16(valueBuffer, 1e1);
|
float temp_motor = buffer_get_float16(valueBuffer, 1e1);
|
float current_motor = buffer_get_float32(valueBuffer, 1e2);
|
float current_in = buffer_get_float32(valueBuffer, 1e2);
|
float id = buffer_get_float32(valueBuffer, 1e2);
|
float iq = buffer_get_float32(valueBuffer, 1e2);
|
float duty_now = buffer_get_float16(valueBuffer, 1e3);
|
float rpm = buffer_get_float32(valueBuffer, 1e0);
|
float v_in = buffer_get_float16(valueBuffer, 1e1);
|
float amp_hours = buffer_get_float32(valueBuffer, 1e4);
|
float amp_hours_charged = buffer_get_float32(valueBuffer, 1e4);
|
float watt_hours = buffer_get_float32(valueBuffer, 1e4);
|
float watt_hours_charged = buffer_get_float32(valueBuffer, 1e4);
|
float tachometer = buffer_get_int32(valueBuffer);
|
float tachometer_abs = buffer_get_int32(valueBuffer);
|
|
handleBatteryVoltage(v_in);
|
|
Intent intent = new Intent(ACTION_GOT_VALUES);
|
intent.putExtra(EXTRA_VOLTAGE, v_in);
|
}
|
|
|
|
void handleBatteryVoltage(float voltage){
|
SharedPreferences prefs = GBApplication.getDeviceSpecificSharedPrefs(getDevice().getAddress());
|
float minimalVoltage = Float.parseFloat(prefs.getString(DeviceSettingsPreferenceConst.PREF_VESC_MINIMUM_VOLTAGE, "-1"));
|
float maximalVoltage = Float.parseFloat(prefs.getString(DeviceSettingsPreferenceConst.PREF_VESC_MAXIMUM_VOLTAGE, "-1"));
|
|
if(minimalVoltage == -1){
|
return;
|
}
|
if(maximalVoltage == -1){
|
return;
|
}
|
|
float voltageAboveMinimum = voltage - minimalVoltage;
|
float voltageRange = maximalVoltage - minimalVoltage;
|
float fullness = voltageAboveMinimum / voltageRange;
|
|
int fullnessPercent = (int)(fullness * 100);
|
fullnessPercent = Math.max(fullnessPercent, 0);
|
fullnessPercent = Math.min(fullnessPercent, 100);
|
|
getDevice().setBatteryLevel(fullnessPercent);
|
getDevice().setBatteryVoltage(voltage);
|
getDevice().sendDeviceUpdateIntent(getContext());
|
}
|
|
float buffer_get_float16(ByteBuffer buffer, double scale){
|
return (float) (buffer.getShort() / scale);
|
}
|
|
float buffer_get_float32(ByteBuffer buffer, double scale){
|
return (float) (buffer.getInt() / scale);
|
}
|
|
int buffer_get_int32(ByteBuffer buffer){
|
return buffer.getInt();
|
}
|
|
@Override
|
public void onTestNewFunction() {
|
getValues();
|
// getDecodedADC();
|
}
|
|
private void getDecodedADC() {
|
buildAndQueryPacket(CommandType.COMM_GET_DECODED_ADC);
|
}
|
|
private void initBroadcast() {
|
LocalBroadcastManager broadcastManager = LocalBroadcastManager.getInstance(getContext());
|
|
IntentFilter filter = new IntentFilter();
|
filter.addAction(COMMAND_SET_RPM);
|
filter.addAction(COMMAND_SET_CURRENT);
|
filter.addAction(COMMAND_SET_BREAK_CURRENT);
|
filter.addAction(COMMAND_GET_VALUES);
|
|
broadcastManager.registerReceiver(commandReceiver, filter);
|
}
|
|
@Override
|
public void dispose() {
|
super.dispose();
|
LocalBroadcastManager.getInstance(getContext()).unregisterReceiver(commandReceiver);
|
}
|
|
BroadcastReceiver commandReceiver = new BroadcastReceiver() {
|
@Override
|
public void onReceive(Context context, Intent intent) {
|
if (intent.getAction().equals(COMMAND_SET_RPM)) {
|
VescDeviceSupport.this.setRPM(
|
intent.getIntExtra(EXTRA_RPM, 0)
|
);
|
} else if (intent.getAction().equals(COMMAND_SET_BREAK_CURRENT)) {
|
VescDeviceSupport.this.setBreakCurrent(
|
intent.getIntExtra(EXTRA_CURRENT, 0)
|
);
|
} else if (intent.getAction().equals(COMMAND_SET_CURRENT)) {
|
VescDeviceSupport.this.setCurrent(
|
intent.getIntExtra(EXTRA_CURRENT, 0)
|
);
|
} else if (intent.getAction().equals(COMMAND_GET_VALUES)) {
|
VescDeviceSupport.this.getValues();
|
}
|
}
|
};
|
|
public void setCurrent(int currentMillisAmperes) {
|
buildAndQueryPacket(CommandType.COMM_SET_CURRENT, currentMillisAmperes);
|
}
|
|
public void setBreakCurrent(int breakCurrentMillisAmperes) {
|
buildAndQueryPacket(CommandType.COMM_SET_CURRENT_BRAKE, breakCurrentMillisAmperes);
|
}
|
|
public void getValues() {
|
buildAndQueryPacket(CommandType.COMM_GET_VALUES);
|
}
|
|
public void setRPM(int rpm) {
|
buildAndQueryPacket(CommandType.COMM_SET_RPM, rpm);
|
}
|
|
public void buildAndQueryPacket(CommandType commandType, Object... args) {
|
byte[] data = buildPacket(commandType, args);
|
queryPacket(data);
|
}
|
|
public void queryPacket(byte[] data) {
|
new TransactionBuilder("write serial packet")
|
.write(this.serialWriteCharacteristic, data)
|
.queue(getQueue());
|
}
|
|
public byte[] buildPacket(CommandType commandType, Object... args) {
|
int dataLength = 0;
|
for (Object arg : args) {
|
if (arg instanceof Integer) dataLength += 4;
|
else if (arg instanceof Short) dataLength += 2;
|
}
|
ByteBuffer buffer = ByteBuffer.allocate(dataLength);
|
|
for (Object arg : args) {
|
if (arg instanceof Integer) buffer.putInt((Integer) arg);
|
if (arg instanceof Short) buffer.putShort((Short) arg);
|
}
|
|
return buildPacket(commandType, buffer.array());
|
}
|
|
public byte[] buildPacket(CommandType commandType, byte[] data) {
|
return buildPacket(commandType.getCommandByte(), data);
|
}
|
|
private byte[] buildPacket(byte commandByte, byte[] data) {
|
byte[] contents = new byte[data.length + 1];
|
contents[0] = commandByte;
|
System.arraycopy(data, 0, contents, 1, data.length);
|
return buildPacket(contents);
|
}
|
|
private byte[] buildPacket(byte[] contents) {
|
int dataLength = contents.length;
|
ByteBuffer buffer = ByteBuffer.allocate(dataLength + (dataLength < 256 ? 5 : 6));
|
if (dataLength < 256) {
|
buffer.put((byte) 0x02);
|
buffer.put((byte) dataLength);
|
} else {
|
buffer.put((byte) 0x03);
|
buffer.putShort((short) dataLength);
|
}
|
buffer.put(contents);
|
buffer.putShort((short) CheckSums.getCRC16(contents, 0));
|
buffer.put((byte) 0x03);
|
|
return buffer.array();
|
}
|
}
|
