test0202

#!/usr/bin/perl
#use warnings;  
use DBI;  
use File::Copy;  
use POSIX qw(strftime);  
  
################################################  
#             variable define  
################################################  
  
@waferHeader = ();  
%headerValue = ();  
  
# define a format to write BIN_SUMMARY  
format write_bin_sum =  
@>>>>>,@>>>>>>>>,  @>>>>>>>,  @>>>>>>>>,    @*  
$binno,$binname,$binspec,$bincount,$bindesc  
.  
# define a format to write MAP_RAW  
format write_map_raw =
@>>>>>>,@>>>>>>,      @*
$bin_x,$bin_y,$bin_value
.

local $gsCfgFile;  
local $line;  
local $gs_status = "";  
local @bin_map;  
local @raw_map;
local $bin_count;
local $good_bin;
local $lower_x = 0;
local $map_row_count = 0; 
local $exec_bin_count=0;
  
local $bindefFile="/Users/yangmin/Downloads/lml_workspace/test020202/G2980.bindef";
local $mapFile="/Users/yangmin/Downloads/lml_workspace/test020202/001.A734070-01.tmc";

#local $mapFile="01A733944-14.tmb";   
################################################  
#             Main function begin  
################################################  
#if(($gsCfgFile = $ARGV[0]) eq "")
#{
#	die "Could not get CfgFile!\n";
#}
#if (($gsRawFile = $ARGV[1]) eq "")
#{
#	die "RawFile Name should not be NULL!\n";
#}
#
#ReadCfgFile();
#open_log_file();   
#print "gsWorkDir     $gsWorkDir\n";
#print "gsRawFile     $gsRawFile\n";
#open (InFile,"<$gsWorkDir$gsRawFile")||die print LogFile "FAIL$tran_time:$gsRawFile Could not open raw file\n";   
open (InFile, "<$mapFile") || die print LogFile "FAIL$mapFile Could not open raw file\n";  
initHeader();  
@bin_map = qw();  
@raw_map = qw();  
get_bin();
while($line = <InFile>)  
{  
    chomp($line);  
    if ($line eq "") {  
        next;  
    }  
  
    if (index($line, "Wafer Information") >= 0) {  
        $gs_status = "H"; ###Get Header  
    }  
    if (index($line, "++-++-++-++-++-++") >= 0) {  
        $gs_status = "M"; ###Get map  
        #print "Map: $line\n";  
    }  
    if ($gs_status eq "H")  
    {  
        ###print "Header: $line\n";  
        getHeader($line);
        $exec_bin_count++;  
    }
    
#    if($exec_bin_count == 1){
#    get_bin();
#    }
      
    if ($gs_status eq "M")  
    {  
        if (index($line,"|")>=0){
        #print "Map: $line\n";
        get_map();
        $map_row_count++; 
        #print "Map: $map_row_count\n"; 
        }
    }  
    if ($gs_status eq "Yield")  
    {  
        last;  
  
    }  
}  
  
$gsStdFile = $headerValue{$waferHeader[2]}."_".$headerValue{$waferHeader[4]}."_".$headerValue{$waferHeader[5]};  
print "OutFile is $gsStdFile\n";  
open (OutFile, ">$gsStdFile") || die print LogFile "FAIL$tran_time:$gsRawFile Could not open std file $gsStdFile\n";  
#open (OutFile, ">$gsStdDir$gsStdFile") || die print LogFile "FAIL$tran_time:$gsRawFile Could not open std file $gsStdFile\n";
  
drawHeader();  
print OutFile "\n";  
draw_map();  
print OutFile "\n";  
draw_bin_desc();  
print OutFile "\n";  
draw_map_raw();  
  
