//***************************************************************************** // // Called by the NVIC as a result of GPIO port M interrupt event. For this // application GPIO port M pin 3 is the interrupt line for the MPU9150 // // For BoosterPack 2 Interface use Port M pin 7. // //***************************************************************************** void GPIOPortMIntHandler(void) { unsigned long ulStatus; // // Get the status flags to see which pin(s) caused the interrupt. // ulStatus = GPIOIntStatus(GPIO_PORTM_BASE, true); // // Clear all the pin interrupts that are set // GPIOIntClear(GPIO_PORTM_BASE, ulStatus); // // Check if this is an interrupt on the MPU9150 interrupt line. // // For BoosterPack 2 use Pin 7 instead. // if(ulStatus & GPIO_PIN_3) { // // Turn on the LED to show that transaction is starting. // LEDWrite(CLP_D3 | CLP_D4, CLP_D3); // // MPU9150 Data is ready for retrieval and processing. // MPU9150DataRead(&g_sMPU9150Inst, MPU9150AppCallback, &g_sMPU9150Inst); } }
void Timer1IntHandler(void) { TimerIntClear(TIMER1_BASE, TIMER_TIMA_TIMEOUT); if(GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_0)) { GPIOPinWrite(GPIO_PORTF_BASE,GPIO_PIN_0, PIN_LOW); } else { GPIOPinWrite(GPIO_PORTF_BASE,GPIO_PIN_0, PIN_HIGH); } switch(sensorTurn) { case 0: { TMP006DataRead(&g_sTMP006Inst, TMP006AppCallback, &g_sTMP006Inst); TimerDisable(TIMER1_BASE, TIMER_A); break; } case 1: { BMP180DataRead(&g_sBMP180Inst, BMP180AppCallback, &g_sBMP180Inst); TimerDisable(TIMER1_BASE, TIMER_A); break; } case 2: { ISL29023DataRead(&g_sISL29023Inst, ISL29023AppCallback, &g_sISL29023Inst); TimerDisable(TIMER1_BASE, TIMER_A); break; } case 3: { SHT21DataRead(&g_sSHT21Inst, SHT21AppCallback, &g_sSHT21Inst); TimerDisable(TIMER1_BASE, TIMER_A); break; } case 4: { MPU9150DataRead(&g_sMPU9150Inst, MPU9150AppCallback, &g_sMPU9150Inst); TimerDisable(TIMER1_BASE, TIMER_A); break; } } }
//***************************************************************************** // // Called by the NVIC as a result of GPIO port E interrupt event. For this // application GPIO port E pin 2 is the interrupt line for the MPU9150 // //***************************************************************************** void IntGPIOE(void) { unsigned long ulStatus; ulStatus = GPIOIntStatus(GPIO_PORTE_BASE, true); // // Clear all the pin interrupts that are set // GPIOIntClear(GPIO_PORTE_BASE, ulStatus); if (ulStatus & GPIO_PIN_2) { // // MPU9150 Data is ready for retrieval and processing. // MPU9150DataRead(&g_sMPU9150Inst, MPU9150AppCallback, &g_sMPU9150Inst); } }
//***************************************************************************** // // Called by the NVIC as a result of GPIO port S interrupt event. For this // application GPIO port S pin 2 is the interrupt line for the MPU9150 // //***************************************************************************** void GPIOSIntHandler(void) { uint32_t ui32Status; ui32Status = MAP_GPIOIntStatus(GPIO_PORTS_BASE, true); // // Clear all the pin interrupts that are set // MAP_GPIOIntClear(GPIO_PORTS_BASE, ui32Status); // // Check which GPIO caused the interrupt event. // if(ui32Status & GPIO_PIN_2) { // // The MPU9150 data ready pin was asserted so start an I2C transfer // to go get the latest data from the device. // MPU9150DataRead(&g_sMPU9150Inst, MotionCallback, &g_sMPU9150Inst); } }
void main (void) { SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3); ROM_SysCtlClockSet (SYSCTL_SYSDIV_2_5 | SYSCTL_USE_PLL | SYSCTL_XTAL_16MHZ | SYSCTL_OSC_MAIN); IntMasterEnable(); ConfigureUART(); ConfigureGPRS(); float fAccel[3]; tMPU9150 sMPU9150; UARTprintf("Point 0\n"); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_I2C3); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); 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 MPU9150. This code assumes that the I2C master instance // has already been initialized. // I2CMInit(&sI2CInst, I2C3_BASE, INT_I2C3, 0xff, 0xff, ROM_SysCtlClockGet()); GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3, 4); UARTprintf("Point 2\n"); g_bMPU9150Done = false; MPU9150Init(&sMPU9150, &sI2CInst, 0x68, MPU9150Callback, 0); while(!g_bMPU9150Done) { } // // Configure the MPU9150 for +/- 4 g accelerometer range. // UARTprintf("Point 3\n"); g_bMPU9150Done = false; // MPU9150ReadModifyWrite(&sMPU9150, MPU9150_O_ACCEL_CONFIG, // ~MPU9150_ACCEL_CONFIG_AFS_SEL_M, // MPU9150_ACCEL_CONFIG_AFS_SEL_16G, MPU9150Callback, // 0); sMPU9150.pui8Data[0] = MPU9150_CONFIG_DLPF_CFG_94_98; sMPU9150.pui8Data[1] = MPU9150_GYRO_CONFIG_FS_SEL_250; sMPU9150.pui8Data[2] = (MPU9150_ACCEL_CONFIG_ACCEL_HPF_5HZ | MPU9150_ACCEL_CONFIG_AFS_SEL_16G); MPU9150Write(&sMPU9150, MPU9150_O_CONFIG, sMPU9150.pui8Data, 3, MPU9150Callback, 0); // while(1){} while(!g_bMPU9150Done) { } // // Loop forever reading data from the MPU9150. Typically, this process // would be done in the background, but for the purposes of this example, // it is shown in an infinite loop. // int count=0; int prev_count=-100; int is_acc=0; float imp[3]; int j=0; for(;j<2;j++) imp[j]=0; float curr_avg=0; while(1) { GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3, 8); // // Request another reading from the MPU9150. // g_bMPU9150Done = false; if(!MPU9150DataRead(&sMPU9150, MPU9150Callback, 0)) continue; while(!g_bMPU9150Done) { } // // Get the new accelerometer, gyroscope, and magnetometer readings. // float backup[3]; int l=0; if(count!=0)for(;l<3;l++)backup[l]=fAccel[l]; MPU9150DataAccelGetFloat(&sMPU9150, &fAccel[0], &fAccel[1], &fAccel[2]); // MPU9150DataGyroGetFloat(&sMPU9150, &fGyro[0], &fGyro[1], &fGyro[2]); // MPU9150DataMagnetoGetFloat(&sMPU9150, &fMagneto[0], &fMagneto[1], // &fMagneto[2]); // float factor = 0.0011970964; // UARTprintf("%d %d %d ",(int)(fMagneto[0]*1000), (int)(fMagneto[1]*1000),(int)(fMagneto[2]*1000)); // UARTprintf("Accel %d %d %d \n",(int)(fAccel[0]*1000), (int)(fAccel[1]*1000),(int)(fAccel[2]*1000)); // if(count ==0)UARTprintf("\n"); // UARTprintf("Gyro %d %d %d \n",(int)(fGyro[0]*1000), (int)(fGyro[1]*1000),(int)(fGyro[2]*1000)); // int iter; // for(iter=0;iter<6;iter++) // UARTprintf("%f %f %f \n",fAccel[0]*factor, fAccel[1] *factor,fAccel[2]*factor ); float temp = check_acc(fAccel, backup); curr_avg = curr_avg + (temp - curr_avg)/(count +1); if(is_acc && count< prev_count+ 400) { int j=0; for(;j<2;j++)imp[j]+=(fAccel[j] - backup[j]); } if(is_acc && count == prev_count + 400) { is_acc = 0; UARTprintf("Impulse %d %d %d \n",(int)(imp[0]*1000), (int)(imp[1]*1000),(int)(imp[2]*1000)); int side = 0; int sign=0; int j=0, max_imp = 0; for(;j<2;j++) if(imp[j]*imp[j] > max_imp) { max_imp = imp[j]*imp[j]; side = j; sign = imp[j] > 0 ? 1 : -1; } send_accident_data(side, sign); j=0; for(;j<2;j++)imp[j]=0; } if(count!=0 && temp >= thres && count >= prev_count + 400) { UARTprintf("Accel %d %d %d ",(int)(fAccel[0]*1000), (int)(fAccel[1]*1000),(int)(fAccel[2]*1000)); prev_count = count; is_acc=1; } count++; if(count % 5000 ==0) UARTprintf("Driver stats : %d\r\n", (int)(curr_avg)); if(count % 50000 == 0) { int rating = driver_rating(curr_avg); // UARTprintf("Sending data to server\r\n"); memset(command,0,200); strcpy(command,"AT+HTTPPARA=\"URL\",\"embedded-roshanroshan.rhcloud.com/add/Driver_rating="); itoa(rating, command+strlen(command)); strcpy(command+strlen(command), "\""); send_AT_command(command,NULL); send_AT_command("AT+HTTPACTION=0",NULL); count=0; curr_avg = 0; } GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3, 0); // SysCtlDelay(5000000); // // Do something with the new accelerometer, gyroscope, and magnetometer // readings. // } }