headset_charger.c

bluelab的一个很好的例程

/****************************************************************************
NAME    
    monitorCharge
    
DESCRIPTION
  	This function is called to monitor the fast charge algorithm
    
RETURNS
    TRUE if fast charge is complete, otherwise false
*/
static bool monitorCharge(power_type* power)
{
	bool fast_charge_complete = FALSE;
	
	CH_DEBUG(("CH: state=%d\n", power->charger.state));

	/* Look at current charging state */
	switch(power->charger.state)
	{
		case trickle_charge:
		case charge_error:
			/* Check if fast charge was stopped as an abornal battery condition was detected */
			if(power->charger.fast_charge_inhibit)
			{
				/* Check if battery is OK to continue fast charge */
				if(batteryGetCurrentVoltage(power) > (power->config.charger.min_voltage + VBAT_OFFSET))
				{
					if(batteryGetCurrentVoltage(power) < (power->config.charger.max_voltage - VBAT_OFFSET))
					{
						if(batteryGetCurrentTemperature(power) > (power->config.charger.min_temp + TBAT_OFFSET))
						{
							if(batteryGetCurrentTemperature(power) < (power->config.charger.max_temp - TBAT_OFFSET))
							{
								/* Cancel current LED indication */
								CH_DEBUG(("CH: Cancel LED Ind 1\n"));
								MessageSend(getAppTask(), EventCancelLedIndication, 0);	
				
								/* Start fast charging */
								startFastCharge(power);
							}
						}
					}
				}		
			}
			else
			{
				/* Battery voltage out of range (potential divider is open circuit) */
				if(batteryGetCurrentVoltage(power) < (VBAT_ABNORMAL - VBAT_OFFSET))
				{
					/* Cancel current LED indication */
					CH_DEBUG(("CH: Cancel LED Ind 2\n"));
					MessageSend(getAppTask(), EventCancelLedIndication, 0);	

					/* Start fast charging */
					startFastCharge(power);
				}
			}
			break;
			
		case fast_charge:
			/* Check for abnormal battery condition */
			if((batteryGetCurrentVoltage(power) < power->config.charger.min_voltage) ||
			   	(batteryGetCurrentVoltage(power) > power->config.charger.max_voltage) ||
			   	(batteryGetCurrentTemperature(power) < power->config.charger.min_temp) ||
			   	(batteryGetCurrentTemperature(power) > power->config.charger.max_temp))
			{
				/* End fast charge */
				endFastCharge(power);
				CH_DEBUG(("CH: FC End Abnormal\n"));

				/* Check for abnormal condition */
				if(batteryGetCurrentVoltage(power) > VBAT_ABNORMAL)
				{
					CH_DEBUG(("CH: VBAT_ABNORMAL\n"));
					resetFastCharge(power);
				}

				/* Enter error state */
				chargerError(power);
			}
			else
			{
				/* Battery voltage and temerature are within limits */
				
				/* Check to ensure we have been fast charging for the minimum time */
				if(power->charger.fast_charge_timer > power->config.charger.dv_inhibit_time)
				{
					/* -dV inhibit timer has expired */
					if((batteryGetCurrentVoltage(power) > getVbatThreshold(power)))
					{
						/* Perform -dV detection */
						if(dvDetect(power))
						{
							/* Fast charge complete */
							endFastCharge(power);
							fast_charge_complete = TRUE;
							CH_DEBUG(("CH: FC End -dV\n"));
						}
						else if(dtDetect(power))
						{
							/* Fast charge complete */
							endFastCharge(power);
							fast_charge_complete = TRUE;
							CH_DEBUG(("CH: FC End dT\n"));
						}
					}
				
					/* Check if fast charge timer has expired */
					if(fastChargeTimeExpired(power))
					{
						/* Fast charge complete */
						endFastCharge(power);
						fast_charge_complete = TRUE;
						CH_DEBUG(("CH: FC End T\n"));
					}	
				}
				else
				{
					/* Record battery temperature during inhibit period */
					updateBatteryTemperature(power);
				}
				
				/* Update fast charger timer */
				if(!power->charger.fast_charge_inhibit)
					power->charger.fast_charge_timer += power->config.charger.update_period;
				
				CH_DEBUG(("CH T=%d period=%d\n", power->charger.fast_charge_timer, power->config.charger.update_period));
			}
			break;
			
		case disconnected:
			fast_charge_complete = TRUE;
			break;
	}
	
	return fast_charge_complete;
}


