Calibrate.c

// AkvarieComputer - calibrate.c
 
#include <pic18.h>
#include <stdio.h>
#include <string.h>
#include "lcd.h"
#include "delay.h"
#include "akvarie.h"
#include "menu.h"
#include "xeeprom.h"
 
int		Cali_Int;
 
// ---------------------------------------------------------------
// Calibration Steps
// ---------------------------------------------------------------
const char Cali_ph[] = "Buffer <%d> pH ";
const char *Cali_ph_list[] = {Cali_ph};
const void *Cali_ph_Values[] = {&Cali_Int};
const char Cali_ph_Types[] = {TYPE_INTEGER};
 
const char Cali_mv[] = "Buffer <%d> mV ";
const char *Cali_mv_list[] = {Cali_mv};
const void *Cali_mv_Values[] = {&Cali_Int};
const char Cali_mv_Types[] = {TYPE_INTEGER};
 
#define CALIBRATE_COUNT 200
 
float Calibrate_probe(char Probe)
{
	float Sum = 0;
	int i;
	char Text[30];
	for (i = 0; i < CALIBRATE_COUNT; i++)
	{
		float Value = ReadAD(Probe);
		Sum = Sum + Value;
		sprintf(Text,"Wait %.2f %.2f  ",Sum/(i+1),Value);
		DelayMs(100);
		lcdtext(1,4,Text);
	}
	Sum = 0;
	for (i = 0; i < CALIBRATE_COUNT; i++)
	{
		float Value = ReadAD(Probe);
		Sum = Sum + Value;
		DelayMs(100);
		sprintf(Text,"Work %.2f %.2f  ",Sum/(i+1),Value);
		lcdtext(1,4,Text);
 
	}
	return Sum / CALIBRATE_COUNT;
}
 
void Calibrate_Calculate(char Probe)
{
	char Text[30];
	AI.Probe_A[Probe] = (AI.Probe_Cali[Probe][0] - AI.Probe_Cali[Probe][1]) / 
	                    (AI.Probe_Value[Probe][0] - AI.Probe_Value[Probe][1]);
	AI.Probe_B[Probe] = AI.Probe_Cali[Probe][0] - 
	                    (AI.Probe_Value[Probe][0] * AI.Probe_A[Probe]);
 
	sprintf(Text,"A=%.2f B=%.2f  ",AI.Probe_A[Probe],AI.Probe_B[Probe]);
	lcdtext(1,2,Text);
	sprintf(Text,"A/D Value 1 =%.2f   ",AI.Probe_Value[Probe][0]);
	lcdtext(1,3,Text);
	sprintf(Text,"A/D Value 2 =%.2f   ",AI.Probe_Value[Probe][1]);
	lcdtext(1,4,Text);
 
	while(!KeyEnter);
	while(KeyEnter);
}
 
 
const char Cali_Nos[] = {2,2,2,1};
const char *Cali_Texts[] = {&Cali_ph_list,Cali_mv_list,NULL,NULL};
const char *Cali_Values[] = {&Cali_ph_Values,Cali_mv_Values,NULL,NULL};
const char *Cali_Types[] = {&Cali_ph_Types,&Cali_mv_Types,NULL,NULL};
const int Cali_Lower[4] = {0,-1000,0,0};
const int Cali_Upper[4] = {14,1000,0,0};
 
char GetProbeType(char Probe)
 {
	if (strcmp(AI.ProbeSetup[Probe],"Off") == 0)
		return PROBE_OFF;
	if (strcmp(AI.ProbeSetup[Probe],"pH") == 0)
		return PROBE_PH;
	if (strcmp(AI.ProbeSetup[Probe],"mV") == 0)
		return PROBE_MV;
	if (strcmp(AI.ProbeSetup[Probe],"mS") == 0)
		return PROBE_MS;
	if (strcmp(AI.ProbeSetup[Probe],"C") == 0)
		return PROBE_TEMP;
  return PROBE_OFF;
}
 
char Calibrate(char Probe)
{
	char Text[30];
	char Type = GetProbeType(Probe);
	char No;
	char i;
 
	lcd_clear();
	if (Type == PROBE_OFF)
	{
		ErrorMsg("No probe on port!",Probe);
		return 0;
	}
 
	for (No = 0; No < Cali_Nos[Type]; No++)
	{
		switch(Type)
		{
			case PROBE_MV:
				if (No == 0)
					Cali_Int = 0;
				else
					Cali_Int = 230;
				break;
			case PROBE_PH:
				if (No == 0)
				  Cali_Int = 4;
				else
				  Cali_Int = 9;
				break;
		}
		sprintf(Text,"%s Calibration (%d):",AI.ProbeSetup[Probe],No + 1);
		lcdtext(1,1,Text);
		if (EditOption(Cali_Texts[Type],Cali_Values[Type],Cali_Types[Type],2,0))
		{
			if (Cali_Int >= Cali_Lower[Type] && Cali_Int <= Cali_Upper[Type])
			{
				float x = Cali_Int;
				AI.Probe_Cali[Probe][No] = x;
 
				// Perform calibration
 
				sprintf(Text,"Place probe in %.0f   ",AI.Probe_Cali[Probe][No]);
				lcdtext(1,2,Text);
				lcdtext(1,3,"solution and press  ");
				lcdtext(1,4,"Enter(Left to abort)");
				while(!KeyEnter && !KeyLeft);
				if (KeyLeft)
				{
					while(KeyLeft);
				  return 0;
				  }
				else
				  AI.Probe_Value[Probe][No] = Calibrate_probe(Probe);
				for (i = 2; i <=4; i++)
  				lcdtext(1,i,"                   ");
			}
			else
			{
				ErrorMsg("Out of range!",0);
				return 0;
			}
		}
		else
			return 0;
	}
	Calibrate_Calculate(Probe);
	return 1;
}