// search for specified scene file and load it // return 1 on success, 0 on failure u8 files_load_scene_name(const char* name) { void* fp; u32 size = 0; u8 ret = 0; app_pause(); fp = list_open_file_name(&sceneList, name, "r", &size); if( fp != NULL) { fake_fread((volatile u8*)sceneData, sizeof(sceneData_t), fp); fl_fclose(fp); scene_read_buf(); // try and load dsp module indicated by scene descriptor //// DUDE! NO!!! scene does this. when did this happen! //// probably snuck in in some merge. // ret = files_load_dsp_name(sceneData->desc.moduleName); } else { print_dbg("\r\n error: fp was null in files_load_scene_name \r\n"); ret = 0; } app_resume(); return ret; }
// store scene to sdcard at name void files_store_scene_name(const char* name, u8 ext) { //u32 i; void* fp; char namebuf[64] = SCENES_PATH; u8* pScene; app_pause(); strcat(namebuf, name); if(ext) { // weird.. strip_space(namebuf, 32); strcat(namebuf, ".scn"); } print_dbg("\r\n opening scene file for writing: "); print_dbg(namebuf); // fill the scene RAM buffer from current state of system scene_write_buf(); // open FP for writing fp = fl_fopen(namebuf, "wb"); pScene = (u8*)sceneData; fl_fwrite((const void*)pScene, sizeof(sceneData_t), 1, fp); fl_fclose(fp); // rescan list_scan(&sceneList, SCENES_PATH); delay_ms(10); app_resume(); }
void bfin_get_num_params(volatile u32* num) { #if 1 *num = 0; #else u16 x; app_pause(); // command spi_selectChip(BFIN_SPI, BFIN_SPI_NPCS); spi_write(BFIN_SPI, MSG_GET_NUM_PARAMS_COM); spi_unselectChip(BFIN_SPI, BFIN_SPI_NPCS); print_dbg("\r\n : spi_write MSG_GET_NUM_PARAMS"); // read num spi_selectChip(BFIN_SPI, BFIN_SPI_NPCS); spi_write(BFIN_SPI, 0); //dont care spi_read(BFIN_SPI, &x); spi_unselectChip(BFIN_SPI, BFIN_SPI_NPCS); *num = (u8)(x & 0xff); print_dbg("\r\n : spi_read numparams: "); print_dbg_ulong(*num); app_resume(); #endif }
// search for named .dsc file and load into network param desc memory extern u8 files_load_desc(const char* name) { char path[64] = DSP_PATH; void * fp; int nparams = -1; // word buffer for 4-byte unpickling u8 nbuf[4]; // buffer for binary blob of single descriptor u8 dbuf[PARAM_DESC_PICKLE_BYTES]; // unpacked descriptor ParamDesc desc; int i; u8 ret = 0; app_pause(); strcat(path, name); strip_ext(path); strcat(path, ".dsc"); print_dbg("\r\n opening .dsc file at path: "); print_dbg(path); fp = fl_fopen(path, "r"); if(fp == NULL) { print_dbg("... error opening .dsc file."); print_dbg(path); ret = 1; } else { // get number of parameters fake_fread(nbuf, 4, fp); unpickle_32(nbuf, (u32*)&nparams); /// loop over params if(nparams > 0) { net_clear_params(); // net->numParams = nparams; for(i=0; i<nparams; i++) { // FIXME: a little gross, // to be interleaving network and file manipulation like this... ///.... // read into desc buffer fake_fread(dbuf, PARAM_DESC_PICKLE_BYTES, fp); // unpickle directly into network descriptor memory pdesc_unpickle( &desc, dbuf ); // copy descriptor to network and increment count net_add_param(i, (const ParamDesc*)(&desc)); } } else { print_dbg("\r\n error: crazy parameter count from descriptor file."); ret = 1; } } fl_fclose(fp); app_resume(); return ret; }
// load from default void scene_read_default(void) { app_pause(); print_dbg("\r\n reading default scene from flash... "); flash_read_scene(); print_dbg("\r\n finished reading "); app_resume(); }
void bfin_get_param_desc(u16 paramIdx, volatile ParamDesc* pDesc) { ParamValue pval; u16 x; // u16 for spi_read() u8 i; app_pause(); // command spi_selectChip(BFIN_SPI, BFIN_SPI_NPCS); spi_write(BFIN_SPI, MSG_GET_PARAM_DESC_COM); spi_unselectChip(BFIN_SPI, BFIN_SPI_NPCS); // idx spi_selectChip(BFIN_SPI, BFIN_SPI_NPCS); spi_write(BFIN_SPI, paramIdx); spi_unselectChip(BFIN_SPI, BFIN_SPI_NPCS); // read label for(i=0; i<PARAM_LABEL_LEN; i++) { spi_selectChip(BFIN_SPI, BFIN_SPI_NPCS); spi_write(BFIN_SPI, 0); //dont care spi_read(BFIN_SPI, &x); spi_unselectChip(BFIN_SPI, BFIN_SPI_NPCS); pDesc->label[i] = (char)(x & 0xff); } // read unit for(i=0; i<PARAM_UNIT_LEN; i++) { spi_selectChip(BFIN_SPI, BFIN_SPI_NPCS); spi_write(BFIN_SPI, 0); //dont care spi_read(BFIN_SPI, &x); spi_unselectChip(BFIN_SPI, BFIN_SPI_NPCS); pDesc->unit[i] = (char)(x & 0xff); } // read type spi_selectChip(BFIN_SPI, BFIN_SPI_NPCS); spi_write(BFIN_SPI, 0); //dont care spi_read(BFIN_SPI, &x); spi_unselectChip(BFIN_SPI, BFIN_SPI_NPCS); pDesc->type = (U8)(x & 0xff); // read min for(i=0; i<4; i++) { spi_selectChip(BFIN_SPI, BFIN_SPI_NPCS); spi_write(BFIN_SPI, 0); //dont care spi_read(BFIN_SPI, &x); spi_unselectChip(BFIN_SPI, BFIN_SPI_NPCS); pval.asByte[i] = (u8)(x & 0xff); } pDesc->min = pval.asInt; // read max for(i=0; i<4; i++) { spi_selectChip(BFIN_SPI, BFIN_SPI_NPCS); spi_write(BFIN_SPI, 0); //dont care spi_read(BFIN_SPI, &x); spi_unselectChip(BFIN_SPI, BFIN_SPI_NPCS); pval.asByte[i] = (u8)(x & 0xff); } pDesc->max = pval.asInt; app_resume(); }
// load from default void scene_read_default(void) { app_pause(); /* print_dbg("\r\n reading default scene from flash... "); */ /* flash_read_scene(); */ print_dbg("\r\n reading default scene from card... "); files_load_scene_name(DEFAULT_SCENE_NAME_EXT); print_dbg("\r\n finished reading "); app_resume(); }
// search for specified dsp file and load it u8 files_load_dsp_name(const char* name) { void* fp; u32 size = 0; u8 ret; // ModuleVersion modVers; delay_ms(10); app_pause(); fp = list_open_file_name(&dspList, name, "r", &size); if( fp != NULL) { print_dbg("\r\n found file, loading dsp: "); print_dbg(name); fake_fread(bfinLdrData, size, fp); fl_fclose(fp); bfinLdrSize = size; if(bfinLdrSize > 0) { print_dbg("\r\n loading bfin from buf"); // reboot the dsp with new firmware in RAM bfin_load_buf(); print_dbg("\r\n finished load"); // write module name in global scene data ///////////////// /// FIXME: filename and reported modulename should be decoupled /// bees should search for aleph-module-x.y.z.ldr /// but try aleph-module*.ldr on failure //// /// query name and version to the scene data // scene_query_module(); /// now set it to the actual filename because we are dumb scene_set_module_name(name); /////////////////////////// print_dbg("\r\n sceneData->moduleName : "); print_dbg(name); ret = 1; } else { print_dbg("\r\n bfin ldr size was <=0, aborting"); ret = 0; } } else { print_dbg("\r\n error: fp was null in files_load_dsp_name \r\n"); ret = 0; } app_resume(); return ret; }
// store scene to sdcard at name void files_store_scene_name(const char* name, u8 ext) { //u32 i; void* fp; char namebuf[64] = SCENES_PATH; u8* pScene; app_pause(); strcat(namebuf, name); if(ext) { // weird.. strip_space(namebuf, 32); strcat(namebuf, ".scn"); } print_dbg("\r\n opening scene file for writing: "); print_dbg(namebuf); // fill the scene RAM buffer from current state of system scene_write_buf(); print_dbg("\r\n filled scene binary buffer"); // open FP for writing fp = fl_fopen(namebuf, "wb"); print_dbg("\r\n opened file for binary write at 0x"); print_dbg_hex((u32)fp); pScene = (u8*)sceneData; print_dbg("\r\n writing data from scene buffer at 0x"); print_dbg_hex((u32)pScene); print_dbg(", size : "); print_dbg_hex(sizeof(sceneData_t)); // dump the scene data to debug output... fl_fwrite((const void*)pScene, sizeof(sceneData_t), 1, fp); fl_fclose(fp); print_dbg("\r\n ... finished writing, closed file pointer"); // rescan list_scan(&sceneList, SCENES_PATH); delay_ms(10); print_dbg("\r\n re-scanned scene file list and waited."); app_resume(); }
// destroy last operator created s16 net_pop_op(void) { const s16 opIdx = net->numOps - 1; op_t* op = net->ops[opIdx]; int i=0; int x, y; app_pause(); // bail if system op if(net_op_flag (opIdx, eOpFlagSys)) { return 1; } // de-init op_deinit(op); // store the global index of the first input x = net_op_in_idx(opIdx, 0); y = x + op->numInputs; // check if anything connects here for(i=0; i<net->numOuts; i++) { // this check works b/c we know this is last op in list if( net->outs[i].target >= x ) { if( net->outs[i].target < y) { net_disconnect(i); } else { // net->outs[i].target -= op->numInputs; net_connect(i, net->outs[i].target - op->numInputs); } } } // erase input nodes while(x < y) { net_init_inode(x++); } // store the global index of the first output x = net_op_out_idx(opIdx, 0); y = x + op->numOutputs; // erase output nodes while(x < y) { net_init_onode(x++); } net->numIns -= op->numInputs; net->numOuts -= op->numOutputs; net->opPoolOffset -= op_registry[op->type].size; net->numOps -= 1; app_resume(); return 0; }
// get parameter value s32 bfin_get_param(u8 idx) { #if 1 #else ParamValueCommon pval; u16 x; app_pause(); // command spi_selectChip(BFIN_SPI, BFIN_SPI_NPCS); spi_write(BFIN_SPI, MSG_GET_PARAM_COM); spi_unselectChip(BFIN_SPI, BFIN_SPI_NPCS); // idx spi_selectChip(BFIN_SPI, BFIN_SPI_NPCS); spi_write(BFIN_SPI, idx); spi_unselectChip(BFIN_SPI, BFIN_SPI_NPCS); /// read value spi_selectChip(BFIN_SPI, BFIN_SPI_NPCS); spi_write(BFIN_SPI, 0); // don't care spi_read(BFIN_SPI, &x); spi_unselectChip(BFIN_SPI, BFIN_SPI_NPCS); pval.asByte[0] = (u8)x; spi_selectChip(BFIN_SPI, BFIN_SPI_NPCS); spi_write(BFIN_SPI, 0); // don't care spi_read(BFIN_SPI, &x); spi_unselectChip(BFIN_SPI, BFIN_SPI_NPCS); pval.asByte[1] = (u8)x; spi_selectChip(BFIN_SPI, BFIN_SPI_NPCS); spi_write(BFIN_SPI, 0); // don't care spi_read(BFIN_SPI, &x); spi_unselectChip(BFIN_SPI, BFIN_SPI_NPCS); pval.asByte[2] = (u8)x; spi_selectChip(BFIN_SPI, BFIN_SPI_NPCS); spi_write(BFIN_SPI, 0); // don't care spi_read(BFIN_SPI, &x); spi_unselectChip(BFIN_SPI, BFIN_SPI_NPCS); pval.asByte[3] = (u8)x; app_resume(); return pval.asInt; #endif }
// update void render_update(void) { app_pause(); // scrolling region if((pageCenterScroll->reg)->dirty) { scroll_draw(pageCenterScroll); } // standard regions region_update(headRegion); region_update(footRegion[0]); region_update(footRegion[1]); region_update(footRegion[2]); region_update(footRegion[3]); app_resume(); }
void bfin_get_num_params(volatile u32* num) { u16 x; app_pause(); // command spi_selectChip(BFIN_SPI, BFIN_SPI_NPCS); spi_write(BFIN_SPI, MSG_GET_NUM_PARAMS_COM); spi_unselectChip(BFIN_SPI, BFIN_SPI_NPCS); // read num spi_selectChip(BFIN_SPI, BFIN_SPI_NPCS); spi_write(BFIN_SPI, 0); //dont care spi_read(BFIN_SPI, &x); spi_unselectChip(BFIN_SPI, BFIN_SPI_NPCS); *num = (u8)(x & 0xff); app_resume(); }
// get module version void bfin_get_module_version(ModuleVersion* vers) { u16 x; app_pause(); // command spi_selectChip(BFIN_SPI, BFIN_SPI_NPCS); spi_write(BFIN_SPI, MSG_GET_MODULE_VERSION_COM); spi_unselectChip(BFIN_SPI, BFIN_SPI_NPCS); // major spi_selectChip(BFIN_SPI, BFIN_SPI_NPCS); spi_write(BFIN_SPI, 0); //dont care spi_read(BFIN_SPI, &x); spi_unselectChip(BFIN_SPI, BFIN_SPI_NPCS); vers->maj = x; // minor spi_selectChip(BFIN_SPI, BFIN_SPI_NPCS); spi_write(BFIN_SPI, 0); //dont care spi_read(BFIN_SPI, &x); spi_unselectChip(BFIN_SPI, BFIN_SPI_NPCS); vers->min = x; // rev vers->rev = 0; // rev high spi_selectChip(BFIN_SPI, BFIN_SPI_NPCS); spi_write(BFIN_SPI, 0); //dont care spi_read(BFIN_SPI, &x); spi_unselectChip(BFIN_SPI, BFIN_SPI_NPCS); vers->rev |= ((x << 8) & 0xff00); // rev low spi_selectChip(BFIN_SPI, BFIN_SPI_NPCS); spi_write(BFIN_SPI, 0); //dont care spi_read(BFIN_SPI, &x); spi_unselectChip(BFIN_SPI, BFIN_SPI_NPCS); vers->rev |= (x & 0x00ff); app_resume(); }
// load bfin executable from the RAM buffer void bfin_load_buf(void) { u64 i; /// byte index in .ldr if(bfinLdrSize > BFIN_LDR_MAX_BYTES) { print_dbg("\r\n bfin load error: size : "); print_dbg_hex(bfinLdrSize); return; } app_pause(); bfin_start_transfer(); for(i=0; i<bfinLdrSize; i++) { bfin_transfer_byte(bfinLdrData[i]); } bfin_end_transfer(); app_resume(); }
// get module name void bfin_get_module_name(volatile char* buf) { u16 x; // u16 for spi_read() u8 i; app_pause(); // command spi_selectChip(BFIN_SPI, BFIN_SPI_NPCS); spi_write(BFIN_SPI, MSG_GET_MODULE_NAME_COM); spi_unselectChip(BFIN_SPI, BFIN_SPI_NPCS); for(i=0; i<MODULE_NAME_LEN; i++) { spi_selectChip(BFIN_SPI, BFIN_SPI_NPCS); spi_write(BFIN_SPI, 0); //dont care spi_read(BFIN_SPI, &x); spi_unselectChip(BFIN_SPI, BFIN_SPI_NPCS); buf[i] = (char)(x & 0xff); } app_resume(); }
// search for specified scene file and load it // return 1 on success, 0 on failure u8 files_load_scene_name(const char* name) { void* fp; u32 size = 0; u8 ret = 0; //// ahhhhh, i see.. /// this is overwriting the descriptor in sceneData as well as the serialized blob. /// woud be fine, except it f***s up the comparison later. /// for now, let's do this ugly-ass workaround. char oldModuleName[MODULE_NAME_LEN]; /// store extant module name strncpy(oldModuleName, sceneData->desc.moduleName, MODULE_NAME_LEN); app_pause(); fp = list_open_file_name(&sceneList, name, "r", &size); if( fp != NULL) { print_dbg("\r\n reading binary into sceneData serialized data buffer..."); fake_fread((volatile u8*)sceneData, sizeof(sceneData_t), fp); print_dbg(" done."); /// copy old name back to descriptor field... dumb dumb dumb. strncpy(sceneData->desc.moduleName, oldModuleName, MODULE_NAME_LEN); fl_fclose(fp); scene_read_buf(); // try and load dsp module indicated by scene descriptor //// DUDE! NO!!! scene does this. when did this happen! //// probably snuck in in some merge. // ret = files_load_dsp_name(sceneData->desc.moduleName); } else { print_dbg("\r\n error: fp was null in files_load_scene_name \r\n"); ret = 0; } app_resume(); return ret; }
// load bfin executable from the RAM buffer void bfin_load_buf(void) { #if 1 #else u64 i; /// byte index in .ldr ///// //// TEST: print contents of buffer /* print_dbg("\r\n\r\n .ldr buffer for: "); */ /* contents(i=0; i<bfinLdrSize; i++) { */ /* print_dbg("\r\n 0x"); */ /* print_dbg_hex(bfinLdrData[i]); */ /* } */ /* print_dbg("\r\n\r\n"); */ //// ///////// //////////// //// tESTING don't check #if 0 if(bfinLdrSize > BFIN_LDR_MAX_BYTES) { print_dbg("\r\n bfin load error: size : "); print_dbg_hex(bfinLdrSize); return; } #endif /////////////// //////////////// app_pause(); bfin_start_transfer(); for(i=0; i<bfinLdrSize; i++) { bfin_transfer_byte(bfinLdrData[i]); } bfin_end_transfer(); app_resume(); #endif }
// write current state as default void scene_write_default(void) { app_pause(); render_boot("writing default scene"); print_dbg("\r\n writing default scene to card... "); files_store_scene_name(DEFAULT_SCENE_NAME_EXT, 0); // app_resume(); /* #if 0 */ /* s8 neq = 0; */ /* s8 modName[MODULE_NAME_LEN]; */ /* #endif */ /* app_pause(); */ /* render_boot("writing scene to flash"); */ /* print_dbg("\r\n writing scene to flash... "); */ /* print_dbg("module name: "); */ /* print_dbg(sceneData->desc.moduleName); */ /* // flash_write_scene(); */ /* # if 0 // not storing .ldr in flash for the moment! */ /* // write default LDR if changed */ /* neq = strncmp((const char*)modName, (const char*)sceneData->desc.moduleName, MODULE_NAME_LEN); */ /* if(neq) { */ /* render_boot("writing DSP to flash"); */ /* print_dbg("\r\n writing default LDR from scene descriptor"); */ /* files_store_default_dsp_name(sceneData->desc.moduleName); */ /* } */ /* #endif */ delay_ms(20); print_dbg("\r\n finished writing default scene"); app_resume(); }
// write current state as default void scene_write_default(void) { s8 neq = 0; s8 modName[MODULE_NAME_LEN]; app_pause(); render_boot("writing scene to flash"); print_dbg("\r\n writing scene to flash... "); print_dbg("module name: "); print_dbg(sceneData->desc.moduleName); flash_write_scene(); // write default LDR if changed neq = strncmp((const char*)modName, (const char*)sceneData->desc.moduleName, MODULE_NAME_LEN); if(neq) { render_boot("writing DSP to flash"); print_dbg("\r\n writing default LDR from scene descriptor"); // files_store_default_dsp_name(sceneData->desc.moduleName); } delay_ms(20); print_dbg("\r\n finished writing default scene"); app_resume(); }
// destroy last operator created s16 net_pop_op(void) { const s16 opIdx = net->numOps - 1; op_t* op = net->ops[opIdx]; int i, j; int x, y; int ins; int numInsSave = net->numIns; int idxOld, idxNew; app_pause(); // bail if system op if(net_op_flag (opIdx, eOpFlagSys)) { return 1; } // de-init op_deinit(op); ins = op->numInputs; // store the global index of the first input x = net_op_in_idx(opIdx, 0); y = x + ins; // check if anything connects here for(i=0; i<net->numOuts; i++) { // this check works b/c we know this is last op in list if( net->outs[i].target >= x ) { if( net->outs[i].target < y) { net_disconnect(i); } else { /// this should take care of both param and op input targets. net_connect(i, net->outs[i].target - op->numInputs); } } } // erase input nodes while(x < y) { net_init_inode(x++); } // store the global index of the first output x = net_op_out_idx(opIdx, 0); y = x + op->numOutputs; // erase output nodes while(x < y) { net_init_onode(x++); } net->numIns -= op->numInputs; net->numOuts -= op->numOutputs; net->opPoolOffset -= op_registry[op->type].size; net->numOps -= 1; // FIXME: shift preset param data and connections to params, // since they share an indexing list with inputs and we just changed it. for(i=0; i<NET_PRESETS_MAX; ++i) { // shift parameter nodes in preset data for(j=0; j<net->numParams; ++j) { // this was the old param index idxOld = j + numInsSave; // copy to new param index idxNew = idxOld - ins; presets[i].ins[idxNew].value = presets[i].ins[idxOld].value; presets[i].ins[idxNew].enabled = presets[i].ins[idxOld].enabled; // clear the old data. presets[i].ins[idxOld].enabled = 0; presets[i].ins[idxOld].value = 0; } } app_resume(); return 0; }
// search for specified scaler file and load it to specified buffer // return 1 on success, 0 on failure u8 files_load_scaler_name(const char* name, s32* dst, u32 dstSize) { void* fp; u32 size = 0; u32 i; union { u32 u; s32 s; u8 b[4]; } swap; u8 ret = 0; //// test //s32* p = dst; /// app_pause(); fp = list_open_file_name(&scalerList, name, "r", &size); if( fp != NULL) { print_dbg("\r\n scaler file pointer: 0x"); print_dbg_hex((u32)fp); #ifdef SCALER_LE swap.b[3] = fl_fgetc(fp); swap.b[2] = fl_fgetc(fp); swap.b[1] = fl_fgetc(fp); swap.b[0] = fl_fgetc(fp); #else swap.b[0] = fl_fgetc(fp); swap.b[1] = fl_fgetc(fp); swap.b[2] = fl_fgetc(fp); swap.b[3] = fl_fgetc(fp); #endif size = swap.u; print_dbg("\r\n read size (words): 0x"); print_dbg_ulong(size); if(size > dstSize) { print_dbg("\r\n warning: requested scaler data is > target, truncating"); for(i=0; i<dstSize; ++i) { #ifdef SCALER_LE swap.b[3] = fl_fgetc(fp); swap.b[2] = fl_fgetc(fp); swap.b[1] = fl_fgetc(fp); swap.b[0] = fl_fgetc(fp); #else swap.b[0] = fl_fgetc(fp); swap.b[1] = fl_fgetc(fp); swap.b[2] = fl_fgetc(fp); swap.b[3] = fl_fgetc(fp); #endif *dst++ = swap.s; } } else if (size < dstSize) { print_dbg("\r\n warning: requested scaler data is < target, padding"); for(i=0; i<size; ++i) { #ifdef SCALER_LE swap.b[3] = fl_fgetc(fp); swap.b[2] = fl_fgetc(fp); swap.b[1] = fl_fgetc(fp); swap.b[0] = fl_fgetc(fp); #else swap.b[0] = fl_fgetc(fp); swap.b[1] = fl_fgetc(fp); swap.b[2] = fl_fgetc(fp); swap.b[3] = fl_fgetc(fp); #endif *dst++ = swap.s; } // remainder size = dstSize - size; for(i=0; i<size; ++i) { *dst++ = 0; } } else { for(i=0; i<size; ++i) { #ifdef SCALER_LE swap.b[3] = fl_fgetc(fp); swap.b[2] = fl_fgetc(fp); swap.b[1] = fl_fgetc(fp); swap.b[0] = fl_fgetc(fp); #else swap.b[0] = fl_fgetc(fp); swap.b[1] = fl_fgetc(fp); swap.b[2] = fl_fgetc(fp); swap.b[3] = fl_fgetc(fp); #endif *dst++ = swap.s; } } fl_fclose(fp); ret = 1; } else { print_dbg("\r\n error: fp was null in files_load_scaler_name \r\n"); ret = 0; } print_dbg("\r\n finished loading scaler file (?)"); ///// TEST: verify /* for(i=0; i<size; i++) { */ /* print_dbg(" 0x"); print_dbg_hex(p[i]); if((i%4)==0) { print_dbg("\r\n"); } */ /* } */ app_resume(); return ret; }
// set current state of system from global RAM buffer void scene_read_buf(void) { s8 modName[MODULE_NAME_LEN]; const u8* src = (u8*)&(sceneData->pickle); /// FIXME: we really should be using this comparison // s8 neq = 0; // u32 i; app_pause(); // store current mod name in scene desc memcpy(modName, sceneData->desc.moduleName, MODULE_NAME_LEN); ///// always load: print_dbg("\r\n loading module name: "); print_dbg(sceneData->desc.moduleName); files_load_dsp_name(sceneData->desc.moduleName); // } bfin_wait_ready(); net_clear_user_ops(); net_report_params(); // unpickle network print_dbg("\r\n unpickling network for scene recall..."); src = net_unpickle(src); // unpickle presets print_dbg("\r\n unpickling presets for scene recall..."); src = presets_unpickle(src); print_dbg("\r\n copied stored network and presets to RAM "); /* for(i=0; i<net->numParams; i++) { */ /* print_dbg("\r\n param "); */ /* print_dbg_ulong(i); */ /* print_dbg(" : "); */ /* print_dbg(net->params[i].desc.label); */ /* print_dbg(" ; val "); */ /* print_dbg_hex((u32)net->params[i].data.value); */ /* } */ // compare module name //// is strncmp f*****g with us?? /// neq = strncmp((const char*)modName, (const char*)sceneData->desc.moduleName, MODULE_NAME_LEN); // if(neq) { // load bfin module if it doesn't match the current scene desc //... bfin_wait_ready(); //// well let's try it, actually that would explain some things.. // delay_ms(10); // update bfin parameters net_send_params(); print_dbg("\r\n sent new params"); delay_ms(5); // enable audio processing bfin_enable(); app_resume(); }
void bfin_get_param_desc(u16 paramIdx, volatile ParamDesc* pDesc) { #if 1 #else ParamValueCommon pval; u16 x; // u16 for spi_read() u8 i; app_pause(); // command spi_selectChip(BFIN_SPI, BFIN_SPI_NPCS); spi_write(BFIN_SPI, MSG_GET_PARAM_DESC_COM); spi_unselectChip(BFIN_SPI, BFIN_SPI_NPCS); // idx spi_selectChip(BFIN_SPI, BFIN_SPI_NPCS); spi_write(BFIN_SPI, paramIdx); spi_unselectChip(BFIN_SPI, BFIN_SPI_NPCS); // read label for(i=0; i<PARAM_LABEL_LEN; i++) { spi_selectChip(BFIN_SPI, BFIN_SPI_NPCS); spi_write(BFIN_SPI, 0); //dont care spi_read(BFIN_SPI, &x); spi_unselectChip(BFIN_SPI, BFIN_SPI_NPCS); pDesc->label[i] = (char)(x & 0xff); } /* //// don't need with new type system... didn't exactly need anyways // read unit for(i=0; i<PARAM_UNIT_LEN; i++) { spi_selectChip(BFIN_SPI, BFIN_SPI_NPCS); spi_write(BFIN_SPI, 0); //dont care spi_read(BFIN_SPI, &x); spi_unselectChip(BFIN_SPI, BFIN_SPI_NPCS); pDesc->unit[i] = (char)(x & 0xff); } */ // read type spi_selectChip(BFIN_SPI, BFIN_SPI_NPCS); spi_write(BFIN_SPI, 0); //dont care spi_read(BFIN_SPI, &x); spi_unselectChip(BFIN_SPI, BFIN_SPI_NPCS); pDesc->type = (U8)(x & 0xff); // read min for(i=0; i<4; i++) { spi_selectChip(BFIN_SPI, BFIN_SPI_NPCS); spi_write(BFIN_SPI, 0); //dont care spi_read(BFIN_SPI, &x); spi_unselectChip(BFIN_SPI, BFIN_SPI_NPCS); pval.asByte[i] = (u8)(x & 0xff); } pDesc->min = pval.asInt; // read max for(i=0; i<4; i++) { spi_selectChip(BFIN_SPI, BFIN_SPI_NPCS); spi_write(BFIN_SPI, 0); //dont care spi_read(BFIN_SPI, &x); spi_unselectChip(BFIN_SPI, BFIN_SPI_NPCS); pval.asByte[i] = (u8)(x & 0xff); } pDesc->max = pval.asInt; // read radix spi_selectChip(BFIN_SPI, BFIN_SPI_NPCS); spi_write(BFIN_SPI, 0); //dont care spi_read(BFIN_SPI, &x); spi_unselectChip(BFIN_SPI, BFIN_SPI_NPCS); pDesc->radix = (u8)(x & 0xff); app_resume(); #endif }
// this is called from main event handler u8 app_launch(u8 firstrun) { print_dbg("\r\n launching app with firstrun: "); print_dbg_ulong(firstrun); // net_print(); render_boot("BEES"); render_boot(versionString); if(firstrun) { render_boot("launching app, first run"); print_dbg("\r\n first run, writing nonvolatile data..."); ///... write param scaler data // this is done at firstrun instead of being linked statically, // so that users can tune scaler data offline without recompiling render_boot("init param scaling data..."); flash_init_scaler_data(); print_dbg("\r\n first run, try and load default DSP"); render_boot("launching default DSP..."); files_load_dsp_name("aleph-waves.ldr"); render_boot("waiting for DSP init..."); bfin_wait_ready(); // print_dbg(" requesting param report..."); render_boot("requesting DSP params"); net_report_params(); // print_dbg("\r\n enable DSP audio..."); render_boot("enabling audio"); bfin_enable(); render_boot("writing default dsp to flash..."); // files_store_default_dsp_name("aleph-waves.ldr"); } else { app_pause(); print_dbg("\r\n booting default ldr from flash... "); render_boot("booting DSP from flash"); // flash_read_ldr(); bfin_load_buf(); print_dbg("\r\n DSP booted, waiting to query params..."); render_boot("waiting for DSP init..."); /// blackfin should clear ready pin ASAP on boot. /// but give it a moment to accomplish that. delay_ms(2); bfin_wait_ready(); print_dbg(" requesting param report..."); render_boot("requesting DSP params"); net_report_params(); print_dbg("\r\n enable DSP audio..."); render_boot("enabling audio"); bfin_enable(); print_dbg("\r\n reading default scene... "); render_boot("reading default scene"); scene_read_default(); app_resume(); } // init pages (fill graphics buffers) print_dbg("\r\n pages_init..."); pages_init(); print_dbg("\r\n play_init..."); play_init(); // enable timers print_dbg("\r\n enable app timers..."); render_boot("enabling app timers..."); init_app_timers(); // pull up power control pin, enabling soft-powerdown gpio_set_gpio_pin(POWER_CTL_PIN); // assign app event handlers print_dbg("\r\n assigning handlers "); render_boot("assigning UI handlers..."); assign_bees_event_handlers(); // update page rendering and handlers pages_reselect(); // start in play mode pages_toggle_play(); return 1; }
// set current state of system from global RAM buffer void scene_read_buf(void) { /// pointer to serial blob const u8* src = (u8*)&(sceneData->pickle); int i; // param count reported from dsp // u32 paramsReported; //// TEST char moduleName[MODULE_NAME_LEN]; ModuleVersion moduleVersion; //// app_pause(); // store current mod name in scene desc // memcpy(modName, sceneData->desc.moduleName, MODULE_NAME_LEN); // read scene name for(i=0; i<SCENE_NAME_LEN; i++) { sceneData->desc.sceneName[i] = *src; src++; } // read bees version sceneData->desc.beesVersion.min = *src; src++; sceneData->desc.beesVersion.maj = *src; src++; src = unpickle_16(src, &(sceneData->desc.beesVersion.rev)); // read module name // target is temp module name buffer, so we can run a comparison for(i=0; i<MODULE_NAME_LEN; i++) { moduleName[i] = *src; src++; } print_dbg("\r\n unpickled module name: "); print_dbg(moduleName); // read module version sceneData->desc.moduleVersion.min = *src; src++; sceneData->desc.moduleVersion.maj = *src; src++; src = unpickle_16(src, &(sceneData->desc.moduleVersion.rev)); print_dbg("\r\n unpickled module version: "); print_dbg_ulong(sceneData->desc.moduleVersion.maj); print_dbg("."); print_dbg_ulong(sceneData->desc.moduleVersion.min); print_dbg("."); print_dbg_ulong(sceneData->desc.moduleVersion.rev); print_dbg("\r\n checking against module name from scene data: "); print_dbg(sceneData->desc.moduleName); if(strcmp(moduleName, sceneData->desc.moduleName) == 0) { print_dbg("\r\n requested module name is already loaded; skip DSP reboot."); // skip DSP load /// FIXME: should check module version too } else { strcpy(sceneData->desc.moduleName, moduleName); render_boot("loading DSP module:"); render_boot(sceneData->desc.moduleName); ///// load the DSP now! render_boot("loading module from sdcard"); print_dbg("\r\n loading module from card, filename: "); print_dbg(sceneData->desc.moduleName); files_load_dsp_name(sceneData->desc.moduleName); render_boot("waiting for module init"); print_dbg("\r\n waiting for DSP init..."); bfin_wait_ready(); #if RELEASEBUILD==1 #else // query module name / version render_boot("querying module"); print_dbg("\r\n querying module name..."); bfin_get_module_name(moduleName); print_dbg("\r\n querying module version..."); bfin_get_module_version(&moduleVersion); print_dbg("\r\n received module name: "); print_dbg((char*)moduleName); print_dbg("\r\n received module version: "); print_dbg_ulong(moduleVersion.maj); print_dbg("."); print_dbg_ulong(moduleVersion.min); print_dbg("."); print_dbg_ulong(moduleVersion.rev); #ifdef BEEKEEP #else // store in scene data render_boot("storing module version"); sceneData->desc.moduleVersion.maj = moduleVersion.maj; sceneData->desc.moduleVersion.min = moduleVersion.min; sceneData->desc.moduleVersion.rev = moduleVersion.rev; strcpy(sceneData->desc.moduleName, (const char*)moduleName); #endif #endif } // load-module case app_pause(); /// don't have to do this b/c net_unpickle will deinit anyways /* print_dbg("\r\n clearing operator list..."); net_clear_user_ops(); */ //// FIXME: use .dsc /* print_dbg("\r\n reporting DSP parameters..."); paramsReported = net_report_params(); */ /// FIXME: /// check the module version and warn if different! // there could also be a check here for mismatched parameter list. // unpickle network render_boot("reading network"); print_dbg("\r\n unpickling network for scene recall..."); src = net_unpickle(src); // unpickle presets render_boot("reading presets"); print_dbg("\r\n unpickling presets for scene recall..."); src = presets_unpickle(src); render_boot("scene data stored in RAM"); print_dbg("\r\n copied stored network and presets to RAM "); /* for(i=0; i<net->numParams; i++) { */ /* print_dbg("\r\n param "); */ /* print_dbg_ulong(i); */ /* print_dbg(" : "); */ /* print_dbg(net->params[i].desc.label); */ /* print_dbg(" ; val "); */ /* print_dbg_hex((u32)net->params[i].data.value); */ /* } */ render_boot("waiting for DSP"); bfin_wait_ready(); // update bfin parameters // if(net->numParams != paramsReported) { // print_dbg("\r\n !!!!!! WARNING ! param count from scene does not match reported count from DSP"); // render_boot("warning: param count mismatch!"); // } else { #ifdef BEEKEEP #else render_boot("sending param values"); net_send_params(); #endif // } print_dbg("\r\n sent new parameter values"); delay_ms(5); render_boot("enabling audio"); // enable audio processing bfin_enable(); app_resume(); }
// this is called from main event handler u8 app_launch(u8 firstrun) { print_dbg("\r\n launching app with firstrun: "); print_dbg_ulong(firstrun); // net_print(); render_boot("BEES"); render_boot(versionString); while (!sd_mmc_spi_mem_check()) { render_boot("waiting for SD card..."); } if(firstrun) { render_boot("launching app, first run"); print_dbg("\r\n first run, writing nonvolatile data..."); ///... write param scaler data // this is done at firstrun instead of being linked statically, // so that users can tune scaler data offline without recompiling render_boot("init param scaling data..."); flash_init_scaler_data(); print_dbg("\r\n first run, try and load default DSP"); render_boot("launching default DSP"); //// startup using default DSP name files_load_dsp_name(DEFAULT_LDR); render_boot("waiting for DSP init..."); bfin_wait_ready(); // print_dbg("\r\n enable DSP audio..."); render_boot("enabling audio"); bfin_enable(); } else { app_pause(); /// blackfin should clear ready pin ASAP on boot. /// but give it a moment to accomplish that. delay_ms(2); /// read the default scene from sd card /// this also attempts to load associated .ldr render_boot("reading default scene"); print_dbg("\r\n loading default scene. current module name from sceneData: "); print_dbg(sceneData->desc.moduleName); scene_read_default(); delay_ms(2); app_resume(); } // init pages (fill graphics buffers) render_boot("initializing gfx"); print_dbg("\r\n pages_init..."); pages_init(); print_dbg("\r\n play_init..."); play_init(); // enable timers print_dbg("\r\n enable app timers..."); render_boot("enabling app timers"); init_app_timers(); // pull up power control pin, enabling soft-powerdown // gpio_set_gpio_pin(POWER_CTL_PIN); // assign app event handlers print_dbg("\r\n assigning handlers... "); render_boot("assigning UI handlers"); assign_bees_event_handlers(); // update page rendering and handlers... pages_reselect(); // start in play mode if not firstrun if(!firstrun) pages_toggle_play(); return 1; }