int main(void) {
int delay;
float fTemperature, fPressure, fAltitude, fK_Altitude, fAltitude_sum,fK_Altitude_sum;
int count,i;
// static float f_meas[VAR_COUNT], fAlt_Mean, fAlt_Var;
unsigned short sw1_count, sw2_count;
unsigned char sw1_was_cleared = 0, sw2_was_cleared = 0;
// Set the clocking to run directly from the external crystal/oscillator.
MAP_SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |
WRFL_XTAL);
//init ports and peripherals
PlatformInit();
Nokia5110_Init();
Nokia5110_Clear();
Nokia5110_DrawFullImage(gears_logo);
for(delay=0; delay<1000000; delay=delay+1);
Nokia5110_Clear();
Nokia5110_SetCursor(3, 1);
Nokia5110_OutString("WRFL");
Nokia5110_SetCursor(1, 2);
Nokia5110_OutString("Prototype");
Nokia5110_SetCursor(2, 4);
Nokia5110_OutString("VER 0.1");
Nokia5110_SetCursor(0, 5);
Nokia5110_OutString("NightMecanic");
for(delay=0; delay<1000000; delay=delay+1);
Nokia5110_Clear();
//
// Enable interrupts to the processor.
//
MAP_IntMasterEnable();
//
// Initialize I2C1 peripheral.
//
I2CMInit(&g_sI2CInst, BMP180_I2C_BASE, BMP180_I2C_INT, 0xff, 0xff,
MAP_SysCtlClockGet());
//
// Initialize the BMP180
//
BMP180Init(&g_sBMP180Inst, &g_sI2CInst, BMP180_I2C_ADDRESS,
BMP180AppCallback, &g_sBMP180Inst);
//
// Wait for initialization callback to indicate reset request is complete.
//
while(g_vui8DataFlag == 0)
{
//
// Wait for I2C Transactions to complete.
//
}
//
// Reset the data ready flag
//
g_vui8DataFlag = 0;
//set oversampling to 8x
g_sBMP180Inst.ui8Mode = 0xC0;
//Initialize the Kalman filter
Kalman_Init(&Alt_KState, 0.0f, 1.0f, ALT_KALMAN_R, ALT_KALMAN_Q);
//
// Enable the system ticks at 10 hz.
//
MAP_SysTickPeriodSet(MAP_SysCtlClockGet() / (40 * 3));
MAP_SysTickIntEnable();
MAP_SysTickEnable();
Nokia5110_SetCursor(0, 0);
Nokia5110_OutString("SW1:");
Nokia5110_SetCursor(0, 2);
Nokia5110_OutString("SW2:");
//config done
count = 0;
//
// Begin the data collection and printing. Loop Forever.
//
while(1)
{
// SW1
if (sw_state & SW1){
if (sw1_was_cleared){
sw1_was_cleared = 0;
sw1_count++;
Nokia5110_SetCursor(5, 0);
Nokia5110_OutUDec(sw1_count);
}
}else
sw1_was_cleared = 1;
//SW2
if (sw_state & SW2){
if (sw2_was_cleared){
sw2_was_cleared = 0;
sw2_count++;
Nokia5110_SetCursor(5, 2);
Nokia5110_OutUDec(sw2_count);
}
}else
sw2_was_cleared = 1;
// handle BMP180 data (display average every 50 samples)
if (g_vui8DataFlag ){
//
// Reset the data ready flag.
//
g_vui8DataFlag = 0;
//
// Get a local copy of the latest temperature data in float format.
//
BMP180DataTemperatureGetFloat(&g_sBMP180Inst, &fTemperature);
//
// Print temperature with three digits of decimal precision.
//
//Nokia5110_SetCursor(0, 0);
//Nokia5110_OutString("Temp:");
//Nokia5110_OutFloatp3(fTemperature);
//
// Get a local copy of the latest air pressure data in float format.
//
BMP180DataPressureGetFloat(&g_sBMP180Inst, &fPressure);
//
// Print Pressure with three digits of decimal precision.
//
//Nokia5110_SetCursor(0, 1);
// Nokia5110_OutString("Pres:");
//Nokia5110_SetCursor(0, 2);
//display in hPa
//Nokia5110_OutFloatp3((fPressure / 100.0f));
//
// Calculate the altitude.
//
//fAltitude = 44330.0f * (1.0f - powf(fPressure / 101325.0f,
// 1.0f / 5.255f));
//corrected:
fAltitude = 44330.0f * (1.0f - powf(fPressure / LOC_ALT_P0,
1.0f / 5.255f));
// Kalman filtered altitude
Kalman_Update (&Alt_KState, fAltitude);
fK_Altitude = Alt_KState.X;
fAltitude_sum += fAltitude;
fK_Altitude_sum += fK_Altitude;
count++;
if (count>=50){
Nokia5110_SetCursor(0, 3);
Nokia5110_OutString("Alt:");
Nokia5110_OutFloatp3(fAltitude_sum/50.0);
Nokia5110_SetCursor(0, 5);
Nokia5110_OutString("KAlt:");
Nokia5110_OutFloatp3(fK_Altitude_sum/50.0);
fAltitude_sum = 0;
fK_Altitude_sum = 0;
count = 0;
}
/*
//calculate variance
f_meas[count]=fK_Altitude;
count++;
if (count>=VAR_COUNT){
fAlt_Mean = 0.0f;
fAlt_Var = 0.0f;
// calculate mean
for(i=0; i<VAR_COUNT; i++){
fAlt_Mean = fAlt_Mean +f_meas[i];
}
fAlt_Mean = fAlt_Mean/((float) VAR_COUNT);
// Calculate Var
for(i=0; i<VAR_COUNT; i++){
fAlt_Var = fAlt_Var + powf((f_meas[i] - fAlt_Mean),2.0f);
}
fAlt_Var = fAlt_Var/((float) VAR_COUNT);
//
// Print altitude with three digits of decimal precision.
//
Nokia5110_SetCursor(0, 4);
Nokia5110_OutString("Var:");
Nokia5110_OutFloatp3(fAlt_Var);
count = 0;
}
*/
//
// Delay to keep printing speed reasonable. About 100msec.
//
//MAP_SysCtlDelay(MAP_SysCtlClockGet() / (10 * 3));
}
}//while end
}
void BMP180AppCallback(void* pvCallbackData, unsigned int ui8Status)
{
float fTemperature, fPressure, fAltitude;
unsigned char tempString[30]={0};
if(ui8Status == I2CM_STATUS_SUCCESS&&sensorTurn==1)
{
//
// Get a local copy of the latest temperature and pressure data in
// float format.
//
BMP180DataTemperatureGetFloat(&g_sBMP180Inst, &fTemperature);
BMP180DataPressureGetFloat(&g_sBMP180Inst, &fPressure);
//
// Convert the temperature to an integer part and fraction part for
// easy print.
//
BMP180_i32IntegerPart1 = (int32_t) fTemperature;
BMP180_i32FractionPart1 =(int32_t) (fTemperature * 1000.0f);
BMP180_i32FractionPart1 = BMP180_i32FractionPart1 - (BMP180_i32IntegerPart1 * 1000);
if(BMP180_i32FractionPart1 < 0)
{
BMP180_i32FractionPart1 *= -1;
}
//
// Print temperature with three digits of decimal precision.
//
//sprintf(tempString,"Temperature %3d.%03d\t", BMP180_i32IntegerPart1,
// BMP180_i32FractionPart1);
//CLI_Write(tempString);
//
// Convert the pressure to an integer part and fraction part for
// easy print.
//
BMP180_i32IntegerPart2 = (int32_t) fPressure;
BMP180_i32FractionPart2 =(int32_t) (fPressure * 1000.0f);
BMP180_i32FractionPart2 = BMP180_i32FractionPart2 - (BMP180_i32IntegerPart2 * 1000);
if(BMP180_i32FractionPart2 < 0)
{
BMP180_i32FractionPart2 *= -1;
}
//
// Print Pressure with three digits of decimal precision.
//
//sprintf(tempString,"Pressure %3d.%03d\t", BMP180_i32IntegerPart2, BMP180_i32FractionPart2);
//CLI_Write(tempString);
//
// Calculate the altitude.
//
fAltitude = 44330.0f * (1.0f - powf(fPressure / 101325.0f,
1.0f / 5.255f));
//
// Convert the altitude to an integer part and fraction part for easy
// print.
//
BMP180_i32IntegerPart3 = (int32_t) fAltitude;
BMP180_i32FractionPart3 =(int32_t) (fAltitude * 1000.0f);
BMP180_i32FractionPart3 = BMP180_i32FractionPart3 - (BMP180_i32IntegerPart3 * 1000);
if(BMP180_i32FractionPart3 < 0)
{
BMP180_i32FractionPart3 *= -1;
}
//
// Print altitude with three digits of decimal precision.
//
//sprintf(tempString,"Altitude %3d.%03d", BMP180_i32IntegerPart3, BMP180_i32FractionPart3);
//CLI_Write(tempString);
//
// Print new line.
//
//CLI_Write("\n\r");
//sensorTurn=3;
sensorTurn=(sensorTurn+1)%NumberOfSensor;
TimerEnable(TIMER1_BASE, TIMER_A);
}
}
//*****************************************************************************
//
// Main 'C' Language entry point.
//
//*****************************************************************************
int
main(void)
{
float fTemperature, fPressure, fAltitude;
int32_t i32IntegerPart;
int32_t i32FractionPart;
tContext sContext;
uint32_t ui32SysClock;
char pcBuf[15];
//
// Setup the system clock to run at 40 Mhz from PLL with crystal reference
//
ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |
SYSCTL_OSC_MAIN |
SYSCTL_USE_PLL |
SYSCTL_CFG_VCO_480), 40000000);
//
// Configure the device pins.
//
PinoutSet();
//
// Initialize the display driver.
//
Kentec320x240x16_SSD2119Init(ui32SysClock);
//
// Initialize the graphics context.
//
GrContextInit(&sContext, &g_sKentec320x240x16_SSD2119);
//
// Draw the application frame.
//
FrameDraw(&sContext, "bmp180");
//
// Flush any cached drawing operations.
//
GrFlush(&sContext);
//
// Enable UART0
//
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
//
// Initialize the UART for console I/O.
//
UARTStdioConfig(0, 115200, ui32SysClock);
//
// Print the welcome message to the terminal.
//
UARTprintf("\033[2JBMP180 Example\n");
//
// The I2C3 peripheral must be enabled before use.
//
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_I2C3);
//
// Configure the pin muxing for I2C3 functions on port G4 and G5.
// This step is not necessary if your part does not support pin muxing.
//
MAP_GPIOPinConfigure(GPIO_PG4_I2C3SCL);
MAP_GPIOPinConfigure(GPIO_PG5_I2C3SDA);
//
// Select the I2C function for these pins. This function will also
// configure the GPIO pins pins for I2C operation, setting them to
// open-drain operation with weak pull-ups. Consult the data sheet
// to see which functions are allocated per pin.
//
MAP_GPIOPinTypeI2CSCL(GPIO_PORTG_BASE, GPIO_PIN_4);
MAP_GPIOPinTypeI2C(GPIO_PORTG_BASE, GPIO_PIN_5);
//
// Enable interrupts to the processor.
//
MAP_IntMasterEnable();
//
// Initialize I2C3 peripheral.
//
I2CMInit(&g_sI2CInst, I2C3_BASE, INT_I2C3, 0xff, 0xff,
ui32SysClock);
//
// Initialize the BMP180
//
BMP180Init(&g_sBMP180Inst, &g_sI2CInst, BMP180_I2C_ADDRESS,
BMP180AppCallback, &g_sBMP180Inst);
//
// Wait for initialization callback to indicate reset request is complete.
//
while(g_vui8DataFlag == 0)
{
//
// Wait for I2C Transactions to complete.
//
}
//
// Reset the data ready flag
//
g_vui8DataFlag = 0;
//
// Enable the system ticks at 10 hz.
//
MAP_SysTickPeriodSet(ui32SysClock / (10 * 3));
MAP_SysTickIntEnable();
MAP_SysTickEnable();
//
// Configure PQ4 to control the blue LED.
//
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTQ_BASE, GPIO_PIN_4);
//
// Print temperature, pressure and altitude labels once on the LCD.
//
GrStringDraw(&sContext, "Temperature", 11,
((GrContextDpyWidthGet(&sContext) / 2) - 96),
((GrContextDpyHeightGet(&sContext) - 32) / 2) - 24, 1);
GrStringDraw(&sContext, "Pressure", 8,
((GrContextDpyWidthGet(&sContext) / 2) - 63),
(GrContextDpyHeightGet(&sContext) - 32) / 2, 1);
GrStringDraw(&sContext, "Altitude", 8,
((GrContextDpyWidthGet(&sContext) / 2) - 59),
((GrContextDpyHeightGet(&sContext) - 32) / 2) + 24, 1);
//
// Begin the data collection and printing. Loop Forever.
//
while(1)
{
//
// Read the data from the BMP180 over I2C. This command starts a
// temperature measurement. Then polls until temperature is ready.
// Then automatically starts a pressure measurement and polls for that
// to complete. When both measurement are complete and in the local
// buffer then the application callback is called from the I2C
// interrupt context. Polling is done on I2C interrupts allowing
// processor to continue doing other tasks as needed.
//
BMP180DataRead(&g_sBMP180Inst, BMP180AppCallback, &g_sBMP180Inst);
while(g_vui8DataFlag == 0)
{
//
// Wait for the new data set to be available.
//
}
//
// Reset the data ready flag.
//
g_vui8DataFlag = 0;
//
// Get a local copy of the latest temperature data in float format.
//
BMP180DataTemperatureGetFloat(&g_sBMP180Inst, &fTemperature);
//
// Convert the floats to an integer part and fraction part for easy
// print.
//
i32IntegerPart = (int32_t) fTemperature;
i32FractionPart =(int32_t) (fTemperature * 1000.0f);
i32FractionPart = i32FractionPart - (i32IntegerPart * 1000);
if(i32FractionPart < 0)
{
i32FractionPart *= -1;
}
//
// Print temperature with three digits of decimal precision to LCD and
// terminal.
//
usnprintf(pcBuf, sizeof(pcBuf), "%03d.%03d ", i32IntegerPart,
i32FractionPart);
GrStringDraw(&sContext, pcBuf, 8,
((GrContextDpyWidthGet(&sContext) / 2) + 16),
((GrContextDpyHeightGet(&sContext) - 32) / 2) - 24, 1);
UARTprintf("Temperature %3d.%03d\t\t", i32IntegerPart,
i32FractionPart);
//
// Get a local copy of the latest air pressure data in float format.
//
BMP180DataPressureGetFloat(&g_sBMP180Inst, &fPressure);
//
// Convert the floats to an integer part and fraction part for easy
// print.
//
i32IntegerPart = (int32_t) fPressure;
i32FractionPart =(int32_t) (fPressure * 1000.0f);
i32FractionPart = i32FractionPart - (i32IntegerPart * 1000);
if(i32FractionPart < 0)
{
i32FractionPart *= -1;
}
//
// Print Pressure with three digits of decimal precision to LCD and
// terminal.
//
usnprintf(pcBuf, sizeof(pcBuf), "%3d.%03d ", i32IntegerPart,
i32FractionPart);
GrStringDraw(&sContext, pcBuf, -1,
((GrContextDpyWidthGet(&sContext) / 2) + 16),
(GrContextDpyHeightGet(&sContext) - 32) / 2, 1);
UARTprintf("Pressure %3d.%03d\t\t", i32IntegerPart, i32FractionPart);
//
// Calculate the altitude.
//
fAltitude = 44330.0f * (1.0f - powf(fPressure / 101325.0f,
1.0f / 5.255f));
//
// Convert the floats to an integer part and fraction part for easy
// print.
//
i32IntegerPart = (int32_t) fAltitude;
i32FractionPart =(int32_t) (fAltitude * 1000.0f);
i32FractionPart = i32FractionPart - (i32IntegerPart * 1000);
if(i32FractionPart < 0)
{
i32FractionPart *= -1;
}
//
// Print altitude with three digits of decimal precision to LCD and
// terminal.
//
usnprintf(pcBuf, sizeof(pcBuf), "%3d.%03d ", i32IntegerPart,
i32FractionPart);
GrStringDraw(&sContext, pcBuf, 8,
((GrContextDpyWidthGet(&sContext) / 2) + 16),
((GrContextDpyHeightGet(&sContext) - 32) / 2) + 24, 1);
UARTprintf("Altitude %3d.%03d", i32IntegerPart, i32FractionPart);
//
// Print new line.
//
UARTprintf("\n");
//
// Delay to keep printing speed reasonable. About 100 milliseconds.
//
MAP_SysCtlDelay(ui32SysClock / (10 * 3));
}
}
//*****************************************************************************
//
// Main 'C' Language entry point.
//
//*****************************************************************************
int
main(void)
{
float fTemperature, fPressure, fAltitude;
int32_t i32IntegerPart;
int32_t i32FractionPart;
//
// Setup the system clock to run at 40 MHz from PLL with crystal reference
//
ROM_SysCtlClockSet(SYSCTL_SYSDIV_5 | SYSCTL_USE_PLL | SYSCTL_XTAL_16MHZ |
SYSCTL_OSC_MAIN);
//
// Initialize the UART.
//
ConfigureUART();
//
// Print the welcome message to the terminal.
//
UARTprintf("\033[2JBMP180 Example\n");
//
// Set the color to a white approximation.
//
g_pui32Colors[RED] = 0x8000;
g_pui32Colors[BLUE] = 0x8000;
g_pui32Colors[GREEN] = 0x8000;
//
// Initialize RGB driver. Use a default intensity and blink rate.
//
RGBInit(0);
RGBColorSet(g_pui32Colors);
RGBIntensitySet(0.5f);
RGBEnable();
//
// The I2C3 peripheral must be enabled before use.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_I2C3);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
//
// Configure the pin muxing for I2C3 functions on port D0 and D1.
// This step is not necessary if your part does not support pin muxing.
//
ROM_GPIOPinConfigure(GPIO_PD0_I2C3SCL);
ROM_GPIOPinConfigure(GPIO_PD1_I2C3SDA);
//
// Select the I2C function for these pins. This function will also
// configure the GPIO pins pins for I2C operation, setting them to
// open-drain operation with weak pull-ups. Consult the data sheet
// to see which functions are allocated per pin.
//
GPIOPinTypeI2CSCL(GPIO_PORTD_BASE, GPIO_PIN_0);
ROM_GPIOPinTypeI2C(GPIO_PORTD_BASE, GPIO_PIN_1);
//
// Initialize the GPIO for the LED.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1);
ROM_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, 0x00);
//
// Enable interrupts to the processor.
//
ROM_IntMasterEnable();
//
// Initialize the I2C3 peripheral.
//
I2CMInit(&g_sI2CInst, I2C3_BASE, INT_I2C3, 0xff, 0xff,
ROM_SysCtlClockGet());
//
// Initialize the BMP180.
//
BMP180Init(&g_sBMP180Inst, &g_sI2CInst, BMP180_I2C_ADDRESS,
BMP180AppCallback, &g_sBMP180Inst);
//
// Wait for initialization callback to indicate reset request is complete.
//
while(g_vui8DataFlag == 0)
{
//
// Wait for I2C Transactions to complete.
//
}
//
// Reset the data ready flag
//
g_vui8DataFlag = 0;
//
// Enable the system ticks at 10 Hz.
//
ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / (10 * 3));
ROM_SysTickIntEnable();
ROM_SysTickEnable();
//
// After all the init and config we start blink the LED
//
RGBBlinkRateSet(1.0f);
//
// Begin the data collection and printing. Loop Forever.
//
while(1)
{
//
// Read the data from the BMP180 over I2C. This command starts a
// temperature measurement. Then polls until temperature is ready.
// Then automatically starts a pressure measurement and polls for that
// to complete. When both measurement are complete and in the local
// buffer then the application callback is called from the I2C
// interrupt context. Polling is done on I2C interrupts allowing
// processor to continue doing other tasks as needed.
//
BMP180DataRead(&g_sBMP180Inst, BMP180AppCallback, &g_sBMP180Inst);
while(g_vui8DataFlag == 0)
{
//
// Wait for the new data set to be available.
//
}
//
// Reset the data ready flag.
//
g_vui8DataFlag = 0;
//
// Get a local copy of the latest temperature data in float format.
//
BMP180DataTemperatureGetFloat(&g_sBMP180Inst, &fTemperature);
//
// Convert the floats to an integer part and fraction part for easy
// print.
//
i32IntegerPart = (int32_t) fTemperature;
i32FractionPart =(int32_t) (fTemperature * 1000.0f);
i32FractionPart = i32FractionPart - (i32IntegerPart * 1000);
if(i32FractionPart < 0)
{
i32FractionPart *= -1;
}
//
// Print temperature with three digits of decimal precision.
//
UARTprintf("Temperature %3d.%03d\t\t", i32IntegerPart, i32FractionPart);
//
// Get a local copy of the latest air pressure data in float format.
//
BMP180DataPressureGetFloat(&g_sBMP180Inst, &fPressure);
//
// Convert the floats to an integer part and fraction part for easy
// print.
//
i32IntegerPart = (int32_t) fPressure;
i32FractionPart =(int32_t) (fPressure * 1000.0f);
i32FractionPart = i32FractionPart - (i32IntegerPart * 1000);
if(i32FractionPart < 0)
{
i32FractionPart *= -1;
}
//
// Print Pressure with three digits of decimal precision.
//
UARTprintf("Pressure %3d.%03d\t\t", i32IntegerPart, i32FractionPart);
//
// Calculate the altitude.
//
fAltitude = 44330.0f * (1.0f - powf(fPressure / 101325.0f,
1.0f / 5.255f));
//
// Convert the floats to an integer part and fraction part for easy
// print.
//
i32IntegerPart = (int32_t) fAltitude;
i32FractionPart =(int32_t) (fAltitude * 1000.0f);
i32FractionPart = i32FractionPart - (i32IntegerPart * 1000);
if(i32FractionPart < 0)
{
i32FractionPart *= -1;
}
//
// Print altitude with three digits of decimal precision.
//
UARTprintf("Altitude %3d.%03d", i32IntegerPart, i32FractionPart);
//
// Print new line.
//
UARTprintf("\n");
//
// Delay to keep printing speed reasonable. About 100 milliseconds.
//
ROM_SysCtlDelay(ROM_SysCtlClockGet() / (10 * 3));
}//while end
}
void bmp085DataRead(int index){
BMP180DataRead(&bmpAppInstance[index], bmp085AppCallback, &bmpAppInstance[index]);
while(bmp085_dataFlag == 0); bmp085_dataFlag = 0;
BMP180DataTemperatureGetFloat(&bmpAppInstance[index], &bmpTemperature);
BMP180DataPressureGetFloat(&bmpAppInstance[index], &bmpPressure);
}