/** * @brief Main program * @param None * @retval None */ int main() { int i; /*System clock configuration*/ SystemInit(); /* UART0 and UART1 configuration*/ UART_StructInit(&UART_InitStructure); /* Configure UART0 */ UART_Init(UART1,&UART_InitStructure); printf("######## I2C EEPROM TEST #########\r\n"); /* I2C Init */ /* I2C confiugred as follow: * - I2C master mode * - I2C slave address : 0xA0 * - I2C Prescale : 0x61 * /If MCU clock is 20MHz and Prescale value is 0x61, SCL occurs 100KHz as clock. * - I2C Timeout : 0xFFFF */ conf.mode = I2C_Master; conf.slave_address = 0xA0; conf.master.prescale = 0x61; conf.master.timeout = 0xFFFF; /* Cofigure I2C0 */ I2C_Init(I2C0, conf); /* EEPROM Write Test*/ /* It can transmit up to 9data bytes to the EEPROM(24AA02) ( mem_address 1byte, data 8bytes ) */ if( I2C_Burst_Write(I2C0,conf.slave_address,&Transmit_Data[0],9,1) == -1 ) return -1; /*It must be use the delay function between Write operation and Read operation */ I2C_Delay(0x000F0000); /*I2C Core reset */ I2C_Reset(I2C0); // EEPROM Read Test /* I2C Start */ I2C_Start(I2C0,conf.slave_address,I2C_WRITE_SA7); /* The memory address of EEPROM send to EEPROM and it wait the ack signal */ I2C_SendDataAck(I2C0,0x00); /*Once the Slave address and memotu address are clocked in and *acknowledged by the EEPROM, the W7500 must generate another start condition.*/ I2C_Restart_Structure(I2C0,conf.slave_address,I2C_READ_SA7); /* EEPROM Read Test*/ for(i=0;i<MAX_SIZE;i++) { if(i != MAX_SIZE-1) Recv_Data[i] = I2C_ReceiveData(I2C0,0); else Recv_Data[i] = I2C_ReceiveData(I2C0,1); } for(i=0;i<MAX_SIZE-2;i+=2) printf("[%02d]:%02x, [%02d]:%02x\r\n",i,Recv_Data[i],i+1,Recv_Data[i+1]); return 0; }
inline int i2c_stop(i2c_t *obj) { I2cHandle = (I2C_TypeDef *)(obj->i2c); // Generate the STOP condition I2C_Stop(I2cHandle); I2C_Reset(I2cHandle); obj->is_setAddress = 0; return 0; }
void I2C_Master_Init(I2C_TypeDef* I2Cx, uint32_t freq, pin_t scl, pin_t sda){ if(I2Cx == I2C1){ SET_BIT(RCC->APB1ENR, RCC_APB1ENR_I2C1EN); }else if(I2Cx == I2C2){ SET_BIT(RCC->APB1ENR, RCC_APB1ENR_I2C2EN); } GPIO_ModeAF(scl, AF_OD, AF_4); GPIO_ModeAF(sda, AF_OD, AF_4); I2C_Reset(I2Cx); I2C_SetFreq(I2Cx, freq, I2C_MASTER); }
int i2c_init_master(i2c_t dev, i2c_speed_t speed) { /* check if device is valid */ if (dev >= I2C_NUMOF) { return -1; } /* initialize lock */ mutex_init(&i2c_lock[dev]); /* enable clocks */ CMU_ClockEnable(cmuClock_HFPER, true); CMU_ClockEnable(i2c_config[dev].cmu, true); /* configure the pins */ gpio_init(i2c_config[dev].scl_pin, GPIO_OD); gpio_init(i2c_config[dev].sda_pin, GPIO_OD); /* ensure slave is in a known state, which it may not be after a reset */ for (int i = 0; i < 9; i++) { gpio_set(i2c_config[dev].scl_pin); gpio_clear(i2c_config[dev].scl_pin); } /* reset and initialize the peripheral */ I2C_Init_TypeDef init = I2C_INIT_DEFAULT; init.enable = false; init.freq = (uint32_t) speed; I2C_Reset(i2c_config[dev].dev); I2C_Init(i2c_config[dev].dev, &init); /* configure pin functions */ #ifdef _SILICON_LABS_32B_SERIES_0 i2c_config[dev].dev->ROUTE = (i2c_config[dev].loc | I2C_ROUTE_SDAPEN | I2C_ROUTE_SCLPEN); #else i2c_config[dev].dev->ROUTEPEN = I2C_ROUTEPEN_SDAPEN | I2C_ROUTEPEN_SCLPEN; i2c_config[dev].dev->ROUTELOC0 = i2c_config[dev].loc; #endif /* enable interrupts */ NVIC_ClearPendingIRQ(i2c_config[dev].irq); NVIC_EnableIRQ(i2c_config[dev].irq); /* enable peripheral */ I2C_Enable(i2c_config[dev].dev, true); return 0; }
void i2c_reset(i2c_t *obj) { I2cHandle = (I2C_TypeDef *)(obj->i2c); I2C_Reset(I2cHandle); }
void SensorsTask(void) { // Array storing the status of each physical sensor. // If a sensor fails to initialize, or fails 3 sensor reads in a row, // it will be disabled here until the next system reboot // 0 = tmp0 // 1 = tmp1 // 2 = tmp3 // 3 = humidity / air temp // 4 = pressure // 5 = accelerometer uint8_t enabledSensors[7] = {3, 3, 3, 3, 3, 3, 3}; uint8_t i; I2C_Status retVal = I2C_OK; INFO("(SENSORS_TASK) I2C Sensor failed to initialize\r\n"); for(i = 0; i < 3; i++) { // If the temperature sensor initialized, set its enabled value to 3 (so it has 3 chances to respond to a read request) // Else, disable the sensor if(InitTempSensor(i) != I2C_OK) { I2C_Reset(SLB_I2C); enabledSensors[i] = 0; WARN("(SENSORS_TASK) I2C Sensor failed to initialize\r\n"); } } if(InitHumiditySensor() != I2C_OK) { I2C_Reset(ALB_I2C); enabledSensors[3] = 0; WARN("(SENSORS_TASK) Humidity sensor failed to initialize\r\n"); } if(InitPressureSensor() != I2C_OK) { I2C_Reset(ALB_I2C); enabledSensors[4] = 0; WARN("(SENSORS_TASK) Pressure sensor failed to initialize\r\n"); } if(InitAccelerometer() != I2C_OK) { I2C_Reset(ALB_I2C); enabledSensors[5] = 0; WARN("(SENSORS_TASK) Accelerometer failed to initialize\r\n"); } // Let other tasks in the system warmup before entering the sensor polling loop osDelay(2000); // TODO: re-initialize the sensors once a day to check for failures and for sensors that have come back online // TODO: report to the base station when a sensor fails while(1) { for(i = 0; i < 3; i++) { if(enabledSensors[i] > 0) { switch(i) { case 0: retVal = ReadTempSensor(0, &sensorData.temp0); break; case 1: retVal = ReadTempSensor(1, &sensorData.temp1); break; case 2: retVal = ReadTempSensor(2, &sensorData.temp2); break; default: retVal = ReadTempSensor(0, &sensorData.temp0); break; } // If the sensor read failed, indicate that the sensor has one less chance to respond correctly before being disabled if(retVal != I2C_OK) { I2C_Reset(SLB_I2C); enabledSensors[i]--; WARN("(SENSORS_TASK) Temp sensor read failed\r\n"); } // The sensor is still alive! Restore it to a full 3 chances to respond else if(enabledSensors[i] != 3) { enabledSensors[i] = 3; DEBUG("(SENSORS_TASK) Temp sensor connection restored\r\n"); } } } if(enabledSensors[3] > 0) { do { if(ReadHumiditySensor(&sensorData.humid) != I2C_OK) { I2C_Reset(ALB_I2C); enabledSensors[3]--; WARN("(SENSORS_TASK) Humidity sensor read failed\r\n"); break; } else if(enabledSensors[3] != 3) { enabledSensors[3] = 3; DEBUG("(SENSORS_TASK) Humidity sensor connection restored\r\n"); } if(ReadAirTempSensor(&sensorData.tempAir) != I2C_OK) { I2C_Reset(ALB_I2C); enabledSensors[3]--; WARN("(SENSORS_TASK) Air temp sensor read failed\r\n"); } else if(enabledSensors[3] != 3) { enabledSensors[3] = 3; DEBUG("(SENSORS_TASK) Air temp sensor connection restored\r\n"); } } while(0); } if(enabledSensors[4] > 0) { if(ReadPressureSensor(&sensorData.alt) != I2C_OK) { I2C_Reset(ALB_I2C); enabledSensors[4]--; WARN("(SENSORS_TASK) Altimeter sensor read failed\r\n"); } } if(enabledSensors[5] > 0) { uint16_t x, y, z; if(ReadAccelerometer(&x, &y, &z) != I2C_OK) { I2C_Reset(ALB_I2C); enabledSensors[5]--; WARN("(SENSORS_TASK) Accelerometer sensor read failed\r\n"); } DEBUG("X: %d, Y: %d, Z: %d", x, y, z); } ReadSoilMoisture(&sensorData.moist0, &sensorData.moist1, &sensorData.moist2); // Send sensor Data to the base station SendSensorData(); osDelay(pollingRate); } }
int ms_detection_polling_getinfo_callback(tNALMsrComInstance *dev, unsigned char *inbuf, int len) { unsigned char infoType; PNALDebugLog("[ms_detection_polling_getinfo_callback]start, len = %d\n", len); if (len <= 0) { //PNALDebugLog("[ms_detection_polling_getinfo_callback]recvlen < 0"); ms_detection_polling_req(dev); return 0; } PNALDebugLog("[ms_detection_polling_getinfo_callback]inbuf:"); PNALDebugLogBuffer(inbuf, len); //A3Rsp(1)[0x02] , Len(1)[n], SubFuncCode(1), ParamNum(1) [n1], ParaID(1)[0x03],ParamLen(1)[n1+1],ID(1), OriginalRsp(n1) //PS: ID format: DrvPL_Category_et | DrvPL_PLItem_et if ((inbuf[4] != 0xA1) || (inbuf[5] <= 1)) { PNALDebugLog("Queue data is empty, do detection."); ms_detection_polling_req(dev); return 0; } infoType = inbuf[6]; PNALDebugError("SWP Reset Cnt= %d", dev->swp_reset_cnt); PNALDebugLog("Info Type= %x", infoType); switch(infoType) { case DrvPL_PLItem_R_ISO43A: ms_A3_RFID_43A_Inventory_Callback(dev, inbuf+7, inbuf[5]-1); break; case DrvPL_PLItem_R_ISO43B: ms_open_nfc_43b_inventory_cbrecv(dev, inbuf+7, inbuf[5]-1); break; case DrvPL_PLItem_R_ISO693: ms_A3_RFID_693_Inventory_Callback(dev, inbuf+7, inbuf[5]-1); break; case DrvPL_PLItem_R_Felica: ms_open_nfc_felica_Inventory_callback(dev, inbuf+7, inbuf[5]-1); break; case DrvPL_PLItem_R_Type1: ms_open_nfc_type1_detection_sens_new_callback(dev, inbuf+7, inbuf[5]-1); break; case DrvPL_PLItem_PI_P2P_212: break; case DrvPL_PLItem_PI_P2P_424: ms_open_nfc_initiator_detection_212_424_callback(dev, inbuf+7, inbuf[5]-1); break; case DrvPL_PLItem_PT_P2P_106: break; case DrvPL_PLItem_PT_P2P_212: break; case DrvPL_PLItem_PT_P2P_424: dev->sendTargetSddEvt = W_FALSE; dev->temp_target_buf_len = 0; ms_nfc_p2p_target_enable_callback(dev, inbuf+7, inbuf[5]-1); break; case DrvPL_PLItem_C_ISO43A: PNALDebugLog("43A Card Mode Started."); Start_IRQ_Detect(dev); break; case DrvPL_PLItem_C_ISO43B: PNALDebugLog("43B Card Mode Started."); Start_IRQ_Detect(dev); break; case DrvPL_PLItem_C_CONN: PNALDebugLog("EVT_CONNECTIVITION"); Start_IRQ_Detect(dev); break; case DrvPL_PLItem_C_TRAN: PNALDebugLog("EVT_TRANSACTION"); Start_IRQ_Detect(dev); break; case DrvPL_PLItem_PIT_P2P_424: PNALDebugLog("P2P IT Mode Started."); if (inbuf[10] == DRVP2P_result_As_Initiator) { PNALDebugLog("P2P IT Mode Started: Initiator"); ms_open_nfc_initiator_detection_212_424_callback(dev, inbuf+7, inbuf[5]-1); } else if (inbuf[10] == DRVP2P_result_As_Target) { PNALDebugLog("P2P IT Mode Started: Target"); dev->sendTargetSddEvt = W_FALSE; dev->temp_target_buf_len = 0; ms_nfc_p2p_target_enable_callback(dev, inbuf+7, inbuf[5]-1); } else { PNALDebugError("P2P IT Mode Report Error"); } break; case DrvPL_PLItem_Reset: PNALDebugLog("Reader need to Reset"); dev->swp_reset_cnt++; I2C_Reset(); ms_card_detection(dev); break; default: break; } PNALDebugLog("[ms_detection_polling_getinfo_callback]end"); return 1; }
void i2c_reset(i2c_t *obj) { /* EMLib function */ I2C_Reset(obj->i2c.i2c); }
/***************************************************************************//** * @brief * Initialize the specified IIC unit * * @details * * @note * * @param[in] unitNumber * Unit number * * @param[in] location * Pin location number ******************************************************************************/ static struct efm32_iic_device_t *rt_hw_iic_unit_init( struct efm32_iic_block *block, rt_uint8_t unitNumber, rt_uint8_t location) { struct efm32_iic_device_t *iic; CMU_Clock_TypeDef iicClock; GPIO_Port_TypeDef port_scl, port_sda; rt_uint32_t pin_scl, pin_sda; I2C_Init_TypeDef init = I2C_INIT_DEFAULT; efm32_irq_hook_init_t hook; rt_uint8_t name[RT_NAME_MAX]; do { /* Allocate device */ iic = rt_malloc(sizeof(struct efm32_iic_device_t)); if (iic == RT_NULL) { iic_debug("IIC err: no MEM for IIC%d driver\n", unitNumber); break; } iic->counter = 0; iic->timer = &block->timer; iic->timeout = false; iic->state |= IIC_STATE_MASTER; iic->address = 0x0000; iic->rx_buffer = RT_NULL; /* Initialization */ if (unitNumber >= I2C_COUNT) { break; } switch (unitNumber) { case 0: iic->iic_device = I2C0; iicClock = (CMU_Clock_TypeDef)cmuClock_I2C0; port_scl = AF_I2C0_SCL_PORT(location); pin_scl = AF_I2C0_SCL_PIN(location); port_sda = AF_I2C0_SDA_PORT(location); pin_sda = AF_I2C0_SDA_PIN(location); break; #if (I2C_COUNT > 1) case 1: iic->iic_device = I2C1; iicClock = (CMU_Clock_TypeDef)cmuClock_I2C1; port_scl = AF_I2C1_SCL_PORT(location); pin_scl = AF_I2C1_SCL_PIN(location); port_sda = AF_I2C1_SDA_PORT(location); pin_sda = AF_I2C1_SDA_PIN(location); break; #endif default: break; } rt_sprintf(name, "iic%d", unitNumber); /* Enabling clock */ CMU_ClockEnable(iicClock, true); /* Reset */ I2C_Reset(iic->iic_device); /* Config GPIO */ GPIO_PinModeSet( port_scl, pin_scl, gpioModeWiredAndPullUpFilter, 1); GPIO_PinModeSet( port_sda, pin_sda, gpioModeWiredAndPullUpFilter, 1); hook.type = efm32_irq_type_iic; hook.unit = unitNumber; hook.cbFunc = rt_hw_iic_slave_isr; hook.userPtr = (void *)&block->device; efm32_irq_hook_register(&hook); /* Enable SDZ and SCL pins and set location */ iic->iic_device->ROUTE = I2C_ROUTE_SDAPEN | I2C_ROUTE_SCLPEN | \ (location << _I2C_ROUTE_LOCATION_SHIFT); /* Initializing IIC */ init.enable = false; I2C_Init(iic->iic_device, &init); /* Abort current TX data and clear TX buffers */ iic->iic_device->CMD = I2C_CMD_ABORT | I2C_CMD_CLEARPC | I2C_CMD_CLEARTX; /* Initialize lock */ iic->lock = &block->lock; if (rt_sem_init(iic->lock, name, 1, RT_IPC_FLAG_FIFO) != RT_EOK) { break; } /* Initialize timer */ rt_timer_init(iic->timer, name, rt_iic_timer, &iic->timeout, IIC_TIMEOUT_PERIOD, RT_TIMER_FLAG_ONE_SHOT); return iic; } while(0); if (iic) { rt_free(iic); } iic_debug("IIC err: Unit %d init failed!\n", unitNumber); return RT_NULL; }
//############################################################################ //Hauptprogramm int main (void) //############################################################################ { unsigned int timer,i,timer2 = 0, timerPolling; DDRB = 0x00; PORTB = 0x00; for(timer = 0; timer < 1000; timer++); // verzögern #if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__)) PlatinenVersion = 21; #else if(PINB & 0x01) { if(PINB & 0x02) PlatinenVersion = 13; else PlatinenVersion = 11; } else { if(PINB & 0x02) PlatinenVersion = 20; else PlatinenVersion = 10; } #endif DDRC = 0x81; // SCL DDRC |=0x40; // HEF4017 Reset PORTC = 0xff; // Pullup SDA DDRB = 0x1B; // LEDs und Druckoffset PORTB = 0x01; // LED_Rot DDRD = 0x3E; // Speaker & TXD & J3 J4 J5 PORTD = 0x47; // LED HEF4017R_ON; MCUSR &=~(1<<WDRF); WDTCSR |= (1<<WDCE)|(1<<WDE); WDTCSR = 0; beeptime = 2500; StickGier = 0; PPM_in[K_GAS] = 0; StickRoll = 0; StickNick = 0; if(PlatinenVersion >= 20) GIER_GRAD_FAKTOR = 1220; else GIER_GRAD_FAKTOR = 1291; // unterschiedlich für ME und ENC ROT_OFF; Timer_Init(); TIMER2_Init(); UART_Init(); rc_sum_init(); ADC_Init(); I2C_Init(1); SPI_MasterInit(); Capacity_Init(); LIBFC_Init(); GRN_ON; sei(); ParamSet_Init(); // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // + Check connected BL-Ctrls // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Check connected BL-Ctrls BLFlags |= BLFLAG_READ_VERSION; motor_read = 0; // read the first I2C-Data SendMotorData(); timer = SetDelay(500); while(!(BLFlags & BLFLAG_TX_COMPLETE) && !CheckDelay(timer)); //wait for complete transfer printf("\n\rFound BL-Ctrl: "); timer = SetDelay(4000); for(i=0; i < MAX_MOTORS; i++) { SendMotorData(); while(!(BLFlags & BLFLAG_TX_COMPLETE) && !CheckDelay(timer)); //wait for complete transfer if(Mixer.Motor[i][0] > 0) // wait max 4 sec for the BL-Ctrls to wake up { while(!CheckDelay(timer) && !(Motor[i].State & MOTOR_STATE_PRESENT_MASK) ) { SendMotorData(); while(!(BLFlags & BLFLAG_TX_COMPLETE) && !CheckDelay(timer)); //wait for complete transfer } } if(Motor[i].State & MOTOR_STATE_PRESENT_MASK) { printf("%d",i+1); FoundMotors++; // if(Motor[i].Version & MOTOR_STATE_NEW_PROTOCOL_MASK) printf("(new) "); } } for(i=0; i < MAX_MOTORS; i++) { if(!(Motor[i].State & MOTOR_STATE_PRESENT_MASK) && Mixer.Motor[i][0] > 0) { printf("\n\r\n\r!! MISSING BL-CTRL: %d !!",i+1); ServoActive = 2; // just in case the FC would be used as camera-stabilizer } Motor[i].State &= ~MOTOR_STATE_ERROR_MASK; // clear error counter } printf("\n\r==================================="); if(RequiredMotors < FoundMotors) VersionInfo.HardwareError[1] |= FC_ERROR1_MIXER; //if(EE_Parameter.GlobalConfig & CFG_HOEHENREGELUNG) { printf("\n\rCalibrating pressure sensor.."); timer = SetDelay(1000); SucheLuftruckOffset(); while (!CheckDelay(timer)); printf("OK\n\r"); } SetNeutral(0); ROT_OFF; beeptime = 2000; ExternControl.Digital[0] = 0x55; FlugMinuten = (unsigned int)GetParamByte(PID_FLIGHT_MINUTES) * 256 + (unsigned int)GetParamByte(PID_FLIGHT_MINUTES + 1); FlugMinutenGesamt = (unsigned int)GetParamByte(PID_FLIGHT_MINUTES_TOTAL) * 256 + (unsigned int)GetParamByte(PID_FLIGHT_MINUTES_TOTAL + 1); if((FlugMinutenGesamt == 0xFFFF) || (FlugMinuten == 0xFFFF)) { FlugMinuten = 0; FlugMinutenGesamt = 0; } printf("\n\rFlight-time %u min Total:%u min", FlugMinuten, FlugMinutenGesamt); printf("\n\rControl: "); if (EE_Parameter.GlobalConfig & CFG_HEADING_HOLD) printf("HeadingHold"); else printf("Normal (ACC-Mode)"); LcdClear(); I2CTimeout = 5000; WinkelOut.Orientation = 1; LipoDetection(1); LIBFC_ReceiverInit(EE_Parameter.Receiver); printf("\n\r===================================\n\r"); //SpektrumBinding(); timer = SetDelay(2000); timerPolling = SetDelay(250); Debug(ANSI_CLEAR "FC-Start!\n\rFlugzeit: %d min", FlugMinutenGesamt); // Note: this won't waste flash memory, if #DEBUG is not active DebugOut.Status[0] = 0x01 | 0x02; JetiBeep = 0; while (1) { if (JetiUpdateModeActive) while (1); if(CheckDelay(timerPolling)) { timerPolling = SetDelay(100); LIBFC_Polling(); } if(UpdateMotor && AdReady) // ReglerIntervall { UpdateMotor=0; if(WinkelOut.CalcState) CalMk3Mag(); else MotorRegler(); SendMotorData(); ROT_OFF; if(SenderOkay) { SenderOkay--; VersionInfo.HardwareError[1] &= ~FC_ERROR1_PPM; } else { TIMSK1 |= _BV(ICIE1); // enable PPM-Input PPM_in[0] = 0; // set RSSI to zero on data timeout VersionInfo.HardwareError[1] |= FC_ERROR1_PPM; } //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ //if(HoehenReglerAktiv && NaviDataOkay && SenderOkay < 160 && SenderOkay > 10 && FromNaviCtrl_Value.SerialDataOkay > 220) SenderOkay = 160; //if(HoehenReglerAktiv && NaviDataOkay && SenderOkay < 101 && SenderOkay > 10 && FromNaviCtrl_Value.SerialDataOkay > 1) SenderOkay = 101; //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ if(!--I2CTimeout || MissingMotor) { if(!I2CTimeout) { I2C_Reset(); I2CTimeout = 5; DebugOut.Analog[28]++; // I2C-Error VersionInfo.HardwareError[1] |= FC_ERROR1_I2C; DebugOut.Status[1] |= 0x02; // BL-Error-Status } if((BeepMuster == 0xffff) && MotorenEin) { beeptime = 10000; BeepMuster = 0x0080; } } else { ROT_OFF; if(!beeptime) { VersionInfo.HardwareError[1] &= ~FC_ERROR1_I2C; } } if(!UpdateMotor) { if(CalculateServoSignals) CalculateServo(); DatenUebertragung(); BearbeiteRxDaten(); if(CheckDelay(timer)) { static unsigned char second; timer += 20; // 20 ms interval if(MissingMotor) { VersionInfo.HardwareError[1] |= FC_ERROR1_BL_MISSING; DebugOut.Status[1] |= 0x02; // BL-Error-Status } else { VersionInfo.HardwareError[1] &= ~FC_ERROR1_BL_MISSING; if(I2CTimeout > 6) DebugOut.Status[1] &= ~0x02; // BL-Error-Status } if(I2CTimeout > 6) VersionInfo.HardwareError[1] &= ~FC_ERROR1_I2C; if(PcZugriff) PcZugriff--; else { ExternControl.Config = 0; ExternStickNick = 0; ExternStickRoll = 0; ExternStickGier = 0; if(BeepMuster == 0xffff && SenderOkay == 0) { beeptime = 15000; BeepMuster = 0x0c00; } } if(NaviDataOkay > 200) { NaviDataOkay--; VersionInfo.HardwareError[1] &= ~FC_ERROR1_SPI_RX; } else { if(NC_Version.Compatible) { VersionInfo.HardwareError[1] |= FC_ERROR1_SPI_RX; if(BeepMuster == 0xffff && MotorenEin) { beeptime = 15000; BeepMuster = 0xA800; } } GPS_Nick = 0; GPS_Roll = 0; //if(!beeptime) FromNaviCtrl.CompassValue = -1; NaviDataOkay = 0; } if(UBat < BattLowVoltageWarning) { FC_StatusFlags |= FC_STATUS_LOWBAT; if(BeepMuster == 0xffff) { beeptime = 6000; BeepMuster = 0x0300; } } else if(!beeptime) FC_StatusFlags &= ~FC_STATUS_LOWBAT; SPI_StartTransmitPacket(); SendSPI = 4; if(!MotorenEin) timer2 = 1450; // 0,5 Minuten aufrunden else if(++second == 49) { second = 0; FlugSekunden++; } if(++timer2 == 2930) // eine Minute { timer2 = 0; FlugMinuten++; FlugMinutenGesamt++; SetParamByte(PID_FLIGHT_MINUTES,FlugMinuten / 256); SetParamByte(PID_FLIGHT_MINUTES+1,FlugMinuten % 256); SetParamByte(PID_FLIGHT_MINUTES_TOTAL,FlugMinutenGesamt / 256); SetParamByte(PID_FLIGHT_MINUTES_TOTAL+1,FlugMinutenGesamt % 256); timer = SetDelay(20); // falls "timer += 20;" mal nicht geht } } LED_Update(); Capacity_Update(); } //else DebugOut.Analog[26]++; } if(!SendSPI) { SPI_TransmitByte(); } } return (1); }