static void mdlOutputs(SimStruct *S, int_T tid)
{
#ifndef MATLAB_MEX_FILE
int_T nChannels=ssGetIWorkValue(S,CHANNELS_I_IND);
uint_T base=ssGetIWorkValue(S,BASE_ADDR_I_IND);
int_T i,j,channel;
uint_T tempData;
real_T *output;
volatile uint32_T *ioaddress;
//start A/D conversion (ADCNTL5)
ioaddress=(void *)(base+0x2C0);
ioaddress[0]=0x1;
//wait for the start of A/D conversion
delay(60e-6);
//wait for the finish of all channels
delay(nChannels*(120e-6));
//start A/D conversion (ADCNTL5)
ioaddress=(void *)(base+0x2C0);
ioaddress[0]=0x0;
delay(16e-6);
for(i=0;i<nChannels;i++)
{
//read data from ADCNTL8
ioaddress=(void *)(base+0x2F0);
tempData=ioaddress[0];
delay(16e-6);
//get channel number from tempData[13][12]
channel=(tempData&0xf000)>>12;
output=ssGetOutputPortSignal(S,channel);
tempData=tempData&0xfff;
output[0]=(real_T)(tempData*ssGetRWorkValue(S,GAIN_R_IND)+ssGetRWorkValue(S,OFFSET_R_IND));
}
//clear data on FIFO (ADCNTL7)
ioaddress=(void *)(base+0x2E0);
ioaddress[0]=0xfff;
delay(16e-6);
//clear FIFO again (read ADCNTL8,there is "752" store in FIFO even after clear FIFO once,only on PCI2013)
ioaddress=(void *)(base+0x2F0);
tempData=ioaddress[0];
delay(16e-6);
#endif
}
static void mdlOutputs(SimStruct *S, int_T tid)
{
real_T t_previousSimTime = ssGetRWorkValue(S,0);
const real_T *scaleFactor = mxGetPr(TIME_SCALE_FACTOR(S));
time_T t_SimTime = ssGetT(S);
real_T t_diff = 0.0;
real_T dt;
real_T t_current;
real_T t_0;
real_T t_previous;
real_T t_elapsed;
/* Desired Delta time */
dt = (t_SimTime - t_previousSimTime) * (scaleFactor[0]);
/* Get clock time at the beginning of this step*/
t_previous = (real_T)clock()/CLOCKS_PER_SEC;
t_0 = t_previous;
/* Wait to reach the desired time */
while (t_diff<dt){
t_current = (real_T) clock()/CLOCKS_PER_SEC;
/* Look for wrapup */
if (t_current<t_previous){
t_elapsed = t_previous - t_0;
t_0 = (real_T) clock()/CLOCKS_PER_SEC - t_elapsed;
}
t_diff = t_current - t_0;
t_previous = t_current;
}
/* Store current time to be used in next time step*/
ssSetRWorkValue(S, 0, t_SimTime);
}
/* Function: mdlTerminate =====================================================
* Abstract:
* In this function, you should perform any actions that are necessary
* at the termination of a simulation. For example, if memory was
* allocated in mdlStart, this is the place to free it.
*/
static void mdlTerminate(SimStruct *S)
{
close_ftdi();
UNUSED_ARG(S); /* unused input argument */
real_T t_pre = getTime();
real_T t_pre0=ssGetRWorkValue(S,2);
printf("Overall executing time:%f\r\n",t_pre-t_pre0);
}
static void mdlOutputs(SimStruct *S,int_T tid) {
InputRealPtrsType uPtrs0 = ssGetInputPortRealSignalPtrs(S,0);
InputRealPtrsType uPtrs1 = ssGetInputPortRealSignalPtrs(S,1);
real_T prev = ssGetRWorkValue(S,0);
bool dataPort = PARAM(2)[0];
int_T i;
#ifndef MATLAB_MEX_FILE
rosShmData_t *shm = (rosShmData_t *)ssGetPWorkValue(S,0);
SEM *sem = (SEM *)ssGetPWorkValue(S,1);
#endif
char_T *msg;
unsigned int strlen = sizeof(char_T)*(PARAM_SIZE(1)+1);
UNUSED_ARG(tid); /* not used in single tasking mode */
if (U0(0) > 0.5 && U0(0) > prev) {
msg = (char_T *)malloc(strlen);
mxGetString(ssGetSFcnParam(S,1), msg, strlen);
#ifndef MATLAB_MEX_FILE
if (dataPort) {
for (i = 0; i < ssGetInputPortWidth(S,1); ++i) {
asprintf(&msg, "%s %f", msg, U1(i));
}
}
if (rt_sem_wait_if(sem) != 0) {
memcpy(shm->msg.text, msg, MAX_LOG_MSG_SIZE);
shm->msg.state = NEW_VALUE;
rt_sem_signal(sem);
}
#else
switch ((int)PARAM(0)[0]) {
case 1: printf("DEBUG"); break;
case 2: printf("INFO"); break;
case 3: printf("WARN"); break;
case 4: printf("ERROR"); break;
case 5: printf("FATAL"); break;
default: printf("NONE"); break;
}
printf(": %s", msg);
if (dataPort) {
for (i = 0; i < ssGetInputPortWidth(S,1); ++i) {
printf(" %f", U1(i));
}
}
printf("\n");
#endif
free(msg);
}
ssSetRWorkValue(S,0,U0(0));
}
/* Function: mdlOutputs =======================================================
*
*/
static void mdlOutputs(SimStruct *S, int_T tid)
{
const uint32_T *set_BaudRate = (const uint32_T*) ssGetInputPortSignal(S,0);
const int16_T *data_send = (const int16_T*) ssGetInputPortSignal(S,1);
int16_T *data_out = (int16_T *)ssGetOutputPortRealSignal(S,0);
int16_T *data_new_flag = (int16_T *)ssGetOutputPortRealSignal(S,1);
real_T *HL_Status = (real_T *)ssGetOutputPortRealSignal(S,2);
int16_T *realTime = (int16_T *)ssGetOutputPortRealSignal(S,3);
real_T t_previousSimTime = ssGetRWorkValue(S,0);
time_T t_SimTime = ssGetT(S);
real_T t_diff = 0.0;
real_T dt;
real_T t_current=getTime();
real_T t_0=t_current;
real_T t_previous=t_current;
real_T t_elapsed;
real_T *y0 = (real_T *)ssGetOutputPortRealSignal(S,0);
real_T t_pre=ssGetRWorkValue(S,1);
real_T t_pre0=ssGetRWorkValue(S,2);
real_T t_term=ssGetRWorkValue(S,3);
real_T t_realTime=t_current-t_pre0;
/* Desired Delta time */
dt = (t_SimTime - t_previousSimTime) ;
/* Get clock time at the beginning of this step*/
if(t_0-t_pre>(dt+0.001))
{
printf("Warning:It is slower than the real time::%f\r\n",t_0-t_pre);
}
t_pre= t_0;
/* Store current time to be used in next time step*/
/* %%%-SFUNWIZ_wrapper_Outputs_Changes_BEGIN --- EDIT HERE TO _END */
//static int FTDIopen=0;
if (openFtdi==0)
{
openFtdi = open_ftdi(*set_BaudRate, "Quad_USB2", 5, 15);
}
if (openFtdi == 1)
{
*data_new_flag = read_ftdi (data_out, HL_Status);
while (t_realTime<t_term-dt/2){/*(t_diff<dt){*/
t_current = getTime();
t_realTime=t_current-t_pre0;
/* Look for wrapup */
if (t_current<t_previous){
t_elapsed = t_previous - t_0;
t_0 = getTime() - t_elapsed;
}
t_diff = t_current - t_0;
t_previous = t_current;
}
send_ftdi (data_send);
}
else
{
*data_new_flag = -1;
}
/* Wait to reach the desired time */
while (t_realTime<t_term){/*(t_diff<dt){*/
t_current = getTime();
t_realTime=t_current-t_pre0;
/* Look for wrapup */
if (t_current<t_previous){
t_elapsed = t_previous - t_0;
t_0 = getTime() - t_elapsed;
}
t_diff = t_current - t_0;
t_previous = t_current;
}
ssSetRWorkValue(S, 0, t_SimTime);
ssSetRWorkValue(S,1,t_pre);
ssSetRWorkValue(S,3,t_realTime+dt);
*realTime=t_0-t_pre0;
// Quadlinux_Com_Outputs_wrapper(set_BaudRate, data_send, data_out, data_new_flag, HL_Status, bytes_sent);
}
