int main(int argc, char* argv[])
{
print_title("BBN APS2 Enumerate Utility");
set_logging_level(logDEBUG1);
//First get the number of devices we can see
unsigned numDevices = 0;
get_numDevices(&numDevices);
cout << concol::CYAN << numDevices << " APS device" << (numDevices > 1 ? "s": "") << " found" << concol::RESET << endl;
cout << endl;
//If we don't see anything bail
if (numDevices < 1) return 0;
//Get IP strings and firmware versions
const char ** serialBuffer = new const char*[numDevices];
get_device_IPs(serialBuffer);
for (unsigned ct=0; ct < numDevices; ct++) {
APS2_STATUS status;
status = connect_APS(serialBuffer[ct]);
if (status != APS2_OK) {
cout << concol::RED << "Failed to connect to " << serialBuffer[ct] << concol::RESET << endl;
continue;
}
char version_string[64];
get_firmware_version(serialBuffer[ct], nullptr, nullptr, nullptr, version_string);
double uptime{0};
get_uptime(serialBuffer[ct], &uptime);
std::chrono::duration<float> uptime_seconds(uptime);
auto uptime_days = std::chrono::duration_cast<std::chrono::duration<int, std::ratio<24*3600>>>(uptime_seconds);
std::ostringstream uptime_pretty;
if (uptime_days.count()) {
uptime_pretty << uptime_days.count() << " day" << (uptime_days.count() > 1 ? "s " : " ");
}
uptime_seconds -= uptime_days;
auto uptime_hours = std::chrono::duration_cast<std::chrono::hours>(uptime_seconds);
uptime_pretty << std::setfill('0') << std::setw(2) << uptime_hours.count() << ":";
uptime_seconds -= uptime_hours;
auto uptime_minutes = std::chrono::duration_cast<std::chrono::minutes>(uptime_seconds);
uptime_pretty << std::setfill('0') << std::setw(2) << uptime_minutes.count() << ":";
uptime_seconds -= uptime_minutes;
uptime_pretty << std::fixed << std::setprecision(3) << uptime_seconds.count();
cout << concol::CYAN << "Device " << ct << " at IPv4 address " << serialBuffer[ct] <<
" running firmware version " << version_string <<
" has been up " << uptime_pretty.str() << concol::RESET << endl;
disconnect_APS(serialBuffer[ct]);
}
cout << endl;
return 0;
}
void read_write_register(void)
{
unsigned char i;
if(ControlData.DeviceRequest.bmRequestType & (unsigned char)USB_ENDPOINT_DIRECTION_MASK)
{
if(bD13flags.bits.verbose)
{
printf("Read Registers: Offset = 0x%x, Length = 0x%x, Index = 0x%x.\n",
ControlData.DeviceRequest.wValue,
ControlData.DeviceRequest.wLength,
ControlData.DeviceRequest.wIndex);
}
if(ControlData.DeviceRequest.wIndex == GET_FIRMWARE_VERSION &&
ControlData.DeviceRequest.wValue == 0 &&
ControlData.DeviceRequest.wLength == 1)
{
get_firmware_version();
}
else
{
Chap9_StallEP0();
printf("stall: get firmware version\n");
}
}
else
{
if(bD13flags.bits.verbose)
{
printf("Write Registers: Offset = 0x%x, Length = 0x%x, Index = 0x%x.\n",
ControlData.DeviceRequest.wValue,
ControlData.DeviceRequest.wLength,
ControlData.DeviceRequest.wIndex);
printf("Data: ");
for(i = 0; i < ControlData.DeviceRequest.wLength; i ++)
printf("0x%x, ", *((ControlData.dataBuffer)+i));
printf("\n");
}
if(ControlData.DeviceRequest.wIndex == SETUP_DMA_REQUEST &&
ControlData.DeviceRequest.wValue == 0 &&
ControlData.DeviceRequest.wLength == 6)
{
RaiseIRQL();
setup_dma_request();
LowerIRQL();
}
}
}
int
BlinkM::probe()
{
uint8_t version[2];
int ret;
ret = get_firmware_version(version);
if (ret == OK)
log("found BlinkM firmware version %c%c", version[1], version[0]);
return ret;
}
void loop_clone_rfid(uint8_t *menu, uint8_t *opmode)
{
uint8_t data[80];
uint8_t keyindex = 0;
uint8_t block = 0;
uint8_t tries = 0;
int res, oid;
get_firmware_version();
while (block < BLOCKS) {
if ( READ != *menu) { break; }
res = mifare_reader_init(data, sizeof(data));
if (tries >= KEYS) {
tries = 0;
block += 1;
}
if (res >= 0) {
res = initiator_init(data, sizeof(data));
if (res >= 11) {
if (0x00 == data[3] && data[6] >= 0x04) {
memcpy(&oid, &data[7], sizeof(oid));
if (0x00 == block) {
debug_printf("MIFARE_CARD_ID:");
rfid_hexdump(&oid, sizeof(oid));
}
set_uid(data, oid);
set_key(data, keyindex);
res = mifare_authenticate_block(data, sizeof(data), block);
/*
debug_printf("res:");
rfid_hexdump(&res, sizeof(res));
debug_printf("data:");
rfid_hexdump(&data[0], sizeof(data));
*/
if (0x41 == data[0] && 0x00 == data[1]) {
debug_printf("Auth Succeeded.\n");
tries = 0;
switch (*opmode) {
case READ:
res = mifare_read_block(data, sizeof(data), block);
if (res == 18) {
debug_printf("Block:");
rfid_hexdump(&block, sizeof(block));
debug_printf("Data:");
rfid_hexdump(&data[2], BLOCK_SIZE);
debug_printf("Key:");
rfid_hexdump(&default_keys[keyindex], MIFARE_KEY_SIZE);
memcpy(&mifare_card[block*BLOCK_SIZE], &data[2], BLOCK_SIZE);
if (0x00 == (block+1) % 4) {
memcpy(&mifare_card[block*BLOCK_SIZE], &default_keys[keyindex], MIFARE_KEY_SIZE);
memcpy(&mifare_card[block*BLOCK_SIZE+6], &access_bytes[0], ACCESS_BYTES);
memcpy(&mifare_card[block*BLOCK_SIZE+10], &key_b[0], MIFARE_KEY_SIZE);
}
}
break;
case WRITE:
memcpy(&data[4], &mifare_card[block*BLOCK_SIZE], BLOCK_SIZE);
res = mifare_write_block(data, sizeof(data), block);
debug_printf("res:");
rfid_hexdump(&res, sizeof(res));
break;
}
block += 1;
} else if (0x41 == data[0] && 0x14 == data[1]) {
debug_printf("Auth Failed.\n");
keyindex = (keyindex + 1) % KEYS;
tries += 1;
}
}
}
} else {
turn_rf_off(data, sizeof(data));
}
}
*menu = LIBNFC;
}
int frizz_ioctl_sensor(struct file_id_node *node, unsigned int cmd, unsigned long arg) {
int sensor_id;
int status = 0;
packet_t packet;
int period_ms;
sensor_enable_t sensor_enable = { 0 };
sensor_delay_t sensor_delay = { 0 };
pedometer_counter_t pedo_counter = { 0 };
batch_t batch = { 0 };
packet.header.prefix = 0xFF;
packet.header.type = 0x81;
packet.header.sen_id = HUB_MGR_ID;
switch (cmd) {
case FRIZZ_IOCTL_SENSOR_SET_ENABLE:
status = copy_from_user_sensor_enable_t(cmd, (void*) arg,
&sensor_enable);
sensor_id = convert_code_to_id(sensor_enable.code);
packet.header.num = 1;
switch (sensor_enable.flag) {
case 0:
packet.data[0] = HUB_MGR_GEN_CMD_CODE(HUB_MGR_CMD_DEACTIVATE_SENSOR,
sensor_id, 0x00, 0x00);
break;
case 1:
packet.data[0] = set_sensor_active(sensor_id);
break;
}
DEBUG_PRINT("SENSOR_SET_ENABLE %x %d \n", packet.data[0], sensor_id);
status = create_frizz_workqueue((void*) &packet);
//if is the pedometer sensor shutdown, clean the data in the firmware
if((sensor_enable.code == SENSOR_TYPE_STEP_COUNTER) && (sensor_enable.flag == 0)) {
pedo_onoff = 0;
} else if((sensor_enable.code == SENSOR_TYPE_STEP_COUNTER) && (sensor_enable.flag == 1)){
pedo_onoff = 1;
}
if(sensor_enable.code == SENSOR_TYPE_GESTURE) {
if(sensor_enable.flag == 1) {
gesture_on = 1;
}else if(sensor_enable.flag == 0) {
gesture_on = 0;
}
}
//if close the gsensor, set the Gsensor_min_delay to default
if(sensor_enable.code == SENSOR_TYPE_ACCELEROMETER && sensor_enable.flag == 0) {
Gsensor_min_delay = 10000;
}
if(sensor_enable.code == SENSOR_TYPE_ACCEL_FALL_DOWN || sensor_enable.code == SENSOR_TYPE_ACCEL_POS_DET) {
set_fall_parameter();
}
break;
case FRIZZ_IOCTL_SENSOR_SET_DELAY:
copy_from_user_sensor_delay_t(cmd, (void*) arg, &sensor_delay);
sensor_id = convert_code_to_id(sensor_delay.code);
packet.header.num = 2;
packet.data[0] = HUB_MGR_GEN_CMD_CODE(HUB_MGR_CMD_SET_SENSOR_INTERVAL,
sensor_id, 0x00, 0x00);
packet.data[1] = sensor_delay.ms;
if(sensor_delay.code == SENSOR_TYPE_ACCELEROMETER) {
if(sensor_delay.ms < Gsensor_min_delay) {
packet.data[1] = sensor_delay.ms;
Gsensor_min_delay = sensor_delay.ms;
} else {
break;
}
}
DEBUG_PRINT("SENSOR_SET_DELAY %d %x\n", sensor_id, packet.data[0]);
status = create_frizz_workqueue((void*) &packet);
break;
case FRIZZ_IOCTL_SENSOR_GET_ENABLE:
get_sensor_enable(cmd, (void*) arg);
break;
case FRIZZ_IOCTL_SENSOR_GET_DELAY:
get_sensor_delay(cmd, (void*) arg);
break;
case FRIZZ_IOCTL_SENSOR_GET_DATA:
get_sensor_data(node, cmd, (void*) arg);
break;
case FRIZZ_IOCTL_SENSOR_SIMULATE_TIMEOUT:
simulate_timeout(cmd, (void*) arg);
break;
case FRIZZ_IOCTL_SENSOR_SET_BATCH:
copy_from_user_batch_t(cmd, (void*) arg, &batch);
sensor_id = convert_code_to_id(batch.code);
DEBUG_PRINT("FIFO_FULL_FLAG %d %d \n", batch.fifo_full_flag,
batch.code);
if (batch.fifo_full_flag == 1) {
update_fifo_full_flag(batch.fifo_full_flag);
}
update_timeout(batch.timeout_ns);
if (batch.period_ns < 1000000) {
period_ms = 1;
DEBUG_PRINT("1ms\n");
} else {
period_ms = div64_u64(batch.period_ns, 1000000);
DEBUG_PRINT("period ms %d\n", period_ms);
}
DEBUG_PRINT("batch sensor id %d %d \n", sensor_id, period_ms);
packet.header.num = 2;
packet.data[0] = HUB_MGR_GEN_CMD_CODE(HUB_MGR_CMD_SET_SENSOR_INTERVAL,
sensor_id, 0x00, 0x00);
packet.data[1] = period_ms;
status = create_frizz_workqueue((void*) &packet);
packet.header.num = 1;
if (batch.timeout_ns == 0) {
packet.data[0] = HUB_MGR_GEN_CMD_CODE(HUB_MGR_CMD_DEACTIVATE_SENSOR,
sensor_id, 0x00, 0x00);
} else {
DEBUG_PRINT("enable batch\n");
packet.data[0] = HUB_MGR_GEN_CMD_CODE(
HUB_MGR_CMD_SET_SENSOR_ACTIVATE, sensor_id, 0x01, 0x00);
}
status = create_frizz_workqueue((void*) &packet);
break;
case FRIZZ_IOCTL_SENSOR_FLUSH_FIFO:
DEBUG_PRINT("FLUSH\n");
break;
case FRIZZ_IOCTL_GET_SENSOR_DATA_CHANGED:
DEBUG_PRINT("GET data changed flag\n");
get_sensor_data_changed(node, cmd, (void*) arg);
break;
case FRIZZ_IOCTL_GET_FIRMWARE_VERSION:
DEBUG_PRINT("GET firmware_version");
get_firmware_version(cmd, (void*) arg);
break;
case FRIZZ_IOCTL_SET_PEDO_COUNTER:
copy_from_user_pedometer_counter_t(cmd, (void*)arg, &pedo_counter);
if(pedo_counter.counter < 0) {
kprint("Frizz pedo_counter EVALUE (%d)!!, ignore.",pedo_counter.counter);
break;
}
set_pedo_interval(pedo_counter.counter);
break;
default:
kprint("%s :NONE IOCTL SENSORxxx %x", __func__, cmd);
return -1;
break;
}
return status;
}