close(OutFile);  
close(InFile) || die print LogFile "FAIL$tran_time:$mapFile Could not close infile\n";  
#unlink("$mapFile");  
#######################################################  
#             function define  
#######################################################  
#Read Config File
sub ReadCfgFile {
	open (cfgFile,$gsCfgFile)||die("Could not open Config file $gsCfgFile!\n"); 
print "gsCfgFile=$gsCfgFile\n"; 	
	my $line;
	while ($line = <cfgFile>)
	{
		if($line =~ /=/)
		{
			my @array = split("=",$line);
			$array[0] =~ tr/ //d;
			$array[1] =~ tr/\n //d;
			if($array[0] eq "LOGDIR")
			{
				$gsLogDir = $array[1];
#				print "gsLogDir=$gsLogDir\n"; 
				next;
			}
			elsif($array[0] eq "WORKDIR")
			{
				$gsWorkDir = $array[1];
#				print "gsWorkDir=$gsWorkDir\n"; 
				next;
			}
			elsif($array[0] eq "STDDIR")
			{
				$gsStdDir = $array[1];
#				print "gsStdDir=$gsStdDir\n"; 
				next;
			}
			elsif($array[0] eq "BINDIR")
			{
				$gsBinDir = $array[1];
#				print "origin BINFILE_DIR:$gsBinDir\n";
				next;
			}
			elsif($array[0] eq "ERRDIR")
			{
				$gsErrDir = $array[1];
#				print "BINFILE_DIR:$gsBinDir\n";
				next;
			}
		}
		else
		{
			next;
		}	
	}
}

# create and open logfile
sub open_log_file {
	my $date=localtime(time);
	print "$date\n";
	my @date_time = split(" ",$date);
	$tran_time = join("_",@date_time);	
	my $filename;
	if ($days{$date_time[2]} eq "") {
		$filename = "tran_" . "$date_time[1]" . "$date_time[2]" . ".log";	
	}
	else {
		$filename = "tran_" . "$date_time[1]" . "$days{$date_time[2]}" . ".log";
	} 	
	
	my $logfile = $gsLogDir . $filename;
	open (LogFile,">>$logfile")||die("Could not open Log file $logfile!\n");	
}

# Fetch ProdId from EDA DB via LotID
sub getProdId {
	my $result;
	my $part6;
	#my @fid = split(/\./,$headerValue{$waferHeader[2]});
	#my $flotid = $headerValue{$waferHeader[2]}.".1";
	#print "-------------$flotid\n";
	my $dbh = DBI->connect("dbi:Oracle:edapdt",'pie','pie123') || return 0;
	my $sql = qq {select unique partname from actl\@edaap where lotid = '$headerValue{$waferHeader[2]}'};
	my $sth = $dbh->prepare($sql)||warn $dbh->errstr;
	$sth->execute();
	if($result = $sth->fetchrow)
	{
		$headerValue{$waferHeader[1]} = $result;
		$part6 = substr($result,0,5);
		$headerValue{$waferHeader[8]} = $part6.".bindef";
	}
	return 1;
}
  
# initial Wafer_Info Part  
sub initHeader {  
    # initial Wafer_Info title  
    $waferHeader[0] = "FAB           ";  
    $waferHeader[1] = "PRODUCT       ";  
    $waferHeader[2] = "Lot           ";  
    $waferHeader[3] = "PARENT_LOT    ";  
    $waferHeader[4] = "WAFER_ID      ";  
    $waferHeader[5] = "TEST_TYPE     ";  
    $waferHeader[6] = "MEASURE_TIME  ";  
    $waferHeader[7] = "TEST_PROGRAM  ";  
    $waferHeader[8] = "BIN_DEF_NAME  ";  
    $waferHeader[9] = "PROBE_CARD    ";  
    $waferHeader[10] = "LOAD_BOARD    ";  
    $waferHeader[11] = "TESTER        ";  
    $waferHeader[12] = "TEST_SITE     ";  
    $waferHeader[13] = "OPERATOR      ";  
    $waferHeader[14] = "WAFER_SIZE    ";  
    $waferHeader[15] = "DIE_SIZE      ";  
    $waferHeader[16] = "GROSS_DIES    ";  
    $waferHeader[17] = "TESTED_DIES   ";  
    $waferHeader[18] = "GOOD_DIES     ";  
    $waferHeader[19] = "REPAIR_DIES   ";  
    $waferHeader[20] = "FUNCTION_DIES ";  
    $waferHeader[21] = "NOTCH         ";  
    $waferHeader[22] = "UPPER_LEFT_XY ";  
    $waferHeader[23] = "LOWER_RIGHT_XY";  
    $waferHeader[24] = "BYTE_PER_DIE  ";  
    $waferHeader[25] = "NO_VALUE_DIE  ";  
    $waferHeader[26] = "NO_DIE        ";  
    $waferHeader[27] = "STARTTIME     ";  
    # initial Wafer_Info value  
    $headerValue{$waferHeader[0]}="FAB1A";               
    $headerValue{$waferHeader[1]}="G2980";               
    $headerValue{$waferHeader[2]}="";                    
    $headerValue{$waferHeader[3]}="";                    
    $headerValue{$waferHeader[4]}="";                    
    $headerValue{$waferHeader[5]}="CP1";                 
    $headerValue{$waferHeader[6]}="2010/01/01_00:00:00"; 
    $headerValue{$waferHeader[7]}="Program_CP1";         
    $headerValue{$waferHeader[8]}="Program_CP1";         
    $headerValue{$waferHeader[9]}="ProbeCard";           
    $headerValue{$waferHeader[10]}="LoadBoard";          
    $headerValue{$waferHeader[11]}="Tester";             
    $headerValue{$waferHeader[12]}="cellwise";                   
    $headerValue{$waferHeader[13]}="Operator";           
    $headerValue{$waferHeader[14]}=200;                  
    $headerValue{$waferHeader[15]}="12376.5,23450.11";   
    $headerValue{$waferHeader[16]}=0;                    
    $headerValue{$waferHeader[17]}=0;                    
    $headerValue{$waferHeader[18]}=0;                    
    $headerValue{$waferHeader[19]}=0;                    
    $headerValue{$waferHeader[20]}=0;                    
    $headerValue{$waferHeader[21]}="RIGHT";              
    $headerValue{$waferHeader[22]}="0,0";                
    $headerValue{$waferHeader[23]}="";                   
    $headerValue{$waferHeader[24]}=2;                    
    $headerValue{$waferHeader[25]}="@";                  
    $headerValue{$waferHeader[26]}="-";                  
    $headerValue{$waferHeader[27]}="2010/01/01_00:00:00"; 
}  
  
