bool MenuState::onEnter() { SoundManager::Instance()->playMusic("SongMenu", -1); SDL_Renderer* render; render = Game::Instance()->getRender(); SDL_SetRenderDrawColor(render, 255, 229, 204, 255); Game::Instance()->setRender(render); // parse the state StateParser stateParser; stateParser.parseState("assets/images.xml", s_menuID, &m_gameObjectsMenuState, &m_textureIDList); m_callbacksMenu.push_back(0); //pushback 0 callbackID start from 1 m_callbacksMenu.push_back(s_menuToPlay); m_callbacksMenu.push_back(s_exitFromMenu); // set the callbacks for menu items setCallbacks(m_callbacksMenu); return true; }
int main() { int i,result; fd_set readfds; struct timeval tv; printf("Initializing OSIP\n"); TRACE_INITIALIZE(END_TRACE_LEVEL,NULL); if(networkInit() < 0){ printf("ERROR Initializing NETWORK\n"); return -1; } i=osip_init(&osip); if (i!=0) return -1; printf("Setting Callbacks\n"); setCallbacks(osip); printf("Entering Main loop 1\n"); OSIP_TRACE(osip_trace(__FILE__,__LINE__,OSIP_BUG,NULL,"Check OSIP_TRACE init\n")); bSipRegister("This is Test Cookie"); while(1){ FD_ZERO(&readfds); FD_SET(sipSock,&readfds); tv.tv_sec = 0; tv.tv_usec = 100000; result = select(FD_SETSIZE,&readfds,0,0,&tv); if(result < 0){ perror("main: select error"); exit(1); } if(FD_ISSET(sipSock,&readfds)){ printf("main: Received SIP message\n"); processSipMsg(); } osip_ict_execute(osip); osip_ist_execute(osip); osip_nict_execute(osip); osip_nist_execute(osip); osip_timers_ict_execute(osip); osip_timers_ist_execute(osip); osip_timers_nict_execute(osip); osip_timers_nist_execute(osip); } return 0; }
bool MenuState::onEnter() { if (!TextureManager::Instance()->load("play.bmp", "play", Game::Instance()->getRender())) { return false; } if (!TextureManager::Instance()->load("exit.bmp", "exit", Game::Instance()->getRender())) { return false; } StateParser stateParser; stateParser.parseState("XMLFile.xml", s_menuID, &m_gameObjects, &m_textureIDList); m_callbacks.push_back(0); //El primero vacío m_callbacks.push_back(s_menuToPlay); m_callbacks.push_back(s_exitFromMenu); setCallbacks(m_callbacks); return true; }
bool PlayState::onEnter() { StateParser stateParser; stateParser.parseState("./Data/Tiny.xml", s_playID, &m_gObjects, &m_TextureIDList); LevelParser levelParser; pLevel = levelParser.parseLevel("./Data/mapaObjetos.tmx"); //layerParser.parseTileLayer("./Data/mapa1.tmx"); m_callbacks.push_back(0); setCallbacks(); SoundManager::Instance()->playMusic("play", -1); /*player = new Player(); zep = new Zep(); gordo = new Gordo(); TextureManager::Instance()->load("Kirby.bmp", "player", Game::Instance()->getRender()); TextureManager::Instance()->load("ZepS.bmp", "zep", Game::Instance()->getRender()); TextureManager::Instance()->load("GordoS.bmp", "gordo", Game::Instance()->getRender()); load = new LoaderParams(100, 100, 35, 32,10, "player",0); load2 = new LoaderParams(200, 200, 89, 78,4, "zep",0); load3 = new LoaderParams(400, 300, 50, 70,4, "gordo", 0); player->load(load); m_gObjects.push_back(player); zep->load(load2); m_gObjects.push_back(zep); gordo->load(load3); m_gObjects.push_back(gordo);*/ return true; }
void VlcQmlVideoObject::connectToMediaPlayer(VlcMediaPlayer *player) { setCallbacks(player); }
int main(int argc, const char **argv) #endif { bContext *C = CTX_create(); SYS_SystemHandle syshandle; #ifndef WITH_PYTHON_MODULE bArgs *ba; #endif #ifdef WIN32 wchar_t **argv_16 = CommandLineToArgvW(GetCommandLineW(), &argc); int argci = 0; char **argv = MEM_mallocN(argc * sizeof(char *), "argv array"); for (argci = 0; argci < argc; argci++) { argv[argci] = alloc_utf_8_from_16(argv_16[argci], 0); } LocalFree(argv_16); #endif #ifdef WITH_PYTHON_MODULE #ifdef __APPLE__ environ = *_NSGetEnviron(); #endif #undef main evil_C = C; #endif #ifdef WITH_BINRELOC br_init(NULL); #endif #ifdef WITH_LIBMV libmv_initLogging(argv[0]); #endif setCallbacks(); #if defined(__APPLE__) && !defined(WITH_PYTHON_MODULE) /* patch to ignore argument finder gives us (pid?) */ if (argc == 2 && strncmp(argv[1], "-psn_", 5) == 0) { extern int GHOST_HACK_getFirstFile(char buf[]); static char firstfilebuf[512]; argc = 1; if (GHOST_HACK_getFirstFile(firstfilebuf)) { argc = 2; argv[1] = firstfilebuf; } } #endif #ifdef __FreeBSD__ fpsetmask(0); #endif /* initialize path to executable */ BLI_init_program_path(argv[0]); BLI_threadapi_init(); initglobals(); /* blender.c */ IMB_init(); BKE_images_init(); BKE_brush_system_init(); BLI_callback_global_init(); #ifdef WITH_GAMEENGINE syshandle = SYS_GetSystem(); #else syshandle = 0; #endif /* first test for background */ #ifndef WITH_PYTHON_MODULE ba = BLI_argsInit(argc, (const char **)argv); /* skip binary path */ setupArguments(C, ba, &syshandle); BLI_argsParse(ba, 1, NULL, NULL); if (use_crash_handler) { /* after parsing args */ signal(SIGSEGV, blender_crash_handler); } #else G.factory_startup = true; /* using preferences or user startup makes no sense for py-as-module */ (void)syshandle; #endif #ifdef WITH_FFMPEG IMB_ffmpeg_init(); #endif /* after level 1 args, this is so playanim skips RNA init */ RNA_init(); RE_engines_init(); init_nodesystem(); /* end second init */ #if defined(WITH_PYTHON_MODULE) || defined(WITH_HEADLESS) G.background = true; /* python module mode ALWAYS runs in background mode (for now) */ #else /* for all platforms, even windos has it! */ if (G.background) { signal(SIGINT, blender_esc); /* ctrl c out bg render */ } #endif /* background render uses this font too */ BKE_vfont_builtin_register(datatoc_bfont_pfb, datatoc_bfont_pfb_size); /* Initialize ffmpeg if built in, also needed for bg mode if videos are * rendered via ffmpeg */ sound_init_once(); init_def_material(); if (G.background == 0) { #ifndef WITH_PYTHON_MODULE BLI_argsParse(ba, 2, NULL, NULL); BLI_argsParse(ba, 3, NULL, NULL); #endif WM_init(C, argc, (const char **)argv); /* this is properly initialized with user defs, but this is default */ /* call after loading the startup.blend so we can read U.tempdir */ BLI_init_temporary_dir(U.tempdir); #ifdef WITH_SDL BLI_setenv("SDL_VIDEODRIVER", "dummy"); #endif } else { #ifndef WITH_PYTHON_MODULE BLI_argsParse(ba, 3, NULL, NULL); #endif WM_init(C, argc, (const char **)argv); /* don't use user preferences temp dir */ BLI_init_temporary_dir(NULL); } #ifdef WITH_PYTHON /** * NOTE: the U.pythondir string is NULL until WM_init() is executed, * so we provide the BPY_ function below to append the user defined * python-dir to Python's sys.path at this point. Simply putting * WM_init() before #BPY_python_start() crashes Blender at startup. */ /* TODO - U.pythondir */ #else printf("\n* WARNING * - Blender compiled without Python!\nthis is not intended for typical usage\n\n"); #endif CTX_py_init_set(C, 1); WM_keymap_init(C); #ifdef WITH_FREESTYLE /* initialize Freestyle */ FRS_initialize(); FRS_set_context(C); #endif /* OK we are ready for it */ #ifndef WITH_PYTHON_MODULE BLI_argsParse(ba, 4, load_file, C); if (G.background == 0) { if (!G.file_loaded) if (U.uiflag2 & USER_KEEP_SESSION) WM_recover_last_session(C, NULL); } #endif #ifndef WITH_PYTHON_MODULE BLI_argsFree(ba); #endif #ifdef WIN32 while (argci) { free(argv[--argci]); } MEM_freeN(argv); argv = NULL; #endif #ifdef WITH_PYTHON_MODULE return 0; /* keep blender in background mode running */ #endif if (G.background) { /* actually incorrect, but works for now (ton) */ WM_exit(C); } else { if (G.fileflags & G_FILE_AUTOPLAY) { if (G.f & G_SCRIPT_AUTOEXEC) { if (WM_init_game(C)) { return 0; } } else { if (!(G.f & G_SCRIPT_AUTOEXEC_FAIL_QUIET)) { G.f |= G_SCRIPT_AUTOEXEC_FAIL; BLI_snprintf(G.autoexec_fail, sizeof(G.autoexec_fail), "Game AutoStart"); } } } if (!G.file_loaded) { WM_init_splash(C); } } WM_main(C); return 0; } /* end of int main(argc, argv) */
int main() { const std::string checkFile = "shader/flush.frag"; if (!std::ifstream(checkFile).good()) { glow::fatal("Seems that Elemate is running in a wrong working directory."); glow::fatal("(Cannot find %;)", checkFile); fgetc(stdin); return -1; } if (!glfwInit()) { glow::fatal("Could not initialize glfw."); return -1; } glfwSetErrorCallback(errorCallback); const int initialWidth = 640; const int initialHeight = 480; glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, MajorVersionRequire); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, MinorVersionRequire); #ifndef BUMBLEBEE // Running with bumblebee causes the following commands to crash. glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); if (MajorVersionRequire >= 3 && MinorVersionRequire >= 2) glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); #endif GLFWwindow * window = glfwCreateWindow(initialWidth, initialHeight, "Elemate", NULL, NULL); if (!window) { glow::fatal("glfw window creation failed."); glfwTerminate(); return -1; } glfwMakeContextCurrent(window); setCallbacks(window); checkVersion(); // GLOW takes care of initializing GLEW correctly. if (!glow::init()) { glow::fatal("GLOW initialization failed."); return -1; } glow::debugmessageoutput::enable(); Game * game = new Game(*window); eventHandler = new EventHandler(*window, *game); eventHandler->handeResizeEvent(initialWidth, initialHeight); game->start(); delete eventHandler; delete game; glfwTerminate(); return 0; }
void AboutState::initCallbacks() { m_callbacks.push_back(0); // pushback 0 callbackID start from 1 m_callbacks.push_back(s_exitFromAbout); // set the callbacks for menu items setCallbacks(m_callbacks); }
/** Start the Module and join a network, using the AF/ZDO interface. Reads RF Operating Region (US/EU) from GPIO. @param moduleConfiguration the settings to use to start the module @param applicationConfiguration the settings to use to start the Zigbee Application @see struct moduleConfiguration in module_utilities.h for information about each field of the moduleConfiguration @see struct applicationConfiguration in application_configuration.h for information about each field of the applicationConfiguration @see module.c for more information about each of these steps. */ moduleResult_t startModule(const struct moduleConfiguration* mc, const struct applicationConfiguration* ac) { printf("Module Startup\r\n"); /* Initialize the Module */ RETURN_RESULT_IF_FAIL(moduleReset(), METHOD_START_MODULE); /* Clear out any old network or state information (if requested) */ RETURN_RESULT_IF_FAIL(setStartupOptions(mc->startupOptions), METHOD_START_MODULE); /* This section is for reading Operating region from GPIO pins - omit if using different method */ /* First, configure GPIOs as inputs: */ RETURN_RESULT_IF_FAIL(sysGpio(GPIO_SET_DIRECTION , GPIO_DIRECTION_ALL_INPUTS), METHOD_START_MODULE); RETURN_RESULT_IF_FAIL(sysGpio(GPIO_SET_INPUT_MODE , GPIO_INPUT_MODE_ALL_PULL_UPS), METHOD_START_MODULE); /* Now, read GPIO inputs 0 & 1: */ RETURN_RESULT_IF_FAIL(sysGpio(GPIO_READ, (GPIO_0 | GPIO_1)), METHOD_START_MODULE); /* The operating region (US vs. EU etc.) is based on DIP Switch settings, read from GPIO 0 & 1 */ uint16_t moduleRegion = zmBuf[SYS_GPIO_READ_RESULT_FIELD]; /*** Done reading GPIO inputs. If application needs them as outputs then configure accordingly ***/ /* Reset the Module to apply the changes we just set */ RETURN_RESULT_IF_FAIL(moduleReset(), METHOD_START_MODULE); /* Read the productId - this indicates the model of module used. */ uint8_t productId = zmBuf[SYS_RESET_IND_PRODUCTID_FIELD]; /* If this is not valid (bad firmware) then stop */ RETURN_RESULT_IF_EXPRESSION_TRUE((productId < MINIMUM_BUILD_ID), METHOD_START_MODULE, ZM_INVALID_MODULE_CONFIGURATION); /* Configure the module's RF output */ setModuleRfPower(productId, moduleRegion); /* Set any end device options */ if (mc->deviceType == END_DEVICE) RETURN_RESULT_IF_FAIL(setPollRate(mc->endDevicePollRate), METHOD_START_MODULE); /* Configure which RF Channels to use. If none set then this will default to 11. */ RETURN_RESULT_IF_FAIL(setZigbeeDeviceType(mc->deviceType), METHOD_START_MODULE); // Set Zigbee Device Type RETURN_RESULT_IF_FAIL(setChannelMask(mc->channelMask), METHOD_START_MODULE); RETURN_RESULT_IF_FAIL(setPanId(mc->panId), METHOD_START_MODULE); RETURN_RESULT_IF_FAIL(setCallbacks(CALLBACKS_ENABLED), METHOD_START_MODULE); // Note: ZCD_NV_SECURITY_MODE defaults to 01 if (mc->securityMode != SECURITY_MODE_OFF) // Note: If a coordinator has ZCD_NV_SECURITY_MODE = 00, router must have ZCD_NV_SECURITY_MODE = 01 or else they won't communicate { RETURN_RESULT_IF_FAIL(setSecurityMode(mc->securityMode), METHOD_START_MODULE); RETURN_RESULT_IF_FAIL(setSecurityKey(mc->securityKey), METHOD_START_MODULE); } if (ac == GENERIC_APPLICATION_CONFIGURATION) //TODO: use custom applicationFramework if this isn't null: { RETURN_RESULT_IF_FAIL(afRegisterGenericApplication(), METHOD_START_MODULE); // Configure the Module for our application } else { printf("Custom Application Frameworks not supported\r\n"); return INVALID_PARAMETER; } RETURN_RESULT_IF_FAIL(zdoStartApplication(), METHOD_START_MODULE); // Start your engines /* Wait until this device has joined a network. Device State will change to DEV_ROUTER, DEV_END_DEVICE, or DEV_COORD to indicate that the device has correctly joined a network. */ #ifdef ZDO_STATE_CHANGE_IND_HANDLED_BY_APPLICATION //if you're handling this in your application instead... return MODULE_SUCCESS; #else #define TEN_SECONDS 10000 #define FIFTEEN_SECONDS 15000 #define START_TIMEOUT FIFTEEN_SECONDS RETURN_RESULT(waitForDeviceState(getDeviceStateForDeviceType(mc->deviceType), START_TIMEOUT), METHOD_START_MODULE); #endif }
/** Starts module using an operating region as a parameter. This does NOT read the GPIO pin to set the region. @param mc the module configuration - what RF channel, which PAN ID, etc. These options are used in this expressStartModule function as arguments to the various functions. @param ac the Zigbee application configuration - which endpoint to use and other global settings. If not using GENERIC_APPLICATION_CONFIGURATION then you must #define the compilation option SUPPORT_CUSTOM_APPLICATION_CONFIGURATION. Normally this option is NOT defined to reduce code size. @param moduleRegion - which region of the world to use to ensure FCC/ETSI compliance. */ moduleResult_t expressStartModule(const struct moduleConfiguration* mc, const struct applicationConfiguration* ac, const uint8_t moduleRegion) { printf("Express Startup "); /* Initialize the Module */ RETURN_RESULT_IF_FAIL(moduleReset(), METHOD_EXPRESS_START_MODULE); /* Clear out any old network or state information (if requested) */ printf("Startup Options 0x%02X\r\n", mc->startupOptions); RETURN_RESULT_IF_FAIL(setStartupOptions(mc->startupOptions), METHOD_EXPRESS_START_MODULE); /* Reset the Module to apply the changes we just set */ RETURN_RESULT_IF_FAIL(moduleReset(), METHOD_EXPRESS_START_MODULE); /* Read the productId - this indicates the model of module used. */ uint8_t productId = zmBuf[SYS_RESET_IND_PRODUCTID_FIELD]; /* If this is not valid (bad firmware) then stop */ RETURN_RESULT_IF_EXPRESSION_TRUE((productId < MINIMUM_BUILD_ID), METHOD_EXPRESS_START_MODULE, ZM_INVALID_MODULE_CONFIGURATION); /* Configure the module's RF output */ setModuleRfPower(productId, moduleRegion); /* Set any end device options */ if (mc->deviceType == END_DEVICE) { RETURN_RESULT_IF_FAIL(setPollRate(mc->endDevicePollRate), METHOD_EXPRESS_START_MODULE); } /* Override for testing low power operation - referenced in Basic Comms ED example*/ #ifdef DISABLE_END_DEVICE_POLLING RETURN_RESULT_IF_FAIL(setPollRate(0), METHOD_EXPRESS_START_MODULE); #endif /* Configure the Zigbee Device Type (Coordinator, Router, End Device */ RETURN_RESULT_IF_FAIL(setZigbeeDeviceType(mc->deviceType), METHOD_EXPRESS_START_MODULE); /* Configure which RF Channels to use. If none set then this will default to a default set. */ RETURN_RESULT_IF_FAIL(setChannelMask(mc->channelMask), METHOD_EXPRESS_START_MODULE); /* Set the PAN ID, if you want to restrict the module to only a particular PAN ID. */ RETURN_RESULT_IF_FAIL(setPanId(mc->panId), METHOD_EXPRESS_START_MODULE); RETURN_RESULT_IF_FAIL(setCallbacks(CALLBACKS_ENABLED), METHOD_EXPRESS_START_MODULE); /* Set security mode and security key if required. Note: If a coordinator has ZCD_NV_SECURITY_MODE = 00 then router must have ZCD_NV_SECURITY_MODE = 01 or else they won't communicate */ if (mc->securityMode != SECURITY_MODE_OFF) { RETURN_RESULT_IF_FAIL(setSecurityMode(mc->securityMode), METHOD_EXPRESS_START_MODULE); RETURN_RESULT_IF_FAIL(setSecurityKey(mc->securityKey), METHOD_EXPRESS_START_MODULE); } #ifdef SUPPORT_CUSTOM_APPLICATION_CONFIGURATION if (ac == GENERIC_APPLICATION_CONFIGURATION) { RETURN_RESULT_IF_FAIL(afRegisterGenericApplication(), METHOD_EXPRESS_START_MODULE); // Configure the Module for our application } else { RETURN_RESULT_IF_FAIL(afRegisterApplication(ac), METHOD_EXPRESS_START_MODULE); } #else if (ac == GENERIC_APPLICATION_CONFIGURATION) { RETURN_RESULT_IF_FAIL(afRegisterGenericApplication(), METHOD_EXPRESS_START_MODULE); // Configure the Module for our application } else { /* Note: to use a custom application configuration, you must #define SUPPORT_CUSTOM_APPLICATION_CONFIGURATION. */ return INVALID_PARAMETER; } #endif /* Note: you can register more than one Zigbee endpoint; just call afRegisterApplication() here for the next endpoint */ /* Start the module with the registered application configuration */ RETURN_RESULT_IF_FAIL(zdoStartApplication(), METHOD_EXPRESS_START_MODULE); /* Wait until this device has joined a network. Device State will change to DEV_ROUTER, DEV_END_DEVICE, or DEV_COORD to indicate that the device has correctly joined a network. */ #ifdef ZDO_STATE_CHANGE_IND_HANDLED_BY_APPLICATION //if you're handling this in your application instead... return MODULE_SUCCESS; #else #define TEN_SECONDS 10000 #define FIFTEEN_SECONDS 15000 RETURN_RESULT(waitForDeviceState(getDeviceStateForDeviceType(mc->deviceType), FIFTEEN_SECONDS), METHOD_EXPRESS_START_MODULE); #endif }
int main( void ) { halInit(); printf("\r\n****************************************************\r\n"); printf("Basic Communications Example - COORDINATOR - using AFZDO\r\n"); HAL_ENABLE_INTERRUPTS(); setLed(0); /* Initialize the ZNP */ printf("Initializing the ZNP "); znpInit(); handleReturnValue(); /* Set Startup Options (will restore the ZNP to default values on reset) */ printf("Setting StartupOptions "); setStartupOptions(STARTOPT_CLEAR_CONFIG + STARTOPT_CLEAR_STATE); handleReturnValue(); /* Reset the ZNP */ printf("Reset the ZNP "); znpReset(); handleReturnValue(); /* Set Zigbee Device Type to be COORDINATOR */ printf("Setting Zigbee Device Type "); setZigbeeDeviceType(COORDINATOR); handleReturnValue(); /* Enabling Callbacks (required to receive ZDO_IEEE_ADDR_RSP) */ //#ifdef FIND_MAC_ADDRESS_OF_SENDER //define this to print out sender's MAC address printf("Enabling Callbacks "); setCallbacks(CALLBACKS_ENABLED); handleReturnValue(); //#endif /* Configure the ZNP for our application */ printf("Registering Application "); afRegisterGenericApplication(); handleReturnValue(); /* Now, start the application. We will receive a START_REQUEST_SRSP, and then if it is successful, a START_CONFIRM. */ printf("Starting the Application "); zdoStartApplication(); handleReturnValue(); /** Wait until we get on the network. We will receive a ZDO_STATE_CHANGE_IND message whenever the state changes. */ waitForDeviceState(DEV_ZB_COORD); printf("On Network!\r\n"); setLed(1); /* On network, display info about this network */ #ifdef DISPLAY_NETWORK_INFORMATION getNetworkConfigurationParameters(); getDeviceInformation(); #endif /* Now the network is running - continually poll for any received messages from the ZNP */ #ifdef FIND_MAC_ADDRESS_OF_SENDER //define this to print out sender's MAC address displayReceivedMessagesAndFindDevice(); #else displayReceivedMessages(); #endif }
int main( void ) { halInit(); //Sets up all hardware inc debug Tx/Rx (Used for WiFi <--> ZNP) printf("\r\n++++++++++++++++++++++++++++++++++++++++++++++++++++\r\n"); printf("\r\nBasic Communications Example - COORDINATOR - using Simple API\r\n"); HAL_ENABLE_INTERRUPTS(); setLed(0); //Simple check to ensure that both security options weren't #defined. #if defined(USE_SECURITY_MODE_PRECONFIGURED_KEYS) && defined(USE_SECURITY_MODE_COORD_DIST_KEYS) printf("ERROR\r\n"); while (1); #endif /* Initialize the ZNP */ printf("Initializing the ZNP\r\n"); znpInit(); handleReturnValue(); /* Set Startup Options (will restore the ZNP to default values on reset) */ printf("Setting StartupOptions\r\n"); setStartupOptions(STARTOPT_CLEAR_CONFIG + STARTOPT_CLEAR_STATE); handleReturnValue(); /* Reset the ZNP */ printf("Reset the ZNP\r\n"); znpReset(); handleReturnValue(); /* Set Zigbee Device Type to be COORDINATOR */ printf("Setting Zigbee Device Type\r\n"); setZigbeeDeviceType(COORDINATOR); handleReturnValue(); /* Enabling Callbacks (required to receive ZDO_IEEE_ADDR_RSP) */ printf("Enabling Callbacks\r\n"); setCallbacks(CALLBACKS_ENABLED); handleReturnValue(); /* Configure security mode, if it is being used */ #ifdef USE_SECURITY_MODE_PRECONFIGURED_KEYS printf("SECURITY ON WITH PRECONFIGURED KEYS\r\n"); /* Turn security ON with pre-configured keys */ setSecurityMode(SECURITY_MODE_PRECONFIGURED_KEYS); handleReturnValue(); /* All devices on the network must be loaded with the same key */ setSecurityKey(key); handleReturnValue(); #endif #ifdef USE_SECURITY_MODE_COORD_DIST_KEYS printf("SECURITY ON WITH COORDINATOR DISTRIBUTING KEYS\r\n"); /* Turn security ON with the coordinator distributing keys. */ setSecurityMode(SECURITY_MODE_COORD_DIST_KEYS); handleReturnValue(); /* This is the key that will be distributed to other devices when they attempt to join */ setSecurityKey(key); handleReturnValue(); #endif #if !defined(USE_SECURITY_MODE_PRECONFIGURED_KEYS) && !defined(USE_SECURITY_MODE_COORD_DIST_KEYS) printf("SECURITY OFF\r\n"); #endif /* Configure the ZNP for our application: */ printf("Registering Application\r\n"); sapiRegisterGenericApplication(); handleReturnValue(); /* Now, start the application. We will receive a START_REQUEST_SRSP, and then if it is successful, a START_CONFIRM. */ printf("Starting the Application\r\n"); sapiStartApplication(); handleReturnValue(); printf("On Network!\r\n"); setLed(1); /* On network, display info about this network */ #ifdef DISPLAY_NETWORK_INFORMATION getNetworkConfigurationParameters(); getDeviceInformation(); #endif /* Now the network is running - continually poll for any received messages from the ZNP */ //displayReceivedMessages(); while(1) { /* int light = getLightSense(); if(light > 100) { sendData(0xC72, 0xF, 0x1, 1); } else { sendData(0xC72, 0xF, 0x2, 1); } */ int cmd = readUART(); //Read UART //Depending on command, send appropriate message to relevant end point switch (cmd) { case CLOSE1: //sendData(dest, cluster, data, dataLength); sendData(0xC72, 0xF, 0x1, 1); break; case OPEN1: sendData(0xC72, 0xF, 0x2, 1); break; case FILM1: sendData(0xC72, 0xF, 0x3, 1); break; case DAY1: sendData(0xC72, 0xF, 0x4, 1); break; case NIGHT1: sendData(0xC72, 0xF, 0x5, 1); break; case CLOSE2: sendData(0xC72, 0xF, 0x6, 1); break; case OPEN2: sendData(0xC72, 0xF, 0x7, 1); break; case FILM2: sendData(0xC72, 0xF, 0x8, 1); break; case DAY2: sendData(0xC72, 0xF, 0x9, 1); break; case NIGHT2: sendData(0xC72, 0xF, 0xA, 1); break; default: break; } } }
TetraTrace::TetraTrace(int argc, char *argv[]) { Covise::set_module_description("perform particle-trace on tetrahedra-grids"); Covise::add_port(INPUT_PORT, "gridIn", "UnstructuredGrid", "tetrahedra-grid"); Covise::add_port(INPUT_PORT, "velIn", "Vec3", "velocity input"); Covise::add_port(INPUT_PORT, "volIn", "Float", "volumes of tetrahedras"); Covise::add_port(INPUT_PORT, "neighborIn", "Float", "neighbors of tetrahedras"); Covise::add_port(OUTPUT_PORT, "traceOut", "Points|Polygons|Lines|TriangleStrips", "computed trace"); Covise::add_port(OUTPUT_PORT, "dataOut", "Float|Vec3", "data to be mapped on the trace"); Covise::add_port(PARIN, "startpoint1", "FloatVector", "..."); Covise::set_port_default("startpoint1", "1.0 1.0 1.0"); Covise::add_port(PARIN, "startpoint2", "FloatVector", "..."); Covise::set_port_default("startpoint2", "1.0 2.0 1.0"); Covise::add_port(PARIN, "normal", "FloatVector", "..."); Covise::set_port_default("normal", "0.0 0.0 1.0"); Covise::add_port(PARIN, "direction", "FloatVector", "..."); Covise::set_port_default("direction", "1.0 0.0 0.0"); Covise::add_port(PARIN, "numStart", "IntScalar", "number of traces to start"); Covise::set_port_default("numStart", "10"); Covise::add_port(PARIN, "startStep", "IntScalar", "initial timestep (transient only)"); Covise::set_port_default("startStep", "1"); Covise::add_port(PARIN, "whatOut", "Choice", "what data should we compute"); Covise::set_port_default("whatOut", "1 number velocity magnitude"); Covise::add_port(PARIN, "startStyle", "Choice", "how to compute starting-points"); Covise::set_port_default("startStyle", "1 line plane sphere box"); Covise::add_port(PARIN, "traceStyle", "Choice", "how to output the trace"); Covise::set_port_default("traceStyle", "1 points lines easymesh mesh fader"); Covise::add_port(PARIN, "numSteps", "IntScalar", "number of steps to compute"); Covise::set_port_default("numSteps", "100"); Covise::add_port(PARIN, "stepDuration", "FloatScalar", "duration of each step"); Covise::set_port_default("stepDuration", "0.01"); Covise::add_port(PARIN, "numNodes", "IntScalar", "number of nodes/processors to use"); Covise::set_port_default("numNodes", "1"); Covise::add_port(PARIN, "multiProcMode", "Choice", "which multi-processing mode to use"); Covise::set_port_default("multiProcMode", "1 none SMP MMP"); Covise::add_port(PARIN, "searchMode", "Choice", "which searching-algorithm to use for startcells"); Covise::set_port_default("searchMode", "1 quick save"); Covise::init(argc, argv); const char *in_names[] = { "gridIn", "velIn", "volIn", "neighborIn", NULL }; const char *out_names[] = { "traceOut", "dataOut", NULL }; setPortNames(in_names, out_names); setComputeTimesteps(0); setCallbacks(); return; };
int main( void ) { halInit(); printf("\r\n****************************************************\r\n"); printf("Secure Communications Example - COORDINATOR - using AFZDO\r\n"); HAL_ENABLE_INTERRUPTS(); setLed(0); //Simple idiot check to ensure that we didn't accidentally define both security options. #if defined(USE_SECURITY_MODE_PRECONFIGURED_KEYS) && defined(USE_SECURITY_MODE_COORD_DIST_KEYS) printf("ERROR - only select one security option!\r\n"); while (1); #endif /* Initialize the ZNP */ printf("Initializing the ZNP\r\n"); znpInit(); handleReturnValue(); /* Set Startup Options (will restore the ZNP to default values on reset) */ printf("Setting StartupOptions\r\n"); setStartupOptions(STARTOPT_CLEAR_CONFIG + STARTOPT_CLEAR_STATE); handleReturnValue(); /* Set Zigbee Device Type to be COORDINATOR */ printf("Setting Zigbee Device Type\r\n"); setZigbeeDeviceType(COORDINATOR); handleReturnValue(); /* Enabling Callbacks (required to receive ZDO_IEEE_ADDR_RSP) */ printf("Enabling Callbacks\r\n"); setCallbacks(CALLBACKS_ENABLED); handleReturnValue(); /* Reset the ZNP */ printf("Reset the ZNP\r\n"); znpReset(); handleReturnValue(); /* Configure security mode, if it is being used */ #ifdef USE_SECURITY_MODE_PRECONFIGURED_KEYS printf("SECURITY ON WITH PRECONFIGURED KEYS\r\n"); /* Turn security ON with pre-configured keys */ setSecurityMode(SECURITY_MODE_PRECONFIGURED_KEYS); handleReturnValue(); /* All devices on the network must be loaded with the same key */ setSecurityKey(key); handleReturnValue(); #endif #ifdef USE_SECURITY_MODE_COORD_DIST_KEYS printf("SECURITY ON WITH COORDINATOR DISTRIBUTING KEYS\r\n"); /* Turn security ON with the coordinator distributing keys. */ setSecurityMode(SECURITY_MODE_COORD_DIST_KEYS); handleReturnValue(); /* This is the key that will be distributed to other devices when they attempt to join */ setSecurityKey(key); handleReturnValue(); #endif /** Note: if no security option is selected then this will behave like a normal coordinator and will accept join requests from any device. */ #if !defined(USE_SECURITY_MODE_PRECONFIGURED_KEYS) && !defined(USE_SECURITY_MODE_COORD_DIST_KEYS) printf("WARNING - NO SECURITY OPTION SELECTED; SECURITY OFF\r\n"); #endif /* Configure the ZNP for our application */ printf("Registering Application\r\n"); afRegisterGenericApplication(); handleReturnValue(); /* Now, start the application. We will receive a START_REQUEST_SRSP, and then if it is successful, a START_CONFIRM. */ printf("Starting the Application\r\n"); zdoStartApplication(); handleReturnValue(); /** Wait until we get on the network. We will receive a ZDO_STATE_CHANGE_IND message whenever the state changes. */ waitForDeviceState(DEV_ZB_COORD); printf("On Network!\r\n"); setLed(1); /* On network, display info about this network */ #ifdef DISPLAY_NETWORK_INFORMATION getNetworkConfigurationParameters(); getDeviceInformation(); #endif /* Now the network is running - continually poll for any received messages from the ZNP */ if (SRDY_IS_HIGH()) pollAndDisplay(); displayReceivedMessages(); }
void VlcQmlVideoObject::connectToMediaPlayer(VlcMediaPlayer *mediaObject) { setCallbacks(mediaObject); }