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; } } }