| /beta/Code Redesign killagreg/eeprom.c |
|---|
| 76,7 → 76,6 |
| paramset_t ParamSet; |
| MixerTable_t Mixer; |
| uint8_t RequiredMotors = 0; |
| BLConfig_t BLConfig[MAX_MOTORS]; |
| uint8_t RAM_Checksum(uint8_t* pBuffer, uint16_t len) |
| 594,66 → 593,8 |
| Mixer.crc = RAM_Checksum((uint8_t*)(&Mixer), sizeof(Mixer) - 1); |
| } |
| /***************************************************/ |
| /* Read BL-Config from EEPROM */ |
| /***************************************************/ |
| uint8_t BLConfig_ReadFromEEProm(uint8_t index) |
| { |
| uint8_t crc; |
| uint16_t eeadr = EEPROM_ADR_BLCONFIG + (uint16_t)index * sizeof(BLConfig_t); |
| // calculate checksum in eeprom |
| crc = EEProm_Checksum(eeadr, sizeof(BLConfig_t) - 1); |
| // check crc |
| if( crc != eeprom_read_byte((uint8_t*)(eeadr + sizeof(BLConfig_t) - 1)) ) return 0; |
| // check revision |
| if(eeprom_read_byte((uint8_t*)(eeadr)) != EEBLCONFIG_REVISON) return 0; |
| // read mixer BLConfig |
| eeprom_read_block((void *)&(BLConfig[index]), (void*)(eeadr), sizeof(BLConfig_t)); |
| return 1; |
| } |
| /***************************************************/ |
| /* Write BL-Config to EEPROM */ |
| /***************************************************/ |
| uint8_t BLConfig_WriteToEEProm(uint8_t index) |
| { |
| uint16_t eeadr = EEPROM_ADR_BLCONFIG + (uint16_t)index * sizeof(BLConfig_t); |
| if(index >= MAX_MOTORS) return 0; |
| if(BLConfig[index].Revision == EEBLCONFIG_REVISON) |
| { |
| // update crc |
| BLConfig[index].crc = RAM_Checksum((uint8_t*)(&(BLConfig[index])), sizeof(BLConfig_t) - 1); |
| // write to eeprom |
| eeprom_write_block((void *) &(BLConfig[index]), (void*)(eeadr), sizeof(BLConfig_t)); |
| return 1; |
| } |
| else return 0; |
| } |
| /***************************************************/ |
| /* Default BLConfig */ |
| /***************************************************/ |
| void BLConfig_SetDefault(uint8_t index) |
| { |
| if(index < MAX_MOTORS) |
| { |
| BLConfig[index].Revision = EEBLCONFIG_REVISON; // set revision |
| BLConfig[index].SetMask = MASK_SET_PWM_SCALING|MASK_SET_CURRENT_LIMIT|MASK_SET_TEMP_LIMIT|MASK_SET_CURRENT_SCALING|MASK_SET_BITCONFIG; |
| BLConfig[index].PwmScaling = 255; // MaxPWM |
| BLConfig[index].CurrentLimit = 30; // Current Limit in A |
| BLConfig[index].TempLimit = 99; // Temperature Limit in °C |
| BLConfig[index].CurrentScaling = 64; // Current Scaling |
| BLConfig[index].BitConfig = 0; // BitConfig |
| BLConfig[index].crc = RAM_Checksum((uint8_t*)&(BLConfig[index]), sizeof(BLConfig_t) - 1); // update checksum |
| } |
| } |
| /***************************************************/ |
| /* Get active parameter set */ |
| /***************************************************/ |
| uint8_t GetActiveParamSet(void) |
| 745,18 → 686,6 |
| ParamSet_ReadFromEEProm(i); |
| printf("\n\rUsing Parameter Set %d", i); |
| // load all BLConfig's |
| for(i=0; i<MAX_MOTORS; i++) |
| { |
| if(ee_default || !BLConfig_ReadFromEEProm(i)) // could not read BLConfig from eeprom |
| { |
| printf("\n\rGenerating default BL-Config for motor %d", i+1); |
| BLConfig_SetDefault(i); |
| BLConfig_WriteToEEProm(i); |
| } |
| } |
| // load mixer table |
| if(ee_default || !MixerTable_ReadFromEEProm() ) |
| { |
| /beta/Code Redesign killagreg/eeprom.h |
|---|
| 19,7 → 19,6 |
| #define EEPROM_ADR_CHANNELS 80 // 80 - 93, 12 bytes + 1 byte crc |
| #define EEPROM_ADR_PARAMSET 100 // 100 - 650, 5 * 110 bytes |
| #define EEPROM_ADR_MIXERTABLE 1000 // 1000 - 1078, 78 bytes |
| #define EEPROM_ADR_BLCONFIG 1200 // 1200 - 1296, 12 * 8 bytes |
| #define MIX_GAS 0 |
| 38,39 → 37,6 |
| extern MixerTable_t Mixer; |
| extern uint8_t RequiredMotors; |
| #define MASK_SET_PWM_SCALING 0x01 |
| #define MASK_SET_CURRENT_LIMIT 0x02 |
| #define MASK_SET_TEMP_LIMIT 0x04 |
| #define MASK_SET_CURRENT_SCALING 0x08 |
| #define MASK_SET_BITCONFIG 0x10 |
| #define MASK_RESET_CAPCOUNTER 0x20 |
| #define MASK_SET_DEFAULT_PARAMS 0x40 |
| #define MASK_SET_SAVE_EEPROM 0x80 |
| #define BITCONF_REVERSE_ROTATION 0x01 |
| #define BITCONF_RES1 0x02 |
| #define BITCONF_RES2 0x04 |
| #define BITCONF_RES3 0x08 |
| #define BITCONF_RES4 0x10 |
| #define BITCONF_RES5 0x20 |
| #define BITCONF_RES6 0x40 |
| #define BITCONF_RES7 0x80 |
| typedef struct |
| { |
| uint8_t Revision; // must be BL_REVISION |
| uint8_t SetMask; // settings mask |
| uint8_t PwmScaling; // maximum value of control pwm, acts like a thrust limit |
| uint8_t CurrentLimit; // current limit in A |
| uint8_t TempLimit; // in °C |
| uint8_t CurrentScaling; // scaling factor for current measurement |
| uint8_t BitConfig; // see defines above |
| uint8_t crc; // checksum |
| } __attribute__((packed)) BLConfig_t; |
| extern BLConfig_t BLConfig[MAX_MOTORS]; |
| // bit mask for ParamSet.Config0 |
| #define CFG0_AIRPRESS_SENSOR 0x01 |
| #define CFG0_HEIGHT_SWITCH 0x02 |
| 126,7 → 92,7 |
| #define EEPARAM_REVISION 82 // is count up, if paramater stucture has changed (compatibility) |
| #define EEMIXER_REVISION 1 // is count up, if mixer stucture has changed (compatibility) |
| #define EEBLCONFIG_REVISON '#' |
| #define EEBLCONFIG_REVISON 35 // is count up, if blconfig stucture has changed (compatibility to BLs!) |
| // values above 247 representing poti1 to poti8 |
| // poti1 = 255 |
| /beta/Code Redesign killagreg/fc.c |
|---|
| 235,8 → 235,6 |
| ExpandBaro = 0; |
| I2C_SendBLConfig(); |
| // sample values with bias set to zero |
| Delay_ms_Mess(100); |
| 696,7 → 694,6 |
| Mean(); |
| GRN_ON; |
| DebugOut.Analog[16] = Calibration_Done; |
| // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| // RC-signal is bad |
| /beta/Code Redesign killagreg/libfc1284.a |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| /beta/Code Redesign killagreg/libfc644.a |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| /beta/Code Redesign killagreg/spi.c |
|---|
| 467,11 → 467,9 |
| memcpy(ptr, (uint8_t *) SPI_RxBuffer, sizeof(FromNaviCtrl)); |
| sei(); |
| SPI_RxDataValid = 1; |
| //DebugOut.Analog[18]++; |
| } |
| else |
| { // checksum does not match |
| //DebugOut.Analog[17]++; |
| SPI_RxDataValid = 0; // reset valid flag |
| } |
| SPI_RXState = SPI_SYNC1; // reset state sync |
| /beta/Code Redesign killagreg/twimaster.c |
|---|
| 58,11 → 58,12 |
| #include "fc.h" |
| #include "analog.h" |
| volatile uint8_t twi_state = TWI_STATE_MOTOR_TX; |
| volatile uint8_t twi_state = TWI_STATE_MOTOR_TX; |
| volatile uint8_t dac_channel = 0; |
| volatile uint8_t motor_write = 0; |
| volatile uint8_t motor_read = 0; |
| volatile uint16_t I2CTimeout = 100; |
| uint8_t MissingMotor = 0; |
| 70,16 → 71,20 |
| volatile uint8_t BLFlags = 0; |
| MotorData_t Motor[MAX_MOTORS]; |
| BLConfig_t BLConfig[MAX_MOTORS]; |
| #define I2C_WriteByte(byte) {TWDR = byte; TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWIE);} |
| #define I2C_ReceiveByte() {TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWIE) | (1<<TWEA);} |
| #define I2C_ReceiveLastByte() {TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWIE);} |
| #define BL_CONF_SYNC_BYTE '#' |
| #define SCL_CLOCK 200000L |
| #define I2C_TIMEOUT 30000 |
| #define TWI_BASE_ADDRESS 0x52 |
| /**************************************************/ |
| /* Initialize I2C (TWI) */ |
| /**************************************************/ |
| void I2C_Init(void) |
| { |
| uint8_t i; |
| 117,90 → 122,10 |
| SREG = sreg; |
| } |
| /****************************************/ |
| /* Start I2C */ |
| /****************************************/ |
| /* |
| void I2C_Start(uint8_t start_state) |
| { |
| twi_state = start_state; |
| // TWI Control Register |
| // clear TWI interrupt flag (TWINT=1) |
| // disable TWI Acknowledge Bit (TWEA = 0) |
| // enable TWI START Condition Bit (TWSTA = 1), MASTER |
| // disable TWI STOP Condition Bit (TWSTO = 0) |
| // disable TWI Write Collision Flag (TWWC = 0) |
| // enable i2c (TWEN = 1) |
| // enable TWI Interrupt (TWIE = 1) |
| TWCR = (1<<TWINT) | (1<<TWSTA) | (1<<TWEN) | (1<<TWIE); |
| } |
| */ |
| /****************************************/ |
| /* Stop I2C */ |
| /****************************************/ |
| /*void I2C_Stop(uint8_t start_state) |
| { |
| twi_state = start_state; |
| // TWI Control Register |
| // clear TWI interrupt flag (TWINT=1) |
| // disable TWI Acknowledge Bit (TWEA = 0) |
| // diable TWI START Condition Bit (TWSTA = 1), no MASTER |
| // enable TWI STOP Condition Bit (TWSTO = 1) |
| // disable TWI Write Collision Flag (TWWC = 0) |
| // enable i2c (TWEN = 1) |
| // disable TWI Interrupt (TWIE = 0) |
| TWCR = (1<<TWINT) | (1<<TWSTO) | (1<<TWEN); |
| }*/ |
| /****************************************/ |
| /* Write to I2C */ |
| /****************************************/ |
| #define I2C_WriteByte(byte) {TWDR = byte; TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWIE);} |
| /* |
| void I2C_WriteByte(int8_t byte) |
| { |
| // move byte to send into TWI Data Register |
| TWDR = byte; |
| // clear interrupt flag (TWINT = 1) |
| // enable i2c bus (TWEN = 1) |
| // enable interrupt (TWIE = 1) |
| TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWIE); |
| } |
| */ |
| /****************************************/ |
| /* Receive byte and send ACK */ |
| /****************************************/ |
| #define I2C_ReceiveByte() {TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWIE) | (1<<TWEA);} |
| /* |
| void I2C_ReceiveByte(void) |
| { |
| TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWIE) | (1<<TWEA); |
| } |
| */ |
| /****************************************/ |
| /* I2C receive last byte and send no ACK*/ |
| /****************************************/ |
| #define I2C_ReceiveLastByte() {TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWIE);} |
| /* |
| void I2C_ReceiveLastByte(void) |
| { |
| TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWIE); |
| } |
| */ |
| /****************************************/ |
| /* Reset I2C */ |
| /****************************************/ |
| void I2C_Reset(void) |
| { |
| // stop i2c bus |
| I2C_Stop(TWI_STATE_MOTOR_TX); |
| twi_state = 0; |
| motor_write = TWDR; |
| motor_write = 0; |
| motor_read = 0; |
| TWCR = (1<<TWINT); // reset to original state incl. interrupt flag reset |
| 210,7 → 135,8 |
| TWSR = 0; |
| TWBR = 0; |
| I2C_Init(); |
| I2C_Start(TWI_STATE_MOTOR_TX); |
| I2C_WriteByte(0); |
| BLFlags |= BLFLAG_READ_VERSION; |
| } |
| /****************************************/ |
| 218,13 → 144,19 |
| /****************************************/ |
| ISR (TWI_vect) |
| { |
| static uint8_t missing_motor = 0, byte_counter = 0, read_more = 0, motor_read_temperature = 0; |
| static uint8_t *pTxBuff; |
| static uint8_t missing_motor = 0, motor_read_temperature = 0; |
| static uint8_t *pBuff = 0; |
| static uint8_t BuffLen = 0; |
| switch (twi_state++) // First i2c_start from SendMotorData() |
| #define BL_READ_STATUS 0 |
| #define BL_READ_CONFIG 16 |
| static uint8_t BLReadMode = BL_READ_STATUS; |
| switch (twi_state++) |
| { |
| // Master Transmit |
| case 0: // TWI_STATE_MOTOR_TX |
| // skip motor if not used in mixer |
| while((Mixer.Motor[motor_write][MIX_GAS] <= 0) && (motor_write < MAX_MOTORS)) motor_write++; |
| if(motor_write >= MAX_MOTORS) // writing finished, read now |
| 231,9 → 163,9 |
| { |
| motor_write = 0; // reset motor write counter for next cycle |
| twi_state = TWI_STATE_MOTOR_RX; |
| I2C_WriteByte(0x53 + (motor_read * 2) ); // select slave address in rx mode |
| I2C_WriteByte(TWI_BASE_ADDRESS + TW_READ + (motor_read<<1) ); // select slave address in rx mode |
| } |
| else I2C_WriteByte(0x52 + (motor_write * 2) ); // select slave address in tx mode |
| else I2C_WriteByte(TWI_BASE_ADDRESS + TW_WRITE + (motor_write<<1) ); // select slave address in tx mode |
| break; |
| case 1: // Send Data to Slave |
| I2C_WriteByte(Motor[motor_write].SetPoint); // transmit setpoint |
| 243,17 → 175,20 |
| twi_state = 4; //jump over sending more data |
| } |
| // the new version has been detected |
| else if(!( (Motor[motor_write].SetPointLowerBits && (RequiredMotors < 7)) || (BLFlags & BLFLAG_SEND_CONFIG)) ) |
| else if(!( (Motor[motor_write].SetPointLowerBits && (RequiredMotors < 7)) || (BLFlags & (BLFLAG_SET_CONFIG|BLFLAG_GET_CONFIG)) ) ) |
| { // or LowerBits are zero and no BlConfig should be sent (saves round trip time) |
| twi_state = 4; //jump over sending more data |
| } |
| break; |
| case 2: // lower bits of setpoint (higher resolution) |
| I2C_WriteByte((Motor[motor_write].SetPointLowerBits << 1) & 0x07); // send the lower bits of setpoint |
| if (BLFlags & BLFLAG_GET_CONFIG) BLReadMode = BL_READ_CONFIG; |
| else BLReadMode = BL_READ_STATUS; |
| I2C_WriteByte((BLReadMode<<3)|(Motor[motor_write].SetPointLowerBits & 0x07)); // send read mode and the lower bits of setpoint |
| // transmit config only on demand and the motors are not running and only for one motor per round trip |
| if( (BLFlags & BLFLAG_SEND_CONFIG) && (motor_write == motor_read)) |
| if( (BLFlags & BLFLAG_SET_CONFIG) && (motor_write == motor_read)) |
| { // prepare sending of configuration |
| byte_counter = 0; // reset send byte counter |
| pBuff = (uint8_t*)(&BLConfig[motor_write]); // select config for motor |
| BuffLen = sizeof(BLConfig_t); |
| } |
| else |
| { // jump to state for end of transmission for that motor |
| 261,23 → 196,9 |
| } |
| break; |
| case 3: // send configuration |
| if(!byte_counter) // first byte? |
| { |
| pTxBuff = (uint8_t*)&BLConfig[motor_write]; // select configuration for motor |
| I2C_WriteByte(pTxBuff[byte_counter]); |
| twi_state = 3; |
| } |
| else if(byte_counter >= sizeof(BLConfig_t)) |
| { |
| I2C_WriteByte(0); |
| // continue in state 4 |
| } |
| else // transmit configuration to BLs |
| { |
| I2C_WriteByte(pTxBuff[byte_counter]); // submit next byte |
| twi_state = 3; // stay in this state |
| } |
| byte_counter++; // next byte |
| I2C_WriteByte(*pBuff); |
| pBuff++; |
| if(--BuffLen > 0) twi_state = 3; // if there are some bytes left |
| break; |
| case 4: // repeat case 0-4 for all motors |
| if(TWSR == TW_MT_DATA_NACK) // Data transmitted, NACK received |
| 292,13 → 213,14 |
| break; |
| // Master Receive Data |
| case 5: // TWI_STATE_MOTOR_RX |
| if(TWSR != TW_MR_SLA_ACK) // SLA+R transmitted, if not ACK received |
| if(TWSR != TW_MR_SLA_ACK) // SLA+R transmitted but no ACK received |
| { // no response from the addressed slave received |
| Motor[motor_read].State &= ~MOTOR_STATE_PRESENT_MASK; // clear present bit |
| if(++motor_read >= MAX_MOTORS) |
| { // all motors read |
| motor_read = 0; // restart from beginning |
| BLFlags &= ~BLFLAG_SEND_CONFIG; |
| BLFlags &= ~(BLFLAG_GET_CONFIG|BLFLAG_SET_CONFIG); |
| BLReadMode = BL_READ_STATUS; |
| if(++motor_read_temperature >= MAX_MOTORS) |
| { |
| motor_read_temperature = 0; |
| 311,33 → 233,66 |
| else |
| { // motor successfully addressed |
| Motor[motor_read].State |= MOTOR_STATE_PRESENT_MASK; // set present bit |
| // read cylclic more data |
| if((motor_read == motor_read_temperature) || (BLFlags & BLFLAG_READ_VERSION)) |
| if(Motor[motor_read].Version & MOTOR_STATE_NEW_PROTOCOL_MASK) |
| { |
| read_more = 1; |
| I2C_ReceiveByte(); // read next byte |
| // new BL found |
| switch(BLReadMode) |
| { |
| case BL_READ_CONFIG: |
| pBuff = (uint8_t*)&BLConfig[motor_read]; |
| BuffLen = sizeof(BLConfig_t); |
| break; |
| case BL_READ_STATUS: |
| pBuff = (uint8_t*)&(Motor[motor_read].Current); |
| if(motor_read == motor_read_temperature) BuffLen = 3; // read Current, MaxPwm & Temp |
| else BuffLen = 1;// read Current only |
| break; |
| } |
| } |
| else // old BL version |
| { |
| pBuff = (uint8_t*)&(Motor[motor_read].Current); |
| if(BLFlags & BLFLAG_READ_VERSION) BuffLen = 2; // Current & MaxPwm |
| else BuffLen = 1; // read Current only |
| } |
| if(BuffLen == 1) |
| { |
| I2C_ReceiveLastByte(); // read last byte |
| } |
| else |
| { |
| read_more = 0; |
| I2C_ReceiveLastByte(); //read last byte |
| I2C_ReceiveByte(); // read next byte |
| } |
| } |
| MissingMotor = missing_motor; |
| missing_motor = 0; |
| break; |
| case 6: // 1st byte recieved |
| Motor[motor_read].Current = TWDR; // get Current |
| if(read_more) |
| case 6: // receive bytes |
| *pBuff = TWDR; |
| pBuff++; |
| BuffLen--; |
| if(BuffLen>1) |
| { |
| I2C_ReceiveByte(); // read 2nd byte |
| I2C_ReceiveByte(); // read next byte |
| } |
| else |
| else if (BuffLen == 1) |
| { |
| I2C_ReceiveLastByte(); // read last byte |
| } |
| else // nothing left |
| { |
| if(BLFlags & BLFLAG_READ_VERSION) |
| { |
| if(!(FCFlags & FCFLAG_MOTOR_RUN) && (Motor[motor_read].MaxPWM == 250) ) Motor[motor_read].Version |= MOTOR_STATE_NEW_PROTOCOL_MASK; |
| else Motor[motor_read].Version = 0; |
| } |
| if(++motor_read >= MAX_MOTORS) |
| { |
| motor_read = 0; // restart from beginning |
| BLFlags &= ~BLFLAG_SEND_CONFIG; |
| BLFlags &= ~(BLFLAG_GET_CONFIG|BLFLAG_SET_CONFIG); |
| BLReadMode = BL_READ_STATUS; |
| if(++motor_read_temperature >= MAX_MOTORS) |
| { |
| motor_read_temperature = 0; |
| 346,40 → 301,11 |
| } |
| I2C_Stop(TWI_STATE_MOTOR_TX); |
| BLFlags |= BLFLAG_TX_COMPLETE; |
| return; |
| } |
| twi_state = 6; // if there are some bytes left |
| break; |
| case 7: // 2nd byte recieved |
| Motor[motor_read].MaxPWM = TWDR; // get MaxPWM |
| if(BLFlags & BLFLAG_READ_VERSION) |
| { |
| if(TWDR == 250) |
| { // a new BL found |
| if(!(FCFlags & FCFLAG_MOTOR_RUN)) Motor[motor_read].Version |= MOTOR_STATE_NEW_PROTOCOL_MASK; |
| } |
| else |
| { // its not a new BL |
| Motor[motor_read].Version = 0; |
| } |
| } |
| I2C_ReceiveLastByte(); // nack |
| break; |
| case 8: // 3rd byte received |
| Motor[motor_read].Temperature = TWDR; // get Temperature |
| if(++motor_read >= MAX_MOTORS) |
| { |
| motor_read = 0; // restart reading of first motor |
| BLFlags &= ~BLFLAG_SEND_CONFIG; |
| if(++motor_read_temperature >= MAX_MOTORS) |
| { |
| motor_read_temperature = 0; |
| BLFlags &= ~BLFLAG_READ_VERSION; |
| } |
| } |
| I2C_Stop(TWI_STATE_MOTOR_TX); |
| BLFlags |= BLFLAG_TX_COMPLETE; |
| break; |
| // writing Gyro-Offsets |
| case 18: |
| I2C_WriteByte(0x98); // Address the DAC |
| 431,16 → 357,16 |
| motor_read = 0; |
| break; |
| } |
| } |
| void I2C_SendBLConfig(void) |
| uint8_t I2C_SetBLConfig(void) |
| { |
| uint8_t i; |
| if(FCFlags & FCFLAG_MOTOR_RUN) return; // not when motors are running! |
| if(FCFlags & FCFLAG_MOTOR_RUN) return(0); // not when motors are running! |
| while(!(BLFlags & BLFLAG_TX_COMPLETE)); //wait for complete transfer |
| BLFlags |= BLFLAG_SEND_CONFIG; // enable sending of BL config |
| for(i = 0; i < MAX_MOTORS; i++) |
| { |
| Motor[i].SetPoint = 0; |
| 447,11 → 373,34 |
| Motor[i].SetPointLowerBits = 0; |
| } |
| motor_read = 0; |
| BLFlags |= BLFLAG_SET_CONFIG; // enable sending of BL config |
| // needs at least MAX_MOTORS loops of 2 ms (12*2ms = 24ms) |
| do |
| { |
| I2C_Start(TWI_STATE_MOTOR_TX); // start an i2c transmission |
| while(!(BLFlags & BLFLAG_TX_COMPLETE)); //wait for complete transfer |
| }while(BLFlags & BLFLAG_SEND_CONFIG); // repeat until the BL config has been send to all motors |
| }while(BLFlags & BLFLAG_SET_CONFIG); // repeat until the BL config has been send to all motors |
| return(1); |
| } |
| uint8_t I2C_GetBLConfig(void) |
| { |
| uint8_t i; |
| if(FCFlags & FCFLAG_MOTOR_RUN) return(0); // not when motors are running! |
| while(!(BLFlags & BLFLAG_TX_COMPLETE)); //wait for complete transfer |
| for(i = 0; i < MAX_MOTORS; i++) |
| { |
| Motor[i].SetPoint = 0; |
| Motor[i].SetPointLowerBits = 0; |
| } |
| motor_read = 0; |
| BLFlags |= BLFLAG_GET_CONFIG; // enable request of BL config |
| // needs at least MAX_MOTORS loops of 2 ms (12*2ms = 24ms) |
| do |
| { |
| I2C_Start(TWI_STATE_MOTOR_TX); // start an i2c transmission |
| while(!(BLFlags & BLFLAG_TX_COMPLETE)); //wait for complete transfer |
| }while(BLFlags & BLFLAG_GET_CONFIG); // repeat until the BL config has been received from all motors |
| return(1); |
| } |
| /beta/Code Redesign killagreg/twimaster.h |
|---|
| 21,9 → 21,10 |
| #define MOTOR_STATE_NEW_PROTOCOL_MASK 0x01 |
| #define BLFLAG_READ_VERSION 0x01 |
| #define BLFLAG_SEND_CONFIG 0x02 |
| #define BLFLAG_TX_COMPLETE 0x04 |
| #define BLFLAG_TX_COMPLETE 0x01 |
| #define BLFLAG_READ_VERSION 0x02 |
| #define BLFLAG_SET_CONFIG 0x04 |
| #define BLFLAG_GET_CONFIG 0x08 |
| extern volatile uint8_t BLFlags; |
| 33,6 → 34,7 |
| uint8_t SetPoint; // written by attitude controller |
| uint8_t SetPointLowerBits; // for higher Resolution of new BLs |
| uint8_t State; // 7 bit for I2C error counter, highest bit indicates if motor is present |
| // the following bytes must be exactly in that order! |
| uint8_t Current; // in 0.1 A steps, read back from BL |
| uint8_t MaxPWM; // read back from BL is less than 255 if BL is in current limit |
| int8_t Temperature; // old BL-Ctrl will return a 255 here, the new version the temp. in °C |
| 40,6 → 42,40 |
| extern MotorData_t Motor[MAX_MOTORS]; |
| #define BLCONFIG_REVISION 1 |
| #define MASK_SET_PWM_SCALING 0x01 |
| #define MASK_SET_CURRENT_LIMIT 0x02 |
| #define MASK_SET_TEMP_LIMIT 0x04 |
| #define MASK_SET_CURRENT_SCALING 0x08 |
| #define MASK_SET_BITCONFIG 0x10 |
| #define MASK_RESET_CAPCOUNTER 0x20 |
| #define MASK_SET_DEFAULT_PARAMS 0x40 |
| #define MASK_SET_SAVE_EEPROM 0x80 |
| #define BITCONF_REVERSE_ROTATION 0x01 |
| #define BITCONF_RES1 0x02 |
| #define BITCONF_RES2 0x04 |
| #define BITCONF_RES3 0x08 |
| #define BITCONF_RES4 0x10 |
| #define BITCONF_RES5 0x20 |
| #define BITCONF_RES6 0x40 |
| #define BITCONF_RES7 0x80 |
| typedef struct |
| { |
| uint8_t Revision; // must be BL_REVISION |
| uint8_t SetMask; // settings mask |
| uint8_t PwmScaling; // maximum value of control pwm, acts like a thrust limit |
| uint8_t CurrentLimit; // current limit in A |
| uint8_t TempLimit; // in °C |
| uint8_t CurrentScaling; // scaling factor for current measurement |
| uint8_t BitConfig; // see defines above |
| uint8_t crc; // checksum |
| } __attribute__((packed)) BLConfig_t; |
| extern BLConfig_t BLConfig[MAX_MOTORS]; |
| extern volatile uint16_t I2CTimeout; |
| void I2C_Init (void); // Initialize I2C |
| 46,6 → 82,7 |
| #define I2C_Start(start_state) {twi_state = start_state; BLFlags &= ~BLFLAG_TX_COMPLETE; TWCR = (1<<TWSTA) | (1<<TWEN) | (1<<TWINT) | (1<<TWIE);} |
| #define I2C_Stop(start_state) {twi_state = start_state; TWCR = (1<<TWEN) | (1<<TWSTO) | (1<<TWINT);} |
| void I2C_Reset(void); // Reset I2C |
| void I2C_SendBLConfig(void); |
| uint8_t I2C_SetBLConfig(void); |
| uint8_t I2C_GetBLConfig(void); |
| #endif |
| /beta/Code Redesign killagreg/uart0.c |
|---|
| 115,27 → 115,6 |
| int16_t Heading; |
| } __attribute__((packed)) Heading_t; |
| #define BLPARAM_REVISION 1 |
| #define MASK_SET_PWM_SCALING 0x01 |
| #define MASK_SET_CURRENT_LIMIT 0x02 |
| #define MASK_SET_TEMP_LIMIT 0x04 |
| #define MASK_SET_CURRENT_SCALING 0x08 |
| #define MASK_SET_BITCONFIG 0x10 |
| #define MASK_RESET_CAPCOUNTER 0x20 |
| #define MASK_SET_DEFAULT_PARAMS 0x40 |
| #define MASK_SET_SAVE_EEPROM 0x80 |
| typedef struct |
| { |
| uint8_t Revision; // revision of parameter structure |
| uint8_t Address; // target address |
| uint8_t PwmScaling; // maximum value of pwm setpoint |
| uint8_t CurrentLimit; // current limit in 1A steps |
| uint8_t TemperatureLimit; // in °C |
| uint8_t CurrentScaling; // scaling factor for current measurement |
| uint8_t BitConfig; // see defines above |
| uint8_t SetMask; // filter for active paramters |
| uint8_t Checksum; // checksum for parameter sturcture |
| } __attribute__((packed)) BLParameter_t; |
| DebugOut_t DebugOut; |
| Data3D_t Data3D; |
| 625,6 → 604,56 |
| PPM_in[24] = (int8_t)pRxData[11]; |
| break; |
| case 'u': // request BL parameter |
| tempchar1 = pRxData[0]; |
| Debug("Reading BL %d", tempchar1); |
| if( (tempchar1 > 0) && (tempchar1 <= MAX_MOTORS) ) |
| { // valid motor address |
| BLConfig[tempchar1-1].Revision = 0; // bad revision |
| BLConfig[tempchar1-1].crc = 0; // bad checksum |
| if(I2C_GetBLConfig()) |
| { // try to get the BL configs |
| if(BLConfig[tempchar1-1].crc == RAM_Checksum((uint8_t*)(&BLConfig[tempchar1-1]), sizeof(BLConfig_t)-1) ) |
| { // when crc is fine, send out |
| while(!txd_complete); // wait for previous frame to be sent |
| SendOutData('U', FC_ADDRESS, 2, tempchar1, 1, &BLConfig[tempchar1-1], sizeof(BLConfig_t)); |
| } |
| } |
| } |
| break; |
| case 'w': // write BL parameter |
| tempchar1 = 0; |
| Debug("Writing BL %d", pRxData[0]); |
| if(!(FCFlags & FCFLAG_MOTOR_RUN) && (pRxData[0] <= MAX_MOTORS)) // save parameter only if motors are off and a valid motor address was sent |
| { |
| BLConfig_t *pBLConfig = (BLConfig_t*)(&pRxData[1]); |
| // version check |
| if(pBLConfig->Revision == BLCONFIG_REVISION) |
| { |
| uint8_t i, start, end; |
| if(pRxData[0] == 0) // all BLs! |
| { |
| start = 0; |
| end = MAX_MOTORS - 1; |
| } |
| else |
| { // only one specific |
| start = pRxData[0] - 1; |
| end = start; |
| } |
| pBLConfig->crc = RAM_Checksum((uint8_t*)pBLConfig, sizeof(BLConfig_t) - 1); // update crc |
| for(i = start; i <= end; i++) |
| { |
| memcpy(&BLConfig[i], pBLConfig, sizeof(BLConfig_t)); |
| } |
| tempchar1 = I2C_SetBLConfig(); |
| } |
| } |
| while(!txd_complete); // wait for previous frame to be sent |
| SendOutData('W', FC_ADDRESS,1, &tempchar1, sizeof(tempchar1)); |
| break; |
| default: |
| //unsupported command received |
| break; |
| 689,68 → 718,6 |
| AboTimeOut = SetDelay(ABO_TIMEOUT); |
| break; |
| case 'u': // request BL parameter |
| tempchar1 = pRxData[0]; |
| Debug("Reading BL-Parameter %d", tempchar1); |
| if( (tempchar1 > 0) && (tempchar1 <= MAX_MOTORS) ) |
| { |
| BLParameter_t BLParam; |
| tempchar1--; |
| BLParam.Revision = BLPARAM_REVISION; |
| BLParam.Address = tempchar1+1; |
| BLParam.PwmScaling = BLConfig[tempchar1].PwmScaling; |
| BLParam.CurrentLimit = BLConfig[tempchar1].CurrentLimit; |
| BLParam.TemperatureLimit = BLConfig[tempchar1].TempLimit; |
| BLParam.CurrentScaling = BLConfig[tempchar1].CurrentScaling; |
| BLParam.BitConfig = BLConfig[tempchar1].BitConfig; |
| BLParam.SetMask = 0; |
| BLParam.Checksum = RAM_Checksum((uint8_t*)&(BLConfig[tempchar1]), sizeof(BLParam)-1); |
| SendOutData('U', FC_ADDRESS, 1, &BLParam, sizeof(BLParam)); |
| } |
| break; |
| case 'w': // write BL parameter |
| tempchar1 = 0; |
| if(!(FCFlags & FCFLAG_MOTOR_RUN)) // save parameter only if motors are off |
| { |
| BLParameter_t *pBLParam = (BLParameter_t*)pRxData; |
| // version and address check |
| if( (pBLParam->Revision == BLPARAM_REVISION) && (pBLParam->Address <= MAX_MOTORS) ) |
| { |
| uint8_t i, start, end; |
| if(pBLParam->Address == 0) |
| { // all BLs |
| start = 0; |
| end = MAX_MOTORS - 1; |
| } |
| else |
| { // only one specific |
| start = pBLParam->Address - 1; |
| end = start; |
| } |
| for(i = start; i <= end; i++) |
| { |
| if(pBLParam->SetMask & MASK_SET_DEFAULT_PARAMS) BLConfig_SetDefault(i); |
| else |
| { |
| if(pBLParam->SetMask & MASK_SET_PWM_SCALING) BLConfig[i].PwmScaling = pBLParam->PwmScaling; |
| if(pBLParam->SetMask & MASK_SET_CURRENT_LIMIT) BLConfig[i].CurrentLimit = pBLParam->CurrentLimit; |
| if(pBLParam->SetMask & MASK_SET_TEMP_LIMIT) BLConfig[i].TempLimit = pBLParam->TemperatureLimit; |
| if(pBLParam->SetMask & MASK_SET_CURRENT_SCALING) BLConfig[i].CurrentScaling = pBLParam->CurrentScaling; |
| if(pBLParam->SetMask & MASK_SET_BITCONFIG) BLConfig[i].BitConfig = pBLParam->BitConfig; |
| BLConfig[i].crc = RAM_Checksum((uint8_t*)&(BLConfig[i]), sizeof(BLConfig_t)-1); // update crc |
| } |
| if(pBLParam->SetMask & MASK_SET_SAVE_EEPROM) BLConfig_WriteToEEProm(i); |
| } |
| I2C_SendBLConfig(); |
| tempchar1 = 1; |
| } |
| } |
| while(!txd_complete); // wait for previous frame to be sent |
| SendOutData('W', FC_ADDRESS,1, &tempchar1, sizeof(tempchar1)); |
| break; |
| default: |
| //unsupported command received |
| break; |