hid_keyboard_button.c

CSR 的键盘模块

/*
    This file was autogenerated by buttonparse
*/

#include "hid_keyboard_button.h"

#include <pio.h>
#include <app/message/system_message.h>
#include <panic.h>
#include <ps.h>
#include <stdlib.h>

enum {internal_pio_timer_message = 0, double_pio_press_timer, pio_external_changed, internal_ext_timer_message, double_ext_press_timer};

static InternalState external_encode(uint16 pressed)
{
	switch(pressed)
	{
		case (1UL<<0) : return sCONNECT;
		default : return Unknown;
	}
}

typedef struct
{
	unsigned release:1;
	unsigned double_tap:1;
	unsigned timeout:15;
	unsigned external:1;
	MessageId id;
} EnterMessage;

/* Messages sent on state entry */
static const struct
{
	uint16 count; const EnterMessage *send;
} enter_messages[] = {
	{ 0, 0 }
};

static void send_ext_enter_messages(PioState *pioState, InternalState state)
{
	uint16 init_count = enter_messages[state].count;
	uint16 count = init_count;
	const EnterMessage *p = enter_messages[state].send;
	while(count--)
	{
		if (!p->external)
		{
			p++;
			continue;
		}
		if (p->double_tap)
		{
			if (pioState->ext_states.double_press == state)
			{
				if (MessageCancelAll(&pioState->task, double_ext_press_timer))
				{
					pioState->ext_states.store_held = Unknown;
					MessageSend(pioState->client, p->id, 0);
				}
				else
					MessageSendLater(&pioState->task, double_ext_press_timer, 0, p->timeout);
			}
			else
			{
				pioState->ext_states.double_press = state;
				(void) MessageCancelAll(&pioState->task, double_ext_press_timer);
				MessageSendLater(&pioState->task, double_ext_press_timer, 0, p->timeout);
			}
		}
		else
		if (!p->release)
			MessageSend(pioState->client, p->id, 0);
		else
		{
			pioState->ext_states.store_held = state;
			pioState->ext_states.store_count = init_count - (count + 1);
		}
		p++;
	}
}

/* Timed messages to be sent to the client */
typedef struct
{
	unsigned repeat:1;
	unsigned msec:15; /* Limit to 32767ms. Sounds reasonable. */
	unsigned msecRepeat:15;
	unsigned release:1;
	unsigned external:1;
	MessageId id;
} TimedMessage;

static const TimedMessage timed_messages_sCONNECT[] =
{
	{ 0, 5000, 0, 0, 1, APP_INTERNAL_UNPLUG_IND }
};

static const struct
{
	uint16 count;
	const TimedMessage *send;
} timed_messages[] =
{
	{ 1, timed_messages_sCONNECT }
};

static void send_ext_timed_message(PioState *pioState, const TimedMessage *p, int hold_repeat)
{
	const TimedMessage **m = (const TimedMessage **) PanicNull(malloc(sizeof(const TimedMessage *)));
	*m = p;
	if (hold_repeat)
		MessageSendLater(&pioState->task, internal_ext_timer_message, m, p->msecRepeat);
	else
		MessageSendLater(&pioState->task, internal_ext_timer_message, m, p->msec);
}

static void send_ext_timed_messages(PioState *pioState, InternalState state)
{
	uint16 count = timed_messages[state].count;
	const TimedMessage *p = timed_messages[state].send;
	while(count--)
	{
		if (p->external)
			send_ext_timed_message(pioState, p, 0);
		p++;
	}
}

static void externalChanged(Task task, PioState *pioState, uint16 external_bits)
{
	InternalState next;
	uint16 raw_bits = 0;
	uint16 mState = external_bits;

	mState &= ~ 0;
	raw_bits = (external_bits & 0);
	next = external_encode(mState);

	if ((pioState->ext_states.store_held != Unknown) && (next != pioState->ext_states.store_held))
	{
		uint16 changed = mState ^ pioState->ext_states.store_bits;
		uint16 released = changed & pioState->ext_states.store_bits;
		if (released == pioState->ext_states.store_bits)
		{
			const EnterMessage *p = enter_messages[pioState->ext_states.store_held].send;
			MessageSend(pioState->client, p[pioState->ext_states.store_count].id, 0);
		}
		pioState->ext_states.store_held = Unknown;
	}

	if (pioState->ext_states.timed_id)
	{
		MessageSend(pioState->client, pioState->ext_states.timed_id, 0);
		pioState->ext_states.timed_id = 0;
	}

	(void) MessageCancelAll(task, internal_ext_timer_message);
	if(next != Unknown)
	{
		send_ext_enter_messages(pioState, next);
		send_ext_timed_messages(pioState, next);
	}
	pioState->ext_states.store_bits = mState;
}

typedef struct { uint16 xor; uint16 and;} PioExternalMessage;

static void pioHandler(Task task, MessageId id, Message data)
{
	PioState *pioState = (PioState *) task;
	switch(id)
	{
	case internal_ext_timer_message:
	{
		const TimedMessage **m = (const TimedMessage **) data;
		const TimedMessage *p = *m;
		if (p->release)
			pioState->ext_states.timed_id = p->id;
		else
		{
			MessageSend(pioState->client, p->id, 0);
			pioState->ext_states.timed_id = 0;
		}
		pioState->ext_states.store_held = Unknown;
		if(p->repeat)
		{
			if(p->msecRepeat)
				send_ext_timed_message(pioState, p, 1);
			else
				send_ext_timed_message(pioState, p, 0);
		}
	}
	break;
	case MESSAGE_PIO_CHANGED:
	{
	}
	break;
	case pio_external_changed:
	{
		const PioExternalMessage *m = (const PioExternalMessage *)data;
		externalChanged(task, pioState, m->xor ^ (pioState->ext_states.store_bits & ~m->and));
	}
	break;
	case double_pio_press_timer:
	case double_ext_press_timer:
	default:
		break;
	}
}

void pioExternal(PioState *pioState, uint16 external_and, uint16 external_xor)
{
	PioExternalMessage *m = malloc(sizeof(PioExternalMessage));
	m->xor = external_xor;
	m->and = external_and;
	MessageSend(&pioState->task, pio_external_changed, m);
}

void pioInit(PioState *pioState, Task client)
{
	MessagePioChanged *m = malloc(sizeof(MessagePioChanged));
	uint16 pio_get = PioGet();
	pioState->task.handler = pioHandler;
	pioState->client       = client;


	pioState->ext_states.store_held = Unknown;
	pioState->ext_states.double_press = Unknown;
	pioState->ext_states.store_count = 0;
	pioState->ext_states.store_bits = 0;
	pioState->ext_states.timed_id = 0;
	pioState->ext_states.pio_raw_bits = 0;

	(void) MessagePioTask(&pioState->task);
	m->state = pio_get & (0);
	m->time  = 0;
	MessageSend(&pioState->task, MESSAGE_PIO_CHANGED, m);
}