static int Run() { int retval = 0; try { // Find the list of addresses at the specified VID/PID. printf("\n" "Enumerating ASR-2300 devices...\n" "--------------------------------------\n"); int addr = s_cfgDevice.Attach(); printf("Attached to ASR-2300 at address = %d\n", addr); } catch (std::runtime_error& re) { printf("Error: %s\n", re.what()); return -8; } // Dump the device information DumpDeviceInformation(); // Calibrate the device retval = DoCalibrate (); // Detach from device s_cfgDevice.Detach(); return retval; }
static int Run() { int retval = 0; try { // Find the list of addresses at the specified VID/PID. printf("\n" "Enumerating ASR-2300 devices...\n" "--------------------------------------\n"); int addr = s_cfgDevice.Attach(); printf("Attached to ASR-2300 at address = %d\n", addr); } catch (std::runtime_error& re) { printf("Error: %s\n", re.what()); return -8; } // Dump the device information DumpDeviceInformation(); printf("**\n** PLEASE MAKE SURE ALL SIGNALS ARE DISCONNECTED\n** FROM THE ASR-2300 BEFORE CALIBRATING\n**\n\n\n"); SLEEP_SEC(5); // Calibrate the device retval = DoCalibrate (); // Detach from device s_cfgDevice.Detach(); return retval; }
static int Run() { int retval = 0; try { // Find the list of addresses at the specified VID/PID. printf("\n" "Enumerating ASR-2300 devices...\n" "--------------------------------------\n"); int addr = s_config.Attach(); printf("Attached to ASR-2300 at address = %d\n", addr); } catch (std::runtime_error& re) { printf("Error: %s\n", re.what()); return -8; } //Dump the device information DumpDeviceInformation(); // grab the DCI transport interface. s_ptd = &(s_config.Dci0Transport()); //1) Tell the user what we are doing printf("--------------------------------------\n"); printf( s_pOp->szDescriptionFormat, s_fileName); printf("--------------------------------------\n"); //2) set up the BIT operations manager Dci_BitOperationMgrInit(&s_bitmgr, &OnSendMessage); //3) set up the BIT client and its callbacks. //NOTE: Make our component ID the same as the target component, so it knows //how to send the data back. This worksaround a design issue with the BIT //structure. Dci_BitClient_Init(&s_BITClient, s_pOp->idTargetComponent); s_BITClient.fncInitiateSourceTransfer = &OnBitInitiateSourceTransfer; s_BITClient.fncInitiateTargetTransfer = &OnBitInitiateTargetTransfer; s_BITClient.fncGetFrameData = &OnBitGetFrameData; s_BITClient.fncSetFrameData = &OnBitSetFrameData; s_BITClient.fncTransferComplete = &OnBitTransferComplete; //4) Register the Client with the BIT operations manager. Dci_BitRegisterClient(&s_bitmgr, &s_BITClient); // Do the specified operation retval = (*(s_pOp->fncOpHandler))(); s_config.Detach(); return retval; }
/** * <summary> * Main Program Entry Point. * </summary> */ int main(int argc, const char** argv) { int retval = 0; WriteHeader(); //Add all the arguments. s_args.AddMapEntries( s_argmap); s_s1.RegisterArgs( "s1", s_args); s_s2.RegisterArgs( "s2", s_args); //Parse the arguments. retval = s_args.Parse( argc, argv); if( retval > 0) { int addr = (int) s_args.GetLong( "address"); try { addr = s_cfgDevice.Attach(addr); printf("Attached to ASR-2300 at address = %d\n", addr); } catch (std::runtime_error& re) { printf("Error: %s0\n", re.what()); return -1; } // Dump the device information DumpDeviceInformation(); //Initialize the stream loggers. retval = s_s1.Init( s_args, &s_cfgDevice); if( retval == 0) retval = s_s2.Init( s_args, &s_cfgDevice); //Receive the data and store to disk. if( retval == 0) { s_s1.DisplayConfiguration(); s_s2.DisplayConfiguration(); s_cfgDevice.Dci0Transport().ClearReceiveQueue(); retval = ReceiveData((size_t) (s_args.GetDouble("duration")*1000.0)); } s_s1.Terminate(); s_s2.Terminate(); s_cfgDevice.Detach(); } else //Arguments were not right. { PrintUsage(); } return retval; }
static void DumpDeviceInformation () { std::string sId = s_cfgDevice.IdentifyDevice(); std::string sVer = s_cfgDevice.FirmwareVersion(); uint16 idFpga = s_cfgDevice.FpgaId(); uint16 verFpga = s_cfgDevice.FpgaVersion(); int iVer = (verFpga >> 8); int iRev = (verFpga & 0x00ff); printf("\n"); printf("Identity: %s\n", sId.c_str()); printf("FW Ver: %s\n", sVer.c_str()); printf("FPGA ID-Ver: %04X-%02X.%02X\n\n", idFpga, iVer, iRev); }
// This program demonstrates how to use the ConfigeDevice class to easily attach // to an ASR-2300 device. Then using the TransportDci to set a custom property on the default waveform // component. The property (A0) sets an LED blink rate in the custom HDL container demonstrated at the // Loctronix A2300 Open Source Webinar presentation dated 2/18/14. Be sure to build and load the corresponding // verilog container in the hdl/containers directory to use with this demo application. See // http://www.loctronix.com/news/webinars/LoctronixWebinar-2-140218.pdf for discussion and setup. int main(int, char**) { // Attach to the first device we find. ConfigDevice config; int result = config.Attach(); if( result < 0) { printf("Could not attach ASR-2300 device\n"); return result; } else printf( "ASR-2300 Device Opened\n"); //Get the FPGA ID and Version uint16 idFpga = config.FpgaId(); uint16 verFpga = config.FpgaVersion(); int iVer = (verFpga>>8); int iRev = (verFpga& 0x00ff); printf(" FPGA ID-Ver: %04X - %02X.%02X\n\n", idFpga, iVer, iRev); //Set the custom register( id = A0) setting the frequency //on the LED blinker from slowest rate to 16 times slowest rate TransportDci& dt = config.Dci0Transport(); for( uint32 i = 0; i < 4; i++) { uint32 countval = 1 + i*16; printf("Setting Blink Rate Count Value = %d\n", countval); dt.SetProperty<uint32>( 0x00, 0xA0, 1 + i*16); SLEEP_SEC(5); } //Detach from ASR-2300 config.Detach(); return(0); }
/** * <summary> * Function configures the ASR-2300 to receive a specified frequency * and then streams the data to the host via BulkDataPort interface. * </summary> */ static int ReceiveData (size_t msecDur) { int retval = 0; printf( msecDur == 0 ? "Duration: inifinite\n" : "Duration: %lu sec.\n", msecDur/1000); printf("\n--> Starting Run\n"); printf("Hit any key to stop data collection ...\n"); // start a separate thread waiting on any keyboard entry #if defined(LINUX) || defined(APPLE) pthread_t keyThread; if (pthread_create (&keyThread, NULL, KeyThreadFunc, NULL) != 0) { printf ("Error creating key entry thread; use ^C to exit data connection if necessary.\n"); } #endif //SLEEP_SEC(1); //Synchronize the RF Front-ends s_cfgDevice.SynchRfState(); //SLEEP_SEC(1); //Start the loggers. retval = s_s1.Start(msecDur, false); //Starts but does not enable. if( !retval ) s_s2.Start(msecDur, true); //Enables both, effectively synchronizing the DSP. // Periodically poll and check status of processing. while ((retval == 0) && (!s_bKeyHit)) { #if defined(HAVE_LIBUSB) retval= s_cfgDevice.Device().PollAsynchronousEvents(); #elif defined(WIN32) || defined(WIN64) Sleep(10); #endif //Check status of processing. if( !retval) retval = s_s1.CheckStatus(); if( !retval) retval = s_s2.CheckStatus(); } s_cfgDevice.Dci0Transport().ClearReceiveQueue(); s_s2.Stop(); s_s1.Stop(); printf("\n--> Completed Run\n"); // join the keyboard entry thread #if defined(LINUX) || defined(APPLE) if (!s_bKeyHit) { pthread_kill (keyThread, SIGINT); } pthread_join (keyThread, NULL); #endif return 0; }
/** * Operation Handler function implements message processing performing the specified BIT Transfer operation. */ static int DoBitTransfer() { byte buff[MAX_MSG_SIZE]; Dci_Context ctxt; memset(&ctxt, 0, sizeof(ctxt)); ctxt.pConv = s_ptd->Conversation(); byte idStatus = BSE_OperationNotAvailable; printf("\n** Initiating BIT Operation ... \n"); //Get firmware version to see if advanced bit operations supported. bool bChecksum = false; bool bOverride = false; Dci_VersionInfo vi; if( s_config.FirmwareVersionRaw( &vi)) { int ver = (vi.VerMajor <<8) + vi.VerMinor; bChecksum = ver >= 0x0101; //must be greater than 1.1.0 bOverride = ver >= 0x0101; printf(" - Checksum Validation Enabled\n - Existing Transfers Will be Terminated\n"); } fflush (stdout); if (s_pOp->dir == e_Download) { byte flags = 1; // Save the data. if( bChecksum) flags |= BCF_ChecksumValidation; if( bOverride) flags |= BCF_TerminateExisting; idStatus = Dci_BitInitiateTargetTransfer(&s_bitmgr, &s_BITClient, s_pOp->idTargetComponent, flags, 0, &ctxt); // flags: 1 == save; 0 means don't save if (idStatus != BSE_InitiatingTransfer) { printf(" Error initiating target transfer:\n"); if (idStatus == BSE_OperationNotAvailable) { printf(" Operation not available.\n"); return -5; } else { printf(" Read error.\n"); return -6; } } } else { byte flags = 1; // Save the data. if( bChecksum) flags |= BQF_ChecksumValidation; if( bOverride) flags |= BQF_TerminateExisting; Dci_BitRequestSourceTransfer(&s_bitmgr, &s_BITClient, s_pOp->idTargetComponent, flags, 0, &ctxt); } // enter while loop to process messages while BIT operation completes int nread = 0; int cntLoop = 0; while (cntLoop < 20) { memset(buff, 0, sizeof(buff)); nread = s_ptd->ReceiveMsg(buff, MAX_MSG_SIZE,5); if (nread > 0) { Dci_Hdr* pMsg = (Dci_Hdr*) buff; // Prepare the context and send received message off for // processing. memset(&ctxt, 0, sizeof(ctxt)); ctxt.pMsg = pMsg; ctxt.lenMsg = nread; ctxt.pConv = s_ptd->Conversation(); ctxt.bHandled = false; ctxt.idMessage = Dci_Hdr_MessageId(pMsg); ctxt.idComponent = 0xFF; //If WCA Message grab the component ID to help WCA // based message processing. if (pMsg->idCategory == 0x21) ctxt.idComponent = ((byte*) pMsg)[WCA_COMPONENT_INDEX ]; if (!Dci_BitProcessDciMsg(&s_bitmgr, &ctxt)) { switch( ctxt.idMessage) { case Dci_DebugMsg_Id: { Dci_DebugMsg* plog = (Dci_DebugMsg*)( pMsg); std::string smsg = TransportDci::DebugMsgToString( plog); puts( smsg.c_str()); putc( '\n', stdout); } break; default: printf("Unhandled Dci message: %04X.\n", ctxt.idMessage); break; } } // should go idle when finished if (s_bitmgr.aBitOps[0].state == DCI_BOS_IDLE) { break; } // got something; reset loop counter cntLoop = 0; } else { // got nothing; increment loop counter towards failure ++cntLoop; } } //If not transfer complete, then we had a transfer error (-7); return (s_idLastBitStatus == BSE_TransferComplete) ? 0: -7; }
static int DoCalibrate () { byte buff[DCI_MAX_MSGSIZE]; int msgSize, ctSent, ctAck; TransportDci& tDci = s_cfgDevice.Dci0Transport (); struct _rxPath { byte Value; const char* Name; }; struct _rxPath rx0Paths[] = { {(byte) RX0DPE_GpsL1Int, "GpsL1Int"}, {(byte) RX0DPE_GpsL1Ext, "GpsL1Ext"}, {(byte) RX0DPE_PcsExt, "PcsExt"}, {(byte) RX0DPE_Wideband, "Wideband"} }; const size_t numRx0Paths = sizeof(rx0Paths) / sizeof(struct _rxPath); struct _rxPath rx1Paths[] = { {(byte) RX1DPE_UhfExt, "UhfExt"}, {(byte) RX1DPE_IsmInt, "IsmInt"}, {(byte) RX1DPE_IsmExt, "IsmExt"}, {(byte) RX1DPE_Wideband, "Wideband"} }; const size_t numRx1Paths = sizeof(rx1Paths) / sizeof(struct _rxPath); struct _RxInfo { ConfigRf& cRf; byte numPaths; struct _rxPath* rxPaths; }; struct _RxInfo rxInfo[] = { {s_cfgDevice.RF0(), (byte) numRx0Paths, rx0Paths}, {s_cfgDevice.RF1(), (byte) numRx1Paths, rx1Paths} }; const size_t numRxComponents = sizeof(rxInfo) / sizeof(struct _RxInfo); // disable both Tx and Rx paths s_cfgDevice.RF0().TxPath(TX0DPE_Disabled); s_cfgDevice.RF1().TxPath(TX1DPE_Disabled); s_cfgDevice.RF0().RxPath(RX0DPE_Disabled); s_cfgDevice.RF1().RxPath(RX1DPE_Disabled); SLEEP_SEC(1); // Set the RF Profile component into cache mode printf ("Setting the RF Profile component into cache mode ...\n"); memset(buff, 0, sizeof(buff)); msgSize = Dci_ExecuteAction_Init (buff, DCI_MAX_MSGSIZE, WCACOMP_RFPROFILES, RFP_ACTION_CACHEDATA, 0, NULL); ctSent = tDci.SendMsg (buff, (size_t) msgSize, true); // get ack, and verify memset(buff, 0, sizeof(buff)); ctAck = tDci.ReceiveMsg (buff, DCI_MAX_MSGSIZE); if ((ctAck <= 0) || (ctSent != msgSize)) { printf ("Warning: Unable to set device into cache mode (%d, %d).\n", ctSent, ctAck); printf (" Proceeding anyway."); } // print received ack info if (Dci_Hdr_MessageId((Dci_Hdr*) buff) == Dci_DebugMsg_Id) { Dci_Hdr* pMsg = (Dci_Hdr*) buff; Dci_DebugMsg* plog = (Dci_DebugMsg*)( pMsg); std::string smsg = TransportDci::DebugMsgToString( plog); puts( smsg.c_str()); putc( '\n', stdout); } SLEEP_SEC(1); printf ("Done.\n"); for (byte nn = 0; nn < (byte) numRxComponents; ++nn) { // calibrate profiles for this Rx component struct _RxInfo& tRxInfo = rxInfo[nn]; // Reset Top-Level Calibration printf ("Resetting Top-Level Calibration for Rx component %d ...\n", (nn+1)); memset(buff, 0, sizeof(buff)); msgSize = Dci_ExecuteAction_Init (buff, DCI_MAX_MSGSIZE, tRxInfo.cRf.componentId(), RFACTION_RESETTOPCALIB, 0, NULL); ctSent = tDci.SendMsg (buff, (size_t) msgSize, true); // get ack, and verify memset(buff, 0, sizeof(buff)); ctAck = tDci.ReceiveMsg (buff, DCI_MAX_MSGSIZE); if ((ctAck <= 0) || (ctSent != msgSize)) { printf ("Warning: Unable to Reset Top-Level Calibration for Rx component #%d (%d, %d).\n", nn, ctSent, ctAck); printf (" Proceeding anyway."); } // print received ack info if (Dci_Hdr_MessageId((Dci_Hdr*) buff) == Dci_DebugMsg_Id) { Dci_Hdr* pMsg = (Dci_Hdr*) buff; Dci_DebugMsg* plog = (Dci_DebugMsg*)( pMsg); std::string smsg = TransportDci::DebugMsgToString( plog); puts( smsg.c_str()); putc( '\n', stdout); } SLEEP_SEC(1); printf ("Done.\n"); // Calibrate Top-Level printf ("Calibration Top-Level for Rx component %d ...\n", (nn+1)); memset(buff, 0, sizeof(buff)); msgSize = Dci_ExecuteAction_Init (buff, DCI_MAX_MSGSIZE, tRxInfo.cRf.componentId(), RFACTION_TOPCALIBRATE, 0, NULL); ctSent = tDci.SendMsg (buff, (size_t) msgSize, true); // get ack, and verify memset(buff, 0, sizeof(buff)); ctAck = tDci.ReceiveMsg (buff, DCI_MAX_MSGSIZE); if ((ctAck <= 0) || (ctSent != msgSize)) { printf ("Warning: Unable to Calibrate Top-Level for Rx component #%d (%d, %d).\n", nn, ctSent, ctAck); printf (" Proceeding anyway."); } // print received ack info if (Dci_Hdr_MessageId((Dci_Hdr*) buff) == Dci_DebugMsg_Id) { Dci_Hdr* pMsg = (Dci_Hdr*) buff; Dci_DebugMsg* plog = (Dci_DebugMsg*)( pMsg); std::string smsg = TransportDci::DebugMsgToString( plog); puts( smsg.c_str()); putc( '\n', stdout); } SLEEP_SEC(1); printf ("Done.\n"); ConfigRf& cRf = tRxInfo.cRf; // calibrate all Rx paths, one at a time for (byte mm = 0; mm < tRxInfo.numPaths; ++mm) { // Set RX Path to Calibrate struct _rxPath& thisRxPath = tRxInfo.rxPaths[mm]; cRf.RxPath(thisRxPath.Value); // Reset RX Calibration for this path printf ("Resetting Calibration for Rx component %d path %d (%s) ...\n", (nn+1), (mm+1), thisRxPath.Name); memset(buff, 0, sizeof(buff)); msgSize = Dci_ExecuteAction_Init (buff, DCI_MAX_MSGSIZE, tRxInfo.cRf.componentId(), RFACTION_RESETRXCALIB, 0, NULL); ctSent = tDci.SendMsg (buff, (size_t) msgSize, true); // get ack, and verify memset(buff, 0, sizeof(buff)); ctAck = tDci.ReceiveMsg (buff, DCI_MAX_MSGSIZE); if ((ctAck <= 0) || (ctSent != msgSize)) { printf ("Warning: Unable to Reset RX Calibration for Rx%d path %s (%d, %d).\n", nn, thisRxPath.Name, ctSent, ctAck); printf (" Proceeding anyway."); } // print received ack info if (Dci_Hdr_MessageId((Dci_Hdr*) buff) == Dci_DebugMsg_Id) { Dci_Hdr* pMsg = (Dci_Hdr*) buff; Dci_DebugMsg* plog = (Dci_DebugMsg*)( pMsg); std::string smsg = TransportDci::DebugMsgToString( plog); puts( smsg.c_str()); putc( '\n', stdout); } SLEEP_SEC(1); printf ("Done.\n"); // Calibrate this path printf ("Calibrating Rx component %d path %d (%s) ...\n", (nn+1), (mm+1), thisRxPath.Name); memset(buff, 0, sizeof(buff)); msgSize = Dci_ExecuteAction_Init (buff, DCI_MAX_MSGSIZE, tRxInfo.cRf.componentId(), RFACTION_SAVERXPROFILE, 0, NULL); ctSent = tDci.SendMsg (buff, (size_t) msgSize, true); // get ack, and verify memset(buff, 0, sizeof(buff)); ctAck = tDci.ReceiveMsg (buff, DCI_MAX_MSGSIZE); if ((ctAck <= 0) || (ctSent != msgSize)) { printf ("Warning: Unable to Calibrate Rx%d path %s (%d, %d).\n", nn, thisRxPath.Name, ctSent, ctAck); printf (" Proceeding anyway."); } // print received ack info if (Dci_Hdr_MessageId((Dci_Hdr*) buff) == Dci_DebugMsg_Id) { Dci_Hdr* pMsg = (Dci_Hdr*) buff; Dci_DebugMsg* plog = (Dci_DebugMsg*)( pMsg); std::string smsg = TransportDci::DebugMsgToString( plog); puts( smsg.c_str()); putc( '\n', stdout); } SLEEP_SEC(1); printf ("Done.\n"); } } // Save Cached Changes printf ("Saving all cached calibrations ...\n"); memset(buff, 0, sizeof(buff)); msgSize = Dci_ExecuteAction_Init (buff, DCI_MAX_MSGSIZE, WCACOMP_RFPROFILES, RFP_ACTION_SAVECHANGES, 0, NULL); ctSent = tDci.SendMsg (buff, (size_t) msgSize, true); // get ack, and verify memset(buff, 0, sizeof(buff)); ctAck = tDci.ReceiveMsg (buff, DCI_MAX_MSGSIZE); if ((ctAck <= 0) || (ctSent != msgSize)) { printf ("Warning: Unable to set device into cache mode (%d, %d).\n", ctSent, ctAck); printf (" Proceeding anyway."); } // print received ack info if (Dci_Hdr_MessageId((Dci_Hdr*) buff) == Dci_DebugMsg_Id) { Dci_Hdr* pMsg = (Dci_Hdr*) buff; Dci_DebugMsg* plog = (Dci_DebugMsg*)( pMsg); std::string smsg = TransportDci::DebugMsgToString( plog); puts( smsg.c_str()); putc( '\n', stdout); } printf ("Done.\n"); // disable both Tx and Rx paths s_cfgDevice.RF0().TxPath(TX0DPE_Disabled); s_cfgDevice.RF1().TxPath(TX1DPE_Disabled); s_cfgDevice.RF0().RxPath(RX0DPE_Disabled); s_cfgDevice.RF1().RxPath(RX1DPE_Disabled); return 0; }