static bool MessageDone() {
// TODO: check pin capabilities
switch (rx_msg.type) {
case HARD_RESET:
CHECK(rx_msg.args.hard_reset.magic == IOIO_MAGIC);
HardReset();
break;
case CHECK_INTERFACE:
CheckInterface(rx_msg.args.check_interface.interface_id);
break;
case READ_FINGERPRINT:
if (!ReadFingerprint()) {
log_printf("Failed to read fingerprint");
return false;
}
break;
case WRITE_FINGERPRINT:
if (!WriteFingerprint(rx_msg.args.write_fingerprint.fingerprint)) {
log_printf("Failed to write fingerprint");
return false;
}
break;
case WRITE_IMAGE:
rx_message_state = WAIT_FILE;
rx_message_remaining = rx_msg.args.write_image.size;
if (!EraseFingerprint()) {
log_printf("Failed to erase fingerprint");
return false;
}
file_checksum = 0;
log_printf("Starting to receive image file");
IOIOFileInit();
break;
// BOOKMARK(add_feature): Add incoming message handling to switch clause.
default:
log_printf("Unexpected message type: 0x%x", rx_msg.type);
return false;
}
return true;
}
static void
AndroidInterfaceAdded(void *refCon, io_iterator_t iterator)
{
kern_return_t kr;
io_service_t usbDevice;
io_service_t usbInterface;
IOCFPlugInInterface **plugInInterface = NULL;
IOUSBInterfaceInterface220 **iface = NULL;
IOUSBDeviceInterface197 **dev = NULL;
HRESULT result;
SInt32 score;
UInt32 locationId;
UInt16 vendor;
UInt16 product;
UInt8 serialIndex;
char serial[256];
char devpathBuf[64];
char *devpath = NULL;
while ((usbInterface = IOIteratorNext(iterator))) {
//* Create an intermediate interface plugin
kr = IOCreatePlugInInterfaceForService(usbInterface,
kIOUSBInterfaceUserClientTypeID,
kIOCFPlugInInterfaceID,
&plugInInterface, &score);
IOObjectRelease(usbInterface);
if ((kIOReturnSuccess != kr) || (!plugInInterface)) {
DBG("ERR: Unable to create an interface plug-in (%08x)\n", kr);
continue;
}
//* This gets us the interface object
result = (*plugInInterface)->QueryInterface(plugInInterface,
CFUUIDGetUUIDBytes(kIOUSBInterfaceInterfaceID), (LPVOID*)
&iface);
//* We only needed the plugin to get the interface, so discard it
(*plugInInterface)->Release(plugInInterface);
if (result || !iface) {
DBG("ERR: Couldn't query the interface (%08x)\n", (int) result);
continue;
}
//* this gets us an ioservice, with which we will find the actual
//* device; after getting a plugin, and querying the interface, of
//* course.
//* Gotta love OS X
kr = (*iface)->GetDevice(iface, &usbDevice);
if (kIOReturnSuccess != kr || !usbDevice) {
DBG("ERR: Couldn't grab device from interface (%08x)\n", kr);
continue;
}
plugInInterface = NULL;
score = 0;
//* create an intermediate device plugin
kr = IOCreatePlugInInterfaceForService(usbDevice,
kIOUSBDeviceUserClientTypeID,
kIOCFPlugInInterfaceID,
&plugInInterface, &score);
//* only needed this to find the plugin
(void)IOObjectRelease(usbDevice);
if ((kIOReturnSuccess != kr) || (!plugInInterface)) {
DBG("ERR: Unable to create a device plug-in (%08x)\n", kr);
continue;
}
result = (*plugInInterface)->QueryInterface(plugInInterface,
CFUUIDGetUUIDBytes(kIOUSBDeviceInterfaceID), (LPVOID*) &dev);
//* only needed this to query the plugin
(*plugInInterface)->Release(plugInInterface);
if (result || !dev) {
DBG("ERR: Couldn't create a device interface (%08x)\n",
(int) result);
continue;
}
//* Now after all that, we actually have a ref to the device and
//* the interface that matched our criteria
kr = (*dev)->GetDeviceVendor(dev, &vendor);
kr = (*dev)->GetDeviceProduct(dev, &product);
kr = (*dev)->GetLocationID(dev, &locationId);
if (kr == 0) {
snprintf(devpathBuf, sizeof(devpathBuf), "usb:%lX", locationId);
devpath = devpathBuf;
}
kr = (*dev)->USBGetSerialNumberStringIndex(dev, &serialIndex);
if (serialIndex > 0) {
IOUSBDevRequest req;
UInt16 buffer[256];
UInt16 languages[128];
memset(languages, 0, sizeof(languages));
req.bmRequestType =
USBmakebmRequestType(kUSBIn, kUSBStandard, kUSBDevice);
req.bRequest = kUSBRqGetDescriptor;
req.wValue = (kUSBStringDesc << 8) | 0;
req.wIndex = 0;
req.pData = languages;
req.wLength = sizeof(languages);
kr = (*dev)->DeviceRequest(dev, &req);
if (kr == kIOReturnSuccess && req.wLenDone > 0) {
int langCount = (req.wLenDone - 2) / 2, lang;
for (lang = 1; lang <= langCount; lang++) {
memset(buffer, 0, sizeof(buffer));
memset(&req, 0, sizeof(req));
req.bmRequestType =
USBmakebmRequestType(kUSBIn, kUSBStandard, kUSBDevice);
req.bRequest = kUSBRqGetDescriptor;
req.wValue = (kUSBStringDesc << 8) | serialIndex;
req.wIndex = languages[lang];
req.pData = buffer;
req.wLength = sizeof(buffer);
kr = (*dev)->DeviceRequest(dev, &req);
if (kr == kIOReturnSuccess && req.wLenDone > 0) {
int i, count;
// skip first word, and copy the rest to the serial string,
// changing shorts to bytes.
count = (req.wLenDone - 1) / 2;
for (i = 0; i < count; i++)
serial[i] = buffer[i + 1];
serial[i] = 0;
break;
}
}
}
}
(*dev)->Release(dev);
DBG("INFO: Found vid=%04x pid=%04x serial=%s\n", vendor, product,
serial);
usb_handle* handle = CheckInterface((IOUSBInterfaceInterface**)iface,
vendor, product);
if (handle == NULL) {
DBG("ERR: Could not find device interface: %08x\n", kr);
(*iface)->Release(iface);
continue;
}
DBG("AndroidDeviceAdded calling register_usb_transport\n");
register_usb_transport(handle, (serial[0] ? serial : NULL), devpath, 1);
// Register for an interest notification of this device being removed.
// Pass the reference to our private data as the refCon for the
// notification.
kr = IOServiceAddInterestNotification(notificationPort,
usbInterface,
kIOGeneralInterest,
AndroidInterfaceNotify,
handle,
&handle->usbNotification);
if (kIOReturnSuccess != kr) {
DBG("ERR: Unable to create interest notification (%08x)\n", kr);
}
}
}
void ActivateAP::run()
{
QSettings *GlobalSettings = new QSettings("/root/.WiFiHostapdAP/WiFi_Hostapd_AP.conf",QSettings::NativeFormat); // создание нового объекта
char tmp[400], command[150] = "ifconfig ", *temp;
bool starting = true;
int i = 0;
QString WhoIAm = tr("Activate system");
QDateTime TimeNow;
QString dateUNIXNow;
// Последовательность активации:
qDebug()<< "Start activation.\n";
////////////////////////////////////////////////////////////////////////////////////////////
// move 1: disable interface
QString temp_QT = GlobalSettings->value("AP/Iface", "wlan0").toString().toLocal8Bit();
//temp = temp_QT.toAscii().data();
temp = temp_QT.toUtf8().data();
strcat(command, temp);
strcat(command, " down");
console(command, tmp);
emit toLog(QString("%1|%2|%3|%4").arg(WhoIAm, dateUNIXNow, tr("Preparation of the device has successfully completed"), QString("1")));
dateUNIXNow.clear(); dateUNIXNow = QString::number(TimeNow.currentDateTime().toTime_t());
emit send_step(tr("Preparation of the device has successfully completed"));
emit setPercent(10);
qDebug()<< "Preparation device" << " ... " << "OK";
////////////////////////////////////////////////////////////////////////////////////////////
sleep(0.5);
////////////////////////////////////////////////////////////////////////////////////////////
// move 2: set addresses
////////////////////////////////////////////////////////////////////////////////////////////
if(starting==true) {
strcpy(command, "ifconfig ");
strcpy(temp, "");
temp_QT = GlobalSettings->value("AP/Iface", "wlan0").toString().toLocal8Bit();
//temp = temp_QT.toAscii().data();
temp = temp_QT.toUtf8().data();
strcat(command, temp);
strcat(command, " ");
temp_QT = GlobalSettings->value("AP/IP_SERVER", "192.168.0.1").toString().toLocal8Bit();
//temp = temp_QT.toAscii().data();
temp = temp_QT.toUtf8().data();
strcat(command, temp);
strcat(command, " netmask ");
strcpy(temp, "");
temp_QT = GlobalSettings->value("AP/MASK", "255.255.255.0").toString().toLocal8Bit();
//temp = temp_QT.toAscii().data();
temp = temp_QT.toUtf8().data();
strcat(command, temp);
strcat(command, " up");
console(command, tmp);
strcpy(temp, "");
sleep(0.5);
dateUNIXNow.clear(); dateUNIXNow = QString::number(TimeNow.currentDateTime().toTime_t());
emit toLog(QString("%1|%2|%3|%4").arg(WhoIAm, dateUNIXNow, tr("Address setting is completed"), QString("1")));
emit send_step(tr("Address setting is completed"));
emit setPercent(20);
qDebug()<< "Check device" << " ... "<< "OK";
}
////////////////////////////////////////////////////////////////////////////////////////////
sleep(0.5);
////////////////////////////////////////////////////////////////////////////////////////////
// move 3: raise the interface
////////////////////////////////////////////////////////////////////////////////////////////
if(starting==true) {
strcpy(command, "ifconfig ");
temp_QT = GlobalSettings->value("AP/Iface", "wlan0").toString().toLocal8Bit();
//temp = temp_QT.toAscii().data();
temp = temp_QT.toUtf8().data();
strcat(command, temp);
strcat(command, " up");
console(command, tmp);
sleep(1);
/* check */
CheckProcess CheckInterface(1, GlobalSettings->value("AP/Iface", "wlan0").toString());
if(!CheckInterface.init()) {
dateUNIXNow.clear(); dateUNIXNow = QString::number(TimeNow.currentDateTime().toTime_t());
emit toLog(QString("%1|%2|%3|%4").arg(WhoIAm, dateUNIXNow, tr("The device is not ready for use!"), QString("2")));
emit send_step(tr("The device is not ready for use!"));
qDebug()<< "Starting device" << " ... "<< "FAIL";
starting = false;
} else {
dateUNIXNow.clear(); dateUNIXNow = QString::number(TimeNow.currentDateTime().toTime_t());
emit toLog(QString("%1|%2|%3|%4").arg(WhoIAm, dateUNIXNow, tr("The device is ready for use"), QString("1")));
emit send_step(tr("The device is ready for use"));
emit setPercent(30);
qDebug()<<"Starting device"<< " ... " << "OK";
}
}
////////////////////////////////////////////////////////////////////////////////////////////
sleep(0.5);
////////////////////////////////////////////////////////////////////////////////////////////
// move 4: to include IPv4 forwarding
////////////////////////////////////////////////////////////////////////////////////////////
if(starting==true) {
console("sysctl -w net.ipv4.ip_forward=\"1\"", tmp);
sleep(0.5);
/* check */
CheckProcess CheckIPForwarding(2, "");
if(!CheckIPForwarding.init()) {
dateUNIXNow.clear(); dateUNIXNow = QString::number(TimeNow.currentDateTime().toTime_t());
emit toLog(QString("%1|%2|%3|%4").arg(WhoIAm, dateUNIXNow, tr("Failed to activate IP Forvard!"), QString("2")));
qDebug()<<"Enable IP Forwardng"<< " ... "<< "FAIL";
starting = false;
}
else {
dateUNIXNow.clear(); dateUNIXNow = QString::number(TimeNow.currentDateTime().toTime_t());
emit toLog(QString("%1|%2|%3|%4").arg(WhoIAm, dateUNIXNow, tr("IP Forward is successfully activated"), QString("1")));
emit send_step(tr("IP Forward is successfully activated"));
emit setPercent(45);
qDebug()<<"Enable IP Forwardng"<< " ... " << "OK";
}
}
////////////////////////////////////////////////////////////////////////////////////////////
sleep(0.5);
////////////////////////////////////////////////////////////////////////////////////////////
// move 5: include NAT
////////////////////////////////////////////////////////////////////////////////////////////
if(starting==true) {
strcpy(command, "iptables -t nat -A POSTROUTING -o ");
temp_QT = GlobalSettings->value("DHCP/Internet_iface", "eth0").toString().toLocal8Bit();
//temp = temp_QT.toAscii().data();
temp = temp_QT.toUtf8().data();
strcat(command, temp);
strcat(command, " -j MASQUERADE");
sleep(0.5);
system(command);
dateUNIXNow.clear(); dateUNIXNow = QString::number(TimeNow.currentDateTime().toTime_t());
emit toLog(QString("%1|%2|%3|%4").arg(WhoIAm, dateUNIXNow, tr("NAT is successfully activated"), QString("1")));
emit send_step(tr("NAT is successfully activated"));
emit setPercent(65);
qDebug()<<"Set rules to IPTABLES"<< " ... " << "OK";
}
////////////////////////////////////////////////////////////////////////////////////////////
sleep(0.5);
////////////////////////////////////////////////////////////////////////////////////////////
// move 6: raising DNSMASQ
////////////////////////////////////////////////////////////////////////////////////////////
if(starting==true) {
system(QString(Platform.CommandToStartDNSMASQ).toLocal8Bit().data());
/* check */
sleep(3);
CheckProcess CheckDNSMASQ("dnsmasq");
sleep(0.1);
if(!CheckDNSMASQ.init()) {
//TODO: Error info to log?
dateUNIXNow.clear(); dateUNIXNow = QString::number(TimeNow.currentDateTime().toTime_t());
emit toLog(QString("%1|%2|%3|%4").arg(WhoIAm, dateUNIXNow, tr("Failed to start DNSMASQ!"), QString("2")));
emit send_step(tr("Failed to start DNSMASQ!"));
qDebug()<< "Starting DNSMASQ" << " ... "<< "FAIL";
starting=false;
}
else {
dateUNIXNow.clear(); dateUNIXNow = QString::number(TimeNow.currentDateTime().toTime_t());
emit toLog(QString("%1|%2|%3|%4").arg(WhoIAm, dateUNIXNow, tr("DNSMASQ successfully launched"), QString("1")));
emit send_step(tr("DNSMASQ successfully launched"));
emit setPercent(80);
qDebug()<< "Starting DNSMASQ" << " ... "<< "OK";
}
}
////////////////////////////////////////////////////////////////////////////////////////////
sleep(0.5);
////////////////////////////////////////////////////////////////////////////////////////////
// move 7: raising HOSTAPD
////////////////////////////////////////////////////////////////////////////////////////////
if(starting==true) {
system(QString(Platform.CommandToStartHostapd).toLocal8Bit().data());
sleep(4);
/* check */
CheckProcess CheckHostapd("hostapd");
sleep(0.1);
if(!CheckHostapd.init()) {
dateUNIXNow.clear(); dateUNIXNow = QString::number(TimeNow.currentDateTime().toTime_t());
emit toLog(QString("%1|%2|%3|%4").arg(WhoIAm, dateUNIXNow, tr("Failed to start Hostapd!"), QString("2")));
emit send_step(tr("Failed to start Hostapd!"));
qDebug()<<command<< " ... "<< "FAIL";
starting = false;
}
else {
dateUNIXNow.clear(); dateUNIXNow = QString::number(TimeNow.currentDateTime().toTime_t());
emit toLog(QString("%1|%2|%3|%4").arg(WhoIAm, dateUNIXNow, tr("Hostapd successfully launched"), QString("1")));
emit send_step(tr("Hostapd successfully launched"));
emit setPercent(95);
qDebug()<<command<< " ... " << "OK";
}
}
////////////////////////////////////////////////////////////////////////////////////////////
sleep(0.5);
////////////////////////////////////////////////////////////////////////////////////////////
// move 8: checking and debriefing
////////////////////////////////////////////////////////////////////////////////////////////
if(starting==true) {
// This means that all steps are performed and the access point is started
qDebug()<< tr("AP is running!\n");
emit setPercent(100);
emit send_step(tr("AP successfully activated"));
emit reset_status_active();
} else {
// This means that the access point is not started!
qDebug()<< tr("AP is NOT running!\n");
emit reset_status_active();
}
////////////////////////////////////////////////////////////////////////////////////////////
dateUNIXNow.clear(); dateUNIXNow = QString::number(TimeNow.currentDateTime().toTime_t());
emit toLog(QString("%1|%2|%3|%4").arg(WhoIAm, dateUNIXNow, QString(tr("Activation sequence is completed")), QString("0")));
delete GlobalSettings;
exec();
}
static BOOL MessageDone() {
// TODO: check pin capabilities
switch (rx_msg.type) {
case HARD_RESET:
CHECK(rx_msg.args.hard_reset.magic == IOIO_MAGIC);
HardReset();
break;
case SOFT_RESET:
SoftReset();
Echo();
break;
case SET_PIN_DIGITAL_OUT:
CHECK(rx_msg.args.set_pin_digital_out.pin < NUM_PINS);
SetPinDigitalOut(rx_msg.args.set_pin_digital_out.pin,
rx_msg.args.set_pin_digital_out.value,
rx_msg.args.set_pin_digital_out.open_drain);
break;
case SET_DIGITAL_OUT_LEVEL:
CHECK(rx_msg.args.set_digital_out_level.pin < NUM_PINS);
SetDigitalOutLevel(rx_msg.args.set_digital_out_level.pin,
rx_msg.args.set_digital_out_level.value);
break;
case SET_PIN_DIGITAL_IN:
CHECK(rx_msg.args.set_pin_digital_in.pin < NUM_PINS);
CHECK(rx_msg.args.set_pin_digital_in.pull < 3);
SetPinDigitalIn(rx_msg.args.set_pin_digital_in.pin, rx_msg.args.set_pin_digital_in.pull);
break;
case SET_CHANGE_NOTIFY:
CHECK(rx_msg.args.set_change_notify.pin < NUM_PINS);
if (rx_msg.args.set_change_notify.cn) {
Echo();
}
SetChangeNotify(rx_msg.args.set_change_notify.pin, rx_msg.args.set_change_notify.cn);
if (!rx_msg.args.set_change_notify.cn) {
Echo();
}
break;
case SET_PIN_PWM:
CHECK(rx_msg.args.set_pin_pwm.pin < NUM_PINS);
CHECK(rx_msg.args.set_pin_pwm.pwm_num < NUM_PWM_MODULES);
SetPinPwm(rx_msg.args.set_pin_pwm.pin, rx_msg.args.set_pin_pwm.pwm_num,
rx_msg.args.set_pin_pwm.enable);
break;
case SET_PWM_DUTY_CYCLE:
CHECK(rx_msg.args.set_pwm_duty_cycle.pwm_num < NUM_PWM_MODULES);
SetPwmDutyCycle(rx_msg.args.set_pwm_duty_cycle.pwm_num,
rx_msg.args.set_pwm_duty_cycle.dc,
rx_msg.args.set_pwm_duty_cycle.fraction);
break;
case SET_PWM_PERIOD:
CHECK(rx_msg.args.set_pwm_period.pwm_num < NUM_PWM_MODULES);
SetPwmPeriod(rx_msg.args.set_pwm_period.pwm_num,
rx_msg.args.set_pwm_period.period,
rx_msg.args.set_pwm_period.scale_l
| (rx_msg.args.set_pwm_period.scale_h) << 1);
break;
case SET_PIN_ANALOG_IN:
CHECK(rx_msg.args.set_pin_analog_in.pin < NUM_PINS);
SetPinAnalogIn(rx_msg.args.set_pin_analog_in.pin);
break;
case UART_DATA:
CHECK(rx_msg.args.uart_data.uart_num < NUM_UART_MODULES);
UARTTransmit(rx_msg.args.uart_data.uart_num,
rx_msg.args.uart_data.data,
rx_msg.args.uart_data.size + 1);
break;
case UART_CONFIG:
CHECK(rx_msg.args.uart_config.uart_num < NUM_UART_MODULES);
CHECK(rx_msg.args.uart_config.parity < 3);
UARTConfig(rx_msg.args.uart_config.uart_num,
rx_msg.args.uart_config.rate,
rx_msg.args.uart_config.speed4x,
rx_msg.args.uart_config.two_stop_bits,
rx_msg.args.uart_config.parity);
break;
case SET_PIN_UART:
CHECK(rx_msg.args.set_pin_uart.pin < NUM_PINS);
CHECK(rx_msg.args.set_pin_uart.uart_num < NUM_UART_MODULES);
SetPinUart(rx_msg.args.set_pin_uart.pin,
rx_msg.args.set_pin_uart.uart_num,
rx_msg.args.set_pin_uart.dir,
rx_msg.args.set_pin_uart.enable);
break;
case SPI_MASTER_REQUEST:
CHECK(rx_msg.args.spi_master_request.spi_num < NUM_SPI_MODULES);
CHECK(rx_msg.args.spi_master_request.ss_pin < NUM_PINS);
{
const BYTE total_size = rx_msg.args.spi_master_request.total_size + 1;
const BYTE data_size = rx_msg.args.spi_master_request.data_size_neq_total
? rx_msg.args.spi_master_request.data_size
: total_size;
const BYTE res_size = rx_msg.args.spi_master_request.res_size_neq_total
? rx_msg.args.spi_master_request.vararg[
rx_msg.args.spi_master_request.data_size_neq_total]
: total_size;
const BYTE* const data = &rx_msg.args.spi_master_request.vararg[
rx_msg.args.spi_master_request.data_size_neq_total
+ rx_msg.args.spi_master_request.res_size_neq_total];
SPITransmit(rx_msg.args.spi_master_request.spi_num,
rx_msg.args.spi_master_request.ss_pin,
data,
data_size,
total_size,
total_size - res_size);
}
break;
case SPI_CONFIGURE_MASTER:
CHECK(rx_msg.args.spi_configure_master.spi_num < NUM_SPI_MODULES);
SPIConfigMaster(rx_msg.args.spi_configure_master.spi_num,
rx_msg.args.spi_configure_master.scale,
rx_msg.args.spi_configure_master.div,
rx_msg.args.spi_configure_master.smp_end,
rx_msg.args.spi_configure_master.clk_edge,
rx_msg.args.spi_configure_master.clk_pol);
break;
case SET_PIN_SPI:
CHECK(rx_msg.args.set_pin_spi.mode < 3);
CHECK((!rx_msg.args.set_pin_spi.enable
&& rx_msg.args.set_pin_spi.mode == 1)
|| rx_msg.args.set_pin_spi.pin < NUM_PINS);
CHECK((!rx_msg.args.set_pin_spi.enable
&& rx_msg.args.set_pin_spi.mode != 1)
|| rx_msg.args.set_pin_spi.spi_num < NUM_SPI_MODULES);
SetPinSpi(rx_msg.args.set_pin_spi.pin,
rx_msg.args.set_pin_spi.spi_num,
rx_msg.args.set_pin_spi.mode,
rx_msg.args.set_pin_spi.enable);
break;
case I2C_CONFIGURE_MASTER:
CHECK(rx_msg.args.i2c_configure_master.i2c_num < NUM_I2C_MODULES);
I2CConfigMaster(rx_msg.args.i2c_configure_master.i2c_num,
rx_msg.args.i2c_configure_master.rate,
rx_msg.args.i2c_configure_master.smbus_levels);
break;
case I2C_WRITE_READ:
CHECK(rx_msg.args.i2c_write_read.i2c_num < NUM_I2C_MODULES);
{
unsigned int addr;
if (rx_msg.args.i2c_write_read.ten_bit_addr) {
addr = rx_msg.args.i2c_write_read.addr_lsb;
addr = addr << 8
| ((rx_msg.args.i2c_write_read.addr_msb << 1)
| 0b11110000);
} else {
CHECK(rx_msg.args.i2c_write_read.addr_msb == 0
&& rx_msg.args.i2c_write_read.addr_lsb >> 7 == 0
&& rx_msg.args.i2c_write_read.addr_lsb >> 2 != 0b0011110);
addr = rx_msg.args.i2c_write_read.addr_lsb << 1;
}
I2CWriteRead(rx_msg.args.i2c_write_read.i2c_num,
addr,
rx_msg.args.i2c_write_read.data,
rx_msg.args.i2c_write_read.write_size,
rx_msg.args.i2c_write_read.read_size);
}
break;
case SET_ANALOG_IN_SAMPLING:
CHECK(rx_msg.args.set_analog_pin_sampling.pin < NUM_PINS);
ADCSetScan(rx_msg.args.set_analog_pin_sampling.pin,
rx_msg.args.set_analog_pin_sampling.enable);
break;
case CHECK_INTERFACE:
CheckInterface(rx_msg.args.check_interface.interface_id);
break;
case ICSP_SIX:
ICSPSix(rx_msg.args.icsp_six.inst);
break;
case ICSP_REGOUT:
ICSPRegout();
break;
case ICSP_PROG_ENTER:
ICSPEnter();
break;
case ICSP_PROG_EXIT:
ICSPExit();
break;
case ICSP_CONFIG:
if (rx_msg.args.icsp_config.enable) {
Echo();
}
ICSPConfigure(rx_msg.args.icsp_config.enable);
if (!rx_msg.args.icsp_config.enable) {
Echo();
}
break;
case INCAP_CONFIG:
CHECK(rx_msg.args.incap_config.incap_num < NUM_INCAP_MODULES);
CHECK(!rx_msg.args.incap_config.double_prec
|| 0 == (rx_msg.args.incap_config.incap_num & 0x01));
CHECK(rx_msg.args.incap_config.mode < 6);
CHECK(rx_msg.args.incap_config.clock < 4);
InCapConfig(rx_msg.args.incap_config.incap_num,
rx_msg.args.incap_config.double_prec,
rx_msg.args.incap_config.mode,
rx_msg.args.incap_config.clock);
break;
case SET_PIN_INCAP:
CHECK(rx_msg.args.set_pin_incap.incap_num < NUM_INCAP_MODULES);
CHECK(!rx_msg.args.set_pin_incap.enable
|| rx_msg.args.set_pin_incap.pin < NUM_PINS);
SetPinInCap(rx_msg.args.set_pin_incap.pin,
rx_msg.args.set_pin_incap.incap_num,
rx_msg.args.set_pin_incap.enable);
break;
case SOFT_CLOSE:
log_printf("Soft close requested");
Echo();
state = STATE_CLOSING;
break;
case SET_PIN_PULSECOUNTER:
CHECK(rx_msg.args.set_pin_pulsecounter.pin < NUM_PINS);
CHECK(rx_msg.args.set_pin_pulsecounter.mode < 4);
CHECK(rx_msg.args.set_pin_pulsecounter.rateord < 9);
CHECK(rx_msg.args.set_pin_pulsecounter.stepsord < 4);
SetPinPulseCounter(rx_msg.args.set_pin_pulsecounter.pin,
rx_msg.args.set_pin_pulsecounter.enable,
rx_msg.args.set_pin_pulsecounter.mode,
rx_msg.args.set_pin_pulsecounter.rateord,
rx_msg.args.set_pin_pulsecounter.stepsord);
break;
// BOOKMARK(add_feature): Add incoming message handling to switch clause.
// Call Echo() if the message is to be echoed back.
default:
return FALSE;
}
return TRUE;
}
void CPageNetwork::ShowTargetSelection()
{
Manager *manager, *partner_manager;
Worker *worker, *partner_worker;
char *remote_address;
HTREEITEM hmgr;
HTREEITEM hifc;
int i, expected_worker;
TargetSelType state;
switch (theApp.pView->m_pWorkerView->GetSelectedType()) {
case WORKER:
worker = theApp.pView->m_pWorkerView->GetSelectedWorker();
// Get the interface to check.
if (IsType(worker->Type(), GenericServerType)) {
if (!worker->net_partner) {
partner_manager = NULL;
} else {
partner_manager = worker->net_partner->manager;
if (IsType(worker->GetTarget(0)->spec.type, TCPClientType))
remote_address = worker->GetTarget(0)->spec.tcp_info.remote_address;
else if (IsType(worker->GetTarget(0)->spec.type, VIClientType))
remote_address = worker->GetTarget(0)->spec.vi_info.remote_nic_name;
else {
ErrorMessage("Invalid client target type in CPageNetwork::"
"ShowTargetSelection().");
return;
}
}
} else if (IsType(worker->Type(), GenericClientType)) {
partner_manager = worker->net_partner->manager;
remote_address = worker->net_partner->spec.name;
} else {
return;
}
// Walk the target tree to find the correct partner manager.
for (hmgr = m_TTargets.GetRootItem(); hmgr; hmgr = m_TTargets.GetNextSiblingItem(hmgr)) {
if (m_TTargets.GetItemData(hmgr) == (DWORD_PTR) partner_manager) {
// Check the appropriate interface on the partner manager.
CheckInterface(hmgr, remote_address);
} else {
// Clear all check marks for this manager's interfaces.
CheckInterface(hmgr, NULL);
}
}
break;
case MANAGER:
// Get the selected manager.
manager = theApp.pView->m_pWorkerView->GetSelectedManager();
expected_worker = 0;
// Loop through all the target tree items.
for (hmgr = m_TTargets.GetRootItem(); hmgr; hmgr = m_TTargets.GetNextSiblingItem(hmgr)) {
// Get the possible partner manager from the tree.
partner_manager = (Manager *) m_TTargets.GetItemData(hmgr);
// Loop through that manager item's interfaces.
for (hifc = m_TTargets.GetChildItem(hmgr); hifc; hifc = m_TTargets.GetNextSiblingItem(hifc)) {
// Initialize the state. It may or may not be changed,
// depending on whether we find it selected by a worker.
state = TargetUnChecked;
// Check the interface for selection by any of the manager's
// workers
for (i = 0; i < manager->WorkerCount(GenericServerType); i++) {
// Get the net partner of the expected worker.
partner_worker = manager->GetWorker(i, GenericServerType)->net_partner;
// If the partner worker exists and it's manager is the
// same as the manager in the target tree that we are
// currently looking at and..
if (partner_worker && partner_worker->manager == partner_manager) {
// if the net addresses match but..
if (m_TTargets.GetItemText(hifc) ==
partner_worker->GetLocalNetworkInterface()) {
// the worker is not the expected worker..
if (i != expected_worker || state != TargetUnChecked) {
// gray the selection
SetAllCheck(TargetGrayed);
return;
}
state = TargetChecked;
expected_worker++;
}
}
}
SetSelectionCheck(hifc, state);
}
}
break;
default:
SetAllCheck(TargetGrayed);
break;
}
}
