ILF
/
mbed_ILF
Important changes to repositories hosted on mbed.com
Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.
To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.
It is also possible to export all your personal repositories from the account settings page.
Dependencies: mbed SDFileSystem
Embed:
(wiki syntax)
Show/hide line numbers
ILF3_rev1.cpp
00001 #include "mbed.h" 00002 #include "SDFileSystem.h" 00003 00004 00005 //difine_mbed_LPC1768 00006 00007 /******************************************************************************* 00008 00009 2022.4.8 00010 ILF V3 Iop汎用器 00011 00012 ver3.0.0 2022.4.8 tanaka 00013 mbed_ILF ver1.2.5を引継ぎ 00014 ILF3のハードに合せて改編する 00015 00016 1.EEPROMの変更 ONsemi製CAT24M01WI-GT3 00017 the CAT24M01 is a 1024kb serial CMOS EEPROM 00018 addres: 101010** 00019 00020 2.電圧測定の平均化 00021 00022 00023 00024 ******************************************************************************/ 00025 /* 00026 仕様 00027 電圧/抵抗測定：12bit 00028 電流測定:14bit 00029 00030 割込みはP0~P2で可能 00031 シーケンサスタート信号は、回路図「seq_yobi]で対応 00032 00033 ver1.2.5 00034 IOP測定値にO.L追加 ±100uA 00035 00036 ver1.2.4 00037 ver1.2.3のDEB_EN=0としたもの。 00038 公開用。 00039 00040 ver1.2.3 00041 EEPROM通信のコードを修正。 00042 debug mode の追加 00043 00044 ver1.2.2 00045 過充電防止検査の上限規格の判定追加 00046 CAL情報登録画面において、登録項目の順序入替え（過充電防止上限規格の挿入） 00047 過充電防止上限規格ゼロの場合、判定しない 00048 00049 ver1.2.1 00050 過充電防止検査の上限規格を新たに設置。 00051 それに伴い、規格値のメモリ割り当てと、上限規格設定画面を追加。 00052 00053 ver1.2.0 00054 00055 2021.9.7 00056 00057 CAL.LJ21(A1098A05)専用 00058 発電検出時、高照度条件下でVSS電圧がIC耐圧超える為、VHD-VDD短絡する仕様へ変更（A05） 00059 200lx下でもVHD-VDD短絡の電圧条件を満たす為、ILFも対応。 00060 VSS端子でVOC測定をする。その為、VOC測定時以外はVSS端子と測定器を切り離すリレーを 00061 サブ基板へ取り付け、制御プログラムを追加した。 00062 CH1:P1_23(LPC1768) (led3_on) 00063 CH2:P1_22(LPC1768) (led3_off) 00064 00065 アンテナ測定時にアンテナ測定端子切り離し用リレーのON/OFF制御を追加 00066 (led4_on) 00067 (led4_off) 00068 00069 ver1.1.0 00070 1)VFD_SW23 SW31がタッチ感度故障の為、配置替え 00071 CAL登録画面とMANUAL測定画面 00072 2)DELETE EEPROM ボタンの配置変更 00073 3)シーケンサ判定IOの変更 00074 00075 ver1.1.1 00076 void auto_meas において初期 R[i]の値をクリアすることを追加 00077 自動測定時、タッチパネルでスタートをやめる（外部IO入力のみ） 00078 00079 ver1.1.2 00080 過充電防止検査時の電源電圧:VOC検査時の電圧となっていたのを修正。 00081 00082 ver1.1.3 00083 1)SDカード未挿入の表示を削除 00084 00085 2)R=Hの時間を0.2sから1sへ変更 00086 00087 R5186 ver2.0.3の内容を反映。 00088 00089 未）フラグでR5186系と切替え 00090 未）測定部ごとにクラス分け（過充電防止のところだけでも） 00091 00092 *******************************************************************************/ 00093 // 00094 //定数 00095 // 00096 //soft ver 00097 const int version_major = 3; 00098 const int version_minor = 0; 00099 const int version_build = 0; 00100 00101 const char pass[] = "ILF"; //password(大文字) 00102 #define YOSO 3 //password文字数 00103 00104 #define O_L 100 //[uA]電流測定値のオーバーロード値 //ver1.2.5 00105 /* 00106 #define CAP 20 //[uF] 積分回路のコンデンサ容量 00107 #define TIME_INT 2 //[s]積分時間 00108 #define GAIN_I 0.2 //電流測定プリアンプのGAIN 00109 #define LSB_I 0.00025 //[V] MCP3424 LSB size of 14bit conversion rate setting 00110 #define MINCODE_I -8192 //Minimum output code of MCP3424 00111 #define MAXCODE_I 8191 //Maximum output code of MCP3424 00112 #define GAIN_V 0.2 //電流測定プリアンプのGAIN 00113 */ 00114 #define DEB_EN 0 //デバッグイネーブル:1 ディスイネーブル:0 ver1.2.3 00115 #define RL_EN 0 //1:io[]を外付けのリードリレー制御用に使用する場合は1.以外は0. ver1.2.3 00116 #define SEQ_EN 0 //1:シーケンサ接続仕様 0:シーケンサ未接続仕様 00117 #define period_pwm 200 //*us 00118 #define COP 0.0039 //pwm_duty(%) = COP * DATA(0~255) ver3 0.005 -> 0.0039 00119 #define rsense 1000 //抵抗測定回路のプルアップ抵抗値 1kΩ 00120 #define res_vref 0x800 //抵抗測定回路のリファレンス電圧 2.048V 00121 #define dac_vref 2500 //DACのリファレンス電圧 単位[mV] 00122 #define number_of_channels 4 //測定チャンネル数（MAX 4) 00123 #define time_discharge 0.5 //discharging time(s) 00124 #define time_integral 2 //integral time(s) 00125 #define wait_voc_1 0.5 //[s]VOC測定電圧設定後からリセットまでの時間 00126 //#define wait_reset 0.3 //[s]リセット解除からVOC測定までの時間 00127 #define wait_poweron 4 //[s]電源投入からリセットまでの時間 00128 #define time_reset 0.5 //reset Hの時間 ver1.1.3 00129 #define TIME_RELAY_ON 0.5 //外付けリードリレー用 Ton[s] 00130 #define TIME_RELAY_OFF 0.2 //外付けリードリレー用 Toff[s] 00131 const int ton_rr = 0.1; //内蔵リードリレー ton[s] 00132 const int toff_rr = 0.1; //内蔵リードリレー toff] 00133 const bool tenken = true; //日常点検用 マニュアルモードにて True:測定CHのみVSS出力 False:全CH,VSS出力 00134 00135 //Display 00136 #define touch 5 //GU-D タッチパネル感度 0~7で設定。低いほど敏感。 00137 const char sw_up_set[] = {20,21,22,23}; //CAL情報セット画面におけるUPスイッチの表示位置番号 00138 const char sw_down_set[] = {28,29,30,31}; //CAL情報セット画面におけるDOWNスイッチの表示位置番号 00139 const int zahyou_para1[] = {0,2}; //CAL情報セット画面における項目の表示位置座標 00140 const int zahyou_para2[] = {0,4}; //CAL情報セット画面における項目の表示位置座標 00141 const int zahyou_val[] = {96,4}; //CAL情報セット画面における数値の表示位置座標 00142 const int zahyou_unit[] = {160,4}; //CAL情報セット画面における単位の表示位置座標 00143 const char *cpara1[]= { 00144 "IOP", //x=0 : vss_iop[V] 00145 "OCP", //x=1 : vss_ocp[V] 00146 "VOC", //x=2 : vss_voc[V] 00147 "VOC", //x=3 : low_limit_voc[V] 00148 "IOP", //x=4 : low_limit_iop[uA] 00149 "OCP", //x=5 : low_limit_ocp[uA] 00150 "OCP", //x=6 : up_limit_ocp[uA] 00151 "OCP", //x=7 : low_limit_ocp_v[V] 00152 "OCP", //x=8 : up_limit_ocp_v[V] 00153 "IOP", //x=9 : wait_iop[s] 00154 "OCP", //x=10 : wait_ocp[s] 00155 "VOC", //x=11 : wait_voc[s] 00156 "ANTENA", //x=12 : low_limit_resistor[Ω] 00157 "ANTENA", //x=13 : up_limit_resistor[Ω] 00158 "" //x=14 : cal_name(ASCII) 00159 }; 00160 const char *cpara2[]= { 00161 "VSS", //x=0 : vss_iop[V] 00162 "VSS", //x=1 : vss_ocp[V] 00163 "VSS", //x=2 : vss_voc[V] 00164 "LOW LIMIT", //x=3 : low_limit_voc[V] 00165 "LOW LIMIT", //x=4 : low_limit_iop[uA] 00166 "LOW LIMIT", //x=5 : low_limit_ocp[uA] 00167 "UP LIMIT", //x=6 : up_limit_ocp[uA] 00168 "LOW LIMIT", //x=7 : low_limit_ocp_v[V] 00169 "UP LIMIT", //x=8 : up_limit_ocp_v[V] 00170 "WAIT", //x=9 : wait_iop[s] 00171 "WAIT", //x=10 : wait_ocp[s] 00172 "WAIT", //x=11 : wait_voc[s] 00173 "LOW LIMIT", //x=12 : low_limit_resistor[Ω] 00174 "UP LIMIT", //x=13 : up_limit_resistor[Ω] 00175 "NAME" //x=14 : cal_name(ASCII) 00176 }; 00177 const char *cunit[]= { 00178 "V", //x=0 : vss_iop[V] 00179 "V", //x=1 : vss_ocp[V] 00180 "V", //x=2 : vss_voc[V] 00181 "V", //x=3 : low_limit_voc[V] 00182 "uA", //x=4 : low_limit_iop[uA] 00183 "uA", //x=5 : low_limit_ocp[uA] 00184 "uA", //x=6 : up_limit_ocp[uA] 00185 "V", //x=7 : low_limit_ocp_v[V] 00186 "V", //x=8 : up_limit_ocp_v[V] 00187 "s", //x=9 : wait_iop[s] 00188 "s", //x=10 : wait_ocp[s] 00189 "s", //x=11 : wait_voc[s] 00190 "", //x=12 : low_limit_resistor[Ω] 00191 "", //x=13 : up_limit_resistor[Ω] 00192 "" //x=14 : cal_name(ASCII) 00193 }; 00194 00195 /* 00196 x=0 : vss_iop[V] 00197 x=1 : vss_ocp[V] 00198 x=2 : vss_voc[V] 00199 x=3 : low_limit_voc[V] 00200 x=4 : low_limit_iop[uA] 00201 x=5 : low_limit_ocp[uA] 00202 x=6 : up_limit_ocp[uA] 00203 x=7 : low_limit_ocp_v[V] 00204 x=8 : up_limit_ocp_v[V] 00205 x=9 : wait_iop[s] 00206 x=10 : wait_ocp[s] 00207 x=11 : wait_voc[s] 00208 x=12 : low_limit_resistor[Ω] 00209 x=13 : up_limit_resistor[Ω] 00210 x=14 : cal_name(ASCII) 00211 */ 00212 00213 00214 /******************************************************************************* 00215 00216 LPC1768 PIN MAPPING 00217 00218 *******************************************************************************/ 00219 //繰り返しタイマー割り込み 00220 Ticker flipper; /* 初期化 */ 00221 //one shot timer 00222 Timeout oneshot1; 00223 Timeout oneshot2; 00224 Timeout oneshot3; 00225 Timeout oneshot4; 00226 Timeout oneshot5;//CAL番号未送信タイムアウト用 00227 00228 /*** SD-CARD ***/ 00229 SDFileSystem sd(P0_9, P0_8, P0_7, P0_6, "sd"); //SDFileSystem name(mosi, miso, sck, cs, mount); 00230 00231 /*** I2C ***/ 00232 I2C i2c(P0_10,P0_11); //(PinName sda, PinName scl) I2Cを定義 00233 00234 /*** UART ver3 ***/ 00235 //RawSerial uart(P0_15,P0_16,19200); 00236 //RawSerial pc(USBTX,USBRX,9600); //mbed⇔PCデバック用 00237 RawSerial pc(P0_15,P0_16,19200);//ILF3⇔PCデバック用 00238 00239 /*** interruput ***/ 00240 //InterruptIn seq_yobi(P0_19); 00241 00242 /*** start sw ***/ 00243 DigitalIn sw_start(P0_4); 00244 00245 /*** DigitalOut ***/ 00246 DigitalOut houden[] = { // 配列を用意します 00247 DigitalOut( P2_1 ), //houden1 配列の1番目の要素を**で初期化したDigitalOutに 00248 DigitalOut( P2_0 ), //houden2 00249 DigitalOut( P1_28 ), //houden3 00250 DigitalOut( P1_29 ) //houden4 00251 }; 00252 00253 DigitalOut io[] = { 00254 DigitalOut( P2_11 ), //io1 00255 DigitalOut( P2_12 ), //io2 00256 DigitalOut( P1_18 ), //io3 00257 DigitalOut( P1_19 ), //io4 00258 DigitalOut( P0_17 ), //io5 00259 DigitalOut( P0_18 ), //io6 00260 DigitalOut( P1_30 ), //io7 00261 DigitalOut( P1_31 ), //io8 00262 DigitalOut( P1_22 ), //io9 00263 DigitalOut( P1_23 ), //io10 00264 DigitalOut( P1_24 ), //io11 00265 DigitalOut( P1_25 ), //io12 00266 DigitalOut( P0_23 ), //io13 00267 DigitalOut( P0_24 ), //io14 00268 DigitalOut( P0_25 ), //io15 00269 DigitalOut( P0_26 ) //io16 00270 }; 00271 00272 DigitalOut io_reset[] = { 00273 DigitalOut( P1_22 ), //io9 00274 DigitalOut( P1_23 ), //io10 00275 DigitalOut( P1_24 ), //io11 00276 DigitalOut( P1_25 ), //io12 00277 }; 00278 00279 /* 00280 DigitalOut io[] = { // 配列を用意します 00281 DigitalOut( P0_25 ), //io1 配列の1番目の要素をP0_25で初期化したDigitalOutに 00282 DigitalOut( P0_26 ), //io2 00283 DigitalOut( P0_23 ), //io3 00284 DigitalOut( P0_24 ), //io4 00285 DigitalOut( P1_22 ), //io5 00286 DigitalOut( P1_23 ), //io6 00287 DigitalOut( P1_24 ), //io7 00288 DigitalOut( P1_25 ) //io8 00289 }; 00290 */ 00291 00292 DigitalOut range[] = { // 配列を用意します 00293 DigitalOut( P2_3 ), //range1 配列の1番目の要素を**で初期化したDigitalOutに 00294 DigitalOut( P2_2 ), //range2 00295 DigitalOut( P1_26 ), //range3 00296 DigitalOut( P1_27 ) //range4 00297 }; 00298 00299 DigitalOut led_green[] = { 00300 DigitalOut( P0_17 ), 00301 DigitalOut( P1_31 ), 00302 DigitalOut( P2_11 ), 00303 DigitalOut( P1_18 ) 00304 }; 00305 00306 DigitalOut led_red[] = { 00307 DigitalOut( P0_18 ), 00308 DigitalOut( P1_30 ), 00309 DigitalOut( P2_12 ), 00310 DigitalOut( P1_19 ) 00311 }; 00312 00313 /*** PLC ver3 ***/ 00314 DigitalIn seq_in[] = { 00315 DigitalIn(P0_19), //si1 00316 DigitalIn(P2_9), //si2 00317 DigitalIn(P2_13), //si3 00318 DigitalIn(P4_28), //si4 00319 DigitalIn(P0_29), //si5 00320 DigitalIn(P0_30) //si6 00321 }; 00322 00323 DigitalOut seq_out[] = { 00324 DigitalOut( P0_21 ), //so1 00325 DigitalOut( P0_22 ), //so2 00326 DigitalOut( P3_25 ), //so3 00327 DigitalOut( P3_26 ), //so4 00328 DigitalOut( P0_20 ), //so5 00329 DigitalOut( P2_6 ), //so6 00330 DigitalOut( P2_7 ), //so7 00331 DigitalOut( P2_8 ) //so8 00332 }; 00333 00334 //ver1.1.0 00335 /* 00336 DigitalOut seq_hantei[] = { 00337 DigitalOut( P0_21 ), 00338 DigitalOut( P0_22 ), 00339 DigitalOut( P3_25 ), 00340 DigitalOut( P3_26 ) 00341 }; 00342 00343 DigitalOut seq_busy(P0_20); 00344 //DigitalIn 00345 DigitalIn seq_start(P4_28); 00346 DigitalIn seq_cal_a(P2_6); 00347 DigitalIn seq_cal_b(P2_7); 00348 DigitalIn seq_cal_c(P2_8); 00349 DigitalIn seq_kosuu_a(P2_13); 00350 DigitalIn seq_kosuu_b(P2_9); 00351 //DigitalIn seq_yobi(P0_19); 00352 */ 00353 00354 /*** PWM ***/ 00355 PwmOut leds[] = { //配列を用意 00356 PwmOut(P2_5), //LED1 00357 PwmOut(P2_4), //LED2 00358 PwmOut(P1_21), //LED3 00359 PwmOut(P1_20) //LED4 00360 }; 00361 00362 //RELAY ver3.0.0 00363 DigitalOut rlen[] = { 00364 DigitalOut( P1_4 ), //RLCNT1 00365 DigitalOut( P1_8 ), //RLCNT2 00366 DigitalOut( P1_9 ), //RLCNT3 00367 DigitalOut( P1_10 ), //RLCNT4 00368 DigitalOut( P1_14 ), //RLCNT5 00369 DigitalOut( P1_15 ), //RLCNT6 00370 DigitalOut( P1_16 ), //RLCNT7 00371 DigitalOut( P1_17 ), //RLCNT8 00372 }; 00373 00374 /******************************************************************************* 00375 00376 SD Card 00377 00378 *******************************************************************************/ 00379 void sd_writetext(char* text); 00380 00381 /******************************************************************************* 00382 00383 gu-D(表示器) addr:50H 00384 00385 *******************************************************************************/ 00386 //parameter_gu256X128C-D903M 00387 const int addr_gu = 0x50 << 1; // Address of gu256X128C-D903M 00388 // 00389 //prototype 00390 const int Proportional1 = 0x02; 00391 //const int Proportional2 = 0x03; 00392 //const int Proportional3 = 0x04; 00393 // 00394 void gu_cls(); 00395 void gu_drawButton(int x, int y, int w, int h, const char *data); 00396 void gu_cursor(int x, int y); 00397 void gu_fontsize(const char code); 00398 void gu_print_dot(int x, int y, const char *ptext); 00399 void gu_fontWidth(const char fontWidth); 00400 void gu_print(const char t[] ); 00401 void gu_fontReverse(int code); 00402 void gu_RealTimeImage_dot(int x, int y, int w, int h, const char data[]); 00403 void gu_RealTimeImage(int w, int h, char data[]); 00404 void gu_magnify(int x, int y); 00405 // 00406 //オリジナルgu用関数 00407 void gu_print1(const char* ptext); 00408 void gu_luminance(const char* cl); 00409 void gu_touchPara(int x,int y); 00410 void gu_sendOneByte(char data); 00411 void utility(); //輝度調整ｻﾌﾞﾙｰﾁﾝ 00412 void gu_CRLF(); 00413 void gu_reverse(char x); 00414 void gu_drawbutton_cursor(char x,char y); 00415 void gu_onebyte(char data); 00416 // 00417 //Button Trig Function 00418 void adjust_illumination();//LED輝度調整ｻﾌﾞ 00419 void gu_initial();//初期設定ｻﾌﾞ 00420 void gu_set_button(char sw_num,char* text);//SWﾅﾝﾊﾞｰと表示ﾃｷｽﾄを指定 00421 void gu_set_button_font1(char sw_num,char* text);//fontsize = 1 00422 void gu_button_up(char sw_num); //upボタン表示 00423 void gu_button_down(char sw_num);//downボタン表示 00424 void gu_Button_up1(); 00425 void gu_Button_up2(); 00426 void gu_Button_up3(); 00427 void gu_Button_up4(); 00428 void gu_button_up_on(char sw_num); 00429 void gu_Button_up_on2(); 00430 void gu_Button_down1(); 00431 void gu_Button_down2(); 00432 void gu_Button_down3(); 00433 void gu_Button_down4(); 00434 void gu_button_down_on(char sw_num); 00435 void gu_Button_down_on2(); 00436 void gu_Button_power_on(); 00437 void gu_Button_power_off(); 00438 // 00439 /******************************************************************************* 00440 00441 表示関数 00442 00443 *******************************************************************************/ 00444 void select_cal(); //CAL選択画面 00445 void setup_cal_information(char cal_num); //CAL情報登録画面 00446 void manual_int_hyouji(); 00447 void auto_int_hyouji(); 00448 void disp_setup_cal(char cal_num ,int parameter); //CAL情報登録画面表示 00449 // 00450 //****************************************************************************** 00451 00452 // CAT24M01(EEPROM) 00453 // ver3.0.0 2022.4.8 00454 00455 const static int eeprom_adrs = 0xA8; //0x2A << 2 Address of PCAS08A(EEPROM) 6/8bit 00456 00457 int slave_adrs; //i2c slave address 8bit 00458 00459 char rdata[17]; //EEPROMからのリードデータ 00460 char wdata[17]; //EEPROMへのライトデータ 00461 int Jyushin; //受信成功時 Jyushin=0 00462 int Soushin; //送信成功時 Soushin=0 00463 00464 const static char adrs_kido[]={0x00,0x00}; //VFDの輝度 00465 const static char adrs_syoudo[]={0x00,0x10}; //測定用LED照度の値を保存しているアドレス 00466 const static char adrs_calnum[]={0x00,0x20}; //CPUにロードしているCALの登録番号 00467 const static char adrs_calinfo[]={0x01,0x00}; //CAL情報 0x0100~0x032FFを割り当て。1page256byte。No.1～No.50まで登録 00468 // 00469 // CAL情報登録 -> EEPROM 00470 // 00471 #define caliber_number 50 /* CAL登録数 */ 00472 // 00473 // 00474 /******************************************************************************* 00475 00476 LCP1768(EEPROM) addr:15H 00477 00478 *******************************************************************************/ 00479 //parameter_PCAS08A(EEPROM) 00480 //const int addr_EEPROM = 0x15 << 3; // Address of PCAS08A(EEPROM) コメント化 ver1.2.1 00481 //char rdata[17]; //EEPROMからのリードデータ 00482 //char wdata[17]; //EEPROMへのライトデータ 00483 //int Jyushin; //受信成功時 Jyushin=0 00484 //int Soushin; //送信成功時 Soushin=0 00485 //const int eeprom_adrs = 0x15 << 3; // Address of PCAS08A(EEPROM) 始めの5bit ver1.2.1 00486 //int slave_adrs; //slave address ver1.2.1 00487 // 00488 /******************************************************************************* 00489 00490 MCP3424(ADC) 00491 00492 RESOLUTION SETTINGS VS. LSB 00493 ----------------------------------- 00494 |Resolution Setting | LSB | 00495 ----------------------------------- 00496 | 12bits(00) | 1mv | 00497 | 14bits(01) | 250uV | 00498 | 16bits(10) | 62.5uV | 00499 | 18bits(11) | 15.625uV | 00500 ----------------------------------- 00501 00502 *******************************************************************************/ 00503 //parameter_ADC(MCP3424) 00504 const int addr_ADC1 = 0x6C <<1;//電圧抵抗測定No.1,No.2用ADC 00505 const int addr_ADC2 = 0x6A <<1;//電圧抵抗測定No.3,No.4用ADC 00506 const int addr_ADC3 = 0x68 <<1;//電流測定No.1,No.2 00507 const int addr_ADC4 = 0x6E <<1;//電流測定No.3,No.4 00508 // 00509 char hd[] = "0123456789ABCDEF" ; 00510 // 00511 //関数 00512 void general_call(char com); //power on reset 00513 char adc_config(char ch, char rate); 00514 // 00515 /******************************************************************************* 00516 00517 AD5625RBUZ(DAC) addr:1F 00518 00519 *******************************************************************************/ 00520 const char addr_dac = 0x1F <<1; 00521 void dac_out(short mvolt, char addr); 00522 void dac_init(); 00523 // 00524 /******************************************************************************* 00525 00526 測定関係関数 00527 00528 *******************************************************************************/ 00529 void set_pullup();//シーケンサからの入力ピンのプルアップ設定 00530 void trigger();//シーケンサからのスタート信号割込みサブ 00531 void calibration(); 00532 void compute_adc(int adc_con, long *avg);//(ADCのCONFIG, 計算結果） 00533 void gu_putdec(short* x);//2byteを10進で表示 00534 void gu_putdeck(short* x);//2byteを10進で表示。1/1000. 00535 void gu_putdeci(float* x);// ver1.1.4 00536 void gu_putdeci_mA(float* x);// ver1.1.4 00537 void meas_current_automode(char amount);//AutoMOdeの電流測定サブ iop ocp共通 00538 void auto_run();//自動測定ﾓｰﾄﾞ 00539 void auto_meas(char noc);//一括測定。ch:測定する総チャンネル数 00540 void meas_sub();//自動測定モード内の繰り返し処理 00541 void manual();//手動測定ﾓｰﾄﾞ 00542 void hantei(char noc);//規格値比較エラーフラグ立てる 00543 void select_ich(char ch);//電流測定chの選択と設定 00544 short read_adc(char addr);//指定addressから2byte読込み 00545 short meas_voltage(char ch);//測定チャンネルを指定して、測定値（2byte)を返す 00546 short meas_resistor(char ch);//測定チャンネルを指定して、測定値（2byte)を返す 00547 void display_resistor(short sdata);//測定値を表示する。 00548 void led_off();//判定用LED全消灯 00549 void read_syoudo(char* c);//EEPROMから照度データ(PwmDuty)を読み込んでセットする 00550 void seq_serialsend(/*int noc*/);//シーケンサへのシリアル出力 00551 void seq_serialrecive(/*int noc*/);//シーケンサへのシリアル入力 00552 void seq_timeout();//シーケンサからCAL番号が一定時間出力されなければ前回のCAL番号で測定 00553 00554 00555 /******************************************************************************* 00556 00557 測定関係 変数 00558 00559 *******************************************************************************/ 00560 char io_voc; //VOC測定時のIO操作。ON(=VDD)の場合は”0x01"OFF(=OPEN)は"0x00" 00561 char err_f[4];//ch1~4 規格外発生時のフラグ 0or1 00562 short V[4];//ADC入力値を3倍した値 測定値[V] 16進数 00563 float I[4];//電流測定値チャンネル毎の 00564 short R[4];//抵抗測定値 00565 short voc[4];//ADC入力値を3倍した値 測定値[mV] 16進数 00566 double vocp[4];//過充電防止時のHD測定電圧 00567 float iop[4];//2byte 補数あり 測定値 1bit 0.01uA 00568 float ocp[4];//2byte 補数あり 測定値 00569 char ch_num ;//選択中の測定チャネル（0~3) 00570 int cat;//検査カテゴリNo. 00571 float fdata[4][4];//ファイル出力用 00572 char seq_name[4] = {0,0,0,0};//CAL番号一時格納用配列 00573 00574 00575 //structure 00576 struct cal_info { 00577 char name[4]; // CAL NAME ASCII CODE ver3 00578 short number; // CAL.No. 00579 short vss_iop; // IOP測定時のVss電圧 1bit * 0.01uA 00580 short vss_ocp; // 過充電防止(over charge protection)測定時のVss電圧 00581 short vss_voc; // VOC測定時のVss電圧 00582 short low_limit_voc; // 1bit * 1mv 00583 short low_limit_iop; // 1bit * 0.01uA 00584 short low_limit_ocp; // 過充電防止検査の下規格値（プラス側） 00585 short up_limit_ocp; // 過充電防止検査の上限規格値（マイナス側）ver1.2.1追加 00586 float wait_iop; // Iop測定前の待機時間[s] 1bit 1s 換算 00587 float wait_ocp; // 過充電防止時消電測定前の待機時間[s] 1bit 1s換算 00588 short low_limit_resistor; // アンテナ抵抗規格 1bit 10Ω 00589 short up_limit_resistor; // アンテナ抵抗規格 1bit 10Ω 00590 short low_limit_ocp_v; // 過充電防止検査の下限規格[V] ver3 00591 short up_limit_ocp_v; // 過充電防止検査の上限規格[V] ver3 00592 float wait_voc; // リセット立上りからVOC測定までの待機時間[s] 1bit 1s 換算 ver3 00593 }; 00594 00595 00596 //parameter 00597 struct cal_info calinfo; 00598 char reg_num; /* 選択中の登録CALﾅﾝﾊﾞｰ */ 00599 //function 00600 void erace_calinfo(); 00601 void read_regnum(); 00602 void read_caliber(cal_info *cal, int num); 00603 void write_caliber_information(cal_info *cal, int num); 00604 00605 /******************************* 00606 00607 ver1.2.5 00608 convert code to Ampare 00609 00610 ******************************* 00611 float cul_ADC(short code){ 00612 00613 float analog_data; 00614 00615 analog_data = code * LSB_I / GAIN_I / TIME_INT * CAP ; 00616 00617 return( analog_data ); 00618 00619 } 00620 */ 00621 00622 /******************************* 00623 00624 set mode interruptin/degitalin 00625 00626 *******************************/ 00627 void set_pullup() 00628 { 00629 //シーケンサ受信割り込み 00630 pc.attach(&seq_serialrecive,RawSerial::RxIrq); 00631 00632 /*** ver3 ***/ 00633 sw_start.mode(PullUp); 00634 00635 for (int i = 0; i <= 5; i++){ 00636 seq_in[i].mode(PullUp); 00637 } 00638 00639 } 00640 /******************************* 00641 00642 Sequence Mode main screen 00643 00644 *******************************/ 00645 void seq() 00646 { 00647 char cmd_gu[32] ; //gu-DへのI2Cコマンド用配列 1byte 00648 char crdata[6]; 00649 00650 gu_cls();//clear screen 00651 gu_fontsize(2); 00652 gu_print1("Sequenser Mode"); 00653 gu_Button_power_on();//show button 00654 00655 //seq_start.fall(&trigger);//スタート信号立下りで割込み 00656 00657 00658 //シーケンサのトリガ以外は受け付けない 00659 while(1) { 00660 /*** ver3 ***/ 00661 if( sw_start == 0 ) { 00662 //if ( seq_in[0] == 0 ){ 00663 trigger(); 00664 } 00665 00666 wait(0.3); 00667 00668 crdata[0] = 0; 00669 crdata[1] = 0; 00670 crdata[2] = 0; 00671 00672 i2c.read ((addr_gu + 0x01), crdata, 3, true); 00673 00674 if ( crdata[0] == 0x11 && crdata[2] == 1 ) { //個別ﾀｯﾁｽｲｯﾁ状態読み出しﾌｫｰﾏｯﾄ。識別子11h。 00675 00676 //cswnum = crdata[1]; //ｽｲｯﾁ番号 00677 //cswdata = crdata[2];//ON/OFF情報 00678 00679 //gu-D タッチスイッチ読み出し動作設定 p49 00680 cmd_gu[0]= 0x1F; 00681 cmd_gu[1]= 0x4B; 00682 cmd_gu[2]= 0x18; 00683 cmd_gu[3]= 0x00;//SW状態変化時自動送信モード2解除 00684 i2c.write(addr_gu, cmd_gu, 4); //gu-D タッチスイッチ読み出し動作設定 p49 00685 00686 if ( crdata[1] == 7 ) { 00687 00688 gu_Button_power_off();//電源ﾎﾞﾀﾝｲﾒｰｼﾞ反転表示 00689 wait(0.5); 00690 00691 led_off();//LED全消灯 00692 00693 return;//この関数を抜ける 00694 00695 } //end if 00696 00697 /* ver 1.1.1 タッチパネルで測定開始を削除 00698 else { 00699 00700 meas_sub();//測定用サブ 00701 00702 00703 } //else if 00704 */ 00705 00706 //gu-D タッチスイッチ読み出し動作設定 p49 00707 cmd_gu[0]= 0x1F; 00708 cmd_gu[1]= 0x4B; 00709 cmd_gu[2]= 0x18; 00710 cmd_gu[3]= 0x02;//SW状態変化時自動送信モード2解除 00711 i2c.write(addr_gu, cmd_gu, 4); //gu-D タッチスイッチ読み出し動作設定 p49 00712 00713 wait(0.1); 00714 00715 i2c.read ((addr_gu + 0x01), crdata, 3, true); 00716 00717 }//if 00718 00719 }//while(1) 00720 } 00721 00722 00723 /******************************* 00724 00725 Strart Sequence 00726 00727 *******************************/ 00728 void trigger() 00729 { 00730 char meas_num;//測定個数 00731 char cal_num; //CAL選択ﾅﾝﾊﾞｰ 00732 //char cmd_gu[2]; 00733 00734 gu_cls();//clear screen 00735 gu_fontsize(2); 00736 gu_print1("Sequenser Mode"); 00737 gu_fontsize(1); 00738 gu_cursor(0,3); 00739 gu_print1("start "); 00740 gu_cursor(128,0); 00741 gu_print1("CAL."); 00742 00743 00744 //ｼｰｹﾝｻからCAL選択bit読込と表示 00745 /* 00746 cal_num = ( seq_cal_c << 2 ) + ( seq_cal_b << 1 ) + seq_cal_a; 00747 00748 cal_num = ( ~ cal_num ) & 0x7 ; //3bit入力の負論理 00749 */ 00750 00751 /*** v3 debug ***/ 00752 cal_num = 1; 00753 00754 //read caliber infomation from eeprom 00755 if( cal_num >= 1 && cal_num <= 6 ) { 00756 read_caliber(&calinfo, cal_num); 00757 gu_onebyte( cal_num + 0x30 );//CAL.No.確認用 00758 } else { 00759 gu_cls(); 00760 gu_fontsize(1); 00761 gu_print1("Cal number error"); 00762 wait(1); 00763 } 00764 00765 /*** v3 debag ***/ 00766 //meas_num = ( ~(( seq_kosuu_b << 1 ) + seq_kosuu_a )) & 0x3; //2bit負論理 00767 meas_num = ( ~(( seq_in[2] << 1 ) + seq_in[3] )) & 0x3; //2bit負論理 00768 /******/ 00769 00770 gu_cursor(128,1); 00771 gu_print1("n="); 00772 gu_onebyte( meas_num + 0x30 );//測定個数確認用 00773 00774 /*** ver3 ***/ 00775 //seq_busy = 1;//DegitalOut busy 00776 seq_out[4] = 1; 00777 00778 auto_meas( meas_num ); 00779 00780 //判定結果をシーケンサへ出力 00781 hantei( meas_num ); 00782 00783 wait(0.1); 00784 00785 //測定終了ver3 00786 //seq_busy = 0;//DegitalOut busy 00787 seq_out[4] = 1; 00788 00789 //終了表示 00790 gu_fontsize(1); 00791 gu_cursor(0,3); 00792 gu_print1("ready "); 00793 00794 } 00795 00796 /******************************************************************************* 00797 00798 EEPROMへCAL情報(struct)を保存 00799 00800 ver3. CAT24M01用に改修 2022.4.12 00801 00802 1page(256byte)につき1Cal分の品種情報を登録する。 00803 BYTE_ADDRESS上位9bitでpage指定。下位8bitはpage内アドレス。 00804 00805 argument 00806 num : CAL登録ナンバー（1～50） 00807 cal_info : 測定条件 00808 00809 *******************************************************************************/ 00810 void write_caliber_information(cal_info *cal, int num) 00811 { 00812 char cdata[29]; //1byte*x 00813 int adrs_init; 00814 int adrs; 00815 00816 adrs_init = ((adrs_calinfo[0] << 8 ) & 0xFF00 ) + (adrs_calinfo[1] & 0xFF); 00817 00818 //EEPROM書込み page指定 00819 00820 adrs = adrs_init + 0x100 * ( num - 1 ); 00821 cdata[0] = ( (adrs & 0xFF00) >> 8 ) & 0xFF; //address 15~8 bit 00822 cdata[1] = 0x00; //address 7~0 bit 00823 00824 //連続データ書込み BYTE_ADDRESS 下位8bit 0x00~0x0Bまで 00825 00826 cdata[2] = calinfo.vss_iop & 0xFF; //0x00 00827 cdata[3] = ( calinfo.vss_iop >> 8 ) & 0xFF; //0x01 00828 00829 cdata[4] = calinfo.vss_ocp & 0xFF; //0x02 00830 cdata[5] = ( calinfo.vss_ocp >> 8 ) & 0xFF; //0x03 00831 00832 cdata[6] = calinfo.vss_voc & 0xFF; //0x04 00833 cdata[7] = ( calinfo.vss_voc >> 8 ) & 0xFF; //0x05 00834 00835 cdata[8] = calinfo.low_limit_voc & 0xFF; //0x06 00836 cdata[9] = ( calinfo.low_limit_voc >> 8 ) & 0xFF; //0x07 00837 00838 cdata[10] = calinfo.low_limit_iop & 0xFF; //0x08 00839 cdata[11] = ( calinfo.low_limit_iop >> 8 ) & 0xFF; //0x09 00840 00841 cdata[12] = calinfo.low_limit_ocp & 0xFF; //0x0A 00842 cdata[13] = ( calinfo.low_limit_ocp >> 8 ) & 0xFF; //0x0B 00843 00844 cdata[14] = calinfo.up_limit_ocp & 0xFF; //0x0C 00845 cdata[15] = ( calinfo.up_limit_ocp >> 8 ) & 0xFF; //0x0D 00846 00847 cdata[16] = calinfo.low_limit_ocp_v & 0xFF; //0x0E 00848 cdata[17] = ( calinfo.low_limit_ocp_v >> 8 ) & 0xFF; //0x0F 00849 00850 cdata[18] = calinfo.up_limit_ocp_v & 0xFF; //0x10 00851 cdata[19] = ( calinfo.up_limit_ocp_v >> 8 ) & 0xFF; //0x11 00852 00853 cdata[20] = calinfo.wait_iop; //0x12 00854 cdata[21] = calinfo.wait_ocp; //0x13 00855 cdata[22] = calinfo.wait_voc; //0x14 00856 00857 cdata[23] = calinfo.low_limit_resistor / 10; //0x15 1bitあたり10ohm 00858 cdata[24] = calinfo.up_limit_resistor / 10; //0x16 1bitあたり10ohm 00859 00860 cdata[25] = calinfo.name[0]; //0x17 00861 cdata[26] = calinfo.name[1]; //0x18 00862 cdata[27] = calinfo.name[2]; //0x19 00863 cdata[28] = calinfo.name[3]; //0x1A 00864 00865 Soushin = i2c.write (eeprom_adrs, cdata, 29); 00866 00867 wait(0.2); //ver3 00868 00869 } 00870 /******************************************************************************* 00871 00872 EEPROMからCAL情報を 00873 読み出して構造体へ代入する 00874 00875 argument num:登録番号 00876 00877 ver3. CAT24M01用に改修 2022.4.12 00878 00879 *******************************************************************************/ 00880 void read_caliber(cal_info *cal, int num) 00881 { 00882 signed short sdata[16]; //CAL設定条件 00883 int i; 00884 int adrs_init; 00885 int adrs; 00886 char cdata[27]; 00887 00888 adrs_init = ((adrs_calinfo[0] << 8 ) & 0xFF00) + (adrs_calinfo[1] & 0x00FF); 00889 00890 adrs = adrs_init + 0x100 * ( num - 1 ); 00891 00892 wdata[0] = ( (adrs & 0xFF00) >> 8 ) & 0xFF; //address 15~8 bit 00893 wdata[1] = 0x00; //address 7~0 bit 00894 00895 Soushin = i2c.write (eeprom_adrs, wdata, 2,true); //not set stpo at end 00896 Jyushin = i2c.read ((eeprom_adrs + 0x01), cdata, 1); 00897 Jyushin = i2c.read ((eeprom_adrs + 0x01), (cdata + 1), 27);//read 27byte 00898 00899 /*** ver3.0.0 debug***/ 00900 if ( Jyushin != 0 ){ 00901 gu_fontsize(1); 00902 gu_cursor(0,2); 00903 gu_print1("not read cal information"); 00904 } 00905 00906 //データ合成 EEPROM_BYTE 0x00~0x11まで2byte結合 00907 for ( i = 0; i <= 8; i++ ) { 00908 sdata[i] = cdata[i*2] | ( cdata[ i*2 + 1 ] << 8 ); 00909 } 00910 00911 cal -> number = num; 00912 cal -> vss_iop = sdata[0]; //0x00 00913 cal -> vss_ocp = sdata[1]; //0x02 00914 cal -> vss_voc = sdata[2]; //0x04 00915 cal -> low_limit_voc = sdata[3]; //0x06 00916 cal -> low_limit_iop = sdata[4]; //0x08 00917 cal -> low_limit_ocp = sdata[5]; //0x0A 00918 cal -> up_limit_ocp = sdata[6]; //0x0C 00919 cal -> low_limit_ocp_v = sdata[7]; //0x0E 00920 cal -> up_limit_ocp_v = sdata[8]; //0x10 00921 00922 cal -> wait_iop = cdata[18]; //0x12 wait_iop 00923 cal -> wait_ocp = cdata[19]; //0x13 wait_ocp 00924 cal -> wait_voc = cdata[20]; //0x14 wait_voc 00925 00926 cal -> low_limit_resistor = cdata[21] * 10; //0x15 low_limit_resistor 00927 cal -> up_limit_resistor = cdata[22] * 10; //0x16 up_limit_resistor 00928 00929 cal -> name[0] = cdata[23]; //0x17 cal name 00930 cal -> name[1] = cdata[24]; //0x18 cal name 00931 cal -> name[2] = cdata[25]; //0x19 cal name 00932 cal -> name[3] = cdata[26]; //0x1A cal name 00933 00934 } 00935 /******************************************************************************* 00936 00937 EEPROMからCAL登録番号を読出し 00938 00939 ver3. CAT24M01用に改修 2022.4.11 00940 00941 *******************************************************************************/ 00942 void read_regnum() 00943 { 00944 00945 //Selective Read Timing 00946 00947 Soushin = i2c.write (eeprom_adrs, adrs_calnum, 2,true); //ver3 00948 00949 Jyushin = i2c.read ((eeprom_adrs + 0x01), rdata, 1);//read 1byte 00950 00951 reg_num = rdata[0]; 00952 } 00953 /******************************************************************************* 00954 00955 EEPROMからCAL登録情報全消去("0x00"書込み) 00956 00957 ver3. CAT24M01用に改修 2022.4.11 00958 0x00000 ~ 0x032FF を消去 00959 00960 *******************************************************************************/ 00961 void erace_calinfo() 00962 { 00963 int i; 00964 int j; 00965 00966 //init cal number ver3 00967 reg_num = 0x01; 00968 wdata[0] = adrs_calnum[0]; 00969 wdata[1] = adrs_calnum[1]; 00970 wdata[2] = reg_num; 00971 Soushin = i2c.write (eeprom_adrs, wdata, 3); 00972 00973 wait(0.2); 00974 00975 //write "0x00" by 256 byte 00976 00977 char wd[258]; //DATA 00978 int byte_adrs; //送信するBYTE ADDRESS I2C送信データの1，2BYTE目 00979 const static int cal_adrs = 0x0100; //CAL情報を保存する開始アドレス 00980 int page = 50; //page数 00981 00982 for ( j = 0; j < page; j++){ 00983 00984 byte_adrs = cal_adrs + j * 256; 00985 wd[0] = (byte_adrs & 0xFF00) >> 8; 00986 wd[1] = byte_adrs & 0xFF; 00987 for( i = 2; i <= 258; i++) { //write 1page(256byte) 00988 wd[i] = 0x00; 00989 } 00990 Soushin = i2c.write (eeprom_adrs, wd, 258); 00991 00992 wait(0.2); 00993 00994 } 00995 00996 } 00997 /******************************************************************************* 00998 00999 ADC(MCP3424) Configuration Register 01000 01001 ch : Channel Selection Bit 01002 00 = Select Channel 1 01003 01 = Select Channel 2 01004 10 = Select Channel 3 01005 11 = Select Channel 4 01006 01007 rate : Sample Rate Selection Bit 01008 00 = 240 SPS(12bits) 01009 01 = 60 SPS(14bits) 01010 10 = 15 SPS(16bits) 01011 11 = 3.75 SPS(18bits) 01012 01013 *******************************************************************************/ 01014 char adc_config(char ch, char rate) 01015 { 01016 char confreg; //Configuration Register 1byte 01017 01018 char rdy = 0; //Ready Bit 01019 char cm = 1; //Conversion Mode Bit 01020 char gain = 0; //PGA Gain Selection Bits 01021 01022 confreg = (( rdy & 0x1 ) << 7 ) + (( ch & 0x3) << 5 ) + (( cm & 0x1 ) << 4) + (( rate & 0x3 ) << 2) + ( gain & 0x3 ) ; 01023 01024 return( confreg ); 01025 } 01026 /******************************************************************************* 01027 01028 ADC(MCP3424) Configuration Register 01029 電流測定チャンネルの選択 01030 char ch : 1~4ch 01031 01032 *******************************************************************************/ 01033 void select_ich(char ch) 01034 { 01035 char com; 01036 01037 switch ( ch ) { 01038 case 0: 01039 com = adc_config( 0, 1 );//ADC3_ch1選択 14bits 01040 i2c.write( addr_ADC3, &com, 1 ); 01041 break; 01042 case 1: 01043 com = adc_config( 1, 1 );//ADC3_ch2選択 14bits 01044 i2c.write( addr_ADC3, &com, 1 ); 01045 break; 01046 case 2: 01047 com = adc_config( 0, 1 );//ADC4_ch1選択 14bits 01048 i2c.write( addr_ADC4, &com, 1 ); 01049 break; 01050 case 3: 01051 com = adc_config( 1, 1 );//ADC4_ch2選択 14bits 01052 i2c.write( addr_ADC4, &com, 1 ); 01053 break; 01054 } 01055 } 01056 /******************************************************************************* 01057 01058 ADC(MCP3424) 01059 指定addressから2byte読込み 01060 01061 ver3.0.0 20ms間隔の5回平均 01062 01063 *******************************************************************************/ 01064 short read_adc(char addr)//指定addressから2byte読込み 01065 { 01066 char cdata[2];//1byte 01067 short sdata;//2byte 01068 //short kekka; 01069 //short goukei; 01070 //int bosu = 5; 01071 01072 i2c.read( addr + 0x01, cdata, 2); 01073 01074 /* 01075 for( int i = 0; i < bosu; i++){ 01076 i2c.read( addr + 0x01, cdata, 2); 01077 01078 //connect 2byte 01079 kekka = cdata[0] & 0xFF; 01080 kekka = ( sdata << 8 ) | cdata[1]; 01081 01082 goukei += kekka; 01083 01084 wait(0.1); 01085 01086 } 01087 01088 sdata = goukei / bosu; 01089 */ 01090 01091 i2c.read( addr + 0x01, cdata, 2); 01092 01093 //connect 2byte 01094 sdata = cdata[0] & 0xFF; 01095 sdata = ( sdata << 8 ) | cdata[1]; 01096 01097 return ( sdata ); 01098 } 01099 /******************************************************************************* 01100 01101 AUTO/SEQ Mode 01102 01103 ワンショットタイマー発生イベント 01104 01105 For Current measurement 01106 a recurring interrupt to repeatedly call a function at a specified rate. 01107 01108 *******************************************************************************/ 01109 void flip_ch1() 01110 { 01111 short sdata; 01112 01113 sdata = read_adc( addr_ADC3 ); 01114 01115 I[0] = sdata * 5 * 0.25; 01116 01117 //次の測定chへ切替 01118 select_ich(1); 01119 } 01120 01121 void flip_ch2() 01122 { 01123 short sdata; 01124 01125 sdata = read_adc( addr_ADC3 ); 01126 01127 I[1] = sdata * 5 * 0.25; 01128 01129 //次の測定chへ切替 01130 select_ich(2); 01131 } 01132 01133 void flip_ch3() 01134 { 01135 short sdata; 01136 01137 sdata = read_adc( addr_ADC4 ); 01138 01139 I[2] = sdata * 5 * 0.25; 01140 01141 //次の測定chへ切替 01142 select_ich(3); 01143 } 01144 01145 void flip_ch4() 01146 { 01147 short sdata; 01148 01149 sdata = read_adc( addr_ADC4 ); 01150 01151 I[3] = sdata * 5 * 0.25; 01152 01153 //次の測定chへ切替 無し 01154 } 01155 01156 /******************************************************************************* 01157 01158 Manual Mode 01159 01160 繰り返しタイマー発生イベント 01161 01162 For Current measurement 01163 a recurring interrupt to repeatedly call a function at a specified rate. 01164 01165 *******************************************************************************/ 01166 void flip() 01167 { 01168 short sdata; //_2byte reading data of ADC 01169 float fdata; // ver1.1.4 01170 01171 switch ( ch_num ) { 01172 case 0: 01173 case 1: 01174 sdata = read_adc( addr_ADC3 ); 01175 break; 01176 case 2: 01177 case 3: 01178 sdata = read_adc( addr_ADC4 ); 01179 break; 01180 } 01181 01182 //sdata = sdata * 5 * 0.25;//プリアンプのGAINが1/5なのでここで5倍.ADC14bit分解能で、1bitあたり0.25mv 01183 /*ver1.1.4*/ 01184 fdata = sdata * 5 * 0.25;//プリアンプのGAINが1/5なのでここで5倍.ADC14bit分解能で、1bitあたり0.25mv 01185 01186 gu_cursor(0,4); 01187 gu_print1(" "); 01188 /*ver1.1.4*/ 01189 gu_putdeci(&fdata); 01190 //gu_putdeci(&sdata); 01191 01192 houden[ ch_num ] = 1; //Discharge 01193 01194 wait(time_discharge); //Discharge time 01195 01196 /*** ver3.0.0 ***/ 01197 01198 //電圧測定 01199 sdata = meas_voltage( ch_num ) * -1 ; 01200 gu_fontsize(2); 01201 gu_cursor(108,4); 01202 gu_putdeck(&sdata); 01203 gu_print1("V"); 01204 01205 //抵抗測定 01206 sdata = meas_resistor( ch_num ); 01207 gu_fontsize(2); 01208 gu_cursor(192,4); 01209 display_resistor( sdata ); //抵抗値表示サブ 01210 01211 /*****************/ 01212 01213 houden[ ch_num ] = 0; //charging 01214 01215 } 01216 /********************************* 01217 Manual Mode 01218 initial screen 01219 *********************************/ 01220 void manual_int_hyouji() 01221 { 01222 01223 /* 画面表示 */ 01224 gu_cls(); 01225 gu_fontsize(2); //change fontsize 01226 gu_fontWidth(Proportional1); 01227 gu_print1("Manual Mode"); 01228 01229 gu_cursor(0, 2); 01230 gu_print1("CH."); 01231 gu_cursor(40, 14); 01232 gu_print1("vss"); 01233 gu_cursor(192, 14); 01234 gu_print1("ch."); 01235 /* 01236 gu_cursor(128, 14); 01237 gu_print1("slct ch."); 01238 */ 01239 01240 //操作ボタン配置 01241 gu_Button_power_on();//メニューへ戻る 01242 gu_button_up(27);//印加電圧増加 01243 gu_button_down(28);//印加電圧減少 01244 gu_button_up(32);//ch切替 01245 //gu_button_down(32);//ch切替 01246 01247 //Show Reset button(LEFT) 01248 gu_set_button(25,"R"); 01249 01250 } 01251 /******************************************************************************* 01252 01253 Manual Mode (Main) 01254 01255 *******************************************************************************/ 01256 void manual() 01257 { 01258 01259 char cswnum; //SW_No. sw1->0x00 ~~ sw32->0x1F 01260 char cswdata; // 0x00 or 0x01 01261 char crdata[3]; 01262 char *pcswnum = &cswnum; 01263 char *pcswdata = &cswdata; 01264 int i; 01265 int j; 01266 float interval;//繰り返し測定間隔(s) <- 積分時間と、繰り返し割込みｻﾌﾞ中のwait（放電時間）も足す 01267 short vss; 01268 short sdata; 01269 int r_flag; 01270 float ima; 01271 short ssdata; 01272 01273 ch_num = 0; //初期電流測定CH. 01274 01275 interval = time_integral + time_discharge ;//繰り返し割込みの間隔設定 01276 flipper.attach(&flip, interval); 01277 01278 read_regnum();//CAL登録No.読込 01279 read_caliber(&calinfo, reg_num);//指定したCAL登録No.の情報を読込後、calinfoへ代入 01280 01281 /* 初期表示 */ 01282 manual_int_hyouji(); 01283 //選択測定チャンネルの表示 01284 gu_fontsize(2); //change fontsize 01285 gu_cursor(24, 2); 01286 wdata[0] = ( ch_num + 1 ) + 0x30; 01287 i2c.write( addr_gu, wdata, 1); 01288 01289 //初期測定設定 01290 //set range 01291 range[0] = 1;//ch.1 10uA測定レンジ 01292 //select channel 01293 wdata[0] = adc_config( 0, 1 );//ADC3_ch1選択 14bits 01294 i2c.write( addr_ADC3, wdata, 1 ); 01295 01296 /*** 電源印加 ***/ 01297 01298 vss = calinfo.vss_iop; 01299 01300 if ( tenken == true ){ 01301 for ( i = 0; i <= (number_of_channels - 1); i++) { 01302 dac_out(0,i); 01303 } 01304 dac_out( vss,0); //Vss設定 DAC ch.1 ver3.0.0 01305 } else { 01306 //apply Vss to all channel 01307 for ( i = 0; i <= (number_of_channels - 1); i++) { 01308 dac_out( vss,i); //Vss設定 DAC 01309 } 01310 } 01311 01312 /**************/ 01313 01314 gu_cursor(0,8); 01315 gu_print1("Vss "); 01316 01317 gu_cursor(64,8); 01318 sdata = -1 * vss; 01319 gu_putdeck( &sdata ); 01320 gu_print1("V"); 01321 01322 while(1) { 01323 01324 crdata[0] = 0; 01325 crdata[1] = 0; 01326 crdata[2] = 0; 01327 01328 //タッチパネルスイッチ読込 01329 Jyushin = i2c.read ((addr_gu + 0x01), crdata, 3, true); 01330 01331 if (crdata[0] == 0x11 ) { //個別ﾀｯﾁｽｲｯﾁ状態読み出しﾌｫｰﾏｯﾄ。識別子11h。 01332 *pcswnum = crdata[1]; //ｽｲｯﾁ番号 01333 *pcswdata = crdata[2];//ON/OFF情報 01334 01335 if (cswdata == 0x01) { //ﾀｯﾁしたならば 01336 switch( cswnum ) { //SWの番号（位置） 01337 01338 case 26://SW27 01339 //gu_reverse(0x01); //gu_ﾘﾊﾞｰｽ指定 01340 //gu_button_up(27); 01341 01342 if ( vss < 4500 ) { 01343 vss = vss + 100; 01344 } 01345 01346 if ( tenken == true ){ 01347 dac_out( vss,ch_num); 01348 } else { 01349 //apply Vss to all channel 01350 for ( i = 0; i <= (number_of_channels - 1); i++) { 01351 dac_out( vss,i); //Vss設定 DAC 01352 } 01353 } 01354 01355 gu_reverse(0x00); 01356 gu_cursor(64,8); 01357 sdata = -1 * vss; 01358 gu_putdeck( &sdata ); 01359 gu_print1("V"); 01360 01361 //gu_button_up(27); 01362 01363 //wait(0.1); 01364 01365 break; 01366 01367 case 27://SW28 01368 //gu_reverse(0x01); //gu_ﾘﾊﾞｰｽ指定 01369 //gu_button_down(28);//印加電圧減少 01370 01371 if ( vss >= 100 ) { 01372 vss = vss - 100; 01373 } 01374 01375 if ( tenken == true ){ 01376 dac_out( vss,ch_num); 01377 } else { 01378 //apply Vss to all channel 01379 for ( i = 0; i <= (number_of_channels - 1); i++) { 01380 dac_out( vss,i); //Vss設定 DAC 01381 } 01382 } 01383 01384 //gu_reverse(0x00); //gu_ﾘﾊﾞｰｽ指定 01385 gu_cursor(64,8); 01386 sdata = -1 * vss; 01387 gu_putdeck( &sdata ); 01388 gu_print1("V"); 01389 01390 //gu_button_down(28);//印加電圧減少 01391 01392 //wait(0.1); 01393 01394 break; 01395 01396 case 0x07 ://Exit 01397 01398 gu_Button_power_off();//電源ﾎﾞﾀﾝｲﾒｰｼﾞ反転表示 01399 01400 //割り込み停止 01401 flipper.detach(); 01402 01403 for( i = 0; i <= 3; i++) { 01404 houden[i] = 1;//discharge 01405 } 01406 01407 wait( time_discharge ); 01408 //set measuring range 01409 for( i = 0; i <= 3; i++) { 01410 range[i] = 0;//range 1mA 01411 houden[i] = 0;//not discharge 01412 } 01413 01414 /*** ver 3.0.0 ****************************************/ 01415 for ( i = 0; i <= (number_of_channels - 1); i++) { 01416 dac_out(0,i); //Vss設定 DAC 01417 } 01418 /******************************************************/ 01419 01420 wait(0.2); 01421 01422 for ( i = 0; i <= 15; i++) 01423 io[i] = 0; //全てのio"L" 01424 01425 return;//この関数を抜ける 01426 01427 case 0x18 ://sw25 reset DUT 01428 01429 //gu_ﾘﾊﾞｰｽ指定 01430 gu_reverse(0x01); 01431 //Show Reset button(Left) 01432 gu_set_button(25,"R"); 01433 01434 wait(0.1); 01435 01436 gu_reverse(0x00); //gu_ﾘﾊﾞｰｽ解除 01437 gu_set_button(25,"R"); //Show Reset button(Left) 01438 01439 io_reset[ch_num] = 1;//ver3.0.0 R="H" 01440 01441 //set measuring range ver1.1.0 01442 for( i = 0; i <= 3; i++) 01443 range[i] = 0;//range 1mA 01444 01445 r_flag = 1; 01446 01447 //割り込み停止 電流測定用タイマー停止 01448 flipper.detach(); 01449 01450 break; 01451 01452 case 31 ://sw32 CH選択 01453 01454 //gu_reverse(0x01);//gu_ﾘﾊﾞｰｽ指定 01455 //gu_button_up(32); 01456 //gu_reverse(0x00);//gu_ﾘﾊﾞｰｽ解除 01457 01458 if ( ch_num < ( number_of_channels - 1 )) { 01459 ch_num = ch_num + 1; 01460 } else { 01461 ch_num = 0; 01462 } //ver1.1.0 01463 01464 select_ich(ch_num);//ADC測定CHの変更 01465 01466 //set measuring range 01467 for( i = 0; i <= 3; i++) 01468 range[i] = 0; //range 1mA 01469 01470 range[ch_num] = 1; //range 10uA 01471 01472 if ( tenken == true ){ 01473 for ( i = 0; i <= (number_of_channels - 1); i++) { 01474 dac_out(0,i); //Vss設定 DAC 01475 } 01476 dac_out( vss,ch_num); 01477 } else { 01478 //apply Vss to all channel 01479 for ( i = 0; i <= (number_of_channels - 1); i++) { 01480 dac_out( vss,i); //Vss設定 DAC 01481 } 01482 } 01483 01484 //選択測定チャンネルの表示 01485 gu_cursor(24, 2); 01486 wdata[0] = ( ch_num + 1 ) + 0x30; 01487 i2c.write( addr_gu, wdata, 1); 01488 01489 //gu_button_up(32); 01490 01491 wait(0.1); 01492 01493 break; 01494 01495 } //switch 01496 Jyushin = i2c.read ((addr_gu + 0x01), crdata, 3, true); 01497 01498 }//if 01499 }//if 01500 01501 //ver1.1.0 0.1s*10(jの値)=1s待機後（プラスリレー制御時間）に電流測定用タイマー始動 01502 if ( j >= 10 ) { 01503 io_reset[ch_num] = 0; // R = "OPEN" 01504 range[ ch_num ] = 1; //range 10uA 01505 r_flag = 0; 01506 j = 0; 01507 flipper.attach(&flip, interval);//割込み開始 01508 } 01509 01510 if ( r_flag == 1 ) { 01511 j = j + 1; 01512 01513 //R=Hの時の電流測定（1ma renge) 01514 select_ich( ch_num ); 01515 ssdata = read_adc( addr_ADC3 ); 01516 ima = ssdata * 5 * 0.25; 01517 01518 gu_cursor(0,4); 01519 gu_fontsize(2); 01520 gu_print1(" "); 01521 gu_putdeci_mA(&ima); 01522 } 01523 01524 /* 01525 //電圧測定 01526 sdata = meas_voltage( ch_num ) * -1 ; 01527 gu_fontsize(2); 01528 gu_cursor(108,4); 01529 gu_putdeck(&sdata); 01530 gu_print1("V"); 01531 01532 //抵抗測定 01533 sdata = meas_resistor( ch_num ); 01534 gu_fontsize(2); 01535 gu_cursor(192,4); 01536 display_resistor( sdata ); //抵抗値表示サブ 01537 */ 01538 01539 wait( 0.1 ); 01540 01541 }//While 01542 } 01543 01544 /***************************** 01545 01546 I2C General Call 01547 01548 *****************************/ 01549 void general_call(char com) 01550 { 01551 char cmd[1]; 01552 01553 cmd[0]= com; 01554 i2c.write(0x00, cmd, 1); //General Call 01555 } 01556 /******************************************************************************* 01557 01558 MAIN 01559 01560 *******************************************************************************/ 01561 int main(void) 01562 { 01563 while(1) { 01564 01565 wait(0.2); 01566 01567 //ver3.0.0 01568 //uart.format(7, Serial::Even, 1); 01569 01570 set_pullup(); 01571 01572 general_call(0x06); //ADC power on reset 01573 01574 dac_init(); //DAC 初期化 01575 01576 gu_initial();//初期画面へ 01577 //utility(); 01578 } 01579 } //main end 01580 01581 void gu_initial() 01582 { 01583 char cmd_gu[32] ; //gu-DへのI2Cコマンド用配列 1byte0 01584 //char *pcmd = cmd_gu; 01585 char clumi; //輝度設定用変数 01h<=n<=08h 01586 char* pclumi = &clumi; //ポインタの定義 01587 char crdata[3]; 01588 char cswnum; //SW_No. sw1->0x00 ~~ sw32->0x1F 01589 char cswdata; // 0x00 or 0x01 01590 char *pcswnum = &cswnum; 01591 char *pcswdata = &cswdata; 01592 char csyoudo[4]; 01593 int i; 01594 float duty_pwm; 01595 01596 for ( i = 0; i <= ( number_of_channels - 1 ); i++) { 01597 leds[i].period_us(period_pwm); //Set tha PWM period(us) 01598 } 01599 01600 duty_pwm = 0; //表示器立ち上がるまでLEDOFF 01601 01602 for( i = 0; i <= 3; i++) { 01603 leds[i].write(duty_pwm);//Set Duty 01604 } 01605 01606 i2c.frequency(100000); //gu_D I2Cｸﾛｯｸﾚｰﾄ(HZ) 400khz以下 01607 01608 cmd_gu[0]= 0x1B; 01609 cmd_gu[1]= 0x40; 01610 i2c.write(addr_gu, cmd_gu, 2); //gu-D ESC 初期化 01611 wait(0.2); 01612 01613 //ﾒﾓﾘ00h番地(GU_D輝度設定ﾃﾞｰﾀ)読み出し 01614 //wdata[0] = 0x00; 01615 wdata[0] = adrs_kido[0]; 01616 wdata[1] = adrs_kido[1]; 01617 Soushin = i2c.write (eeprom_adrs, wdata, 2,true); //読込先頭ｱﾄﾞﾚｽ指定 ReStart 01618 Jyushin = i2c.read ((eeprom_adrs + 0x01), rdata, 1);//read 1byte 01619 *pclumi = rdata[0]; 01620 //輝度設定更新 01621 if(*pclumi==0x00 || *pclumi > 0x08) *pclumi=0x05; 01622 gu_luminance(pclumi); 01623 01624 gu_fontsize(2); //change fontsize 01625 //ver1.2.3 01626 //gu_print1("ILF Iop/Voc/O.C.P/R"); 01627 gu_print1("ILF mode selectiion"); 01628 //upto 01629 //gu_CRLF();//CR+LF 01630 //gu_print1("Settings"); 01631 gu_fontsize(1); 01632 gu_cursor(192,1); 01633 gu_print1("ver"); 01634 gu_onebyte( version_major + 0x30 ); 01635 gu_print1("."); 01636 gu_onebyte( version_minor + 0x30 ); 01637 gu_print1("."); 01638 gu_onebyte( version_build + 0x30 ); 01639 01640 gu_touchPara(0,touch);//タッチ感度 00h~07h 01641 01642 //MODE選択用ボタンの表示 01643 gu_set_button(9,""); 01644 gu_set_button(17,""); 01645 gu_set_button(25,""); 01646 gu_set_button(13,""); 01647 gu_set_button(21,""); 01648 gu_set_button(29,""); 01649 //LED Brighness 01650 gu_fontsize(2); 01651 gu_cursor(36,32/8); 01652 gu_print1("CAL"); 01653 gu_cursor(36,64/8); 01654 gu_print1("LUX"); 01655 //gu_cursor(36,80/8); 01656 //gu_print1("illumi"); 01657 //Display Brightness 01658 gu_cursor(36,96/8); 01659 gu_print1("Utility"); 01660 //Auto MODE 01661 gu_cursor(164,32/8); 01662 gu_print1("Auto"); 01663 //Manual Mode 01664 gu_cursor(164,64/8); 01665 gu_print1("Manual"); 01666 //Sequenser Mode 01667 gu_cursor(164,96/8); 01668 gu_print1("SEQ"); 01669 01670 /********************** 01671 SDカードファイルオープン 01672 **********************/ 01673 01674 mkdir("/sd/mydir", 0777); 01675 01676 FILE *fp = fopen("/sd/mydir/iop.csv", "ab+");//ディレクトリとファイル名の指定 01677 01678 if(fp == NULL) { 01679 /*ver1.1.3 01680 gu_fontsize(1); 01681 gu_cursor(0,2); 01682 gu_print1("Could not open file for SD card"); 01683 */ 01684 } else { 01685 fprintf(fp, "NewData R IOP OCP VOC"); 01686 fprintf(fp, "\n"); 01687 fclose(fp); 01688 } 01689 /********************** 01690 LED照度初期設定 01691 **********************/ 01692 read_syoudo( csyoudo ); 01693 01694 //gu-D タッチスイッチ読み出し動作設定 p49 01695 cmd_gu[0]= 0x1F; 01696 cmd_gu[1]= 0x4B; 01697 cmd_gu[2]= 0x18; 01698 cmd_gu[3]= 0x02;//SW状態変化時自動送信モード2 01699 i2c.write(addr_gu, cmd_gu, 4); //gu-D タッチスイッチ読み出し動作設定 p49 01700 01701 while(1) { 01702 01703 //ﾀｯﾁｽｲｯﾁ読み出し 01704 i2c.read ((addr_gu + 0x01), crdata, 3, true); 01705 01706 if (crdata[0] == 0x11 ) { //個別ﾀｯﾁｽｲｯﾁ状態読み出しﾌｫｰﾏｯﾄ。識別子11h。 01707 *pcswnum = crdata[1]; //ｽｲｯﾁ番号 01708 *pcswdata = crdata[2];//ON/OFF情報 01709 01710 if (cswdata == 0x01) { //ﾀｯﾁしたならば 01711 switch( cswnum ) { //SWの番号（位置） 01712 01713 case 0x08 ://SW9 CAL登録画面 01714 //gu_ﾘﾊﾞｰｽ指定 01715 gu_reverse(0x01); 01716 //Show Button 01717 gu_set_button(9,""); 01718 wait(0.1); 01719 //gu_ﾘﾊﾞｰｽ解除 01720 gu_reverse(0x00); 01721 01722 select_cal();//CAL選択画面へ移動 01723 01724 return; 01725 01726 case 0x10 ://SW17 01727 //gu_ﾘﾊﾞｰｽ指定 01728 gu_reverse(0x01); 01729 //Show Button 01730 gu_set_button(17,""); 01731 wait(0.1); 01732 //gu_ﾘﾊﾞｰｽ解除 01733 gu_reverse(0x00); 01734 01735 adjust_illumination();//LED照度調整へ移動 01736 01737 return; 01738 01739 case 0x18 ://SW25 01740 //gu_ﾘﾊﾞｰｽ指定 01741 gu_reverse(0x01); 01742 //Show Button 01743 gu_set_button(25,""); 01744 wait(0.1); 01745 //gu_ﾘﾊﾞｰｽ解除 01746 gu_reverse(0x00); 01747 01748 utility();//画面輝度調整へ移動 01749 01750 return; 01751 01752 case 0x0C ://SW13 自動測定モード 01753 //gu_ﾘﾊﾞｰｽ指定 01754 gu_reverse(0x01); 01755 //Show Button 01756 gu_set_button(13,""); 01757 wait(0.1); 01758 //gu_ﾘﾊﾞｰｽ解除 01759 gu_reverse(0x00); 01760 01761 auto_run(); 01762 01763 return; 01764 01765 case 0x14 ://SW21 手動測定モード 01766 //gu_ﾘﾊﾞｰｽ指定 01767 gu_reverse(0x01); 01768 //Show Button 01769 gu_set_button(21,""); 01770 wait(0.1); 01771 //gu_ﾘﾊﾞｰｽ解除 01772 gu_reverse(0x00); 01773 01774 manual(); 01775 01776 return; 01777 01778 case 0x1C ://SW29 シーケンサ制御モード 01779 //gu_ﾘﾊﾞｰｽ指定 01780 gu_reverse(0x01); 01781 //Show Button 01782 gu_set_button(29,""); 01783 wait(0.1); 01784 //gu_ﾘﾊﾞｰｽ解除 01785 gu_reverse(0x00); 01786 01787 seq(); 01788 01789 return; 01790 01791 } //switch 01792 01793 }//if(cswdata == 0x01) { 01794 } //if(crdata[0] == 0x11 ) { 01795 01796 wait(0.1);//ﾀｯﾁｽｲｯﾁ入力読み出し間隔 01797 01798 } //while(1) { 01799 01800 } 01801 01802 /******************************************************************************* 01803 01804 CAL選択画面 sub 01805 01806 ver3.0.0 CAL名を追加 01807 01808 *******************************************************************************/ 01809 void show_info(int n) 01810 { 01811 short sdata[6]; 01812 char cl[2]; 01813 01814 read_caliber(&calinfo,n); 01815 01816 //読出したCAL情報の表示 01817 gu_fontsize(1); 01818 gu_cursor(0,2); 01819 gu_print1(" "); 01820 gu_fontsize(1); 01821 gu_cursor(0,2); 01822 gu_print1("No."); 01823 01824 cl[1] = calinfo.number % 10 + '0'; 01825 cl[0] = calinfo.number /10 + '0'; 01826 01827 gu_print(cl); 01828 //gu_putdec(&calinfo.number); 01829 01830 gu_print1(" CAL."); 01831 //gu_print1(calinfo.name); 01832 i2c.write(addr_gu, calinfo.name, 4); //4byte ascii code 01833 01834 gu_cursor(0,3); 01835 gu_print1("Vss(Iop) ="); 01836 sdata[0] = -1 * calinfo.vss_iop; 01837 gu_putdeck(&sdata[0]); 01838 gu_print1("V "); 01839 gu_cursor(0,4); 01840 gu_print1("Vss(ocp) ="); 01841 sdata[1] = -1 * calinfo.vss_ocp; 01842 gu_putdeck(&sdata[1]); 01843 gu_print1("V "); 01844 gu_cursor(0,5); 01845 gu_print1("Vss(Voc) ="); 01846 sdata[2] = -1 * calinfo.vss_voc; 01847 gu_putdeck(&sdata[2]); 01848 gu_print1("V "); 01849 } 01850 /******************************************************************************* 01851 01852 GU-D CAL選択スイッチボタン再表示 サブ 01853 01854 画面上にあるスイッチの配置 01855 01856 01,02,03,04,05,06,07,08, 01857 09,10,11,12,13,14,15,16, 01858 17,18,19,20,21,22,23,24, 01859 25,26,27,28,29,30,31,32, 01860 01861 *******************************************************************************/ 01862 void redraw_sw(int dig, char sw_num){ 01863 01864 char str_num[3]; // ascii code 01865 char sw; // GU-D Swich Number 01866 01867 str_num[2] = 0; // null終端 01868 01869 if ( dig >= 1 ){ 01870 str_num[0] = dig + 0x30; //convert ASCII １０の位 01871 } else { 01872 str_num[0] = 0x20; //space 01873 } 01874 01875 for ( sw = 17; sw <= 29; sw++ ){ 01876 01877 if ( sw >= 22 && sw <= 24 ){ 01878 continue; 01879 } 01880 01881 if ( sw <= 21 ){ 01882 str_num[1] = ( sw - 16 ) + 0x30; 01883 } else if ( sw >= 24 && sw <= 28 ){ 01884 str_num[1] = ( sw - 19 ) + 0x30; 01885 } else if ( sw == 29) { 01886 str_num[0] = ( dig + 1 )+ 0x30; 01887 str_num[1] = 0x30; 01888 } 01889 01890 if ( sw_num != sw ){ 01891 gu_set_button(sw,str_num); 01892 } else { 01893 gu_reverse(0x01); //gu_ﾘﾊﾞｰｽ指定 01894 gu_set_button(sw,str_num); 01895 gu_reverse(0x00); //gu_ﾘﾊﾞｰｽ解除 01896 } 01897 }//for 01898 } 01899 01900 /******************************************************************************* 01901 01902 CAL選択画面 #CAL登録画面 01903 01904 画面上にあるスイッチの配置 01905 01906 01,02,03,04,05,06,07,08, 01907 09,10,11,12,13,14,15,16, 01908 17,18,19,20,21,22,23,24, 01909 25,26,27,28,29,30,31,32, 01910 01911 *******************************************************************************/ 01912 void select_cal() 01913 { 01914 char crdata[3]; 01915 char cswnum; //SW_No. sw1->0x00 ~~ sw32->0x1F 01916 char cswdata; // 0x00 or 0x01 01917 char *pcswnum = &cswnum; 01918 char *pcswdata = &cswdata; 01919 char calnum; //選択したCALﾅﾝﾊﾞｰ 01920 01921 int digit = 0 ; //CAL番号 １０の位の値 0~4 01922 bool redraw ; //再描画 01923 01924 read_regnum();//EEPROMに保存した選択CAL_NO.の読み出し 01925 01926 while(1){//ver3 01927 01928 redraw = false; 01929 01930 calnum = 0; //initial 01931 01932 gu_cls(); //GU-D 画面クリア 01933 01934 show_info(reg_num); 01935 01936 gu_fontsize(2); //change fontsize 01937 gu_cursor(0,0); 01938 //ver3.0.0 01939 //gu_print1("Select CAL."); 01940 gu_print1("CONFIG"); 01941 01942 //Set Button init ver3.0.0 01943 redraw_sw(calnum,0); 01944 01945 gu_set_button_font1(7,"slct"); 01946 gu_set_button_font1(8,"set"); 01947 01948 gu_button_up(24); 01949 gu_button_down(32); 01950 01951 while(1) { 01952 //ﾀｯﾁｽｲｯﾁ読み出し 01953 i2c.read ((addr_gu + 0x01), crdata, 3, true); 01954 01955 if (crdata[0] == 0x11 ) { //個別ﾀｯﾁｽｲｯﾁ状態読み出しﾌｫｰﾏｯﾄ。識別子11h。 01956 *pcswnum = crdata[1]; //ｽｲｯﾁ番号 01957 *pcswdata = crdata[2];//ON/OFF情報 01958 01959 if (cswdata == 0x01) { //ﾀｯﾁしたならば 01960 switch( cswnum ) { //SWの番号（位置） 01961 01962 case 23: //SW24 page up 01963 01964 if ( digit <= 3 ){ 01965 digit += 1; 01966 } else if ( digit == 4 ){ 01967 digit = 0; 01968 } 01969 01970 redraw_sw(digit,0); 01971 01972 //calnum = digit * 10 + 1; 01973 //show_info(calnum); 01974 01975 break; 01976 01977 case 31: //SW32 page down 01978 01979 if ( digit >= 1 ){ 01980 digit -= 1; 01981 } else if ( digit == 0 ) { 01982 digit = 4; 01983 } 01984 01985 redraw_sw(digit,0); 01986 01987 //calnum = digit * 10 + 1; 01988 //show_info(calnum); 01989 01990 break; 01991 01992 case 16: //SW17 01993 case 17: //SW18 01994 case 18: //SW19 01995 case 19: //SW20 01996 case 20: //SW21 01997 01998 calnum = cswnum - 15 + (digit*10); 01999 02000 redraw_sw(digit,cswnum + 1); 02001 02002 show_info(calnum); 02003 02004 break; 02005 02006 case 24: //SW25 02007 case 25: //SW26 02008 case 26: 02009 case 27: 02010 02011 02012 calnum = cswnum - 18 + (digit*10); 02013 02014 redraw_sw(digit,cswnum + 1); 02015 02016 show_info(calnum); 02017 02018 break; 02019 02020 case 28: //SW29 02021 02022 calnum = ((digit + 1 )*10); 02023 02024 redraw_sw(digit,cswnum + 1); 02025 02026 show_info(calnum); 02027 02028 break; 02029 02030 case 0x06: //SW7 ”slct"(CAL選択)ボタン 02031 02032 if ( calnum >= 1 && calnum <=6 ) { 02033 reg_num = calnum; 02034 02035 //ver3 EEPROM書込み Byte Write 02036 wdata[0] = adrs_calnum[0]; //byte address a15~8 02037 wdata[1] = adrs_calnum[1]; //byte address a7~a0 02038 wdata[2] = reg_num; 02039 Soushin = i2c.write (eeprom_adrs, wdata, 3); //send stop at end default value is false. 02040 02041 //GU-D 02042 gu_reverse(0x01); //gu_ﾘﾊﾞｰｽ指定 02043 gu_set_button_font1(7,"slct"); 02044 wait(0.2); 02045 gu_reverse(0x00); //gu_ﾘﾊﾞｰｽ解除 02046 02047 read_caliber(&calinfo,reg_num); 02048 02049 return; 02050 02051 } else if( calnum == 0 ) { 02052 //CALNo.選択しなければ、何もしないでこのサブを抜ける 02053 gu_reverse(0x01); //gu_ﾘﾊﾞｰｽ指定 02054 gu_set_button_font1(7,"slct"); 02055 wait(0.2); 02056 gu_reverse(0x00); //gu_ﾘﾊﾞｰｽ解除 02057 return; 02058 } 02059 02060 break; 02061 02062 case 0x07: //SW8 "set"ボタン 02063 02064 if ( calnum >= 1 && calnum <= 50 ) { 02065 gu_reverse(0x01); //gu_ﾘﾊﾞｰｽ指定 02066 gu_set_button_font1(8,"set"); 02067 wait(0.2); 02068 gu_reverse(0x00); //gu_ﾘﾊﾞｰｽ解除 02069 02070 setup_cal_information(calnum);//CAL情報登録画面へ 02071 02072 //return; 02073 redraw = true; 02074 } 02075 break; 02076 02077 } //switch 02078 02079 if (redraw){ 02080 break; //exit while 02081 } 02082 02083 }//if(cswdata == 0x01) { 02084 } //if(crdata[0] == 0x11 ) { 02085 wait(0.1);//ﾀｯﾁｽｲｯﾁ入力読み出し間隔 02086 } //while(1) 02087 02088 } 02089 } 02090 02091 /******************************************************************************* 02092 02093 CAL情報登録画面 ｻﾌﾞﾙｰﾁﾝ 02094 項目の表示 02095 02096 ver3.0.0 22.4.12 02097 02098 x=0 : vss_iop[V] 02099 x=1 : vss_ocp[V] 02100 x=2 : vss_voc[V] 02101 x=3 : low_limit_voc[V] 02102 x=4 : low_limit_iop[uA] 02103 x=5 : low_limit_ocp[uA] 02104 x=6 : up_limit_ocp[uA] 02105 x=7 : low_limit_ocp_v[V] 02106 x=8 : up_limit_ocp_v[V] 02107 x=9 : wait_iop[s] 02108 x=10 : wait_ocp[s] 02109 x=11 : wait_voc[s] 02110 x=12 : low_limit_resistor[Ω] 02111 x=13 : up_limit_resistor[Ω] 02112 x=14 : cal_name(ASCII) 02113 02114 /1.2.1 02115 x=0 : vss_iop[V] 02116 x=1 : vss_ocp[V] 02117 x=2 : vss_voc[V] 02118 x=3 : low_limit_voc[V] 02119 x=4 : low_limit_iop[uA] 02120 x=5 : low_limit_ocp[uA] 02121 x=6 : up_limit_ocp[uA] ver1.2.2 追加 02122 x=7 : wait_iop[s] 02123 x=8 : wait_ocp[s] 02124 x=9 : low_limit_resistor[Ω] 02125 x=10 : up_limit_resistor[Ω] 02126 / 02127 02128 *******************************************************************************/ 02129 void hyouji_cal_param(int x) 02130 { 02131 gu_fontsize(2); 02132 gu_cursor(0,4); 02133 gu_print1(" "); 02134 gu_cursor(0,6); 02135 gu_print1(" "); 02136 02137 gu_fontsize(2); 02138 gu_cursor(zahyou_para1[0],zahyou_para1[1]); 02139 gu_print1(cpara1[x]); 02140 gu_fontsize(2); 02141 gu_cursor(zahyou_para2[0],zahyou_para2[1]); 02142 gu_print1(cpara2[x]); 02143 02144 gu_fontsize(2); 02145 gu_cursor(zahyou_unit[0],zahyou_unit[1]); 02146 02147 if ( x == 12 || x == 13 ){ 02148 wdata[0] = 0xEA; //Ω 02149 i2c.write( addr_gu, wdata, 1); 02150 } else { 02151 gu_print1(cunit[x]); 02152 } 02153 02154 } 02155 02156 /******************************************************************************* 02157 02158 CAL情報登録画面 sub 02159 02160 para kind of parameter 02161 idata data value 02162 inc add number ex)0x64 0x0A 0x01 02163 02164 *******************************************************************************/ 02165 /*** 加算 ***/ 02166 void increase_param(int para, signed short *sdata, short inc) 02167 { 02168 switch ( para ) { //パラメータの項目によって上限値異なる 02169 case 0://vss_iop 02170 case 1://vss_ocp 02171 case 2://vss_voc 02172 case 3://low_limit_voc 02173 case 7://low_limit_ocp_v 02174 case 8://up_limit_ocp_v 02175 if(*sdata <= ( 4999 - inc )) { 02176 *sdata = *sdata + inc ; 02177 } 02178 break;//switch ( param ){ 02179 02180 case 4: //low_limit_iop 02181 case 5: //low_limit_o.c.p 02182 case 6: //up_limit_o.c.p 02183 if(*sdata <= ( 2500 - inc / 10 )) { 02184 *sdata = *sdata + inc /10 ; 02185 } 02186 break;//switch ( param ) 02187 case 9: //wait_iop 02188 case 10: //wait_ocp 02189 case 11: //wait_voc 02190 02191 if(*sdata <= ( 2550 - inc / 10 )) { 02192 *sdata = *sdata + inc / 10 ; 02193 } 02194 break;//switch ( param ) 02195 02196 case 12: //low_limit_resistor 02197 case 13: //up_limit_resistor 02198 if(*sdata <= ( 2550 - inc )) { 02199 *sdata = *sdata + inc; 02200 } 02201 break; 02202 02203 }//switch ( param ){ 02204 } 02205 02206 /*** 減算 ***/ 02207 void decrease_param(int para, signed short *sdata, short dec) 02208 { 02209 switch ( para ) { //パラメータの項目によって上限値異なる 02210 case 0://vss_iop 02211 case 1://vss_ocp 02212 case 2://vss_voc 02213 case 3://low_limit_voc 02214 case 7://low_limit_ocp_v 02215 case 8://up_limit_ocp_v 02216 02217 if(*sdata >= dec ) { 02218 *sdata = *sdata - dec; 02219 } 02220 break; 02221 02222 case 4://low_limit_iop 02223 02224 if(*sdata >= dec / 10 ) { 02225 *sdata = *sdata - dec / 10; 02226 } 02227 break; 02228 02229 case 5://low_limit_o.c.p 02230 case 6://up_limit_o.c.p 02231 02232 if(*sdata >= -2500 + dec / 10 ) { 02233 *sdata = *sdata - dec / 10; 02234 } 02235 break; 02236 02237 case 9: //wait_iop 02238 case 10: //wait_ocp 02239 case 11: //wait_voc 02240 02241 if(*sdata >= dec / 10 ) { 02242 *sdata = *sdata - dec / 10 ; 02243 } 02244 break;//switch ( param ) 02245 02246 case 12: //low_limit_resistor 02247 case 13: //up_limit_resistor 02248 02249 if(*sdata >= dec ) { 02250 *sdata = *sdata - dec; 02251 } 02252 break; 02253 02254 }//switch ( param ){ 02255 } 02256 02257 /******************************************************************************* 02258 02259 CAL NAME (ASCII) 02260 3文字で構成(ex.B61)。1文字づつ上下キーで変更する。 02261 範囲はASCII表において 0x30～0x5A 02262 02263 ver3.0.0 2022.4.13 02264 02265 *******************************************************************************/ 02266 /*** UP ***/ 02267 void up_ascii(char *c){ 02268 02269 if (*c >= 0x5A ){ 02270 *c = 0x30; 02271 } else if ( *c < 0x30 ){ 02272 *c = 0x30; 02273 } else { 02274 *c = *c + 1; 02275 } 02276 02277 } 02278 /*** DOWN ***/ 02279 void down_ascii(char *c){ 02280 02281 if (*c > 0x5A ){ 02282 *c = 0x5A; 02283 } else if ( *c <= 0x30 ){ 02284 *c = 0x5A; 02285 } else { 02286 *c = *c - 1; 02287 } 02288 02289 } 02290 /******************************************************************************* 02291 02292 CAL情報登録画面 表示 02293 02294 ****** Swich matrix ****** 02295 01,02,03,04,05,06,07,08, 02296 09,10,11,12,13,14,15,16, 02297 17,18,19,20,21,22,23,24, 02298 25,26,27,28,29,30,31,32, 02299 *************************** 02300 02301 *******************************************************************************/ 02302 void disp_setup_cal(char cal_num , int parameter){ 02303 02304 char wdata[2]; 02305 02306 gu_cls();//clear dispray 02307 gu_fontsize(1); 02308 gu_print1("SETUP No."); 02309 wdata[0] = ( cal_num / 10 ) + 0x30;//ver3.0.0 02310 wdata[1] = ( cal_num % 10 ) + 0x30;//show caliber number 02311 i2c.write(addr_gu, wdata, 2); 02312 02313 if( parameter == 14 ){ 02314 gu_button_up(sw_up_set[3]); 02315 gu_button_down(sw_down_set[3]); 02316 } 02317 02318 gu_set_button_font1(7,"esc"); 02319 gu_set_button_font1(8,"save"); 02320 gu_button_up(17); 02321 gu_button_down(25); 02322 gu_button_up(sw_up_set[0]); 02323 gu_button_up(sw_up_set[1]); 02324 gu_button_up(sw_up_set[2]); 02325 gu_button_down(sw_down_set[0]); 02326 gu_button_down(sw_down_set[1]); 02327 gu_button_down(sw_down_set[2]); 02328 02329 hyouji_cal_param(parameter); 02330 02331 } 02332 02333 02334 /******************************************************************************* 02335 02336 PASS WORD 画面 02337 02338 *******************************************************************************/ 02339 void pw(int* pflag){ 02340 02341 char crdata[3];//GUDからの受信データ 02342 char strnum[2]; 02343 char basho = 0; 02344 char word[YOSO]; 02345 char c[2];//GU-D SW 表示文字 02346 int j = 0; 02347 02348 gu_cls();//clear dispray 02349 02350 strnum[1] = 0;//NULL 02351 c[1]=0;//NULL 02352 02353 for ( int i = 0; i <=25; i++ ){ 02354 strnum[0] = i + 0x41; 02355 gu_set_button( (basho + 1 ) ,strnum); 02356 basho = basho + 1; 02357 } 02358 02359 wait(0.2); 02360 02361 int i = 0; 02362 02363 while(1) { 02364 02365 i2c.read ((addr_gu + 0x01), crdata, 3, true); 02366 02367 if (crdata[0] == 0x11 && crdata[2] == 0x01 ) { //個別ﾀｯﾁｽｲｯﾁ状態読み出しﾌｫｰﾏｯﾄ。識別子11h。&& ﾀｯﾁしたならば 02368 02369 word[j] = crdata[1] + 0x41; 02370 c[0] = word[j]; 02371 02372 gu_reverse(1); 02373 gu_set_button( (crdata[1] + 1 ) ,c); 02374 gu_reverse(0); 02375 02376 j = j + 1; 02377 02378 } 02379 02380 if ( j == YOSO ){ 02381 02382 while (1){ 02383 if ( word[i] != pass[i] ){ 02384 *pflag = 1; 02385 break; 02386 } 02387 if (i == ( YOSO - 1) ){ 02388 break; 02389 } 02390 02391 i += 1; 02392 } 02393 02394 wait(0.5); 02395 return; 02396 02397 }//if 02398 02399 wait(0.2); 02400 02401 }//while 02402 } 02403 /******************************************************************************* 02404 02405 CAL情報登録画面 MAIN 02406 別途システム設計図,EEPROMのシートを参照 02407 02408 ver3.0.0 02409 02410 param: 02411 0:vss_iop 02412 1:vss_ocp 02413 2:vss_voc 02414 3:low_limit_voc 02415 4:low_limit_iop 02416 5:low_limit_ocp 02417 6:up_limit_ocp 02418 7:low_limit_ocp_v 02419 8:up_limit_ocp_v 02420 9:wait_iop 02421 10:wait_ocp 02422 11:wait_voc 02423 12:LowLimitResistor 02424 13:UPLimitResistor 02425 14:CAL_name 02426 02427 *******************************************************************************/ 02428 void setup_cal_information(char cal_num) 02429 { 02430 int param; //設定するパラメータの選択 02431 char crdata[3]; //GU-Dからの受信DATA 3byte 02432 signed short sdata_cal[18]; //CAL設定条件 02433 signed short hyouji_data; 02434 int param_sum = 14; //パラメータの最大設定数 02435 char c_temp[4]; //CAL名設定条件 calinfo.name 02436 //int i; 02437 //short sdata_byte[16]; //EEPROM BYTEごとのDATA 1byte 02438 //char cmd_gu[32]; //gu-DへのI2Cコマンド用配列 1byte0 02439 //char adrs_cal; //EEPROM CAL情報を保存しているアドレス 0x90~ 02440 02441 int pwflag = 0; 02442 02443 pw(&pwflag); 02444 02445 if ( pwflag != 0 ){ 02446 return; 02447 } 02448 02449 //Load caliber information 02450 read_caliber(&calinfo,cal_num); 02451 02452 sdata_cal[0] = calinfo.vss_iop; 02453 sdata_cal[1] = calinfo.vss_ocp; 02454 sdata_cal[2] = calinfo.vss_voc; 02455 sdata_cal[3] = calinfo.low_limit_voc; 02456 sdata_cal[4] = calinfo.low_limit_iop; 02457 sdata_cal[5] = calinfo.low_limit_ocp; 02458 sdata_cal[6] = calinfo.up_limit_ocp; 02459 sdata_cal[7] = calinfo.low_limit_ocp_v; 02460 sdata_cal[8] = calinfo.up_limit_ocp_v; 02461 sdata_cal[9] = calinfo.wait_iop; 02462 sdata_cal[10] = calinfo.wait_ocp; 02463 sdata_cal[11] = calinfo.wait_voc; 02464 sdata_cal[12] = calinfo.low_limit_resistor; 02465 sdata_cal[13] = calinfo.up_limit_resistor; 02466 02467 c_temp[0] = calinfo.name[0]; 02468 c_temp[1] = calinfo.name[1]; 02469 c_temp[2] = calinfo.name[2]; 02470 c_temp[3] = calinfo.name[3]; 02471 02472 //初期表示はCAL名設定 02473 param = 14; 02474 disp_setup_cal(cal_num,param); 02475 02476 while(1) { 02477 i2c.read ((addr_gu + 0x01), crdata, 3, true); 02478 02479 if (crdata[0] == 0x11 && crdata[2] == 0x01 ) { //個別ﾀｯﾁｽｲｯﾁ状態読み出しﾌｫｰﾏｯﾄ。識別子11h。&& ﾀｯﾁしたならば 02480 //cswnum = crdata[1]; //ｽｲｯﾁ番号 02481 //cswdata = crdata[2];//ON/OFF情報 02482 02483 //タッチしたSWの番号（位置）による分岐 02484 02485 //sw17 パラメータ変更スイッチ(上) 02486 if ( crdata[1] == 16 ){ 02487 02488 if ( param <= param_sum -1 ) { 02489 param = param + 1; 02490 } else { 02491 param = 0; 02492 } 02493 02494 disp_setup_cal(cal_num,param); 02495 //hyouji_cal_param(param);//設定パラメータ表示 02496 02497 } 02498 02499 //case 0x18 ://sw25 パラメータ変更スイッチ(下) 02500 if ( crdata[1] == 24 ){ 02501 02502 if ( param >= 1 ) { 02503 param = param - 1; 02504 } else { 02505 param = param_sum; 02506 } 02507 02508 disp_setup_cal(cal_num,param); 02509 //hyouji_cal_param(param);//設定パラメータ表示 02510 02511 } 02512 02513 if ( crdata[1] == (sw_up_set[0] - 1)){ //increase 02514 02515 // if set caliber name .. ver3 02516 if ( param == 14 ){ 02517 up_ascii(&c_temp[0]); 02518 } else { 02519 increase_param(param, &sdata_cal[param], 1000); 02520 } 02521 } 02522 02523 if ( crdata[1] == (sw_up_set[1] - 1)){ //increase 02524 02525 if ( param == 14 ){ 02526 up_ascii(&c_temp[1]); 02527 } else { 02528 increase_param(param, &sdata_cal[param], 100); 02529 } 02530 } 02531 02532 if ( crdata[1] == (sw_up_set[2] - 1)){ //SW** increase 02533 02534 if ( param == 14 ){ 02535 up_ascii(&c_temp[2]); 02536 } else { 02537 increase_param(param, &sdata_cal[param], 10); 02538 } 02539 } 02540 02541 if ( crdata[1] == (sw_up_set[3] - 1)){ //SW** increase CAL名設定時に使用する 02542 02543 if ( param == 14 ){ 02544 up_ascii(&c_temp[3]); 02545 } 02546 } 02547 02548 if ( crdata[1] == (sw_down_set[0] - 1)){ //SW** decrease 02549 02550 if ( param == 14 ){ 02551 down_ascii(&c_temp[0]); 02552 } else { 02553 decrease_param(param, &sdata_cal[param], 1000); 02554 } 02555 } 02556 02557 if ( crdata[1] == (sw_down_set[1] - 1)){ //SW** decrease 02558 02559 if ( param == 14 ){ 02560 down_ascii(&c_temp[1]); 02561 } else { 02562 decrease_param(param, &sdata_cal[param], 100); 02563 } 02564 } 02565 02566 if ( crdata[1] == (sw_down_set[2] - 1)){ //SW** decrease 02567 02568 if ( param == 14 ){ 02569 down_ascii(&c_temp[2]); 02570 } else { 02571 decrease_param(param, &sdata_cal[param], 10); 02572 } 02573 } 02574 02575 if ( crdata[1] == (sw_down_set[3] - 1)){ //SW** decrease 02576 02577 if ( param == 14 ){ 02578 down_ascii(&c_temp[3]); 02579 } 02580 } 02581 02582 if ( crdata[1] == 6 ){ //SW7 "esc"ボタン 02583 02584 gu_reverse(1); 02585 gu_set_button_font1(7,"esc"); 02586 wait(0.2); 02587 gu_reverse(0);//ver3 02588 02589 return; //何もせずに抜ける 02590 } 02591 02592 if ( crdata[1] == 7 ){ //SW8 "save"保存ボタン 02593 02594 //ver3 CAL情報 代入 02595 //*** ver3 *** 02596 calinfo.vss_iop = sdata_cal[0]; 02597 calinfo.vss_ocp = sdata_cal[1]; 02598 calinfo.vss_voc = sdata_cal[2]; 02599 calinfo.low_limit_voc = sdata_cal[3]; 02600 calinfo.low_limit_iop = sdata_cal[4]; 02601 calinfo.low_limit_ocp = sdata_cal[5]; 02602 calinfo.up_limit_ocp = sdata_cal[6]; 02603 calinfo.up_limit_ocp_v = sdata_cal[7]; 02604 calinfo.low_limit_ocp_v = sdata_cal[8]; 02605 calinfo.wait_iop = sdata_cal[9]; 02606 calinfo.wait_ocp = sdata_cal[10]; 02607 calinfo.wait_voc = sdata_cal[11]; 02608 calinfo.low_limit_resistor = sdata_cal[12]; 02609 calinfo.up_limit_resistor = sdata_cal[13]; 02610 02611 calinfo.name[0] = c_temp[0]; 02612 calinfo.name[1] = c_temp[1]; 02613 calinfo.name[2] = c_temp[2]; 02614 calinfo.name[3] = c_temp[3]; 02615 02616 /*ver3 Byte Write CALNO.EEPROM 書込み 02617 reg_num = cal_num; 02618 wdata[0] = adrs_calnum[0]; 02619 wdata[1] = adrs_calnum[1]; 02620 wdata[2] = reg_num; 02621 02622 Soushin = i2c.write (eeprom_adrs, wdata, 3); //send stop at end 02623 wait(0.2); 02624 */ 02625 02626 /*** ver3 *** 02627 //CAL情報 >> EEPROM 02628 //送信完了ならば実行 02629 if(Soushin == 0) { 02630 02631 write_caliber_information(&calinfo, cal_num); 02632 02633 //ver1.2.3 02634 } else { 02635 gu_fontsize(1); 02636 gu_cursor(0,2); 02637 gu_print1("can not save cal no"); 02638 wait(2); 02639 return; 02640 } 02641 ***/ 02642 02643 /*** ver3 ***/ 02644 write_caliber_information(&calinfo, cal_num); 02645 02646 //送信完了ならば実行 02647 if(Soushin == 0) { 02648 gu_reverse(1); 02649 gu_set_button_font1(8,"save"); 02650 wait(0.2); 02651 gu_reverse(0);//ver3 02652 return;//CAL情報登録画面を抜ける 02653 02654 //ver1.2.3 02655 } else { 02656 gu_fontsize(1); 02657 gu_cursor(0,2); 02658 gu_print1("can not save cal information"); 02659 wait(2); 02660 return; 02661 } 02662 02663 }//end if 02664 }//end if 02665 02666 //gu-D表示 ver3 02667 gu_fontsize(2); 02668 gu_cursor(zahyou_val[0],zahyou_val[1]); //表示位置の指定 02669 02670 switch ( param ) { 02671 case 0://vss_iop 02672 case 1://vss_ocp 02673 case 2://vss_voc 02674 case 3://low_limit_voc 02675 case 7://low_limit_voc_v 02676 case 8://up_limit_voc_v 02677 hyouji_data = sdata_cal[param] * -1; 02678 gu_putdeck ( &hyouji_data ); 02679 break; 02680 02681 case 4://low_limit_iop 02682 case 5://low_limit_ocp 02683 case 6://up_limit_ocp 02684 hyouji_data = sdata_cal[param] * 10; 02685 gu_putdeck ( &hyouji_data ); 02686 break; 02687 02688 case 9: //wait_iop 02689 case 10: //wait_ocp 02690 case 11: //wait_voc 02691 //ver1.1.0 02692 hyouji_data = sdata_cal[param]; 02693 gu_putdec ( &hyouji_data ); 02694 break; 02695 02696 case 12://low_limit_resistor 02697 case 13://up_limit_resistor 02698 hyouji_data = sdata_cal[param]; 02699 gu_putdec ( &hyouji_data ); 02700 break; 02701 02702 case 14: //cal name ver3 02703 i2c.write(addr_gu, c_temp, 4); //3byte ascii code 02704 break; 02705 02706 }//swith 02707 wait(0.1);//gu-D 読込間隔の設定 02708 }//while 02709 } 02710 02711 /********************************* 02712 02713 Auto Mode (sub) 02714 自動測定モード 初期画面 02715 02716 *********************************/ 02717 void auto_int_hyouji() 02718 { 02719 //short st; 02720 char cmd_gu[32] ; //gu-DへのI2Cコマンド用配列 1byte 02721 02722 gu_cls(); 02723 gu_fontsize(1); 02724 gu_print1("AUTO MODE CAL No."); 02725 cmd_gu[0] = reg_num + 0x30; 02726 i2c.write(addr_gu, cmd_gu, 1); 02727 gu_Button_power_on();//show button 02728 02729 } 02730 /******************************************************* 02731 02732 Auto Mode (Main) 02733 自動測定モード 画面 02734 ver1.04 パネルタッチ -> スタートスイッチで測定開始へ変更 02735 02736 *******************************************************/ 02737 void auto_run() 02738 { 02739 char cmd_gu[32] ; //gu-DへのI2Cコマンド用配列 1byte 02740 char crdata[6]; 02741 //char cswnum; //SW_No. sw1->0x00 ~~ sw32->0x1F 02742 //int i; 02743 //float fdata[4][4];//ファイル出力用 02744 //short sdata[4]; 02745 //short s; 02746 02747 read_regnum();//CAL登録No.読込 02748 read_caliber(&calinfo,reg_num);//指定したCAL登録No.の情報を読込後、calinfoへ代入 02749 02750 auto_int_hyouji(); 02751 02752 //dac_init(); //DAC 初期化 02753 02754 //gu-D タッチスイッチ読み出し動作設定 p49 02755 cmd_gu[0]= 0x1F; 02756 cmd_gu[1]= 0x4B; 02757 cmd_gu[2]= 0x18; 02758 cmd_gu[3]= 0x02;//SW状態変化時自動送信モード2 02759 i2c.write(addr_gu, cmd_gu, 4); //gu-D タッチスイッチ読み出し動作設定 p49 02760 02761 wait(0.1); 02762 02763 Jyushin = i2c.read ((addr_gu + 0x01), crdata, 3, true); 02764 02765 while(1) { 02766 //ｽﾀｰﾄｽｲｯﾁで測定開始 02767 if ( sw_start == 0 ) { 02768 meas_sub(); 02769 } 02770 02771 wait(0.1); 02772 02773 crdata[0] = 0; 02774 crdata[1] = 0; 02775 crdata[2] = 0; 02776 02777 i2c.read ((addr_gu + 0x01), crdata, 3, true); 02778 02779 if ( crdata[0] == 0x11 && crdata[2] == 1 ) { //個別ﾀｯﾁｽｲｯﾁ状態読み出しﾌｫｰﾏｯﾄ。識別子11h。 02780 02781 //cswnum = crdata[1]; //ｽｲｯﾁ番号 02782 //cswdata = crdata[2];//ON/OFF情報 02783 02784 //gu-D タッチスイッチ読み出し動作設定 p49 02785 cmd_gu[0]= 0x1F; 02786 cmd_gu[1]= 0x4B; 02787 cmd_gu[2]= 0x18; 02788 cmd_gu[3]= 0x00;//SW状態変化時自動送信モード2解除 02789 i2c.write(addr_gu, cmd_gu, 4); //gu-D タッチスイッチ読み出し動作設定 p49 02790 02791 if ( crdata[1] == 7 ) { 02792 02793 gu_Button_power_off();//電源ﾎﾞﾀﾝｲﾒｰｼﾞ反転表示 02794 wait(0.5); 02795 02796 led_off();//LED全消灯 02797 02798 return;//この関数を抜ける 02799 02800 } //end if 02801 02802 /* ver 1.1.1 タッチパネルで測定開始を削除 02803 else { 02804 02805 meas_sub();//測定用サブ 02806 02807 02808 } //else if 02809 */ 02810 02811 //gu-D タッチスイッチ読み出し動作設定 p49 02812 cmd_gu[0]= 0x1F; 02813 cmd_gu[1]= 0x4B; 02814 cmd_gu[2]= 0x18; 02815 cmd_gu[3]= 0x02;//SW状態変化時自動送信モード2解除 02816 i2c.write(addr_gu, cmd_gu, 4); //gu-D タッチスイッチ読み出し動作設定 p49 02817 02818 wait(0.1); 02819 02820 i2c.read ((addr_gu + 0x01), crdata, 3, true); 02821 02822 }//if 02823 wait(0.1); 02824 }//While 02825 02826 } 02827 02828 /* 02829 char cmd_gu[32] ; //gu-DへのI2Cコマンド用配列 1byte 02830 char crdata[6]; 02831 char cswnum; //SW_No. sw1->0x00 ~~ sw32->0x1F 02832 //int i; 02833 //float fdata[4][4];//ファイル出力用 02834 //short sdata[4]; 02835 //short s; 02836 02837 read_regnum();//CAL登録No.読込 02838 read_caliber(&calinfo,reg_num);//指定したCAL登録No.の情報を読込後、calinfoへ代入 02839 02840 auto_int_hyouji(); 02841 02842 //dac_init(); //DAC 初期化 02843 02844 //gu-D タッチスイッチ読み出し動作設定 p49 02845 cmd_gu[0]= 0x1F; 02846 cmd_gu[1]= 0x4B; 02847 cmd_gu[2]= 0x18; 02848 cmd_gu[3]= 0x02;//SW状態変化時自動送信モード2 02849 i2c.write(addr_gu, cmd_gu, 4); //gu-D タッチスイッチ読み出し動作設定 p49 02850 02851 wait(0.1); 02852 02853 Jyushin = i2c.read ((addr_gu + 0x01), crdata, 3, true); 02854 02855 while(1) { 02856 02857 wait(0.1); 02858 02859 crdata[0] = 0; 02860 crdata[1] = 0; 02861 crdata[2] = 0; 02862 02863 i2c.read ((addr_gu + 0x01), crdata, 3, true); 02864 02865 if ( crdata[0] == 0x11 && crdata[2] == 1 ) { //個別ﾀｯﾁｽｲｯﾁ状態読み出しﾌｫｰﾏｯﾄ。識別子11h。 02866 cswnum = crdata[1]; //ｽｲｯﾁ番号 02867 //cswdata = crdata[2];//ON/OFF情報 02868 02869 //gu-D タッチスイッチ読み出し動作設定 p49 02870 cmd_gu[0]= 0x1F; 02871 cmd_gu[1]= 0x4B; 02872 cmd_gu[2]= 0x18; 02873 cmd_gu[3]= 0x00;//SW状態変化時自動送信モード2解除 02874 i2c.write(addr_gu, cmd_gu, 4); //gu-D タッチスイッチ読み出し動作設定 p49 02875 02876 //SWの番号（位置） 02877 if ( cswnum == 7 ) { 02878 02879 gu_Button_power_off();//電源ﾎﾞﾀﾝｲﾒｰｼﾞ反転表示 02880 wait(0.5); 02881 02882 led_off();//LED全消灯 02883 02884 return;//この関数を抜ける 02885 02886 } 02887 02888 //gu-D タッチスイッチ読み出し動作設定 p49 02889 cmd_gu[0]= 0x1F; 02890 cmd_gu[1]= 0x4B; 02891 cmd_gu[2]= 0x18; 02892 cmd_gu[3]= 0x02;//SW状態変化時自動送信モード2解除 02893 i2c.write(addr_gu, cmd_gu, 4); //gu-D タッチスイッチ読み出し動作設定 p49 02894 02895 wait(0.1); 02896 02897 i2c.read ((addr_gu + 0x01), crdata, 3, true); 02898 02899 } else if ( sw_start == 0 ) { //if 02900 02901 auto_int_hyouji(); 02902 02903 gu_cursor(0,2); 02904 gu_print1("Please Wait.."); 02905 gu_fontsize(2); 02906 02907 read_regnum();//CAL登録No.読込 02908 02909 read_caliber(&calinfo,reg_num);//指定したCAL登録No.の情報を読込後、calinfoへ代入 02910 02911 auto_meas( number_of_channels );//2個測定 02912 02913 hantei( number_of_channels );//判定LED 02914 02915 wait(0.5); 02916 02917 gu_fontsize(1); 02918 gu_cursor(0,2); 02919 gu_print1("READY "); 02920 02921 } 02922 wait(0.1); 02923 }//While 02924 } 02925 */ 02926 02927 /* 02928 void auto_run() 02929 { 02930 char cmd_gu[32] ; //gu-DへのI2Cコマンド用配列 1byte 02931 char crdata[6]; 02932 char cswnum; //SW_No. sw1->0x00 ~~ sw32->0x1F 02933 //int i; 02934 //float fdata[4][4];//ファイル出力用 02935 //short sdata[4]; 02936 //short s; 02937 02938 read_regnum();//CAL登録No.読込 02939 read_caliber(&calinfo,reg_num);//指定したCAL登録No.の情報を読込後、calinfoへ代入 02940 02941 auto_int_hyouji(); 02942 02943 //dac_init(); //DAC 初期化 02944 02945 //gu-D タッチスイッチ読み出し動作設定 p49 02946 cmd_gu[0]= 0x1F; 02947 cmd_gu[1]= 0x4B; 02948 cmd_gu[2]= 0x18; 02949 cmd_gu[3]= 0x02;//SW状態変化時自動送信モード2 02950 i2c.write(addr_gu, cmd_gu, 4); //gu-D タッチスイッチ読み出し動作設定 p49 02951 02952 wait(0.1); 02953 02954 Jyushin = i2c.read ((addr_gu + 0x01), crdata, 3, true); 02955 02956 while(1) { 02957 02958 wait(0.1); 02959 02960 crdata[0] = 0; 02961 crdata[1] = 0; 02962 crdata[2] = 0; 02963 02964 i2c.read ((addr_gu + 0x01), crdata, 3, true); 02965 02966 if ( crdata[0] == 0x11 && crdata[2] == 1 ) { //個別ﾀｯﾁｽｲｯﾁ状態読み出しﾌｫｰﾏｯﾄ。識別子11h。 02967 cswnum = crdata[1]; //ｽｲｯﾁ番号 02968 //cswdata = crdata[2];//ON/OFF情報 02969 02970 //gu-D タッチスイッチ読み出し動作設定 p49 02971 cmd_gu[0]= 0x1F; 02972 cmd_gu[1]= 0x4B; 02973 cmd_gu[2]= 0x18; 02974 cmd_gu[3]= 0x00;//SW状態変化時自動送信モード2解除 02975 i2c.write(addr_gu, cmd_gu, 4); //gu-D タッチスイッチ読み出し動作設定 p49 02976 02977 //SWの番号（位置） 02978 if ( cswnum == 7 ) { 02979 02980 gu_Button_power_off();//電源ﾎﾞﾀﾝｲﾒｰｼﾞ反転表示 02981 wait(0.5); 02982 02983 led_off();//LED全消灯 02984 02985 return;//この関数を抜ける 02986 02987 } else { 02988 02989 auto_int_hyouji(); 02990 02991 gu_cursor(0,2); 02992 gu_print1("Please Wait.."); 02993 gu_fontsize(2); 02994 02995 read_regnum();//CAL登録No.読込 02996 02997 read_caliber(&calinfo,reg_num);//指定したCAL登録No.の情報を読込後、calinfoへ代入 02998 02999 auto_meas( number_of_channels );//2個測定 03000 03001 hantei( number_of_channels );//判定LED 03002 03003 wait(0.5); 03004 03005 gu_fontsize(1); 03006 gu_cursor(0,2); 03007 gu_print1("READY "); 03008 03009 } //else if 03010 03011 //gu-D タッチスイッチ読み出し動作設定 p49 03012 cmd_gu[0]= 0x1F; 03013 cmd_gu[1]= 0x4B; 03014 cmd_gu[2]= 0x18; 03015 cmd_gu[3]= 0x02;//SW状態変化時自動送信モード2解除 03016 i2c.write(addr_gu, cmd_gu, 4); //gu-D タッチスイッチ読み出し動作設定 p49 03017 03018 wait(0.1); 03019 03020 i2c.read ((addr_gu + 0x01), crdata, 3, true); 03021 03022 }//if 03023 03024 wait(0.1); 03025 03026 }//While 03027 03028 } 03029 */ 03030 03031 /********************************* 03032 03033 Auto Mode (Sub) 03034 03035 *********************************/ 03036 void meas_sub() 03037 { 03038 auto_int_hyouji(); 03039 03040 gu_cursor(0,2); 03041 gu_print1("Please Wait.."); 03042 gu_fontsize(2); 03043 03044 //STX受信待ち抜け割込みイネーブル 03045 oneshot5.attach(&seq_timeout, 10); 03046 03047 //シーケンサからEXT受信するまでループ 03048 /* 03049 while(seq_name[0] == 2){ 03050 if(seq_name[3] == 3){ 03051 break; 03052 } 03053 wait(0.5); 03054 }//while 03055 */ 03056 03057 while(seq_name[0] == 50){ 03058 if(seq_name[3] == 51){ 03059 break; 03060 } 03061 wait(0.5); 03062 }//while 03063 03064 oneshot5.detach(); 03065 03066 read_regnum();//CAL登録No.読込 03067 03068 read_caliber(&calinfo,reg_num);//指定したCAL登録No.の情報を読込後、calinfoへ代入 03069 03070 auto_meas( number_of_channels );//2個測定 03071 03072 hantei( number_of_channels );//判定LED 03073 03074 seq_serialsend();//デバック用シーケンサ通信関数呼出 03075 03076 03077 //STX,EXT初期化 03078 seq_name[0] = 2; 03079 seq_name[3] = 3; 03080 03081 wait(0.5); 03082 03083 gu_fontsize(1); 03084 gu_cursor(0,2); 03085 gu_print1("READY "); 03086 03087 } 03088 03089 /******************************************************************************* 03090 03091 Auto Mode/SEQ Mode (sub) 03092 自動測定 03093 char noc -> 総測定数 1~4 03094 03095 *******************************************************************************/ 03096 void auto_meas(char noc) 03097 { 03098 int x[4] = {0,0,128,128}; //GU_D x座標 4個測定時の表示スタート位置 03099 int y[4] = {5,11,5,11}; //GU_D y座標 4個測定時の表示スタート位置 03100 int iy ; //GU_D y座標 2個測定時の表示スタート位置 03101 int i; 03102 short sdata[4]; 03103 03104 iy = 4;//GU_D 2個測定時の測定値の表示開始位置 y座標 03105 03106 if ( noc > 4 ) { 03107 noc = 4; 03108 } 03109 03110 //値の初期化 03111 for ( i = 0; i <= 3; i++) { 03112 I[i] = 0; 03113 R[i] = 0; //ver 1.1.1 03114 iop[i] = 0; 03115 voc[i] = 0; 03116 ocp[i] = 0; 03117 } 03118 03119 //判定用LED消灯 03120 led_off(); 03121 03122 //電源投入 03123 for ( i = 0; i <= ( noc - 1 ); i++) { 03124 dac_out( calinfo.vss_iop,i); //Vss設定 DAC_A~D 03125 } 03126 03127 wait( wait_poweron );//パワーブレイク復帰待機？ 03128 03129 //Reset DUT 03130 for ( i = 0; i <= ( noc -1 ); i++) { 03131 io_reset[i] = 1; //R = VDD 03132 } 03133 03134 wait(time_reset); 03135 03136 for ( i = 0; i <= ( noc -1 ); i++) { 03137 io_reset[i] = 0; //R = "OPEN" 03138 } 03139 03140 //抵抗測定 03141 for ( i = 0; i <= ( noc -1 ); i++ ) { 03142 R[i] = meas_resistor(i); 03143 } 03144 03145 //display GU_D 03146 if ( number_of_channels <= 2 ) { //2個測定の時の表示 03147 gu_fontsize(2); 03148 gu_cursor(0,iy); 03149 gu_print1("[ch.1]"); 03150 gu_cursor(128,iy); 03151 gu_print1("[ch.2]"); 03152 //CH.1 表示 03153 gu_cursor(0, iy + 2); 03154 gu_print1("R "); 03155 display_resistor( R[0] ); 03156 //CH.2 表示 03157 gu_cursor(128, iy + 2); 03158 gu_print("R "); 03159 display_resistor( R[1] ); 03160 } else if( number_of_channels >= 3) { //3.4個測定の時の表示 03161 gu_fontsize(1); 03162 gu_cursor(x[0],y[0]); 03163 gu_print1("ch.1"); 03164 gu_cursor(x[1],y[1] ); 03165 gu_print1("ch.2"); 03166 gu_cursor(x[2],y[2]); 03167 gu_print1("ch.3"); 03168 03169 if ( number_of_channels == 4 ) { 03170 gu_cursor(x[3],y[3]); 03171 gu_print1("ch.4"); 03172 } 03173 03174 //CH.1~4 表示 03175 for ( i = 0; i <= ( number_of_channels - 1 ); i++) { 03176 gu_cursor( x[i], y[i] + 1 );//x座標指定 03177 gu_print1("R "); 03178 display_resistor( R[i] ); 03179 } 03180 } 03181 03182 //iop測定 03183 wait(calinfo.wait_iop);//Vss印加~リセット後からiop測定までの待機時間 03184 03185 meas_current_automode( noc );//電流測定サブ 測定値をI[]へ代入 03186 03187 for( i = 0; i <= ( noc - 1) ; i++) { 03188 iop[i] = I[i]; 03189 } 03190 03191 //display GU_D 03192 if ( number_of_channels <= 2 ) { //2個測定の時の表示 03193 gu_cursor(0, iy + 4 );//IOP測定値表示位置指定 03194 gu_print1("Iop "); 03195 gu_putdeci(&iop[0]); 03196 gu_cursor(128, iy + 4 ); 03197 gu_print1("Iop "); 03198 gu_putdeci(&iop[1]); 03199 } else { 03200 //CH.1~4 表示 03201 for ( i=0; i <= ( number_of_channels - 1 ); i++) { 03202 gu_cursor( x[i], y[i] + 2 ); //x座標指定 03203 gu_print1("Iop "); 03204 gu_putdeci(&iop[i]); 03205 } 03206 } 03207 03208 wait(0.01); 03209 03210 //過充電防止時電流測定 03211 for ( i = 0; i <= ( noc - 1 ); i++) { 03212 dac_out( calinfo.vss_ocp,i); //Vss設定 DAC_A~D //ver1.1.2 03213 } 03214 03215 wait( calinfo.wait_ocp ); 03216 03217 meas_current_automode( noc ); 03218 03219 for( i = 0; i <= ( noc - 1) ; i++) { 03220 ocp[i] = I[i]; 03221 } 03222 03223 //display GU_D 03224 if ( number_of_channels <= 2 ) { //2個測定の時の表示 03225 gu_cursor(0, iy + 6 );//IOP測定値表示位置指定 03226 gu_print1("OCP "); 03227 gu_putdeci(&ocp[0]); 03228 gu_cursor(128, iy + 6 ); 03229 gu_print1("OCP "); 03230 gu_putdeci(&ocp[1]); 03231 } else { 03232 //CH.1~4 表示 03233 for ( i=0; i <= ( number_of_channels - 1 ); i++) { 03234 gu_cursor( x[i], y[i] + 3 ); //x座標指定 03235 gu_print1("OCP "); 03236 gu_putdeci(&ocp[i]); 03237 } 03238 } 03239 03240 //VOC測定 03241 for ( i = 0; i <= ( noc - 1 ); i++) { 03242 dac_out( calinfo.vss_voc,i); //Vss設定 DAC_A~D 03243 } 03244 03245 wait( wait_voc_1 ); 03246 03247 //Reset DUT 03248 for ( i = 0; i <= ( noc -1 ); i++) { 03249 io_reset[i] = 1; //R = VDD 03250 } 03251 03252 wait( calinfo.wait_voc );//ver3 03253 03254 for ( i = 0; i <= ( noc -1 ); i++ ) { 03255 03256 voc[i] = meas_voltage(i); 03257 sdata[i] = voc[i] * -1; 03258 03259 } 03260 03261 //display GU_D 03262 if ( number_of_channels <= 2 ) { //2個測定の時の表示 03263 gu_cursor(0, iy + 8 );//IOP測定値表示位置指定 03264 gu_print1("Voc "); 03265 gu_putdeck(&sdata[0]); 03266 gu_print1("V"); 03267 gu_cursor(128, iy + 8 ); 03268 gu_print1("Voc "); 03269 gu_putdeck(&sdata[1]); 03270 gu_print1("V"); 03271 } else { 03272 //CH.1~4 表示 03273 for ( i=0; i <= ( number_of_channels - 1 ); i++) { 03274 gu_cursor( x[i], y[i] + 4 );//x座標指定 03275 gu_print1("Voc "); 03276 gu_putdeck(&sdata[i]); 03277 gu_print1("V"); 03278 } 03279 } 03280 03281 //R = "L" 03282 for ( i = 0; i <= ( noc -1 ); i++) { 03283 io_reset[i] = 0; //R = "OPEN" 03284 } 03285 03286 wait(0.1); 03287 03288 //Vss=0V 03289 for ( i = 0; i <= ( noc - 1 ); i++) { 03290 dac_out( 0, i );//Vss設定 DAC_A~D 03291 } 03292 03293 //ファイルオープン 03294 mkdir("/sd/mydir", 0777); 03295 03296 FILE *fp = fopen("/sd/mydir/iop.csv", "ab+");//ディレクトリとファイル名の指定,追加モード 03297 03298 if(fp == NULL) { 03299 /* ver1.1.3 03300 gu_fontsize(1); 03301 gu_cursor(0,2); 03302 gu_print1("Could not open file for SD card"); 03303 */ 03304 } else { 03305 for ( i = 0; i <= ( noc - 1 ); i++) { 03306 fdata[i][0] = iop[i] * 0.01; //1bitあたり0.01uA 03307 fdata[i][1] = ocp[i] * 0.01; //1bitあたり0.01uA 03308 fdata[i][2] = voc[i] * 0.001; //1bitあたり0.001V 03309 } 03310 03311 for( i = 0; i <= ( noc - 1 ); i++) { 03312 03313 switch ( i ) { 03314 case 0: 03315 fprintf(fp, "CH.1"); 03316 break; 03317 case 1: 03318 fprintf(fp, "CH.2"); 03319 break; 03320 case 2: 03321 fprintf(fp, "CH.3"); 03322 break; 03323 case 3: 03324 fprintf(fp, "CH.4"); 03325 break; 03326 } 03327 03328 fprintf(fp, " ");//excel 区切り位置 03329 if ( R[i] < res_vref && R[0] >= 0 ) { 03330 fprintf(fp, "%d", R[i]); 03331 } else { 03332 fprintf(fp,"OL"); 03333 } 03334 fprintf(fp, " "); 03335 fprintf(fp, "%f", fdata[i][0]); 03336 fprintf(fp, " "); 03337 fprintf(fp, "%f", fdata[i][1]); 03338 fprintf(fp, " "); 03339 fprintf(fp, "%f", fdata[i][2]); 03340 fprintf(fp, " "); 03341 }//for 03342 03343 //ファイルクローズ 03344 fprintf(fp, "\n"); 03345 fclose(fp); 03346 } 03347 03348 } 03349 03350 /********************************* 03351 03352 電流測定(iop/voc共通) 03353 char amount;//測定数 03354 03355 *********************************/ 03356 void meas_current_automode(char amount) //a quantity of measuring channel 03357 { 03358 int i; 03359 03360 //amount = number_of_channels; 03361 03362 //set range 03363 for ( i = 0; i <= ( amount - 1 ); i++) 03364 range[i] = 1; //range 10uA 03365 03366 wait(0.1); 03367 03368 //discharge condenser 03369 for ( i = 0; i <= ( amount - 1 ); i++) 03370 houden[i] = 1; //discharge condenser 03371 03372 wait(time_discharge);//discharge time 03373 03374 ch_num = 0; 03375 select_ich( ch_num ); //select channel that mesuring current 03376 houden[0] = 0; //start integral 03377 03378 oneshot1.attach ( &flip_ch1, time_integral ); 03379 03380 if ( amount >= 2 ) { 03381 wait(0.1); 03382 houden[1] = 0; 03383 oneshot2.attach ( &flip_ch2, time_integral ); 03384 } 03385 03386 if ( amount >= 3 ) { 03387 wait(0.1); 03388 houden[2] = 0; 03389 oneshot3.attach ( &flip_ch3, time_integral ); 03390 } 03391 03392 if ( amount == 4 ) { 03393 wait(0.1); 03394 houden[3] = 0; 03395 oneshot4.attach ( &flip_ch4, time_integral ); 03396 } 03397 03398 wait( time_integral + 0.3 );//wait Timeout 03399 03400 //discharge condenser 03401 for ( i = 0; i <= ( amount - 1 ); i++) 03402 houden[i] = 1; //discharge condenser 03403 03404 wait(time_discharge);//discharge time 03405 03406 //not discharge condenser 03407 for ( i = 0; i <= ( amount - 1 ); i++) 03408 houden[i] = 0; 03409 03410 //set range 03411 for ( i = 0; i <= ( amount - 1 ); i++) 03412 range[i] = 0; //range 1mA 03413 03414 oneshot1.detach(); 03415 oneshot2.detach(); 03416 oneshot3.detach(); 03417 oneshot4.detach(); 03418 03419 } 03420 03421 /********************************* 03422 DAC 初期設定 03423 LDACﾚｼﾞｽﾀの設定 03424 内部ﾘﾌｧﾚﾝｽ電圧のｾｯﾄｱｯﾌﾟ 03425 入力ｼﾌﾄﾚｼﾞｽﾀ： 03426 0011 1000 0000 0000 0000 0001 03427 (0x3F0001) 03428 *********************************/ 03429 void dac_init() 03430 { 03431 03432 //内部ﾘﾌｧﾚﾝｽ電圧のｾｯﾄｱｯﾌﾟ 03433 wdata[0] = 0x38; 03434 wdata[1] = 0x00; 03435 wdata[2] = 0x01;// 03436 03437 i2c.write ( addr_dac, wdata, 3); 03438 03439 wait(0.1); 03440 03441 //LDAC設定 03442 wdata[0] = 0x30; 03443 wdata[1] = 0x00; 03444 wdata[2] = 0x0F;// 03445 03446 i2c.write ( addr_dac, wdata, 3); 03447 03448 } 03449 03450 /************************************** 03451 DAC 電圧印加 03452 Vout = 2 * Vref(2.5V) * ( D /2^2 ) 03453 mvolt[mV] 0~5000で設定 03454 addrは、0x00~03.全チャネルは0x07で指定 03455 **************************************/ 03456 void dac_out(short mvolt, char addr) //addr DACA:0x00 DACB:0x01 DACC:0x02 DACD:0x03 allDACs:0x07 03457 { 03458 char command;//1byte 03459 short dacdata;//2byte 03460 03461 command = 0x02;//write to input register n 仕様書p25参照 03462 03463 dacdata = mvolt * 4095 / 2 / dac_vref ; //12bit mvolt[mV] 0~5000で設定する 03464 03465 dacdata = dacdata << 4; //後ろ4bitはdon't care bit 03466 03467 wdata[0] = command << 3 | addr; //1byte 03468 wdata[1] = dacdata >> 8 ; //1byte 03469 wdata[2] = dacdata & 0xFF;//1byte 03470 03471 i2c.write(addr_dac, wdata, 3); 03472 03473 } 03474 /********************************* 03475 ADC測定し、平均値を算出する 03476 03477 貰う値：平均値の分母 03478 渡す値：平均値 03479 *********************************/ 03480 void compute_adc(int adc_con, long *avg) //(ADCのCONFIG, 計算結果） 03481 { 03482 03483 //short sdata[10];//2byte 03484 long ldata[10];//4byte 03485 long nu;//平均値の分子 4byte 03486 long max; 03487 long min; 03488 char i; 03489 char x; 03490 //int n; 03491 03492 x = 10; 03493 03494 wdata[0] = adc_con; //ADC configuration data チャンネルの選択など 03495 i2c.write( addr_ADC1, wdata, 1 ); 03496 wait(0.1); 03497 03498 //平均値の母数の数、測定を実施。 03499 for( i=0; i<=(x-1); i++) { 03500 03501 i2c.read( addr_ADC1 + 0x01, rdata, 3); 03502 //2byte結合 03503 ldata[i] = rdata[0] & 0xFF; 03504 ldata[i] = ( ldata[i] << 8 ) | rdata[1]; 03505 03506 if ( ldata[i] >= 0x8000 ) { 03507 ldata[i] = ldata[i] | 0xFFFF0000; //4byteの補数へ変換 03508 } 03509 03510 wait(0.05); 03511 03512 }//for 03513 03514 //最大値を取得 03515 max = ldata[0]; 03516 for ( i=0; i<=(x-2); i++) { 03517 if ( ldata[i+1] > ldata[i]) { 03518 max = ldata[i+1]; 03519 } 03520 } 03521 //最小値 03522 min = ldata[0]; 03523 for ( i=0; i<=(x-2); i++) { 03524 if ( ldata[i+1] < ldata[i]) { 03525 min = ldata[i+1]; 03526 } 03527 } 03528 03529 //平均値 03530 nu = 0x00000000; //4byte 03531 for ( i=0; i<=(x-1); i++) { 03532 nu = nu + ldata[i]; 03533 } 03534 03535 *avg = ( nu - max - min ) / ( x - 2 ); 03536 03537 } 03538 03539 03540 /************************************** 03541 2バイトを10進数で表示する 0~65535 03542 format *0.000 03543 mV→uAへ変換(1/1000) 03544 プリアンプ GAIN 1/5 03545 ADC_LSB:0.25mV 03546 積分時間 2s 03547 容量 20uF 03548 **************************************/ 03549 void gu_putdeci(float* idata) 03550 { 03551 03552 float uA; //ver1.1.4 03553 long y; //ver1.1.4 03554 long x; //ver1.1.4 03555 03556 //千分の一、四捨五入。 03557 if ( *idata > 0 ) { 03558 uA = *idata + 0.5; 03559 } else { 03560 uA = *idata - 0.5; 03561 } 03562 03563 x = uA; //小数点以下切り捨て 03564 03565 //四捨五入 up to here 03566 03567 //プラスマイナスの表示 03568 if( x >= 0 ) { 03569 wdata[0] = 0x2B;//ascii "+" 03570 i2c.write(addr_gu, wdata, 1); 03571 03572 y = x; 03573 03574 } else { 03575 wdata[0] = 0x2D;//ascii "-" 03576 i2c.write(addr_gu, wdata, 1); 03577 03578 y = ( ~x ) + 0x01;//2の補数 03579 } 03580 03581 //y = y * 5 * 0.25;//プリアンプのGAINが1/5なのでここで5倍.ADC14bit分解能で、1bitあたり0.25mv 03582 03583 wdata[0] = (( y / 1000 ) % 10 ) + 0x30; 03584 03585 if( wdata[0] == 0x30 )//2桁目が零の場合、"0"を表示しない。 03586 wdata[0] = 0x20; 03587 03588 wdata[1] = (( y / 100 ) % 10 ) + 0x30; 03589 wdata[2] = 0x2E;//ASCII "." 03590 wdata[3] = (( y / 10 ) % 10 ) + 0x30; 03591 wdata[4] = ( y % 10 ) + 0x30; 03592 03593 //ver1.2.5 03594 //i2c.write(addr_gu, wdata, 5); 03595 //gu_print1("uA"); 03596 03597 if ( *idata > O_L * -100 && *idata < O_L * 100 ){ 03598 03599 i2c.write(addr_gu, wdata, 5); 03600 gu_print1("uA"); 03601 03602 }else{ 03603 03604 gu_print1("O.L"); 03605 03606 } 03607 //upto 03608 03609 } 03610 03611 /************************************** 03612 2バイトを10進数で表示する 0~65535 03613 format *0.000 03614 mV→uAへ変換(1/1000) 03615 プリアンプ GAIN 1/5 03616 ADC_LSB:0.25mV 03617 シャント抵抗1kΩ 03618 **************************************/ 03619 void gu_putdeci_mA(float* idata) 03620 { 03621 float uA; //ver1.1.4 03622 long y; //ver1.1.4 03623 long x; //ver1.1.4 03624 03625 //千分の一、四捨五入。 03626 if ( *idata > 0 ) { 03627 uA = *idata + 0.5; 03628 } else { 03629 uA = *idata - 0.5; 03630 } 03631 03632 x = uA; //小数点以下切り捨て 03633 03634 //四捨五入 up to here 03635 03636 //プラスマイナスの表示 03637 if( x >= 0 ) { 03638 wdata[0] = 0x2B;//ascii "+" 03639 i2c.write(addr_gu, wdata, 1); 03640 03641 y = x; 03642 03643 } else { 03644 wdata[0] = 0x2D;//ascii "-" 03645 i2c.write(addr_gu, wdata, 1); 03646 03647 y = ( ~x ) + 0x01;//2の補数 03648 } 03649 03650 //y = y * 5 * 0.25;//プリアンプのGAINが1/5なのでここで5倍.ADC14bit分解能で、1bitあたり0.25mv 03651 03652 /* 03653 wdata[0] = (( *y / 100000 ) % 10 ) + 0x30; 03654 03655 if( wdata[0] == 0x30 )//3桁目が零の場合、"0"を表示しない。 03656 wdata[0] = 0x20; 03657 */ 03658 03659 wdata[0] = (( y / 1000 ) % 10 ) + 0x30; 03660 03661 if( wdata[0] == 0x30 )//2桁目が零の場合、"0"を表示しない。 03662 wdata[0] = 0x20; 03663 03664 wdata[1] = (( y / 100 ) % 10 ) + 0x30; 03665 wdata[2] = 0x2E;//ASCII "." 03666 wdata[3] = (( y / 10 ) % 10 ) + 0x30; 03667 wdata[4] = ( y % 10 ) + 0x30; 03668 03669 i2c.write(addr_gu, wdata, 5); 03670 03671 gu_print1("mA"); 03672 03673 } 03674 03675 /************************************** 03676 2バイトを10進数で表示する 0~65535 03677 1/1000倍 format *0.000 03678 mV→V Ω→kΩ 03679 **************************************/ 03680 void gu_putdeck(short* x) 03681 { 03682 03683 short num; 03684 03685 //プラスマイナスの表示 03686 if( *x >= 0 ) { 03687 wdata[0] = 0x2B;//ascii "+" 03688 i2c.write(addr_gu, wdata, 1); 03689 num = *x; 03690 03691 } else { 03692 wdata[0] = 0x2D;//ascii "-" 03693 i2c.write(addr_gu, wdata, 1); 03694 03695 //*x = ( ~*x ) + 0x01;//2の補数 03696 num = *x * -1; 03697 } 03698 03699 wdata[0] = (( num / 10000 ) % 10 ) + 0x30; 03700 03701 if( wdata[0] == 0x30 )//2桁目が零の場合、"0"を表示しない。 03702 wdata[0] = 0x20; 03703 03704 wdata[1] = (( num / 1000 ) % 10 ) + 0x30; 03705 wdata[2] = 0x2E;//ASCII "." 03706 wdata[3] = (( num / 100 ) % 10 ) + 0x30; 03707 wdata[4] = (( num / 10 ) % 10 ) + 0x30; 03708 //wdata[5] = ( num % 10 ) + 0x30; 03709 03710 i2c.write(addr_gu, wdata, 5); 03711 03712 } 03713 03714 /******************************** 03715 03716 判定 LED点灯 03717 03718 ********************************/ 03719 void hantei(char noc) 03720 { 03721 int i; 03722 03723 //エラーフラグ 03724 for ( i=0; i<= 3 ; i++) { 03725 err_f[i] = 0; 03726 } 03727 03728 //ver1.2 03729 if (DEB_EN == 1) { 03730 voc[0] = 3100;//[mV] 03731 ocp[0] = -0.4*100;//[uA] 0.1uAのときocp[]の値は10 03732 iop[0] = 16.5*100;//[uA] 0.1uAのときicp[]の値は10 03733 voc[1] = 3100;//[V] 03734 ocp[1] = 0.4*100;//[uA] 03735 iop[1] = 16.5*100;//[uA] 03736 } 03737 //upto 03738 03739 for ( i = 0; i <= ( noc - 1 ); i++) { 03740 03741 /*ver1.1.3 規格設置値=0の場合は判定しない*/ 03742 if( voc[i] < calinfo.low_limit_voc && calinfo.low_limit_voc != 0) { 03743 err_f[i] = 1; 03744 } 03745 03746 if( iop[i] < calinfo.low_limit_iop ) { 03747 err_f[i] = 1; 03748 } 03749 03750 if( ocp[i] > calinfo.low_limit_ocp ) { 03751 err_f[i] = 1; 03752 } 03753 03754 //ver1.2.2 03755 if( ocp[i] < calinfo.up_limit_ocp && calinfo.up_limit_ocp != 0) { 03756 err_f[i] = 1; 03757 } 03758 03759 if( R[i] < calinfo.low_limit_resistor && calinfo.low_limit_resistor != 0 ) { 03760 err_f[i] = 1; 03761 } 03762 03763 if( R[i] > calinfo.up_limit_resistor && calinfo.up_limit_resistor != 0 ) { 03764 err_f[i] = 1; 03765 } 03766 03767 if( err_f[i] == 1) { 03768 led_red[i] = 1; 03769 } else { 03770 led_green[i] = 1; 03771 } 03772 03773 if ( SEQ_EN == 1 && err_f[i] == 0 ) { 03774 /*** ver3 03775 seq_hantei[i] = 1; 03776 ***/ 03777 seq_out[i] = 1; 03778 } 03779 03780 //ver1.2.3 03781 char *print_text; 03782 03783 if(DEB_EN == 1) { 03784 03785 gu_fontsize(1); 03786 gu_cursor(0,2); 03787 gu_print1(" "); 03788 03789 if(err_f[i] == 1) { 03790 03791 switch(i){ 03792 case 0: 03793 print_text="FAIL DUT1"; 03794 break; 03795 case 1: 03796 print_text="FAIL DUT2"; 03797 break; 03798 } 03799 03800 gu_fontsize(1); 03801 gu_cursor(0,2); 03802 gu_print1(print_text); 03803 wait(1); 03804 } 03805 if(err_f[i] == 0) { 03806 03807 03808 switch(i){ 03809 case 0: 03810 print_text="PASS DUT1"; 03811 break; 03812 case 1: 03813 print_text="PASS DUT2"; 03814 break; 03815 } 03816 03817 gu_fontsize(1); 03818 gu_cursor(0,2); 03819 gu_print1(print_text); 03820 03821 wait(1); 03822 } 03823 } 03824 //upto 03825 03826 }//for 03827 03828 03829 } 03830 03831 /******************************************************************************* 03832 03833 measure voltage 03834 測定CHを指定して、電圧値Rを返す 03835 char ch 0~3 -> 1ch ~ 4ch 03836 03837 ver3.0.0 リレー制御シーケンスを追加 03838 03839 *******************************************************************************/ 03840 short meas_voltage(char ch)//ch 0~3 -> 1ch ~ 4ch 03841 { 03842 char com; 03843 short sdata; 03844 03845 switch(ch) { 03846 case 0: 03847 /*** ver3 *****************/ 03848 rlen[4] = 1; //RLEN5="H" 03849 wait(ton_rr); 03850 /**************************/ 03851 03852 com = adc_config(2,0);//ch1(adc),12bit 03853 i2c.write( addr_ADC1, &com, 1); 03854 wait(0.1); 03855 sdata = read_adc(addr_ADC1); 03856 break; 03857 03858 case 1: 03859 03860 /*** ver3 *****************/ 03861 rlen[5] = 1; //RLEN6="H" 03862 wait(ton_rr); 03863 /**************************/ 03864 03865 com = adc_config(3,0);//ch2(adc),12bit 03866 i2c.write( addr_ADC1, &com, 1); 03867 wait(0.1); 03868 sdata = read_adc(addr_ADC1); 03869 break; 03870 03871 case 2: 03872 03873 /*** ver3 *****************/ 03874 rlen[6] = 1; //RLEN7="H" 03875 wait(ton_rr); 03876 /**************************/ 03877 03878 com = adc_config(2,0);//ch1(adc),12bit 03879 i2c.write( addr_ADC2, &com, 1); 03880 wait(0.1); 03881 sdata = read_adc(addr_ADC2); 03882 break; 03883 03884 case 3: 03885 03886 /*** ver3 *****************/ 03887 rlen[7] = 1; //RLEN8="H" 03888 wait(ton_rr); 03889 /**************************/ 03890 03891 com = adc_config(3,0);//ch2(adc),12bit 03892 i2c.write( addr_ADC2, &com, 1); 03893 wait(0.1); 03894 sdata = read_adc(addr_ADC2); 03895 break; 03896 03897 }// end switch 03898 03899 /*** ver3 ***/ 03900 //電圧測定用リレーを全てオフ 03901 for (int i = 4; i <= 7; i++){ 03902 rlen[i] = 0; 03903 } 03904 wait(toff_rr); 03905 /************/ 03906 03907 //プリアンプ倍率を代入して、電圧値を算出する(単位はmV) 03908 sdata = sdata * 5;//プリアンプ倍率 03909 03910 return ( sdata ); 03911 } 03912 03913 03914 /******************************************************************************* 03915 03916 measure resistor 03917 03918 測定CHを指定して、抵抗測定値Rを返す 03919 char ch 0~3 -> 1ch ~ 4ch 03920 03921 ver3.0.0 リレー制御追加 03922 03923 *******************************************************************************/ 03924 short meas_resistor(char ch)//ch 0~3 -> 1ch ~ 4ch 03925 { 03926 char com; 03927 short sdata; 03928 03929 switch(ch) { 03930 case 0: 03931 /* 03932 //ver1.2.0 03933 if (RL_EN == 1) { 03934 io[6] = 1; //外付けリレーON 03935 wait(TIME_RELAY_ON); 03936 } 03937 //up to here 03938 */ 03939 03940 /*** ver3 *****************/ 03941 rlen[0] = 1; //RLEN1="H" 03942 wait(ton_rr); 03943 /**************************/ 03944 03945 com = adc_config(0,0);//ch1(adc),12bit 03946 i2c.write( addr_ADC1, &com, 1); 03947 wait(0.1); 03948 sdata = read_adc(addr_ADC1); 03949 03950 /* 03951 //ver1.2.0 relay off 03952 if (RL_EN == 1) { 03953 io[6] = 0 ; 03954 } 03955 */ 03956 03957 break; 03958 03959 case 1: 03960 03961 /* 03962 //ver1.2.0 03963 if (RL_EN == 1) { 03964 io[7] = 1; //外付けリレーON 03965 wait(TIME_RELAY_ON); 03966 } 03967 //up to here 03968 */ 03969 03970 /*** ver3 *****************/ 03971 rlen[1] = 1; //RLEN2="H" 03972 wait(ton_rr); 03973 /**************************/ 03974 03975 com = adc_config(1,0);//ch2(adc),12bit 03976 i2c.write( addr_ADC1, &com, 1); 03977 wait(0.1); 03978 sdata = read_adc(addr_ADC1); 03979 03980 /* 03981 //ver1.2.0 03982 if (RL_EN == 1) { 03983 io[7] = 0; 03984 } 03985 */ 03986 03987 break; 03988 03989 case 2: 03990 /*** ver3 *****************/ 03991 rlen[2] = 1; //RLEN3="H" 03992 wait(ton_rr); 03993 /**************************/ 03994 03995 com = adc_config(0,0);//ch1(adc),12bit 03996 i2c.write( addr_ADC2, &com, 1); 03997 wait(0.1); 03998 sdata = read_adc(addr_ADC2); 03999 04000 break; 04001 04002 case 3: 04003 /*** ver3 *****************/ 04004 rlen[3] = 1; //RLEN4="H" 04005 wait(ton_rr); 04006 /**************************/ 04007 04008 com = adc_config(1,0);//ch2(adc),12bit 04009 i2c.write( addr_ADC2, &com, 1); 04010 wait(0.1); 04011 sdata = read_adc(addr_ADC2); 04012 04013 break; 04014 04015 }// end switch 04016 04017 /*** ver3 *********************/ 04018 //抵抗測定用リレーを全てオフ 04019 for (int i = 0; i <= 3; i++){ 04020 rlen[i] = 0; 04021 } 04022 wait(toff_rr); 04023 /*****************************/ 04024 04025 //検出用抵抗値を代入して、測定抵抗値を算出する(単位はmV,Ω) 04026 if ( sdata < res_vref ) { 04027 sdata =( rsense * sdata ) / ( res_vref - sdata); 04028 } else { 04029 sdata = res_vref;//overload 04030 } 04031 04032 return ( sdata ); 04033 } 04034 04035 04036 /********************************* 04037 04038 display resistor 04039 測定抵抗値を表示する 04040 04041 *********************************/ 04042 void display_resistor(short sdata)//測定値を表示する。 04043 { 04044 if ( sdata < res_vref && sdata >= 0 ) { 04045 gu_putdec(&sdata); 04046 } else { 04047 gu_print1(" OL ");//overload 04048 } 04049 gu_onebyte(0xEA);//ohm 04050 } 04051 04052 /************************************** 04053 4バイトを10進数で表示する 0~9999 04054 **************************************/ 04055 void gu_putdec(short* x) 04056 { 04057 04058 char cmd[4]; 04059 04060 //cmd[0] = (( *x / 100000 ) % 10 ) + 0x30; 04061 cmd[0] = (( *x / 1000 ) % 10 ) + 0x30; 04062 cmd[1] = (( *x / 100 ) % 10 ) + 0x30; 04063 cmd[2] = (( *x / 10 ) % 10 ) + 0x30; 04064 cmd[3] = ( *x % 10 ) + 0x30; 04065 04066 i2c.write(addr_gu, cmd, 4); 04067 04068 } 04069 /********************************* 04070 04071 LED 照度 04072 設定読込~反映 04073 //ﾒﾓﾘから設定値を読み出して、LEDのPWMのDutyを設定する 04074 //LED1設定値&LED2設定値の計2Byte読込 04075 04076 *********************************/ 04077 void read_syoudo(char* c) 04078 { 04079 //char cmd; //gu-DへのI2Cコマンド用配列 1byte0 04080 //char csyoudo[4];//led出力用pwm duty 設定比1ﾊﾞｲﾄ255段階 04081 04082 float duty_pwm; //pwm ﾊﾟｰｾﾝﾃｰｼﾞ 04083 int i; 04084 04085 //ﾒﾓﾘ10h番地(照度設定ﾃﾞｰﾀ)読み出し 04086 //cmd[0] = 0x10; //ver3 04087 //Sequential Read 04088 04089 i2c.write (eeprom_adrs, adrs_syoudo, 2,true); //ver3 repeated start,true - do not send stop condition 04090 //i2c.write (slave_adrs, &cmd, 1,true); //ver3 send 1 byte remove stop condition 04091 slave_adrs = eeprom_adrs + 0x01; //ver3 read mode 04092 i2c.read (slave_adrs, rdata, 4); //read 4 byte 04093 04094 for ( i = 0; i <=3; i++) { 04095 c[i] = rdata[i]; 04096 } 04097 04098 //set pwm duty 04099 for ( i = 0; i <= ( number_of_channels - 1 ); i++) { 04100 04101 if(c[i] == 0x00) { 04102 c[i] = 0x32; 04103 } 04104 04105 duty_pwm = COP * c[i]; 04106 04107 leds[i].write (duty_pwm);//Set Duty 04108 } 04109 } 04110 /********************************* 04111 04112 LED 照度調整 (Main) 04113 04114 *********************************/ 04115 void adjust_illumination() 04116 { 04117 char cmd_gu[32] ; //gu-DへのI2Cコマンド用配列 1byte0 04118 //char *pcmd = cmd_gu; 04119 //char msg; 04120 //char *pmsg = &msg; 04121 char crdata[3]; 04122 char cswnum; //SW_No. sw1->0x00 ~~ sw32->0x1F gu-D ｽｲｯﾁNo. 04123 char cswdata; // 0x00 or 0x01 ONかOFFか 04124 char *pcswnum = &cswnum; 04125 char *pcswdata = &cswdata; 04126 char csyoudo[4];//led出力用pwm duty 設定比1ﾊﾞｲﾄ255段階 04127 char ch; 04128 float duty_pwm;//pwm ﾊﾟｰｾﾝﾃｰｼﾞ 04129 int i; 04130 int x[4] = {64,64,192,192}; //レベル値の表示位置 x座標 04131 int y[4] = {2,4,2,4}; //レベル値の表示位置 y座標 04132 // 04133 //EEPROMから照度データ読込とPWMDUTYセット 04134 read_syoudo( csyoudo ); 04135 // 04136 //画面表示 04137 gu_cls();//画面のｸﾘｱ 04138 gu_fontsize(2); 04139 gu_print1("Adjust illumination "); 04140 //照度レベルを256段階で表示 04141 //LED1 04142 gu_cursor(0,16/8); 04143 gu_print1("LED1 Lv "); 04144 //LED2 04145 gu_cursor(0,32/8); 04146 gu_print1("LED2 Lv "); 04147 //LED3 04148 if( number_of_channels >= 3 ) { 04149 gu_cursor(128,2); 04150 gu_print1("LED3 Lv "); 04151 } 04152 //LED4 04153 if( number_of_channels >= 4 ) { 04154 gu_cursor(128,4); 04155 gu_print1("LED4 Lv "); 04156 } 04157 // 04158 for ( i = 0; i <= ( number_of_channels - 1 ); i++) { 04159 04160 gu_cursor(x[i],y[i]); 04161 04162 cmd_gu[0] = ((csyoudo[i] / 100) & 0xFF) + 0x30; 04163 cmd_gu[1] = (csyoudo[i] - (csyoudo[i] / 100) * 100) / 10 + 0x30; 04164 cmd_gu[2] = ((csyoudo[i] % 10) & 0xFF) + 0x30; 04165 i2c.write(addr_gu, cmd_gu, 3); 04166 } 04167 04168 // 04169 gu_fontsize(1); 04170 gu_cursor(0,56/8); 04171 gu_print1("LED1"); 04172 gu_cursor(32,56/8); 04173 gu_print1("fine"); 04174 gu_cursor(64,56/8); 04175 gu_print1("LED2"); 04176 gu_cursor(96,56/8); 04177 gu_print1("fine"); 04178 04179 if( number_of_channels >= 3) { 04180 gu_cursor(128,56/8); 04181 gu_print1("LED3"); 04182 gu_cursor(160,56/8); 04183 gu_print1("fine"); 04184 } 04185 if( number_of_channels >= 4) { 04186 gu_cursor(192,56/8); 04187 gu_print1("LED4"); 04188 gu_cursor(224,56/8); 04189 gu_print1("fine"); 04190 } 04191 // 04192 //gu-D タッチスイッチ読み出し動作設定 p49 04193 cmd_gu[0]= 0x1F; 04194 cmd_gu[1]= 0x4B; 04195 cmd_gu[2]= 0x18; 04196 cmd_gu[3]= 0x02;//SW状態変化時自動送信モード2 04197 i2c.write(addr_gu, cmd_gu, 4); //gu-D タッチスイッチ読み出し動作設定 p49 04198 // 04199 //ﾎﾞﾀﾝｲﾒｰｼﾞの表示 04200 for ( i = 17; i < 17 + ( number_of_channels * 2 ); i++) { 04201 gu_button_up(i); 04202 } 04203 for ( i = 25; i < 25 + ( number_of_channels * 2 ); i++) { 04204 gu_button_down(i); 04205 } 04206 gu_Button_power_on();//show button 04207 wait(0.2); 04208 04209 while(1) { 04210 04211 i2c.read ((addr_gu + 0x01), crdata, 3); 04212 04213 if (crdata[0] == 0x11 ) { //個別ﾀｯﾁｽｲｯﾁ状態読み出しﾌｫｰﾏｯﾄ。識別子11h。 04214 *pcswnum = crdata[1]; //ｽｲｯﾁ番号 04215 *pcswdata = crdata[2];//ON/OFF情報 04216 04217 if (cswdata == 0x01) { //ﾀｯﾁしたならば 04218 04219 switch ( number_of_channels ) { //ver1.1.0 04220 04221 case 1: 04222 case 2: 04223 if ( cswnum >= 20 && cswnum <= 23 ) 04224 cswnum = 0; 04225 04226 if ( cswnum >= 28 && cswnum <= 31 ) 04227 cswnum = 0; 04228 04229 break; 04230 04231 case 3: 04232 if ( cswnum >= 22 && cswnum <= 23 ) 04233 cswnum = 0; 04234 04235 if ( cswnum >= 30 && cswnum <= 31 ) 04236 cswnum = 0; 04237 04238 break; 04239 04240 } //switch 04241 04242 switch( cswnum ) { //SWの番号（位置） 04243 04244 case 22: 04245 case 20: 04246 case 16: 04247 case 18: 04248 04249 ch = ( cswnum - 16 ) / 2; //SWnoから選択したLEDNoの算出 04250 04251 gu_button_up_on( cswnum + 1 ); 04252 wait(0.2); 04253 gu_button_up( cswnum + 1 ); 04254 wait(0.1); 04255 04256 if(csyoudo[ch] <= 0xEF ) { 04257 csyoudo[ch] = csyoudo[ch] + 0x0A; 04258 } 04259 04260 break; 04261 04262 case 23: 04263 case 21: 04264 case 17: 04265 case 19: 04266 04267 ch = ( cswnum - 17 ) / 2; //SWnoから選択したLEDNoの算出 04268 04269 gu_button_up_on( cswnum + 1 ); 04270 wait(0.2); 04271 gu_button_up( cswnum + 1 ); 04272 wait(0.1); 04273 04274 if(csyoudo[ch] <= 0xFF ) { 04275 csyoudo[ch] = csyoudo[ch] + 0x01; 04276 } 04277 04278 break; 04279 04280 case 24: 04281 case 26: 04282 case 28: 04283 case 30: 04284 04285 ch = ( cswnum - 24 ) / 2; //SWnoから選択したLEDNoの算出 04286 04287 gu_button_down_on( cswnum + 1 ); 04288 wait(0.2); 04289 gu_button_down( cswnum + 1 ); 04290 wait(0.1); 04291 04292 if(csyoudo[ch] >= 0x0A ) { 04293 csyoudo[ch] = csyoudo[ch] - 0x0A; 04294 } 04295 04296 break; 04297 04298 case 25: 04299 case 27: 04300 case 29: 04301 case 31: 04302 04303 ch = ( cswnum - 24 ) / 2; //SWnoから選択したLEDNoの算出 04304 04305 gu_button_down_on( cswnum + 1 ); 04306 wait(0.2); 04307 gu_button_down( cswnum + 1 ); 04308 wait(0.1); 04309 04310 if(csyoudo[ch] >= 0x01 ) { 04311 csyoudo[ch] = csyoudo[ch] - 0x01; 04312 } 04313 04314 break; 04315 04316 case 7 ://SW.8 保存ボタンを押すと現在のLED照度をEEPROMへ保存する 04317 04318 wdata[0] = adrs_syoudo[0]; //word address 書込み先頭ｱﾄﾞﾚｽ指定 04319 wdata[1] = adrs_syoudo[1]; //ver3 04320 04321 for ( i = 0; i <= ( number_of_channels - 1 ); i++) { 04322 wdata[ i + 2 ] = csyoudo[i]; //DATA_LED i 04323 } 04324 04325 Soushin = i2c.write (eeprom_adrs, wdata,( number_of_channels + 2 )); // ver3 全送信BYTE数は、書込みデータにBYTE ADDRESSの2byteを加算した数 04326 04327 if(Soushin == 0) { 04328 gu_Button_power_off();//電源ﾎﾞﾀﾝｲﾒｰｼﾞ反転表示 04329 wait(0.3); 04330 04331 return;//照度調整ﾙｰﾁﾝを抜ける 04332 } 04333 } //switch 04334 04335 04336 04337 //PWMのDUTY設定 04338 04339 for( i = 0; i <= ( number_of_channels - 1 ); i++) { 04340 duty_pwm = COP * csyoudo[i]; 04341 leds[i].write (duty_pwm);//Set Duty 04342 } 04343 04344 04345 //照度レベルを256段階で表示 04346 //LED1 04347 gu_fontsize(2); 04348 04349 for ( i = 0; i <= ( number_of_channels - 1 ); i++) { 04350 04351 gu_cursor(x[i],y[i]); 04352 04353 cmd_gu[0] = ((csyoudo[i] / 100) & 0xFF) + 0x30; 04354 cmd_gu[1] = (csyoudo[i] - (csyoudo[i] / 100) * 100) / 10 + 0x30; 04355 cmd_gu[2] = ((csyoudo[i] % 10) & 0xFF) + 0x30; 04356 i2c.write(addr_gu, cmd_gu, 3); 04357 } 04358 } 04359 } //if 04360 04361 wait(0.1);//gu-D 読込間隔の設定 04362 04363 } 04364 } 04365 04366 /********************************* 04367 04368 サブ基板LED(判定用)全消灯 04369 04370 *********************************/ 04371 void led_off() 04372 { 04373 int i; 04374 04375 for( i = 0; i <= ( number_of_channels - 1 ); i++) { 04376 led_green[ i ] = 0; 04377 led_red[ i ] = 0; 04378 } 04379 04380 } 04381 /********************************* 04382 04383 Utility Main 04384 gu_D 輝度調整 タッチ感度調整 04385 04386 *********************************/ 04387 void utility() //輝度調整ｻﾌﾞﾙｰﾁﾝ 04388 { 04389 04390 char cmd_gu[32] ; //gu-DへのI2Cコマンド用配列 1byte0 04391 //char *pcmd = cmd_gu; 04392 char clumi; //輝度設定用変数 01h<=n<=08h 04393 char* pclumi = &clumi; //ポインタの定義 04394 char msg; 04395 char *pmsg = &msg; 04396 char crdata[3]; 04397 char cswnum; //SW_No. sw1->0x00 ~~ sw32->0x1F 04398 char cswdata; // 0x00 or 0x01 04399 char *pcswnum = &cswnum; 04400 char *pcswdata = &cswdata; 04401 // 04402 //ﾒﾓﾘ00h番地(輝度設定ﾃﾞｰﾀ)読み出し 04403 //wdata[0] = 0x00; 04404 //Soushin = i2c.write (eeprom_adrs, wdata, 1,true); //読込先頭ｱﾄﾞﾚｽ指定 ReStart 04405 Soushin = i2c.write (eeprom_adrs, adrs_kido, 2,true); //ver3 読込先頭ｱﾄﾞﾚｽ指定 2byte 04406 Jyushin = i2c.read ((eeprom_adrs + 0x01), rdata, 1);//read 1byte 04407 *pclumi = rdata[0]; 04408 04409 //輝度設定更新 04410 if(*pclumi==0x00 || *pclumi > 0x08) *pclumi=0x05; 04411 gu_luminance(pclumi); 04412 04413 //画面表示 04414 gu_cls();//画面のｸﾘｱ 04415 gu_print1("Set Display Brightness"); 04416 gu_cursor(0,16/8); 04417 gu_print1("LEVEL "); 04418 *pmsg = *pclumi + 0x30; 04419 gu_print1(pmsg); 04420 04421 gu_cursor(0,96/8); //ver1.1.0 04422 gu_print1("DELETE EEPROM_DATA"); 04423 gu_set_button_font1(30,"del"); 04424 04425 //SW状態変化時自動送信モード2 04426 cmd_gu[0]= 0x1F; 04427 cmd_gu[1]= 0x4B; 04428 cmd_gu[2]= 0x18; 04429 cmd_gu[3]= 0x02; 04430 i2c.write(addr_gu, cmd_gu, 4); //gu-D タッチスイッチ読み出し動作設定 p49 04431 04432 //ﾎﾞﾀﾝｲﾒｰｼﾞの表示 04433 gu_button_up(6);//show button 04434 gu_button_down(14);//show button 04435 gu_Button_power_on();//show button 04436 04437 while(1) { 04438 04439 i2c.read ((addr_gu + 0x01), crdata, 3, true); 04440 04441 if (crdata[0] == 0x11 ) { //個別ﾀｯﾁｽｲｯﾁ状態読み出しﾌｫｰﾏｯﾄ。識別子11h。 04442 *pcswnum = crdata[1]; //ｽｲｯﾁ番号 04443 *pcswdata = crdata[2];//ON/OFF情報 04444 04445 if (cswdata == 0x01) { //ﾀｯﾁしたならば 04446 switch( cswnum ) { //SWの番号（位置） 04447 case 5 ://SW6 04448 gu_button_up_on( 6 ); 04449 wait(0.2); 04450 gu_button_up( 6 ); 04451 wait(0.1); 04452 04453 if(clumi < 8 ) *pclumi = *pclumi + 1; 04454 04455 break; 04456 04457 case 13 ://SW14 04458 gu_button_down_on( 14 ); 04459 wait(0.2); 04460 gu_button_down( 14 ); 04461 wait(0.1); 04462 04463 if(clumi >= 1 ) *pclumi = *pclumi - 1; 04464 04465 break; 04466 04467 case 29: //SW30 04468 04469 gu_reverse(0x01); //gu_ﾘﾊﾞｰｽ指定 04470 gu_set_button_font1(30,"del"); 04471 gu_reverse(0x00); //gu_ﾘﾊﾞｰｽ解除 04472 04473 erace_calinfo(); 04474 04475 gu_set_button_font1(30,"del"); 04476 04477 break; 04478 04479 case 0x07 ://保存ボタンを押すと現在の輝度をEEPROMへ保存する 04480 04481 //wdata[0] = 0x00 ; //word address 書込み先頭ｱﾄﾞﾚｽ指定 04482 //wdata[1] = *pclumi ; //DATA 04483 04484 wdata[0] = adrs_kido[0]; //ver3 04485 wdata[1] = adrs_kido[1]; //ver3 04486 wdata[2] = *pclumi ; //ver3 04487 04488 Soushin = i2c.write (eeprom_adrs, wdata, 3); //ver3 04489 04490 if(Soushin == 0) { 04491 gu_Button_power_off();//電源ﾎﾞﾀﾝｲﾒｰｼﾞ反転表示 04492 wait(0.5); 04493 return;//輝度調整ﾙｰﾁﾝを抜ける 04494 } 04495 04496 } //switch 04497 04498 gu_luminance(pclumi);//輝度変更 04499 gu_cursor(0,16/8); 04500 gu_print1("LEVEL "); 04501 *pmsg = *pclumi + 0x30; 04502 gu_print1(pmsg); 04503 04504 } 04505 } //if 04506 04507 wait(0.1);//gu-D 読込間隔の設定 04508 04509 } 04510 } 04511 04512 /********************************* 04513 gu_D グラフィックデータ 04514 *********************************/ 04515 char gu_Button_MODE_data[] = { 04516 0x7F,0xF0,0x80,0x08,0x80,0x0C,0x80,0x0A,0x80,0x0A,0x80,0x0A,0x80,0x0A,0x80,0x0A, 04517 0x80,0x0A,0x80,0x0A,0x80,0x0A,0x80,0x0A,0x7F,0xF2,0x20,0x02,0x1F,0xFC,0x00,0x00, 04518 }; 04519 04520 void gu_set_button(char sw_num,char* text) 04521 { 04522 char x; 04523 char y; 04524 04525 //SW_NoからSWの座標を求める 04526 x = ((sw_num - 1) % 8 ) * 32; 04527 y = ((sw_num - 1) / 8 ) * 32; 04528 04529 gu_drawButton(x,y,32,32, gu_Button_MODE_data ); 04530 04531 // Change Font Size 04532 gu_fontsize(2); 04533 // set font width 04534 gu_fontWidth(Proportional1); 04535 gu_print_dot( x + 8,y + 8,text); 04536 // Change Font Size 04537 gu_fontsize(1); 04538 // set font width 04539 gu_fontWidth(1); 04540 } 04541 04542 void gu_set_button_font1(char sw_num,char* text) 04543 { 04544 char x; 04545 char y; 04546 04547 //SW_NoからSWの座標を求める 04548 x = ((sw_num - 1) % 8 ) * 32; 04549 y = ((sw_num - 1) / 8 ) * 32; 04550 04551 gu_drawButton(x,y,32,32, gu_Button_MODE_data ); 04552 04553 // Change Font Size 04554 gu_fontsize(1); 04555 // set font width 04556 gu_fontWidth(1); 04557 gu_print_dot( x + 2,y + 10,text); 04558 04559 } 04560 04561 char gu_Button_up_data[] = { 04562 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0F,0xFF,0xFF,0xF0,0x10,0x00,0x00,0x08, 04563 0x20,0x00,0x00,0x04,0x20,0x00,0x00,0x04,0x20,0x00,0x00,0x04,0x20,0x00,0x18,0x04, 04564 0x20,0x00,0x38,0x04,0x20,0x00,0x78,0x04,0x20,0x00,0xF8,0x04,0x20,0x01,0xF8,0x04, 04565 0x20,0x03,0xF8,0x04,0x20,0x07,0xF8,0x04,0x20,0x0F,0xF8,0x04,0x20,0x1F,0xF8,0x04, 04566 0x20,0x1F,0xF8,0x04,0x20,0x0F,0xF8,0x04,0x20,0x07,0xF8,0x04,0x20,0x03,0xF8,0x04, 04567 0x20,0x01,0xF8,0x04,0x20,0x00,0xF8,0x04,0x20,0x00,0x78,0x04,0x20,0x00,0x38,0x04, 04568 0x20,0x00,0x18,0x04,0x20,0x00,0x00,0x04,0x20,0x00,0x00,0x04,0x20,0x00,0x00,0x04, 04569 0x10,0x00,0x00,0x08,0x0F,0xFF,0xFF,0xF0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 04570 }; 04571 04572 void gu_button_up(char sw_num) 04573 { 04574 char x; 04575 char y; 04576 04577 //SW_NoからSWの座標を求める 04578 x = ((sw_num - 1) % 8 ) * 32; 04579 y = ((sw_num - 1) / 8 ) * 32; 04580 04581 gu_cursor( x, y/8 ); 04582 gu_RealTimeImage(32, 32, gu_Button_up_data); 04583 } 04584 04585 void gu_Button_up1() 04586 { 04587 gu_cursor(224,8); 04588 gu_RealTimeImage(32, 32, gu_Button_up_data); 04589 } 04590 04591 void gu_Button_up2() 04592 { 04593 gu_cursor(192,8); 04594 gu_RealTimeImage(32, 32, gu_Button_up_data); 04595 } 04596 04597 void gu_Button_up3() 04598 { 04599 gu_cursor(160,8); 04600 gu_RealTimeImage(32, 32, gu_Button_up_data); 04601 } 04602 04603 void gu_Button_up4() 04604 { 04605 gu_cursor(128,8); 04606 gu_RealTimeImage(32, 32, gu_Button_up_data); 04607 } 04608 04609 char gu_Button_down_data[] = { 04610 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0F,0xFF,0xFF,0xF0,0x10,0x00,0x00,0x08, 04611 0x20,0x00,0x00,0x04,0x20,0x00,0x00,0x04,0x20,0x00,0x00,0x04,0x20,0x18,0x00,0x04, 04612 0x20,0x1C,0x00,0x04,0x20,0x1E,0x00,0x04,0x20,0x1F,0x00,0x04,0x20,0x1F,0x80,0x04, 04613 0x20,0x1F,0xC0,0x04,0x20,0x1F,0xE0,0x04,0x20,0x1F,0xF0,0x04,0x20,0x1F,0xF8,0x04, 04614 0x20,0x1F,0xF8,0x04,0x20,0x1F,0xF0,0x04,0x20,0x1F,0xE0,0x04,0x20,0x1F,0xC0,0x04, 04615 0x20,0x1F,0x80,0x04,0x20,0x1F,0x00,0x04,0x20,0x1E,0x00,0x04,0x20,0x1C,0x00,0x04, 04616 0x20,0x18,0x00,0x04,0x20,0x00,0x00,0x04,0x20,0x00,0x00,0x04,0x20,0x00,0x00,0x04, 04617 0x10,0x00,0x00,0x08,0x0F,0xFF,0xFF,0xF0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 04618 }; 04619 04620 void gu_button_down(char sw_num) 04621 { 04622 char x; 04623 char y; 04624 04625 //SW_NoからSWの座標を求める 04626 x = ((sw_num - 1) % 8 ) * 32; 04627 y = ((sw_num - 1) / 8 ) * 32; 04628 04629 gu_cursor( x, y/8 ); 04630 gu_RealTimeImage(32, 32, gu_Button_down_data); 04631 } 04632 04633 void gu_Button_down1() 04634 { 04635 gu_cursor(224,12); 04636 gu_RealTimeImage(32, 32, gu_Button_down_data); 04637 } 04638 04639 void gu_Button_down2() 04640 { 04641 gu_cursor(192,12); 04642 gu_RealTimeImage(32, 32, gu_Button_down_data); 04643 } 04644 04645 void gu_Button_down3() 04646 { 04647 gu_cursor(160,12); 04648 gu_RealTimeImage(32, 32, gu_Button_down_data); 04649 } 04650 04651 void gu_Button_down4() 04652 { 04653 gu_cursor(128,12); 04654 gu_RealTimeImage(32, 32, gu_Button_down_data); 04655 } 04656 04657 char gu_Button_up_on_data[] = { 04658 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0F,0xFF,0xFF,0xF0,0x1F,0xFF,0xFF,0xF8, 04659 0x3F,0xFF,0xFF,0xFC,0x3F,0xFF,0xFF,0xFC,0x3F,0xFF,0xFF,0xFC,0x3F,0xFF,0xE7,0xFC, 04660 0x3F,0xFF,0xC7,0xFC,0x3F,0xFF,0x87,0xFC,0x3F,0xFF,0x07,0xFC,0x3F,0xFE,0x07,0xFC, 04661 0x3F,0xFC,0x07,0xFC,0x3F,0xF8,0x07,0xFC,0x3F,0xF0,0x07,0xFC,0x3F,0xE0,0x07,0xFC, 04662 0x3F,0xE0,0x07,0xFC,0x3F,0xF0,0x07,0xFC,0x3F,0xF8,0x07,0xFC,0x3F,0xFC,0x07,0xFC, 04663 0x3F,0xFE,0x07,0xFC,0x3F,0xFF,0x07,0xFC,0x3F,0xFF,0x87,0xFC,0x3F,0xFF,0xC7,0xFC, 04664 0x3F,0xFF,0xE7,0xFC,0x3F,0xFF,0xFF,0xFC,0x3F,0xFF,0xFF,0xFC,0x3F,0xFF,0xFF,0xFC, 04665 0x1F,0xFF,0xFF,0xF8,0x0F,0xFF,0xFF,0xF0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 04666 }; 04667 04668 void gu_button_up_on( char sw_num ) 04669 { 04670 char x; 04671 char y; 04672 04673 //SW_NoからSWの座標を求める 04674 x = ((sw_num - 1) % 8 ) * 32; 04675 y = ((sw_num - 1) / 8 ) * 32; 04676 04677 gu_cursor( x, y/8 ); 04678 04679 gu_RealTimeImage(32, 32, gu_Button_up_on_data); 04680 } 04681 04682 void gu_Button_up_on2() 04683 { 04684 gu_cursor(192,8); 04685 gu_RealTimeImage(32, 32, gu_Button_up_on_data); 04686 } 04687 04688 char gu_Button_down_on_data[] = { 04689 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0F,0xFF,0xFF,0xF0,0x1F,0xFF,0xFF,0xF8, 04690 0x3F,0xFF,0xFF,0xFC,0x3F,0xFF,0xFF,0xFC,0x3F,0xFF,0xFF,0xFC,0x3F,0xE7,0xFF,0xFC, 04691 0x3F,0xE3,0xFF,0xFC,0x3F,0xE1,0xFF,0xFC,0x3F,0xE0,0xFF,0xFC,0x3F,0xE0,0x7F,0xFC, 04692 0x3F,0xE0,0x3F,0xFC,0x3F,0xE0,0x1F,0xFC,0x3F,0xE0,0x0F,0xFC,0x3F,0xE0,0x07,0xFC, 04693 0x3F,0xE0,0x07,0xFC,0x3F,0xE0,0x0F,0xFC,0x3F,0xE0,0x1F,0xFC,0x3F,0xE0,0x3F,0xFC, 04694 0x3F,0xE0,0x7F,0xFC,0x3F,0xE0,0xFF,0xFC,0x3F,0xE1,0xFF,0xFC,0x3F,0xE3,0xFF,0xFC, 04695 0x3F,0xE7,0xFF,0xFC,0x3F,0xFF,0xFF,0xFC,0x3F,0xFF,0xFF,0xFC,0x3F,0xFF,0xFF,0xFC, 04696 0x1F,0xFF,0xFF,0xF8,0x0F,0xFF,0xFF,0xF0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 04697 }; 04698 04699 void gu_button_down_on(char sw_num) 04700 { 04701 char x; 04702 char y; 04703 04704 //SW_NoからSWの座標を求める 04705 x = ((sw_num - 1) % 8 ) * 32; 04706 y = ((sw_num - 1) / 8 ) * 32; 04707 04708 gu_cursor( x, y/8 ); 04709 04710 gu_RealTimeImage(32, 32, gu_Button_down_on_data); 04711 } 04712 04713 void gu_Button_down_on2() 04714 { 04715 gu_cursor(192,12); 04716 gu_RealTimeImage(32, 32, gu_Button_down_on_data); 04717 } 04718 04719 char gu_Button_power_on_data[] = { 04720 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0F,0xFF,0xFF,0xF0,0x10,0x00,0x00,0x08, 04721 0x20,0x00,0x00,0x04,0x20,0x00,0x00,0x04,0x20,0x00,0x00,0x04,0x20,0x03,0xF0,0x04, 04722 0x20,0x0F,0xFC,0x04,0x20,0x1F,0xFE,0x04,0x20,0x3C,0x0F,0x04,0x20,0x38,0x07,0x84, 04723 0x20,0x00,0x03,0x84,0x20,0x00,0x03,0xC4,0x20,0x00,0x01,0xC4,0x21,0xFF,0x01,0xC4, 04724 0x21,0xFF,0x01,0xC4,0x20,0x00,0x01,0xC4,0x20,0x00,0x03,0xC4,0x20,0x00,0x03,0x84, 04725 0x20,0x38,0x07,0x84,0x20,0x3C,0x0F,0x04,0x20,0x1F,0xFE,0x04,0x20,0x0F,0xFC,0x04, 04726 0x20,0x03,0xF0,0x04,0x20,0x00,0x00,0x04,0x20,0x00,0x00,0x04,0x20,0x00,0x00,0x04, 04727 0x10,0x00,0x00,0x08,0x0F,0xFF,0xFF,0xF0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 04728 }; 04729 04730 void gu_Button_power_on() 04731 { 04732 gu_cursor(224,0); 04733 gu_RealTimeImage(32, 32, gu_Button_power_on_data); 04734 } 04735 04736 04737 char gu_Button_power_off_data[] = { 04738 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0F,0xFF,0xFF,0xF0,0x1F,0xFF,0xFF,0xF8, 04739 0x3F,0xFF,0xFF,0xFC,0x3F,0xFF,0xFF,0xFC,0x3F,0xFF,0xFF,0xFC,0x3F,0xFC,0x0F,0xFC, 04740 0x3F,0xF0,0x03,0xFC,0x3F,0xE0,0x01,0xFC,0x3F,0xC3,0xF0,0xFC,0x3F,0xC7,0xF8,0x7C, 04741 0x3F,0xFF,0xFC,0x7C,0x3F,0xFF,0xFC,0x3C,0x3F,0xFF,0xFE,0x3C,0x3C,0x00,0x7E,0x3C, 04742 0x3C,0x00,0x7E,0x3C,0x3F,0xFF,0xFE,0x3C,0x3F,0xFF,0xFC,0x3C,0x3F,0xFF,0xFC,0x7C, 04743 0x3F,0xC7,0xF8,0x7C,0x3F,0xC1,0xE0,0xFC,0x3F,0xE0,0x01,0xFC,0x3F,0xF0,0x03,0xFC, 04744 0x3F,0xFC,0x0F,0xFC,0x3F,0xFF,0xFF,0xFC,0x3F,0xFF,0xFF,0xFC,0x3F,0xFF,0xFF,0xFC, 04745 0x1F,0xFF,0xFF,0xF8,0x0F,0xFF,0xFF,0xF0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 04746 }; 04747 04748 void gu_Button_power_off() 04749 { 04750 gu_cursor(224,0); 04751 gu_RealTimeImage(32, 32, gu_Button_power_off_data); 04752 } 04753 04754 /********************************* 04755 ノリタケ関数 04756 ここから 04757 **********************************/ 04758 // 04759 // Clear screen// 04760 void gu_cls() 04761 { 04762 04763 i2c.start(); 04764 i2c.write(addr_gu); 04765 i2c.write(0x0c); 04766 i2c.stop(); 04767 04768 } 04769 04770 void gu_drawButton(int x, int y, int w, int h, const char data[]) 04771 { 04772 h = h >> 3; // get height in byte 04773 y = y >> 3; // get Y location in byte 04774 04775 gu_cursor(x,y); 04776 // Realtime Image draw header 04777 04778 i2c.start(); 04779 i2c.write(addr_gu); 04780 gu_sendOneByte(0x1f); 04781 gu_sendOneByte(0x28); 04782 gu_sendOneByte(0x66); 04783 gu_sendOneByte(0x11); 04784 gu_sendOneByte( w & 0xff); 04785 gu_sendOneByte( w >> 8); 04786 gu_sendOneByte( h & 0xff); 04787 gu_sendOneByte( h >> 8); 04788 gu_sendOneByte(0x01); 04789 04790 for(int i = 0; i<w; i++) { 04791 if(i<8) { // 8 dots from left 04792 gu_sendOneByte(data[i*2]); 04793 if(h>2) { 04794 for(int j=0; j<(h-2); j++) { 04795 if((data[i*2]&0x01)==0) { 04796 gu_sendOneByte(0x00); 04797 } else { 04798 gu_sendOneByte(0xff); 04799 } 04800 } 04801 } 04802 gu_sendOneByte(data[i*2+1]); 04803 } else if (i > (w-8)) { // 8 dots from right 04804 04805 gu_sendOneByte(data[(16+i-w)*2]); 04806 if(h>2) for(int j=0; j<(h-2); j++) { 04807 if((data[(16+i-w)*2]&0x01)==0) { 04808 gu_sendOneByte(0x00); 04809 } else { 04810 gu_sendOneByte(0xff); 04811 } 04812 } 04813 gu_sendOneByte(data[(16+i-w)*2+1]); 04814 04815 } else { // in the middle 04816 gu_sendOneByte(data[14]); 04817 if(h>2) { 04818 for(int j=0; j<(h-2); j++) { 04819 if((data[14]&0x01)==0) { 04820 gu_sendOneByte(0x00); 04821 } else { 04822 gu_sendOneByte(0xff); 04823 } 04824 } 04825 } 04826 gu_sendOneByte(data[15]); 04827 } 04828 } 04829 04830 i2c.stop(); 04831 04832 } 04833 04834 04835 // ドット単位キャラクタ表示 p37 04836 void gu_print_dot(int x, int y, const char* ptext) 04837 { 04838 04839 i2c.start(); 04840 i2c.write(addr_gu); 04841 gu_sendOneByte(0x1f); 04842 gu_sendOneByte(0x28); 04843 gu_sendOneByte(0x64); 04844 gu_sendOneByte(0x30); 04845 gu_sendOneByte(x & 0xff); 04846 gu_sendOneByte(x >> 8); 04847 gu_sendOneByte(y & 0xff); 04848 gu_sendOneByte(y >> 8); 04849 gu_sendOneByte(0x00); 04850 04851 int i=0; 04852 int j=0; 04853 while(*(ptext+i)) { 04854 if (*(ptext + i++) =='%') { 04855 j+=2; //文字列終端”0%"までインクリメント 04856 } 04857 } 04858 04859 gu_sendOneByte(i-j); //キャラクタデータ長 04860 gu_print(ptext); //キャラクタデータ 04861 04862 i2c.stop(); 04863 04864 } 04865 04866 // 04867 // Print test// 04868 void gu_print(const char t[] ) 04869 { 04870 i2c.start(); 04871 i2c.write(addr_gu); 04872 04873 int i=0; 04874 int j=0; 04875 int k=0; 04876 while(t[i]) { 04877 if(t[i] != 37) { 04878 gu_sendOneByte(t[i++]); 04879 } else { 04880 i++; 04881 j=t[i++]-0x30; 04882 if(j>9) { 04883 j -= 7; 04884 } 04885 if(j>0x10) { 04886 j -= 0x20; 04887 } 04888 k=t[i++]-0x30; 04889 if(k>9) { 04890 k -= 7; 04891 } 04892 if(k>0x10) { 04893 k -= 0x20; 04894 } 04895 gu_sendOneByte(j*16+k); 04896 } 04897 } 04898 i2c.stop(); 04899 } 04900 04901 void gu_RealTimeImage(int w, int h, char data[]) 04902 { 04903 h = h >> 3; // get height in byte 04904 04905 i2c.start(); 04906 gu_sendOneByte(addr_gu); 04907 gu_sendOneByte(0x1f); 04908 gu_sendOneByte(0x28); 04909 gu_sendOneByte(0x66); 04910 gu_sendOneByte(0x11); 04911 gu_sendOneByte( w & 0xff); 04912 gu_sendOneByte( w >> 8); 04913 gu_sendOneByte( h & 0xff); 04914 gu_sendOneByte( h >> 8); 04915 gu_sendOneByte(0x01); 04916 for( int i=0; i < ( w * h ); i++) { 04917 gu_sendOneByte( data[i]); 04918 } 04919 i2c.stop(); 04920 } 04921 04922 // Draw RealTimeBitImage by dot 04923 void gu_RealTimeImage_dot(int x, int y, int w, int h, const char data[]) 04924 { 04925 i2c.start(); 04926 gu_sendOneByte(addr_gu); 04927 gu_sendOneByte(0x1f); 04928 gu_sendOneByte(0x28); 04929 gu_sendOneByte(0x64); 04930 gu_sendOneByte(0x21); 04931 gu_sendOneByte(x & 0xff); 04932 gu_sendOneByte(x >> 8); 04933 gu_sendOneByte(y & 0xff); 04934 gu_sendOneByte(y >> 8); 04935 gu_sendOneByte(w & 0xff); 04936 gu_sendOneByte(w >> 8); 04937 gu_sendOneByte(h & 0xff); 04938 gu_sendOneByte(h >> 8); 04939 gu_sendOneByte(0x01); 04940 for(int i=0; i<( w * ((h + 7)>>3)); i++ ) { 04941 gu_sendOneByte(data[i]); 04942 } 04943 i2c.stop(); 04944 } 04945 04946 04947 // Set Font width 04948 void gu_fontWidth(const char fontWidth) 04949 { 04950 /* 04951 gu_sendOneByte(0x1f); 04952 gu_sendOneByte(0x28); 04953 gu_sendOneByte(0x67); 04954 gu_sendOneByte(0x03); 04955 gu_sendOneByte(fontWidth); 04956 */ 04957 04958 char accom_gu[5] ; //gu-DへのI2Cコマンド用配列 04959 04960 accom_gu[0] = 0x1F; 04961 accom_gu[1] = 0x28; 04962 accom_gu[2] = 0x67; 04963 accom_gu[3] = 0x03; 04964 accom_gu[4] = fontWidth; 04965 04966 i2c.write(addr_gu, accom_gu, 5); 04967 04968 } 04969 04970 // 04971 // Move Cursor 04972 // 動作確認完了 2017/6/26 04973 void gu_cursor(int x, int y) 04974 { 04975 04976 /* 04977 gu_sendOneByte(0x1f); 04978 gu_sendOneByte(0x24); 04979 gu_sendOneByte(x%256); 04980 gu_sendOneByte(x>>8); 04981 gu_sendOneByte(y%256); 04982 gu_sendOneByte(y>>8); 04983 */ 04984 04985 char accom_gu[6] ; //gu-DへのI2Cコマンド用配列 04986 04987 accom_gu[0] = 0x1f; 04988 accom_gu[1] = 0x24; 04989 accom_gu[2] = x & 0xFF; 04990 accom_gu[3] = x >> 8; 04991 accom_gu[4] = y & 0xFF; 04992 accom_gu[5] = y >> 8; 04993 04994 i2c.write(addr_gu, accom_gu, 6); 04995 04996 } 04997 04998 // Font Body Size 04999 // 動作確認2017/6/26 05000 void gu_fontsize(const char code) 05001 { 05002 /* 05003 gu_sendOneByte(0x1f); 05004 gu_sendOneByte(0x28); 05005 gu_sendOneByte(0x67); 05006 gu_sendOneByte(0x01); 05007 gu_sendOneByte(code); 05008 */ 05009 char accom_gu[5] ; //gu-DへのI2Cコマンド用配列 05010 05011 accom_gu[0] = 0x1F; 05012 accom_gu[1] = 0x28; 05013 accom_gu[2] = 0x67; 05014 accom_gu[3] = 0x01; 05015 accom_gu[4] = code; 05016 05017 i2c.write(addr_gu, accom_gu, 5); 05018 05019 } 05020 05021 05022 // 05023 // Reverse video font 05024 void gu_fontReverse(int code) 05025 { 05026 05027 i2c.start(); 05028 gu_sendOneByte(addr_gu); 05029 gu_sendOneByte(0x1f); 05030 gu_sendOneByte(0x72); 05031 gu_sendOneByte(code); 05032 i2c.stop(); 05033 05034 } 05035 05036 void gu_touchPara(int x,int y) 05037 { 05038 i2c.start(); 05039 i2c.write(addr_gu); 05040 i2c.write(0x1F); 05041 i2c.write(0x4B); 05042 i2c.write(0x70); 05043 i2c.write(x & 0xFF); 05044 i2c.write(y & 0xFF); 05045 i2c.stop(); 05046 } 05047 05048 // Magnify Font ｷｬﾗｸﾀ拡大表示 05049 void gu_magnify(int x, int y) 05050 { 05051 gu_sendOneByte(0x1f); 05052 gu_sendOneByte(0x28); 05053 gu_sendOneByte(0x67); 05054 gu_sendOneByte(0x40); 05055 gu_sendOneByte(x); 05056 gu_sendOneByte(y); 05057 } 05058 05059 /********************************* 05060 ノリタケ関数 05061 ここまで 05062 **********************************/ 05063 // 05064 //Show text 05065 void gu_print1(const char* ptext) 05066 { 05067 i2c.write(addr_gu, ptext, strlen(ptext)); 05068 } 05069 // 05070 //輝度調整 05071 void gu_luminance(const char* cl) 05072 { 05073 i2c.start(); 05074 i2c.write(addr_gu); 05075 i2c.write(0x1F); 05076 i2c.write(0x58); 05077 i2c.write(*cl & 0xFF); 05078 i2c.stop(); 05079 } 05080 // 05081 //gu_Dｸﾗｽ用 1ﾊﾞｲﾄ送信 05082 void gu_sendOneByte(char data) //arduino->mbed 05083 { 05084 i2c.write(data); 05085 //while(digitalRead(gu_MBUSY)==HIGH){} // wait for ready. 05086 //Serial.write(data); // send a byte. 05087 } 05088 // 05089 //CF+RF 05090 void gu_CRLF() 05091 { 05092 char com[2]; 05093 05094 com[0] = 0x0A; //LF 05095 com[1] = 0x0D; //CR 05096 i2c.write(addr_gu, com, 2); //LF+CR 05097 } 05098 // 05099 //ﾘﾊﾞｰｽ指定or解除 05100 void gu_reverse(char x) //ﾘﾊﾞｰｽ指定or解除 05101 { 05102 char com[3]; 05103 05104 com[0] = 0x1F; 05105 com[1] = 0x72; 05106 com[2] = x & 0xFF; //0x01:指定 0x00:解除 05107 i2c.write(addr_gu, com, 3); 05108 } 05109 //1byte送信用 05110 void gu_onebyte(char data) 05111 { 05112 i2c.write(addr_gu, &data, 1); 05113 } 05114 /***************************************** 05115 05116 SD CARD 05117 05118 *****************************************/ 05119 void sd_writetext(const char* ptext) 05120 { 05121 05122 mkdir("/sd/mydir", 0777); 05123 05124 FILE *fp = fopen("/sd/mydir/iop.txt", "w");//ディレクトリとファイル名の指定 05125 05126 if(fp == NULL) { 05127 05128 gu_fontsize(1); 05129 gu_cursor(0,2); 05130 /* ver1.1.3*/ 05131 gu_print1("No SD card"); 05132 //gu_print1("Could not open file for SD card"); 05133 //error("Could not open file for write\n"); 05134 05135 } 05136 05137 fprintf(fp, ptext); 05138 fclose(fp); 05139 05140 } 05141 05142 05143 05144 /**************************************** 05145 05146 シーケンサ通信 05147 05148 ****************************************/ 05149 //一定時間CAL名未送信 05150 void seq_timeout(){ 05151 /* 05152 seq_name[0] = 2; 05153 seq_name[3] = 3; 05154 */ 05155 seq_name[0] = 50; 05156 seq_name[3] = 51; 05157 } 05158 05159 05160 //CAL名受信 05161 void seq_serialrecive(){ 05162 05163 seq_name[0] = pc.getc(); 05164 seq_name[1] = pc.getc(); 05165 seq_name[2] = pc.getc(); 05166 seq_name[3] = pc.getc(); 05167 05168 //CAL番号だけ抽出 05169 reg_num = (seq_name[1] - 0x30) * 10; 05170 reg_num = reg_num + (seq_name[2] - 0x30); 05171 05172 //EEPROMへCAL番号を書き込み 05173 wdata[0] = adrs_calnum[0]; //byte address a15~8 05174 wdata[1] = adrs_calnum[1]; //byte address a7~a0 05175 wdata[2] = reg_num; 05176 Soushin = i2c.write (eeprom_adrs, wdata, 3); //send stop at end default value is false. 05177 05178 } 05179 05180 05181 //測定データ送信 05182 void seq_serialsend(/*int noc*/) //デバック時int nocコメントアウト 05183 { 05184 char STX = 2; 05185 char EXT = 3; 05186 int i; 05187 int CH[] = {1,2,3,4}; 05188 int noc = 4; 05189 05190 for(i = 0; i <= ( noc - 1); i++){ 05191 //PCデバック用 pc.→uart.に変更で装置用へ変更出来る 05192 pc.printf("%c" , STX); 05193 pc.printf("%d" , CH[i]); 05194 pc.printf("%c" , ','); 05195 pc.printf("%d" , seq_name[0]); 05196 pc.printf("%c" , ','); 05197 pc.printf("%d" , seq_name[3]); 05198 pc.printf("%c" , ','); 05199 pc.printf("%d" , reg_num); 05200 pc.printf("%c" , ','); 05201 pc.printf("%s\n" , calinfo.name); 05202 pc.printf("%c" , ','); 05203 05204 //アンテナ抵抗値 05205 if(R[i] < res_vref && R[0] >= 0){ 05206 pc.printf("%d" , R[i]); 05207 } 05208 else{ 05209 pc.printf("%s" , "OL"); 05210 } 05211 05212 pc.printf("%c" , ','); 05213 pc.printf("%f" , fdata[i][0]); //Iop 05214 pc.printf("%c" , ','); 05215 pc.printf("%f" , fdata[i][1]); //Idd 05216 pc.printf("%c" , ','); 05217 pc.printf("%f" , fdata[i][2]); //Voc 05218 pc.printf("%c" , ','); 05219 pc.printf("%f" , vocp[i]); 05220 pc.printf("%c" , ','); 05221 05222 if(err_f == 0){ //void hanteiのエラーフラグを流用 05223 pc.printf("%s" , "PASS"); 05224 } 05225 else{ 05226 pc.printf("%s" , "FAIL"); 05227 } 05228 05229 pc.printf("%c" , ','); 05230 pc.printf("%d" , cat); 05231 pc.printf("%c\n" , EXT); 05232 }//for 05233 05234 }
Generated on Thu Aug 4 2022 04:43:32 by
1.7.2