HiToLowBrightnessTrail::HiToLowBrightnessTrail(Color aColor,
int length,
int start,
bool direction)
{
for (int n=0; n<length; n++)
{
// get brightness ratio
float numb = length;
float mb = maxBrightness;
float ratio = n/numb;
float br = ratio * mb;
// determine address of LED based on direction input
int addr = 0;
if (direction) addr = start + n;
else addr = start - n;
addr = checkAddress(addr);
addLEDs(aColor, br, addr, addr);
}
// addStepWithFunction(&MovingFoo::moveLeft,1);
}
static void searchHeapBlocks (HashTable *addrs, bdescr *bd)
{
StgPtr p;
StgInfoTable *info;
nat size;
rtsBool prim;
for (; bd != NULL; bd = bd->link) {
if (bd->flags & BF_PINNED) {
// Assume that objects in PINNED blocks cannot refer to
continue;
}
p = bd->start;
while (p < bd->free) {
info = get_itbl((StgClosure *)p);
prim = rtsFalse;
switch (info->type) {
case THUNK:
size = thunk_sizeW_fromITBL(info);
break;
case THUNK_1_1:
case THUNK_0_2:
case THUNK_2_0:
size = sizeofW(StgThunkHeader) + 2;
break;
case THUNK_1_0:
case THUNK_0_1:
case THUNK_SELECTOR:
size = sizeofW(StgThunkHeader) + 1;
break;
case CONSTR:
case FUN:
case FUN_1_0:
case FUN_0_1:
case FUN_1_1:
case FUN_0_2:
case FUN_2_0:
case CONSTR_1_0:
case CONSTR_0_1:
case CONSTR_1_1:
case CONSTR_0_2:
case CONSTR_2_0:
size = sizeW_fromITBL(info);
break;
case BLACKHOLE:
case BLOCKING_QUEUE:
prim = rtsTrue;
size = sizeW_fromITBL(info);
break;
case IND:
// Special case/Delicate Hack: INDs don't normally
// appear, since we're doing this heap census right
// after GC. However, GarbageCollect() also does
// resurrectThreads(), which can update some
// blackholes when it calls raiseAsync() on the
// resurrected threads. So we know that any IND will
// be the size of a BLACKHOLE.
prim = rtsTrue;
size = BLACKHOLE_sizeW();
break;
case BCO:
prim = rtsTrue;
size = bco_sizeW((StgBCO *)p);
break;
case MVAR_CLEAN:
case MVAR_DIRTY:
case TVAR:
case WEAK:
case PRIM:
case MUT_PRIM:
case MUT_VAR_CLEAN:
case MUT_VAR_DIRTY:
prim = rtsTrue;
size = sizeW_fromITBL(info);
break;
case AP:
prim = rtsTrue;
size = ap_sizeW((StgAP *)p);
break;
case PAP:
prim = rtsTrue;
size = pap_sizeW((StgPAP *)p);
break;
case AP_STACK:
{
StgAP_STACK *ap = (StgAP_STACK *)p;
prim = rtsTrue;
size = ap_stack_sizeW(ap);
searchStackChunk(addrs, (StgPtr)ap->payload,
(StgPtr)ap->payload + ap->size);
break;
}
case ARR_WORDS:
prim = rtsTrue;
size = arr_words_sizeW((StgArrBytes*)p);
break;
case MUT_ARR_PTRS_CLEAN:
case MUT_ARR_PTRS_DIRTY:
case MUT_ARR_PTRS_FROZEN:
case MUT_ARR_PTRS_FROZEN0:
prim = rtsTrue;
size = mut_arr_ptrs_sizeW((StgMutArrPtrs *)p);
break;
case SMALL_MUT_ARR_PTRS_CLEAN:
case SMALL_MUT_ARR_PTRS_DIRTY:
case SMALL_MUT_ARR_PTRS_FROZEN:
case SMALL_MUT_ARR_PTRS_FROZEN0:
prim = rtsTrue;
size = small_mut_arr_ptrs_sizeW((StgSmallMutArrPtrs *)p);
break;
case TSO:
prim = rtsTrue;
size = sizeofW(StgTSO);
break;
case STACK: {
StgStack *stack = (StgStack*)p;
prim = rtsTrue;
searchStackChunk(addrs, stack->sp,
stack->stack + stack->stack_size);
size = stack_sizeW(stack);
break;
}
case TREC_CHUNK:
prim = rtsTrue;
size = sizeofW(StgTRecChunk);
break;
default:
barf("heapCensus, unknown object: %d", info->type);
}
if (!prim) {
checkAddress(addrs,info);
}
p += size;
}
}
}
//
// Check whether we can unload any object code. This is called at the
// appropriate point during a GC, where all the heap data is nice and
// packed together and we have a linked list of the static objects.
//
// The check involves a complete heap traversal, but you only pay for
// this (a) when you have called unloadObj(), and (b) at a major GC,
// which is much more expensive than the traversal we're doing here.
//
void checkUnload (StgClosure *static_objects)
{
nat g, n;
HashTable *addrs;
StgClosure* p;
const StgInfoTable *info;
ObjectCode *oc, *prev, *next;
gen_workspace *ws;
StgClosure* link;
if (unloaded_objects == NULL) return;
ACQUIRE_LOCK(&linker_unloaded_mutex);
// Mark every unloadable object as unreferenced initially
for (oc = unloaded_objects; oc; oc = oc->next) {
IF_DEBUG(linker, debugBelch("Checking whether to unload %" PATH_FMT "\n",
oc->fileName));
oc->referenced = rtsFalse;
}
addrs = allocHashTable();
for (p = static_objects; p != END_OF_STATIC_OBJECT_LIST; p = link) {
p = UNTAG_STATIC_LIST_PTR(p);
checkAddress(addrs, p);
info = get_itbl(p);
link = *STATIC_LINK(info, p);
}
// CAFs on revertible_caf_list are not on static_objects
for (p = (StgClosure*)revertible_caf_list;
p != END_OF_CAF_LIST;
p = ((StgIndStatic *)p)->static_link) {
p = UNTAG_STATIC_LIST_PTR(p);
checkAddress(addrs, p);
}
for (g = 0; g < RtsFlags.GcFlags.generations; g++) {
searchHeapBlocks (addrs, generations[g].blocks);
searchHeapBlocks (addrs, generations[g].large_objects);
for (n = 0; n < n_capabilities; n++) {
ws = &gc_threads[n]->gens[g];
searchHeapBlocks(addrs, ws->todo_bd);
searchHeapBlocks(addrs, ws->part_list);
searchHeapBlocks(addrs, ws->scavd_list);
}
}
#ifdef PROFILING
/* Traverse the cost centre tree, calling checkAddress on each CCS/CC */
searchCostCentres(addrs, CCS_MAIN);
/* Also check each cost centre in the CC_LIST */
CostCentre *cc;
for (cc = CC_LIST; cc != NULL; cc = cc->link) {
checkAddress(addrs, cc);
}
#endif /* PROFILING */
// Look through the unloadable objects, and any object that is still
// marked as unreferenced can be physically unloaded, because we
// have no references to it.
prev = NULL;
for (oc = unloaded_objects; oc; oc = next) {
next = oc->next;
if (oc->referenced == 0) {
if (prev == NULL) {
unloaded_objects = oc->next;
} else {
prev->next = oc->next;
}
IF_DEBUG(linker, debugBelch("Unloading object file %" PATH_FMT "\n",
oc->fileName));
freeObjectCode(oc);
} else {
IF_DEBUG(linker, debugBelch("Object file still in use: %"
PATH_FMT "\n", oc->fileName));
prev = oc;
}
}
freeHashTable(addrs, NULL);
RELEASE_LOCK(&linker_unloaded_mutex);
}
//
// Check whether we can unload any object code. This is called at the
// appropriate point during a GC, where all the heap data is nice and
// packed together and we have a linked list of the static objects.
//
// The check involves a complete heap traversal, but you only pay for
// this (a) when you have called unloadObj(), and (b) at a major GC,
// which is much more expensive than the traversal we're doing here.
//
void checkUnload (StgClosure *static_objects)
{
nat g, n;
HashTable *addrs;
StgClosure* p;
const StgInfoTable *info;
ObjectCode *oc, *prev, *next;
gen_workspace *ws;
StgClosure* link;
if (unloaded_objects == NULL) return;
// Mark every unloadable object as unreferenced initially
for (oc = unloaded_objects; oc; oc = oc->next) {
IF_DEBUG(linker, debugBelch("Checking whether to unload %" PATH_FMT "\n",
oc->fileName));
oc->referenced = rtsFalse;
}
addrs = allocHashTable();
for (p = static_objects; p != END_OF_STATIC_LIST; p = link) {
checkAddress(addrs, p);
info = get_itbl(p);
link = *STATIC_LINK(info, p);
}
for (g = 0; g < RtsFlags.GcFlags.generations; g++) {
searchHeapBlocks (addrs, generations[g].blocks);
searchHeapBlocks (addrs, generations[g].large_objects);
for (n = 0; n < n_capabilities; n++) {
ws = &gc_threads[n]->gens[g];
searchHeapBlocks(addrs, ws->todo_bd);
searchHeapBlocks(addrs, ws->part_list);
searchHeapBlocks(addrs, ws->scavd_list);
}
}
// Look through the unloadable objects, and any object that is still
// marked as unreferenced can be physically unloaded, because we
// have no references to it.
prev = NULL;
for (oc = unloaded_objects; oc; prev = oc, oc = next) {
next = oc->next;
if (oc->referenced == 0) {
if (prev == NULL) {
unloaded_objects = oc->next;
} else {
prev->next = oc->next;
}
IF_DEBUG(linker, debugBelch("Unloading object file %" PATH_FMT "\n",
oc->fileName));
freeObjectCode(oc);
} else {
IF_DEBUG(linker, debugBelch("Object file still in use: %"
PATH_FMT "\n", oc->fileName));
}
}
freeHashTable(addrs, NULL);
}
void test_CorrectAddressWorks(void)
{
checkAddress(address);
TEST_ASSERT_EQUAL_HEX8(1<<PORT_I2C_SDA,DDR_I2C & (1<<PORT_I2C_SDA));
}
void test_GlobalAddressWorks(void)
{
checkAddress(0);
TEST_ASSERT_EQUAL_HEX8(1<<PORT_I2C_SDA,DDR_I2C & (1<<PORT_I2C_SDA));
}
void test_InCorrectAddressDoesNotWork(void)
{
checkAddress(address+1);
TEST_ASSERT_EQUAL_HEX8(0,DDR_I2C & (1<<PORT_I2C_SDA));
}
/*------------------------------------------------------------------------------
* Purpose: Initialize the default login control configuration.
* Input: none
* Output: returns 0 on success, 1 on failure
* Kevin Burnett @ November 18, 2008
* ---------------------------------------------------------------------------*/
int
initLoginControlSettings(char *config_file, char* scratchDir, int recoveryPort) {
int err = 0;
// zero out all LoginSettings values
memset(&LoginSettings, 0x00, sizeof(LoginSettings));
// set the configuration file location
memcpy(LoginSettings.configFile, config_file, FILENAME_MAX_CHARS);
// set the configuration file location
memcpy(LoginSettings.scratchDir, scratchDir, FILENAME_MAX_CHARS);
// address used to listen for cli connections
int result = checkAddress(DEFAULT_LOGIN_LISTEN_ADDR, ADDR_PASSIVE);
if(result != ADDR_VALID)
{
err = 1;
strncpy(LoginSettings.listenAddr, IPv4_LOOPBACK, ADDR_MAX_CHARS);
}
else
strncpy(LoginSettings.listenAddr, DEFAULT_LOGIN_LISTEN_ADDR, ADDR_MAX_CHARS);
// set the port for Login
if(recoveryPort>0) {
// set to recovery mode if port is greater than 0
LoginSettings.recoveryMode = TRUE;
LoginSettings.listenPort = recoveryPort;
}
else {
// set port
LoginSettings.recoveryMode = FALSE;
LoginSettings.listenPort = DEFAULT_LOGIN_PORT;
}
// make sure port is valid otherwise default to 50000
if ( (LoginSettings.listenPort < 1) ||
(LoginSettings.listenPort > 65536) ) {
err = 1;
log_warning("Invalid site default for login listen port.");
LoginSettings.listenPort = 50000;
}
// Maximum number of cli connections allowed
if (MAX_CLI_IDS < 0) {
err = 1;
log_warning("Invalid site default for max allowed cli connections.");
LoginSettings.maxConnections = 1;
} else {
LoginSettings.maxConnections = MAX_CLI_IDS;
}
// initial bookkeeping figures
LoginSettings.activeConnections = 0;
LoginSettings.enableModeActive = FALSE;
LoginSettings.lastAction = time(NULL);
LoginSettings.firstNode = NULL;
// initialize the passwords
memcpy(LoginSettings.accessPassword, DEFAULT_ACCESS_PASSWORD,
sizeof(DEFAULT_ACCESS_PASSWORD));
memcpy(LoginSettings.enablePassword, DEFAULT_ENABLE_PASSWORD,
sizeof(DEFAULT_ENABLE_PASSWORD));
// create a lock for the login list
if (pthread_mutex_init(&LoginSettings.loginLock, NULL) )
log_fatal("unable to init mutex lock for login");
// setup the command tree structure
LoginSettings.rootCommandNode = malloc(sizeof(commandNode));
if(LoginSettings.rootCommandNode==NULL) {
log_err("Failed to create command tree structure.");
free(LoginSettings.rootCommandNode);
return 1;
}
memset(LoginSettings.rootCommandNode, 0, sizeof(commandNode));
// initialize the commands in the tree
initCommandTree(LoginSettings.rootCommandNode);
return err;
}
/*--------------------------------------------------------------------------------------
* Purpose: Read the login control settings from the config file.
* Input: none
* Output: returns 0 on success, 1 on failure
* Kevin Burnett @ November 18, 2008
* -------------------------------------------------------------------------------------*/
int readLoginControlSettings() {
int err = 0;
int result = 0;
int num = 0;
char * addr = NULL;
char * temp = NULL;
// get listen addr and port only if we are not in recovery mode
if(!LoginSettings.recoveryMode){
result = getConfigValueAsAddr(&addr, XML_LOGIN_ADDRESS_PATH, ADDR_PASSIVE);
if (result == CONFIG_VALID_ENTRY){
result = checkAddress(addr, ADDR_PASSIVE);
if(result != ADDR_VALID){
err = 1;
log_warning("Invalid configuration of login listen address.");
} else {
strncpy(LoginSettings.listenAddr, addr, ADDR_MAX_CHARS);
}
free(addr);
}else if ( result == CONFIG_INVALID_ENTRY ){
err = 1;
log_warning("Invalid configuration of login listen address.");
}else{
log_msg("No configuration of login listen address, using default.");
}
#ifdef DEBUG
debug(__FUNCTION__, "Login Control Addr:%s", LoginSettings.listenAddr);
#endif
// get listen port
result = getConfigValueAsInt(&num, XML_LOGIN_PORT_PATH, 1, 65536);
if (result == CONFIG_VALID_ENTRY) {
LoginSettings.listenPort = num;
}else if( result == CONFIG_INVALID_ENTRY ){
err = 1;
log_warning("Invalid configuration of login listen port.");
} else{
log_msg("No configuration of login listen port, using default.");
}
#ifdef DEBUG
debug(__FUNCTION__, "Login listen port set to %d", LoginSettings.listenPort);
#endif
}
// get ACCESS_PASSWORD value
if(getConfigValueAsString(&temp, XML_LOGIN_ACCESS_PASSWORD_PATH, PASSWORD_MAX_CHARS )) {
log_warning("Invalid configuration of Login access password, default value used.");
}
else {
memcpy(LoginSettings.accessPassword, temp, strlen(temp) + 1);
free(temp);
}
// get ENABLE_PASSWORD value
if(getConfigValueAsString(&temp, XML_LOGIN_ENABLE_PASSWORD_PATH, PASSWORD_MAX_CHARS)) {
log_warning("Invalid configuration of Login enable password, default value used.");
}
else {
memcpy(LoginSettings.enablePassword, temp, strlen(temp) + 1);
free(temp);
}
// get the cli ACL
AccessControlList * acl = NULL;
#ifdef DEBUG
char * aclName = NULL;
#endif
result = getConfigValueAsString(&temp, XML_LOGIN_CLI_ACL_PATH, PASSWORD_MAX_CHARS);
if(result==0) {
acl = getACL(temp);
if(acl!=NULL) {
LoginSettings.cliAcl = acl;
#ifdef DEBUG
aclName = acl->name;
#endif
}
free(temp);
}
#ifdef DEBUG
debug(__FUNCTION__, "Command Line Interface Access Control List set to [%s]", aclName);
#endif
// get the client update ACL
acl = NULL;
#ifdef DEBUG
aclName = NULL;
#endif
result = getConfigValueAsString(&temp, XML_LOGIN_CLIENT_UPDATE_ACL_PATH, PASSWORD_MAX_CHARS);
if(result==0) {
acl = getACL(temp);
if(acl!=NULL) {
LoginSettings.clientUpdateAcl = acl;
#ifdef DEBUG
aclName = acl->name;
#endif
}
free(temp);
}
#ifdef DEBUG
debug(__FUNCTION__, "Client Update's Access Control List set to [%s]", aclName);
#endif
// get the client rib ACL
acl = NULL;
#ifdef DEBUG
aclName = NULL;
#endif
result = getConfigValueAsString(&temp, XML_LOGIN_CLIENT_RIB_ACL_PATH, PASSWORD_MAX_CHARS);
if(result==0) {
acl = getACL(temp);
if(acl!=NULL) {
LoginSettings.clientRIBAcl = acl;
#ifdef DEBUG
aclName = acl->name;
#endif
}
free(temp);
}
#ifdef DEBUG
debug(__FUNCTION__, "Client RIB's Access Control List set to [%s]", aclName);
#endif
// get the mrt ACL
acl = NULL;
#ifdef DEBUG
aclName = NULL;
#endif
result = getConfigValueAsString(&temp, XML_LOGIN_MRT_ACL_PATH, PASSWORD_MAX_CHARS);
if(result==0) {
acl = getACL(temp);
if(acl!=NULL) {
LoginSettings.mrtAcl = acl;
#ifdef DEBUG
aclName = acl->name;
#endif
}
free(temp);
}
#ifdef DEBUG
debug(__FUNCTION__, "Mrt's Access Control List set to [%s]", aclName);
#endif
return err;
}
/// Process data received by UART
///
void simpleBinary::processSerial()
{
while (serial->available() > 0)
{
int data = serial->read();
serbuf[serbuflen++] = data;
}
if(serbuflen > 3)
{
receiveTime = millis();
if(serbuf[0] == _uartAddress)
{
int address;
char crc;
switch(serbuf[1])
{
//new data
case (char)0xD0:
if(serbuf[2] == 0x01)
{
//force all output data as new through user function
forceAllNewData();
}
if(serbuf[2] == 0x00 || serbuf[2] == 0x01)
{
crc = CRC8::evalCRC(serbuf,3);
if(crc != serbuf[3])
sendWrongData(crc);
else
checkNewData();
}
else
sendUnknownData();
serbuflen = 0;
break;
//read data
case (char)0xD1:
if(serbuflen < 5)
break;
address = serbuf[2] | (serbuf[3] << 8);
crc = CRC8::evalCRC(serbuf,4);
if(crc != serbuf[4])
sendWrongData(crc);
else
readData(address);
serbuflen = 0;
break;
//write byte
case (char)0xDA:
if(serbuflen < 6)
break;
//address
address = serbuf[2] | (serbuf[3] << 8);
//crc check
crc = CRC8::evalCRC(serbuf,5);
if(serbuf[5] != crc)
sendWrongData(crc);
else
{
//check address
if(!checkAddress(address))
sendInvalidAddress();
//write data into memory
if(saveByte(address,serbuf+4))
sendOK();
else
sendSavingError();
}
//clear buffer
serbuflen = 0;
break;
//write word
case (char)0xDB:
if(serbuflen < 7)
break;
//address
address = serbuf[2] | (serbuf[3] << 8);
//crc check
crc = CRC8::evalCRC(serbuf,6);
if(serbuf[6] != crc)
sendWrongData(crc);
else
{
//check address
if(!checkAddress(address))
sendInvalidAddress();
//write data into memory
if(saveWord(address,serbuf+4))
sendOK();
else
sendSavingError();
}
//clear buffer
serbuflen = 0;
break;
//write dword
case (char)0xDC:
case (char)0xDD:
if(serbuflen < 9)
break;
//address
address = serbuf[2] | (serbuf[3] << 8);
//crc check
crc = CRC8::evalCRC(serbuf,8);
if(serbuf[8] != crc)
sendWrongData(crc);
else
{
//check address
if(!checkAddress(address))
sendInvalidAddress();
//write data into memory
if(saveDword(address,serbuf+4))
sendOK();
else
sendSavingError();
}
//clear buffer
serbuflen = 0;
break;
//write array
case (char)0xDE:
if(serbuflen < 6)
break;
int datalen;
datalen = (serbuf[4] | (serbuf[5] << 8));
//correct packet length check
if(serbuflen < 7 + datalen)
break;
//address
address = serbuf[2] | (serbuf[3] << 8);
//crc check
crc = CRC8::evalCRC(serbuf,6+datalen);
if(serbuf[7+datalen] != crc)
sendWrongData(crc);
else
{
//check address
if(!checkAddress(address))
sendInvalidAddress();
char *pData = serbuf + 6;
//write data into memory
if(saveArray(address,pData, datalen))
sendOK();
else
sendSavingError();
}
//clear buffer
serbuflen = 0;
break;
default:
serbuflen = 0;
sendUnknownData();
break;
}
}
else
{
serbuflen = 0;
return;
}
}
}
