void TEST_LightMCU() { char rx[10]; unsigned int i, r, g, b, final; while (1) { uprint("l to loop, other for special"); rx[0] = uart1Rx(); if (rx[0] == 'l') { for (i = 0; i < 192; i ++) { uprint_int("Sending ", i); sendLightMCU(i); DELAY_MS(50); } } else { uprint("Enter r 0-4: "); uart1_gets(rx, 10); r = atoi(rx); uprint("Enter g 0-4: "); uart1_gets(rx, 10); g = atoi(rx); uprint("Enter b 0-4: "); uart1_gets(rx, 10); b = atoi(rx); final = 0b11000000 + (r << 4) + (g << 2) + b; uprint_int("Sending ", final); sendLightMCU(final); } }
int main(void) { struct video *driver_implem; uprint("Video: Launching driver"); if (!(driver_implem = malloc(sizeof (struct video)))) { uprint("Video: Out of memory"); return 1; } if (video_initialize(driver_implem) < 0) { free(driver_implem); return 1; } driver_implem->opened = 0; uprint("Video: Initialization successful"); return video_driver_run(driver_implem); }
void TEST_RadioSend() { char rx[2]; while (1) { uprint("Enter character to send: "); uart1_gets(rx, 1); radioSendMessage(rx, 0x0A00); uprint("Sent message!"); } }
void TEST_RadioReceive() { char rx[2]; while (1) { uprint("Wating for message ..."); radioGetMessage(rx, 1); uprint("Got message: "); uprint(rx); } }
static SDev* aoeprobe(char *path, SDev *s) { int n, i; char *p; Chan *c; Ctlr *ctlr; if((p = strrchr(path, '/')) == 0) error(Ebadarg); *p = 0; uprint("%s/ctl", path); *p = '/'; c = namec(up->genbuf, Aopen, OWRITE, 0); if(waserror()) { cclose(c); nexterror(); } n = uprint("discover %s", p+1); devtab[c->type]->write(c, up->genbuf, n, 0); poperror(); cclose(c); for(i = 0;; i += Probeintvl) { if(i > Probemax || waserror()) error(Etimedout); tsleep(&up->sleep, return0, 0, Probeintvl); poperror(); uprint("%s/ident", path); if(waserror()) continue; c = namec(up->genbuf, Aopen, OREAD, 0); poperror(); cclose(c); ctlr = newctlr(path); break; } if(s == nil && (s = malloc(sizeof *s)) == nil) return nil; s->ctlr = ctlr; s->ifc = &sdaoeifc; s->nunit = 1; return s; }
void set_coordi(void) { uint8 logicalType; osal_nv_item_init( ZCD_NV_LOGICAL_TYPE, sizeof(logicalType), &logicalType ); logicalType = ZG_DEVICETYPE_COORDINATOR; if( osal_nv_write( ZCD_NV_LOGICAL_TYPE, 0 ,sizeof(logicalType), &logicalType) != ZSUCCESS) { uprint("set device to coordi failed"); }else { zgWriteStartupOptions (ZG_STARTUP_SET, ZCD_STARTOPT_DEFAULT_NETWORK_STATE); uprint("set device to coordi,restart it"); } return; }
struct fp_ext * fp_fsincos7(struct fp_ext *dest, struct fp_ext *src) { uprint("fsincos7\n"); return dest; }
/* Format the date */ static void date(const UChar *tz, UDateFormatStyle style, char *format, UErrorCode *status) { UChar *s = 0; int32_t len = 0; UDateFormat *fmt; UChar uFormat[100]; fmt = udat_open(style, style, 0, tz, -1,NULL,0, status); if ( format != NULL ) { u_charsToUChars(format,uFormat,strlen(format)), udat_applyPattern(fmt,FALSE,uFormat,strlen(format)); } len = udat_format(fmt, ucal_getNow(), 0, len, 0, status); if(*status == U_BUFFER_OVERFLOW_ERROR) { *status = U_ZERO_ERROR; s = (UChar*) malloc(sizeof(UChar) * (len+1)); if(s == 0) goto finish; udat_format(fmt, ucal_getNow(), s, len + 1, 0, status); if(U_FAILURE(*status)) goto finish; } /* print the date string */ uprint(s, stdout, status); /* print a trailing newline */ printf("\n"); finish: udat_close(fmt); free(s); }
/* Version information */ static void version() { UErrorCode status = U_ZERO_ERROR; const char *tzVer; int len = 256; UChar tzName[256]; printf("icudate version %s, created by Stephen F. Booth.\n", DATE_VERSION); puts(U_COPYRIGHT_STRING); tzVer = ucal_getTZDataVersion(&status); if(U_FAILURE(status)) { tzVer = u_errorName(status); } printf("\n"); printf("ICU Version: %s\n", U_ICU_VERSION); printf("ICU Data (major+min): %s\n", U_ICUDATA_NAME); printf("Default Locale: %s\n", uloc_getDefault()); printf("Time Zone Data Version: %s\n", tzVer); printf("Default Time Zone: "); status = U_ZERO_ERROR; u_init(&status); len = ucal_getDefaultTimeZone(tzName, len, &status); if(U_FAILURE(status)) { printf(" ** Error getting default zone: %s\n", u_errorName(status)); } uprint(tzName, stdout, &status); printf("\n\n"); }
static int identify(Ctlr *c, ushort *id) { uchar oserial[21]; vlong osectors, s; osectors = c->sectors; memmove(oserial, c->serial, sizeof c->serial); s = idfeat(c, id); if(s == -1) { uprint("%s: identify fails", c->unit->name); print("%s\n", up->genbuf); error(up->genbuf); } idmove(c->serial, id+10, 20); idmove(c->firmware, id+23, 8); idmove(c->model, id+27, 40); if((osectors == 0 || osectors != s) && memcmp(oserial, c->serial, sizeof oserial) != 0) { c->sectors = s; c->drivechange = 1; c->vers++; } return 0; }
/* must call with d qlocked */ static int aoeidentify(Ctlr *d, SDunit *u) { Chan *c; c = nil; if(waserror()){ if(c) cclose(c); iprint("aoeidentify: %s\n", up->errstr); nexterror(); } uprint("%s/ident", d->path); c = namec(up->genbuf, Aopen, OREAD, 0); devtab[c->type]->read(c, d->ident, sizeof d->ident, 0); poperror(); cclose(c); d->feat = 0; d->smart = 0; identify(d, (ushort*)d->ident); memset(u->inquiry, 0, sizeof u->inquiry); u->inquiry[2] = 2; u->inquiry[3] = 2; u->inquiry[4] = sizeof u->inquiry - 4; memmove(u->inquiry+8, d->model, 40); return 0; }
/* (*uprint) user provided print function */ void inorder(struct node_t *node, void (*uprint)(void *, void *)) { if (node != NULL) { inorder(node->left, uprint); uprint(node->key, node->value); inorder(node->right, uprint); } }
void TEST_Audio() { char rx[50]; unsigned char vol; unsigned int snd; while (1) { uprint("Enter volume level: "); uart1_gets(rx, 50); vol = atoi(rx); uprint_int("Volume is: ", vol); uprint("Enter sound: "); uart1_gets(rx, 50); snd = atoi(rx); uprint_int("Sound is: ", snd); setVolume(vol); playSound(snd); } }
struct fp_ext * fp_flog2(struct fp_ext *dest, struct fp_ext *src) { uprint("flog2\n"); fp_monadic_check(dest, src); return dest; }
struct fp_ext * fp_ftentox(struct fp_ext *dest, struct fp_ext *src) { uprint("ftentox\n"); fp_monadic_check(dest, src); return dest; }
struct fp_ext * fp_fcosh(struct fp_ext *dest, struct fp_ext *src) { uprint("fcosh\n"); fp_monadic_check(dest, src); return dest; }
struct fp_ext * fp_fatan(struct fp_ext *dest, struct fp_ext *src) { uprint("fatan\n"); fp_monadic_check(dest, src); return dest; }
struct fp_ext * fp_fetoxm1(struct fp_ext *dest, struct fp_ext *src) { uprint("fetoxm1\n"); fp_monadic_check(dest, src); return dest; }
int printf(const char* fmt,...) { va_list args; int i; char buf[500]; va_start(args,fmt); i=vsprintf(buf,fmt,args); va_end(args); uprint(buf); return i; }
void set_router(void) { uint8 logicalType; osal_nv_item_init( ZCD_NV_LOGICAL_TYPE, sizeof(logicalType), &logicalType ); logicalType = ZG_DEVICETYPE_ROUTER; if( osal_nv_write( ZCD_NV_LOGICAL_TYPE, 0 ,sizeof(logicalType), &logicalType) != ZSUCCESS) { uprint("set device to router failed"); }else { zgWriteStartupOptions (ZG_STARTUP_SET, ZCD_STARTOPT_DEFAULT_NETWORK_STATE); uprint("set device to router,restart it"); } // zgWriteStartupOptions (ZG_STARTUP_SET, 0x02); // zgInit(); // ZDOInitDevice( 0 ); // SystemReset(); return; }
struct ext2_inode *ext2_icache_request(struct ext2fs *ext2, ino_t inode) { int i; uint64_t group; uint64_t index; int ret; struct fiu_instance *fi = ext2->fi; for (i = 0; i < EXT2_INODE_CACHE_SIZE; ++i) { if (ext2->inode_cache[i].inode == inode) { ++ext2->inode_cache[i].ref_count; return &(ext2->inode_cache[i].cinode); } } /* * If the inode was not in cache, we find a place to hold it in the cache * and we fetch it */ for (i = 0; i < EXT2_INODE_CACHE_SIZE; ++i) { if (ext2->inode_cache[i].inode == EXT2_BAD_INODE || ext2->inode_cache[i].ref_count == 0) break; } /* No place to hold it */ if (i == EXT2_INODE_CACHE_SIZE) { uprint("EXT2: Cache is full! FIXME!"); return NULL; } index = (inode - 1) % ext2->sb.inode_per_group; group = (inode - 1) / ext2->sb.inode_per_group; off_t lseek_off = (off_t)ext2->grp_table[group].inode_table * ext2->block_size + index * ext2->sb.sizeof_inode; ret = lseek(fi->device_fd, lseek_off, SEEK_SET); if (ret < 0) return NULL; ret = read(fi->device_fd, &ext2->inode_cache[i].cinode, sizeof (struct ext2_inode)); if (ret < 0) return NULL; ext2->inode_cache[i].inode = inode; ext2->inode_cache[i].ref_count = 1; return &ext2->inode_cache[i].cinode; }
void cloudMain() { uprint("\r\n ************************ BOOT UP (CLOUD) ************************ \r\n"); configureAudio(); audioReset(); configureIRSend(); int sta = configureRadio(0x0A00, 0x0000111111111111); uprint_int("Configured radio: ", sta); char rxbuf[2]; int damageToSend, i; configureCloudLighting(); DELAY_MS(400); playSound(CS_BOOT); DELAY_MS(CS_BOOT_LEN); while (1) { uprint("Beginning of main loop"); cloudLightingSetMode(ALGM_BLINK); uprint("Waiting for hammer message"); radioGetMessage(rxbuf, 1); uprint("Got message"); playSound(CS_FIRE); // Don't wait for this sound // Enter manual lighting mode cloudLightingSetMode(ALGM_OFF); cloudLightingSetAll(BRIGHTNESS_MAX); cloudLightingUpdate(); damageToSend = rxbuf[0]; for (i = 0; i < damageToSend; i ++) { uprint("Sending damage packet"); sendDamagePacket(); if ((i % 10) == 0) { cloudLightingSetAll(BRIGHTNESS_MAX); } else if ((i % 5) == 0) { cloudLightingSetAll(50); } cloudLightingUpdate(); } uprint("Sending DONE message"); radioSendMessage("DONE", 0x0A00); } }
int main(void) { int tid; if (ide_detect(&ide) < 0) { uprint("ATA: No IDE controller found. Bye!"); return 1; } if (!ide_initialize(&ide)) { uprint("ATA: No disk have been detected. Bye!"); return 2; } uprint("ATA: configuration detected, creating devices ..."); for (int i = 0; i < 4; ++i) { if (ide.devices[i].exists) { tid = thread_create(driver_device_thread, 1, &ide.devices[i]); if (tid < 0) uprint("ATA: Fail to start thread"); } } while (1) sleep(1); return 0; }
/* Print the days */ static void print_days(UChar *days [], FILE *f, UErrorCode *status) { int32_t i; if(U_FAILURE(*status)) return; /* Print the day names */ for(i = 0; i < DAY_COUNT; ++i) { uprint(days[i], f, status); putc(' ', f); } }
static Aoedev* unit2dev(ulong unit) { int i; Aoedev *d; rlock(&devs); i = 0; for(d = devs.d; d; d = d->next) if(i++ == unit){ runlock(&devs); return d; } runlock(&devs); uprint("unit lookup failure: %lux pc %#p", unit, getcallerpc(&unit)); error(up->genbuf); return nil; }
/********************************************************************* * @fn GenericApp_ProcessZDOMsgs() * * @brief Process response messages * * @param none * * @return none */ static void GenericApp_ProcessZDOMsgs( zdoIncomingMsg_t *inMsg ) { switch ( inMsg->clusterID ) { case End_Device_Bind_rsp: if ( ZDO_ParseBindRsp( inMsg ) == ZSuccess ) { // Light LED HalLedSet( HAL_LED_2, HAL_LED_MODE_ON ); } #if defined( BLINK_LEDS ) else { // Flash LED to show failure HalLedSet ( HAL_LED_2, HAL_LED_MODE_FLASH ); } #endif break; case Match_Desc_rsp: { uprint("Match_Decs_rsp"); ZDO_ActiveEndpointRsp_t *pRsp = ZDO_ParseEPListRsp( inMsg ); if ( pRsp ) { if ( pRsp->status == ZSuccess && pRsp->cnt ) { GenericApp_DstAddr.addrMode = (afAddrMode_t)Addr16Bit; //GenericApp_DstAddr.addr.shortAddr = pRsp->nwkAddr; GenericApp_DstAddr.addr.shortAddr = 0xFFFF; // Take the first endpoint, Can be changed to search through endpoints GenericApp_DstAddr.endPoint = pRsp->epList[0]; // Light LED //HalLedSet( HAL_LED_2, HAL_LED_MODE_ON ); } osal_mem_free( pRsp ); } } break; } }
void set_panid( uint16 u16NewPanid) { uint8 u8BackCode; _NIB.nwkPanId = u16NewPanid; macRadioSetPanID ( _NIB.nwkPanId); ZMacSetReq( ZMacPanId, (byte *)& _NIB.nwkPanId); u8BackCode = osal_nv_write(ZCD_NV_PANID, 0, 2, &u16NewPanid); if( u8BackCode == ZSUCCESS) { NLME_UpdateNV(0x01); // HAL_SYSTEM_RESET(); } else { uprint("set_panid failed"); } }
/* ** subtest_ul(test_list, status, ch) ** ** test transparent underline (ul) */ static void subtest_ul( struct test_list *t, int *state, int *ch) { if (!over_strike) { /* (ul) is used only if (os) is reset */ put_crlf(); sprintf(temp, "This text should %sbe underlined.", transparent_underline ? "" : "not "); uprint(temp); put_crlf(); ptextln("If the above line is not underlined the (ul) should be false."); sprintf(temp, "(ul) Transparent-underline is %s in the data base", transparent_underline ? "true" : "false"); ptextln(temp); generic_done_message(t, state, ch); } }
static void aoectl(Ctlr *d, char *s) { Chan *c; c = nil; if(waserror()) { if(c) cclose(c); print("sdaoectl: %s\n", up->errstr); nexterror(); } uprint("%s/ctl", d->path); c = namec(up->genbuf, Aopen, OWRITE, 0); devtab[c->type]->write(c, s, strlen(s), 0); poperror(); cclose(c); }
static int aoeconnect(SDunit *u, Ctlr *c) { qlock(c); if(waserror()){ qunlock(c); return -1; } aoeidentify(u->dev->ctlr, u); if(c->c) cclose(c->c); c->c = 0; uprint("%s/data", c->path); c->c = namec(up->genbuf, Aopen, ORDWR, 0); qunlock(c); poperror(); return 0; }