EasyFuse_Prog.cpp

00001 #include "mbed.h"
00002 
00003 extern Serial pc;
00004 extern int frequ; //unit kHz
00005 extern char dev_addr; //fixed
00006 
00007 char get_half_byte(int *); //defined in I2C_read.cpp
00008  
00009 
00010 char get_byte(int *flag) {
00011     char cur_char;
00012     char temp;
00013     int flag1 = 0;
00014     cur_char = get_half_byte(&flag1); 
00015     if (flag1 == 1) {
00016         cur_char = cur_char << 4;
00017         temp = get_half_byte(&flag1);
00018         cur_char = (cur_char | temp);
00019     }
00020     *flag = flag1;
00021     return cur_char;
00022 }     
00023 
00024 void print_nvm_reg(uint8_t *max_Vout, uint8_t *max_Vout_trim, uint8_t *high_time, uint8_t *low_time, uint8_t *adc_samp_rate, 
00025 uint8_t *adc_range, uint8_t *adc_time_out, uint8_t *comp_offset, uint8_t *range_trim, uint8_t *PMOS_off, uint8_t *Driver2, uint8_t *Driver3, 
00026 uint8_t *neg_hlf_rng, uint8_t *CCM_threshold, uint8_t *DMOS_ctrl_trim, uint8_t *adc_op_mode) {
00027 
00028     pc.printf("\033[%dm ", 35);//change text color to red
00029     pc.printf("\n\n\n\r\t    Register contents :\n\r\t   ");
00030     for ( int i = 0; i<26; i++) pc.printf("\304"); 
00031     if (*PMOS_off == 0x0f) // ACP Mode
00032     {
00033         pc.printf("\n\n\r\t\t    ACP Mode \n\n");
00034         pc.printf("\n\n\r\t    1. max_Vout        = 0x%2.2X",*max_Vout);
00035         pc.printf("\n\n\r\t    2. max_Vout_trim   = 0x%2.2X",*max_Vout_trim);
00036         pc.printf("\n\n\r\t    3. high_time       = 0x%2.2X",*high_time);
00037         pc.printf("\n\n\r\t    4. low_time        = 0x%2.2X",*low_time);
00038         pc.printf("\n\n\r\t    5. adc_samp_rate   = 0x%2.2X",*adc_samp_rate);
00039         pc.printf("\n\n\r\t    6. adc_range       = 0x%2.2X",*adc_range);
00040         pc.printf("\n\n\r\t    7. adc_time_out    = 0x%2.2X",*adc_time_out);
00041         pc.printf("\n\n\r\t    8. comp_offset     = 0x%2.2X",*comp_offset);
00042         pc.printf("\n\n\r\t    9. range_trim      = 0x%2.2X",*range_trim);
00043         pc.printf("\n\n\r\t   10. PMOS_off        = 0x%2.2X",*PMOS_off);
00044         pc.printf("\n\n\r\t   13. SkipPwr         = 0x%2.2X",*neg_hlf_rng);
00045         pc.printf("\n\n\r\t   16. adc_op_mode     = 0x%2.2X",*adc_op_mode);
00046         pc.printf("\n\n\r\t   ");
00047     }
00048     else
00049     {
00050         pc.printf("\n\n\r\t\t    BiP Mode \n\n");       
00051         pc.printf("\n\n\r\t    1. max_Vout        = 0x%2.2X",*max_Vout);
00052         pc.printf("\n\n\r\t    2. max_Vout_trim   = 0x%2.2X",*max_Vout_trim);
00053         pc.printf("\n\n\r\t    3. high_time       = 0x%2.2X",*high_time);
00054         pc.printf("\n\n\r\t    4. low_time        = 0x%2.2X",*low_time);
00055         pc.printf("\n\n\r\t    5. adc_samp_rate   = 0x%2.2X",*adc_samp_rate);
00056         pc.printf("\n\n\r\t    6. adc_range       = 0x%2.2X",*adc_range);
00057         pc.printf("\n\n\r\t    7. adc_time_out    = 0x%2.2X",*adc_time_out);
00058         pc.printf("\n\n\r\t    8. comp_offset     = 0x%2.2X",*comp_offset);
00059         pc.printf("\n\n\r\t    9. range_trim      = 0x%2.2X",*range_trim);
00060         pc.printf("\n\n\r\t   10. PMOS_off        = 0x%2.2X",*PMOS_off);
00061         pc.printf("\n\n\r\t   11. Driver2         = 0x%2.2X",*Driver2);
00062         pc.printf("\n\n\r\t   12. Driver3         = 0x%2.2X",*Driver3);
00063         pc.printf("\n\n\r\t   13. neg_hlf_rng     = 0x%2.2X",*neg_hlf_rng);
00064         pc.printf("\n\n\r\t   14. CCM_threshold   = 0x%2.2X",*CCM_threshold);
00065         pc.printf("\n\n\r\t   15. DMOS_ctrl_trim  = 0x%2.2X",*DMOS_ctrl_trim);
00066         pc.printf("\n\n\r\t   16. adc_op_mode     = 0x%2.2X",*adc_op_mode);
00067         pc.printf("\n\n\r\t   ");
00068     }                
00069     for ( int i = 0; i<26; i++) pc.printf("\315");
00070     pc.printf("\033[%dm", 32);//change text color to green
00071     pc.printf("\n\r");    
00072 }   
00073 
00074 void edit_nvm_reg(uint8_t *max_Vout, uint8_t *max_Vout_trim, uint8_t *high_time, uint8_t *low_time, uint8_t *adc_samp_rate, 
00075 uint8_t *adc_range, uint8_t *adc_time_out, uint8_t *comp_offset, uint8_t *range_trim, uint8_t *PMOS_off, uint8_t *Driver2, uint8_t *Driver3, 
00076 uint8_t *neg_hlf_rng, uint8_t *CCM_threshold, uint8_t *DMOS_ctrl_trim, uint8_t *adc_op_mode) {
00077 
00078     char temp;
00079     int flag1;
00080     char count;
00081     char reg_data;
00082     
00083     char reg_name[16][20] = {"max_Vout", "max_Vout_trim", "high_time", "low_time", "adc_samp_rate", 
00084                             "adc_range", "adc_time_out", "comp_offset", "range_trim", "PMOS_off", "Driver2", "Driver3", 
00085                             "neg_hlf_rng_SkipPwr", "CCM_threshold", "DMOS_ctrl_trim", "adc_op_mode" };
00086 
00087     uint8_t *reg_addr[16] =  {   max_Vout, max_Vout_trim, high_time, low_time, adc_samp_rate, 
00088                             adc_range, adc_time_out, comp_offset, range_trim, PMOS_off, Driver2, Driver3, 
00089                             neg_hlf_rng, CCM_threshold, DMOS_ctrl_trim, adc_op_mode};
00090                             
00091     pc.printf("\n\n\n \r\tDo you want to edit the registers? (y/n) : ");  
00092     temp = 0;
00093     while ( temp!='y' && temp!='n') {
00094         temp = pc.getc();
00095     }
00096     if (temp == 'n') {
00097         pc.printf("\n\n \r\tContinuing with above contents");
00098         return;
00099     }
00100     temp = 'y';
00101     while (temp =='y') {
00102             //get selection
00103             flag1 = 0;
00104             while (!flag1) {
00105                     pc.printf("\n\n\n\r\tEnter (1 - 16) to select the register to edit and hit 'enter' key: ");
00106                     temp = '0';
00107                     count = 0;
00108                     while (temp != '\r') {  //look for enter key
00109                         count = (count * 10) + (temp - '0');  // converting to number
00110                         temp = pc.getc();
00111                         if ((temp < '0' || temp > '9') && temp !='\r') {
00112                             pc.printf(" \n\r\t\033[%dm Invalid Chracter!! No worries, let us try again \033[%dm",41,40);
00113                             break;
00114                         }
00115                     }
00116                     if (count >= 1 && count <= 16 && temp == '\r') flag1 = 1;
00117                     else if (temp == '\r') pc.printf(" \n\r\t\033[%dm Invalid Chracter!! No worries, let us try again \033[%dm",41,40);
00118             }  
00119             count = count - 1; //array starts from 0
00120             //Read New Register Data
00121             flag1 = 0;
00122             while (!flag1) {
00123                 pc.printf("\n\n \r\tEnter new value in hex (00 to ff) for \033[%dm %s \033[%dm register : ",35,reg_name[count],32);
00124                 reg_data = get_half_byte(&flag1); 
00125                 if (flag1 == 1) {
00126                     reg_data = reg_data << 4;
00127                     temp = get_half_byte(&flag1);
00128                     reg_data = (reg_data | temp);
00129                 }
00130                 if (flag1==0) pc.printf(" \033[%dm Invalid Chracter!! No worries, let us try again \033[%dm",41,40);
00131             }       
00132             *(reg_addr[count]) = reg_data;
00133             
00134             print_nvm_reg(  max_Vout, max_Vout_trim, high_time, low_time, adc_samp_rate, 
00135                         adc_range, adc_time_out, comp_offset, range_trim, PMOS_off, Driver2, Driver3, 
00136                         neg_hlf_rng, CCM_threshold, DMOS_ctrl_trim, adc_op_mode);
00137             
00138             pc.printf("\n\n \r\tDo you want to make more changes? (y/n) : ");
00139             temp = pc.getc();
00140     }  //end of edit while loop
00141 }
00142         
00143 void i2c_write_fn(I2C *i2c_obj, char ptr, char write_data) {
00144     int flag1;
00145     wait_us(20);
00146     (*i2c_obj).start();
00147     flag1 = (*i2c_obj).write(dev_addr);
00148     if (flag1 != 1) pc.printf("\n\n\r\tNo Ack for dev addr :(");
00149     flag1 = (*i2c_obj).write(ptr);
00150     if (flag1 != 1) pc.printf("\n\n\r\tNo Ack reg pointer :(");    
00151     flag1 = (*i2c_obj).write(write_data); 
00152     if (flag1 != 1) pc.printf("\n\n\r\tNo Ack data :(");           
00153     wait_us(20);
00154     (*i2c_obj).stop();
00155     wait_us(300);
00156 }
00157 
00158 char i2c_read_fn(I2C *i2c_obj, char ptr) {
00159     int flag1;
00160     char read_data;
00161     wait_us(10);
00162     (*i2c_obj).start();
00163     flag1 = (*i2c_obj).write(dev_addr); 
00164     if (flag1 != 1) pc.printf("\n\n\n\r\tNo Ack for dev addr :(");
00165     flag1 = (*i2c_obj).write(ptr);
00166     if (flag1 != 1) pc.printf("\n\n\r\tNo Ack reg pointer :(");
00167     (*i2c_obj).stop();
00168     wait_us(300);
00169     (*i2c_obj).start();
00170     flag1 = (*i2c_obj).write(dev_addr | 0x01); //lsb 1 for read
00171     if (flag1 != 1) pc.printf("\n\n\r\tNo Ack for dev addr :(");         
00172     read_data = (*i2c_obj).read(0); //0- donot send ack after read is done         
00173     wait_us(5);
00174     (*i2c_obj).stop();      
00175     wait_us(300);
00176     return read_data;
00177 }
00178 
00179 uint64_t EasyFuse_read(I2C *i2c_obj)    {
00180     char reg_ptr = 0x00;
00181     char reg_data[10];
00182     char data;
00183     uint8_t NVM_PWR_ON      = 0x20 ;
00184     uint8_t NVM_READ        = 0x90 ;  //force load shadow register
00185     uint8_t NVM_CTLR_ADR    = 0x0a ;  //Register address for NVM CTRL
00186     uint64_t NVM_data = 0x0000000000000000;
00187     
00188     //Variables to store read data
00189     uint8_t max_Vout;
00190     uint8_t max_Vout_trim;
00191     uint8_t high_time;
00192     uint8_t low_time;
00193     uint8_t adc_samp_rate;
00194     uint8_t adc_range;
00195     uint8_t adc_time_out;
00196     uint8_t comp_offset;
00197     uint8_t range_trim;
00198     uint8_t PMOS_off;
00199     uint8_t Driver2;
00200     uint8_t Driver3;
00201     uint8_t neg_hlf_rng;
00202     uint8_t CCM_threshold;
00203     uint8_t DMOS_ctrl_trim;
00204     uint8_t adc_op_mode;
00205     
00206     int i;
00207     char temp;
00208     
00209     pc.printf("\n\n\n\r\t"); 
00210     for ( i = 0; i<60; i++) pc.printf("\304");   
00211     pc.printf("\n\n\n\r\tPerforming an NVM read and loading the contents to the register");
00212     pc.printf("\n\n\r\tSwitching to faster clock before reading the NVM");    
00213     i2c_write_fn(i2c_obj,0x02,0x01); //switching to faster clock for NVM read
00214     i2c_write_fn(i2c_obj,0x03,0x01); //switching to faster clock for NVM read
00215     i2c_write_fn(i2c_obj,NVM_CTLR_ADR,NVM_PWR_ON);
00216     wait_ms(1);
00217     i2c_write_fn(i2c_obj,NVM_CTLR_ADR,(NVM_PWR_ON + NVM_READ)); //Force load shadow register from NVM    
00218     wait_ms(200);
00219 
00220     pc.printf("\n\n\n\r\tReading register 0x00 to 0x09");
00221     for( reg_ptr = 0x00;  reg_ptr <= 0x09; reg_ptr = reg_ptr+1) {
00222         reg_data[reg_ptr] = i2c_read_fn(i2c_obj,reg_ptr);
00223     }           
00224     
00225     //Storing read data into variables
00226     max_Vout        = reg_data[0] & 0x0f;
00227     max_Vout_trim   = reg_data[1] & 0x1f;
00228     high_time       = reg_data[2] & 0x7f;
00229     low_time        = reg_data[3] & 0x7f;
00230     adc_samp_rate   = reg_data[4]>>4;
00231     adc_range       = (reg_data[4]>>2) & 0x03;
00232     adc_time_out    = reg_data[4] & 0x03;
00233     comp_offset     = reg_data[5] & 0x1f;
00234     range_trim      = reg_data[6] & 0x1f;
00235     PMOS_off        = reg_data[7] & 0x0f;
00236     Driver2         = reg_data[8] & 0x0f;
00237     Driver3         = (reg_data[8]>>4) & 0x0f;
00238     neg_hlf_rng     = (reg_data[9]>>7) & 0x01;
00239     CCM_threshold   = (reg_data[7]>>4) & 0x0f;
00240     DMOS_ctrl_trim  = reg_data[9] & 0x1f;
00241     adc_op_mode     = (reg_data[5]>>7) & 0x01;
00242 
00243     pc.printf("\n\n\r\tFollowing data was read from the Register");
00244 
00245     print_nvm_reg(&max_Vout, &max_Vout_trim, &high_time, &low_time, &adc_samp_rate, 
00246     &adc_range, &adc_time_out, &comp_offset, &range_trim, &PMOS_off, &Driver2, &Driver3, 
00247     &neg_hlf_rng, &CCM_threshold, &DMOS_ctrl_trim, &adc_op_mode);
00248     
00249     //push data into NVM_data
00250     NVM_data =  NVM_data | (max_Vout); //max_Vout(register) = max_Vout(NVM) - 1// this needs to be changed
00251     NVM_data = (NVM_data<<5) | max_Vout_trim; 
00252     NVM_data = (NVM_data<<7) | high_time; // <<x : x corresponds to no. of bits
00253     NVM_data = (NVM_data<<7) | low_time;
00254     NVM_data = (NVM_data<<4) | adc_samp_rate;
00255     NVM_data = (NVM_data<<2) | adc_range;
00256     NVM_data = (NVM_data<<2) | adc_time_out;
00257     NVM_data = (NVM_data<<5) | comp_offset;
00258     NVM_data = (NVM_data<<5) | range_trim;
00259     NVM_data = (NVM_data<<4) | PMOS_off;
00260     NVM_data = (NVM_data<<4) | Driver2;
00261     NVM_data = (NVM_data<<4) | Driver3;
00262     NVM_data = (NVM_data<<1) | neg_hlf_rng;
00263     NVM_data = (NVM_data<<4) | CCM_threshold;
00264     NVM_data = (NVM_data<<5) | DMOS_ctrl_trim;
00265     NVM_data = (NVM_data<<1) | adc_op_mode;    
00266 
00267     pc.printf("\n\n\n\r\tReconstructed data read from NVM = 0x%016llX",NVM_data);   
00268     return NVM_data;        
00269 }    
00270 
00271 
00272 void EasyFuse_prog() {
00273     uint64_t NVM_data = 0x0000000000000000;
00274     uint64_t NVM_read_data;
00275     
00276     // Register variables
00277     uint8_t max_Vout = 0x00; //4.2V
00278     uint8_t max_Vout_trim = 0x03; //0%
00279     uint8_t high_time = 0x11; //12us 
00280     uint8_t low_time = 0x46; //38us 
00281     uint8_t adc_samp_rate = 0x05; //1 sample/1.35s
00282     uint8_t adc_range = 0x01; //2mV
00283     uint8_t adc_time_out = 0x02; // 1/256 = 5.3ms
00284     uint8_t comp_offset = 0x00; //0% 
00285     uint8_t range_trim = 0x16; //0% 
00286     uint8_t PMOS_off = 0x07; //7 -> 18mV 
00287     uint8_t Driver2 = 0x08; //8 -> 36mV
00288     uint8_t Driver3 = 0x08; // 8 -> 54mV
00289     uint8_t neg_hlf_rng = 0x00; //disabled
00290     uint8_t CCM_threshold = 0x00; //off 
00291     uint8_t DMOS_ctrl_trim = 0x16; //<14us
00292     uint8_t adc_op_mode = 0x00; //Transmit measurements continously 
00293 
00294     // NVM Register Control Bit locations; 
00295     uint8_t NVM_RESET       = 0x01 ;
00296     uint8_t NVM_PWE1        = 0x02 ;
00297     uint8_t NVM_CLK1        = 0x04 ;
00298     uint8_t NVM_PWR_ON      = 0x20 ;
00299     uint8_t NVM_LD_SHDW     = 0x90 ;//unpdated in Rev1.0
00300     uint8_t NVM_READ        = 0x50 ;    
00301     
00302     uint8_t NVM_CTLR_ADR    = 0x0a ;  //Register address for NVM CTRL
00303      
00304     char reg_data = 0xaa;
00305     char temp;
00306     char high_time_prog = 0x04;
00307     char low_time_prog = 0x05;
00308     int flag1 = 0;
00309     int i = 0;
00310     
00311     int delay1 = 20;
00312     int delay2 = 2 * delay1;
00313     
00314     I2C i2c(p9,p10);
00315     i2c.frequency((frequ/2)*1000);
00316     LPC_PINCON->PINMODE_OD0 = (LPC_PINCON->PINMODE_OD0  | 0x0003); // To make p9 & P10 open_drain
00317     i2c.stop(); //add a stop after hot-read 
00318 
00319     pc.printf("\n\n\r\tFollowing are the default register data that will be programmed: \n\r ");
00320     print_nvm_reg(&max_Vout, &max_Vout_trim, &high_time, &low_time, &adc_samp_rate, 
00321     &adc_range, &adc_time_out, &comp_offset, &range_trim, &PMOS_off, &Driver2, &Driver3, 
00322     &neg_hlf_rng, &CCM_threshold, &DMOS_ctrl_trim, &adc_op_mode);    
00323 
00324     edit_nvm_reg(&max_Vout, &max_Vout_trim, &high_time, &low_time, &adc_samp_rate, 
00325     &adc_range, &adc_time_out, &comp_offset, &range_trim, &PMOS_off, &Driver2, &Driver3, 
00326     &neg_hlf_rng, &CCM_threshold, &DMOS_ctrl_trim, &adc_op_mode);       
00327       
00328     //push data into NVM_data
00329     NVM_data =  NVM_data | max_Vout; //no more addition of 1 as in Jacaranda
00330     NVM_data = (NVM_data<<5) | max_Vout_trim; 
00331     NVM_data = (NVM_data<<7) | high_time; // <<x : x corresponds to no. of bits
00332     NVM_data = (NVM_data<<7) | low_time;
00333     NVM_data = (NVM_data<<4) | adc_samp_rate;
00334     NVM_data = (NVM_data<<2) | adc_range;
00335     NVM_data = (NVM_data<<2) | adc_time_out;
00336     NVM_data = (NVM_data<<5) | comp_offset;
00337     NVM_data = (NVM_data<<5) | range_trim;
00338     NVM_data = (NVM_data<<4) | PMOS_off;
00339     NVM_data = (NVM_data<<4) | Driver2;
00340     NVM_data = (NVM_data<<4) | Driver3;
00341     NVM_data = (NVM_data<<1) | neg_hlf_rng;
00342     NVM_data = (NVM_data<<4) | CCM_threshold;
00343     NVM_data = (NVM_data<<5) | DMOS_ctrl_trim;
00344     NVM_data = (NVM_data<<1) | adc_op_mode;
00345     pc.printf("\n\n\n\r\tData to be written into NVM = 0x%016llX",NVM_data);
00346     pc.printf("\n\n\r\t"); 
00347     for ( i = 0; i<80; i++) pc.printf("\304");  
00348     pc.printf("\n\n\r\tContinue EasyFuse Programming? (y/n): ");  
00349     temp = 0;
00350     while ( temp!='y' && temp!='n') {
00351         temp = pc.getc();
00352     }
00353     if (temp == 'n') {
00354         pc.printf("\n\n\r\tAborting... :(");
00355         return;
00356     }
00357     temp = 0;
00358     pc.printf("\n\n\n\r\tConnect PROG to 4.5V & VINA to 4.5V and press 'c' to continue"); 
00359     while ( temp!='c') {
00360         temp = pc.getc();
00361     }
00362     //EasyFuse Empty check
00363     pc.printf("\n\n\r\tPerforming NVM Empty check by trying to load register with NVM contents.");
00364     i2c_write_fn(&i2c,0x02,0x01); //switching to faster clock for NVM read
00365     i2c_write_fn(&i2c,0x03,0x01); //switching to faster clock for NVM read
00366     wait_ms(1);
00367     i2c_write_fn(&i2c,NVM_CTLR_ADR,NVM_PWR_ON); 
00368     wait_ms(1);       
00369     i2c_write_fn(&i2c,NVM_CTLR_ADR,(NVM_READ + NVM_PWR_ON)); //Initiate NVM read cycle    
00370     wait_ms(200);
00371           
00372     reg_data = i2c_read_fn(&i2c,0x02);
00373     reg_data = reg_data<<4;
00374     reg_data = reg_data | i2c_read_fn(&i2c,0x03);
00375     if (reg_data == 0xff) pc.printf("  |\033[%dm  Register read might not be sucessfull \033[%dm ",45,40);
00376     if (reg_data == 0x11) pc.printf("\n\n\r\t\033[%dm EasyFuse empty \033[%dm",44,40); //NVM load will be successful only when NVM is not empty
00377     else {
00378         pc.printf("\n\n\r\t\033[%dm EasyFuse not empty \033[%dm",45,40);
00379         pc.printf("\n\n\r\t Better to abort the test.. :(");
00380         //return;
00381     }         
00382     
00383     //added for debug.. delete later
00384     pc.printf("\n\n\n\r\tWe will next configure the oscillator. Proceed? (y/n): ");  
00385     temp = 0;
00386     while ( temp!='y' && temp!='n') {
00387         temp = pc.getc();
00388     }
00389     if (temp == 'n') {
00390         pc.printf("\n\n\r\tAborting.. :(");
00391         return;
00392     }
00393     
00394     i2c_write_fn(&i2c,0x17,0x01); //internal clock is muxed out through DATA2_CLK
00395     pc.printf("\n\n\r\tMonitor Clock at DATA2_CLK pin");       
00396 
00397 osc_trim:
00398     i2c_write_fn(&i2c,0x02,high_time_prog); //Recommended clocks period 
00399     i2c_write_fn(&i2c,0x03,low_time_prog); // for programming is 10us
00400     wait_ms(1);
00401 
00402     pc.printf("\n\n\n\r\t\033[%dm", 44);//change backround to blue
00403     pc.printf("Please check if Oscillator period is approx 10us (9.5us to 10.5us) \033[%dm\n\n\r\tPress 'y' to continue; Press 'm' to modify clock trim settings : ",40); 
00404 
00405     temp = 0;
00406     while ( temp!='y' && temp!='m' && temp!='n' ) {
00407         temp = pc.getc();
00408     }
00409     if (temp == 'n') {
00410         pc.printf("\n\n\r\tAborting.. :(");
00411         return;
00412     }
00413     if (temp == 'm') {
00414         pc.printf("\n\n\n\n\r\tCurrent high_time trim = 0x%2.2X  & low_time trim = 0x%2.2X",high_time_prog,low_time_prog);
00415         pc.printf("\n\n\r\tSuggestion - Change high_trim first then low_trim");
00416         flag1 = 0;
00417         while (!flag1) {
00418             pc.printf("\n\n\r\tEnter new high_time trim in hex (00 to ff): 0x");
00419             high_time_prog = get_byte(&flag1);
00420             if (flag1 == 0) pc.printf(" \033[%dm Invalid Chracter!! No worries, let us try again \033[%dm",41,40);
00421         } 
00422         flag1 = 0;
00423         while (!flag1) {
00424             pc.printf("\n\n\r\tEnter new low_time trim in hex (00 to ff) : 0x");
00425             low_time_prog = get_byte(&flag1);
00426             if (flag1 == 0) pc.printf(" \033[%dm Invalid Chracter!! No worries, let us try again \033[%dm",41,40);
00427         }        
00428         pc.printf("\n\n\r\tProgramming new high_time trim = 0x%2.2X  & new low_time trim = 0x%2.2X",high_time_prog,low_time_prog);
00429         goto osc_trim;
00430     }
00431     i2c_write_fn(&i2c,0x17,0x00); //DATA2_CLK pulled to GND 
00432     i2c_write_fn(&i2c,0x10,0x04); //tm_ProgSamp_en = 1, needed to disable pull-up device between VINA & PROG        
00433     pc.printf("\n\n\r\tDATA2_CLK pulled low");     
00434     wait_ms(delay2); 
00435     pc.printf("\n\n\n\r\tAll set to program the EasyFuse, time to blow up some ploy fuses! ..**BOOOM**\n\n\r"); 
00436 
00437     temp = 0;
00438     pc.printf("\n\n\n\r\tConnect PROG to 4.5V & VINA to 5V and press 'c' to continue"); 
00439     while ( temp!='c') {
00440         temp = pc.getc();
00441     }
00442     i2c_write_fn(&i2c,NVM_CTLR_ADR,NVM_PWR_ON); //turn ON supply to EasyFuse
00443     wait_ms(100);    
00444     i2c_write_fn(&i2c,NVM_CTLR_ADR,(NVM_RESET + NVM_PWR_ON)); //turn ON supply to EasyFuse & RESETN = 1
00445     wait_ms(1);
00446     i2c_write_fn(&i2c,NVM_CTLR_ADR,NVM_PWR_ON); //RESETN = 0, Prog mode enabled: CKL1 = 0 during RESETN = 0,
00447     
00448     pc.printf("\n\n\n\r\t");
00449     wait_us(delay2);
00450     i2c_write_fn(&i2c,NVM_CTLR_ADR,(NVM_RESET + NVM_PWR_ON));  //RESETN = 1
00451     wait_us(delay2);           
00452     for ( i = 0; i < 64; i = i+1) {
00453         if ( ((NVM_data>>i) & 0x0000000000000001) == 1 ) {
00454             temp = NVM_PWE1;
00455             pc.printf("1");
00456         }
00457         else { 
00458             temp = 0x00;
00459             pc.printf("0");
00460         }
00461         temp =  (temp | NVM_RESET | NVM_PWR_ON); //NVM_PWE1 if NVM_data[i]=1 & CLK1 de-asserted
00462         //pc.printf("\n\n\n\n\r\ttemp = 0x%2.2X",temp);
00463         i2c_write_fn(&i2c,NVM_CTLR_ADR,temp);
00464         //wait_us(delay2);
00465         temp =  (NVM_RESET | NVM_PWR_ON);
00466         i2c_write_fn(&i2c,NVM_CTLR_ADR,temp); //de-assert NVM_PWE1
00467         wait_us(delay2);          
00468         temp =  (NVM_RESET | NVM_CLK1 | NVM_PWR_ON);
00469         i2c_write_fn(&i2c,NVM_CTLR_ADR,temp); //assert CLK1
00470         wait_us(delay2); 
00471     }
00472 
00473     pc.printf("\n\n\n\r\t\a\033[%dm", 44);//change backround to blue
00474     //pc.printf("Finished programming. Let us confirm if the NVM has been programmed correctly by reading the NVM. Proceed (y/n): ");
00475     pc.printf("Finished programming. Let us confirm if the NVM has been programmed correctly by reading the NVM.");    
00476     pc.printf("\033[%dm", 40);//change backround to black 
00477     pc.printf("\n\n\n\r\tReduce PROG to 4.2V & VINA to 4.2V and press 'c' to continue");     
00478     while ( temp!='c') {
00479         temp = pc.getc();
00480     }        
00481     i2c_write_fn(&i2c,0x10,0x00); //tm_ProgSamp_en = 0,    
00482     wait_ms(1);          
00483     //temp = 0;
00484     //while ( temp!='y' ) {
00485     //    temp = pc.getc();
00486     //}
00487     NVM_read_data = EasyFuse_read(&i2c);
00488     if ( NVM_data == NVM_read_data ) pc.printf("\n\n\r\tData written into NVM matches data read from NVM\n\n\n\r\t\033[%dm NVM PROGRAMMING SUCESSFULL. Hoorayyy!\a \033[%dm\n\r",44,40);
00489     else  pc.printf("\n\n\r\tuh-oh.. Data written into NVM does not match data read from NVM\n\n\n\r\t\033[%dm NVM PROGRAMMING FAILED!\a \033[%dm\n\r",41,40);    
00490 }