unixtime转换 hive unix 时间转换

实时时钟在嵌入式系统中应用非常广泛，一些芯片还内置了实时时钟。实际应用中往往使用外接I2C总线带电池时钟，系统上电后读取I2C总线时钟，初始化内部实时时钟，程序获取时间直接读内部实时时钟就可以了。
PHLIPS公司的ARM都内置了年月日时分秒格式的实时时钟，很好用；但是其他公司的产品并不具备这个功能，一部分只能记秒；51等简单单片机甚至没有内部实时时钟，一般需要使用中断程序累计秒。

看来Unix时间和年月日时分秒时间格式转换还是很有必要详细分析分析。其实这部分工作电脑很早就实现了，其算法也非常成熟，只不过这些底层的东西平时我们不注意罢了。
下面先看一段Linux年月日转时分秒的算法，听说这个算法是目前最高效的算法：

首先将天数和秒数分开，如果Unix秒为负，表示当前为1970年前。

typedef         
  struct 
   _DATE_TIME                     
  // 
  年月日时分秒毫秒 
  
 
  ... 
  {
    unsigned short year;
    unsigned char month;
    unsigned char day;
    unsigned char hour;
    unsigned char minute;
    unsigned char second;
    unsigned short msel;                        //millisecond
} 
   DATE_TIME;


 
  long 
    
  long 
   rtt_mktime(DATE_TIME time)
 
  ... 
  {
    long long res;

    // 1..12 -> 11,12,1..10, Puts Feb last since it has leap day
    if (time.month <= 2)
    ...{
        time.month += 10;
        time.year -= 1;
    }
    else
    ...{
        time.month -= 2;
    }

    /**//*
    // Calculate how much days from 1970 to today
    res = 59;                            //31@0001-January and 28@0001-February
    res += (time.year - 1) * 365;        //at least 365 days one year
    res += time.year / 4 - time.year / 100 + time.year / 400;    //leap years from 0001
    res += 367 * time.month / 12 - 30;    //days from March(0.5/7<=slope<0.5/5)
    res += time.day - 1;                //days
    res -= 719162;                        //days from 0001-1-1 to 1970-1-1
    // Calculate how much seconds
    res = ( (res * 24 + time.hour) * 60 + time.minute) * 60 + time.second;
    */
    /**////*
    res = (long long)(time.year/4 - time.year/100 + time.year/400) +
            367*time.month/12 + time.day +
            time.year*365 - 719499;
    res = ((res*24 + time.hour        // now have hours
            )*60 + time.minute            // now have minutes
           )*60 + time.second;            // finally seconds
    //*/

    return res;
} 

DATE_TIME是我自己定义的时间格式数据结构。 


年月日时分秒转换为Unix秒时间有两个难点：闰年的计算和月份天数的计算如何能不用判断语句直接利用数学函数来计算，一个看似简单的数字游戏。 

首先要注意公元纪年没有公元前0年和公元0年，公元后的第一天是0001年1月1日。 


闰年的计算可以比较简单：0001年到当年共有year/4-year/100+year/400个，闰年的天数是366天；所以从0001年到当年共有(year-1)*365 + year/4-year/100+year/400天。 

从1月到当月的天数计算起来比较复杂，但是从3月当当月的天数可以用函数来表示；我们可以使用一次函数表示，斜率大于等于30.5+0.5/7，小于30.5+0.5/5，以斜率30.5+0.5/6为例：y=ax+b,a=30.5+0.5/6=367/12,b=-30，有兴趣的朋友可以算一下，结果取整数就是3月到当月的天数：0，31，61，92，122，153，184，214，245，275，306，337。 

为了能够使用巧妙的函数，我们需要假设一年是从3月开始的，步骤如下： 

首先调整月份，一月和二月当作上一年的最后两个月； 

由于调整了月份，调整后的0001年1月即调整前的0001年3月实际上已经有0001年1月31天和0001年2月28天； 

由于公元纪年没有0年，所以调整后的0001年到调整后的当年共有(year-1)*365 + year/4-year/100+year/400天； 

从调整后的1月到调整后的当月共有367*month/12-30天； 

日期也是从1日开始的，从1日到当日共day-1天； 


最后将0001年到当天的天数计算出来，减去0001年到1970年的天数719162，即是Unix天数，这样就可以得到Unix秒了。 



2 年月日时分秒转Unix时间函数 


   
void    rtt_localtime( 
  long 
    
  long 
   res, DATE_TIME  
  * 
  time)
   ... 
  {
    const int monthLengths[2][13] = ...{
        ...{ 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365},
        ...{ 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366},
    };
    const int yearLengths[2] = ...{ 365, 366 };
    int year;
    int month;
    int minMonth;
    int maxMonth;
    
    int days;
    int clock;
    int isLeap;
    
    days = res / 86400;
    clock = res % 86400;
    if(clock < 0)
    ...{
        clock += 86400;
        days -= 1;
    }
    
    /**/////
    // Calcaulate year, 11323=0x3A4FC880/86400; 13879=0x47798280/86400
    /**////    
    if(days >= 0)
    ...{
        year = days/366;
        days -= year*365 + (year+1)/4 - (year+69)/100 + (year+369)/400;
        
        for(time->year = year + 1970; ; time->year++)
        ...{
            isLeap = rtt_isleap(time->year);
            if(days < yearLengths[isLeap])
            ...{
                break;
            }
            days -= yearLengths[isLeap];
        }
    }
    else
    ...{
        year = days/366;
        days -= year*365 + (year-2)/4 - (year-30)/100 + (year-30)/400;
        
        for(time->year = year + 1970 - 1; ; time->year--)
        ...{
            isLeap = rtt_isleap(time->year);
            days += yearLengths[isLeap];
            
            if(days >= 0)
            ...{
                break;
            }
        }
    }    
    
    /**///
    // compute month and day, use the half search save time
    /**////
    minMonth = 0;
    maxMonth = 12;
    for(month = 5; month < 12 && month > 0; month = (minMonth + maxMonth) / 2)
    ...{
        // days between monthLengths[month]<=days<monthLengths[month+1]
        if(days < monthLengths[isLeap][month])    //too big
        ...{
            maxMonth = month;
        }
        else if(days >= monthLengths[isLeap][month + 1])    //too small
        ...{
            minMonth = month;
        }
        else    //so it is
        ...{
            break;
        }
    }
    days -= monthLengths[isLeap][month];
    time->month = month + 1;
    
    time->day = days + 1;
    
    
    /**///
    // Calcaulate hour minute and second
    /**///
    time->hour = clock / 3600;        //3600s one hour
    clock = clock % 3600;
    time->minute = clock / 60;        //60s one minute
    time->second = clock % 60;        //ms
}

Unix天数为正，当前年份在1970年之后，至少为days/366+1970年，首先假设当年为year=days/366+1970年；

从1970年到假设年year的闰年数为(year+1)/4-(year+69)/100+(year+369)/400，从1970年到假设年year共有(year-1970)*365 + (year+1)/4-(year+69)/100+(year+369)/400；

适当调整假设年这样我们就很快找到当前年份了。

Unix天数为负，则当前年份为1970年前，只不过从当前年到1970年的闰年数为(year-2)/4-(year-30)/100+(year-30)/400。

月份的计算采用二分法查找的方法，如果大于等于本月总天数，小于下一个月的总天数，则本月即为当前月；

最后剩余天数加1即为当日。