ombro.c

使用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 "ombrodb.h"

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

volatile unsigned char ombro_a_state = FALSE;
volatile unsigned char ombro_b_state = FALSE;
volatile UINT ombro_ab_check = 0;

//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;
bit all_sending = FALSE;
bit ombro_working_state = FALSE;
bit day_reset = FALSE;
//bit ombro_save_value = FALSE;

unsigned char  warningvalueb = 0;
UINT ombro_nlasting = 0;
UINT free_time = 0;

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;

#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 UINT IGrid;
eeprom float fGrid;
#pragma warn+


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;
	while(1)
	{
        wdr();
		ombro_get_status();
		timer_delay(200);
		if(ombro_working_state == FALSE)
		{
			if((bDisplayed == 0) && (day_reset == FALSE))
			{
				bDisplayed = 1;
			}
		}
		else
		{
			return;
		}
		timer_delay(2000);
	}
}

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

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

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

void ombro_init()
{

	DDRC.0 = 0;
	DDRD.7 = 0;
	ombro_nlasting = 0;
	
	fGrid = 0.2;
	IGrid = (unsigned int)(fGrid*10.0); 
	
	my_ombset.nBeginTime = 6;
		
    if ((my_ombset.fPatrol10m > 999.9) || (my_ombset.fPatrol10m < 2.0))
        my_ombset.fPatrol10m = 10.0;
    if ((my_ombset.fPatrol1h > 999.9) || (my_ombset.fPatrol1h < 2.0))
        my_ombset.fPatrol1h = 20.0;
    if ((my_ombset.fPatrol1d > 999.9) || (my_ombset.fPatrol1d < 2.0))
        my_ombset.fPatrol1d = 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.0;
    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();
}

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;

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


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

//	if((ombro_min_event == TRUE)&&(ombro_sending == TRUE))
	if(ombro_min_event == 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;
		        
		ftemp = (float)(nSigma10)*fGrid;
		if(ftemp >= my_ombset.fPatrol10m)
		{
			warningstate |= WARN_PATROL_10;
			warningvalue = 0x00;
			if(tempwarn < 1)
			{
			    tempwarn = 1;
			}
		}
		if(ftemp >= my_ombset.fRisk10m)
		{
			warningstate |= WARN_RISK_10;
			warningvalue = 0x04;
			if(tempwarn < 2)
			{
			    tempwarn = 2;
			}
		}
		
		ftemp = (float)(nSigma60)*fGrid;
		if(ftemp >= my_ombset.fPatrol1h)
		{
			warningstate |= WARN_PATROL_60;
			warningvalue = 0x01;
			if(tempwarn < 3)
			{
			    tempwarn = 3;
			}
		}
		
		if(ftemp >= my_ombset.fRisk1h)
		{
			warningstate |= WARN_RISK_60;
			warningvalue = 0x05;
			if(tempwarn < 4)
			{
			    tempwarn = 4;
			}
		}
		ftemp = (float)(ombro_day)*fGrid;
		if(ftemp >= my_ombset.fPatrol1d)
		{
			warningstate |= WARN_PATROL_DAY;
			warningvalue = 0x02;
			if(tempwarn < 5)
			{
			    tempwarn = 5;
			}
		}

		if(ftemp >= my_ombset.fRisk1d)
		{
			warningstate |= WARN_RISK_DAY;
			warningvalue = 0x06;
			if(tempwarn < 6)
			{
			    tempwarn = 6;
			}
		}
		ftemp = (float)(ombro_continue)*fGrid;
		if(ftemp >= my_ombset.fPatrolCon)
		{
			warningstate |= WARN_PATROL_CON;
			warningvalue = 0x03;
			if(tempwarn < 7)
			{
			    tempwarn = 7;
			}
		}

		if(ftemp >= my_ombset.fRiskCon)
		{
			warningstate |= WARN_RISK_CON;
			warningvalue = 0x07;
			if(tempwarn < 8)
			{
			    tempwarn = 8;
			}
		}

		if (warningstate)
		{
			uploadAlarmData(warningstate);

			if(tempwarn > warningvalueb)
			{
			    warningvalueb = tempwarn;
                rtc_set_flag = TRUE;
//				rain_alarm=1;
                PORTG |= 0x08;
                if (warningvalue > 0x05)
                {
				    attention_cmgs(warningvalue,3);
				    timer_delay(1000);
				    attention_cmgs(warningvalue,2);
				    timer_delay(1000);
                }
                else
                if (warningvalue > 0x02)
                {
				    attention_cmgs(warningvalue,2);
				    timer_delay(1000);
                }
				attention_cmgs(warningvalue,1);
				timer_delay(1000);
	            rtc_set_flag = FALSE;
//				rain_alarm=0;
                PORTG &= 0x17;
			}
		}
        else
        {
		    if(all_sending == TRUE)
		    {
			    uploadRealtimeData();
//			    rain_alarm=0;
                PORTG &= 0x17;
			    if (warningvalueb != 0)
			        warningvalueb = 0;
                all_sending = FALSE;
		    }
        }
		ombro_min_event = FALSE;
	}
}


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;
}