int demo_start_frame_buffer( demo_t *pdemo )
{
if ( pdemo->bVerbose )
{
xil_printf("VDMA 0 Initialization\r\n");
}
XAxiVdma_Reset(pdemo->paxivdma0, XAXIVDMA_WRITE);
XAxiVdma_Reset(pdemo->paxivdma0, XAXIVDMA_READ);
WriteSetup(pdemo->paxivdma0, 0x10000000, 0, 1, 1, 0, 0, pdemo->hdmii_width, pdemo->hdmii_height, 2048, 2048);
ReadSetup(pdemo->paxivdma0, 0x10000000, 0, 1, 1, 0, 0, pdemo->hdmio_width, pdemo->hdmio_height, 2048, 2048);
StartTransfer(pdemo->paxivdma0);
if ( pdemo->bVerbose )
{
xil_printf("VDMA 1 Initialization\r\n");
}
XAxiVdma_Reset(pdemo->paxivdma1, XAXIVDMA_WRITE);
XAxiVdma_Reset(pdemo->paxivdma1, XAXIVDMA_READ);
WriteSetup(pdemo->paxivdma1, 0x18000000, 0, 1, 1, 0, 0, 1280, 1024, 2048, 2048);
ReadSetup(pdemo->paxivdma1, 0x18000000, 0, 1, 1, 0, 0, 1280, 1024, 2048, 2048);
StartTransfer(pdemo->paxivdma1);
if ( pdemo->bVerbose )
{
xil_printf("OSD Initialization (hdmi=0x%02X, cam=0x%02X)\r\n", pdemo->hdmi_alpha, pdemo->cam_alpha);
}
XOSD_Reset(pdemo->posd);
XOSD_RegUpdateEnable(pdemo->posd);
XOSD_Enable(pdemo->posd);
XOSD_SetScreenSize(pdemo->posd, pdemo->hdmio_width, pdemo->hdmio_height);
XOSD_SetBackgroundColor(pdemo->posd, 0x80, 0x80, 0x80);
// Layer 0 - HDMI input
XOSD_SetLayerPriority(pdemo->posd, 0, XOSD_LAYER_PRIORITY_0);
XOSD_SetLayerAlpha(pdemo->posd, 0, 1, pdemo->hdmi_alpha);
XOSD_SetLayerDimension(pdemo->posd, 0, 0, 0, pdemo->hdmio_width, pdemo->hdmio_height);
// Layer 1 - PYTHON-1300 camera
XOSD_SetLayerPriority(pdemo->posd, 1, XOSD_LAYER_PRIORITY_1);
XOSD_SetLayerAlpha(pdemo->posd, 1, 1, pdemo->cam_alpha);
XOSD_SetLayerDimension(pdemo->posd, 1, 0, 0, 1280, 1024);
XOSD_EnableLayer(pdemo->posd, 0);
XOSD_EnableLayer(pdemo->posd, 1);
return 1;
}
void
CBFileHistoryMenu::CBFileHistoryMenuX
(
const CBDocumentManager::FileHistoryType type
)
{
if (type == CBDocumentManager::kProjectFileHistory)
{
JXImage* icon = new JXImage(GetDisplay(), jcc_project_file);
assert( icon != NULL );
SetDefaultIcon(icon, kJTrue);
}
CBFileHistoryMenu* master =
(CBGetDocumentManager())->GetFileHistoryMenu(itsDocType);
if (master != NULL)
{
std::ostringstream data;
master->WriteSetup(data);
const std::string s = data.str();
std::istringstream input(s);
ReadSetup(input);
}
ListenTo(this);
ListenTo(CBGetDocumentManager());
}
//
//Parse the data out from host to specific NCM control message
//
void CNcmCommunicationInterface::ParseDataOut()
{
OstTraceFunctionEntry1( CNCMCOMMUNICATIONINTERFACE_PARSEDATAOUT_ENTRY, this );
__ASSERT_DEBUG(iDataBuffer.Length()>0,
User::Panic(KNcmCommInterfacePanic, ENcmCommWrongDataLength));
TInt ret = KErrNone;
switch (iRequestType)
{
case ESetNtbInputSize:
ret = iEngine.HandleSetNtbInputSize(iDataBuffer);
break;
default:
ret = KErrNotSupported;
break;
}
if (ret == KErrNone)
{
iPort.SendEp0StatusPacket();
}
else
{
OstTrace1( TRACE_WARNING, CNCMCOMMUNICATIONINTERFACE_PARSEDATAOUT, "handle request iRequestType error %d stall endpoint", ret);
iPort.EndpointZeroRequestError();
}
ReadSetup();
OstTraceFunctionExit1( CNCMCOMMUNICATIONINTERFACE_PARSEDATAOUT_EXIT, this );
}
//
//AO RunL
//
void CNcmCommunicationInterface::RunL()
{
OstTraceFunctionEntry1( CNCMCOMMUNICATIONINTERFACE_RUNL_ENTRY, this );
if(iStatus.Int() != KErrNone)
{
if (KErrCancel == iStatus.Int() )
{
}
else
{
ControlMsgError(EInternalError);
}
OstTraceFunctionExit1( CNCMCOMMUNICATIONINTERFACE_RUNL_EXIT, this );
return;
}
switch(iRWState)
{
case EStateInitial:
{
ReadSetup();
break;
}
case EStateReadSetup:
{
DecodeSetup();
break;
}
case EStateReadDataout:
{
ParseDataOut();
break;
}
case EStateWriteDatain:
{
ReadSetup();
break;
}
}
OstTraceFunctionExit1( CNCMCOMMUNICATIONINTERFACE_RUNL_EXIT_DUP1, this );
}
char *FormatDate(char *DateStr, struct tm *pTm)
{
WORD Fmt;
int Cnt;
static char MonthNames[] = "JanFebMarAprMayJunJulAugSepOctNovDec";
#define DD 1
#define MM 2
#define YY 3
#define MMM 4
#define DASH 5
#define SLASH 6
#define DOT 7
#define DATE_FMT(a, b, c, d, e) (((a) << 12) | \
((b) << 9) | \
((c) << 6) | \
((d) << 3) | (e))
static WORD DateFmtTbl[MAX_DATE_FMT+1] = { /* HP LX Date format table */
/* 0 DD-MMM-YY */ DATE_FMT( DD , DASH , MMM, DASH , YY ),
/* 1 DD-MMM */ DATE_FMT( DD , DASH , MMM, 0 , 0 ),
/* 2 MMM-YY */ DATE_FMT( MMM, DASH , YY , 0 , 0 ),
/* 3 MM/DD/YY */ DATE_FMT( MM , SLASH, DD , SLASH, YY ),
/* 4 DD/MM/YY */ DATE_FMT( DD , SLASH, MM , SLASH, YY ),
/* 5 DD.MM.YY */ DATE_FMT( DD , DOT , MM , DOT , YY ),
/* 6 YY-MM-DD */ DATE_FMT( YY , DASH , MM , DASH , DD ),
/* 7 MM/DD */ DATE_FMT( MM , SLASH, DD , 0 , 0 ),
/* 8 DD/MM */ DATE_FMT( DD , SLASH, MM , 0 , 0 ),
/* 9 DD.MM */ DATE_FMT( DD , DOT , MM , 0 , 0 ),
/*10 MM-DD */ DATE_FMT( MM , DASH , DD , 0 , 0 )};
static char *ppTmp[8] = { "",
"dd", /* DD */
"dd", /* MM */
"dd", /* YY */
"ccc", /* MMM */
"-", /* DASH */
"/", /* SLASH */
"." }; /* DOT */
ReadSetup();
sprintf(ppTmp[DD], "%02d", pTm->tm_mday);
sprintf(ppTmp[MM], "%02d", pTm->tm_mon+1);
sprintf(ppTmp[YY], "%02d", pTm->tm_year % 100);
memcpy(ppTmp[MMM], &MonthNames[pTm->tm_mon*3], 3);
DateStr[0] = '\0';
for (Fmt = DateFmtTbl[TimeSetup.DateFmt], Cnt = 4; Cnt >= 0; --Cnt)
strcat(DateStr, ppTmp[(Fmt >> (3 * Cnt)) & 0x7]);
return DateStr;
}
//
//decode the setup packet to get command information.
//
void CNcmCommunicationInterface::DecodeSetup()
{
OstTraceFunctionEntry1( CNCMCOMMUNICATIONINTERFACE_DECODESETUP_ENTRY, this );
__ASSERT_DEBUG(iSetupPacket.Length()==KSetupPacketLength,
User::Panic(KNcmCommInterfacePanic, ENcmCommWrongSetupLength));
iRequestType = iSetupPacket[KUsbRequestTypeIdx];
iDataStageLength = LittleEndian::Get16(&iSetupPacket[KUsbRequestLengthIdx]);
switch (iRequestType)
{
case EGetNtbParameters:
if (iDataStageLength != KNtbParamStructLength)
{
ControlMsgError(EInvalidLengthToRead);
break;
}
iEngine.HandleGetNtbParam(iDataBuffer);
__ASSERT_DEBUG(iDataBuffer.Length()==KNtbParamStructLength,
User::Panic(KNcmCommInterfacePanic, ENcmCommWrongDataLength));
WriteDataIn();
break;
case EGetNtbInputSize:
if (iDataStageLength != KNtbInputSizeStructLength)
{
ControlMsgError(EInvalidLengthToRead);
break;
}
iEngine.HandleGetNtbInputSize(iDataBuffer);
__ASSERT_DEBUG(iDataBuffer.Length()==KNtbInputSizeStructLength,
User::Panic(KNcmCommInterfacePanic, ENcmCommWrongDataLength));
WriteDataIn();
break;
case ESetNtbInputSize:
if (iDataStageLength != KNtbInputSizeStructLength)
{
ControlMsgError(EInvalidLengthToRead);
break;
}
ReadDataOut();
break;
default:
TInt ret = iPort.EndpointZeroRequestError();
OstTrace1( TRACE_ERROR, CNCMCOMMUNICATIONINTERFACE_DECODESETUP, "unsupport request, halt endpoint with EndpointZeroRequestError %d", ret);
ReadSetup();
break;
}
OstTraceFunctionExit1( CNCMCOMMUNICATIONINTERFACE_DECODESETUP_EXIT, this );
}
void
CBSymbolList::ReadSetup
(
istream& projInput,
const JFileVersion projVers,
istream* symInput,
const JFileVersion symVers
)
{
istream* input = (projVers <= 41 ? &projInput : symInput);
const JFileVersion vers = (projVers <= 41 ? projVers : symVers);
if (input != NULL)
{
ReadSetup(*input, vers);
itsReparseAllFlag = JI2B(
vers < 83 || (itsSymbolList->IsEmpty() && IsActive()));
}
}
void
CBFileListTable::ReadSetup
(
istream& projInput,
const JFileVersion projVers,
istream* symInput,
const JFileVersion symVers
)
{
istream* input = (projVers <= 41 ? &projInput : symInput);
const JFileVersion vers = (projVers <= 41 ? projVers : symVers);
if (vers < 40 || input == NULL)
{
itsReparseAllFlag = kJTrue;
}
else
{
ReadSetup(*input, vers);
}
}
/**
*
* Main function
*
* This function is the main entry point of the example on DMA core. It sets up
* DMA engine to be ready to receive and send frames, and start the transfers.
* It waits for the transfer of the specified number of frame sets, and check
* for transfer errors.
*
* @return
* - XST_SUCCESS if example finishes successfully
* - XST_FAILURE if example fails.
*
* @note None.
*
******************************************************************************/
int vdma_setup(XIntc controller)
{
Intc = controller;
int Status;
XAxiVdma_Config *Config;
XAxiVdma_FrameCounter FrameCfg;
WriteDone = 0;
ReadDone = 0;
WriteError = 0;
ReadError = 0;
ReadFrameAddr = READ_ADDRESS_BASE;
WriteFrameAddr = WRITE_ADDRESS_BASE;
xil_printf("\r\n--- Entering vdma_setup() --- \r\n");
/* The information of the XAxiVdma_Config comes from hardware build.
* The user IP should pass this information to the AXI DMA core.
*/
Config = XAxiVdma_LookupConfig(DMA_DEVICE_ID);
if (!Config) {
xil_printf(
"No video DMA found for ID %d\r\n", DMA_DEVICE_ID);
return XST_FAILURE;
}
/* Initialize DMA engine */
Status = XAxiVdma_CfgInitialize(&AxiVdma, Config, Config->BaseAddress);
if (Status != XST_SUCCESS) {
xil_printf(
"Configuration Initialization failed %d\r\n", Status);
return XST_FAILURE;
}
Status = XAxiVdma_SetFrmStore(&AxiVdma, NUMBER_OF_READ_FRAMES,
XAXIVDMA_READ);
if (Status != XST_SUCCESS) {
xil_printf(
"Setting Frame Store Number Failed in Read Channel"
" %d\r\n", Status);
return XST_FAILURE;
}
Status = XAxiVdma_SetFrmStore(&AxiVdma, NUMBER_OF_WRITE_FRAMES,
XAXIVDMA_WRITE);
if (Status != XST_SUCCESS) {
xil_printf(
"Setting Frame Store Number Failed in Write Channel"
" %d\r\n", Status);
return XST_FAILURE;
}
/* Setup frame counter and delay counter for both channels
*
* This is to monitor the progress of the test only
*
* WARNING: In free-run mode, interrupts may overwhelm the system.
* In that case, it is better to disable interrupts.
*/
FrameCfg.ReadFrameCount = NUMBER_OF_READ_FRAMES;
FrameCfg.WriteFrameCount = NUMBER_OF_WRITE_FRAMES;
FrameCfg.ReadDelayTimerCount = DELAY_TIMER_COUNTER;
FrameCfg.WriteDelayTimerCount = DELAY_TIMER_COUNTER;
Status = XAxiVdma_SetFrameCounter(&AxiVdma, &FrameCfg);
if (Status != XST_SUCCESS) {
xil_printf(
"Set frame counter failed %d\r\n", Status);
if(Status == XST_VDMA_MISMATCH_ERROR)
xil_printf("DMA Mismatch Error\r\n");
return XST_FAILURE;
}
/*
* Setup your video IP that writes to the memory
*/
/* Setup the write channel
*/
Status = WriteSetup(&AxiVdma);
if (Status != XST_SUCCESS) {
xil_printf(
"Write channel setup failed %d\r\n", Status);
if(Status == XST_VDMA_MISMATCH_ERROR)
xil_printf("DMA Mismatch Error\r\n");
return XST_FAILURE;
}
/*
* Setup your video IP that reads from the memory
*/
/* Setup the read channel
*/
Status = ReadSetup(&AxiVdma);
if (Status != XST_SUCCESS) {
xil_printf(
"Read channel setup failed %d\r\n", Status);
if(Status == XST_VDMA_MISMATCH_ERROR)
xil_printf("DMA Mismatch Error\r\n");
return XST_FAILURE;
}
Status = SetupIntrSystem(&AxiVdma, READ_INTR_ID, WRITE_INTR_ID);
if (Status != XST_SUCCESS) {
xil_printf(
"Setup interrupt system failed %d\r\n", Status);
return XST_FAILURE;
}
/* Register callback functions
*/
// XAxiVdma_SetCallBack(&AxiVdma, XAXIVDMA_HANDLER_GENERAL, ReadCallBack,
// (void *)&AxiVdma, XAXIVDMA_READ);
//
// XAxiVdma_SetCallBack(&AxiVdma, XAXIVDMA_HANDLER_ERROR,
// ReadErrorCallBack, (void *)&AxiVdma, XAXIVDMA_READ);
XAxiVdma_SetCallBack(&AxiVdma, XAXIVDMA_HANDLER_GENERAL,
WriteCallBack, (void *)&AxiVdma, XAXIVDMA_WRITE);
XAxiVdma_SetCallBack(&AxiVdma, XAXIVDMA_HANDLER_ERROR,
WriteErrorCallBack, (void *)&AxiVdma, XAXIVDMA_WRITE);
/* Enable your video IP interrupts if needed
*/
/* Start the DMA engine to transfer
*/
Status = StartTransfer(&AxiVdma);
if (Status != XST_SUCCESS) {
if(Status == XST_VDMA_MISMATCH_ERROR)
xil_printf("DMA Mismatch Error\r\n");
return XST_FAILURE;
}
/* Enable DMA read and write channel interrupts
*
* If interrupts overwhelms the system, please do not enable interrupt
*/
// XAxiVdma_IntrEnable(&AxiVdma, XAXIVDMA_IXR_FRMCNT_MASK, XAXIVDMA_WRITE);
// XAxiVdma_IntrEnable(&AxiVdma, XAXIVDMA_IXR_FRMCNT_MASK, XAXIVDMA_READ);
/* Every set of frame buffer finish causes a completion interrupt
*/
// while ((WriteDone < NUM_TEST_FRAME_SETS) && !ReadError &&
// (ReadDone < NUM_TEST_FRAME_SETS) && !WriteError) {
// /* NOP */
// }
// if (ReadError || WriteError) {
// xil_printf("Test has transfer error %d/%d\r\n",
// ReadError, WriteError);
//
// Status = XST_FAILURE;
// }
// else {
// xil_printf("Test passed\r\n");
// }
xil_printf("\r\n--- Exiting vdma_setup() --- \r\n");
// DisableIntrSystem(READ_INTR_ID, WRITE_INTR_ID);
if (Status != XST_SUCCESS) {
if(Status == XST_VDMA_MISMATCH_ERROR)
xil_printf("DMA Mismatch Error\r\n");
return XST_FAILURE;
}
return XST_SUCCESS;
}
int l8210___store(struct descriptor *niddsc_ptr, InStoreStruct *setup)
{
static DESCRIPTOR_A_BOUNDS(raw,sizeof(short),DTYPE_W,0,1,0);
static DESCRIPTOR(counts_str,"counts");
static DESCRIPTOR_WITH_UNITS(counts,&raw,&counts_str);
static DESCRIPTOR_LONG(start_d,&raw.bounds[0].l);
static DESCRIPTOR_LONG(end_d,&raw.bounds[0].u);
static int stop_trig_nid;
static DESCRIPTOR_NID(trigger_d,&stop_trig_nid);
static float frequency;
static DESCRIPTOR_FLOAT(frequency_d,&frequency);
static DESCRIPTOR_RANGE(int_clock_d,0,0,&frequency_d);
static int ext_clock_in_nid;
static DESCRIPTOR_NID(ext_clock_d,&ext_clock_in_nid);
static float coefficient = 10.0/1024;
static DESCRIPTOR_FLOAT(coef_d,&coefficient);
static short offset = -512;
static struct descriptor offset_d = {2,DTYPE_W,CLASS_S,(char *)&offset};
#define DESCRIPTOR_VALUE(name)\
struct descriptor_function_0 { RECORD_HEAD } name =\
{2, DTYPE_FUNCTION, CLASS_R, (unsigned char *)&OpcValue, 0}
static DESCRIPTOR_VALUE(value);
static DESCRIPTOR_FUNCTION_2(add_exp,(unsigned char *)&OpcAdd,&offset_d,&value);
static DESCRIPTOR_FUNCTION_2(mult_exp,(unsigned char *)&OpcMultiply,&coef_d,&add_exp);
static DESCRIPTOR(volts_str,"volts");
static DESCRIPTOR_WITH_UNITS(volts,&mult_exp,&volts_str);
static DESCRIPTOR_WINDOW(window,&start_d,&end_d,&trigger_d);
static int clock_out_nid;
static DESCRIPTOR_NID(clock_out,&clock_out_nid);
static DESCRIPTOR_DIMENSION(dimension,&window,&clock_out);
static DESCRIPTOR(time_str,"seconds");
static DESCRIPTOR_WITH_UNITS(time,&dimension,&time_str);
static DESCRIPTOR_SIGNAL_1(signal,&volts,&counts,&time);
int samples_per_channel;
int min_idx;
int max_idx;
int num_chans;
int vm_size;
short *channel_data_ptr;
int status;
int chan;
int samples_to_read;
int i;
float wait_time;
stop_trig_nid = setup->head_nid + L8210_N_STOP_TRIG;
ext_clock_in_nid = setup->head_nid + L8210_N_EXT_CLOCK_IN;
clock_out_nid = setup->head_nid + L8210_N_CLOCK_OUT;
pio(26,0,0);
wait_time = setup->memories*30E-3;
DevWait(wait_time);
pio(8,0,0);
if ((CamXandQ(0)&1) == 0) return DEV$_NOT_TRIGGERED;
return_on_error(ReadSetup(setup, &setup->memories, setup->header, &samples_per_channel,
&min_idx, &max_idx, &frequency, &num_chans), status);
channel_data_ptr = malloc(samples_per_channel * sizeof(short));
status = TreePutRecord(clock_out_nid,
(struct descriptor *)(frequency == 0.0) ? &ext_clock_d : (struct descriptor *)(&int_clock_d),0);
for (chan=0;((chan<num_chans) && (status & 1));chan++)
{
int channel_nid = setup->head_nid + L8210_N_INPUT_1 + chan * (L8210_N_INPUT_2 - L8210_N_INPUT_1);
int usetimes_nid = channel_nid + L8210_N_INPUT_1_USETIMES - L8210_N_INPUT_1;
int startidx_nid = channel_nid + L8210_N_INPUT_1_STARTIDX - L8210_N_INPUT_1;
int endidx_nid = channel_nid + L8210_N_INPUT_1_ENDIDX - L8210_N_INPUT_1;
if (TreeIsOn(channel_nid) & 1) {
int use_times = 0;
DevLong(&usetimes_nid,&use_times);
if(use_times) {
float start_time, end_time;
raw.bounds[0].l = min_idx;
raw.bounds[0].u = max_idx;
status = DevFloat(&startidx_nid,&start_time);
if (~status&1)
start_time = -1;
status = DevFloat(&endidx_nid,&end_time);
if (~status&1)
end_time = -1;
status = DevXToI(start_time, end_time, &dimension, min_idx, max_idx, &raw.bounds[0].l,
&raw.bounds[0].u);
if (~status&1) {
raw.bounds[0].l = min_idx;
raw.bounds[0].u = max_idx;
}
}
else {
status = DevLong(&startidx_nid,(int *)&raw.bounds[0].l);
if (status&1) raw.bounds[0].l = min(max_idx,max(min_idx,raw.bounds[0].l));
else raw.bounds[0].l = min_idx;
status = DevLong(&endidx_nid, (int *)&raw.bounds[0].u);
if (status&1) raw.bounds[0].u = min(max_idx,max(min_idx,raw.bounds[0].u));
else raw.bounds[0].u = max_idx;
}
raw.m[0] = raw.bounds[0].u - raw.bounds[0].l + 1;
if (raw.m[0] > 0)
{
samples_to_read = raw.bounds[0].u - min_idx + 1;
status = ReadChannel(setup,&samples_per_channel,chan,&samples_to_read,channel_data_ptr);
if (status & 1)
{
raw.pointer = (char *)(channel_data_ptr + (raw.bounds[0].l - min_idx));
raw.a0 = raw.pointer - raw.bounds[0].l * sizeof(*channel_data_ptr);
raw.arsize = raw.m[0] * 2;
status = TreePutRecord(channel_nid,(struct descriptor *)&signal,0);
}
}
}
}
free(channel_data_ptr);
return status;
}
void avnet_config_vgap60_video(demo_t *pInstance) {
int status;
Xil_Out32(XPAR_TCM_RECEIVER_0_S00_AXI_BASEADDR + 0x0000, 0x0001);
XCfa_Reset(pInstance->pcfa);
XCcm_Reset(pInstance->pccm);
XRgb2YCrCb_Reset(pInstance->prgb2ycrcb);
XCresample_Reset(pInstance->pcresample);
XAxiVdma_Reset(pInstance->paxivdma, XAXIVDMA_WRITE);
XAxiVdma_Reset(pInstance->paxivdma, XAXIVDMA_READ);
XVtc_Reset(pInstance->pvtc);
XOSD_Reset(pInstance->posd);
/* CLKWIZ */
Xil_Out32(XPAR_CLK_WIZ_1_BASEADDR + 0x0200, 0x00002203);
Xil_Out32(XPAR_CLK_WIZ_1_BASEADDR + 0x0208, 0x0000002D);
Xil_Out32(XPAR_CLK_WIZ_1_BASEADDR + 0x025C, 0x00000007);
Xil_Out32(XPAR_CLK_WIZ_1_BASEADDR + 0x025C, 0x00000002);
status = 0;
while (!status) {
status = Xil_In32(XPAR_CLK_WIZ_1_BASEADDR + 0x0004);
}
/* ISERDES Reset Assert */
Xil_Out32(XPAR_TCM_RECEIVER_0_S00_AXI_BASEADDR + 0x0000, 0x0001);
/* TCM Initialization */
tca9548_i2c_mux_select(pInstance->piicps, EMBV_IIC_MUX_CAM);
// tcm5117pl_get_chip_id(pInstance->piicps);
tcm5117pl_init(pInstance->piicps, TCM5117PL_VGAP60);
/* CFA */
XCfa_Reset(pInstance->pcfa);
XCfa_Enable(pInstance->pcfa);
XCfa_SetBayerPhase(pInstance->pcfa, 0x00000001);
XCfa_SetActiveSize(pInstance->pcfa, 656, 496);
XCfa_RegUpdateEnable(pInstance->pcfa);
/* CCM */
XCcm_Reset(pInstance->pccm);
XCcm_Enable(pInstance->pccm);
XCcm_SetCoefMatrix(pInstance->pccm, &CCM_IDENTITY);
XCcm_SetRgbOffset(pInstance->pccm, 0, 0, 0);
XCcm_SetActiveSize(pInstance->pccm, 656, 496);
XCcm_RegUpdateEnable(pInstance->pccm);
/* RGB2YCRCB */
XRgb2YCrCb_Reset(pInstance->prgb2ycrcb);
XRgb2YCrCb_Enable(pInstance->prgb2ycrcb);
XRgb2YCrCb_Configuration(pInstance->prgb2ycrcb, XRGB_STANDARD_ITU_601_SD, XRGB_TV_16_TO_240, XRGB_DATA_WIDTH_10);
XRgb2YCrCb_SetActiveSize(pInstance->prgb2ycrcb, 656, 496);
XRgb2YCrCb_RegUpdateEnable(pInstance->prgb2ycrcb);
/* CRESAMPLE */
XCresample_Reset(pInstance->pcresample);
XCresample_Enable(pInstance->pcresample);
XCresample_Configuration(pInstance->pcresample);
XCresample_SetActiveSize(pInstance->pcresample, 656, 496);
XCresample_RegUpdateEnable(pInstance->pcresample);
/* AXIVDMA */
XAxiVdma_Reset(pInstance->paxivdma, XAXIVDMA_WRITE);
XAxiVdma_Reset(pInstance->paxivdma, XAXIVDMA_READ);
ReadSetup(pInstance->paxivdma, 0x30000000, 2, 0, 1, 1, 0, 0, 656, 496, 2048,
2048);
WriteSetup(pInstance->paxivdma, 0x30000000, 2, 0, 1, 1, 0, 0, 656, 496, 2048,
2048);
StartTransfer(pInstance->paxivdma);
/* VTC */
XVtc_Timing Timing;
XVtc_Reset(pInstance->pvtc);
XVtc_RegUpdateEnable(pInstance->pvtc);
XVtc_Enable(pInstance->pvtc);
XVtc_ConvVideoMode2Timing(pInstance->pvtc, XVTC_VMODE_VGA, &Timing);
Timing.HSyncPolarity = 1;
Timing.VSyncPolarity = 1;
XVtc_SetGeneratorTiming(pInstance->pvtc, &Timing);
/* OSD */
XOSD_Reset(pInstance->posd);
XOSD_RegUpdateEnable(pInstance->posd);
XOSD_Enable(pInstance->posd);
XOSD_SetScreenSize(pInstance->posd, 656, 496);
XOSD_SetBackgroundColor(pInstance->posd, 0x80, 0x80, 0x80);
// Layer 0 - Test Pattern Generator
XOSD_SetLayerPriority(pInstance->posd, 0, XOSD_LAYER_PRIORITY_0);
XOSD_SetLayerAlpha(pInstance->posd, 0, 1, 0xFF);
XOSD_SetLayerDimension(pInstance->posd, 0, 0, 0, 656, 496);
XOSD_EnableLayer(pInstance->posd, 0);
// ISERDES Reset De-Assert
Xil_Out32(XPAR_TCM_RECEIVER_0_S00_AXI_BASEADDR + 0x0000, 0x0000);
}
void VSPAEROScreen::GuiDeviceCallBack( GuiDevice* device )
{
assert( m_ScreenMgr );
Vehicle *veh = VehicleMgr.GetVehicle();
if( veh )
{
//TODO add callback to determine if the setup file text has been edited
if ( device == &m_SetupButton )
{
if( veh->GetVSPAEROCmd().empty() || !FileExist( VSPAEROMgr.m_DegenFileFull ) || VSPAEROMgr.IsSolverRunning() )
{ /* Do nothing. Should not be reachable, button should be deactivated.*/ }
else
{
if ( FileExist( VSPAEROMgr.m_SetupFile ) )
{
switch( fl_choice( "Overwrite any existing setup file?", "Cancel", "Abort", "Overwrite" ) )
{
case( 0 ):
case ( 1 ):
break;
case( 2 ):
// Clear the solver console
m_SolverBuffer->text( "" );
m_SolverProcess.StartThread( solver_setup_thread_fun, ( void* ) &m_SolverPair );
break;
}
}
else
{
// Clear the solver console
m_SolverBuffer->text( "" );
m_SolverProcess.StartThread( solver_setup_thread_fun, ( void* ) &m_SolverPair );
}
}
}
else if ( device == &m_SolverButton )
{
if( veh->GetVSPAEROCmd().empty() || !FileExist( VSPAEROMgr.m_DegenFileFull ) || VSPAEROMgr.IsSolverRunning() )
{ /* Do nothing. Should not be reachable, button should be deactivated.*/ }
else
{
// Clear out previous results
VSPAEROMgr.ClearAllPreviousResults();
// Clear the solver console
m_SolverBuffer->text( "" );
//Show the plot screen
m_ScreenMgr->m_ShowPlotScreenOnce = true; //deferred show of plot screen
VSPAEROPlotScreen * vspapscreen = ( VSPAEROPlotScreen * )m_ScreenMgr->GetScreen( ScreenMgr::VSP_VSPAERO_PLOT_SCREEN );
if( vspapscreen )
{
vspapscreen->SetDefaultView();
vspapscreen->Update();
}
m_SolverProcess.StartThread( solver_thread_fun, ( void* ) &m_SolverPair );
}
}
else if ( device == &m_ViewerButton )
{
if( veh->GetVIEWERCmd().empty() || !FileExist( VSPAEROMgr.m_DegenFileFull ) || m_ViewerProcess.IsRunning() )
{ /* Do nothing. Should not be reachable, button should be deactivated.*/ }
else
{
vector<string> args;
args.push_back( VSPAEROMgr.m_ModelNameBase );
m_ViewerProcess.ForkCmd( veh->GetExePath(), veh->GetVIEWERCmd(), args );
m_ViewerBuffer->text( "" );
m_ViewerMonitor.StartThread( monitorfun, ( void* ) &m_ViewerPair );
}
}
else if( device == &m_KillSolverSetupButton )
{
VSPAEROMgr.KillSolver();
}
else if( device == &m_KillSolverButton )
{
VSPAEROMgr.KillSolver();
}
else if( device == &m_PlotButton )
{
m_ScreenMgr->m_ShowPlotScreenOnce = true; //deferred show of plot screen
}
else if( device == &m_SaveSetup )
{
SaveSetup();
}
else if( device == &m_ReadSetup )
{
ReadSetup();
}
else if( device == &m_RefWingChoice )
{
int id = m_RefWingChoice.GetVal();
VSPAEROMgr.m_RefGeomID = m_WingGeomVec[id];
}
else if( device == &m_GeomSetChoice )
{
VSPAEROMgr.m_GeomSet = m_GeomSetChoice.GetVal();
}
else if( device == &m_ComputeGeometryButton )
{
VSPAEROMgr.ComputeGeometry();
}
else if( device == &m_DegenFileButton )
{
veh->setExportFileName( vsp::DEGEN_GEOM_CSV_TYPE, m_ScreenMgr->GetSelectFileScreen()->FileChooser( "Select degen geom CSV output file.", "*.csv" ) );
}
else if( device == &m_CompGeomFileButton )
{
veh->setExportFileName( vsp::VSPAERO_PANEL_TRI_TYPE, m_ScreenMgr->GetSelectFileScreen()->FileChooser( "Select comp geom TRI output file.", "*.tri" ) );
}
else if( device == &m_CGSetChoice )
{
VSPAEROMgr.m_CGGeomSet = m_CGSetChoice.GetVal();
}
else if( device == &m_MassPropButton )
{
string id = veh->MassPropsAndFlatten( m_CGSetChoice.GetVal(), VSPAEROMgr.m_NumMassSlice(), false, false );
veh->DeleteGeom( id );
VSPAEROMgr.m_Xcg = veh->m_CG.x();
VSPAEROMgr.m_Ycg = veh->m_CG.y();
VSPAEROMgr.m_Zcg = veh->m_CG.z();
}
else if( device == &m_ExportResultsToCsvButton )
{
string fileName = m_ScreenMgr->GetSelectFileScreen()->FileChooser( "Select CSV File", "*.csv" );
if ( fileName.size() > 0 )
{
int status = VSPAEROMgr.ExportResultsToCSV( fileName );
if ( status != vsp::VSP_OK )
{
char strBuf[1000];
sprintf( strBuf, "File export failed\nFile: %s", fileName.c_str() );
fl_alert( strBuf );
}
}
}
}
m_ScreenMgr->SetUpdateFlag( true );
}
bool VSPAEROScreen::Update()
{
Vehicle *veh = VehicleMgr.GetVehicle();
VSPAEROMgr.Update();
if( veh )
{
//check if the degenfile name has changed
string t_ModelNameBase = VSPAEROMgr.m_ModelNameBase; //m_ModelNameBase is built from calling veh->getExportFileName();
if( !t_ModelNameBase.empty() && strcmp( m_ModelNameBasePrevious.c_str(), t_ModelNameBase.c_str() ) != 0 )
{
ReadSetup();
}
m_ModelNameBasePrevious = t_ModelNameBase;
// Reference Wing Choice
// find & list all Wing type geometries
vector <string> geomVec = veh->GetGeomVec();
m_RefWingChoice.ClearItems();
m_WingGeomVec.clear();
map <string, int> WingCompIDMap;
int iwing = 0;
for ( int i = 0 ; i < ( int )geomVec.size() ; i++ )
{
char str[256];
Geom* g = veh->FindGeom( geomVec[i] );
if ( g )
{
sprintf( str, "%d_%s", i, g->GetName().c_str() );
if( g->GetType().m_Type == MS_WING_GEOM_TYPE )
{
m_RefWingChoice.AddItem( str );
WingCompIDMap[ geomVec[i] ] = iwing;
m_WingGeomVec.push_back( geomVec[i] );
iwing ++;
}
}
}
m_RefWingChoice.UpdateItems();
// Update selected value
string refGeomID = VSPAEROMgr.m_RefGeomID;
if( refGeomID.length() == 0 && m_WingGeomVec.size() > 0 )
{
// Handle case default case.
refGeomID = m_WingGeomVec[0];
VSPAEROMgr.m_RefGeomID = refGeomID;
// Re-trigger reference quantity update with default component.
VSPAEROMgr.Update();
}
m_RefWingChoice.SetVal( WingCompIDMap[ refGeomID ] );
// Update available set choices
m_GeomSetChoice.ClearItems();
m_CGSetChoice.ClearItems();
vector <string> setVec = veh->GetSetNameVec();
for ( int iSet = 0; iSet < setVec.size(); iSet++ )
{
m_GeomSetChoice.AddItem( setVec[iSet] );
m_CGSetChoice.AddItem( setVec[iSet] );
}
m_GeomSetChoice.UpdateItems();
m_CGSetChoice.UpdateItems();
m_GeomSetChoice.SetVal( VSPAEROMgr.m_GeomSet() );
m_CGSetChoice.SetVal( VSPAEROMgr.m_CGGeomSet() );
// Case Setup
m_AeroMethodToggleGroup.Update( VSPAEROMgr.m_AnalysisMethod.GetID() );
switch ( VSPAEROMgr.m_AnalysisMethod.Get() )
{
case vsp::VSPAERO_ANALYSIS_METHOD::VORTEX_LATTICE:
m_DegenFileName.Activate();
m_DegenFileButton.Activate();
m_CompGeomFileName.Deactivate();
m_CompGeomFileButton.Deactivate();
break;
case vsp::VSPAERO_ANALYSIS_METHOD::PANEL:
m_DegenFileName.Deactivate();
m_DegenFileButton.Deactivate();
m_CompGeomFileName.Activate();
m_CompGeomFileButton.Activate();
break;
default:
//do nothing; this should not be reachable
break;
}
m_DegenFileName.Update( veh->getExportFileName( vsp::DEGEN_GEOM_CSV_TYPE ) );
m_CompGeomFileName.Update( veh->getExportFileName( vsp::VSPAERO_PANEL_TRI_TYPE ) );
m_NCPUSlider.Update( VSPAEROMgr.m_NCPU.GetID() );
m_StabilityCalcToggle.Update( VSPAEROMgr.m_StabilityCalcFlag.GetID() );
m_BatchCalculationToggle.Update( VSPAEROMgr.m_BatchModeFlag.GetID() );
//printf("m_SolverProcess.m_ThreadID = %lu\n", m_SolverProcess.m_ThreadID);
if( m_SolverThreadIsRunning )
{
m_ComputeGeometryButton.Deactivate();
}
else
{
m_ComputeGeometryButton.Activate();
}
// Wake Options
m_WakeNumIterSlider.Update( VSPAEROMgr.m_WakeNumIter.GetID() );
m_WakeAvgStartIterSlider.Update( VSPAEROMgr.m_WakeAvgStartIter.GetID() );
m_WakeSkipUntilIterSlider.Update( VSPAEROMgr.m_WakeSkipUntilIter.GetID() );
// Reference Quantities
m_RefToggle.Update( VSPAEROMgr.m_RefFlag.GetID() );
m_SrefSlider.Update( VSPAEROMgr.m_Sref.GetID() );
m_brefSlider.Update( VSPAEROMgr.m_bref.GetID() );
m_crefSlider.Update( VSPAEROMgr.m_cref.GetID() );
// CG Position
m_NumSliceSlider.Update( VSPAEROMgr.m_NumMassSlice.GetID() );
m_XcgSlider.Update( VSPAEROMgr.m_Xcg.GetID() );
m_YcgSlider.Update( VSPAEROMgr.m_Ycg.GetID() );
m_ZcgSlider.Update( VSPAEROMgr.m_Zcg.GetID() );
// Flow Condition
// Alpha
m_AlphaStartInput.Update( VSPAEROMgr.m_AlphaStart.GetID() );
m_AlphaEndInput.Update( VSPAEROMgr.m_AlphaEnd.GetID() );
m_AlphaNptsInput.Update( VSPAEROMgr.m_AlphaNpts.GetID() );
if ( VSPAEROMgr.m_AlphaNpts.Get() == 1 )
{
m_AlphaEndInput.Deactivate();
}
else if ( VSPAEROMgr.m_AlphaNpts.Get() > 1 )
{
m_AlphaEndInput.Activate();
}
// Beta
m_BetaStartInput.Update( VSPAEROMgr.m_BetaStart.GetID() );
m_BetaEndInput.Update( VSPAEROMgr.m_BetaEnd.GetID() );
m_BetaNptsInput.Update( VSPAEROMgr.m_BetaNpts.GetID() );
if ( VSPAEROMgr.m_BetaNpts.Get() == 1 )
{
m_BetaEndInput.Deactivate();
}
else if ( VSPAEROMgr.m_BetaNpts.Get() > 1 )
{
m_BetaEndInput.Activate();
}
// Mach
m_MachStartInput.Update( VSPAEROMgr.m_MachStart.GetID() );
m_MachEndInput.Update( VSPAEROMgr.m_MachEnd.GetID() );
m_MachNptsInput.Update( VSPAEROMgr.m_MachNpts.GetID() );
if ( VSPAEROMgr.m_MachNpts.Get() == 1 )
{
m_MachEndInput.Deactivate();
}
else if ( VSPAEROMgr.m_MachNpts.Get() > 1 )
{
m_MachEndInput.Activate();
}
// Create Setup Button
if( veh->GetVSPAEROCmd().empty() ||
!FileExist( VSPAEROMgr.m_DegenFileFull ) ||
m_SolverThreadIsRunning ||
m_SolverSetupThreadIsRunning ||
( ( VSPAEROMgr.m_AnalysisMethod.Get() == vsp::VSPAERO_ANALYSIS_METHOD::PANEL ) && ( !FileExist( VSPAEROMgr.m_CompGeomFileFull ) ) ) )
{
m_SetupButton.Deactivate();
}
else
{
m_SetupButton.Activate();
}
// Kill Solver Setup Button
if( m_SolverSetupThreadIsRunning )
{
m_KillSolverSetupButton.Activate();
}
else
{
m_KillSolverSetupButton.Deactivate();
}
// Setup Text Display
m_SetupDividerBox->copy_label( std::string( "Setup File: " + GetFilename( VSPAEROMgr.m_SetupFile ) ).c_str() );
// Read Setup Button
if( !FileExist( VSPAEROMgr.m_SetupFile ) )
{
m_ReadSetup.Deactivate();
}
else
{
m_ReadSetup.Activate();
}
// Save Setup Button
if( veh->GetVSPAEROCmd().empty() || m_SolverThreadIsRunning || m_SolverSetupThreadIsRunning )
{
m_SaveSetup.Deactivate();
}
else
{
m_SaveSetup.Activate();
}
// Solver Button
if( veh->GetVSPAEROCmd().empty() ||
!FileExist( VSPAEROMgr.m_DegenFileFull ) ||
!FileExist( VSPAEROMgr.m_SetupFile ) ||
m_SolverThreadIsRunning ||
( VSPAEROMgr.m_AnalysisMethod.Get() == vsp::VSPAERO_ANALYSIS_METHOD::PANEL && !FileExist( VSPAEROMgr.m_CompGeomFileFull ) ) )
{
m_SolverButton.Deactivate();
}
else
{
m_SolverButton.Activate();
}
// Kill Solver Button
if( m_SolverThreadIsRunning )
{
m_KillSolverButton.Activate();
}
else
{
m_KillSolverButton.Deactivate();
}
// Plot Window Button
if( veh->GetVSPAEROCmd().empty() ||
!FileExist( VSPAEROMgr.m_DegenFileFull ) ||
!FileExist( VSPAEROMgr.m_SetupFile ) ||
( VSPAEROMgr.m_AnalysisMethod.Get() == vsp::VSPAERO_ANALYSIS_METHOD::PANEL && !FileExist( VSPAEROMgr.m_CompGeomFileFull ) ) )
{
m_PlotButton.Deactivate();
}
else
{
m_PlotButton.Activate();
}
// Viewer Button
if( veh->GetVIEWERCmd().empty() || m_SolverThreadIsRunning || m_ViewerProcess.IsRunning() || !FileExist( VSPAEROMgr.m_AdbFile ) )
{
m_ViewerButton.Deactivate();
}
else
{
m_ViewerButton.Activate();
}
// Export Button
if ( ResultsMgr.GetNumResults( "VSPAERO_Wrapper" ) == 0 )
{
m_ExportResultsToCsvButton.Deactivate();
}
else
{
m_ExportResultsToCsvButton.Activate();
}
}
m_FLTK_Window->redraw();
return false;
}
char *FormatTime(char *TimeStr, struct tm *pTm)
{
DWORD Fmt;
int Cnt,
Hour;
#undef MM
#define HH12 1 /* Hour: 12 hour format */
#define HH24 2 /* Hour: 24 hour format */
#define MM 3
#define SS 4
#define AMPM 5
#define COLON 6
#define DOT 7
#define COMMA 8
#define LCH 9 /* Lower Case h */
#define LCM 10 /* Lower Case m */
#define LCS 11 /* Lower Case s */
#define TIME_FMT(a, b, c, d, e, f) ((long) a << 20 | (long) b << 16 | \
c << 12 | d << 8 | e << 4 | f)
static DWORD TimeFmtTbl[MAX_TIME_FMT+1] = { /* HP LX Time format table */
/* 0 HH:MM:SS (AM/PM) */ TIME_FMT( HH12, COLON, MM, COLON, SS, AMPM ),
/* 1 HH:MM (AM/PM) */ TIME_FMT( HH12, COLON, MM, AMPM , 0 , 0 ),
/* 2 HH:MM:SS */ TIME_FMT( HH24, COLON, MM, COLON, SS, 0 ),
/* 3 HH.MM.SS */ TIME_FMT( HH24, DOT , MM, DOT , SS, 0 ),
/* 4 HH,MM,SS */ TIME_FMT( HH24, COMMA, MM, COMMA, SS, 0 ),
/* 5 HHhMMmSSs */ TIME_FMT( HH24, LCH , MM, LCM , SS, LCS ),
/* 6 HH:MM */ TIME_FMT( HH24, COLON, MM, 0 , 0 , 0 ),
/* 7 HH.MM */ TIME_FMT( HH24, DOT , MM, 0 , 0 , 0 ),
/* 8 HH,MM */ TIME_FMT( HH24, COMMA, MM, 0 , 0 , 0 ),
/* 9 HHhMMm */ TIME_FMT( HH24, LCH , MM, LCM , 0 , 0 )};
static char *ppTmp[12] = { "",
"dd", /* HH12 */
"dd", /* HH24 */
"dd", /* MM */
"dd", /* SS */
" am", /* AMPM */
":", /* COLON */
".", /* DOT */
",", /* COMMA */
"h", /* LCH */
"m", /* LCM */
"s" }; /* LCS */
ReadSetup();
if((Hour = pTm->tm_hour % 12) == 0)
Hour = 12;
sprintf(ppTmp[HH12], "%2d", Hour);
sprintf(ppTmp[HH24], "%2d", pTm->tm_hour);
sprintf(ppTmp[MM], "%02d", pTm->tm_min);
sprintf(ppTmp[SS], "%02d", pTm->tm_sec);
ppTmp[AMPM][1] = (char) ((pTm->tm_hour < 12) ? 'a' : 'p');
TimeStr[0] = '\0';
for (Fmt = TimeFmtTbl[TimeSetup.TimeFmt], Cnt = 5; Cnt >= 0; --Cnt)
strcat(TimeStr, ppTmp[(Fmt >> (4 * Cnt)) & 0xF]);
return TimeStr;
}
int WINAPI WinMain(HINSTANCE, HINSTANCE, LPTSTR, int aNumberCommands)
{
ShowCursor(true);
DL_Debug::Debug::Create();
CU::TimerManager::Create();
if (aNumberCommands > 2)
{
int commandCount = 0;
LPWSTR* realCommands = CommandLineToArgvW(GetCommandLineW(), &commandCount);
for (int i = 1; i < commandCount; ++i)
{
std::string command = CW2A(realCommands[i]);
if (command == "-useEngineLog")
{
DL_Debug::Debug::GetInstance()->ActivateFilterLog(DL_Debug::eFilterLog::ENGINE);
}
else if (command == "-useGameLog")
{
DL_Debug::Debug::GetInstance()->ActivateFilterLog(DL_Debug::eFilterLog::GAME);
}
else if (command == "-useResourceLog")
{
DL_Debug::Debug::GetInstance()->ActivateFilterLog(DL_Debug::eFilterLog::RESOURCE);
}
else if (command == "-useDirectXLog")
{
DL_Debug::Debug::GetInstance()->ActivateFilterLog(DL_Debug::eFilterLog::DIRECTX);
}
else if (command == "-useFBXLog")
{
DL_Debug::Debug::GetInstance()->ActivateFilterLog(DL_Debug::eFilterLog::FBX);
}
else if (command == "-useFunctionTimerLog")
{
DL_Debug::Debug::GetInstance()->ActivateFilterLog(DL_Debug::eFilterLog::FUNCTION_TIMER);
}
else if (command == "-useEntityLog")
{
DL_Debug::Debug::GetInstance()->ActivateFilterLog(DL_Debug::eFilterLog::ENTITY);
}
}
LocalFree(realCommands);
}
if (ReadSetup(globalSetup, CU::GetMyDocumentFolderPath() + "Raven\\Data\\Setting\\SET_config.bin") == false)
{
return 1;
}
HWND hwnd;
if (Prism::Engine::Create(hwnd, WndProc, globalSetup) == false)
{
return 1;
}
globalGame = new Game();
if (globalGame->Init(hwnd) == false)
{
return 1;
}
SetActiveWindow(hwnd);
globalPreviousFullscreenState = Prism::Engine::GetInstance()->IsFullscreen();
#ifdef RELEASE_BUILD
Prism::Engine::GetInstance()->SetFullscreen(true);
globalPreviousFullscreenState = true;
#endif
MSG msg;
while (1)
{
if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
{
if (msg.message == WM_QUIT)
{
break;
}
TranslateMessage(&msg);
DispatchMessage(&msg);
}
else
{
if (globalGame->Update() == false)
{
break;
}
Prism::Engine::GetInstance()->Render();
}
}
globalGame->Destroy();
delete globalGame;
globalGame = nullptr;
Prism::Engine::Destroy();
return 0;
}
