main.cpp

00001 /// high-bandwidth 3-phase motor control, for robots
00002 /// Written by benkatz, with much inspiration from Bayley Wang, Nick Kirkby, Shane Colton, David Otten, and others
00003 /// Hardware documentation can be found at build-its.blogspot.com
00004 /// Written for the STM32F446, but can be implemented on other STM32 MCU's with some further register-diddling
00005 /// Version for the TI DRV8323 Everything Chip
00006 
00007 #define REST_MODE           0
00008 #define CALIBRATION_MODE    1
00009 #define MOTOR_MODE          2
00010 #define SETUP_MODE          4
00011 #define ENCODER_MODE        5
00012 #define INIT_TEMP_MODE      6
00013 
00014 #define VERSION_NUM "1.10"
00015 
00016 
00017 float __float_reg[64];                                                          // Floats stored in flash
00018 int __int_reg[256];                                                             // Ints stored in flash.  Includes position sensor calibration lookup table
00019 
00020 #include "mbed.h"
00021 #include "PositionSensor.h"
00022 #include "structs.h"
00023 #include "foc.h" 
00024 #include "calibration.h"
00025 #include "hw_setup.h"
00026 #include "math_ops.h" 
00027 #include "current_controller_config.h"
00028 #include "hw_config.h"
00029 #include "motor_config.h"
00030 #include "stm32f4xx_flash.h"
00031 #include "FlashWriter.h"
00032 #include "user_config.h"
00033 #include "PreferenceWriter.h"
00034 #include "CAN_com.h"
00035 #include "DRV.h"
00036  
00037 PreferenceWriter prefs(6);
00038 
00039 GPIOStruct gpio;
00040 ControllerStruct controller;
00041 ObserverStruct observer;
00042 COMStruct com;
00043 Serial pc(PA_2, PA_3);
00044 
00045 
00046 CAN          can(PB_8, PB_9, 1000000);      // CAN Rx pin name, CAN Tx pin name
00047 CANMessage   rxMsg;
00048 CANMessage   txMsg;
00049 
00050 
00051 SPI drv_spi(PA_7, PA_6, PA_5);
00052 DigitalOut drv_cs(PA_4);
00053 //DigitalOut drv_en_gate(PA_11);
00054 DRV832x drv(&drv_spi, &drv_cs);
00055 
00056 PositionSensorAM5147 spi(16384, 0.0, NPP);  
00057 
00058 volatile int count = 0;
00059 volatile int state = REST_MODE;
00060 volatile int state_change;
00061 
00062 void onMsgReceived() {
00063     //msgAvailable = true;
00064     //printf("%d\n\r", rxMsg.id);
00065     can.read(rxMsg);  
00066     if((rxMsg.id == CAN_ID)){
00067         controller.timeout = 0;
00068         if(((rxMsg.data[0]==0xFF) & (rxMsg.data[1]==0xFF) & (rxMsg.data[2]==0xFF) & (rxMsg.data[3]==0xFF) & (rxMsg.data[4]==0xFF) & (rxMsg.data[5]==0xFF) & (rxMsg.data[6]==0xFF) & (rxMsg.data[7]==0xFC))){
00069             state = MOTOR_MODE;
00070             state_change = 1;
00071             }
00072         else if(((rxMsg.data[0]==0xFF) & (rxMsg.data[1]==0xFF) & (rxMsg.data[2]==0xFF) & (rxMsg.data[3]==0xFF) * (rxMsg.data[4]==0xFF) & (rxMsg.data[5]==0xFF) & (rxMsg.data[6]==0xFF) & (rxMsg.data[7]==0xFD))){
00073             state = REST_MODE;
00074             state_change = 1;
00075             gpio.led->write(0);; 
00076             }
00077         else if(((rxMsg.data[0]==0xFF) & (rxMsg.data[1]==0xFF) & (rxMsg.data[2]==0xFF) & (rxMsg.data[3]==0xFF) * (rxMsg.data[4]==0xFF) & (rxMsg.data[5]==0xFF) & (rxMsg.data[6]==0xFF) & (rxMsg.data[7]==0xFE))){
00078             spi.ZeroPosition();
00079             }
00080         else if(state == MOTOR_MODE){
00081             unpack_cmd(rxMsg, &controller);
00082             }
00083         pack_reply(&txMsg, controller.theta_mech, controller.dtheta_mech, controller.i_q_filt*KT_OUT);
00084         can.write(txMsg);
00085         }
00086     
00087 }
00088 
00089 void enter_menu_state(void){
00090     drv.disable_gd();
00091     reset_foc(&controller); 
00092     //gpio.enable->write(0);
00093     printf("\n\r\n\r\n\r");
00094     printf(" Commands:\n\r");
00095     wait_us(10);
00096     printf(" m - Motor Mode\n\r");
00097     wait_us(10);
00098     printf(" c - Calibrate Encoder\n\r");
00099     wait_us(10);
00100     printf(" s - Setup\n\r");
00101     wait_us(10);
00102     printf(" e - Display Encoder\n\r");
00103     wait_us(10);
00104     printf(" z - Set Zero Position\n\r");
00105     wait_us(10);
00106     printf(" esc - Exit to Menu\n\r");
00107     wait_us(10);
00108     state_change = 0;
00109     gpio.led->write(0);
00110     }
00111 
00112 void enter_setup_state(void){
00113     printf("\n\r\n\r Configuration Options \n\r\n\n");
00114     wait_us(10);
00115     printf(" %-4s %-31s %-5s %-6s %-2s\n\r\n\r", "prefix", "parameter", "min", "max", "current value");
00116     wait_us(10);
00117     printf(" %-4s %-31s %-5s %-6s %.1f\n\r", "b", "Current Bandwidth (Hz)", "100", "2000", I_BW);
00118     wait_us(10);
00119     printf(" %-4s %-31s %-5s %-6s %-5i\n\r", "i", "CAN ID", "0", "127", CAN_ID);
00120     wait_us(10);
00121     printf(" %-4s %-31s %-5s %-6s %-5i\n\r", "m", "CAN Master ID", "0", "127", CAN_MASTER);
00122     wait_us(10);
00123     printf(" %-4s %-31s %-5s %-6s %.1f\n\r", "l", "Current Limit (A)", "0.0", "40.0", I_MAX);
00124     wait_us(10);
00125     printf(" %-4s %-31s %-5s %-6s %.1f\n\r", "f", "FW Current Limit (A)", "0.0", "33.0", I_FW_MAX);
00126     wait_us(10);
00127     printf(" %-4s %-31s %-5s %-6s %d\n\r", "t", "CAN Timeout (cycles)(0 = none)", "0", "100000", CAN_TIMEOUT);
00128     wait_us(10);
00129     printf(" %-4s %-31s %-5s %-6s %.1f\n\r", "h", "Temp Cutoff (C) (0 = none)", "0", "150", TEMP_MAX);
00130     wait_us(10);
00131     printf(" %-4s %-31s %-5s %-6s %.1f\n\r", "c", "Continuous Current (A)", "0", "40.0", I_MAX_CONT);
00132     wait_us(10);
00133     printf("\n\r To change a value, type 'prefix''value''ENTER'\n\r i.e. 'b1000''ENTER'\n\r\n\r");
00134     wait_us(10);
00135     state_change = 0;
00136     }
00137     
00138 void enter_torque_mode(void){
00139     drv.enable_gd();
00140     //gpio.enable->write(1);
00141     controller.ovp_flag = 0;
00142     reset_foc(&controller);                                                     // Tesets integrators, and other control loop parameters
00143     wait(.001);
00144     controller.i_d_ref = 0;
00145     controller.i_q_ref = 0;                                                     // Current Setpoints
00146     gpio.led->write(1);                                                     // Turn on status LED
00147     state_change = 0;
00148     printf("\n\r Entering Motor Mode \n\r");
00149     }
00150     
00151 void calibrate(void){
00152     drv.enable_gd();
00153     //gpio.enable->write(1);
00154     gpio.led->write(1);                                                    // Turn on status LED
00155     order_phases(&spi, &gpio, &controller, &prefs);                             // Check phase ordering
00156     calibrate(&spi, &gpio, &controller, &prefs);                                // Perform calibration procedure
00157     gpio.led->write(0);;                                                     // Turn off status LED
00158     wait(.05);
00159     R_NOMINAL = 0;
00160     state = INIT_TEMP_MODE;
00161     //printf("\n\r Calibration complete.  Press 'esc' to return to menu\n\r");
00162     //drv.disable_gd();
00163     //state_change = 0;
00164      
00165     }
00166     
00167 void print_encoder(void){
00168     printf(" Mechanical Angle:  %f    Electrical Angle:  %f    Raw:  %d\n\r", spi.GetMechPosition(), spi.GetElecPosition(), spi.GetRawPosition());
00169     //printf("%d\n\r", spi.GetRawPosition());
00170     wait(.001);
00171     }
00172 
00173 /// Current Sampling Interrupt ///
00174 /// This runs at 40 kHz, regardless of of the mode the controller is in ///
00175 //float testing[1000];
00176 //float testing2[1000];
00177 extern "C" void TIM1_UP_TIM10_IRQHandler(void) {
00178   if (TIM1->SR & TIM_SR_UIF ) {
00179         //gpio.led->write(1);
00180         ///Sample current always ///
00181         gpio.led->write(!gpio.led->read());
00182         ADC1->CR2  |= 0x40000000;                                               // Begin sample and conversion
00183         //volatile int delay;   
00184         //for (delay = 0; delay < 55; delay++);
00185         
00186         spi.Sample(DT);                                                           // sample position sensor
00187         /*
00188         if(count < 10){printf("%d\n\r", spi.GetRawPosition());}
00189         count ++;
00190         */        
00191         controller.adc2_raw = ADC2->DR;                                         // Read ADC Data Registers
00192         controller.adc1_raw = ADC1->DR;
00193         controller.adc3_raw = ADC3->DR;
00194         controller.theta_elec = spi.GetElecPosition();
00195         controller.theta_mech = (1.0f/GR)*spi.GetMechPosition();
00196         controller.dtheta_mech = (1.0f/GR)*spi.GetMechVelocity();  
00197         controller.dtheta_elec = spi.GetElecVelocity();
00198         controller.v_bus = 0.95f*controller.v_bus + 0.05f*((float)controller.adc3_raw)*V_SCALE; //filter the dc link voltage measurement
00199         
00200 
00201         
00202         ///
00203         
00204         /// Check state machine state, and run the appropriate function ///
00205         switch(state){
00206             case REST_MODE:                                                     // Do nothing
00207                 if(state_change){
00208                     enter_menu_state();
00209                     }
00210                 update_observer(&controller, &observer);
00211                 break;
00212             
00213             case CALIBRATION_MODE:                                              // Run encoder calibration procedure
00214                 if(state_change){
00215                     calibrate();
00216                     }
00217                 break;
00218             case INIT_TEMP_MODE:
00219                 if(state_change){
00220                     enter_torque_mode();
00221                     count = 0;
00222                     observer.resistance = 0.0f;
00223                     } 
00224                 controller.i_d_ref = -10.0f;
00225                 controller.i_q_ref = 0.0f;
00226                 commutate(&controller, &observer, &gpio, controller.theta_elec); 
00227 
00228                 if(count > 200)
00229                 {
00230                     float r_meas = controller.v_d*(DTC_MAX-DTC_MIN)/(controller.i_d*SQRT3);
00231                     //testing2[count-100] = controller.i_d;
00232                     observer.resistance += .001f*r_meas;
00233                 }
00234                 if(count > 1200)
00235                 {
00236                     count = 0;
00237                     state = REST_MODE;
00238                     state_change = 1;
00239                     gpio.led->write(0);
00240                     observer.temperature = (double)(T_AMBIENT + ((observer.resistance/R_NOMINAL) - 1.0f)*254.5f);
00241                     printf("Winding Resistance:  %f\n\r", observer.resistance);
00242                     printf("Winding Temperature:  %f\n\r", observer.temperature);
00243                     
00244                     if(R_NOMINAL==0)
00245                     {
00246                         printf("Saving winding resistance\n\r");
00247                         R_NOMINAL = observer.resistance;
00248                         if (!prefs.ready()) prefs.open();
00249                         prefs.flush();                                                         // write offset and lookup table to flash
00250                         prefs.close();
00251                     }
00252                     //for(int i = 0; i<1000; i++){printf("%f \n\r", testing[i]);}
00253                 }
00254                 
00255                 count++; 
00256                 break;
00257             case MOTOR_MODE:                                                   // Run torque control
00258                 if(state_change){
00259                     enter_torque_mode();
00260                     count = 0;
00261                     }
00262                 else{
00263                 /*
00264                 if(controller.v_bus>28.0f){         //Turn of gate drive if bus voltage is too high, to prevent FETsplosion if the bus is cut during regen
00265                     gpio.
00266                     ->write(0);
00267                     controller.ovp_flag = 1;
00268                     state = REST_MODE;
00269                     state_change = 1;
00270                     printf("OVP Triggered!\n\r");
00271                     }
00272                     */  
00273 
00274                 if((controller.timeout > CAN_TIMEOUT) && (CAN_TIMEOUT > 0)){
00275                     controller.i_d_ref = 0;
00276                     controller.i_q_ref = 0;
00277                     controller.kp = 0;
00278                     controller.kd = 0;
00279                     controller.t_ff = 0;
00280                     } 
00281     
00282                 torque_control(&controller);
00283                 update_observer(&controller, &observer);
00284                 field_weaken(&controller);
00285                 commutate(&controller, &observer, &gpio, controller.theta_elec);           // Run current loop
00286                 controller.timeout++;
00287 
00288                 if(controller.otw_flag)
00289                 { 
00290                     state = REST_MODE;
00291                     state_change = 1;
00292                     gpio.led->write(0);
00293                 }
00294                 
00295                 count++; 
00296                 }   
00297                 
00298                   
00299                 break;
00300             
00301             case SETUP_MODE:
00302                 if(state_change){
00303                     enter_setup_state();
00304                 }
00305                 break;
00306             case ENCODER_MODE:
00307                 print_encoder();
00308                 break;
00309                 }                 
00310       }
00311       //gpio.led->write(0);
00312   TIM1->SR = 0x0;                                                               // reset the status register
00313 }
00314 
00315 
00316 char cmd_val[8] = {0};
00317 char cmd_id = 0;
00318 char char_count = 0;
00319 
00320 /// Manage state machine with commands from serial terminal or configurator gui ///
00321 /// Called when data received over serial ///
00322 void serial_interrupt(void){
00323     while(pc.readable()){
00324         char c = pc.getc();
00325         if(c == 27){
00326                 state = REST_MODE;
00327                 state_change = 1;
00328                 char_count = 0;
00329                 cmd_id = 0;
00330                 gpio.led->write(0);;
00331                 for(int i = 0; i<8; i++){cmd_val[i] = 0;}
00332                 }
00333         if(state == REST_MODE){
00334             switch (c){
00335                 case 'c':
00336                     state = CALIBRATION_MODE;
00337                     state_change = 1;
00338                     break;
00339                 case 'm':
00340                     state = MOTOR_MODE;
00341                     state_change = 1;
00342                     break;
00343                 case 'e':
00344                     state = ENCODER_MODE;
00345                     state_change = 1;
00346                     break;
00347                 case 's':
00348                     state = SETUP_MODE;
00349                     state_change = 1;
00350                     break;
00351                 case 'z':
00352                     spi.SetMechOffset(0);
00353                     spi.Sample(DT);
00354                     wait_us(20);
00355                     M_OFFSET = spi.GetMechPosition();
00356                     if (!prefs.ready()) prefs.open();
00357                         prefs.flush();                                                  // Write new prefs to flash
00358                         prefs.close();    
00359                         prefs.load(); 
00360                     spi.SetMechOffset(M_OFFSET);
00361                     printf("\n\r  Saved new zero position:  %.4f\n\r\n\r", M_OFFSET);
00362                     
00363                     break;
00364                 }
00365                 
00366                 }
00367         else if(state == SETUP_MODE){
00368             if(c == 13){
00369                 switch (cmd_id){
00370                     case 'b':
00371                         I_BW = fmaxf(fminf(atof(cmd_val), 2000.0f), 100.0f);
00372                         break;
00373                     case 'i':
00374                         CAN_ID = atoi(cmd_val);
00375                         break;
00376                     case 'm':
00377                         CAN_MASTER = atoi(cmd_val);
00378                         break;
00379                     case 'l':
00380                         I_MAX = fmaxf(fminf(atof(cmd_val), 40.0f), 0.0f);
00381                         break;
00382                     case 'f':
00383                         I_FW_MAX = fmaxf(fminf(atof(cmd_val), 33.0f), 0.0f);
00384                         break;
00385                     case 't':
00386                         CAN_TIMEOUT = atoi(cmd_val);
00387                         break;
00388                     case 'h':
00389                         TEMP_MAX = fmaxf(fminf(atof(cmd_val), 150.0f), 0.0f);
00390                         break;
00391                     case 'c':
00392                         I_MAX_CONT = fmaxf(fminf(atof(cmd_val), 40.0f), 0.0f);
00393                         break;
00394                     default:
00395                         printf("\n\r '%c' Not a valid command prefix\n\r\n\r", cmd_id);
00396                         break;
00397                     }
00398                     
00399                 if (!prefs.ready()) prefs.open();
00400                 prefs.flush();                                                  // Write new prefs to flash
00401                 prefs.close();    
00402                 prefs.load();                                              
00403                 state_change = 1;
00404                 char_count = 0;
00405                 cmd_id = 0;
00406                 for(int i = 0; i<8; i++){cmd_val[i] = 0;}
00407                 }
00408             else{
00409                 if(char_count == 0){cmd_id = c;}
00410                 else{
00411                     cmd_val[char_count-1] = c;
00412                     
00413                 }
00414                 pc.putc(c);
00415                 char_count++;
00416                 }
00417             }
00418         else if (state == ENCODER_MODE){
00419             switch (c){
00420                 case 27:
00421                     state = REST_MODE;
00422                     state_change = 1;
00423                     break;
00424                     }
00425             }
00426         else if (state == MOTOR_MODE){
00427             switch (c){
00428                 case 'd':
00429                     controller.i_q_ref = 0;
00430                     controller.i_d_ref = 0;
00431                 }
00432             }
00433             
00434         }
00435     }
00436        
00437 int main() {
00438     controller.v_bus = V_BUS;
00439     controller.mode = 0;
00440     Init_All_HW(&gpio);                                                         // Setup PWM, ADC, GPIO
00441     wait_us(100);
00442     
00443     gpio.enable->write(1);
00444     wait_us(100);
00445     drv.calibrate();
00446     wait_us(100);
00447     drv.write_DCR(0x0, DIS_GDF_DIS, 0x0, PWM_MODE_3X, 0x0, 0x0, 0x0, 0x0, 0x1);
00448     wait_us(100);
00449     drv.write_CSACR(0x0, 0x1, 0x0, CSA_GAIN_40, 0x0, 0x1, 0x1, 0x1, SEN_LVL_1_0);   // calibrate shunt amplifiers
00450     wait_us(100);
00451     
00452         
00453     drv.write_HSR(LOCK_OFF, IDRIVEP_HS_330MA, IDRIVEN_HS_660MA);
00454     wait_us(100);
00455     drv.write_LSR(0x1, TDRIVE_4000NS, IDRIVEP_LS_330MA, IDRIVEN_LS_660MA);
00456     wait_us(100);
00457     
00458     
00459     zero_current(&controller.adc1_offset, &controller.adc2_offset); 
00460     wait_us(100);
00461     drv.write_CSACR(0x0, 0x1, 0x0, CSA_GAIN_40, 0x1, 0x0, 0x0, 0x0, SEN_LVL_1_0);
00462     wait_us(100);
00463     drv.write_OCPCR(TRETRY_50US, DEADTIME_50NS, OCP_NONE, OCP_DEG_8US, VDS_LVL_1_88);
00464     
00465     //drv.enable_gd();
00466     drv.disable_gd();
00467     //zero_current(&controller.adc1_offset, &controller.adc2_offset);             // Measure current sensor zero-offset
00468     //drv.enable_gd();
00469 
00470     wait_us(100);
00471     
00472     reset_foc(&controller);                                                     // Reset current controller
00473     reset_observer(&observer);                                                 // Reset observer
00474     //TIM1->CR1 |= TIM_CR1_UDIS; //enable interrupt
00475     
00476     wait_us(100);
00477     NVIC_SetPriority(TIM1_UP_TIM10_IRQn, 2);                                             // commutation > communication
00478     NVIC_SetPriority(CAN1_RX0_IRQn, 3);
00479                                    // attach 'CAN receive-complete' interrupt handler    
00480     
00481     // If preferences haven't been user configured yet, set defaults 
00482     prefs.load();                                                               // Read flash
00483     can.filter(CAN_ID , 0xFFF, CANStandard, 0);                                                         
00484     txMsg.id = CAN_MASTER;
00485     txMsg.len = 6;
00486     rxMsg.len = 8;
00487     can.attach(&onMsgReceived);  
00488     
00489     if(isnan(E_OFFSET)){E_OFFSET = 0.0f;}
00490     if(isnan(M_OFFSET)){M_OFFSET = 0.0f;}
00491     if(isnan(I_BW) || I_BW==-1){I_BW = 1000;}
00492     if(isnan(I_MAX) || I_MAX ==-1){I_MAX=40;}
00493     if(isnan(I_FW_MAX) || I_FW_MAX ==-1){I_FW_MAX=12;}
00494     if(isnan(CAN_ID) || CAN_ID==-1){CAN_ID = 1;}
00495     if(isnan(CAN_MASTER) || CAN_MASTER==-1){CAN_MASTER = 0;}
00496     if(isnan(CAN_TIMEOUT) || CAN_TIMEOUT==-1){CAN_TIMEOUT = 1000;}
00497     if(isnan(R_NOMINAL) || R_NOMINAL==-1){R_NOMINAL = 0.0f;}
00498     if(isnan(TEMP_MAX) || TEMP_MAX==-1){TEMP_MAX = 125.0f;}
00499     if(isnan(I_MAX_CONT) || I_MAX_CONT==-1){I_MAX_CONT = 14.0f;}
00500     spi.SetElecOffset(E_OFFSET);                                                // Set position sensor offset
00501     spi.SetMechOffset(M_OFFSET);
00502     spi.Sample(1.0f);
00503     if(spi.GetMechPosition() > PI){spi.SetMechOffset(M_OFFSET+2.0f*PI);}        // now zeroes to +- 30 degrees about nominal, independent of rollover point
00504     else if (spi.GetMechPosition() < -PI){spi.SetMechOffset(M_OFFSET-2.0f*PI);}
00505     
00506     int lut[128] = {0};
00507     memcpy(&lut, &ENCODER_LUT, sizeof(lut));
00508     spi.WriteLUT(lut);                                                          // Set potision sensor nonlinearity lookup table
00509     init_controller_params(&controller);
00510     
00511 
00512     pc.baud(921600);                                                            // set serial baud rate
00513     wait(.01);
00514     pc.printf("\n\r\n\r HobbyKing Cheetah\n\r\n\r");
00515     wait(.01);
00516     printf("\n\r Debug Info:\n\r");
00517     printf(" Firmware Version: %s\n\r", VERSION_NUM);
00518     printf(" ADC1 Offset: %d    ADC2 Offset: %d\n\r", controller.adc1_offset, controller.adc2_offset);
00519     printf(" Position Sensor Electrical Offset:   %.4f\n\r", E_OFFSET);
00520     printf(" Output Zero Position:  %.4f\n\r", M_OFFSET);
00521     printf(" CAN ID:  %d\n\r", CAN_ID);
00522     
00523 
00524     TIM1->CR1 ^= TIM_CR1_UDIS;
00525 
00526     
00527     pc.attach(&serial_interrupt);                                               // attach serial interrupt
00528 
00529 
00530     int counter = 0;
00531     while(1) {
00532         //drv.print_faults();
00533         wait(.1);
00534         //printf("%.3f  %.3f\n\r" , observer.temperature, observer.q_in);
00535         //if(controller.otw_flag){gpio.led->write(!gpio.led->read());}
00536              /*
00537         if(state == MOTOR_MODE)
00538         {
00539             if(controller.otw_flag){gpio.led->write(!gpio.led->read());}
00540             //printf("%f  %f\n\r", controller.dtheta_mech, controller.i_d_ref);
00541             //printf("%.3f  %.3f  %.3f\n\r", (float)observer.temperature, (float)observer.temperature2, observer.resistance);
00542             //printf("%.3f  %.3f  %.3f %.3f %.3f\n\r", controller.v_d, controller.v_q, controller.i_d_filt, controller.i_q_filt, controller.dtheta_elec);
00543             //printf("%.3f  %.3f  %.3f %.3f\n\r", controller.dtheta_elec, observer.resistance, observer.temperature, observer.temp_measured);
00544             //printf("%.3f  %.3f\n\r" , observer.temperature, observer.temp_measured);
00545         }
00546         
00547         */
00548 
00549     }
00550 }