//Code blocks in the preamble are labelled with the names
//of the libraries in which the used functions are defined.
//Look in these to discover fundamental definitions.
void main(void) {
EALLOW;//an assembly language thing required to allow access to system control registers
SysCtrlRegs.WDCR = 0x68;//disable watchdog
//clock
SysClkInit(FIFTY);//set the system clock to 50MHz
//gpio
Uint8 out[3] = {31, 34};//0 is !shdn on wifi
GpioOutputsInit(out, 2); //34 is a pin that goes high/low each second
//interrupts //31 is ld2: lights when wifi is sending
IsrInit(TINT0, &timerISR);
IsrInit(ADCINT2, &adcISR);
//adc
AdcInit();
AdcSetClock(FOURTH);
AdcSetupSOC(SOC3, ADCB6, SOFTWARE);
AdcEnableIsr(SOC3, ADCINT2);
//clock
TimerInit(1.0);//set the timer to 1kHz and start. Relies on SysClkInit, so call that first.
EDIS;//disallow access to system control registers
while(1) {
loopcnt++;
}
}
//int seek_flag = 0;
////////////////////////////////////////////////////
// 功能:
// 输入:
// 输出:
// 返回:
// 说明:
////////////////////////////////////////////////////
int JzCtlInit(void)
{
// ADC & DAC设备初始化
AdcInit();
DacInit();
return 0;
}
void Board::init() // initialize the board specifics
{
//
// Enable lazy stacking for interrupt handlers. This allows floating-point
// instructions to be used within interrupt handlers, but at the expense of
// extra stack usage.
//
FPUEnable();
FPULazyStackingEnable();
//
// Set the clocking to run from the PLL at 50MHz
//
ROM_SysCtlClockSet(
SYSCTL_SYSDIV_1 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ);
IntMasterEnable(); // Enable interrupts to the processor.
// Set up the period for the SysTick timer for 1 mS.
SysTickPeriodSet(SysCtlClockGet() / 1000);
SysTickIntEnable(); // Enable the SysTick Interrupt.
SysTickEnable(); // Enable SysTick.
/* //
// Enable lazy stacking for interrupt handlers. This allows floating-point
// instructions to be used within interrupt handlers, but at the expense of
// extra stack usage.
FPUEnable();
FPULazyStackingEnable();
SysCtlClockSet(
SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN
| SYSCTL_XTAL_16MHZ); // Set the clocking to run directly from the crystal.
IntMasterEnable(); // Enable interrupts to the processor.*/
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); // Enable the GPIO port that is used for the on-board LED.
GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_2); // Enable the GPIO pins for the LED (PF2).
GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1);
GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_3);
/* SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0); // Enable the peripherals used by this example.
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
IntMasterEnable(); // Enable processor interrupts.
// Set up the period for the SysTick timer for 1 mS.
SysTickPeriodSet(SysCtlClockGet() / 1000);
SysTickIntEnable(); // Enable the SysTick Interrupt.
SysTickEnable(); // Enable SysTick.
GPIOPinConfigure(GPIO_PA0_U0RX); // Set GPIO A0 and A1 as UART pins.
GPIOPinConfigure(GPIO_PA1_U0TX);
GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
UARTConfigSetExpClk(UART0_BASE, SysCtlClockGet(), 115200,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE)); // Configure the UART for 115,200, 8-N-1 operation.
IntEnable(INT_UART0);
UARTFIFODisable(UART0_BASE);
// UARTFIFOLevelSet(UART0_BASE, UART_FIFO_TX1_8, UART_FIFO_RX1_8);
UARTFlowControlSet(UART0_BASE, UART_FLOWCONTROL_NONE);
UARTIntDisable(UART0_BASE, UART_INT_RT);
UARTIntEnable(UART0_BASE, UART_INT_RX | UART_INT_TX); // Enable the UART interrupt.*/
Board::setLedOn(Board::LED_GREEN, false);
Board::setLedOn(Board::LED_RED, false);
Board::setLedOn(Board::LED_BLUE, false);
AdcInit();
}
void BoardInitMcu( void )
{
if( McuInitialized == false )
{
// We use IRQ priority group 4 for the entire project
// When setting the IRQ, only the preemption priority is used
NVIC_PriorityGroupConfig( NVIC_PriorityGroup_4 );
// Disable Systick
SysTick->CTRL &= ~SysTick_CTRL_TICKINT_Msk; // Systick IRQ off
SCB->ICSR |= SCB_ICSR_PENDSTCLR_Msk; // Clear SysTick Exception pending flag
AdcInit( &Adc, POTI );
SpiInit( &SX1272.Spi, RADIO_MOSI, RADIO_MISO, RADIO_SCLK, NC );
SX1272IoInit( );
#if( LOW_POWER_MODE_ENABLE )
TimerSetLowPowerEnable( true );
#else
TimerSetLowPowerEnable( false );
#endif
BoardUnusedIoInit( );
if( TimerGetLowPowerEnable( ) == true )
{
RtcInit( );
}
else
{
TimerHwInit( );
}
McuInitialized = true;
}
}
void SensorProxyInit(void) {
InternalAnalogSensorPowerCtrlInit();
AdcInit();
Sht11Init();
Ms5540Init();
// Bmp085Init();
}
void BspInit(void)
{
AdcInit();
// BeepInit();
KeyInit();
LedInit();
// MotorInit();
UartInit();
// InitEEPROM();
}
void BoardInitMcu( void )
{
Gpio_t ioPin;
if( McuInitialized == false )
{
HAL_Init( );
// LEDs
GpioInit( &Led1, LED_1, PIN_OUTPUT, PIN_PUSH_PULL, PIN_NO_PULL, 1 );
GpioInit( &Led2, LED_2, PIN_OUTPUT, PIN_PUSH_PULL, PIN_NO_PULL, 1 );
GpioInit( &Led3, LED_3, PIN_OUTPUT, PIN_PUSH_PULL, PIN_NO_PULL, Led3Status );
SystemClockConfig( );
GpioInit( &ioPin, UART_RX, PIN_INPUT, PIN_PUSH_PULL, PIN_NO_PULL, 0 );
if( GpioRead( &ioPin ) == 1 ) // Debug Mode
{
UsbIsConnected = true;
FifoInit( &Uart1.FifoTx, UartTxBuffer, UART_FIFO_TX_SIZE );
FifoInit( &Uart1.FifoRx, UartRxBuffer, UART_FIFO_RX_SIZE );
// Configure your terminal for 8 Bits data (7 data bit + 1 parity bit), no parity and no flow ctrl
UartInit( &Uart1, UART_1, UART_TX, UART_RX );
UartConfig( &Uart1, RX_TX, 115200, UART_8_BIT, UART_1_STOP_BIT, NO_PARITY, NO_FLOW_CTRL );
}
else
{
UsbIsConnected = false;
UartDeInit( &Uart1 );
}
RtcInit( );
BoardUnusedIoInit( );
}
else
{
SystemClockReConfig( );
}
I2cInit( &I2c, I2C_SCL, I2C_SDA );
AdcInit( &Adc, BAT_LEVEL_PIN );
SpiInit( &SX1272.Spi, RADIO_MOSI, RADIO_MISO, RADIO_SCLK, NC );
SX1272IoInit( );
if( McuInitialized == false )
{
McuInitialized = true;
if( GetBoardPowerSource( ) == BATTERY_POWER )
{
CalibrateSystemWakeupTime( );
}
}
}
void InitSystem() {
// General init
InitOsc();
InitPort();
// Peripheral init
AdcInit();
I2cInit();
// Interrupt init
InterruptInit();
}
inline void Initialization_All(void)
{
init_outpin();
AdcInit();
GlobalTimerInit();
Button_Init();
init_meandr__gpio();
init_meandr_timer();
Init_Uart3();
//TIM3_IRQHandler();
NVIC_InitTypeDef NVIC_InitStructure_usart3;
NVIC_InitStructure_usart3.NVIC_IRQChannel = USART3_IRQn;
NVIC_InitStructure_usart3.NVIC_IRQChannelSubPriority = 1;
NVIC_InitStructure_usart3.NVIC_IRQChannelPreemptionPriority = 1;
NVIC_InitStructure_usart3.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init (&NVIC_InitStructure_usart3);
USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);
//state_err=2;
//USART_ITConfig(USART3, USART_IT_ERR, ENABLE);
USART_ITConfig(USART3, USART_IT_TC, DISABLE);
// NVIC_conf();
display.a.port = GPIOH;
display.b.port = GPIOC;
display.c.port = GPIOE;
display.d.port = GPIOE;
display.e.port = GPIOE;
display.f.port = GPIOE;
display.g.port = GPIOB;
display.common[0].port = GPIOC;
display.common[1].port = GPIOC;
display.common[2].port = GPIOH;
display.dot.port = GPIOB;
display.a.pin = GPIO_Pin_0;
display.b.pin = GPIO_Pin_14;
display.c.pin = GPIO_Pin_6;
display.d.pin = GPIO_Pin_4;
display.e.pin = GPIO_Pin_2;
display.f.pin = GPIO_Pin_0;
display.g.pin = GPIO_Pin_8;
display.common[0].pin = GPIO_Pin_13;
display.common[1].pin = GPIO_Pin_15;
display.common[2].pin = GPIO_Pin_1;
display.dot.pin = GPIO_Pin_6;
DI_Init(&display);
}
int main(void)
{
UartInit();
AdcInit();
while(1)
{
for (int i=0; i < CHANNELS; ++i)
{
SendAdcResultViaUsart(i, AdcTakeMeasure(i));
_delay_ms(100);
}
}
}
void BoardInitMcu( void )
{
if( McuInitialized == false )
{
#if defined( USE_BOOTLOADER )
// Set the Vector Table base location at 0x3000
NVIC_SetVectorTable( NVIC_VectTab_FLASH, 0x3000 );
#endif
// We use IRQ priority group 4 for the entire project
// When setting the IRQ, only the preemption priority is used
NVIC_PriorityGroupConfig( NVIC_PriorityGroup_4 );
// Disable Systick
SysTick->CTRL &= ~SysTick_CTRL_TICKINT_Msk; // Systick IRQ off
SCB->ICSR |= SCB_ICSR_PENDSTCLR_Msk; // Clear SysTick Exception pending flag
I2cInit( &I2c, I2C_SCL, I2C_SDA );
AdcInit( &Adc, BAT_LEVEL );
SpiInit( &SX1272.Spi, RADIO_MOSI, RADIO_MISO, RADIO_SCLK, NC );
SX1272IoInit( );
#if defined( USE_DEBUG_PINS )
GpioInit( &DbgPin1, CON_EXT_1, PIN_OUTPUT, PIN_PUSH_PULL, PIN_NO_PULL, 0 );
GpioInit( &DbgPin2, CON_EXT_3, PIN_OUTPUT, PIN_PUSH_PULL, PIN_NO_PULL, 0 );
GpioInit( &DbgPin3, CON_EXT_7, PIN_OUTPUT, PIN_PUSH_PULL, PIN_NO_PULL, 0 );
GpioInit( &DbgPin4, CON_EXT_9, PIN_OUTPUT, PIN_PUSH_PULL, PIN_NO_PULL, 0 );
#endif
BoardUnusedIoInit( );
#if defined( USE_USB_CDC )
UsbMcuInit( );
UartInit( &UartUsb, UART_USB_CDC, NC, NC );
UartConfig( &UartUsb, RX_TX, 115200, UART_8_BIT, UART_1_STOP_BIT, NO_PARITY, NO_FLOW_CTRL );
#endif
#ifdef LOW_POWER_MODE_ENABLE
RtcInit( );
#else
TimerHwInit( );
#endif
McuInitialized = true;
}
}
void BoardInitMcu( void )
{
if( McuInitialized == false )
{
#if defined( USE_BOOTLOADER )
// Set the Vector Table base location at 0x3000
SCB->VTOR = FLASH_BASE | 0x3000;
#endif
HAL_Init( );
SystemClockConfig( );
#if defined( USE_USB_CDC )
UartInit( &UartUsb, UART_USB_CDC, NC, NC );
UartConfig( &UartUsb, RX_TX, 115200, UART_8_BIT, UART_1_STOP_BIT, NO_PARITY, NO_FLOW_CTRL );
DelayMs( 1000 ); // 1000 ms for Usb initialization
#endif
RtcInit( );
BoardUnusedIoInit( );
I2cInit( &I2c, I2C_1, I2C_SCL, I2C_SDA );
}
else
{
SystemClockReConfig( );
}
AdcInit( &Adc, BAT_LEVEL_PIN );
SpiInit( &SX1272.Spi, SPI_1, RADIO_MOSI, RADIO_MISO, RADIO_SCLK, NC );
SX1272IoInit( );
if( McuInitialized == false )
{
McuInitialized = true;
if( GetBoardPowerSource( ) == BATTERY_POWER )
{
CalibrateSystemWakeupTime( );
}
}
}
float Board::getTemp() {
/* float ulTempValueC;
unsigned long ulADC0Value[4], ulTempAvg;
// ADCIntClear(ADC0_BASE, 1);
// ADCIntEnable(ADC0_BASE, 1);
ADCProcessorTrigger(ADC0_BASE, 1);
while (!ADCIntStatus(ADC0_BASE, 1, false)) {
}
SysCtlDelay(100000);
ADCSequenceDataGet(ADC0_BASE, 1, ulADC0Value);
if (ulADC0Value[0] == 0)
ADCInit();
ulTempAvg = (ulADC0Value[0] + ulADC0Value[1] + ulADC0Value[2]
+ ulADC0Value[3] + 2) / 4;
ulTempValueC = (1475.0 - ((2475.0 * ulTempAvg)) / 4096) / 10;*/
if (ui32TempAvg == 0)
AdcInit();
fTempValueC = (1475.0 - ((2475.0 * ui32TempAvg)) / 4096) / 10; //TEMP = 147.5 – ((75 * (VREFP – VREFN) * ADCVALUE) / 4096) multiply by 10 to keep precision and then div by 10 at end
return fTempValueC;
}
int main(void)
{
delay_init();
Set_System();
LcdInit();
VBatInit();
USB_Config();
DacInit();
AdcInit();
MCPInit();
QuadEncInit();
LcdHello();
ClearCorrector();
while (1)
{
AdcQuant();
}
}
void main(void)
{
int i=0; // Loop Variable
timeout_ctr = 0 ;
//############################ Initialisation ###############################//
// _SOURCE_
DeviceInit(); // DeviceInit.c
InitGpio(); // GpioInit.c
InitPieVectTable(); // PieVect.c
InitPieCtrl(); // PieCtrl.c
InitSci(); // Serial.c
init_lcd_menu(); // LcdMenu.c
lcd_init(); // LcdDriver.c
SineRefInit(); // SineRefInit.c
AdcInit(); // AdcInit.c
PwmInit(); // PwmInit.c
State.all = 0;
State.bit.Start = 1;
PeripheralEn.bit.Buttons= 1; // Allow button checks
EnableInterrupts(); // PieCtrl.c
DisableInverter(); // Ensure inverter is disabled on start-up
lcd_position(0x5,0x0);
lcd_puts("Kingfisher"); // Print introductory message on top line
lcd_position(0x0,0x1); // Start Cursor From First Line
lcd_puts(" Hydro Controller "); // Print introductory message on bottom line
asm(" CLRC INTM, DBGM"); // Enable global interrupts and real-time debug
CpuTimer0Regs.PRD.all = COUNTER0_PRD; // Initialise CPU timer0
CpuTimer1Regs.PRD.all = COUNTER1_PRD; // Initialise CPU timer0
//############################# Polling Loop ################################//
while(1)
{
//#######################################################################//
// STATES //
//#######################################################################//
//
//############################ START STATE ##############################//
if(State.bit.Start)
{
asm("NOP");
}
//######################### EXCITATION STATE ############################//
if (State.bit.Excitation)
{
data_out.bit.led_ctrl_green = 1;
data_out.bit.led_ctrl_red = 0;
if ( (AdcSignal.V_HVDC < 50) && (AdcSignal.Shaft_Velocity > 2000) && !(State.bit.Fault) )
{
// PeripheralEn.bit.Buttons= 0;
timeout_ctr++;
if (timeout_ctr > 3)
{
State.all = 0;
State.bit.Fault = 1;
timeout_ctr = 0;
}
else
{
data_out.bit.startup = 1;
shift_data_out();
if (CpuTimer0Regs.TCR.bit.TIF == 1)
{
for (i=1;i<=2;i++) // wait 2 seconds
{
CpuTimer0Regs.TCR.bit.TIF = 1; // Clear flag
while(!CpuTimer0Regs.TCR.bit.TIF);
}
}
data_out.bit.startup = 0;
shift_data_out();
if (CpuTimer0Regs.TCR.bit.TIF == 1)
{
for(i=1;i<=3;i++) // wait 3 seconds
{
CpuTimer0Regs.TCR.bit.TIF = 1; // Clear flag
while(!CpuTimer0Regs.TCR.bit.TIF);
}
}
}
}
else if ( (AdcSignal.V_HVDC >= 50) && (AdcSignal.V_HVDC < 250) )
{
timeout_ctr = 0;
State.all = 0;
State.bit.Excited = 1;
// Perhaps change LCD Screen to message saying "Slowly increase turbine speed to increase voltage."
}
else if ( (AdcSignal.V_HVDC > 250) )
{
timeout_ctr = 0; // Resets the timeout counter for excitation
State.all = 0;
State.bit.StartupSequence = 1;
}
}
//############################ EXCITED STATE ############################//
if (State.bit.Excited)
{
if (AdcSignal.V_HVDC > 250)
{
timeout_ctr = 0; // Resets the timeout counter for excitation
State.all = 0;
State.bit.StartupSequence = 1;
}
else
{
// !!!!! ADD SOME CODE FOR THIS CONDITION !!!!!
}
}
//############################# FAULT STATE #############################//
if (State.bit.Fault)
{
if (PeripheralEn.bit.Inverter)
{
DisableInverter();
data_out.bit.led_dump1 = 0;
data_out.bit.led_dump2 = 0;
data_out.bit.led_inverter = 0;
data_out.bit.led_update = 0;
}
data_out.bit.protect_trig = 1;
data_out.bit.led_ctrl_green = 0;
data_out.bit.led_ctrl_red = 1;
if ( !(LED_Fault_Ctr++ % 16384) )
{
data_out.bit.led_dump1 = ~(data_out.bit.led_dump1);
data_out.bit.led_dump2 = ~(data_out.bit.led_dump2);
data_out.bit.led_inverter = ~(data_out.bit.led_inverter);
data_out.bit.led_update = ~(data_out.bit.led_update);
}
}
//########################### DC STABLE STATE ###########################//
if (State.bit.DcStable)
{
if ( !(PeripheralEn.bit.Inverter) ) EnableInverter();
data_out.bit.led_ctrl_green = 1;
data_out.bit.led_ctrl_red = 0;
}
//############################## TEST STATE #############################//
if (State.bit.Test)
{
}
//########################### TURNED OFF STATE ##########################//
if (State.bit.TurnOff)
{
data_out.bit.led_ctrl_green = 0;
data_out.bit.led_ctrl_red = 0;
data_out.bit.led_dump1 = 0;
data_out.bit.led_dump2 = 0;
data_out.bit.led_inverter = 0;
data_out.bit.led_update = 0;
}
//#######################################################################//
// FLAGS //
//#######################################################################//
//
//######################## SCREEN UPDATE FLAG #######################//
if (flag_bc)
{
menu_update_lcd();
flag_bc = 0;
}
asm(" nop");
//########################### READ IN DATA FLAG #########################//
if (flag.bit.DataIN)
{
shift_data_in();
check_buttons();
flag.bit.DataIN = 0;
}
//########################## SEND OUT DATA FLAG #########################//
if (flag.bit.DataOUT)
{
shift_data_out();
flag.bit.DataOUT = 0;
}
//######################## HVDC VOLTAGE REGULATION ######################//
if (flag.bit.V_HVDC)
{
if ( !(State.bit.TurnOff) && !(State.bit.Fault) )
{
V_DcError = V_DC_REF - AdcSignal.V_HVDC; // Calculate the DC error from the reference
DutyError = 0.75*K_DC*V_DcError + 0.25*DutyError; // Modify the dump load duty cycle with respect to the DC error
if (V_DcError > 0) // If the DC voltage is less than the reference, dump no power
{
EPwm3Regs.CMPA.half.CMPA= 0;
EPwm3Regs.CMPB = 0;
}
else if (DutyError > DUMP1_DUTY_MAX)
{
DutyFeedback = 1.0*(DUMP1_DUTY_MAX)*DUMP_PRD;
EPwm3Regs.CMPA.half.CMPA= DutyFeedback;
DutyFeedback = 1.0*(DutyError - DUMP1_DUTY_MAX)*DUMP_PRD;
EPwm3Regs.CMPB = DutyFeedback;
}
else
{
DutyFeedback = 1.0*(DutyError)*DUMP_PRD;
EPwm3Regs.CMPA.half.CMPA= DutyFeedback;
EPwm3Regs.CMPB = 0;
}
}else // If there is a fault or the system is off, dump all power
{
EPwm3Regs.CMPA.half.CMPA = (DUMP1_DUTY_MAX)*DUMP_PRD; // Dump all power!
EPwm3Regs.CMPB = DUMP_PRD; // Dump all power!
}
flag.bit.V_HVDC = 0; // Reset the flag
}
//###################### SHAFT VELOCITY MEASUREMENT #####################//
if (ShaftVelocCtr >= 1000) // Updates the measured velocity every 1000*(1/EPWM8) = 0.5s
{
AdcSignal.Shaft_Velocity = shaftspeedtest; //0.8*(ShaftPulseCtr/0.5)*60 + 0.2*AdcSignal.Shaft_Velocity; // Where 1 pulse = 1 rotation
ShaftPulseCtr = 0; // { Reset counters
ShaftVelocCtr = 0; // {
}
//################### OUTPUT AC VOLTAGE FREQUENCY MEASURE ################//
if (V_AcOutPrdCtr >= 10)
{
AdcSignal.V_AcOut_Freq = (SYSCLK/ADC_SAMP_PRD+1)*(V_AcOutPrdCtr/FreqOutDivCtr); // Approximate frequency over at least 10 periods
AcOutFreqError = AC_OUT_FREQ - AdcSignal.V_AcOut_Freq; // Find frequency error
V_AcOutReqFreq = V_AcOutReqFreq + 0.05*AcOutFreqError; // Frequency feedback loop
sinGen.freq = V_AcOutReqFreq*(BIT31)*(2*BIT32*INVERTER_PWM_PRD)*(1/(sinGen.step_max*SYSCLK)); // Alter reference sine wave frequency
V_AcOutPrdCtr = 0 ; // }
FreqOutDivCtr = 0 ; // } Reset counters
}
//####################### INVERTER CONTROL #######################//
if (flag.bit.Inverter)
{
/* BROKEN InverterMaxDuty = V_AC_OUT_REF*(1.0/(AdcSignal.V_HVDC)); // Find the maximum duty cycle necessary to create Vacoutpeak=325V
DutyScaleMax = (BIT16*InverterMaxDuty-BIT15)*30.51850948e-6; // 30.51850948e-6 = 1/(BIT15-1)
if ( !(State.bit.InvSoftStart) )
{
DutyScaleError = DutyScaleMax - DutyScale;
DutyScale = DutyScale + 0.01*DutyScaleError;
if (DutyScale < 0.2)
{
DutyScale = 0.2;
ADD SOME CODE IN CASE IT IS DANGEROUS TO GO BELOW 0.2
}
}
*/
// ----- Toggle the onboard LED to show inverter control is active
if (GPIO34_count >= 4000) // toggle_time = GPIO34_count_limit/fpwm
{
GpioDataRegs.GPBTOGGLE.bit.GPIO34 = 1; // Toggle the pin
GPIO34_count = 0; // Reset the count
}
flag.bit.Inverter = 0;
}
//################### INPUT AC VOLTAGE FREQUENCY MEASURE ################//
if (V_AcInPrdCtr >= 10)
{
AdcSignal.V_AcIn_Freq = 0.8*((SYSCLK/ADC_SAMP_PRD+1)*(V_AcInPrdCtr/FreqInDivCtr)) + 0.2*(AdcSignal.V_AcIn_Freq); // Approximate frequency over at least 10 periods
genSlip = 100*((AdcSignal.V_AcIn_Freq*60) - (AdcSignal.Shaft_Velocity))/(AdcSignal.V_AcIn_Freq*60); // Calculates slip: s= 100%*((ns-nr)/ns)
V_AcInPrdCtr = 0 ; // }
FreqInDivCtr = 0 ; // } Reset counters
}
/* if(SendADCResult)
{
SendADCResult = 0;
SerialSendStr("Voltage: ");
SerialSendInt((int)V_DC_measured);
SerialSendStr(" PWM1: ");
SerialSendInt((int)(EPwm3Regs.CMPA.half.CMPA*100.0/(DUMP_PRD*1.0)));
SerialSendCR();
SerialSendStr(" PWM2: ");
SerialSendInt((int)((EPwm3Regs.CMPB*100.0)/(DUMP_PRD*1.0)));
SerialSendCR();
}*/
}
}
int32_t main()
{
/***************************************************************************
* ClkInit()
****************************************************************************/
ClkInit();
/***************************************************************************
* GPIOInit();
****************************************************************************/
// DrvGPIO_InitFunction(E_FUNC_GPIO);
outpw(&SYS->P0_MFP, 0);
outpw(&SYS->P1_MFP, 0);
outpw(&SYS->P2_MFP, 0);
outpw(&SYS->P3_MFP, 0);
outpw(&SYS->P4_MFP, 0);
_GPIO_SET_PIN_MODE(MODEM_ON_PORT, MODEM_ON_PIN, GPIO_PMD_OUTPUT);
ModuleOn(TRUE);
_GPIO_SET_PIN_MODE(MODEM_POWER_PORT, MODEM_POWER_PIN, GPIO_PMD_OUTPUT);
ModulePowerOn(FALSE);
_GPIO_SET_PIN_MODE(LOCK_POWER_PORT, LOCK_POWER_PIN, GPIO_PMD_OUTPUT);
LockPower(FALSE);
_GPIO_SET_PIN_MODE(KEY_HELP_PORT, KEY_HELP_PIN, GPIO_PMD_QUASI);
_GPIO_SET_PIN_MODE(KEY_BAT_PORT, KEY_BAT_PIN, GPIO_PMD_QUASI);
_GPIO_SET_PIN_MODE(SLEEP_PORT, SLEEP_PIN, GPIO_PMD_OUTPUT);
ModemSleep(FALSE);
_GPIO_SET_PIN_MODE(LED_PORT, LED_PIN, GPIO_PMD_OUTPUT);
LedDark();
_GPIO_SET_PIN_MODE(INT_PORT, INT_PIN, GPIO_PMD_INPUT);
/***************************************************************************
* TimerInit();
****************************************************************************/
SysTick_Config(SYS_TICK);
// SYS_LockReg();
/***************************************************************************
* UartInit();
****************************************************************************/
UartInit();
// debug(VERSION);
// DrvSYS_GetPLLClockFreq();
/***************************************************************************
* WatchdogInit();
****************************************************************************/
WatchdogInit();
// udpTest();
NvInit();
WhatToDo();
AdcInit();
WaitLockPower();
LockPower(!custermParam.param.lockState);
InitMsgDebug();
if( Communication(10) == FALSE )
SoftReset();
if( isCheckingBattery )
{
delay_50ms(40);
MeasurePower(4);
}
else
{
MeasurePower(2);
}
Flag_ModuleOn = TRUE;
//Flag_ModuleOn = TRUE;
ModemVolumeInit();
///--------------------24.11.2015----------------------------------------------
////////////////////////////////////////////////////////////////////////////////////////
while(PressHelp()&&(tmp_my<200)&&(PressBatter())){
tmp_my++;
delay_50ms(1);
if (tmp_my>=150) {
LedLight(144);
if (custermParam.param.lockState) {
LockPower(TRUE);
custermParam.param.lockState = FALSE;
WriteToNv( &custermParam ); //- save to eeprom
PlayVoice("\"unitUnlock.wav\",2\r");
delay_ms(2000);
LockPower(FALSE);
} else {
// debug("ins");
while(PressBatter()){};
tmp_my=0;
while (tmp_my<25){
tmp_my++;
delay_ms(150);
if (PressBatter()){counterPress++;
while(!PressBatter()){};
}
if (counterPress>2){
PlayVoice("\"unitLock.wav\",2\r");
delay_ms(2000);
custermParam.param.lockState = TRUE;
WriteToNv( &custermParam ); //- save to eeprom
tmp_my=0;
delay_ms(2000);
LockPower(DISABLE);
}
}
LedBlink();
}
///////
tmp_my=0;
}
}
while(custermParam.param.lockState){}
///////////////////////////////////////////////////////////////////////////////////////////////
#ifdef DELAY_TEST
DelayTest();
#endif
PowerOn();
if(state==STATE_POWERING_DOWN || Flag_Power_Down)
{
Flag_Power_Down = FALSE;
EnterPowerDown();
while( TimerWait )
FeedWatchdog();
PowerDown();
//不会返回
}
InitVariables();
if(state == STATE_NULL)
{
state = STATE_1ST_CALL;
TimerWait = 100; // 5 s
}
TimerTestMode = 6000;
//debug("ent main loop");
while(1)
{
///--------------------
if (!TimerTestMode && state==STATE_TEST)
{
PlayMusic(MUSIC_PD);
EnterPowerDown();
}
///--------------------
if( Flag_Incomming )
{
#if 1
TimerWait = 200;
Flag_Incomming = FALSE;
TimerStandby = custermParam.param.delay;
//if(state != STATE_ACTIVE)
{
ModemSleep(FALSE);
state = STATE_INCOMMING;
}
#else
Flag_Incomming = FALSE;
if(state != STATE_INCOMMING)
{
state = STATE_INCOMMING;
ModemSleep(FALSE);
EnterAnswer();
}
#endif
}
if(TimerWait == 0)
{
switch(state)
{
case STATE_POWERING_DOWN:
PowerDown();
break;
case STATE_1ST_CALL:
RegisterWait();
break;
case STATE_REGISTER_OK:
GetCpsiInfo();
if( Flag_ObtainCpsi==TRUE)
{
state = STATE_GSM_STEADY;
if( Flag_SimExist )
{
//delay_50ms(200);
SockOpen();
TimerWait = 400;
}
else
{
TimerWait = 60;
}
}
else
{
TimerWait = 70;
}
break;
case STATE_GSM_STEADY:
if( gPhoneNumOk==PHONE_NUM_READY || Flag_SimExist==FALSE)
EnterCall();
else
TimerWait = 40;
break;
case STATE_CALL_PROMPT:
Call();
break;
case STATE_ALERT:
EnterCallFail();
break;
case STATE_NEXT_CALL:
Redial();
break;
case STATE_BATT_DISPLAY:
EnterPowerDown();
break;
case STATE_INCOMMING:
TimerStandby = custermParam.param.delay;
EnterStandby();
break;
}
}
if( TimerSock==0 && Flag_SimExist
&& ( (state>=STATE_GSM_STEADY && state<STATE_STANDBY) || progress>=TEST_GPS ) )
{
switch(sockState)
{
//case SOCKSTATE_NULL:
case SOCKSTATE_CONFIG:
case SOCKSTATE_OPENNING:
SockOpen(); // 打开失败，从新打开
break;
case SOCKSTATE_OPENED:
SendAtWaitRsq(50, 1, FALSE, "AT+CIPOPEN=0,\"UDP\",,,%s\r\n", custermParam.param.local_port);
TimerSock = 80;
break;
#if 0
case SOCKSTATE_CONNECTING:
SockConnect(); // 连接失败，从新连接
break;
#endif
case SOCKSTATE_CONNECT_OK:
if( witchApn == 1)
ClientInit();
break;
default:
break;
}
}
KeyHandle();
SecondHandle();
//SignalCheck();
BatterCheck();
PowerDownHandle();
MsgHandle();
if( Flag_SimExist )
{
UdpHandle();
SmsHandle();
PowerDownHandle();
}
FeedWatchdog();
}
}
void main()
{
#if 0
extern void DebugAdc();
DebugAdc();
#endif
//////////////////////////////////////////////////////////////////////////
// 局部变量或结构体 //
//////////////////////////////////////////////////////////////////////////
SpeedForline = FreecaleConfig.Config.Motor.Speed.LineSpeed;
//////////////////////////////////////////////////////////////////////////
// 位置提示 //
//////////////////////////////////////////////////////////////////////////
/************************************************************************/
/* 开中断 */
/************************************************************************/
set_vector_handler(UART0_VECTORn, UartHandler); // 设置中断服务函数到中断向量表里
uart_rx_irq_en(UART0);//串口中断
FLKeyIrqEnable();
//wdog_init (1000);//初始化看门狗
//wdog_enable ();
//////////////////////////////////////////////////////////////////////////
// 用户操作 //
//////////////////////////////////////////////////////////////////////////
#if UseEndLine
switch (FreecaleConfig.Config.CarState)
{
case CarStandby:
#endif//UseEndLine
printf("start");
#if UseAdcNormalizingInit
AdcNormalizingInit();//初始化归一化变量
#else//UseAdcNormalizingInit
LCDPrint(0, 0, "Car Ready!");
AdcInit();
if (FreecaleConfig.Config.Mode.NrfStartCar == On)
{
if (FreecaleConfig.Config.CarThis == MyCar1)
{
uint8 exitfunc = false;
LCDPrint(0, LcdLine2, "Press the");
LCDPrint(LcdLocal2, LcdLine3, "start!");
LCDPrint(LcdLocal1, LcdLine4, "Nrf Mode");
while (!exitfunc)
{
switch (KeyScanWithoutIrq())//按键检测
{
case FLKeyAdcNorExit:
LcdCls();
LCDPrint(LcdLocal1, LcdLine1, "Findind Car2!");
while (NrfSendStr("$", 1) != Nrf_AllGreen)
{
led(LED1, LED_ON);
DELAY_MS(1);
};
led(LED1, LED_OFF);
exitfunc = TRUE;//退出
break;
default:
break;
}
}
}
else
{
LCDPrint(0, LcdLine2, "Wait Command!");
uint8 strTemp[10];
while (true)
{
if (NrfRecStrCheck(strTemp, 5) != 0)
{
if (strTemp)
{
break;
}
}
led(LED1, LED_ON);
DELAY_MS(1);
} led(LED1, LED_OFF);
}
#endif//UseAdcNormalizingInit
}
else
{
uint8 exitfunc = false;
LCDPrint(0, LcdLine2, "Press the");
LCDPrint(LcdLocal2, LcdLine3, "start!");
LCDPrint(LcdLocal1, LcdLine4, "Manual Mode");
while (!exitfunc)
{
switch (KeyScanWithoutIrq())//按键检测
{
case FLKeyAdcNorExit:
exitfunc = TRUE;//退出
break;
default:
break;
}
}
}
#if UsePowerOnDelay
DELAY_MS(2000);
#else
if (FreecaleConfig.Config.CarDelay > 0)
{
LcdCls();
LCDPrint(0, 0, "wait TimeOut!");
DELAY_MS(FreecaleConfig.Config.CarDelay * 10);
}
LcdCls();
#endif//UsePowerOnDelay
//////////////////////////////////////////////////////////////////////////
//终点线
#if UseEndLine
break;
case CarRunning:
break;
case CarFinish:
LCDPrint(0, 0, "Finish!");
break;
default:
break;
}
#endif//UseEndLine
//uint16 spwm = SteerCenterDuty;
Speed.Expect = SpeedForline;
enable_irq(PIT_IRQn); //使能PIT0中断
//程序循环
while (1)
{
//////////////////////////////////////////////////////////////////////////
//舵机控制
SteerCtrl();
#if 1
#else
///lcd show
NumShow16(Speed.Expect, LcdLocal1, LcdLine1);
NumShow16(Speed.Acturally, LcdLocal1, LcdLine2);
NumShow3(MotorPid.P, LcdLocal1, LcdLine3);
NumShow3(MotorPid.I, LcdLocal2, LcdLine3);
NumShow3(MotorPid.D, LcdLocal3, LcdLine3);
#endif
if (FreecaleConfig.Config.Mode.Ultrasonic == On)
{
NumShow4(CarDistance, LcdLocal1, LcdLine2);
}
SpeedCtrl();
//////////////////////////////////////////////////////////////////////////
//nrf
if (FreecaleConfig.Config.Mode.NrfSendDistance)
{
//NrfErrorType_e nrfErr;
if (FreecaleConfig.Config.CarThis)
{
if (NrfRecStrCheck(NrfBuff, 3))
{
if (FreecaleConfig.Config.Mode.NrfSendDistance)
{
if (NrfBuff[0] == '$')//超声波识别符
{
uint8 i = 0;
while (NrfBuff[i + 1] != '#')//求字符串长度
{
if (NrfBuff[i + 1] == '\0')//error
{
goto exitthismainloop;//没辙了，我真不想这么写，实在不能再循环了，变量太多了
//break;
}
i++;
}
uint32 dis = 0;
for (uint8 j = 0; j < i; j++)//求数值
{
dis += POW((uint32)(NrfBuff[j + 1] - '0'), i - j);
}
}
}
}
}
else
{
if (FreecaleConfig.Config.Mode.NrfSendDistance)
{
sprintf(NrfBuff, "$%d#", CarDistance);
NrfSendStrCheck(NrfBuff, sizeof(NrfBuff) / sizeof(uint8), 3);
}
}
}
//////////////////////////////////////////////////////////////////////////
exitthismainloop:
//延迟，控制周期
DELAY_MS(20);
}
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//Don't leave main////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
}
// *****************************************************************************
// InitialiseHW
// Setup the processor
// *****************************************************************************
void InitialiseHW ( void )
{
// If running on Rev A2 silicon, turn the LDO voltage up to 2.75V. This is
// a workaround to allow the PLL to operate reliably.
//
if(REVISION_IS_A2)
{
SysCtlLDOSet(SYSCTL_LDO_2_75V);
}
// 50 MHz
SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ);
// Enable Peripherals
SysCtlPeripheralEnable(SYSCTL_PERIPH_ETH);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOG);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOH);
SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
SysCtlPeripheralEnable(SYSCTL_PERIPH_UART1);
// Set interrupt priority levels
IntPrioritySet(INT_ETH, 0x20);
IntPrioritySet(FAULT_SYSTICK, 0x40);
//
// Enable the peripherals that should continue to run when the processor
// is sleeping.
//
SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_GPIOA);
SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_GPIOB);
SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_GPIOC);
SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_GPIOD);
SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_GPIOE);
SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_GPIOF);
SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_GPIOG);
SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_GPIOH);
SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_UART0);
SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_UART1);
SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_ETH);
SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_TIMER0);
SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_TIMER1);
SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_TIMER2);
//
// Enable peripheral clock gating. Note that this is required in order to
// measure the the processor usage.
//
SysCtlPeripheralClockGating(true);
// Grab the Config from Flash
SysConfigInit();
AdcInit();
pwmInit();
RelayInit();
//usrand(0x23482937);
// Note (From the DriverLib) :
// It takes five clock cycles after the write to enable a peripheral
// before the the peripheral is actually enabled. During this time, attempts
// to access the peripheral result in a bus fault. Care should be taken
// to ensure that the peripheral is not accessed during this brief time
// period.
#ifdef SERIAL_ENABLED
Serial_Init();
#endif
#ifdef UPNP_ENABLED
UPnPInit();
#endif
Ethernet_Init();
#ifdef LOGIC_ENABLED
LogicStartStop(true);
#endif
#ifdef SOLDERBRIDGES_ENABLED
SB_Init();
ExtGpio_Init();
SolderBridge_StartScan();
ExtGpio_Scan();
#endif
#ifdef SPLASHPIXEL_ENABLED
SP_Init();
#endif
// Set up the GPIO as specified by the user
UserGpioInit();
// Most, if not all M3's have a SysTick which you can use for scheduling your code
SysTickPeriodSet(SysCtlClockGet() / SYSTICKHZ);
SysTickEnable();
SysTickIntEnable();
}
/******************************************************************************
* HostCtrlInitiateReset()
*
* Triggers a reset according to the reason and modifies the reset behaviour
* based on any rstFlags/overrides
*****************************************************************************/
void HostCtrlInitiateReset( WORD reason, WORD rstFlags )
{
if( ResetInProgress ) {
return;
}
if( (rstFlags & RESET_HOST_WARM) == 0 ) {
ResetInProgress = TRUE;
HostCtrlPrepResetProc();
if( AppCallsAllowed ) {
AppExitpoint();
}
I2cUninit();
HostCtrlGpioReset( rstFlags );
}
// if we are doing a soft reset we need to capture the log here
if( (rstFlags & RESET_PMU430_CORE) == 0 ) {
// trigger the pre-reset log to be captured to our buffer
// so when the host boots up again we can read it.
EventLogInit();
// make sure we update the correct reset value which will be read
// by the host when it boots again
UpdateResetStat( reason );
}
InitiateResetReason = reason;
InitiateResetFlags = rstFlags;
// don't sequence the supplies if its a warm reset, just
// turn off the ones that should be off, and reset their default voltages
if( rstFlags & RESET_HOST_WARM ) {
#if defined( PROCESSOR_MQ31 )
const BYTE mask[] = { PLATFORM_WARM_RESET_MASK_LIST };
const BYTE size = sizeof(mask) / sizeof(mask[0]);
BYTE reg;
BYTE index;
#endif
// stop any pending adc and re-init it
if( AppCallsAllowed ) {
AdcUninit();
AdcInit();
}
HostCtrlPmicRegisterReset( rstFlags );
#if defined( PROCESSOR_PMU430 )
PmicClear( PMIC_EN_CMD0, ~CMD0_WARM_RESET_MASK );
PmicClear( PMIC_EN_CMD1, ~CMD1_WARM_RESET_MASK );
PmicClear( PMIC_EN_CMD2, ~CMD2_WARM_RESET_MASK );
#else
#if defined( PROCESSOR_MQ31 )
// disable only supply voltages which are not on the mask list
for( reg=PMIC_VOUTCONFIG1B1 ; reg<=PMIC_L23_CNFG1 ; reg++ ) {
if( (reg <= PMIC_VOUTCONFIG1B5) || (reg >= PMIC_L01_CNFG1) ) {
// search if supply voltage is on the mask list
for( index=0; index<size; index++ ) {
if( reg == mask[index] ) {
break;
}
}
if( index == size) {
// supply voltage is not on the mask list
if( reg == PMIC_LDO_RSVD ) {
// reserve supply voltage
} else if( reg <= PMIC_VOUTCONFIG1B5 ) {
// SM supply voltage
PmicClear( reg, BUCK_PWR_MD_NORMAL );
} else {
// LDO supply voltage
if( PMIC_L23_CNFG1 == reg )
PmicClear( reg, (1 << 5) );
else
PmicClear( reg, LDO_PWR_MD_NORMAL );
}
}
}
}
#endif // PROCESSOR_MQ31
#endif // PROCESSOR_PMU430
ResetInProgress = FALSE;
} else {
#if defined( PROCESSOR_MQ31 )
// Disable active discharge on LDO4
PmicClear( PMIC_L04_CNFG2, (1<<1) );
#endif
SupplySequenceRun( SUPSEQ_POS_UNCHANGED, SUPSEQ_DIR_PWRDN );
}
return;
}
/*
* This function initializes the ADC for the POT_ANALOG_PIN to be available for use. Also
* initializes the last value used for detecting events within PotCheckEvents().
*/
void PotInit(void)
{
AdcInit(POT_ANALOG_PIN);
}
int main()
{
// Configure the device for maximum performance but do not change the PBDIV
// Given the options, this function will change the flash wait states, RAM
// wait state and enable prefetch cache but will not change the PBDIV.
// The PBDIV value is already set via the pragma FPBDIV option above..
SYSTEMConfig(F_SYS, SYS_CFG_WAIT_STATES | SYS_CFG_PCACHE);
// Auto-configure the PIC32 for optimum performance at the specified operating frequency.
SYSTEMConfigPerformance(F_SYS);
// osc source, PLL multipler value, PLL postscaler , RC divisor
OSCConfig(OSC_POSC_PLL, OSC_PLL_MULT_20, OSC_PLL_POST_1, OSC_FRC_POST_1);
// Configure the PB bus to run at 1/4th the CPU frequency, so 20MHz.
OSCSetPBDIV(OSC_PB_DIV_4);
// Enable multi-vector interrupts
INTEnableSystemMultiVectoredInt();
INTEnableInterrupts();
// Configure Timer 2 using PBCLK as input. We configure it using a 1:16 prescalar, so each timer
// tick is actually at F_PB / 16 Hz, so setting PR2 to F_PB / 16 / 100 yields a .01s timer.
OpenTimer2(T2_ON | T2_SOURCE_INT | T2_PS_1_16, F_PB / 16 / 100);
// Set up the timer interrupt with a medium priority of 4.
INTClearFlag(INT_T2);
INTSetVectorPriority(INT_TIMER_2_VECTOR, INT_PRIORITY_LEVEL_4);
INTSetVectorSubPriority(INT_TIMER_2_VECTOR, INT_SUB_PRIORITY_LEVEL_0);
INTEnable(INT_T2, INT_ENABLED);
/******************************** Your custom code goes below here ********************************/
int check;
OledInit();
AdcInit();
LEDS_INIT();
check = GameInit();
if(check == STANDARD_ERROR) {
FATAL_ERROR();
}
float currPage;
float binSize;
float titleSize;
float descSize;
float numPages;
uint8_t roomExit;
uint16_t adcValue = 0;
while(1) {
roomExit = GameGetCurrentRoomExits();
LEDS_SET(roomExit);
while(buttonEvents == 0) {
descSize = GameGetCurrentRoomDescription(roomData.description);
titleSize = GameGetCurrentRoomTitle(roomData.title);
numPages = ((titleSize + descSize) / MAX_OLED_PIXELS);
binSize = (ADC_MAX_VALUE / numPages);
if(AdcChanged()) {
adcValue = AdcRead();
}
currPage = (adcValue / binSize);
if(currPage < 1) {
char titleArray[TITLE_OLED_SPACE] = {0};
char descriptionBuffer[FIRST_PG_DESCRIPTION_OLED_SPACE] = {0};
strncpy(descriptionBuffer, roomData.description, DESCRIPTION_COPY);
sprintf(titleArray, "%s\n%s", roomData.title, descriptionBuffer);
OledClear(OLED_COLOR_BLACK);
OledDrawString(titleArray);
} else {
char buffer[MAX_OLED_PIXELS] = {0};
int buffIndex;
buffIndex = (int)currPage * MAX_OLED_PIXELS;
strncpy(buffer, (roomData.description + buffIndex - OFFSET), MAX_OLED_PIXELS);
OledClear(OLED_COLOR_BLACK);
OledDrawString(buffer);
}
OledUpdate();
}
if((buttonEvents & BUTTON_EVENT_4UP) && (roomExit & GAME_ROOM_EXIT_NORTH_EXISTS)) {
GameGoNorth();
} else if((buttonEvents & BUTTON_EVENT_3UP) && (roomExit & GAME_ROOM_EXIT_EAST_EXISTS)) {
GameGoEast();
} else if((buttonEvents & BUTTON_EVENT_2UP) && (roomExit & GAME_ROOM_EXIT_SOUTH_EXISTS)) {
GameGoSouth();
} else if((buttonEvents & BUTTON_EVENT_1UP) && (roomExit & GAME_ROOM_EXIT_WEST_EXISTS)) {
GameGoWest();
}
buttonEvents = BUTTON_EVENT_NONE;
}
/**************************************************************************************************/
while (1);
}
/********************************************************************
函数功能：主函数。
入口参数：无。
返 回：无。
备 注：无。
********************************************************************/
void main(void)
{
#ifdef DEBUG0
int i;
#endif
int InterruptSource;
SystemClockInit(); //系统时钟初始化
LedInit(); //LED对应的管脚初始化
LcdInit(); //LCD初始化
AdcInit(); //ADC初始化
Timer1Init(); //定时器1初始化，用来产生10ms的定时扫描信号
KeyInit(); //键盘初始化
Uart0Init(); //串口0初始化
#ifdef DEBUG0
for(i=0;i<16;i++) //显示头信息
{
Prints(HeadTable[i]);
}
#endif
UsbChipInit(); //初始化USB部分
while(1)
{
InterruptSource=(*AT91C_UDP_ISR)&(0x0F|(1<<8)|(1<<12)); //取出需要的中断
if(InterruptSource) //如果监视的中断发生
{
if(InterruptSource&(1<<8))
{
*AT91C_UDP_ICR=1<<8; //清除中断
UsbBusSuspend(); //总线挂起中断处理
}
if(InterruptSource&(1<<12))
{
*AT91C_UDP_ICR=1<<12; //清除中断
UsbBusReset(); //总线复位中断处理
}
if(InterruptSource&(1<<0))
{
if(AT91C_UDP_CSR[0]&((1<<1)|(1<<2)|(1<<6))) //如果是SETUP包、缓冲未空等
{
UsbEp0Out(); //端点0输出中断处理
}
if(AT91C_UDP_CSR[0]&(1<<0)) //如果是端点0输入完成
{
UsbEp0In(); //端点0输入中断处理
}
}
if(InterruptSource&(1<<1))
{
UsbEp1In(); //端点1输入中断处理
}
if(InterruptSource&(1<<2))
{
UsbEp2Out(); //端点2输出中断处理
}
if(InterruptSource&(1<<3))
{
UsbEp3In(); //端点3输入中断处理
}
}
if(KeyUp||KeyDown) //如果用户操作了按键
{
DispKey(); //在LCD上显示按键情况
if(ConfigValue!=0) //如果已经设置为非0的配置，则可以返回报告数据
{
if(!Ep1InIsBusy) //如果端点1输入没有处于忙状态，则可以发送数据
{
KeyCanChange=0; //禁止按键扫描
if(KeyUp||KeyDown) //如果有按键事件发生
{
SendReport(); //则返回报告
}
KeyCanChange=1; //允许按键扫描
}
}
//清除KeyUp和KeyDown
KeyUp=0;
KeyDown=0;
LcdRefresh(); //刷新LCD显示
}
}
}
/******************主程序********************************/
void main(void)
{
Pin_Init();
T0_Init();
Uart_Init();
Uart2_Init();
Uart_AppInit();
Uart2_AppInit();
MdTcbInit();
MdTcbInit2();
AdcInit();
PWMInit();
FCInitOne();
while (1)
{
TimeDeal(&FC1);
MdPoll();
MdMasterPoll();
FCKeyScan(&FC1);
ResetDeal(&FC1);
FCURun(&FC1);
FCRelayOutput(&FC1);
if (FC1.Buff.Flag.solo._2msFlag)
{
// FC2IOScan(&FC1);
swih ^= 1;
PORTB_PORTB4 = swih;
TestSpeed();
UartTimeOut(&UartAppData1);
UartTimeOut(&UartAppData2);
}
if (FC1.Buff.Flag.solo._4msFlag)
{
InputDeal();
}
if (FC1.Buff.Flag.solo._10msFlag)
{
FCWorkTime(&FC1);
}
if (FC1.Buff.Flag.solo._20msFlag)
{
AdcGetAll(&FC1);
FCAnalogOutSet(&FC1);
EePromDeal(&FC1.Run, sizeof(FC_RUNING_Def) - CRC_LEN, &EeSave1);
}
if (FC1.Buff.Flag.solo._10000msFlag)
{
uint16 tmpCrc = FC1.Run.RunCrc;
uint16 tmpCrcNew = GetCRC16((uint08 *)&FC1.Run, sizeof(FC_RUNING_Def) - CRC_LEN);
if (tmpCrc != tmpCrcNew)
{
EeWriteTrg(&EeSave1);
}
}
if (FC1.Buff.Flag.solo._nmsFlag)
{
speedPerMin = speedCnt * 60 / 4 / (nTimeSpeed / 100);
speedCnt = 0;
}
FC1.Buff.Flag.All = 0;
}
}
int main(void) {
MainInit();
I2C1init();
RtcInit();
LcdInit();
DataLogInit();
StringInit();
Mct485Init();
FieldInit();
Ads1115Init();
Ads1244Init();
USBInit();
RtuInit();
AdcInit();
TC74Init();
// enable multi-vector interrupts
INTEnableSystemMultiVectoredInt();
MainDelay(50);
DataLogDateTime(DLOG_SFC_POWERUP);
// init param after interrupts are enabled
ParamInit();
// wait to init desiccant until after ParamInit
DesiccantInit();
string[0].mct[0].chan[4] = 0x7FFF;
//
// Begin Main Loop
//
for (;;) {
if (test == 1) {
test = 0;
FieldNewState((FIELD_STATE_m)t1);
}
USBUpdate(); // called as often as possible
//sysTickEvent every ms
if (sysTickEvent) {
sysTickEvent = 0;
sysTicks++;
UsbTimeoutUpdate();
LcdUpdate();
// fill time before dropping LCD_E
if (sysTicks >= 1000) {
sysSec++;
sysTicks = 0;
mPORTDToggleBits(PD_LED_HEARTBEAT);
// These Updates are
// called once a second
//TODO if any of these are long, we could split them on separate milliseconds.
DesiccantUpdate();
AdcUpdate();
TC74Update();
}// end 1 Hz
else if (sysTicks == 250) {
mPORTDToggleBits(PD_LED_HEARTBEAT);
}
else if (sysTicks == 500) {
mPORTDToggleBits(PD_LED_HEARTBEAT);
}
else if (sysTicks == 750) {
mPORTDToggleBits(PD_LED_HEARTBEAT);
}
// Complete LcdUpdate() by dropping LCD_E)
PORTClearBits(IOPORT_G, PG_LCD_E);
// These Updates called once each millisecond
RtcUpdate();
I2C1update();
StringUpdate();
Mct485Update();
FieldUpdate();
RtuUpdate();
DessicantFanPWMupdate();
} // if (sysTickEvent)
} // for (;;)
} // main()
// Attached to USB
void RunAttached(void)
{
// Do this first to give the card time to start up
SD_ENABLE(); // Turn on SD card
// Enable peripherals
RtcInterruptOn(0); // Keeps time upto date
LED_SET(LED_WHITE);
CLOCK_PLL(); // PLL clock
// Initialize sensors
// Check if we have an accelerometer
AccelVerifyDeviceId();
// Check if we have a gyro
#ifdef USE_GYRO
GyroVerifyDeviceId();
#endif
#ifdef HAS_PROX
// Check for prox
ProxVerifyDeviceId();
ProxStartup();
#endif
// Initialize sensors
AccelStartup(ACCEL_RANGE_4G|ACCEL_RATE_100);
#ifdef USE_GYRO
GyroStartup();
#endif
AdcInit();
#ifndef NO_DISPLAY
DisplayClear();
Display_print_xy(" <= USB =>",0,2,2);
#endif
status.diskMounted = (status.lockCode == 0x0000) ? 1 : 0;
status.stream = 0;
// MDD_MediaInitialize(); // KL FIX: The SD card is re-inited in the usb framework which causes a lockup in some cases
// Power up module if off
PMD4bits.USB1MD = 0;
USBInitializeSystem(); // Initializes buffer, USB module SFRs and firmware
#ifdef USB_INTERRUPT
USBDeviceAttach();
#endif
while(USB_BUS_SENSE && restart != 1)
{
// Check bus status and service USB interrupts.
#ifndef USB_INTERRUPT
USBDeviceTasks(); // Interrupt or polling method. If using polling, must call
#endif
USBProcessIO();
if ((USBGetDeviceState() >= CONFIGURED_STATE) && (USBIsDeviceSuspended() == FALSE))
{
const char *line = _user_gets();
status.attached = 1;
if (line != NULL)
{
status.stream = 0; // Disable streaming
SettingsCommand(line, SETTINGS_USB);
}
}
else
{
status.attached = -1;
}
TimedTasks();
// Stream accelerometer data
if (status.stream)
{
#define STREAM_RATE 10
#define STREAM_INTERVAL (0x10000UL / STREAM_RATE)
static unsigned long lastSampleTicks = 0;
unsigned long now = RtcTicks();
if (lastSampleTicks == 0) { lastSampleTicks = now; }
if (now - lastSampleTicks > STREAM_INTERVAL)
{
accel_t accelSample;
#ifdef USE_GYRO
gyro_t gyroSample;
#endif
extern unsigned char scratchBuffer[];
char * ptr = (char *)scratchBuffer;
unsigned short len;
lastSampleTicks += STREAM_INTERVAL;
if (now - lastSampleTicks > 2 * STREAM_INTERVAL) { lastSampleTicks = now; } // not keeping up with sample rate
#ifdef HAS_PROX
// Sample sensors
if(ProxSampleReady())
{
ProxReadSample();
ProxStartSample();
}
#endif
AccelSingleSample(&accelSample);
#ifdef USE_GYRO
GyroSingleSample(&gyroSample);
#endif
// Write ascii to scratch buffer
ptr = (char *)scratchBuffer;
ptr += sprintf(ptr, "\f$ACCEL=%d,%d,%d\r\n", accelSample.x, accelSample.y, accelSample.z);
#ifdef USE_GYRO
ptr += sprintf(ptr, "$GYRO=%d,%d,%d\r\n", gyroSample.x, gyroSample.y, gyroSample.z);
#endif
#ifdef HAS_PROX
ptr += sprintf(ptr, "$PROX=%d\r\n", prox.proximity);
ptr += sprintf(ptr, "$LIGHT=%d\r\n", prox.light);
#endif
len = (unsigned short)((void*)ptr - (void*)scratchBuffer);
// Stream over USB
if ((status.stream) && status.attached == 1) { usb_write(scratchBuffer, len); }
}
}
}
#if defined(USB_INTERRUPT)
USBDeviceDetach();
#endif
status.attached = -1;
return;
}