sub getHeader{  
    my $m_line = $line;  
    my @m_arr;  
    my @m_arr1;  
    my $m_date;  
    my $year;  
    my $month;  
    my $day;  
    my $hour;  
    my $min;  
    my $m_time;  
    my $str1;  
  
    ##lot id  
    if (index($m_line, "Wafer ID") >= 0) {  
        chomp($m_line);  
        $m_line =~ tr/\r//d;  
        print "$m_line /n";  
        @m_arr = split(":", $m_line);  
        $m_arr[1] =~ tr/ //d;  
        @m_arr1 = split("-", $m_arr[1]);  
        $headerValue{$waferHeader[2]} = $m_arr1[0].".1";  ###lot id  
        $headerValue{$waferHeader[4]} = $m_arr1[1];  ###wafer id        
    } 
    ##notch
    if (index($m_line, "Flat Dir") >= 0) {  
        chomp($m_line);  
        $m_line =~ tr/\r//d;  
        print "$m_line /n";  
        @m_arr = split(":", $m_line);  
        $m_arr[1] =~ tr/ //d;  
        $headerValue{$waferHeader[21]} = $m_arr[1];##notch      
    } 
    
    ##Operater
    if (index($m_line, "Operater") >= 0) {  
        chomp($m_line);  
        $m_line =~ tr/\r//d;  
        print "$m_line /n";  
        @m_arr = split(":", $m_line);  
        $m_arr[1] =~ tr/ //d;  
        $headerValue{$waferHeader[13]} = $m_arr[1];##Operater
        print "lot id is $m_arr1[0] wafer id is $m_arr1[1]\n";  
         
    } 
    
  #  getProdId();
  # if(!getProdId())
  #   {
  #   die print LogFile "Fail$tran_time:$gsRawFile Could connect to DB\n";
  #   }
  #   elsif ($headerValue{$waferHeader[1]} eq "rda") {
	#  move ("$gsWorkDir$gsRawFile",$gsErrDir);
	#  die print LogFile "Fail$tran_time:$gsRawFile wrong partid\n";
  #   } 
  #
  
    ###START TIME     : Wafer Test Start Time: 1710150550  
    if (index($m_line, "Wafer Test Start Time") >= 0) {  
        @m_arr = split(":", $m_line);  
        $m_arr[1] =~ tr/ //d;  
        $m_date = $m_arr[1];  
        $year = substr($m_date, 0, 2);  
        $month = substr($m_date, 2, 2);  
        $day = substr($m_date, 4, 2);  
        $hour = substr($m_date, 6, 2);  
        $min = substr($m_date, 8, 2);  
  
        $headerValue{$waferHeader[6]} = "20"."$year/$month/$day"."_"."$hour:$min:"."00"; ###measure_time  
        $headerValue{$waferHeader[27]} = "20"."$year/$month/$day"."_"."$hour:$min:"."00"; ###measure_time  
  
        print "measure_time is $headerValue{$waferHeader[27]}\n";  
    }  
  
}  
  
  
sub get_bin{  
    my $line1;  
    my @array;  
    my %bin_str;  
  
    $gsBinFile = "G3037.bindef";  
    #open (BinFile,"<$gsBinDir$gsBinFile")||die print LogFile "FAIL:$gsRawFile Could not open bin file:$gsBinDir$gsBinFile!\n";
    open (BinFile, "<$bindefFile") || die print LogFile "FAIL:$gsBinFile Could not open bin file:$gsBinFile!\n";  
    #$line1 = <BinFile>;  
    while($line1 = <BinFile>)  
    {  
        chomp($line1);  
        @array = split(",", $line1);  
        $array[0] =~ s/\A\s+|\s+\z//g;  
        $array[1] =~ s/\A\s+|\s+\z//g;  
        $array[2] =~ s/\A\s+|\s+\z//g;  
        $array[3] =~ s/\A\s+|\s+\z//g;  
        print "Bin: $line1\n";  
        # use %bin_str to build a struct to storage every bin_desc  
        %bin_str = (  
            bin_no    => $array[0],  
            bin_name  => $array[1],  
            bin_spec  => $array[2],  
            bin_count => 0,  
            bin_desc  => $array[3]);  
  
        # use @bin_map to storage all %bin_str  
        push(@bin_map, { %bin_str });  
    }  
    close(BinFile);  
}  
  
