/*
* UartDev_Init
*/
static int32_t UartDev_Init(uint32_t Ch)
{
Uart_INFO *p_info;
int32_t ret;
if (Mfs_Lock(Ch) != ERROR) {
p_info = &UartInfo[Ch];
if (Mfs_Open(Ch, SMR_MD_UART) == ERROR) {
ret = ERROR; /* open error */
} else {
/* When Mfs_Open is SUCCESS, p_info->State is UART_UNINITIALIZED. */
/* initialize hardware */
ret = uart_Init(p_info);
if (ret == SUCCESS) {
/* enable NVIC */
UART_ENABLE_IRQ(p_info->RxIRQn);
UART_ENABLE_IRQ(p_info->TxIRQn);
/* change state */
p_info->State = UART_INITIALIZED;
uart_StartRx(p_info);
ret = SUCCESS;
} else {
Mfs_Close(Ch);
ret = ERROR; /* uart_Init error */
}
}
Mfs_UnLock(Ch);
} else {
ret = ERROR; /* Mfs_Lock error */
}
return ret;
}
static void init_system_component() {
// timer
init_system_tick();
// power
power_io_init();
alter_beep_protect();
speak_init_params();
init_beep_io();
led_io_init();
// init_adc();
uart_Init();
}
void sys_Start()
{
uint_t i;
p_gpio_def p;
#if I2C_ENABLE
p_dev_i2c pI2c;
#endif
#if SPI_ENABLE
p_dev_spi pSpi;
#endif
#if UART_ENABLE
p_dev_uart pUart;
#endif
arch_Init();
#if IRQ_ENABLE
irq_VectorInit();
#endif
#if GPIO_ENABLE
for (p = tbl_bspGpio[0]; p < tbl_bspGpio[1]; p++) {
sys_GpioConf(p);
}
#endif
#if HC138_ENABLE
for (p = tbl_bspHC138[0]; p < tbl_bspHC138[1]; p++) {
sys_GpioConf(p);
}
#endif
#if HC165_ENABLE
for (p = tbl_bspHC165[0]; p < tbl_bspHC165[1]; p++) {
sys_GpioConf(p);
}
#endif
#if HC595_ENABLE
for (p = tbl_bspHC595[0]; p < tbl_bspHC595[1]; p++) {
sys_GpioConf(p);
}
#endif
#if BATTERY_ENABLE
for (p = tbl_bspBattery[0]; p < tbl_bspBattery[1]; p++) {
sys_GpioConf(p);
}
#if BAT_VOL_ENABLE
arch_AdcInit();
#endif
#endif
#if WDG_ENABLE
wdg_Init();
#endif
#if BKP_ENABLE
bkp_Init();
#endif
#if KEY_ENABLE
key_Init();
#endif
#if IO_BUF_TYPE == BUF_T_DQUEUE
dque_Init(dqueue);
#endif
#if EPI_SOFTWARE
for (p = tbl_bspEpiData[0]; p < tbl_bspEpiData[1]; p++) {
sys_GpioConf(p);
}
#endif
#if I2C_ENABLE
bzero(dev_I2c, sizeof(dev_I2c));
for (pI2c = dev_I2c, i = 0; pI2c < ARR_ENDADR(dev_I2c); pI2c++, i++) {
pI2c->parent->id = i;
pI2c->parent->type = DEV_T_I2C;
#if I2C_SOFTWARE
i2cbus_Init(pI2c);
#else
pI2c->def = &tbl_bspI2cDef[i];
arch_I2cInit(pI2c);
#endif
}
#endif
#if SPI_ENABLE
bzero(dev_Spi, sizeof(dev_Spi));
for (pSpi = dev_Spi, i = 0; pSpi < ARR_ENDADR(dev_Spi); pSpi++, i++) {
pSpi->parent->id = i;
pSpi->parent->type = DEV_T_SPI;
pSpi->csid = SPI_CSID_INVALID;
#if SPI_SOFTWARE
spibus_Init(pSpi);
#else
pSpi->def = &tbl_bspSpiDef[i];
arch_SpiInit(pSpi);
#endif
}
#endif
#if UART_ENABLE
bzero(dev_Uart, sizeof(dev_Uart));
for (pUart = dev_Uart, i = 0; pUart < ARR_ENDADR(dev_Uart); pUart++, i++) {
pUart->parent->id = i;
pUart->parent->type = DEV_T_UART;
pUart->def = &tbl_bspUartDef[i];
uart_Init(pUart);
}
#endif
#if OS_TYPE
os_Start();
#else
sys_Init();
#endif
}
int main(void) {
ADI_AFE_DEV_HANDLE hDevice;
int16_t dft_results[DFT_RESULTS_COUNT];
q15_t dft_results_q15[DFT_RESULTS_COUNT];
q31_t dft_results_q31[DFT_RESULTS_COUNT];
q31_t magnitude[DFT_RESULTS_COUNT / 2];
q15_t phase[DFT_RESULTS_COUNT / 2];
fixed32_t magnitude_result[DFT_RESULTS_COUNT / 2 - 1];
fixed32_t phase_result[DFT_RESULTS_COUNT / 2 - 1];
char msg[MSG_MAXLEN];
uint32_t offset_code;
uint32_t gain_code;
uint32_t rtiaAndGain;
/* Initialize system */
SystemInit();
/* Change the system clock source to HFXTAL and change clock frequency to 16MHz */
/* Requirement for AFE (ACLK) */
if (ADI_SYS_SUCCESS != SystemTransitionClocks(ADI_SYS_CLOCK_TRIGGER_MEASUREMENT_ON))
{
FAIL("SystemTransitionClocks");
}
/* SPLL with 32MHz used, need to divide by 2 */
SetSystemClockDivider(ADI_SYS_CLOCK_UART, 2);
/* Test initialization */
test_Init();
/* Initialize static pinmuxing */
adi_initpinmux();
/* Initialize the UART for transferring measurement data out */
if (ADI_UART_SUCCESS != uart_Init())
{
FAIL("uart_Init");
}
/* Initialize the AFE API */
if (ADI_AFE_SUCCESS != adi_AFE_Init(&hDevice))
{
FAIL("Init");
}
/* Set RCAL and RTIA values */
if (ADI_AFE_SUCCESS != adi_AFE_SetRcal(hDevice, RCAL))
{
FAIL("adi_AFE_SetRcal");
}
if (ADI_AFE_SUCCESS != adi_AFE_SetRtia(hDevice, RTIA))
{
FAIL("adi_AFE_SetTia");
}
/* AFE power up */
if (ADI_AFE_SUCCESS != adi_AFE_PowerUp(hDevice))
{
FAIL("adi_AFE_PowerUp");
}
/* Delay to ensure Vbias is stable */
delay(2000000);
/* Temp Channel Calibration */
if (ADI_AFE_SUCCESS != adi_AFE_TempSensChanCal(hDevice))
{
FAIL("adi_AFE_TempSensChanCal");
}
/* Auxiliary Channel Calibration */
if (ADI_AFE_SUCCESS != adi_AFE_AuxChanCal(hDevice))
{
FAIL("adi_AFE_AuxChanCal");
}
/* Excitation Channel Power-Up */
if (ADI_AFE_SUCCESS != adi_AFE_ExciteChanPowerUp(hDevice))
{
FAIL("adi_AFE_ExciteChanPowerUp");
}
/* TempCal results will be used to set the TIA calibration registers. These */
/* values will ensure the ratio between current and voltage is exactly 1.5 */
if (ADI_AFE_SUCCESS != adi_AFE_ReadCalibrationRegister(hDevice, ADI_AFE_CAL_REG_ADC_GAIN_TEMP_SENS, &gain_code))
{
FAIL("adi_AFE_ReadCalibrationRegister, gain");
}
if (ADI_AFE_SUCCESS != adi_AFE_WriteCalibrationRegister(hDevice, ADI_AFE_CAL_REG_ADC_GAIN_TIA, gain_code))
{
FAIL("adi_AFE_WriteCalibrationRegister, gain");
}
if (ADI_AFE_SUCCESS != adi_AFE_ReadCalibrationRegister(hDevice, ADI_AFE_CAL_REG_ADC_OFFSET_TEMP_SENS, &offset_code))
{
FAIL("adi_AFE_ReadCalibrationRegister, offset");
}
if (ADI_AFE_SUCCESS != adi_AFE_WriteCalibrationRegister(hDevice, ADI_AFE_CAL_REG_ADC_OFFSET_TIA, offset_code))
{
FAIL("adi_AFE_WriteCalibrationRegister, offset");
}
/* Update FCW in the sequence */
seq_afe_acmeasBioZ_4wire[3] = SEQ_MMR_WRITE(REG_AFE_AFE_WG_FCW, FCW);
/* Update sine amplitude in the sequence */
seq_afe_acmeasBioZ_4wire[4] = SEQ_MMR_WRITE(REG_AFE_AFE_WG_AMPLITUDE, SINE_AMPLITUDE);
/* Recalculate CRC in software for the AC measurement, because we changed */
/* FCW and sine amplitude settings. */
adi_AFE_EnableSoftwareCRC(hDevice, true);
while(true)
{
/* Perform the Impedance measurement */
if (ADI_AFE_SUCCESS != adi_AFE_RunSequence(hDevice, seq_afe_acmeasBioZ_4wire, (uint16_t *)dft_results, DFT_RESULTS_COUNT))
{
FAIL("Impedance Measurement");
}
/* Print DFT complex results to console */
PRINT("DFT results (real, imaginary):\r\n");
sprintf(msg, " CURRENT = (%6d, %6d)\r\n", dft_results[0], dft_results[1]);
PRINT(msg);
sprintf(msg, " VOLTAGE = (%6d, %6d)\r\n", dft_results[2], dft_results[3]);
PRINT(msg);
/* Convert DFT results to 1.15 and 1.31 formats. */
convert_dft_results(dft_results, dft_results_q15, dft_results_q31);
/* Magnitude calculation */
/* Use CMSIS function */
arm_cmplx_mag_q31(dft_results_q31, magnitude, DFT_RESULTS_COUNT / 2);
/* Calculate final magnitude value, calibrated with RTIA the gain of the instrumenation amplifier */
rtiaAndGain = (uint32_t)((RTIA * 1.5) / INST_AMP_GAIN);
magnitude_result[0] = calculate_magnitude(magnitude[1], magnitude[0], rtiaAndGain);
/* Phase calculations */
if (magnitude_result[0].full)
{
/* Current phase */
phase[0] = arctan(dft_results[1], dft_results[0]);
/* Voltage phase */
phase[1] = arctan(dft_results[3], dft_results[2]);
/* Impedance phase */
phase_result[0] = calculate_phase(phase[0], phase[1]);
}
/* No need to calculate the phase if magnitude is 0 (open circuit) */
else
{
/* Current phase */
phase[0] = 0;
/* Voltage phase */
phase[1] = 0;
/* Impedance phase */
phase_result[0].full = 0;
}
/* Print final results to console */
PRINT("Final results (magnitude, phase):\r\n");
print_MagnitudePhase("Impedance", magnitude_result[0], phase_result[0]);
//sprintf_fixed32(tmp, magnitude);
}
/* Restore to using default CRC stored with the sequence */
adi_AFE_EnableSoftwareCRC(hDevice, false);
/* AFE Power Down */
if (ADI_AFE_SUCCESS != adi_AFE_PowerDown(hDevice))
{
FAIL("PowerDown");
}
/* Uninitialize the AFE API */
if (ADI_AFE_SUCCESS != adi_AFE_UnInit(hDevice))
{
FAIL("Uninit");
}
/* Uninitilize the UART */
uart_UnInit();
PASS();
}
void MainTask(void *arg) {
ADI_AFE_DEV_HANDLE hDevice;
int16_t dft_results[DFT_RESULTS_COUNT];
q15_t dft_results_q15[DFT_RESULTS_COUNT];
q31_t dft_results_q31[DFT_RESULTS_COUNT];
q31_t magnitude[DFT_RESULTS_COUNT / 2];
q15_t phase[DFT_RESULTS_COUNT / 2];
fixed32_t magnitude_result[DFT_RESULTS_COUNT / 2 - 1];
fixed32_t phase_result[DFT_RESULTS_COUNT / 2 - 1];
char msg[MSG_MAXLEN];
uint8_t err;
done = 0;
uint16_t pressure_analog;
uint32_t pressure;
nummeasurements = 0;
uint32_t rtcCount;
ADI_I2C_RESULT_TYPE i2cResult;
// Initialize driver.
rtc_Init();
// Calibrate.
rtc_Calibrate();
// Initialize UART.
if (uart_Init()) {
FAIL("ADI_UART_SUCCESS");
}
// Initialize I2C.
i2c_Init(&i2cDevice);
// Initialize flags.
bRtcAlarmFlag = bRtcInterrupt = bWdtInterrupt = false;
// Get the current count.
if (adi_RTC_GetCount(hRTC, &rtcCount)) {
FAIL("adi_RTC_GetCount failed");
}
// Initialize the AFE API.
if (adi_AFE_Init(&hDevice)) {
FAIL("adi_AFE_Init");
}
// AFE power up.
if (adi_AFE_PowerUp(hDevice)) {
FAIL("adi_AFE_PowerUp");
}
// Excitation Channel Power-up.
if (adi_AFE_ExciteChanPowerUp(hDevice)) {
FAIL("adi_AFE_ExciteChanPowerUp");
}
// TIA Channel Calibration.
if (adi_AFE_TiaChanCal(hDevice)) {
FAIL("adi_AFE_TiaChanCal");
}
// Excitation Channel Calibration (Attenuation Enabled).
if (adi_AFE_ExciteChanCalAtten(hDevice)) {
FAIL("adi_AFE_ExciteChanCalAtten");
}
// Update FCW in the sequence.
seq_afe_acmeas2wire[3] = SEQ_MMR_WRITE(REG_AFE_AFE_WG_FCW, FCW);
// Update sine amplitude in the sequence.
seq_afe_acmeas2wire[4] =
SEQ_MMR_WRITE(REG_AFE_AFE_WG_AMPLITUDE, SINE_AMPLITUDE);
// Recalculate CRC in software for the AC measurement, because we changed.
// FCW and sine amplitude settings.
adi_AFE_EnableSoftwareCRC(hDevice, true);
// Perform the impedance measurement.
if (adi_AFE_RunSequence(hDevice, seq_afe_acmeas2wire, (uint16_t *)dft_results,
DFT_RESULTS_COUNT)) {
FAIL("Impedance Measurement");
}
// Set RTC alarm.
printf("rtcCount: %d\r\n", rtcCount);
if (ADI_RTC_SUCCESS != adi_RTC_SetAlarm(hRTC, rtcCount + 120)) {
FAIL("adi_RTC_SetAlarm failed");
}
// Enable RTC alarm.
if (ADI_RTC_SUCCESS != adi_RTC_EnableAlarm(hRTC, true)) {
FAIL("adi_RTC_EnableAlarm failed");
}
// Read the initial impedance.
q31_t magnitudecal;
q15_t phasecal;
convert_dft_results(dft_results, dft_results_q15, dft_results_q31);
arm_cmplx_mag_q31(dft_results_q31, &magnitudecal, 2);
phasecal = arctan(dft_results[1], dft_results[0]);
printf("raw rcal data: %d, %d\r\n", dft_results[1], dft_results[0]);
printf("rcal (magnitude, phase) = (%d, %d)\r\n", magnitudecal, phasecal);
// Create the message queue for communicating between the ISR and this task.
dft_queue = OSQCreate(&dft_queue_msg[0], DFT_QUEUE_SIZE);
// Hook into the DFT interrupt.
if (ADI_AFE_SUCCESS !=
adi_AFE_RegisterAfeCallback(
hDevice, ADI_AFE_INT_GROUP_CAPTURE, AFE_DFT_Callback,
BITM_AFE_AFE_ANALOG_CAPTURE_IEN_DFT_RESULT_READY_IEN)) {
FAIL("adi_AFE_RegisterAfeCallback");
}
if (ADI_AFE_SUCCESS !=
adi_AFE_ClearInterruptSource(
hDevice, ADI_AFE_INT_GROUP_CAPTURE,
BITM_AFE_AFE_ANALOG_CAPTURE_IEN_DFT_RESULT_READY_IEN)) {
FAIL("adi_AFE_ClearInterruptSource (1)");
}
packed32_t q_result;
void *q_result_void;
OS_Q_DATA q_data;
uint16_t q_size;
bool inflated = false;
while (true) {
// Wait for the user to press the button.
printf("MainTask: waiting for button.\n");
OSSemPend(ux_button_semaphore, 0, &err);
if (err != OS_ERR_NONE) {
FAIL("OSSemPend: MainTask");
}
// TODO: fix bug when pressing button multiple times.
// Have the pump task inflate the cuff.
printf("MainTask: button detected. Resuming pump task.\n");
err = OSTaskResume(TASK_PUMP_PRIO);
if (err != OS_ERR_NONE) {
FAIL("OSTaskResume: MainTask (1)");
}
// Wait a bit.
printf("MainTask: waiting a bit.\n");
err = OSTimeDlyHMSM(0, 0, 1, 0);
if (err != OS_ERR_NONE) {
FAIL("OSTimeDlyHMSM: MainTask (3)");
}
// Enable the DFT interrupt.
printf("MainTask: enabling DFT interrupt.\n");
if (ADI_AFE_SUCCESS !=
adi_AFE_EnableInterruptSource(
hDevice, ADI_AFE_INT_GROUP_CAPTURE,
BITM_AFE_AFE_ANALOG_CAPTURE_IEN_DFT_RESULT_READY_IEN, true)) {
FAIL("adi_AFE_EnableInterruptSource");
}
PRINT("START\r\n");
printf("START\r\n");
while (true) {
// Wait on the queue to get DFT data from the ISR (~76 Hz).
//printf("MainTask: pending on DFT queue.\n");
q_result_void = OSQPend(dft_queue, 0, &err);
q_result.pointer = q_result_void;
if (err != OS_ERR_NONE) {
FAIL("OSQPend: dft_queue");
}
OSQQuery(dft_queue, &q_data);
q_size = q_data.OSNMsgs;
// Right after we get this data, get the transducer's value from the
// Arduino.
//printf("MainTask: getting transducer value via I2C.\n");
i2cResult = adi_I2C_MasterReceive(i2cDevice, I2C_PUMP_SLAVE_ADDRESS, 0x0,
ADI_I2C_8_BIT_DATA_ADDRESS_WIDTH,
i2c_rx, 3, false);
if (i2cResult != ADI_I2C_SUCCESS) {
FAIL("adi_I2C_MasterReceive: get pressure from Arduino");
}
// Get the analog pressure value from the Arduino.
if (i2c_rx[0] == ARDUINO_PRESSURE_AVAILABLE
|| i2c_rx[0] == ARDUINO_STILL_INFLATING) {
pressure_analog = i2c_rx[1] | (i2c_rx[2] << 8);
} else {
FAIL("Corrupted or unexpected data from Arduino.");
}
// Convert the analog value to mmHg.
pressure = transducer_to_mmhg(pressure_analog);
//printf("MainTask: got pressure value: %d mmHg.\n", pressure);
// If the pressure is below the threshold, we're done; break the loop.
if (inflated && pressure < LOWEST_PRESSURE_THRESHOLD_MMHG) {
PRINT("END\r\n");
printf("END\r\n");
inflated = false;
break;
} else if (pressure > LOWEST_PRESSURE_THRESHOLD_MMHG * 1.1) {
inflated = true;
}
// Convert DFT results to 1.15 and 1.31 formats.
dft_results[0] = q_result.parts.magnitude;
dft_results[1] = q_result.parts.phase;
convert_dft_results(dft_results, dft_results_q15, dft_results_q31);
// Compute the magnitude using CMSIS.
arm_cmplx_mag_q31(dft_results_q31, magnitude, DFT_RESULTS_COUNT / 2);
// Calculate final magnitude values, calibrated with RCAL.
fixed32_t magnituderesult;
magnituderesult = calculate_magnitude(magnitudecal, magnitude[0]);
q15_t phaseresult;
phaseresult = arctan(dft_results[1], dft_results[0]);
fixed32_t phasecalibrated;
// Calibrate with phase from rcal.
phasecalibrated = calculate_phase(phasecal, phaseresult);
// TODO: dispatch to another thread?
//printf("MainTask: sending data via UART.\n");;
print_PressureMagnitudePhase("", pressure, magnituderesult, phasecalibrated,
q_size);
nummeasurements++;
}
// We're done measuring, for now. Disable the DFT interrupts.
printf("MainTask: disabling DFT interrupts.\n");
if (ADI_AFE_SUCCESS !=
adi_AFE_EnableInterruptSource(
hDevice, ADI_AFE_INT_GROUP_CAPTURE,
BITM_AFE_AFE_ANALOG_CAPTURE_IEN_DFT_RESULT_READY_IEN, false)) {
FAIL("adi_AFE_EnableInterruptSource (false)");
}
// Tell the pump task to deflate the cuff.
printf("MainTask: resuming pump task to deflate the cuff.\n");
err = OSTaskResume(TASK_PUMP_PRIO);
if (err != OS_ERR_NONE) {
FAIL("OSTaskResume: MainTask (2)");
}
// Suspend until the pump finishes deflating. We can then go back to
// listening for the user input.
printf("MainTask: suspending to wait for pump task.\n");
err = OSTaskSuspend(OS_PRIO_SELF);
if (err != OS_ERR_NONE) {
FAIL("OSTaskSuspend: MainTask (3)");
}
// Tell the UX that we're done for now.
UX_Disengage();
}
}
DMPAPI(COMPort *) com_Init(int com)
{
COMPort *port;
if ((port = (COMPort *)CreateCOMPort(com)) == NULL) return NULL;
switch (com)
{
case COM1: case COM2: case COM3: case COM4: case COM5:
case COM6: case COM7: case COM8: case COM9: case COM10:
{
if ((port->func = (void *)CreateUART(com)) == NULL) goto FAIL;
if (uart_Init(port->func) == false)
{
uart_Close(port->func);
goto FAIL;
}
port->Close = uart_Close;
port->SetTimeOut = uart_SetTimeOut;
port->Read = uart_Read;
port->Receive = uart_Receive;
port->QueryRxQueue = uart_QueryRxQueue;
port->RxQueueFull = uart_RxQueueFull;
port->RxQueueEmpty = uart_RxQueueEmpty;
port->FlushRxQueue = uart_FlushRxQueue;
port->Write = uart_Write;
port->Send = uart_Send;
port->QueryTxQueue = uart_QueryTxQueue;
port->TxQueueFull = uart_TxQueueFull;
port->TxQueueEmpty = uart_TxQueueEmpty;
port->FlushTxQueue = uart_FlushTxQueue;
port->TxReady = uart_TxReady;
port->FlushWFIFO = uart_FlushWFIFO;
port->SetBPS = uart_SetBaud;
port->SetFormat = uart_SetFormat;
port->SetFlowControl = uart_SetFlowControl;
port->EnableFIFO = uart_SetHWFIFO;
port->SetWFIFOSize = uart_SetWFIFOSize;
port->ClearRFIFO = uart_ClearRFIFO;
port->ClearWFIFO = uart_ClearWFIFO;
port->SetLSRHandler = uart_SetLSRHandler;
port->SetMSRHandler = uart_SetMSRHandler;
port->GetLSR = uart_GetLSR;
port->GetMSR = uart_GetMSR;
port->EnableHalfDuplex = uart_EnableHalfDuplex;
port->EnableFullDuplex = uart_EnableFullDuplex;
port->EnableDebugMode = uart_EnableDebugMode;
port->DisableDebugMode = uart_DisableDebugMode;
return port;
}
case USB_COM:
{
if ((port->func = (void *)CreateUSBDevice()) == NULL) goto FAIL;
if (set_usb_pins == false)
{
err_print((char*)"%s: no set USB-Device pins.\n", __FUNCTION__);
usb_Close(port->func);
goto FAIL;
}
if (usb_SetUSBPins(port->func, usb_detect_port, usb_detect_pin, usb_on_off_port, usb_on_off_pin) == false)
{
usb_Close(port->func);
goto FAIL;
}
if (usb_Init(port->func) == false)
{
usb_Close(port->func);
goto FAIL;
}
port->Close = usb_Close;
port->SetTimeOut = usb_SetTimeOut;
port->Read = usb_Read;
port->Receive = usb_Receive;
port->QueryRxQueue = usb_QueryRxQueue;
port->RxQueueFull = usb_RxQueueFull;
port->RxQueueEmpty = usb_RxQueueEmpty;
port->FlushRxQueue = usb_FlushRxQueue;
port->Write = usb_Write;
port->Send = usb_Send;
port->QueryTxQueue = usb_QueryTxQueue;
port->TxQueueFull = usb_TxQueueFull;
port->TxQueueEmpty = usb_TxQueueEmpty;
port->FlushTxQueue = usb_FlushTxQueue;
port->TxReady = usb_TxReady;
port->FlushWFIFO = usb_FlushWFIFO;
port->Ready = usb_Ready;
port->GetLineCoding = usb_GetLineCoding;
port->SetSerialState = usb_SetSerialState;
port->GetControlLineState= usb_GetControlLineState;
return port;
}
case CAN_BUS:
{
if ((port->func = (void *)CreateCANBus(IO_PORT)) == NULL) goto FAIL;
if (can_Init(port->func) == false)
{
can_Close(port->func);
goto FAIL;
}
port->Close = can_Close;
port->SetTimeOut = can_SetTimeOut;
port->QueryRxQueue = can_QueryRxQueue;
port->RxQueueFull = can_RxQueueFull;
port->RxQueueEmpty = can_RxQueueEmpty;
port->FlushRxQueue = can_FlushRxQueue;
port->QueryTxQueue = can_QueryTxQueue;
port->TxQueueFull = can_TxQueueFull;
port->TxQueueEmpty = can_TxQueueEmpty;
port->FlushTxQueue = can_FlushTxQueue;
port->TxReady = can_TxReady;
port->FlushWFIFO = can_FlushWFIFO;
port->SetBPS = can_SetBPS;
port->Reset = can_Reset;
port->AddIDFilter = can_AddIDFilter;
port->GetIDFilter = can_GetIDFilter;
port->DelIDFilter = can_DelIDFilter;
port->ClearIDList = can_ClearIDList;
port->EnableBypass = can_EnableBypass;
port->DisableBypass = can_DisableBypass;
port->SetEWLimit = can_SetEWLimit;
port->GetEWLimit = can_GetEWLimit;
port->GetTxErrorCount = can_GetTxErrorCount;
port->GetRxErrorCount = can_GetRxErrorCount;
port->GetNowState = can_GetNowState;
port->EnableStoreError = can_EnableStoreError;
port->DisableStoreError = can_DisableStoreError;
port->SetCANBusOffHandler= can_SetCANBusOffHandler;
port->PopError = can_PopError;
port->GetLastError = can_GetLastError;
port->ReadCAN = can_Read;
port->WriteCAN = can_Write;
return port;
}
default: break;
};
FAIL:
ker_Mfree(port);
return NULL;
}
void mouse_Init()
{
int i;
uint8 code;
REGISTER_LOG_CLIENT("MOUSE SENSOR");
flagCalibStep = OSFlagCreate(0x00, &OSLastError);
LOG_TEST_OS_ERROR(OSLastError);
ex_PushITHandler(MOUSE1_FAILURE, mouseFailureHandler);
ex_PushITHandler(MOUSE2_FAILURE, mouseFailureHandler);
mice[0].uart = CHANNEL_UART_MOUSE_1;
mice[0].RatioKU = 1.00f;
mice[0].RatioKV = 1.00f;
mice[0].theta = -0.785997f;
mice[0].Delta0 = 1500.0f;
mice[0].DeltaA = 0.0f;
mice[0].RX0 = -7668.8f;
mice[0].RXA = 0.0f;
mice[0].RY0 = 10150;//10565.61;
mice[0].RYA = 0;//-3044.32*valueVTops/valueSample;
mice[1].uart = CHANNEL_UART_MOUSE_2;
mice[1].RatioKU = 1.00f;
mice[1].RatioKV = 1.00f;
mice[1].theta = -0.780678f;
mice[1].Delta0 = 1499.5f;
mice[1].DeltaA = 0.0f;
mice[1].RX0 = -7741.7f;
mice[1].RXA = 0.0f;
mice[1].RY0 = -10214;//-10819.70;
mice[1].RYA = 0;//3127.76*valueVTops/valueSample;
corrLR = -6308*valueVTops/valueSample;
corrRR = -6301*valueVTops/valueSample;
for(i=0; i<MOUSE_NUMBER; i++)
{
//init mouse uart
uart_Init(mice[i].uart, MOUSE_UART_BAUDRATE);
//reset mice values
mice[i].error = 0;
mice[i].calibU = 0;
mice[i].calibV = 0;
mice[i].nbGoodMessage = 0;
mice[i].nbCksmError = 0;
mice[i].nbUnkError = 0;
mice[i].calibAlpha1 = 0.0f;
mice[i].calibAlpha2 = 0.0f;
mice[i].calibDelta = 0.0f;
mice[i].cosTheta = cosf(mice[i].theta);
mice[i].sinTheta = sinf(mice[i].theta);
sendCalibParameters(i);
}
}
