int
MPU9250::accel_self_test()
{
if (self_test()) {
return 1;
}
/* inspect accel offsets */
if (fabsf(_accel_scale.x_offset) < 0.000001f) {
return 2;
}
if (fabsf(_accel_scale.x_scale - 1.0f) > 0.4f || fabsf(_accel_scale.x_scale - 1.0f) < 0.000001f) {
return 3;
}
if (fabsf(_accel_scale.y_offset) < 0.000001f) {
return 4;
}
if (fabsf(_accel_scale.y_scale - 1.0f) > 0.4f || fabsf(_accel_scale.y_scale - 1.0f) < 0.000001f) {
return 5;
}
if (fabsf(_accel_scale.z_offset) < 0.000001f) {
return 6;
}
if (fabsf(_accel_scale.z_scale - 1.0f) > 0.4f || fabsf(_accel_scale.z_scale - 1.0f) < 0.000001f) {
return 7;
}
return 0;
}
void *firethread_st(void *param) {
struct thread_params_st *threadparams = (struct thread_params_st *)param;
/*child process*/
#if 0
#ifndef WIN32
fprintf(stderr, "Start of thread %u\n context=%u\n",
(unsigned int)pthread_self(),
(unsigned int)threadparams->context);
#endif
#endif
do {
self_test(threadparams->context, threadparams->tcs, threadparams->tce, threadparams->flags,
threadparams->testcase_config, threadparams->suite, threadparams->doprint, threadparams->max_in_flight);
if (threadparams->wait)
sleep(threadparams->wait);
}while (threadparams->wait);
#if 0
#ifndef WIN32
fprintf(stderr, "End of thread %u\n",
(unsigned int)pthread_self());
#endif
#endif
return NULL;
}
int
BMI160::accel_self_test()
{
if (self_test()) {
return 1;
}
/* inspect accel offsets */
if (fabsf(_accel_scale.x_offset) < 0.000001f) {
return 1;
}
if (fabsf(_accel_scale.x_scale - 1.0f) > 0.4f || fabsf(_accel_scale.x_scale - 1.0f) < 0.000001f) {
return 1;
}
if (fabsf(_accel_scale.y_offset) < 0.000001f) {
return 1;
}
if (fabsf(_accel_scale.y_scale - 1.0f) > 0.4f || fabsf(_accel_scale.y_scale - 1.0f) < 0.000001f) {
return 1;
}
if (fabsf(_accel_scale.z_offset) < 0.000001f) {
return 1;
}
if (fabsf(_accel_scale.z_scale - 1.0f) > 0.4f || fabsf(_accel_scale.z_scale - 1.0f) < 0.000001f) {
return 1;
}
return 0;
}
int main(int argc, char **argv)
{
printf("Config: bits: %d, optimize mult: %d, use mul table: %d, use tables: %d\n",
get_bits(), use_galois(), use_mul_table(), use_tables());
kuz_key_t key;
w128_t x;
uint32_t buf[0x100];
clock_t tim;
kuz_init();
self_test();
// == Speed Test ==
for (int i = 0; i < 0x100; i++)
buf[i] = i;
kuz_set_encrypt_key(&key, testvec_key);
for (int n = 4000, tim = 0; tim < 2 * CLOCKS_PER_SEC; n <<= 1) {
tim = clock();
for (int j = 0; j < n; j++) {
for (int i = 0; i < 0x100; i += 4)
kuz_encrypt_block(&key, &buf[i]);
}
tim = clock() - tim;
printf("kuz_encrypt_block(): %.3f kB/s (n=%dkB,t=%.3fs)\r",
((double) CLOCKS_PER_SEC * n) / ((double) tim),
n, ((double) tim) / ((double) CLOCKS_PER_SEC));
fflush(stdout);
}
printf("\n");
for (int i = 0; i < 0x100; i++)
buf[i] = i;
kuz_set_decrypt_key(&key, testvec_key);
for (int n = 4000, tim = 0; tim < 2 * CLOCKS_PER_SEC; n <<= 1) {
tim = clock();
for (int j = 0; j < n; j++) {
for (int i = 0; i < 0x100; i += 4)
kuz_decrypt_block(&key, &buf[i]);
}
tim = clock() - tim;
printf("kuz_decrypt_block(): %.3f kB/s (n=%dkB,t=%.3fs)\r",
((double) CLOCKS_PER_SEC * n) / ((double) tim),
n, ((double) tim) / ((double) CLOCKS_PER_SEC));
fflush(stdout);
}
printf("\n");
printf("Tables: %.1fK (encrypt: %.1fK, decrypt: %.1fK)\n", (float)get_used_memory_count() / 1024, (float)get_encrypt_used_memory_count() / 1024, (float)get_decrypt_used_memory_count() / 1024);
return 0;
}
int
BMI160::accel_self_test()
{
if (self_test()) {
return 1;
}
return 0;
}
int
MPU9250::accel_self_test()
{
if (self_test()) {
return 1;
}
return 0;
}
int
MPU9250::gyro_self_test()
{
if (self_test()) {
return 1;
}
/*
* Maximum deviation of 20 degrees, according to
* http://www.invensense.com/mems/gyro/documents/PS-MPU-9250A-00v3.4.pdf
* Section 6.1, initial ZRO tolerance
*/
const float max_offset = 0.34f;
/* 30% scale error is chosen to catch completely faulty units but
* to let some slight scale error pass. Requires a rate table or correlation
* with mag rotations + data fit to
* calibrate properly and is not done by default.
*/
const float max_scale = 0.3f;
/* evaluate gyro offsets, complain if offset -> zero or larger than 20 dps. */
if (fabsf(_gyro_scale.x_offset) > max_offset) {
return 1;
}
/* evaluate gyro scale, complain if off by more than 30% */
if (fabsf(_gyro_scale.x_scale - 1.0f) > max_scale) {
return 1;
}
if (fabsf(_gyro_scale.y_offset) > max_offset) {
return 1;
}
if (fabsf(_gyro_scale.y_scale - 1.0f) > max_scale) {
return 1;
}
if (fabsf(_gyro_scale.z_offset) > max_offset) {
return 1;
}
if (fabsf(_gyro_scale.z_scale - 1.0f) > max_scale) {
return 1;
}
/* check if all scales are zero */
if ((fabsf(_gyro_scale.x_offset) < 0.000001f) &&
(fabsf(_gyro_scale.y_offset) < 0.000001f) &&
(fabsf(_gyro_scale.z_offset) < 0.000001f)) {
/* if all are zero, this device is not calibrated */
return 1;
}
return 0;
}
int main(void) {
init();
self_test();
restore_state();
while(1) {
key_press(&key1_lock, &PINA, KEY1, minus);
key_press(&key2_lock, &PINB, KEY2, plus);
render_leds();
};
};
int
BMI160::gyro_self_test()
{
if (self_test()) {
return 1;
}
/*
* Maximum deviation of 10 degrees
*/
const float max_offset = (float)(10 * M_PI_F / 180.0f);
/* 30% scale error is chosen to catch completely faulty units but
* to let some slight scale error pass. Requires a rate table or correlation
* with mag rotations + data fit to
* calibrate properly and is not done by default.
*/
const float max_scale = 0.3f;
/* evaluate gyro offsets, complain if offset -> zero or larger than 30 dps. */
if (fabsf(_gyro_scale.x_offset) > max_offset) {
return 1;
}
/* evaluate gyro scale, complain if off by more than 30% */
if (fabsf(_gyro_scale.x_scale - 1.0f) > max_scale) {
return 1;
}
if (fabsf(_gyro_scale.y_offset) > max_offset) {
return 1;
}
if (fabsf(_gyro_scale.y_scale - 1.0f) > max_scale) {
return 1;
}
if (fabsf(_gyro_scale.z_offset) > max_offset) {
return 1;
}
if (fabsf(_gyro_scale.z_scale - 1.0f) > max_scale) {
return 1;
}
/* check if all scales are zero */
if ((fabsf(_gyro_scale.x_offset) < 0.000001f) &&
(fabsf(_gyro_scale.y_offset) < 0.000001f) &&
(fabsf(_gyro_scale.z_offset) < 0.000001f)) {
/* if all are zero, this device is not calibrated */
return 1;
}
return 0;
}
/////===========MAIN=====================/////////////////////
int main(void)
{
init();
self_test();
while(1)
{
//check to see if autorun is set, if it is don't print the menu
if(read_from_EEPROM(1) == 48) config_read();
else config_menu();
}
}
void config_read(void)
{
uint8_t choice=0;
if(read_from_EEPROM(10) != 48)
{
while(1)
{
choice = uart_getchar();
putchar('\n');
putchar('\r');
if(choice=='1')
{
while(!(UCSR0A & (1 << RXC0)))adxl345();
config_menu();
}
if(choice=='2')
{
while(!(UCSR0A & (1 << RXC0)))
{
hmc5843();
delay_ms(550);//at least 100ms interval between measurements
}
config_menu();
}
if(choice=='3')
{
while(!(UCSR0A & (1 << RXC0)))stgyros();
config_menu();
}
if(choice=='4')
{
while(!(UCSR0A & (1 << RXC0)))raw();
config_menu();
}
if(choice=='5')
{
self_test();
}
if(choice==0x1A) //if ctrl-z
{
write_to_EEPROM(10,48);
auto_raw();
}
if(choice==0x3F) //if ?
{
help();
config_menu();
}
}
}else auto_raw();
}
int main(int argc, char *argv[])
{
RELATED_DEV rdev;
IDEV *p;
rdev.prefix[0] = 0x00;
rdev.start_num = 1;
rdev.end_num = 0;
register_device("ttyUSB0", &rdev, SIM4100);
if (dev_list.dev[0].active == 0) {
dm_log(NULL, "error register device.");
return -1;
}
p = dev_list.dev[0].idev;
while (idev_get_status(p) != READY)
sleep(1);
self_test(p);
return 0;
}
int
L3GD20::ioctl(struct file *filp, int cmd, unsigned long arg)
{
switch (cmd) {
case SENSORIOCSPOLLRATE: {
switch (arg) {
/* switching to manual polling */
case SENSOR_POLLRATE_MANUAL:
stop();
_call_interval = 0;
return OK;
/* external signalling not supported */
case SENSOR_POLLRATE_EXTERNAL:
/* zero would be bad */
case 0:
return -EINVAL;
/* set default/max polling rate */
case SENSOR_POLLRATE_MAX:
case SENSOR_POLLRATE_DEFAULT:
return ioctl(filp, SENSORIOCSPOLLRATE, L3GD20_DEFAULT_RATE);
/* adjust to a legal polling interval in Hz */
default: {
/* do we need to start internal polling? */
bool want_start = (_call_interval == 0);
/* convert hz to hrt interval via microseconds */
unsigned ticks = 1000000 / arg;
/* check against maximum sane rate */
if (ticks < 1000)
return -EINVAL;
/* update interval for next measurement */
/* XXX this is a bit shady, but no other way to adjust... */
_call.period = _call_interval = ticks;
/* adjust filters */
float cutoff_freq_hz = _gyro_filter_x.get_cutoff_freq();
float sample_rate = 1.0e6f/ticks;
set_driver_lowpass_filter(sample_rate, cutoff_freq_hz);
/* if we need to start the poll state machine, do it */
if (want_start)
start();
return OK;
}
}
}
case SENSORIOCGPOLLRATE:
if (_call_interval == 0)
return SENSOR_POLLRATE_MANUAL;
return 1000000 / _call_interval;
case SENSORIOCSQUEUEDEPTH: {
/* lower bound is mandatory, upper bound is a sanity check */
if ((arg < 1) || (arg > 100))
return -EINVAL;
irqstate_t flags = irqsave();
if (!_reports->resize(arg)) {
irqrestore(flags);
return -ENOMEM;
}
irqrestore(flags);
return OK;
}
case SENSORIOCGQUEUEDEPTH:
return _reports->size();
case SENSORIOCRESET:
reset();
return OK;
case GYROIOCSSAMPLERATE:
return set_samplerate(arg);
case GYROIOCGSAMPLERATE:
return _current_rate;
case GYROIOCSLOWPASS: {
float cutoff_freq_hz = arg;
float sample_rate = 1.0e6f / _call_interval;
set_driver_lowpass_filter(sample_rate, cutoff_freq_hz);
return OK;
}
case GYROIOCGLOWPASS:
return _gyro_filter_x.get_cutoff_freq();
case GYROIOCSSCALE:
/* copy scale in */
memcpy(&_gyro_scale, (struct gyro_scale *) arg, sizeof(_gyro_scale));
return OK;
case GYROIOCGSCALE:
/* copy scale out */
memcpy((struct gyro_scale *) arg, &_gyro_scale, sizeof(_gyro_scale));
return OK;
case GYROIOCSRANGE:
/* arg should be in dps */
return set_range(arg);
case GYROIOCGRANGE:
/* convert to dps and round */
return (unsigned long)(_gyro_range_rad_s * 180.0f / M_PI_F + 0.5f);
case GYROIOCSELFTEST:
return self_test();
default:
/* give it to the superclass */
return SPI::ioctl(filp, cmd, arg);
}
}
void PrintConsoleMenu(void)
{
unsigned char byteReceived;
static BOOL waitingResponse = FALSE;
WIFLY_Result_t result;
char OutString[128];
if((strlen(consoleMsg) <= 1) & (!waitingResponse))
{
byteReceived = consoleMsg[0];
switch(byteReceived)
{
case 'a':
putsConsole("\r\nEnter BAUDRATE\r\n");
waitingResponse = TRUE;
consoleState = 'a';
break;
case 'b':
putsConsole("\r\nEnabling Pass-thru mode for RN1723\r\n");
RN_UartCmdMode = TRUE;
RN_COMMAND_MODE();
{
unsigned long int timeout;
timeout = TickGet() + TICK_SECOND * 1;
while ((UINT32)TickGet() < timeout);
}
RN_DATA_MODE();
//XEEWriteCompleteArray(USER_RN_UART_SETTING, (unsigned char *) &RN_UartCmdMode, sizeof(RN_UartCmdMode));
break;
case 'c':
putsConsole("\r\nResetting System to RN1723 Factory Defaults\r\n");
_Factory_Reset_RN();
break;
case '0':
self_test();
case '1':
//putsConsole("\r\nProgramming RN Application Default Settings");
RN_UartCmdMode = TRUE;
Wifly_Default_Config(FALSE); //web app mode turned off
RN_RESET_LOW();
{
//pulse of atleast 160 us
unsigned long int timeout = TickGet();
while(TickGet() < (timeout + (1 * TICK_MILLISECOND)));
}
RN_RESET_HIGH();
RN_UartCmdMode = FALSE;
putsConsole("\r\n>>");
Reset();
break;
case '2':
putsConsole("\r\nScanning for networks\r\n");
RN_UartCmdMode = TRUE;
while(PutCMD_WiFlyUART("$$$", "CMD", SEC(1)) == Result_BUSY);
while(PutCMD_WiFlyUART("\r\n", ">", SEC(1)) == Result_BUSY);
while(PutCMD_WiFlyUART("scan\r\n","END:",SEC(10))==Result_BUSY);
while(PutCMD_WiFlyUART("exit\r\n", "", SEC(1)) == Result_BUSY);
RN_UartCmdMode = FALSE;
putsConsole("\r\n>>");
break;
case '3':
putsConsole("\r\nEnter SSID\r\n");
waitingResponse = TRUE;
consoleState = 0x03;
break;
case '4':
putsConsole("\r\nEnter DNS name\r\n");
waitingResponse = TRUE;
consoleState = 0x04;
break;
case '5':
putsConsole("\r\nEnter Host IP Address\r\n");
waitingResponse = TRUE;
consoleState = 0x05;
break;
case '6':
putsConsole("\r\nEnter destination port number\r\n");
waitingResponse = TRUE;
consoleState = 0x06;
break;
case '7':
putsConsole("\r\nChange SYS Wake time\r\n");
waitingResponse = TRUE;
consoleState = 0x07;
break;
case '8':
putsConsole("\r\nEnter RN1723 Dev Board Base-URI\r\n");
waitingResponse = TRUE;
consoleState = 0x08;
break;
case '9':
putsConsole("\r\nEnter Date in mm/dd/yyyy format\r\n");
waitingResponse = TRUE;
consoleState = 0x09;
break;
default:
putsConsole("\r\n\r\nChoose from the below options:\r\n");
putsConsole("------------------------------------------");
putsConsole("\r\na. Configure PIC32 to RN-UART BAUDRATE");
putsConsole("\r\nb. Pass Terminal to RN-UART");
putsConsole("\r\nc. Factory Reset System\r\n");
putsConsole("\r\n1. Restore RN1723 Dev Board Default Settings");
putsConsole("\r\n2. Scan for networks to join");
putsConsole("\r\n3. Configure SSID, Passphrase");
putsConsole("\r\n4. Change DNS Name");
putsConsole("\r\n5. Change Host IP Address");
putsConsole("\r\n6. Change Destination port");
putsConsole("\r\n7. Change RN SYS Wake time");
putsConsole("\r\n8. Change RN1723 Dev Board Base-URI");
putsConsole("\r\n9. Enter Date and Time (Used for SSL Peer Validation)");
putsConsole("\r\n\r\nPress 'ESC' to exit PIC32 Console Mode");
putsConsole("\r\n>>");
break;
}
}
else
{
waitingResponse = FALSE;
switch(consoleState)
{
case 'a':
{
RN_UartCmdMode = TRUE;
while(PutCMD_WiFlyUART("$$$", "CMD", SEC(1)) == Result_BUSY);
while(PutCMD_WiFlyUART("\r\n", ">", SEC(1)) == Result_BUSY);
sprintf(OutString,"set uart baud %s\r\n", consoleMsg);
while(PutCMD_WiFlyUART(OutString,">",SEC(1))==Result_BUSY);
while(PutCMD_WiFlyUART("save\r\n", ">", SEC(1)) == Result_BUSY);
while(PutCMD_WiFlyUART("exit\r\n", "", SEC(1)) == Result_BUSY);
RN_UartCmdMode = FALSE;
consoleState = 0;
}
break;
case 0x03:
putsConsole("\r\nProgramming SSID...\r\n");
RN_UartCmdMode = TRUE;
while(PutCMD_WiFlyUART("$$$", "CMD", SEC(1)) == Result_BUSY);
while(PutCMD_WiFlyUART("\r\n", ">", SEC(1)) == Result_BUSY);
sprintf(OutString,"set wlan ssid %s\r\n",consoleMsg);
while(PutCMD_WiFlyUART(OutString,"OK",SEC(1))==Result_BUSY);
while(PutCMD_WiFlyUART("save\r\n", "OK", SEC(1)) == Result_BUSY);
while(PutCMD_WiFlyUART("exit\r\n", "", SEC(1)) == Result_BUSY);
RN_UartCmdMode = FALSE;
putsConsole("\r\nEnter Passphrase\r\n");
waitingResponse = TRUE;
consoleState = 0x32;
break;
case 0x04:
putsConsole("\r\nProgramming DNS...\r\n");
if(strlen(consoleMsg) > 2)
{
memset(hostName, '\0', 40);
strcpy(hostName, consoleMsg);
XEEWriteCompleteArray(USER_HOST_NAME, (char*) &hostName, 40);
}
RN_UartCmdMode = TRUE;
while(PutCMD_WiFlyUART("$$$", "CMD", SEC(1)) == Result_BUSY);
while(PutCMD_WiFlyUART("\r\n", ">", SEC(1)) == Result_BUSY);
sprintf(OutString,"set dns name %s\r\n",consoleMsg);
while(PutCMD_WiFlyUART(OutString,">",SEC(1))==Result_BUSY);
while(PutCMD_WiFlyUART("set ip host 0\r\n", ">", SEC(1))== Result_BUSY);
while(PutCMD_WiFlyUART("save\r\n", ">", SEC(1)) == Result_BUSY);
while(PutCMD_WiFlyUART("exit\r\n", "", SEC(1)) == Result_BUSY);
RN_UartCmdMode = FALSE;
consoleState = 0;
break;
case 0x05:
putsConsole("\r\nProgramming host IP...\r\n");
if(strlen(consoleMsg) > 2)
{
memset(hostName, '\0', 40);
strcpy(hostName, consoleMsg);
XEEWriteCompleteArray(USER_HOST_NAME, (char*) &hostName, 40);
}
RN_UartCmdMode = TRUE;
while(PutCMD_WiFlyUART("$$$", "CMD", SEC(1)) == Result_BUSY);
while(PutCMD_WiFlyUART("\r\n", ">", SEC(1)) == Result_BUSY);
sprintf(OutString,"set ip host %s\r\n",consoleMsg);
while(PutCMD_WiFlyUART(OutString,">",SEC(1))==Result_BUSY);
while(PutCMD_WiFlyUART("set dns name 0\r\n",">",SEC(1))==Result_BUSY);
while(PutCMD_WiFlyUART("save\r\n", ">", SEC(1)) == Result_BUSY);
while(PutCMD_WiFlyUART("exit\r\n", "", SEC(1)) == Result_BUSY);
RN_UartCmdMode = FALSE;
consoleState = 0;
break;
case 0x06:
putsConsole("\r\nProgramming Destination port...\r\n");
RN_UartCmdMode = TRUE;
while(PutCMD_WiFlyUART("$$$", "CMD", SEC(1)) == Result_BUSY);
while(PutCMD_WiFlyUART("\r\n", ">", SEC(1)) == Result_BUSY);
sprintf(OutString,"set ip remote %s\r\n",consoleMsg);
while(PutCMD_WiFlyUART(OutString,">",SEC(1))==Result_BUSY);
while(PutCMD_WiFlyUART("save\r\n", ">", SEC(1)) == Result_BUSY);
while(PutCMD_WiFlyUART("exit\r\n", "", SEC(1)) == Result_BUSY);
RN_UartCmdMode = FALSE;
consoleState = 0;
break;
case 0x07:
putsConsole("\r\nProgramming sys wake time...\r\n");
RN_UartCmdMode = TRUE;
while(PutCMD_WiFlyUART("$$$", "CMD", SEC(1)) == Result_BUSY);
while(PutCMD_WiFlyUART("\r\n", ">", SEC(1)) == Result_BUSY);
sprintf(OutString,"set sys wake %s\r\n",consoleMsg);
while(PutCMD_WiFlyUART(OutString,">",SEC(1))==Result_BUSY);
while(PutCMD_WiFlyUART("save\r\n", ">", SEC(1)) == Result_BUSY);
while(PutCMD_WiFlyUART("exit\r\n", "", SEC(1)) == Result_BUSY);
RN_UartCmdMode = FALSE;
consoleState = 0;
break;
case 0x08:
putsConsole("\r\nProgramming Base-URI...\r\n");
memset(moduleBaseURI, '\0', 40);
strcpy(moduleBaseURI, consoleMsg);
XEEWriteCompleteArray(USER_BASE_URI_ADDRESS, (char*) &moduleBaseURI, 40);
consoleState = 0;
break;
case 0x09:
{
char *indexPtr;
if(indexPtr = strchr(consoleMsg, '/'))
{
unsigned char temp[4] = {"\0"};
temp[0] = *(indexPtr-2);
temp[1] = *(indexPtr-1);
timeNow.tm_mon = atoi(temp);
sprintf(OutString,"Month %d\r\n", timeNow.tm_mon);
putsConsole(OutString);
indexPtr = strchr(indexPtr+1, '/');
temp[0] = *(indexPtr-2);
temp[1] = *(indexPtr-1);
timeNow.tm_mday = atoi(temp);
sprintf(OutString,"Day %d\r\n", timeNow.tm_mday);
putsConsole(OutString);
temp[0] = *(indexPtr+1);
temp[1] = *(indexPtr+2);
temp[2] = *(indexPtr+3);
temp[3] = *(indexPtr+4);
timeNow.tm_year = (atoi(temp)-1900);
sprintf(OutString,"Year %d\r\n", atoi(temp));
putsConsole(OutString);
putsConsole("\r\nEnter Time in HH:MM (Hours:Minutes) format\r\n");
waitingResponse = TRUE;
consoleState = 0x92;
}
break;
}
case 0x32:
putsConsole("\r\nProgramming Passphrase...\r\n");
RN_UartCmdMode = TRUE;
while(PutCMD_WiFlyUART("$$$", "CMD", SEC(1)) == Result_BUSY);
while(PutCMD_WiFlyUART("\r\n", ">", SEC(1)) == Result_BUSY);
sprintf(OutString,"set wlan pass %s\r\n",consoleMsg);
while(PutCMD_WiFlyUART(OutString,"OK",SEC(1))==Result_BUSY);
while(PutCMD_WiFlyUART("set wlan join 1\r\n",">",SEC(1))==Result_BUSY);
while(PutCMD_WiFlyUART("save\r\n", "OK", SEC(1)) == Result_BUSY);
while(PutCMD_WiFlyUART("exit\r\n", "", SEC(1)) == Result_BUSY);
RN_UartCmdMode = FALSE;
EEPROM_Config_Defaults();
putsConsole("\r\nSetting EEPROM provisioned flag...");
{
unsigned char xeeVal = DEVICE_PROVISION_VAL;
XEEWriteCompleteArray(EE_PROVISION_ADDR, (char *) &xeeVal, sizeof(xeeVal));
}
consoleState = 0;
//resets the board after new configurations are programmed
SoftReset();
case 0x92:
{
char *indexPtr;
if(indexPtr = strchr(consoleMsg, ':'))
{
unsigned char temp[2] = {"\0"};
temp[0] = *(indexPtr-2);
temp[1] = *(indexPtr-1);
timeNow.tm_hour = atoi(temp);
sprintf(OutString,"Hours %d\r\n", timeNow.tm_hour);
putsConsole(OutString);
temp[0] = *(indexPtr+1);
temp[1] = *(indexPtr+2);
timeNow.tm_min = atoi(temp);
sprintf(OutString,"Min %d\r\n", timeNow.tm_min);
putsConsole(OutString);
}
}
timeNow.tm_isdst = 0;
sprintf(OutString, "\r\nOld Time in secs - %lu\r\n", PIC32_time);
putsConsole(OutString);
PIC32_time = mktime(&timeNow);
sprintf(OutString, "\r\nNew Time in secs - %lu\r\n", PIC32_time);
putsConsole(OutString);
XEEWriteCompleteArray(CURRENT_TIME_INFO, (char *) &PIC32_time, 4);
consoleState = 0;
break;
default:
consoleState = 0;
break;
//Resets console selection
//Unexpected state
}
putsConsole("\r\n>>");
}
memset(consoleMsg, '\0', sizeof(consoleMsg));
}
int
L3GD20::ioctl(struct file *filp, int cmd, unsigned long arg)
{
switch (cmd) {
case SENSORIOCSPOLLRATE: {
switch (arg) {
/* switching to manual polling */
case SENSOR_POLLRATE_MANUAL:
stop();
_call_interval = 0;
return OK;
/* external signalling not supported */
case SENSOR_POLLRATE_EXTERNAL:
/* zero would be bad */
case 0:
return -EINVAL;
/* set default/max polling rate */
case SENSOR_POLLRATE_MAX:
case SENSOR_POLLRATE_DEFAULT:
/* With internal low pass filters enabled, 250 Hz is sufficient */
return ioctl(filp, SENSORIOCSPOLLRATE, 250);
/* adjust to a legal polling interval in Hz */
default: {
/* do we need to start internal polling? */
bool want_start = (_call_interval == 0);
/* convert hz to hrt interval via microseconds */
unsigned ticks = 1000000 / arg;
/* check against maximum sane rate */
if (ticks < 1000)
return -EINVAL;
/* update interval for next measurement */
/* XXX this is a bit shady, but no other way to adjust... */
_call.period = _call_interval = ticks;
/* if we need to start the poll state machine, do it */
if (want_start)
start();
return OK;
}
}
}
case SENSORIOCGPOLLRATE:
if (_call_interval == 0)
return SENSOR_POLLRATE_MANUAL;
return 1000000 / _call_interval;
case SENSORIOCSQUEUEDEPTH: {
/* account for sentinel in the ring */
arg++;
/* lower bound is mandatory, upper bound is a sanity check */
if ((arg < 2) || (arg > 100))
return -EINVAL;
/* allocate new buffer */
struct gyro_report *buf = new struct gyro_report[arg];
if (nullptr == buf)
return -ENOMEM;
/* reset the measurement state machine with the new buffer, free the old */
stop();
delete[] _reports;
_num_reports = arg;
_reports = buf;
start();
return OK;
}
case SENSORIOCGQUEUEDEPTH:
return _num_reports - 1;
case SENSORIOCRESET:
/* XXX implement */
return -EINVAL;
case GYROIOCSSAMPLERATE:
return set_samplerate(arg);
case GYROIOCGSAMPLERATE:
return _current_rate;
case GYROIOCSLOWPASS:
case GYROIOCGLOWPASS:
/* XXX not implemented due to wacky interaction with samplerate */
return -EINVAL;
case GYROIOCSSCALE:
/* copy scale in */
memcpy(&_gyro_scale, (struct gyro_scale *) arg, sizeof(_gyro_scale));
return OK;
case GYROIOCGSCALE:
/* copy scale out */
memcpy((struct gyro_scale *) arg, &_gyro_scale, sizeof(_gyro_scale));
return OK;
case GYROIOCSRANGE:
return set_range(arg);
case GYROIOCGRANGE:
return _current_range;
case GYROIOCSELFTEST:
return self_test();
default:
/* give it to the superclass */
return SPI::ioctl(filp, cmd, arg);
}
}
int IsgwOperBase::internal_process(QModeMsg& req, char* ack, int& ack_len)
{
int ret =0;
switch(req.get_cmd())
{
//框架测试指令1
case CMD_TEST:
{
ACE_DEBUG((LM_INFO, "[%D] IsgwOperBase start to process CMD_TEST\n"));
//调用业务处理逻辑类的相关接口处理请求
#ifdef ISGW_USE_IBC
int max = 100;
for(int i=0; i<max; i++)
{
char msg[100]="";
snprintf(msg, sizeof(msg)
, "cmd=%d&uin=%u&total=%d&info=%d test|"
, req.get_cmd()
, req.get_uin()
, max
, i
);
QModeMsg *new_req = new QModeMsg(msg, req.get_handle()
, req.get_sock_seq(), req.get_msg_seq(), req.get_prot()
, req.get_time(), req.get_sock_ip());
if (IBCMgrSvc::instance()->putq(new_req) == -1)
{
//入队失败回收消息，避免内存泄漏
delete new_req;
new_req = NULL;
}
}
//此处不返回消息
ack_len = -1;
#else
//memset(ack,'@',ack_len);
snprintf(ack, ack_len-1, "%s", "info=in test process in test process in test process in test process in test process in test process");
ack_len = atoi((*(req.get_map()))["ack_len"].c_str());
#endif
//测试用 awayfang
//sleep(100);
ACE_DEBUG((LM_INFO, "[%D] IsgwOperBase process CMD_TEST succ\n"));
}
break;
case CMD_SELF_TEST:
{
QMSG_MAP& req_map = *req.get_map();
int testlevel = 0;
if(req_map.count("testlevel"))
{
testlevel = atoi(req_map["testlevel"].c_str());
}
int overproctime = 0;
std::string errmsg;
struct timeval start, end;
::gettimeofday(&start, NULL);
ret = self_test(testlevel, errmsg);
::gettimeofday(&end, NULL);
unsigned diff = EASY_UTIL::get_span(&start, &end);
int self_test_time_threshold = 500;
SysConf::instance()->get_conf_int("system", "self_test_time_threshold", &self_test_time_threshold);
overproctime = static_cast<int>(diff) - self_test_time_threshold;
// ret值不为0, overproctime>0均引起告警
snprintf(ack, MAX_INNER_MSG_LEN, "overproctime=%d&errmsg=%s", overproctime, errmsg.c_str());
return ret;
}
break;
case CMD_GET_SERVER_VERSION:
{
snprintf(ack, MAX_INNER_MSG_LEN, "ver=%s", SERVER_VERSION);
return ret;
}
break;
case CMD_SYS_LOAD_CONF:
ISGWSighdl::instance()->handle_signal(SIGUSR1);
break;
case CMD_SYS_GET_CONTRL_STAT:
{
ACE_DEBUG((LM_INFO, "[%D] IsgwOperBase start to process CMD_SYS_GET_CONTRL_STAT\n"));
int cmd_no = atoi((*(req.get_map()))["cmd_no"].c_str());
ISGWMgrSvc::freq_obj_->get_statiscs(cmd_no, ack, ack_len);
}
break;
case CMD_SYS_SET_CONTRL_STAT:
{
int cmd_no = atoi((*(req.get_map()))["cmd_no"].c_str());
int status = atoi((*(req.get_map()))["status"].c_str());
ISGWMgrSvc::freq_obj_->set_status(cmd_no, status);
snprintf(ack, ack_len, "info=succ");
}
break;
case CMD_SYS_SET_CONTRL_SWITCH:
{
//运行时设置流量控制功能的开关
//0 关闭，1打开，2只查询开关状态
int flag = atoi((*(req.get_map()))["switch"].c_str());
if(0==flag)
{
ISGWMgrSvc::control_flag_ = 0;
}
else if(1==flag)
{
ISGWMgrSvc::control_flag_ = 1;
}
snprintf(ack, ack_len, "switch=%d&info=succ", ISGWMgrSvc::control_flag_);
}
break;
}
return 0;
}
// Process command line options and arguments
static int
parse_opt (int key, char *arg, struct argp_state *state)
{
int *arg_count = state->input;
switch (key)
{
case 't': //Run the self test suite
{
self_test();
exit(0);
}
case 'p': //Print the generated tree
{
opt_print_tree = 1;
break;
}
case 'l': //Find Longest Common Substring (LCS)
{
opt_lcs = 1;
break;
}
case 'a': //Find Longest Common Substring (LCS)
{
opt_acs = 1;
break;
}
case ARGP_KEY_ARG: //Process the command line arguments
{
(*arg_count)--;
if (*arg_count == 3){
input_text = (unsigned char*)arg;
}
else if (*arg_count == 2){
input_text2 = (unsigned char*)arg;
}
}
break;
case ARGP_KEY_END:
{
printf ("\n");
if (*arg_count >= 4){
argp_failure (state, 1, 0, "too few arguments");
}
else if (*arg_count < 0){
argp_failure (state, 1, 0, "too many arguments");
}
else {
if (opt_print_tree){
// Construct the tree and process based on supplied options
buildSuffixTree(input_text, input_text2, opt_print_tree);
freeSuffixTreeByPostOrder(root);
printf(tree_string, 's');
}
if (opt_lcs){
char *lcs;
if(!input_text2){
argp_failure (state, 1, 0, "missing comparison string");
}
printf("Longest Common Substring in %s and %s is: ",
input_text,
input_text2);
lcs = getLongestCommonSubstring(input_text,
input_text2,
opt_print_tree);
printf(lcs, 's');
}
if (opt_acs){
char *acs;
if(!input_text2){
argp_failure (state, 1, 0, "missing comparison string");
}
printf("All Common Substrings in %s and %s are: ",
input_text,
input_text2);
acs = getAllCommonSubstrings(input_text,
input_text2,
opt_print_tree);
printf(acs, 's');
}
}
}
break;
}
return 0;
}
int
IIS328DQ::ioctl(struct file *filp, int cmd, unsigned long arg)
{
switch (cmd) {
case SENSORIOCSPOLLRATE: {
switch (arg) {
/* switching to manual polling */
case SENSOR_POLLRATE_MANUAL:
stop();
_call_interval = 0;
return OK;
/* external signalling not supported */
case SENSOR_POLLRATE_EXTERNAL:
/* zero would be bad */
case 0:
return -EINVAL;
/* set default/max polling rate */
case SENSOR_POLLRATE_MAX:
case SENSOR_POLLRATE_DEFAULT:
return ioctl(filp, SENSORIOCSPOLLRATE, IIS328DQ_DEFAULT_RATE);
/* adjust to a legal polling interval in Hz */
default: {
/* do we need to start internal polling? */
bool want_start = (_call_interval == 0);
/* convert hz to hrt interval via microseconds */
unsigned ticks = 1000000 / arg;
/* check against maximum sane rate */
if (ticks < 1000)
return -EINVAL;
/* update interval for next measurement */
/* XXX this is a bit shady, but no other way to adjust... */
_call_interval = ticks;
/* adjust filters */
float cutoff_freq_hz = _accel_filter_x.get_cutoff_freq();
float sample_rate = 1.0e6f/ticks;
set_driver_lowpass_filter(sample_rate, cutoff_freq_hz);
/* if we need to start the poll state machine, do it */
if (want_start)
start();
return OK;
}
}
}
case SENSORIOCGPOLLRATE:
if (_call_interval == 0)
return SENSOR_POLLRATE_MANUAL;
return 1000000 / _call_interval;
case SENSORIOCSQUEUEDEPTH: {
/* lower bound is mandatory, upper bound is a sanity check */
if ((arg < 1) || (arg > 100))
return -EINVAL;
irqstate_t flags = irqsave();
if (!ringbuf_resize(_reports, arg)) {
irqrestore(flags);
return -ENOMEM;
}
irqrestore(flags);
return OK;
}
case SENSORIOCGQUEUEDEPTH:
return ringbuf_size(_reports);
case SENSORIOCRESET:
reset();
return OK;
case ACCELIOCSSAMPLERATE:
return set_samplerate(arg, _accel_onchip_filter_bandwidth);
case ACCELIOCGSAMPLERATE:
return _accel_samplerate;
case ACCELIOCSLOWPASS: {
// set the software lowpass cut-off in Hz
float cutoff_freq_hz = arg;
float sample_rate = 1.0e6f / _call_interval;
set_driver_lowpass_filter(sample_rate, cutoff_freq_hz);
return OK;
}
case ACCELIOCGLOWPASS:
return static_cast<int>(_accel_filter_x.get_cutoff_freq());
case ACCELIOCSSCALE:
/* copy scale in */
memcpy(&_accel_scale, (struct accel_scale *) arg, sizeof(_accel_scale));
return OK;
case ACCELIOCGSCALE:
/* copy scale out */
memcpy((struct accel_scale *) arg, &_accel_scale, sizeof(_accel_scale));
return OK;
case ACCELIOCSRANGE:
/* arg should be in dps accel */
return set_range(arg);
case ACCELIOCGRANGE:
/* convert to m/s^2 and return rounded in G */
return (unsigned long)((_accel_range_m_s2)/IIS328DQ_ONE_G + 0.5f);
case ACCELIOCSELFTEST:
return self_test();
case ACCELIOCSHWLOWPASS:
return set_samplerate(_accel_samplerate, arg);
case ACCELIOCGHWLOWPASS:
return _accel_onchip_filter_bandwidth;//set_samplerate函数中赋值
default:
/* give it to the superclass */
return CDev::ioctl(filp, cmd, arg);
}
}
void config_read(void)
{
uint8_t choice=0;
if(read_from_EEPROM(1) != 48)
{
while(1)
{
choice = uart_getchar();
putchar('\n');
putchar('\r');
if(choice=='1')
{
while(!(UCSR0A & (1 << RXC0)))print_adxl345();
config_menu();
}
else if(choice=='2')
{
while(!(UCSR0A & (1 << RXC0)))
{
print_hmc5883();
delay_ms(100);//at least 100ms interval between measurements
}
config_menu();
}
else if(choice=='3')
{
while(!(UCSR0A & (1 << RXC0)))print_itg3200();
config_menu();
}
else if(choice=='4')
{
while(!(UCSR0A & (1 << RXC0)))raw();
config_menu();
}
else if(choice=='5')
{
baud_menu();
config_menu();
}
else if(choice==0x10) //if ctrl-p
{
self_test();
}
else if(choice==0x1A) //if ctrl-z
{
write_to_EEPROM(1,48);
auto_raw();
}
else if(choice==0x3F) //if ?
{
help();
while(!(UCSR0A & (1 << RXC0)));
config_menu();
}
else if(choice==0xFF) config_read();
}
}else auto_raw();
}
/*============================================================================
*
* main() BEGINS HERE
*
*===========================================================================*/
int
main(int argc, char *argv[])
{
val_context_t *context = NULL;
// Parse the command line for a query and resolve+validate it
int c;
char *domain_name = NULL;
const char *args = "c:dF:hi:I:l:m:nw:o:pr:S:st:T:v:V";
int class_h = ns_c_in;
int type_h = ns_t_a;
int success = 0;
int doprint = 0;
int selftest = 0;
int num_threads = 0;
int max_in_flight = 1;
int daemon = 0;
//u_int32_t flags = VAL_QUERY_AC_DETAIL|VAL_QUERY_NO_EDNS0_FALLBACK|VAL_QUERY_SKIP_CACHE;
u_int32_t flags = VAL_QUERY_AC_DETAIL;
u_int32_t nodnssec_flag = 0;
int retvals[] = { 0 };
int tcs = 0, tce = -1;
int wait = 0;
char *label_str = NULL, *nextarg = NULL;
char *suite = NULL, *testcase_config = NULL;
val_log_t *logp;
int rc;
if (argc == 1)
return 0;
while (1) {
#ifdef HAVE_GETOPT_LONG
int opt_index = 0;
#ifdef HAVE_GETOPT_LONG_ONLY
c = getopt_long_only(argc, argv, args, prog_options, &opt_index);
#else
c = getopt_long(argc, argv, args, prog_options, &opt_index);
#endif
#else /* only have getopt */
c = getopt(argc, argv, args);
#endif
if (c == -1) {
break;
}
switch (c) {
case 'h':
usage(argv[0]);
return (-1);
case 'F':
testcase_config = optarg;
break;
case 'd':
daemon = 1;
break;
case 's':
selftest = 1;
if (NULL != suite) {
fprintf(stderr,
"Warning: -s runs all tests.\n"
" ignoring previous suite(s).\n");
suite = NULL; /* == all suites */
}
break;
case 'S':
if (selftest) {
if (NULL == suite)
fprintf(stderr,
"Warning: -s runs all tests.\n"
" ignoring specified suite.\n");
else {
fprintf(stderr,
"Warning: -S may only be specified once.\n"
" ignoring previous suite.\n");
suite = optarg;
}
}
else {
selftest = 1;
suite = optarg;
}
break;
case 'p':
doprint = 1;
break;
case 'n':
nodnssec_flag = 1;
break;
case 'c':
// optarg is a global variable. See man page for getopt_long(3).
class_h = res_nametoclass(optarg, &success);
if (!success) {
fprintf(stderr, "Cannot parse class %s\n", optarg);
usage(argv[0]);
return -1;
}
break;
case 'o':
logp = val_log_add_optarg(optarg, 1);
if (NULL == logp) { /* err msg already logged */
usage(argv[0]);
return -1;
}
break;
case 'I':
#ifndef VAL_NO_ASYNC
max_in_flight = strtol(optarg, &nextarg, 10);
#else
fprintf(stderr, "libval was built without asynchronous support\n");
fprintf(stderr, "ignoring -I parameter\n");
#endif /* ndef VAL_NO_ASYNC */
break;
case 'm':
num_threads = atoi(optarg);
break;
case 'v':
dnsval_conf_set(optarg);
break;
case 'i':
root_hints_set(optarg);
break;
case 'r':
resolv_conf_set(optarg);
break;
case 'w':
wait = strtol(optarg, &nextarg, 10);
break;
case 't':
type_h = res_nametotype(optarg, &success);
if (!success) {
fprintf(stderr, "Cannot parse type %s\n", optarg);
usage(argv[0]);
return -1;
}
break;
case 'T':
tcs = strtol(optarg, &nextarg, 10);
if (*nextarg == '\0')
tce = tcs;
else
tce = atoi(++nextarg);
break;
case 'l':
label_str = optarg;
break;
case 'V':
version();
return 0;
default:
fprintf(stderr, "Unknown option %s (c = %d [%c])\n",
argv[optind - 1], c, (char) c);
usage(argv[0]);
return -1;
} // end switch
}
if (daemon) {
endless_loop();
return 0;
}
#ifndef TEST_NULL_CTX_CREATION
if (VAL_NO_ERROR !=
(rc = val_create_context(label_str, &context))) {
fprintf(stderr, "Cannot create context: %d\n", rc);
return -1;
}
#else
context = NULL;
#endif
/* returned level is 0 based;, > 6 means 7 or higher; e.g. -o 7:stdout */
if (val_log_highest_debug_level() > 6)
res_set_debug_level(val_log_highest_debug_level());
rc = 0;
if (nodnssec_flag) {
val_context_setqflags(context, VAL_CTX_FLAG_SET,
VAL_QUERY_DONT_VALIDATE);
}
// optind is a global variable. See man page for getopt_long(3)
if (optind >= argc) {
if (!selftest && (tcs == -1)) {
fprintf(stderr, "Please specify domain name\n");
usage(argv[0]);
rc = -1;
goto done;
} else {
#ifndef VAL_NO_THREADS
if (num_threads > 0) {
struct thread_params_st
threadparams = {context, tcs, tce, flags, testcase_config,
suite, doprint, wait, max_in_flight};
do_threads(num_threads, &threadparams);
fprintf(stderr, "Parent exiting\n");
} else {
#endif /* VAL_NO_THREADS */
do { /* endless loop */
rc = self_test(context, tcs, tce, flags, testcase_config,
suite, doprint, max_in_flight);
if (wait)
sleep(wait);
} while (wait && !rc);
#ifndef VAL_NO_THREADS
}
#endif /* VAL_NO_THREADS */
}
goto done;
}
domain_name = argv[optind++];
#ifndef VAL_NO_THREADS
if (num_threads > 0) {
struct thread_params_st
threadparams = {context, tcs, tce, flags, testcase_config,
suite, doprint, wait, max_in_flight};
do_threads(num_threads, &threadparams);
} else {
#endif /* VAL_NO_THREADS */
do { /* endless loop */
rc = one_test(context, domain_name, class_h, type_h, flags, retvals,
doprint);
if (wait)
sleep(wait);
} while (wait);
#ifndef VAL_NO_THREADS
}
#endif /* VAL_NO_THREADS */
done:
if (context)
val_free_context(context);
val_free_validator_state();
return rc;
}
int
MPU9250_mag::ioctl(struct file *filp, int cmd, unsigned long arg)
{
switch (cmd) {
case SENSORIOCRESET:
/*
* TODO: we could implement a reset of the AK8963 registers
*/
//return reset();
return _parent->ioctl(filp, cmd, arg);
case SENSORIOCSPOLLRATE: {
switch (arg) {
/* switching to manual polling */
case SENSOR_POLLRATE_MANUAL:
/*
* TODO: investigate being able to stop
* the continuous sampling
*/
//stop();
return OK;
/* external signalling not supported */
case SENSOR_POLLRATE_EXTERNAL:
/* zero would be bad */
case 0:
return -EINVAL;
/* set default/max polling rate */
case SENSOR_POLLRATE_MAX:
return ioctl(filp, SENSORIOCSPOLLRATE, 100);
case SENSOR_POLLRATE_DEFAULT:
return ioctl(filp, SENSORIOCSPOLLRATE, MPU9250_AK8963_SAMPLE_RATE);
/* adjust to a legal polling interval in Hz */
default: {
if (MPU9250_AK8963_SAMPLE_RATE != arg) {
return -EINVAL;
}
return OK;
}
}
}
case SENSORIOCGPOLLRATE:
return MPU9250_AK8963_SAMPLE_RATE;
case SENSORIOCSQUEUEDEPTH: {
/* lower bound is mandatory, upper bound is a sanity check */
if ((arg < 1) || (arg > 100)) {
return -EINVAL;
}
irqstate_t flags = px4_enter_critical_section();
if (!_mag_reports->resize(arg)) {
px4_leave_critical_section(flags);
return -ENOMEM;
}
px4_leave_critical_section(flags);
return OK;
}
case SENSORIOCGQUEUEDEPTH:
return _mag_reports->size();
case MAGIOCGSAMPLERATE:
return MPU9250_AK8963_SAMPLE_RATE;
case MAGIOCSSAMPLERATE:
/*
* We don't currently support any means of changing
* the sampling rate of the mag
*/
if (MPU9250_AK8963_SAMPLE_RATE != arg) {
return -EINVAL;
}
return OK;
case MAGIOCSSCALE:
/* copy scale in */
memcpy(&_mag_scale, (struct mag_scale *) arg, sizeof(_mag_scale));
return OK;
case MAGIOCGSCALE:
/* copy scale out */
memcpy((struct mag_scale *) arg, &_mag_scale, sizeof(_mag_scale));
return OK;
case MAGIOCSRANGE:
return -EINVAL;
case MAGIOCGRANGE:
return 48; // fixed full scale measurement range of +/- 4800 uT == 48 Gauss
case MAGIOCSELFTEST:
return self_test();
#ifdef MAGIOCSHWLOWPASS
case MAGIOCSHWLOWPASS:
return -EINVAL;
#endif
#ifdef MAGIOCGHWLOWPASS
case MAGIOCGHWLOWPASS:
return -EINVAL;
#endif
default:
return (int)CDev::ioctl(filp, cmd, arg);
}
}
int main(void)
{
self_test("../../gcode/test/input");
return 0;
}
