void blink(uint8_t times)
{
while(times--)
{
nrf_gpio_pin_set(CONFIG_LED_PIN);
timer_wait(MILLISECONDS(10));
nrf_gpio_pin_clear(CONFIG_LED_PIN);
timer_wait(MILLISECONDS(490));
}
}
signed ReadMME (struct plc * plc, uint8_t MMV, uint16_t MMTYPE)
{
struct channel * channel = (struct channel *)(plc->channel);
struct message * message = (struct message *)(plc->message);
struct timeval ts;
struct timeval tc;
if (gettimeofday (&ts, NULL) == -1)
{
error (1, errno, CANT_START_TIMER);
}
while ((plc->packetsize = readpacket (channel, message, sizeof (* message))) >= 0)
{
if (UnwantedMessage (message, plc->packetsize, MMV, MMTYPE))
{
if (gettimeofday (&tc, NULL) == -1)
{
error (1, errno, CANT_RESET_TIMER);
}
if (channel->timeout < 0)
{
continue;
}
if (channel->timeout > MILLISECONDS (ts, tc))
{
continue;
}
plc->packetsize = 0;
}
break;
}
return (plc->packetsize);
}
uint16_t acc_magnitude(int8_t* angle)
{
int16_t acc[3], a, alpha;
/* briefly turn on accelerometer */
acc_write(ACC_REG_CTRL_REG1, 0x97);
timer_wait(MILLISECONDS(2));
acc_read(ACC_REG_OUT_X, sizeof(acc), (uint8_t*)&acc);
acc_write(ACC_REG_CTRL_REG1, 0x00);
/* get acceleration vector magnitude */
a = sqrt32(
((int)acc[0])*acc[0] +
((int)acc[1])*acc[1] +
((int)acc[2])*acc[2]
)/64;
/* calculate tag angle */
if(angle)
{
if(!a)
alpha = 127;
else
{
alpha = (acc[2]*2)/a;
if(alpha>127)
alpha=127;
else
if(alpha<-127)
alpha=-127;
}
*angle = asin7deg(alpha);
}
return a;
}
static
VOID
NTAPI
DriverUnload(
__in PDRIVER_OBJECT DriverObject
)
{
LARGE_INTEGER Interval = {0};
if (g_ServerSocket != NULL) {
CloseSocket(g_ServerSocket);
g_ServerSocket = NULL;
}
// Shut down ServerThread() thread
KeWaitForSingleObject(g_ServerThread, Executive, KernelMode, FALSE, NULL);
ObDereferenceObject(g_ServerThread);
// Wait for the clients' threads
Interval.QuadPart = RELATIVE(MILLISECONDS(100));
while (g_ClientsCount)
KeDelayExecutionThread(KernelMode, FALSE, &Interval);
SocketsDeinit();
}
void RTC0_IRQ_Handler(void)
{
/* run every two seconds */
if(NRF_RTC0->EVENTS_COMPARE[0])
{
/* acknowledge event */
NRF_RTC0->EVENTS_COMPARE[0] = 0;
/* re-trigger timer */
NRF_RTC0->CC[0]+= MILLISECONDS(330);
/* switch to next bluetooth channel */
radio_switch_channel();
}
}
static VOID NTAPI ScanWindowsThread(PVOID Param)
{
LARGE_INTEGER Interval;
Interval.QuadPart=RELATIVE(MILLISECONDS(10));
while (STATUS_TIMEOUT==KeWaitForSingleObject(
&g_ShutdownEvent,
Executive,
KernelMode,
FALSE,
&Interval)) {
PrintData();
}
DbgPrint("ScanWindowsThread(): Shutting down\n");
PsTerminateSystemThread(STATUS_SUCCESS);
}
signed evse_cm_mnbc_sound (struct session * session, struct channel * channel, struct message * message)
{
struct timeval ts;
struct timeval tc;
signed timer = 100 * session->TIME_OUT;
unsigned AAG [SLAC_GROUPS];
unsigned sounds = 0;
ssize_t length;
session->sounds = 0;
memset (AAG, 0, sizeof (AAG));
memset (session->AAG, 0, sizeof (session->AAG));
if (gettimeofday (& ts, NULL) == - 1)
{
slac_debug (session, 1, __func__, CANT_START_TIMER);
}
while ((length = readpacket (channel, message, sizeof (* message))) >= 0)
{
struct homeplug * homeplug = (struct homeplug *) (message);
if (! length)
{
}
else if (ntohs (homeplug->ethernet.MTYPE) != ETH_P_HPAV)
{
slac_debug (session, session->exit, __func__, "bad MTYPE");
}
else if (homeplug->homeplug.MMV != HOMEPLUG_MMV)
{
slac_debug (session, session->exit, __func__, "bad MMV");
}
else if (LE16TOH (homeplug->homeplug.MMTYPE) == (CM_MNBC_SOUND | MMTYPE_IND))
{
struct cm_mnbc_sound_indicate * indicate = (struct cm_mnbc_sound_indicate *) (message);
if (! memcmp (session->RunID, indicate->MSVarField.RunID, sizeof (session->RunID)))
{
slac_debug (session, 0, __func__, "<-- CM_MNBC_SOUND.IND (%d)", sounds);
#if SLAC_DEBUG
if (_anyset (session->flags, SLAC_VERBOSE))
{
char string [256];
slac_debug (session, 0, __func__, "CM_MNBC_SOUND.IND.APPLICATION_TYPE %d", indicate->APPLICATION_TYPE);
slac_debug (session, 0, __func__, "CM_MNBC_SOUND.IND.SECURITY_TYPE %d", indicate->SECURITY_TYPE);
slac_debug (session, 0, __func__, "CM_MNBC_SOUND.IND.MSVarField.SenderID %s", HEXSTRING (string, indicate->MSVarField.SenderID));
slac_debug (session, 0, __func__, "CM_MNBC_SOUND.IND.MSVarField.Count %d", indicate->MSVarField.CNT);
slac_debug (session, 0, __func__, "CM_MNBC_SOUND.IND.MSVarField.RunID %s", HEXSTRING (string, indicate->MSVarField.RunID));
slac_debug (session, 0, __func__, "CM_MNBC_SOUND.IND.MSVarField.RND %s", HEXSTRING (string, indicate->MSVarField.RND));
}
#endif
if (memcmp (session->PEV_MAC, indicate->ethernet.OSA, sizeof (session->PEV_MAC)))
{
slac_debug (session, session->exit, __func__, "Unexpected OSA");
}
sounds++;
}
}
else if (LE16TOH (homeplug->homeplug.MMTYPE) == (CM_ATTEN_PROFILE | MMTYPE_IND))
{
struct cm_atten_profile_indicate * indicate = (struct cm_atten_profile_indicate *) (message);
if (! memcmp (session->PEV_MAC, indicate->PEV_MAC, sizeof (session->PEV_MAC)))
{
slac_debug (session, 0, __func__, "<-- CM_ATTEN_PROFILE.IND (%d)", session->sounds);
#if SLAC_DEBUG
if (_anyset (session->flags, SLAC_VERBOSE))
{
char string [256];
slac_debug (session, 0, __func__, "CM_ATTEN_PROFILE.PEV_MAC %s", HEXSTRING (string, indicate->PEV_MAC));
slac_debug (session, 0, __func__, "CM_ATTEN_PROFILE.NumGroups %d", indicate->NumGroups);
slac_debug (session, 0, __func__, "CM_ATTEN_PROFILE.AAG %s", hexstring (string, sizeof (string), indicate->AAG, indicate->NumGroups));
}
#endif
for (session->NumGroups = 0; session->NumGroups < indicate->NumGroups; session->NumGroups++)
{
AAG [session->NumGroups] += indicate->AAG [session->NumGroups];
}
session->NumGroups = indicate->NumGroups;
session->sounds++;
}
}
if (gettimeofday (& tc, NULL) == - 1)
{
slac_debug (session, 1, __func__, CANT_RESET_TIMER);
}
if ((MILLISECONDS (ts, tc) < timer) && (session->sounds < session->NUM_SOUNDS))
{
continue;
}
if (session->sounds > 0)
{
for (session->NumGroups = 0; session->NumGroups < SLAC_GROUPS; ++ session->NumGroups)
{
session->AAG [session->NumGroups] = AAG [session->NumGroups] / session->sounds;
}
}
return (0);
}
return (slac_debug (session, session->exit, __func__, "Sound timeout"));
}
FD_ZERO(&exceptfds);
FD_SET(fd, &writefds);
FD_SET(fd, &exceptfds);
stat = select (width, NULL, &writefds, &exceptfds, &to);
if (stat > 0 && (FD_ISSET(fd, &writefds) || FD_ISSET(fd, &exceptfds)))
return 1;
else
return 0;
}
static void internal_read_wait (int fd, int auxfd, ilu_boolean *sure, ilu_FineTime *limit,
ILU_ERRS((interrupt)) * err)
{
if (read_fn != NULL)
*sure = FixnumToInt((*read_fn)(fd, (limit == NULL) ? 0
: MILLISECONDS(limit)));
else
*sure = 0;
ILU_CLER(*err);
}
static void internal_write_wait (int fd, int auxfd, ilu_boolean *sure, ilu_FineTime *limit,
ILU_ERRS((interrupt)) * err)
{
if (ilufranz_OutputPossibleP(fd))
{
*sure = 1;
}
else
{
if (write_fn != NULL)
void main_entry(void)
{
uint8_t blink;
uint32_t tag_id;
/* enabled LED output */
nrf_gpio_cfg_output(CONFIG_LED_PIN);
nrf_gpio_pin_set(CONFIG_LED_PIN);
/* enabled input pin */
nrf_gpio_cfg_input(CONFIG_SWITCH_PIN, NRF_GPIO_PIN_NOPULL);
/* initialize UART */
uart_init();
/* start timer */
timer_init();
/* initialize flash */
if(flash_init())
halt(2);
/* initialize accelerometer */
if(acc_init())
halt(3);
/* calculate tag ID from NRF_FICR->DEVICEID */
tag_id = crc32(&NRF_FICR->DEVICEID, sizeof(NRF_FICR->DEVICEID));
#ifdef MARKER_TAG
tag_id |= MARKER_TAG_BIT;
#else /*MARKER_TAG*/
tag_id &= MARKER_TAG_BIT-1;
#endif/*MARKER_TAG*/
/* start radio */
debug_printf("\n\rInitializing Tag[%08X] v" PROGRAM_VERSION " @24%02iMHz ...\n\r",
tag_id,
CONFIG_TRACKER_CHANNEL);
radio_init(tag_id);
/* enter main loop */
blink = 0;
nrf_gpio_pin_clear(CONFIG_LED_PIN);
while(TRUE)
{
/* get tag angle once per second */
acc_magnitude(&g_tag_angle);
timer_wait(MILLISECONDS(1000));
/* blink every 5 seconds */
if(blink<5)
blink++;
else
{
blink = 0;
nrf_gpio_pin_set(CONFIG_LED_PIN);
timer_wait(MILLISECONDS(1));
nrf_gpio_pin_clear(CONFIG_LED_PIN);
}
}
}
/*! .
\param [in]
\param [out]
\param [in,out]
\pre
\post
\return
*/
void
TimerThreadExecRoutine(
__in PVOID StartContext
)
{
UNREFERENCED_PARAMETER(StartContext);
DBGPRINT("[flmonflt] Starting timer thread.\n");
DriverInfoData->TimerDueTime.QuadPart = RELATIVE(MILLISECONDS(TIMER_THREAD_LIST_TIMEOUT_MS));
while(!TimerThreadStopExec)
{
// wait for event, thread will sleep until its set.
KeWaitForSingleObject(DriverInfoData->TimerThreadSleepWakeup,
Executive, KernelMode, FALSE, NULL);
if (TimerThreadStopExec)
{
DBGPRINT("[flmonflt] Terminating timer thread with TimerThreadSleepWakeup.\n");
break;
}
DBGPRINT("[flmonflt] Waiting for timer to elapse.\n");
//DriverInfoData->TrackerLastEntryValid = FALSE;
KeSetTimer(DriverInfoData->Timer, DriverInfoData->TimerDueTime, NULL);
KeWaitForSingleObject(DriverInfoData->Timer, Executive, KernelMode, FALSE, NULL);
DBGPRINT("[flmonflt] Timer elapsed.\n");
FlTrackerSetLastEntry(DriverInfoData);
//DriverInfoData->TrackerLastEntryValid = TRUE;
DBGPRINT("[flmonflt] *************** Timer elapsed. ***************\n");
FlTrackerEntryPrint(FlTrackerGetBestEntry(DriverInfoData->Tracker));
DBGPRINT("[flmonflt] **********************************************\n");
FlTrackerPrintListDbg(DriverInfoData->Tracker);
DBGPRINT("[flmonflt] ----------------------------------------------\n");
FlTrackerInfoToUserspace(DriverInfoData, TRUE);
FlTrackerClean(DriverInfoData->Tracker);
// clear event to nonsignaled
KeClearEvent(DriverInfoData->TimerThreadSleepWakeup);
}
DBGPRINT_ARG1("[flmonflt] Terminating timer thread, Stop=%d.\n", TimerThreadStopExec);
PsTerminateSystemThread(STATUS_SUCCESS);
}
