ombro.c.bak

使用avr--cc2420模块程序,需要原理图的联系 QQ:120304948

#include <mega128.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>


#include "typedef.h"

#include "app.h"
#include "attention.h"
#include "Flash.h"
#include "g20modem.h"
#include "g20serialdrv.h"
#include "ombro.h"

#include "rtc.h"
#include "serialdrv.h"
#include "timer.h"
#include "UDP.h"
#include "protocol.h"

#include "key.h"
#include "lcdzk.h"
#include "print.h"
#include "ombrodb.h"

volatile unsigned char ombro_a_state = FALSE;
volatile unsigned char ombro_b_state = FALSE;
volatile UINT ombro_ab_check = 0;
bit ombro_working_state = FALSE;
//bit ombro_save_value = FALSE;

volatile UINT ombro_temp_count = 0;
volatile UINT ombro_shot_hour = 0;
volatile UINT ombro_shot_min = 0;
volatile UINT ombro_shot_year = 0;
volatile UINT ombro_shot_month = 0;
volatile UINT ombro_shot_day = 0;

volatile UINT ombro_hours_val[24];
volatile UINT ombro_min_per_hour[60];
volatile UINT ombro_min_per_tenmin[10];


//每分钟临时存储雨量
volatile UINT ombro_min_temp = 0;
volatile UINT ombro_hour_temp = 0;

volatile UINT ombro_min_count_per_hour = 0;
volatile UINT ombro_min_count_per_tenmin = 0;
volatile UINT ombro_hour_count = 0;

bit ombro_min_event = FALSE;
bit ombro_hour_event = FALSE;
bit ombro_sending = FALSE;

volatile UINT ombro_min = 0;
volatile UINT ombro_day = 0;
volatile UINT ombro_continue = 0;

volatile UINT ombro_ten = 0;
volatile UINT ombro_hour = 0;

volatile BYTE alarm_status = 0;

#pragma warn-
eeprom UINT ombro_ten_min_max_hr;
eeprom UINT ombro_ten_min_max_min;
eeprom UINT ombro_hour_max_hr;
eeprom UINT ombro_hour_max_min;
eeprom UINT ombro_hour_max;
eeprom UINT ombro_ten_min_max;
eeprom float fGrid;
#pragma warn+

unsigned char  warningvalueb = 0;
bit day_reset = FALSE;


UINT ombro_nlasting = 0;

void ombro_save_temp_min()
{
	ombro_min_per_hour[ombro_min_count_per_hour++] = ombro_min_temp;
	ombro_min_per_tenmin[ombro_min_count_per_tenmin ++] = ombro_min_temp;

	ombro_min_event = TRUE;

	ombro_min = ombro_min_temp;
	ombro_min_temp = 0;
	if(ombro_min_count_per_hour >= 60)
	{
		ombro_min_count_per_hour = 0;
	}
	if(ombro_min_count_per_tenmin >= 10)
	{
		ombro_min_count_per_tenmin = 0;
	}
}

void ombro_reset()
{
	unsigned int nLoop = 0;
	bit bDisplayed = 0;
	
	for(nLoop = 0; nLoop < 60; nLoop ++)
	{
		ombro_min_per_hour[nLoop] = 0;
	}

	for(nLoop = 0; nLoop < 10; nLoop++)
	{
		ombro_min_per_tenmin[nLoop] = 0;
	}

	ombro_day = 0;
	ombro_min_temp = 0;
	ombro_hour_temp = 0;
	ombro_continue = 0;
	alarm_status = 0;
	while(1)
	{
        wdr();
		ombro_get_status();
		delay_ms(200);
		if(ombro_working_state == FALSE)
		{
			if((bDisplayed == 0) && (day_reset == FALSE))
			{
//				disp_my_print("\r\n\n\n    雨量计故障, 请检查.");
                disp_hzstr(4,32,"雨量计故障, 请检查！"); 
				bDisplayed = 1;
			}
		}
		else
		{
//			if(bDisplayed == 1)
//				disp_my_print("\r");
//                disp_hzstr(4,32,"　　　　　　　　　　"); 
			return;
		}
		delay_ms(2000);
	}
}

void ombro_save_temp_hour(BYTE n)
{
	ombro_hours_val[n]++;
}

unsigned char ombro_get_a()
{
	if((PIND & 0x80) == 0x80)
		return TRUE;
	return FALSE;
}

unsigned char ombro_get_b()
{
	if((PIND & 0x40) == 0x40)
		return TRUE;
	return FALSE;
}

