mbed code for Farrari board

Dependencies:   DDRO_Farrari mbed

Fork of DDRO_Farrari by Liangzhen Lai

Embed: (wiki syntax)

« Back to documentation index

Show/hide line numbers main.cpp Source File

main.cpp

00001 
00002 #include "mbed.h"
00003 #include "dac.h"
00004 #include "board_test.h"
00005 #include "scan.h"
00006 #include "power.h"
00007 #include "pinout.h"
00008 #include "pll.h"
00009 #include "lcd.h"
00010 #include "jtag.h"
00011 #include "mmap.h"
00012 #include "clock.h"
00013 #include "EasyBMP.h"
00014 #include "main.h"
00015 
00016 //#define WRITE_RESULTS
00017 FILE *results_file;
00018 
00019 DigitalOut myled(LED4);
00020 #ifdef WRITE_RESULTS
00021 //LocalFileSystem local("local");               // Create the local filesystem under the name "local"
00022 #endif
00023 
00024 int main()
00025 {
00026     float core_volt = 1;
00027 #ifdef WRITE_RESULTS
00028     results_file=fopen("/local/results.txt", "a");  // Open "out.txt" on the local file system for writing
00029 #endif
00030 
00031     // power up the board
00032     pc.printf("Begin\r\n");
00033     power_down();
00034     power_up(core_volt); // Power Up Chip
00035     pc.printf("Powered up!\r\n");
00036     pc.printf("Start reading IDCode...\r\n");
00037 
00038     // initializing the resets
00039     PORESETn = 0;
00040     CORERESETn = 0;
00041     wait_us(100);
00042     PORESETn = 1;
00043     CORERESETn = 1;
00044     JTAG jtag;
00045 
00046     // read and verify chip ID
00047     int idcode = jtag.readID();
00048     if(idcode != 0x4ba00477) {
00049         pc.printf("ERROR: IDCode %X\r\n", idcode);
00050         wait(2);
00051         power_down();
00052         return -1;
00053     }
00054     pc.printf("IDCode %X\r\n", idcode);
00055 
00056     // power up the JTAG port
00057     jtag.reset();
00058     jtag.leaveState();
00059     jtag.PowerupDAP();
00060 
00061     // setup necessary internal clock source selection
00062     jtag.writeMemory(intclk_source, 2);
00063     jtag.writeMemory(extclk_source, 1);
00064     jtag.writeMemory(ext_div_by, 10);
00065 
00066     float voltage=1;
00067     power_core(voltage);
00068     pc.printf("V: %f\r\n", voltage);
00069 
00070     // load program
00071     if(jtag.loadProgram()) {
00072         dual_printf("Load Failed");
00073         exit(1);
00074     }
00075     
00076     // reset the core and let it run
00077     CORERESETn = 0;
00078     CORERESETn = 1;
00079     wait(0.2);
00080     
00081     // open the JTAG port again
00082     jtag.reset();
00083     jtag.leaveState();
00084     jtag.PowerupDAP();
00085     
00086     // verify the output here with the following functions
00087     // unsigned int readMemory(unsigned int address);
00088     // void writeMemory(unsigned int address, unsigned int value);
00089     
00090     
00091     pc.printf("Powering Down\r\n");
00092     power_down();
00093     pc.printf("Done\r\n");
00094     while(1) {
00095         myled = 1;
00096         wait(0.2);
00097         myled = 0;
00098         wait(0.2);
00099     }
00100 }
00101 
00102 int check_FFT_Freq(JTAG &jtag, int fMHz)
00103 {
00104     if(jtag.loadProgram()) {
00105         dual_printf("Load Failed");
00106         exit(1);
00107     }
00108     set_pll_frequency (fMHz, jtag);
00109     //dual_printf("Resetting");
00110     CORERESETn = 0;
00111     CORERESETn = 1;
00112     wait(0.2);
00113     jtag.reset();
00114     jtag.leaveState();
00115     jtag.PowerupDAP();
00116     unsigned int buffer_fft[64];
00117     for (int number1=0; number1<=63; number1++) {
00118         buffer_fft[number1] = jtag.readMemory(0x24000100 + number1*4);
00119         jtag.writeMemory(0x24000100 + number1*4,0xF0F0F0F0);
00120         //printf("new[%d]: %d\r\n", number1, buffer_fft[number1]);
00121     }
00122     if ( buffer_fft[0] == 0x0000fffc && buffer_fft[1]==0x0000fffd && buffer_fft[2]==0xffc0000a && buffer_fft[3]==0x0000fffe &&
00123             buffer_fft[4]==0x0000fffd && buffer_fft[5]==0x0000ffff && buffer_fft[6]==0x0000fffd && buffer_fft[7]==0x00000000 &&
00124             buffer_fft[8]==0x0000ffff && buffer_fft[9]==0x0000ffff && buffer_fft[10]==0xfffeffff && buffer_fft[11]==0xffff0000 &&
00125             buffer_fft[12]==0x0000ffff && buffer_fft[13]==0xffff0000 && buffer_fft[14]==0xfffffffe && buffer_fft[15]==0xffff0000 &&
00126             buffer_fft[16]==0x00010000  && buffer_fft[17]==0x0001ffff && buffer_fft[18]==0x0000ffff && buffer_fft[19]==0x0001ffff &&
00127             buffer_fft[20]==0x0001fffe && buffer_fft[21]==0x0000fffe && buffer_fft[22]==0x0001fffe && buffer_fft[23]==0x0000ffff &&
00128             buffer_fft[24]==0x0000ffff && buffer_fft[25]==0x0001fffe && buffer_fft[26]==0x0000ffff && buffer_fft[27]==0x00010000 &&
00129             buffer_fft[28]==0x0001ffff && buffer_fft[29]==0x00010000 && buffer_fft[30]==0x0000ffff && buffer_fft[31]==0x00010000 &&
00130             buffer_fft[32]==0x0000ffff && buffer_fft[33]==0x0000ffff && buffer_fft[34]==0x0000ffff && buffer_fft[35]==0x0000ffff &&
00131             buffer_fft[36]==0x0000fffe && buffer_fft[37]==0x0000ffff && buffer_fft[38]==0x0000fffe && buffer_fft[39]==0x00000000 &&
00132             buffer_fft[40]==0xffffffff && buffer_fft[41]==0x0000ffff && buffer_fft[42]==0xffffffff && buffer_fft[43]==0x00000000 &&
00133             buffer_fft[44]==0x0000ffff && buffer_fft[45]==0x00000000 && buffer_fft[46]==0xffffffff && buffer_fft[47]==0x00000000 &&
00134             buffer_fft[48]==0x00000000 && buffer_fft[49]==0x00000000 && buffer_fft[50]==0x00000000 && buffer_fft[51]==0x00000000 &&
00135             buffer_fft[52]==0x0000ffff && buffer_fft[53]==0x0000ffff && buffer_fft[54]==0x0000ffff && buffer_fft[55]==0x00000000 &&
00136             buffer_fft[56]==0xfffeffff && buffer_fft[57]==0xffffffff && buffer_fft[58]==0xffff0000 && buffer_fft[59]==0x00000000 &&
00137             buffer_fft[60]==0x0000ffff && buffer_fft[61]==0x00000000 && buffer_fft[62]==0x003d000c && buffer_fft[63]==0x00000000 ) {
00138         return 1;
00139     } else {
00140         return 0;
00141     }
00142 }
00143 
00144 void DDRO_Sensor(JTAG &jtag)
00145 {
00146     /**********************enable****************************************/
00147     jtag.writeMemory(ddro_syn_en, 0xffffffff);
00148     jtag.writeMemory(ddro_inv_en, 0xffffffff);
00149     /**********************set ref_clk and samp_clk**********************/
00150     jtag.writeMemory(ddro_ref_src, 0x00000002);
00151     /**********************write threshold*******************************/
00152     jtag.writeMemory(ddro_threshold, 100000);
00153     //jtag.writeMemory(0xe000e104, 0x000000ff); // enable interrupts
00154 
00155     for (int ro_id=3; ro_id<=15; ro_id++) {
00156         unsigned int meas1_s, meas1_e, meas2_s, meas2_e;
00157         int delta1, delta2;
00158         //pc.printf("RO %d\r\n ", ro_id-2);
00159         jtag.writeMemory(ddro_samp_src, ro_id);
00160         jtag.writeMemory(ddro_start, 0);
00161         meas1_s = jtag.readMemory(ddro_count);
00162         //pc.printf("Counter starts at: %d  ", meas1);
00163         jtag.writeMemory(ddro_start, 1);
00164         wait_us(50000);
00165         jtag.writeMemory(ddro_start, 0);
00166         meas1_e = jtag.readMemory(ddro_count);
00167         //pc.printf("ends at: %d\r\n", meas1);
00168         delta1 = meas1_e - meas1_s;
00169 
00170         jtag.writeMemory(ddro_samp_src, ro_id);
00171         jtag.writeMemory(ddro_start, 0);
00172         meas2_s = jtag.readMemory(ddro_count);
00173         //pc.printf("Counter starts at: %d  ", meas1);
00174         jtag.writeMemory(ddro_start, 1);
00175         wait_us(50000);
00176         jtag.writeMemory(ddro_start, 0);
00177         meas2_e = jtag.readMemory(ddro_count);
00178         delta2 = meas2_e - meas2_s;
00179         //printf("ends at: %d\r\n", meas1);
00180 
00181         if ( (float)delta2/meas1_e>=0.95 && (float)delta2/meas1_e<=1.05 ) {
00182             pc.printf("RO %d:  %d\r\n", ro_id, (delta2+meas1_e)/2);
00183 #ifdef WRITE_RESULTS
00184             fprintf(results_file,"RO %d:  %d\r\n", ro_id, (delta2+meas1_e)/2);
00185 #endif
00186         } else if ((float)delta1/meas2_e>=0.95 && (float)delta1/meas2_e<=1.05 ) {
00187             pc.printf("RO %d:  %d\r\n", ro_id, (delta1+meas2_e)/2);
00188 #ifdef WRITE_RESULTS
00189             fprintf(results_file,"RO %d:  %d\r\n", ro_id, (delta1+meas2_e)/2);
00190 #endif
00191         } else if ( (float)delta2/delta1 >=0.95 && (float)delta2/delta1<=1.05 ) {
00192             pc.printf("RO %d:  %d\r\n", ro_id, (delta1+delta2)/2);
00193 #ifdef WRITE_RESULTS
00194             fprintf(results_file,"RO %d:  %d\r\n", ro_id, (delta1+delta2)/2);
00195 #endif
00196         } else if ( (float)meas2_e/meas1_e >=0.95 && (float)meas2_e/meas1_e<=1.05 ) {
00197             pc.printf("RO %d:  %d\r\n", ro_id, (meas1_e+meas2_e)/2);
00198 #ifdef WRITE_RESULTS
00199             fprintf(results_file,"RO %d:  %d\r\n", ro_id, (meas1_e+meas2_e)/2);
00200 #endif
00201         } else {
00202             pc.printf("Error in measuring DDRO %d\r\n", ro_id);
00203 #ifdef WRITE_RESULTS
00204             fprintf(results_file,"Error in measuring DDRO %d\r\n", ro_id);
00205 #endif
00206         }
00207     }
00208 }