/* * 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); } }