# get wafer_map  
sub get_map {  
    my @wafer_map;  
    my @temp;  
    my %map_raw;  
    my $bin_no;
#    my $good_bin = 0;
#    my $bin_count = 0;
    #my $lower_x = 0;  
    my $lower_y = 0;  
    my $outerloop = 0;  
    my $innerloop = 0;  
  
  
    if($map_row_count >0){  
        chomp($line);  
        $line =~ tr/\r//d;  
        $line =~ tr/\\//d;  
        #print $line."\n";  
        @temp = split("", $line );  
        #print $#temp."\n";  
        $now_cloum = 1;  
        for (my $i = $now_cloum; 3 * $i <= $#temp - 1; $i++) {  
  
            $lower_x = $lower_x < $i - $now_cloum ? $i - $now_cloum : $lower_x;  
  
            $str1 = $temp[3 * $i + 2];  
            $str2 = $temp[3 * $i + 3];  
            #$str3 = $temp[4*$i+3];  
  
            $bin_no = "$str1"."$str2";  
  
            $bin_no =~ s/\A\s+|\s+\z//g;  
            $bin_no =~ s/ //g;  
            #$map_x = $i;  
            #print "$bin_no \n";  
            if (length($bin_no) eq "1")  
                {  
                    $bin_no = "0".$bin_no;  
                }  
  
            if ($bin_no ne "") {  
                foreach $cur_bin(@bin_map)  
                {  
                    if ($cur_bin->{bin_name} eq $bin_no)  
                    {  
                        #$bin_no1 = $cur_bin->{bin_no};  
                        $cur_bin->{bin_count}++;  
                        if ($cur_bin->{bin_spec} eq "G")  
                        {  
                            $good_bin++;  
                        }  
                        $bin_count++;  
                        last;  
                    }  
                }  
  
                #%map_raw = ("x" => $i - $now_cloum, "y" => $lower_y, "bin_no" => $bin_no);  
                %map_raw = ("x" => $map_row_count , "y" => $i- $now_cloum, "bin_no" => $bin_no);  
                push(@raw_map, { %map_raw });  
                #print "$bin_no---\n";  
                $max_y = $max_y > ($i- $now_cloum) ? $max_y : $i- $now_cloum;  
                  
  
                $wafer_map[$i - $now_cloum][$lower_y] = $bin_no;  
  
            }  
  
        }  
        $lower_y = $lower_y + 1;  
        #        $line = <InFile>;  
  
  
        for ($outerloop = 0; $outerloop <= $lower_y - 1; $outerloop++) {  
            $map_str .= "<";  
            for ($innerloop = 0; $innerloop <= $lower_x; $innerloop++) {  
                if (defined($wafer_map[$innerloop][$outerloop]))  
                {  
                    $map_str .= $wafer_map[$innerloop][$outerloop];  
  
                } else {  
  
                    $map_str .= "--";  
                }  
            }  
            $map_str .= ">\n";  
        }  
  
        $headerValue{$waferHeader[16]} = $bin_count;  
        $headerValue{$waferHeader[17]} = $bin_count;  
        $headerValue{$waferHeader[18]} = $good_bin;  
        $headerValue{$waferHeader[23]} = ($max_y).",-".($map_row_count);  
        $lower_y = 0;  
  
        print OutFile $map_str;
    }  
    #print $map_str;  
} 
  
