/****************************************************************************** // init_main.c Persistor and PicoDOS starter C file // //***************************************************************************** // // Apr2011, used to initialize CF2 EEPROM and MSP430 modules. // Used to do calibration of MSP430 sensors // // //***************************************************************************** // //==== Future Expansion ======================================================= // last update: // *******************************************************************************/ #include // Persistor BIOS and I/O Definitions #include // Persistor PicoDOS Definitions #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "cf2_qsm332.h" #include "spi_cmd.h" #include "tcm2.h" #include "pitch_roll.h" #include "gpio_mux.h" #include "pump.h" #include "dat_fnx.h" #include "gps.h" #include "nav.h" #include "sbd.h" #include "adp.h" #include "ntk.h" #include "sbe.h" #include "lifo.h" #include "setup.h" // definitions ---------------------------------------------------------------- #define SCI_BAUD 9600L // whatever is appropriate // system clock is HIGH_CLOCK_SPEED defined in setup.h #define WTMODE nsStdSmallBusAdj // choose: nsMotoSpecAdj or nsStdSmallBusAdj #define SCIWAIT 900 // # of milli-secs to wait btwn char before timeout // globals -------------------------------------------------------------------- char Verbose =0; // for diagnostics, can turn on/off more info char IRQ_Flag =0; // flag, whose value determines what caused the interrupt struct all_param all; short iparam [ MAX_PARAM ]; // global parameter settings MAX_PARAM // prototypes ----------------------------------------------------------------- void main_menu ( void ); void set_vac_off ( void ); void set_V14_gain ( void ); void set_V07_gain ( void ); void set_prV_gain ( void ); void set_prI_gain ( void ); IEV_C_PROTO ( Spur_ISR ); // interrupt service routine prototype IEV_C_PROTO ( Irq2_ISR ); // interrupt service routine prototype IEV_C_PROTO ( Irq4_ISR ); // interrupt service routine prototype //define others to safeguard IEV_C_PROTO ( Irq3_ISR ); IEV_C_PROTO ( Irq5_ISR ); IEV_C_PROTO ( Irq7_ISR ); IEV_C_PROTO ( Div0_ISR ); /******************************************************************************\ ** main \******************************************************************************/ int main(int argc, char **argv) { short i, done, err; short result = 0, tmo; char ch; struct spi_param ss1; // struct for spi comms struct time_param ti; // struct for timing of various events struct compass_param compass; // struct with compass parameters struct gps_param gps; // struct with gps parameters struct sbd_param sbd; // struct with Iridium SBD parameters struct lifo_param lifo; // struct with LIFO parameters struct flight_param flight; // flight params //struct miss_param mis; // struct with the mission parameters struct except_param exc; // exception parameter list struct eng_param eng; // engineering parameter list struct drift_param drift; // drift parameters struct hyd_param hyd; // hydraulics params struct dat_param dat; // daq/processing params struct adp_param adp; // adp parameters struct motor_stat mot; // motor stats for last op struct ublox_param ubx; // ublox gps positions, for surface drift struct pwr_param pwr; // power #'s for pitch, roll & hyd struct nav_param nav; // nav parameters struct route_param rte; // route parameters struct pp_daq pp; // mar11, polyplus daq struct // TUChParams tuart_cfg; struct tpu_uart tu_port[N_TU_PORTS] = { FROM_SAT , TO_SAT , BAUD_SAT , 0, FROM_MUX1, TO_MUX1, BAUD_MUX1, 0, FROM_MUX2, TO_MUX2, BAUD_MUX2, 0, FROM_SBE, TO_SBE, BAUD_SBE, 0 }; // 4 TPU uart ports, defined as above CSSetSysAccessSpeeds(nsFlashStd, nsRAMStd, nsCFStd, WTMODE); TMGSetSpeed(HIGH_CLOCK_SPEED); SCIConfigure(SCI_BAUD, 'N', true); SCIRxSetBuffered(true); // enable the built-in 2k-word buffer init_pins(); // initialize the pins for other tasks // INITIALIZE THE TPU UART MODULE TUInit(calloc, free); // give TU manager access to our heap // Identify the progam and build cprintf("\nProgram: %s: %s %s \n", __FILE__, __DATE__, __TIME__); // Identify the device and its firmware cprintf("Persistor CF%d SN:%ld BIOS:%d.%02d PicoDOS:%d.%02d\n", CFX, BIOSGVT.CFxSerNum, BIOSGVT.BIOSVersion, BIOSGVT.BIOSRelease, BIOSGVT.PICOVersion, BIOSGVT.PICORelease); /* Identify the arguments */ cprintf("\n%d Arguments:\n", argc); for (i = 0; i < argc; i++) cprintf(" argv[%d] = \"%s\"\n", i, argv[i]); /**/ //i = sizeof(nav); cprintf("size of nav_param = %d\n", i ); //i = sizeof(lifo);cprintf("size of lifo_param = %d\n", i ); //i = sizeof(dat); cprintf("size of dat_param = %d\n", i ); // // Install handlers for the interrupts we want to catch // // IEVInsertAsmFunct ( Irq4RxISR, level4InterruptAutovector); //R // IEVInsertAsmFunct ( Irq4RxISR, spuriousInterrupt); IEVInsertCFunct ( &Irq2_ISR, level2InterruptAutovector); IEVInsertCFunct ( &Irq4_ISR, level4InterruptAutovector); IEVInsertCFunct ( &Spur_ISR, spuriousInterrupt ); // define others IEVInsertCFunct ( &Irq3_ISR, level3InterruptAutovector); IEVInsertCFunct ( &Irq5_ISR, level5InterruptAutovector); IEVInsertCFunct ( &Irq7_ISR, level7InterruptAutovector); IEVInsertCFunct ( &Div0_ISR, zeroDivision ); TMGSetupCLKOUTPin(false, false); SCITxWaitCompletion(); PITSet51msPeriod(PITOff); // disable timer (drops power) LEDInit(); PITAddChore(hibernate_task,3); // empty chore for PIT // initialize the TPU serial ports all.tu_port = tu_port; // set all.tu_port address same as the local for (i=0;in_reset = 0; // no spurious resets yet all.exc->exc_stat = 0; // zero out the exception status all.time->ti0 = RTCGetTime ( 0, 0 ); // UX time for this dive all.time->ti_cyc = all.time->ti0; // UX time for this cycle //---following will set up eeprom parameters, even if //---they have not been defined before VEEStoreLong( "OPMODE", 0L ); //set_op_mode(0); // put in normal operation-mode = user mode set_default_param(); // initialize the parameter array // initialize the SPI and start up the watchdog =================== spi_set_wdog( 1, 255 ); init_gpio_iparam(); cprintf("Do you want to reset GPIO flash to default (y/n)? >\n"); if (YesNo() ) gp_set_default ( ); // initialize the pitch module if ( init_pr_iparam ( CS_PITCH ) == 0 ) { // pitch module is responding cprintf("Do you want to reset PITCH flash to default (y/n)? >\n"); if (YesNo() ) pr_set_default ( all.sspi ); } // initialize the roll module if ( init_pr_iparam ( CS_ROLL ) == 0 ) { // roll module is responding cprintf("Do you want to reset ROLL flash to default (y/n)? >\n"); if (YesNo() ) pr_set_default ( all.sspi ); } // initialize the hydraulic module if ( init_hyd_iparam () == 0 ) { // hydraulic module is responding cprintf("Do you want to reset HYDRAULIC flash to default (y/n)? >\n"); if (YesNo() ) hyd_set_default ( ); } main_menu(); done = false; tmo = 0; while (!done) //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ { //cycle until we get a quit command EIAEnableRx(1); SerInFlush(); // delete old anything in the buffer if (ch !=' ' && ch>0 ) cprintf(" BAS>\n"); // display directory prompt ch = -1; //illegal input char ch = SCIRxGetCharWithTimeout(1000 ); // get a character tmo = check_tmo ( &ch, tmo ); // increments the tmo counter if ch<0, and // goes to sleep mode after max_tmo. Returns *ch as upper-case switch(ch) //==================================================== { // and depending upon the ch, do the appropriate action ======= case 0x1B : //ESC key , abort program cprintf("Do you really want to quit (y/n)? >\n"); if (YesNo() ) { done=1; } // set flag to quit else { ch = ' ';} break; case '?' : break; // causes directory prompt to be displayed case ' ' : break; // wait for another character case -1 : break; // wait for another character case '+' : toggle_verbose(); // toggle verbose mode break; case 'C' : // go test compass module test_compass ( ); break; case 'D' : // test the dat_fnx module daq_test ( ); break; case 'F' : // go test compass module flash_test ( ); break; case 'G' : // go test compass module test_gps ( ); break; case 'H' : // go test the hydraulic module test_hyd ( ); break; case 'I' : // go test Iridium SBD test_sbd ( ); break; case 'L' : // put into low-power mode sleep_check ( STAY_LOWPWR, PIT_IRQ2_RXD, FALSE ); main_menu(); break; case 'M' : // go test pitch and roll modules test_pitch_roll ( ); break; case 'P' : // go test SBE CTD module test_param ( ); break; case 'U' : main_menu(); break; // show the main menu case 'V' : // set vacuum to zero offset set_vac_off ( ); break; case 'W' : // go test GPIO/MUX msp430 test_gpio ( ); break; case '0' : // reset the dive # and op_mode set_surf_num ( 0 ); set_prof_num ( 0 ); //0902, include profile # set_op_mode ( 0 ); cprintf("Dive# and op_mode now = 0\n"); break; case '1' : // gain for the 14V input set_V14_gain ( ); break; case '2' : // gain for the 7V input set_V07_gain ( ); break; case '3' : // gain for pitch volts set_prV_gain ( ); break; //case '4' : // gain for the 7V input // set_prI_gain ( ); // break; case '9' : // hidden test i = 99 / iparam[ IA_use_set ]; cprintf("I divide-by-zero = %d, flag = %d\n",i, IRQ_Flag ); break; default : cprintf(" input unknown \n"); } //============================================================== } // end while !done //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ cprintf("freeing memory\n"); #if ADP==1 || NTK==1 free( adp.buf); #endif free(lifo.buf ); free( dat.dat ); free( dat.eptr ); // Various exit strategies // BIOSReset(); // full hardware reset // BIOSResetToPBM(); // full reset, but stay in Pesistor Boot Monitor BIOSResetToPicoDOS(); // full reset, but jump to 0xE10000 (PicoDOS) return result; } //____ main() ____// //***************************************************************************** void main_menu ( void ) { //print out menu selections ************************************************* cprintf("INIT MAIN MENU, compiled %s %s\n", __DATE__, __TIME__ ); write_header ( NULL ); // display info if ( ADP) cprintf(" Acoustic Doppler Profiler, "); if ( NTK) cprintf(" Nortek AD2CP, "); if (ISUS) cprintf(" ISUS Nitrate Sensor,"); if ( DOX) cprintf(" DOx Sensor,"); cprintf("\n"); if (DEBUG) cprintf("********* in DEBUG mode !!! \n"); cdrain(); // wait for the above to print cprintf(" ESC Abort prog : U.pdate menu \n" " V.acuum Offset \n" " 1=calibrate 14V GPIO\n" " 2=calibrate 07V GPIO \n" " 3=calibrate PITCH Volts \n" //" 4=calibrate PITCH Amps \n" "\n C.ompass : Flash Test : G.PS module \n" " H.ydraulics : I.ridium SBD : \n" " D.AQ test : L.owpower : M.otors Pitch&Roll\n" " + Toggle Verbose : W.atchdog, GPIO-MUX\n" " P.arameter Settings \n" " 0.Reset Dive#,op_mode\n"); return; } //*************************************************************************** //***************************************************************************** //***************************************************************************** //***************************************************************************** //***calibration routines ***************************************************** void set_vac_off ( void ) //*************************************************** { // take bench readings and set the offset to this value short ival, k, n=10, m=0; long vac =0; struct spi_param *ss; ss = all.sspi; setup_spi ( CS_GPIO, ss ); // re-init the SPI info cprintf("Taking %d vacuum samples \n", n); for (k=0;k0) { vac += ival; m++; } DelayMilliSecs(200); } //---------------------------------------------------- if (m>0) //============================================= { // valid vac = (vac + m/2)/ m; //round up ival = vac; // cast as short cprintf("Avg = %d \n", ival); cprintf("Set new offset to this value?\n"); if (YesNo() ) { spi_flash_write( F_G_VOFF,ival, ss ); init_gpio_iparam( ); //displays result } // else stays the same } //==================================================== else { cprintf("NO VALID readings taken\n"); } return; } //*************************************************************************** void set_V14_gain ( void ) //************************************************ { // take bench readings and set the 14V gain short ival, k, n=10, m; long v14 =0, v7=0; float f14, f7=0, gn; struct spi_param *ss; ss = all.sspi; setup_spi ( CS_GPIO, ss ); // re-init the SPI info printf("Taking %d V14 samples: SET V to 14.0 V \n", n); printf("Give the present input Voltage\n"); scanf("%f",&f14); m=0; for (k=0;k0) { v14 += ival; m++; } DelayMilliSecs(200); } //---------------------------------------------------- if (m>0) //============================================= { // valid v14 = (v14 + m/2)/m; //round up printf("Avg cnts = %5ld at %5.2f V \n", v14, f14); // else stays the same } //==================================================== else { cprintf("NO VALID readings taken\n"); } /* code assumes no offset, just use the 14V value cprintf("Taking %d V samples: SET V to 7.0 V \n", n); printf("Give the present input Voltage\n"); scanf("%f",&f7); m =0; for (k=0;k0) { v7 += ival; m++; } DelayMilliSecs(200); } //---------------------------------------------------- if (m>0) //============================================= { // valid v7 = (v7 + m/2)/m; //round up printf("Avg cnts = %5ld at %5.2f V \n", v7, f7); // else stays the same } //==================================================== else { cprintf("NO VALID readings taken\n"); } gn = ( f14 - f7 )/ (v14 - v7); // volts/cnt */ gn = f14/v14; gn = gn*10000 + 0.5; // gn*cnts ival = gn; // nearest integer if (ival>0) //========================================== { // valid cprintf("New gain = %d \n", ival); cprintf("Set V14 gain to this value?\n"); if (YesNo() ) { spi_flash_write( F_G_C2U_V14,ival, ss ); init_gpio_iparam( ); //displays result } // else stays the same } //==================================================== else { cprintf("Gain was not valid = %d\n", ival); } return; } //*************************************************************************** void set_V07_gain ( void ) //************************************************ { // take bench readings and set the 7V gain short ival, k, n=10, m; long v7 =0, v5=0; float f7, f5=0, gn; struct spi_param *ss; ss = all.sspi; setup_spi ( CS_GPIO, ss ); // re-init the SPI info printf("Taking %d V074 samples: SET V to 7.0 V \n", n); printf("Give the present input Voltage\n"); scanf("%f",&f7); m=0; for (k=0;k0) { v7 += ival; m++; } DelayMilliSecs(200); } //---------------------------------------------------- if (m>0) //============================================= { // valid v7 = (v7 + m/2)/m; //round up printf("Avg cnts = %5ld at %5.2f V \n", v7, f7); // else stays the same } //==================================================== else { cprintf("NO VALID readings taken\n"); } gn = f7/ v7 ; // volts/cnt gn = gn*10000 + 0.5; // gn*cnts ival = gn; // nearest integer if (ival>0) //========================================== { // valid cprintf("New gain = %d \n", ival); cprintf("Set V07 gain to this value?\n"); if (YesNo() ) { spi_flash_write( F_G_C2U_V07,ival, ss ); init_gpio_iparam( ); //displays result } // else stays the same } //==================================================== else { cprintf("Gain was not valid = %d\n", ival); } return; } //*************************************************************************** void set_prV_gain ( void ) //************************************************ { // take bench readings and set the pitch/roll module V gain short ival, k, n=10, m; long v7 =0, v5=0; float f7, f5=0, gn; struct spi_param *ss; ss = all.sspi; setup_spi ( CS_PITCH, ss ); // re-init the SPI info printf("Taking %d V samples of Pitch module: SET V to 14.0 V \n", n); printf("Give the present input Voltage\n"); scanf("%f",&f7); m=0; for (k=0;k0) { v7 += ival; m++; } DelayMilliSecs(200); } //---------------------------------------------------- if (m>0) //============================================= { // valid v7 = (v7 + m/2)/m; //round up printf("Avg cnts = %5ld at %5.2f V \n", v7, f7); // else stays the same } //==================================================== else { cprintf("NO VALID readings taken\n"); } gn = f7/ v7 ; // volts/cnt gn = gn*10000 + 0.5; // gn*cnts ival = gn; // nearest integer if (ival>0) //========================================== { // valid cprintf("New gain = %d \n", ival); cprintf("Set V gain to this value?\n"); if (YesNo() ) { spi_flash_write( F_C2U_V,ival, ss ); init_pr_iparam( CS_PITCH ); //displays result } // else stays the same } //==================================================== else { cprintf("Gain was not valid = %d\n", ival); } return; } //*************************************************************************** /*NO - can't be done on the bench, as motor controller only allows the motor // on if pot counts is believable --------------- void set_prI_gain ( void ) //************************************************ { // take bench readings and set the pitch/roll module I gain short ival, k, n=10, m, ch; long amps =0 ; float ma, gn; struct spi_param *ss; ss = all.sspi; setup_spi ( CS_PITCH, ss ); // re-init the SPI info ival = spi_cmd_ver ( CS_PITCH ); display_ver (); printf("Taking %d Current samples of Pitch module: SET V to 12.0 V \n", n); printf("!!!This runs the motor, disregarding the pot counts. Bench Test ONLY\n"); printf("Add load to simulate motor:\n"); printf(" hook-up wires at J4 to amp-meter to 200-ohm load\n"); printf("Turning on the motor circuit....\n"); printf("MONITOR THE CURRENT WHILE THE CIRCUIT IS ON\n"); send_p_r_run ( CS_PITCH, 0, 1000 ) ; printf("input a char when ready to start the averaging\n"); ch = SCIRxGetChar ( ); m=0; for (k=0;k0) { amps += ival; m++; } DelayMilliSecs(200); } //---------------------------------------------------- xfr_SPI_byte( CS_PITCH, SPI_STOP ); // turn off! if (m>0) //============================================= { // valid amps = (amps + m/2)/m; //round up printf("Give the average current (ma) \n"); scanf("%f",&ma); printf("Avg cnts = %5ld at %5.2f mA \n", amps, ma); // else stays the same } //==================================================== else { cprintf("NO VALID readings taken\n"); } gn = ma/ amps; // volts/cnt gn = gn*10000 + 0.5; // gn*cnts ival = gn; // nearest integer if (ival>0) //========================================== { // valid cprintf("New gain = %d \n", ival); cprintf("Set I gain to this value?\n"); if (YesNo() ) { spi_flash_write( F_C2U_I,ival, ss ); init_pr_iparam( CS_PITCH ); //displays result } // else stays the same } //==================================================== else { cprintf("Gain was not valid = %d\n", ival); } return; } //*************************************************************************** */ //***************************************************************************** //***************************************************************************** //***************************************************************************** //***************************************************************************** //***************************************************************************** //*** Interrupt Service Routines //***************************************************************************** /******************************************************************************\ ** Spur_ISR Interrupt handler for Spurious interrupt \******************************************************************************/ IEV_C_FUNCT( Spur_ISR ) { // ISR when a spurious interrupt #pragma unused(ievstack) IRQ_Flag = SPUR_F; // set global flag that RxD occurred // RTE(); this is added by the IEV_C_FUNCT } //*************************************************************************** /******************************************************************************\ ** Irq4_ISR Interrupt handler for IRQ4 = rs232 RxD detected \******************************************************************************/ IEV_C_FUNCT( Irq4_ISR ) { // ISR when IRQ4 = rs232 RxD is detected #pragma unused(ievstack) IRQ_Flag = IRQ4_F; // set global flag that RxD occurred PinIO(IRQ4RXD); // making it an input turns off ISR // RTE(); this is added by the IEV_C_FUNCT } //*************************************************************************** /******************************************************************************\ ** Irq2_ISR Interrupt handler for IRQ2 (tied to GPIO msp430) \******************************************************************************/ IEV_C_FUNCT( Irq2_ISR ) { #pragma unused(ievstack) IRQ_Flag = IRQ2_F; // set global flag that RxD occurred PinIO(IRQ2); // making it an input turns off ISR // RTE(); this is added by the IEV_C_FUNCT } //*************************************************************************** /******************************************************************************\ ** Irq3_ISR Interrupt handler for IRQ3 \******************************************************************************/ IEV_C_FUNCT( Irq3_ISR ) { // ISR when a spurious interrupt #pragma unused(ievstack) IRQ_Flag = IRQ3_F; // set global flag that RxD occurred // RTE(); this is added by the IEV_C_FUNCT } //*************************************************************************** /******************************************************************************\ ** Irq5_ISR Interrupt handler for IRQ5 \******************************************************************************/ IEV_C_FUNCT( Irq5_ISR ) { // ISR when a spurious interrupt #pragma unused(ievstack) IRQ_Flag = IRQ5_F; // set global flag that RxD occurred // RTE(); this is added by the IEV_C_FUNCT } //*************************************************************************** /******************************************************************************\ ** Irq7_ISR Interrupt handler for IRQ7 \******************************************************************************/ IEV_C_FUNCT( Irq7_ISR ) { // ISR when a spurious interrupt #pragma unused(ievstack) IRQ_Flag = IRQ7_F; // set global flag that RxD occurred // RTE(); this is added by the IEV_C_FUNCT } //*************************************************************************** /******************************************************************************\ ** zeroDivision Interrupt handler for divide-by-zero \******************************************************************************/ IEV_C_FUNCT( Div0_ISR ) { // ISR when a divide-by-zero #pragma unused(ievstack) IRQ_Flag = DIV0_F; // set global flag that divide-by-zero occurred all.exc->exc_stat |= 0x8000; // flag that it is a divide-by-zero // RTE(); this is added by the IEV_C_FUNCT } //***************************************************************************