/****************************************************************************
NAME    
    trickleCharge
    
DESCRIPTION
  	This function is called to start the trickle charge algorithm
    
RETURNS
    void
*/
static void trickleCharge(power_type* power)
{
	CH_DEBUG(("CH: TC Start\n"));
	
	SET_CHARGER_STATE(trickle_charge);
	MessageSend(getAppTask(), EventTrickleCharge, 0);
}


/****************************************************************************
NAME    
    chargerError
    
DESCRIPTION
  	This function is called if a charger error is detected
    
RETURNS
    void
*/
static void chargerError(power_type* power)
{
	CH_DEBUG(("CH: Error\n"));

	SET_CHARGER_STATE(charge_error);

	/* Cancel current LED indication */
	MessageSend(getAppTask(), EventCancelLedIndication, 0);	

	/* Indicate charger error */
	MessageSend(getAppTask(), EventChargeError, 0);
}


/****************************************************************************
NAME    
    chargerConnected
    
DESCRIPTION
  	This function is called by the Power Manager when the charger has been 
	plugged into the headset
    
RETURNS
    void
*/
void chargerConnected(power_type* power)
{
	CH_DEBUG(("CH: Connected\n"));
	
	switch(power->charger.state)
	{
	case disconnected:
		
		if(power->config.chemistry == nimh)
		{
			/* Handle NiMH battery charging under software control */

			/* Reset fast charge control */
			resetFastCharge(power);
		
			/* Start fast charging the battery */
			startFastCharge(power);

			/* Start monitoring battery */
			MessageSend(&power->charger.task, CHARGER_UPDATE, 0);
		}
		else
		{
			/* LiON Handled automatically */
			
			/* Fast charge state */
			SET_CHARGER_STATE(fast_charge);
			
			/* Enable fast charge PIO line */
			setChargeEnable(TRUE);
		}
		break;

		/* Disable deep sleep during charging */
		VmDeepSleepEnable(FALSE);
		
	case trickle_charge:
	case fast_charge:
	case charge_error:
		break;
	}	
}


/****************************************************************************
NAME    
    chargerDisconnected
    
DESCRIPTION
  	This function is called by the Power Manager when the charger has been 
	unplugged from the headset
    
RETURNS
    void
*/
void chargerDisconnected(power_type* power)
{
	CH_DEBUG(("CH: Disconnected\n"));
	
	switch(power->charger.state)
	{
	case trickle_charge:
	case fast_charge:
	case charge_error:
		/* The charger has just been removed, move to disconnected state */
		SET_CHARGER_STATE(disconnected);

		/* Cancel current LED indication */
		CH_DEBUG(("CH: Cancel LED Ind 3\n"));
		MessageSend(getAppTask(), EventCancelLedIndication, 0);	
				
		/* Disable fast charge enable PIO line */
		setChargeEnable(FALSE);

		/* Enable deep sleep */
		VmDeepSleepEnable(TRUE);

		break;
		
	case disconnected:
		break;
	}
}


/****************************************************************************
NAME    
    charger_handler
    
DESCRIPTION
  	Messages for the charger control task arrive here
    
RETURNS
    void
*/
void charger_handler(Task task, MessageId id, Message message)
{
	/* Get Power configuration data */
	power_type* power = ((hsTaskData *)getAppTask())->power;
	
	/* Process message */
	switch(id)
	{	
		case CHARGER_UPDATE:
			CH_DEBUG(("CH: update\n"));
			if(!monitorCharge(power))
				MessageSendLater(&power->charger.task, CHARGER_UPDATE, 0, D_SEC(power->config.charger.update_period * 60));
			break;
			
		default:
			break;
	}
}

/****************************************************************************
NAME    
    chargerInit
    
DESCRIPTION
  	This function is called by the Power Manager to initialise the battery 
    charger subsystem
    
RETURNS
    void
*/
void chargerInit(power_type* power)
{
	CH_DEBUG(("CH: Init\n"));
	
	/* Setup charger message task handler */
	power->charger.task.handler = charger_handler;
	
	/* Assume charger disconnected at boot time */
	power->charger.state = disconnected;
}