void ombro_init()
{
	DDRD &= ~0x3F;
	ombro_nlasting = 0;
	
	fGrid = 0.2; 
	
	my_ombset.nBeginTime = 6;
		
    if ((my_ombset.fPatrol10m > 999) || (my_ombset.fPatrol10m < 2))
        my_ombset.fPatrol10m = 10;
    if ((my_ombset.fPatrol1h > 999.9) || (my_ombset.fPatrol1h < 2.0))
        my_ombset.fPatrol1h = 20.0;
    if ((my_ombset.fPatrik1d > 999.9) || (my_ombset.fPatrik1d < 2.0))
        my_ombset.fPatrik1d = 30.0;
    if ((my_ombset.fPatrolCon > 999.9) || (my_ombset.fPatrolCon < 2.0))
        my_ombset.fPatrolCon = 40.0;
    if ((my_ombset.fRisk10m > 999.9) || (my_ombset.fRisk10m < 2.0))
        my_ombset.fRisk10m = 50;
    if ((my_ombset.fRisk1h > 999.9) || (my_ombset.fRisk1h < 2.0))
        my_ombset.fRisk1h = 60.0;
    if ((my_ombset.fRisk1d > 999.9) || (my_ombset.fRisk1d < 2.0))
        my_ombset.fRisk1d = 70.0;
    if ((my_ombset.fRiskCon > 999.9) || (my_ombset.fRiskCon < 2.0))
        my_ombset.fRiskCon = 80.0;

	ombro_reset();
//	disp_my_print("    雨量计........正常\n");
    disp_hzstr(4,32,"雨量计"); 
    disp_stringf(10,32,"........"); 
    disp_hzstr(18,32,"正常　　"); 
}

void ombro_get_status()
{
	ombro_a_state = ombro_get_a();
	ombro_b_state = ombro_get_b();
	ombro_ten_min_max = 0;
	ombro_hour_max = 0;
	if(ombro_a_state != ombro_b_state)
		ombro_working_state = TRUE;
	else
		ombro_working_state = FALSE;
}

unsigned char ombro_check()
{
	ombro_ab_check ++;
	if(ombro_ab_check > 4)
	{
		ombro_ab_check = 0;
		return TRUE;
	}	
	
	return FALSE;
}

void ombro_count()
{
	volatile unsigned char tempA = FALSE;
	volatile unsigned char tempB = FALSE;

	if(ombro_working_state != TRUE)
		return;
	tempA = ombro_get_a();
	tempB = ombro_get_b();

	if((tempA != ombro_a_state)&&(tempB != ombro_b_state))
	{
	
        free_time=0;
        
		if(ombro_check())
		{
			ombro_min_temp ++;
			ombro_hour_temp ++;
			ombro_continue ++;
			ombro_day ++;
			
			ombro_a_state = tempA;
			ombro_b_state = tempB;
			ombro_nlasting = 0;
			ombro_sending = TRUE;
		}
	}
	
}

void ombro_proc()
{
	register BYTE nLoop = 0;
	register unsigned int nSigma10 = 0;
	register unsigned int nSigma60 = 0;
//	unsigned int nHr = 0;
//	unsigned int nMin = 0;
//	unsigned int nYear = 0, nMonth = 0, nDay = 0, nSec = 0;

	float ftemp = 0.0;
	unsigned char warningstate = 0x00;
    unsigned char warningvalue = 0;
    unsigned char tempwarn = 0;

/*	nHr = nHr;
	nMin = nMin;
	nYear = nYear;
	nMonth = nMonth;
	nDay = nDay;
	nSec = nSec; */

	if (free_time>=54000)
	{
	    free_time=0;
		ombro_sending = FALSE;
	}

	if((ombro_min_event == TRUE)&&(ombro_sending == TRUE))
	{
		//计算十分雨量
		//	clk_shot(&nYear, &nMonth, &nDay, &nHr, &nMin, &nSec);
		
		for(nLoop = 0; nLoop< 10; nLoop ++)
		{
			nSigma10 += ombro_min_per_tenmin[nLoop];
		}
		if(ombro_ten_min_max < nSigma10)
		{
			ombro_ten_min_max = nSigma10;
			ombro_ten_min_max_hr = CLK_HOUR;
			ombro_ten_min_max_min = CLK_MIN;
		}
		ombro_ten = nSigma10;
		//计算小时雨量
		
		for(nLoop = 0; nLoop < 60; nLoop ++)
		{
			nSigma60 += ombro_min_per_hour[nLoop];	
		}
		
		if(ombro_hour_max < nSigma60)
		{
			ombro_hour_max = nSigma60;
			ombro_hour_max_hr = CLK_HOUR;
			ombro_hour_max_min = CLK_MIN;			
		}
		ombro_hour = nSigma60;
		
		warningstate = alarm_mode();
		if ((warningstate > alarm_status)||
		   ((warningstate < alarm_status)&&(alarm_last_time = TRUE)))
		{
		    if (warningstate > 0)
		    {
		        bAlarmData = TRUE;
			    uploadAlarmData();
			    delay_ms(1000);
			    uploadAlarmData();
			    delay_ms(1000);
			    sclk=1;
			    rain_alarm=1;
			    attention_cmgs(warningstate);
			    delay_ms(1000);
			    print_alarm(warningstate);
			    alarm_last_time = FALSE;
			    sclk=0;
			    rain_alarm=0;
			}
			alarm_status = warningstate;
		}
		else
		{
			uploadRealtimeData();
			rain_alarm=0;
		}
		
		ombro_min_event = FALSE;
	}

//	if(ombro_sending == TRUE)
//	{
//		//雨量数据回传计算
//	}
}


void ombro_readstore()
{
    
}

void ombro_writestore()
{

}

/*void ombro_shot_time(UINT nYear, UINT nMonth, UINT nDay, UINT nHr, UINT nMin)
{
	ombro_shot_year = nYear;
	ombro_shot_month = nMonth;
	ombro_shot_day = nDay;
	ombro_shot_hour = nHr;
	ombro_shot_min = nMin;	
}*/

unsigned int ombro_getcount()
{
	return ombro_continue;
}