sub get_map2{  
    ###one by one line extract data  
    my @arr;  
    my $mbin = "";  
    my $mbin_no = "";  
    my $temp_x;  
    my @arr0;  
    my $m_line;  
    my $row = "";  
  
    $line = <InFile>;  
    $line =~ tr/\r//d;  
    chomp($line);  
    @arr = split("", $line);  
    ###print "line:$line\n";  
  
    $map_str = $map_str."<";  
  
    $gi_yMax++; ###Y value increase  
  
    for (my $counter = 1; $counter < $#arr / 3 - 3; $counter++)  
    {  
        $mbin = $arr[$counter * 3 + 2].$arr[$counter * 3 + 3].$arr[$counter * 3 + 4];  
  
        if ($mbin eq "  ") {  
  
            $map_str = $map_str."--"; ###for 3 digtials bin no  
            ###$row=$row."---";  
  
        }  
  
        $map_str = $map_str.$mbin;  
  
        if ($mbin eq "---") {  
            print "$mbin";
        } else {  
            foreach $cur_bin(@bin_map) {  
                if ($cur_bin->{bin_name} eq $mbin) {  
                    $cur_bin->{bin_count}++;  
                    if ($cur_bin->{bin_spec} eq "G") {  
                        ++$gi_good_bin;  
                    }  
  
                    $gi_bin_count++;  
                    last;  
                }  
            }  
  
            %map_raw = ("x" => $counter, "y" => $gi_yMax, "bin_no" => "$mbin");  
  
            push(@raw_map, { %map_raw });  
        }  
  
    }  
  
    $temp_x = int($#arr / 3 - 3);  
  
    $gi_xMax = $gi_xMax < $temp_x ? $temp_x : $gi_xMax;  ###$gi_xMax++; ###compare X value & get Max value  
  
    $map_str = $map_str.">";  
    $map_str = $map_str."\n";  
  
    ###print "row: $row\n";  
}  
  
# draw Wafer_INFO on std file  
sub drawHeader {  
    print OutFile "<WAFER_INFO>\n";  
    foreach my $key (@waferHeader)  
    {  
        $result = $headerValue{$key};  
        print OutFile "$key  = \"$result\"\n";  
    }  
    print OutFile "</WAFER_INFO>\n";  
}  
  
#draw wafer_map on std_file  
sub draw_map {  
    print OutFile "<MAP>\n$map_str</MAP>\n";
}  
  
  
# draw BIN_SUMMARY  
sub draw_bin_desc {  
    print OutFile "<BIN_SUMMARY>\nBIN_NO,\tBIN_NAME,  BIN_SPEC,  BIN_COUNT,    BIN_DESC\n";  
    select OutFile;  
    $~ = "write_bin_sum";  
    foreach my $bin_def(@bin_map)  
    {  
        ($binno, $binname, $binspec, $bincount, $bindesc) = ($bin_def->{bin_no}, $bin_def->{bin_name},  
            $bin_def->{bin_spec}, $bin_def->{bin_count}, $bin_def->{bin_desc});  
        write;  
    }  
    print OutFile "</BIN_SUMMARY>\n";  
}  
  
#draw MAP_RAW on std_file  
sub draw_map_raw {  
    print OutFile "<MAP_RAW>\n";
    $~ = "write_map_raw";  
    ($bin_x, $bin_y, $bin_value) = ("X", "Y", "BIN_NO");  
    write;  
    foreach $bin_raw(@raw_map)  
    {  
        ($bin_x, $bin_y, $bin_value) = ($bin_raw->{x}, $bin_raw->{y}, $bin_raw->{bin_no});  
        write;  
    }  
    print OutFile "</MAP_RAW>\n";
    @raw_map = ();  
}