void
parse_message(unsigned char type, char *buf, int size)
{
char *msgt;
int i;
struct iocblk *iocp;
struct buffer *bp = Pty.inbuff;
if (size != 0) {
switch (Pty.state) {
case PTY_CLOSED:
case PTY_OPERRONLY:
SET_EVENT(EV_UP, EV_UPOPEN, 0, 0);
break;
}
}
if (type == TIOCPKT_DATA) {
# ifdef TSR_MEASURE
devreads++;
devrbytes += size;
# endif
if (size == 0) {
SET_EVENT(EV_UP, EV_UPCLOSE, 0, 0);
}
else {
COPY_TO_BUFFER(bp, buf, size);
SET_EVENT(EV_UP, EV_UPDATA, 0, 0);
}
}
else {
parse_packet((int) type);
}
}
int
comport_command(int command, int arg)
{
int size;
int ret;
unsigned char *obp;
if (Nvt.comport->support == FALSE) {
CLR_CMD_ACTIVE(command); /* Synchronous operation */
SET_EVENT(EV_RN, EV_RNCMDOK, 0, 0);
return (0);
}
obp = &Comobuf[0];
*obp++ = IAC;
*obp++ = SB;
*obp++ = NVT_COM_PORT_OPTION;
*obp++ = (unsigned char) command;
switch (command) {
case USR_COM_SET_BAUDRATE:
SET_VALUE_4(obp, arg);
obp += 4;
break;
default:
SET_VALUE_1(obp, arg);
obp += 1;
break;
}
*obp++ = IAC;
*obp++ = SE;
size = (int) (obp - &Comobuf[0]);
obp = &Comobuf[0];
if (Debug > 2) {
sysmessage(MSG_DEBUG,
"Sock_write, %d bytes: %02X %02X %02X %02X %02X %02X %02X %02X\n",
size, Comobuf[0], Comobuf[1], Comobuf[2], Comobuf[3],
Comobuf[4], Comobuf[5], Comobuf[6], Comobuf[7]);
}
while (size) {
if ((ret = sock_write(obp, size)) == -1) {
SET_EVENT(EV_RN, EV_RNHANG, 0, 0);
return (-1);
}
else if (ret != size) {
sysmessage(MSG_NOTICE,
"Partial write in send_comport: %d/%d\n", ret, size);
sysdelay(ROOM_DELAY); /* Wait for room */
}
size -= ret;
obp += ret;
}
return (0);
}
void
parse_message(unsigned char type, char *buf, int size)
{
char *msgt;
int i;
struct iocblk *iocp;
struct buffer *bp = Pty.inbuff;
print_msg(type, (unsigned char *) buf, size);
if (size > 0) {
switch (Pty.state) {
case PTY_CLOSED:
case PTY_OPERRONLY:
SET_EVENT(EV_UP, EV_UPOPEN, 0, 0);
break;
}
}
else if (size == -1) {
sysmessage(MSG_WARNING, "PARSE: Message data size == -1 \n");
return;
}
switch (type) {
case M_DATA:
# ifdef TSR_MEASURE
devreads++;
devrbytes += size;
# endif
if (size == 0) {
SET_EVENT(EV_UP, EV_UPCLOSE, 0, 0);
}
else {
COPY_TO_BUFFER(bp, buf, size);
SET_EVENT(EV_UP, EV_UPDATA, 0, 0);
}
break;
case M_IOCTL:
iocp = (struct iocblk *) &buf[0];
parse_ioctl(iocp->ioc_cmd, (void *) &buf[sizeof(struct iocblk)]);
break;
case M_FLUSH:
parse_msgflush((int) buf[0]);
break;
default:
sysmessage(MSG_DEBUG, "Unsupported stream message: %d\n", type);
print_msg(type, (unsigned char *) buf, size);
break;
}
}
static void acc_cb(int x, int y, int z, int tap) {
vmVariables.acc[0] = x;
vmVariables.acc[1] = y;
vmVariables.acc[2] = z;
if(tap) {
SET_EVENT(EVENT_TAP);
vmVariables.acc_tap = tap; // set only variable.
}
SET_EVENT(EVENT_ACC);
}
void
send_option(int type, int opt)
{
int ret;
int size;
unsigned char *obp;
obp = &Comobuf[0];
*obp++ = IAC;
*obp++ = type;
*obp++ = opt;
size = 3;
obp = &Comobuf[0];
if (Debug > 2) {
sysmessage(MSG_DEBUG, "Sock_write, 3 bytes: %02X %02X %02X\n",
Comobuf[0], Comobuf[1], Comobuf[2]);
}
while (size) {
if ((ret = sock_write(obp, size)) == -1) {
SET_EVENT(EV_RN, EV_RNHANG, 0, 0);
break;
}
else if (ret != size) {
sysmessage(MSG_NOTICE,
"Partial write in send_option: %d/%d\n", ret, size);
sysdelay(ROOM_DELAY); /* Wait for room */
}
size -= ret;
obp += ret;
}
}
void
parse_termios(int mode, struct termios *tp)
{
struct iocontrol *iocp = &Pty.iocontrol;
struct portconfig *pcp = &iocp->io_portconfig;
switch (mode) {
case TCSETS:
iocp->io_oper = OP_SETNOW;
break;
case TCSETSW:
iocp->io_oper = OP_SETWAIT;
break;
case TCSETSF:
iocp->io_oper = OP_SETFLUSH;
break;
}
Pty.portmodes = termios_to_portmodes(tp);
memset((void *) pcp, 0, sizeof(struct portconfig));
termios_to_portconfig(tp, pcp);
SET_EVENT(EV_UP, EV_UPCONTROL, 0, 0);
}
static void ntc_callback(int temp) {
if(!ntc_calib) {
vmVariables.ntc = temp;
SET_EVENT(EVENT_TEMPERATURE);
}
rc5_enable();
}
void EVNT_SetEvent(EVNT_Handle event) {
CS1_CriticalVariable()
CS1_EnterCritical();
SET_EVENT(event);
CS1_ExitCritical();
}
// This function must update the accelerometer variables
void accelerometer_cb(void)
{
static float accf[3];
demo_acc_get_acc(accf);
vmVariables.acc[0] = (sint16) accf[0];
vmVariables.acc[1] = (sint16) accf[1];
vmVariables.acc[2] = (sint16) accf[2];
SET_EVENT(EVENT_ACC);
}
void
parse_break(int *interval)
{
struct iocontrol *iocp = &Pty.iocontrol;
iocp->io_oper = OP_SENDBREAK;
iocp->io_arg = *interval;
SET_EVENT(EV_UP, EV_UPCONTROL, 0, 0);
}
void* thr1_3_job ()
{
RETURN_CODE_TYPE ret;
while (1)
{
printf("Partition n. 1 - Thread n.3\n");
/***************************************************************/
/* Message processing code should be placed here */
/***************************************************************/
printf(" 3: -- do something\n");
printf(" 3: Setting an event UP\n\n");
SET_EVENT (pok_arinc653_events_ids[0], &(ret));
printf(" 3: Event SET -- Resume sporadic\n\n");
RESUME (arinc_threads[4], &(ret));
PERIODIC_WAIT (&(ret));
}
}
void test_sporadic_refined_model__the_proc_the_sender_entrypoint_impl(
BUFFER_ID_TYPE * cnx_p_out,
EVENT_ID_TYPE * cnx_p_out_entrypoint_barrier)
{
RETURN_CODE_TYPE test_sporadic_refined_model__the_proc_the_sender_entrypoint_impl_the_proc_the_sender_runtime_call_ret;
common_pkg__Integer test_sporadic_refined_model__the_proc_the_sender_entrypoint_impl_p_out_localVariable;
MESSAGE_SIZE_TYPE test_sporadic_refined_model__the_proc_the_sender_entrypoint_impl_p_out_Length = sizeof(common_pkg__Integer);
SYSTEM_TIME_TYPE test_sporadic_refined_model__the_proc_the_sender_entrypoint_impl_p_out_TimeOut = 0;
test_sporadic_refined_model__the_proc_the_sender_behaviorIdentifier_enum whichPortActivated = test_sporadic_refined_model__the_proc_the_sender_behaviorIdentifier_enum_default_behavior;
while(1)
{
switch(the_proc_the_sender_entrypoint_impl_current_state)
{
case test_sporadic_refined_model__the_proc_the_sender_entrypoint_impl_BA_entrypoint_init_state:
// Transition id: which_behavior_default_mode
if(1) // no execution condition
{
the_proc_the_sender_entrypoint_impl_current_state = test_sporadic_refined_model__the_proc_the_sender_entrypoint_impl_BA_entrypoint_exec_state;
whichPortActivated = test_sporadic_refined_model__the_proc_the_sender_behaviorIdentifier_enum_default_behavior;
break;
}
case test_sporadic_refined_model__the_proc_the_sender_entrypoint_impl_BA_entrypoint_wait_dispatch_state:
// Transition id: dispatch_transition
if(1) // no execution condition
{
the_proc_the_sender_entrypoint_impl_current_state = test_sporadic_refined_model__the_proc_the_sender_entrypoint_impl_BA_entrypoint_exec_state;
PERIODIC_WAIT (&test_sporadic_refined_model__the_proc_the_sender_entrypoint_impl_the_proc_the_sender_runtime_call_ret);
break;
}
case test_sporadic_refined_model__the_proc_the_sender_entrypoint_impl_BA_entrypoint_exec_state:
// Transition id: call -- Priority 0
if(whichPortActivated == test_sporadic_refined_model__the_proc_the_sender_behaviorIdentifier_enum_default_behavior)
{
the_proc_the_sender_entrypoint_impl_current_state = test_sporadic_refined_model__the_proc_the_sender_entrypoint_impl_BA_entrypoint_wait_dispatch_state;
send (&test_sporadic_refined_model__the_proc_the_sender_entrypoint_impl_p_out_localVariable);
SEND_BUFFER ((*cnx_p_out), &test_sporadic_refined_model__the_proc_the_sender_entrypoint_impl_p_out_localVariable, test_sporadic_refined_model__the_proc_the_sender_entrypoint_impl_p_out_Length, test_sporadic_refined_model__the_proc_the_sender_entrypoint_impl_p_out_TimeOut, &test_sporadic_refined_model__the_proc_the_sender_entrypoint_impl_the_proc_the_sender_runtime_call_ret);
SET_EVENT ((*cnx_p_out_entrypoint_barrier), &test_sporadic_refined_model__the_proc_the_sender_entrypoint_impl_the_proc_the_sender_runtime_call_ret);
break;
}
}
}
}
void
parse_iocflush(int *queues)
{
struct iocontrol *iocp = &Pty.iocontrol;
iocp->io_oper = OP_FLUSH;
switch (*queues) {
case TCIFLUSH:
iocp->io_arg = OPFLUSH_IN;
break;
case TCOFLUSH:
iocp->io_arg = OPFLUSH_OUT;
break;
case TCIOFLUSH:
iocp->io_arg = OPFLUSH_IO;
break;
}
SET_EVENT(EV_UP, EV_UPCONTROL, 0, 0);
}
void
parse_msgflush(int queues)
{
int mode;
switch (queues) {
case FLUSHR:
mode = OPFLUSH_IN;
break;
case FLUSHW:
mode = OPFLUSH_OUT;
break;
case FLUSHRW:
default:
mode = OPFLUSH_IO;
break;
}
SET_EVENT(EV_UP, EV_UPFLUSH, (void *) &mode, sizeof(int));
}
void
parse_packet(int type)
{
int flushbits;
int flushmode;
flushbits = type & (TIOCPKT_FLUSHREAD | TIOCPKT_FLUSHWRITE);
if (flushbits) {
switch (flushbits) {
case TIOCPKT_FLUSHREAD:
flushmode = OPFLUSH_IN;
break;
case TIOCPKT_FLUSHWRITE:
flushmode = OPFLUSH_OUT;
break;
default:
flushmode = OPFLUSH_IO;
break;
}
SET_EVENT(EV_UP, EV_UPFLUSH, (void *) &flushmode, sizeof(int));
}
}
static void timer_1khz(int timer_id) {
int i;
static unsigned char timer_20ms;
static unsigned char timer_62ms;
static unsigned char timer_10ms;
disk_timerproc();
log_poweron_tick();
// Poll the RF at 100Hz
if(++timer_10ms >= 10) {
timer_10ms = 0;
rf_poll();
}
// Generate behavior softirq at 50Hz
if(++timer_20ms >= 20) {
timer_20ms = 0;
behavior_trigger();
}
// Generate 16Hz, used by NTC & Acc.
if(++timer_62ms >= 62) {
timer_62ms = 0;
timer_slow();
}
for(i = 0; i < 2; i++) {
if(vmVariables.timers[i]) {
if(++timer[i] >= vmVariables.timers[i]) {
timer[i] = 0;
SET_EVENT(EVENT_TIMER0 + i);
}
}
}
}
static void rc5_callback(unsigned int address, unsigned int command) {
vmVariables.rc5_address = address;
vmVariables.rc5_command = command;
SET_EVENT(EVENT_RC5);
}
//--------------------------------------------------------------------------
void MainMenu::KeyEvent(int m_keyNum, int m_keyRepeat)
//--------------------------------------------------------------------------
{
if(m_keyRepeat)return ;//키릴리즈에 반응하지않는다.
int m_keyCode = m_keyNum;
if(m_keyCode == MH_KEY_4)m_keyCode=MH_KEY_LEFT; //값대치
if(m_keyCode == MH_KEY_6)m_keyCode=MH_KEY_RIGHT; //값대치
if(m_keyCode == MH_KEY_2)m_keyCode=MH_KEY_UP; //값대치
if(m_keyCode == MH_KEY_8)m_keyCode=MH_KEY_DOWN; //값대치
if(m_keyCode == MH_KEY_5)m_keyCode=MH_KEY_SELECT; //값대치
switch(MAINMENU_PAGE){
case PAGE_GO_QUEST:
{
switch(m_keyNum)
{
case MH_KEY_CLEAR: {MAINMENU_PAGE=PAGE_MAINMENU;Init_int(); break;}
case MH_KEY_UP: {if(GO_QUEST_NOW_Y>0)GO_QUEST_NOW_Y--; break;}
case MH_KEY_DOWN: {if(GO_QUEST_NOW_Y<1)GO_QUEST_NOW_Y++; break;}
case MH_KEY_SELECT:
{//바로가기
SAVELOAD_sex = GO_QUEST_SEX;
SAVELOAD_MainStyle = 1;
GET_MAINQUEST_IDX() = GO_QUEST_NUM;
int MapNum = 801;
switch(GO_QUEST_NUM){
case MAIN_QUEST_findOpen :MapNum = 202; break;
case MAIN_QUEST_openDoor :MapNum = 201; break;
case MAIN_QUEST_findKail :MapNum = 801; break;
case MAIN_QUEST_oldMedal :MapNum = 800; break;
case MAIN_QUEST_callKail :MapNum = 800; break;
case MAIN_QUEST_goKaien :MapNum = 800; break;
case MAIN_QUEST_goCitizen1 :MapNum = 805; break;
case MAIN_QUEST_goCitizen2 :MapNum = 803; break;
case MAIN_QUEST_goCitizenK :MapNum = 805; break;
case MAIN_QUEST_findCrystal :MapNum = 803; break;
case MAIN_QUEST_returnKaien :MapNum = 803; break;
case MAIN_QUEST_goScholar :MapNum = 805; break;
case MAIN_QUEST_findDiary :MapNum = 803; break;
case MAIN_QUEST_goSmallTown :MapNum = 203; break;
case MAIN_QUEST_findSiz1 :MapNum = 0; break;
case MAIN_QUEST_findSiz2 :MapNum = 0; break;
}
AppMain::ResvNextState(MS_GAME_FIELD, MapNum, 0);
}
break;
}
if(GO_QUEST_NOW_Y==0){
switch(m_keyNum)
{
case MH_KEY_LEFT : {if(GO_QUEST_NUM>0)GO_QUEST_NUM--; break;}
case MH_KEY_RIGHT: {GO_QUEST_NUM++; break;}
case MH_KEY_0: {GO_QUEST_NUM=GO_QUEST_NUM*10+0; break;}
case MH_KEY_1: {GO_QUEST_NUM=GO_QUEST_NUM*10+1; break;}
case MH_KEY_2: {GO_QUEST_NUM=GO_QUEST_NUM*10+2; break;}
case MH_KEY_3: {GO_QUEST_NUM=GO_QUEST_NUM*10+3; break;}
case MH_KEY_4: {GO_QUEST_NUM=GO_QUEST_NUM*10+4; break;}
case MH_KEY_5: {GO_QUEST_NUM=GO_QUEST_NUM*10+5; break;}
case MH_KEY_6: {GO_QUEST_NUM=GO_QUEST_NUM*10+6; break;}
case MH_KEY_7: {GO_QUEST_NUM=GO_QUEST_NUM*10+7; break;}
case MH_KEY_8: {GO_QUEST_NUM=GO_QUEST_NUM*10+8; break;}
case MH_KEY_9: {GO_QUEST_NUM=GO_QUEST_NUM*10+9; break;}
}
if(GO_QUEST_NUM>MAIN_QUEST_goSmallTown){GO_QUEST_NUM = MAIN_QUEST_goSmallTown;}
}else if(GO_QUEST_NOW_Y==1){
switch(m_keyNum)
{
case MH_KEY_LEFT :
case MH_KEY_RIGHT:
{GO_QUEST_SEX= (!GO_QUEST_SEX);break;}
}
}
break;
}
case PAGE_SOUNDONOFF:
switch(m_keyCode)
{
case MH_KEY_SELECT: {if(MAINMENU_ANI){MAINMENU_PAGE=PAGE_TITLE;Init_int();}break;}
case MH_KEY_LEFT: {SOUNDONOFF_SELECT = 0;SOUNDONOFF_TARGET_X=-115;break;}
case MH_KEY_RIGHT: {SOUNDONOFF_SELECT = 1;SOUNDONOFF_TARGET_X=+3;break;}
}
break;
case PAGE_TITLE:
{
if(m_keyCode){
MAINMENU_PAGE=PAGE_MAINMENU_INTRO;
_spr_MainMenu->SetBlendCustom(false,false,0,0);
MAINMENU_ANI = 0;
}
}
break;
case PAGE_MAINMENU:
//------------------------------------------------------------
{
if(MAINMENU_WING_STATE != 0){return;}
switch(m_keyCode)
{
case MH_KEY_SOFT1:
{//바로가기
SAVELOAD_sex = 1;
SAVELOAD_MainStyle = 0;
//GET_MAINQUEST_IDX() = MAIN_QUEST_openDoor;
AppMain::ResvNextState(MS_GAME_FIELD, 400, 0);
}
break;
case MH_KEY_SEND: {Init_int();MAINMENU_PAGE = PAGE_GO_QUEST;GO_QUEST_SEX=1;break;}
case MH_KEY_SELECT: {Init_int();MAINMENU_PAGE = PAGE_SELECT_SEX;SELECT_SEX_ACTION_START=true; _spr_title->workPal(true,0,-20);break;}
case MH_KEY_UP: {MAINMENU_WING_STATE=1;_ins_Wing->SetAnim(ANIM_MAINMENU_ROTATEUP); break;}
case MH_KEY_DOWN: {MAINMENU_WING_STATE=2;_ins_Wing->SetAnim(ANIM_MAINMENU_ROTATEDOWN); break;}
}
break;
}
case PAGE_SELECT_SEX:
{
if(MAINMENU_ANI<10)return;
switch(m_keyCode)
{
case MH_KEY_SELECT: {Init_int();MAINMENU_PAGE = PAGE_SELECT_STYLE;SELECT_STYLE_ACTION_START=true;SELECT_STYLE_SELECT=1;break;}
case MH_KEY_CLEAR: {Init_int();MAINMENU_PAGE = PAGE_MAINMENU; _spr_title->workPal(false,0,0);break;}
case MH_KEY_LEFT: {SELECT_SEX_SELECT=(SELECT_SEX_SELECT+1)%2;SELECT_SEX_ACTION_START=true;break;}
case MH_KEY_RIGHT: {SELECT_SEX_SELECT=(SELECT_SEX_SELECT+1)%2;SELECT_SEX_ACTION_START=true;break;}
}
}
break;
case PAGE_SELECT_STYLE:
{
if(MAINMENU_ANI<10)return;
switch(m_keyCode)
{
case MH_KEY_SELECT: {Init_int();MAINMENU_PAGE = PAGE_SELECT_SLOT;break;}
case MH_KEY_CLEAR: {Init_int();MAINMENU_PAGE = PAGE_SELECT_SEX;SELECT_SEX_SELECT=s_NC.Sex;break;}
case MH_KEY_LEFT: {SELECT_STYLE_ACTION_START=true;SELECT_STYLE_ACTION_RIGHT=false;break;}
case MH_KEY_RIGHT: {SELECT_STYLE_ACTION_START=true;SELECT_STYLE_ACTION_RIGHT=true;break;}
}
}
break;
case PAGE_SELECT_SLOT:
{
if(MAINMENU_ANI<10)return;
switch(m_keyCode)
{
case MH_KEY_SELECT:
{
SAVELOAD_Slot = s_NC.Slot;
SAVELOAD_sex = s_NC.Sex;
SAVELOAD_MainStyle = s_NC.Style;
Init_int();
SET_EVENT(1);
AppMain::ResvNextState(MS_GAME_FIELD, 100, 0);
break;
}
case MH_KEY_CLEAR: {Init_int();MAINMENU_PAGE = PAGE_SELECT_STYLE;break;}
case MH_KEY_UP: {SELECT_SLOT_SELECT=(SELECT_SLOT_SELECT+2)%3;break;}
case MH_KEY_DOWN: {SELECT_SLOT_SELECT=(SELECT_SLOT_SELECT+1)%3;break;}
}
}
break;
}
}
VOID
ndisMCoDpc(
IN PVOID SystemSpecific1,
IN PVOID InterruptContext,
IN PVOID SystemSpecific2,
IN PVOID SystemSpecific3
)
/*++
Routine Description:
Handles ALL Miniport interrupt DPCs, calling the appropriate Miniport DPC
depending on the context.
Arguments:
Interrupt - Interrupt object for the Mac.
Context - Really a pointer to the Interrupt.
Return Value:
None.
--*/
{
//
// Get adapter from context.
//
PNDIS_MINIPORT_INTERRUPT Interrupt = (PNDIS_MINIPORT_INTERRUPT)(InterruptContext);
PNDIS_MINIPORT_BLOCK Miniport = Interrupt->Miniport;
BOOLEAN LocalLock;
W_HANDLE_INTERRUPT_HANDLER MiniportDpc = Interrupt->MiniportDpc;
if (MINIPORT_TEST_FLAG(Miniport, fMINIPORT_HALTING))
{
Decrement((PLONG)&Interrupt->DpcCount, &Interrupt->DpcCountLock);
if (Interrupt->DpcCount==0)
{
SET_EVENT(&Interrupt->DpcsCompletedEvent);
}
}
else
{
//
// Call MiniportDpc
//
(*MiniportDpc)(Miniport->MiniportAdapterContext);
Decrement((PLONG)&Interrupt->DpcCount, &Interrupt->DpcCountLock);
if (!MINIPORT_TEST_FLAG(Miniport, fMINIPORT_HALTING))
{
//
// Enable interrupts
//
MINIPORT_SYNC_ENABLE_INTERRUPT(Miniport);
}
else
{
if (Interrupt->DpcCount == 0)
{
SET_EVENT(&Interrupt->DpcsCompletedEvent);
}
}
}
}
VOID
ndisMDpc(
IN PVOID SystemSpecific1,
IN PVOID InterruptContext,
IN PVOID SystemSpecific2,
IN PVOID SystemSpecific3
)
/*++
Routine Description:
Handles ALL Miniport interrupt DPCs, calling the appropriate Miniport DPC
depending on the context.
Arguments:
Interrupt - Interrupt object for the Mac.
Context - Really a pointer to the Interrupt.
Return Value:
None.
--*/
{
//
// Get adapter from context.
//
PNDIS_MINIPORT_INTERRUPT Interrupt = (PNDIS_MINIPORT_INTERRUPT)(InterruptContext);
PNDIS_MINIPORT_BLOCK Miniport = Interrupt->Miniport;
BOOLEAN LocalLock;
W_HANDLE_INTERRUPT_HANDLER MiniportDpc = Interrupt->MiniportDpc;
NDIS_ACQUIRE_MINIPORT_SPIN_LOCK_DPC(Miniport);
do
{
if (MINIPORT_TEST_FLAG(Miniport, fMINIPORT_HALTING))
{
Decrement((PLONG)&Interrupt->DpcCount, &Interrupt->DpcCountLock);
if (Interrupt->DpcCount==0)
{
SET_EVENT(&Interrupt->DpcsCompletedEvent);
}
break;
}
LOCK_MINIPORT(Miniport, LocalLock);
if (!LocalLock)
{
//
// A DPC is already running, queue this for later.
//
NDISM_QUEUE_WORK_ITEM(Miniport, NdisWorkItemDpc, &Miniport->Dpc, NULL);
Decrement((PLONG)&Interrupt->DpcCount, &Interrupt->DpcCountLock);
break;
}
//
// Call MiniportDpc
//
(*MiniportDpc)(Miniport->MiniportAdapterContext);
Decrement((PLONG)&Interrupt->DpcCount, &Interrupt->DpcCountLock);
if (!MINIPORT_TEST_FLAG(Miniport, fMINIPORT_HALTING))
{
//
// Enable interrupts
//
MINIPORT_SYNC_ENABLE_INTERRUPT(Miniport);
#if _SEND_PRIORITY
//
// If we are not reseting and not halting then give priority to sends
// at this point.
//
if (!MINIPORT_TEST_FLAG(Miniport, fMINIPORT_RESET_REQUESTED) &&
!MINIPORT_TEST_FLAG(Miniport, fMINIPORT_RESET_IN_PROGRESS) &&
!MINIPORT_TEST_FLAG(Miniport, fMINIPORT_HALTING))
{
if (MINIPORT_TEST_FLAG(Miniport, fMINIPORT_FULL_DUPLEX))
{
ndisMProcessDeferredFullDuplexPrioritySends(Miniport);
}
else
{
ndisMProcessDeferredPrioritySends(Miniport);
}
}
else
#endif
{
NDISM_PROCESS_DEFERRED(Miniport);
}
}
else
{
if (Interrupt->DpcCount == 0)
{
SET_EVENT(&Interrupt->DpcsCompletedEvent);
}
}
UNLOCK_MINIPORT(Miniport, LocalLock);
} while (FALSE);
NDIS_RELEASE_MINIPORT_SPIN_LOCK_DPC(Miniport);
}
void
handle_com_port_command(unsigned char *buf)
{
unsigned char cmd = *buf++;
int cmdarg;
int cmdidx;
int is_notify = 0;
int notify;
cmdidx = (int) cmd;
if (cmd >= RAS_COM_START && cmd <= RAS_COM_END) {
cmdidx -= RAS_COM_START;
}
print_command(cmdidx);
switch (cmd) {
case RAS_COM_SIGNATURE:
case RAS_COM_FLOWCONTROL_SUSPEND:
case RAS_COM_FLOWCONTROL_RESUME:
break;
case RAS_COM_SET_BAUDRATE:
Comport.portconfig.speed = GET_VALUE_4(buf);
print_speed(Comport.portconfig.speed);
break;
case RAS_COM_SET_DATASIZE:
Comport.portconfig.datasize = GET_VALUE_1(buf);
print_datasize(Comport.portconfig.datasize);
break;
case RAS_COM_SET_PARITY:
Comport.portconfig.parity = GET_VALUE_1(buf);
print_parity(Comport.portconfig.parity);
break;
case RAS_COM_SET_STOPSIZE:
Comport.portconfig.stopsize = GET_VALUE_1(buf);
print_stopsize(Comport.portconfig.stopsize);
break;
case RAS_COM_SET_CONTROL:
cmdarg = GET_VALUE_1(buf);
print_setcontrol(cmdarg);
switch (cmdarg) {
case COM_OFLOW_NONE:
case COM_OFLOW_SOFT:
case COM_OFLOW_HARD:
Comport.portconfig.flowc = cmdarg;
break;
default:
break;
}
break;
case RAS_COM_NOTIFY_LINESTATE:
is_notify = 1;
cmdarg = GET_VALUE_1(buf);
print_linestate(cmdarg);
Comport.portstate.linestate = cmdarg;
if (cmdarg & LINE_BREAK_ERROR) {
notify = NT_BREAK;
SET_EVENT(EV_RN, EV_RNNTFY, ¬ify, sizeof(int));
}
if (cmdarg & LINE_PARITY_ERROR) {
notify = NT_PARITY;
SET_EVENT(EV_RN, EV_RNNTFY, ¬ify, sizeof(int));
}
break;
case RAS_COM_SET_LINESTATE_MASK:
cmdarg = GET_VALUE_1(buf);
print_linestate(cmdarg);
break;
case RAS_COM_NOTIFY_MODEMSTATE:
is_notify = 1;
cmdarg = GET_VALUE_1(buf);
if ((cmdarg ^ Comport.portstate.modemstate) & MODEM_DCD) {
if (Comport.portstate.modemstate & MODEM_DCD) {
notify = NT_DCDOFF;
SET_EVENT(EV_RN, EV_RNNTFY, ¬ify, sizeof(int));
}
else {
notify = NT_DCDON;
SET_EVENT(EV_RN, EV_RNNTFY, ¬ify, sizeof(int));
}
}
Comport.portstate.modemstate = cmdarg;
print_modemstate(cmdarg);
break;
case RAS_COM_SET_MODEMSTATE_MASK:
cmdarg = GET_VALUE_1(buf);
print_modemstate(cmdarg);
break;
case RAS_COM_PURGE_DATA:
cmdarg = GET_VALUE_1(buf);
print_purge(cmdarg);
break;
default:
sysmessage(MSG_NOTICE, "Unnimplemented command: %d\n", cmd);
break;
}
if (!is_notify) {
if (IS_CMD_ACTIVE(cmdidx)) {
CLR_CMD_ACTIVE(cmdidx); /* Synchronous operation */
}
else {
SET_EVENT(EV_RN, EV_RNCMDOK, 0, 0);
}
}
print_all();
}
void EVNT_SetEvent(EVNT_Handle event) {
SET_EVENT(event);
}
void button_cb(void)
{
SET_EVENT(EVENT_BUTTON);
}
int
tel_getdata(void)
{
int i;
int ret;
struct buffer *bp = Nvt.inbuff;
unsigned char c;
if ((ret = sock_read(Comibuf, Nvt.iosize)) <= 0)
return -1;
if (Debug > 2) {
sysmessage(MSG_DEBUG,
"Sock_read, %d bytes: %02X %02X %02X %02X %02X %02X %02X %02X\n",
ret, Comibuf[0], Comibuf[1], Comibuf[2], Comibuf[3],
Comibuf[4], Comibuf[5], Comibuf[6], Comibuf[7]);
}
if (Nvt.servertype == SRV_SOCKET) {
COPY_TO_BUFFER(bp, Comibuf, ret);
SET_EVENT(EV_RN, EV_RNDATA, 0, 0);
return (0);
}
for (i = 0; i < ret; i++) {
c = Comibuf[i];
switch (S_state) {
case S_DATA:
if (c == IAC) {
S_state = S_IAC;
print_control(c);
}
else {
PUT_BUFFER(bp, c);
/* Event EV_RNDATA will be set at end */
}
break;
case S_IAC:
switch (c) {
case DO:
S_state = S_DO;
print_control(c);
break;
case DONT:
S_state = S_DONT;
print_control(c);
break;
case WILL:
S_state = S_WILL;
print_control(c);
break;
case WONT:
S_state = S_WONT;
print_control(c);
break;
case SB:
S_state = S_SB;
print_control(c);
Suboptsize = 0;
break;
case IAC:
default:
S_state = S_DATA;
PUT_BUFFER(bp, c);
break;
}
break;
case S_DO:
print_option(c);
S_state = S_DATA;
do_option(c);
break;
case S_DONT:
print_option(c);
S_state = S_DATA;
dont_option(c);
break;
case S_WILL:
print_option(c);
S_state = S_DATA;
will_option(c);
break;
case S_WONT:
print_option(c);
S_state = S_DATA;
wont_option(c);
break;
case S_SB:
if (c == IAC) {
S_state = S_SE;
print_control(c);
}
else {
if (Suboptsize > SUBOPT_MAXSIZE) {
sysmessage(MSG_WARNING, "Suboption too large\n");
}
else {
Suboptbuf[Suboptsize++] = c;
}
}
break;
case S_SE:
if (c == SE) {
S_state = S_DATA;
print_control(c);
handle_suboption(Suboptbuf, Suboptsize);
Suboptsize = 0;
}
else {
S_state = S_DATA;
sysmessage(MSG_WARNING, "Suboption not terminated: %d", c);
}
break;
}
}
if (bp->b_hold) {
SET_EVENT(EV_RN, EV_RNDATA, 0, 0);
}
print_all();
return (0);
}
// We are called at 8kHz
// We should manage the Vind and Vbat acquisition @ 100Hz
// => We do it when time == 40, 120, 200, 280, 360, 440, 520, 600, 680, 760
// in order to be phase shifted with the horizontal and vertical prox.
void motor_new_analog(unsigned int l, unsigned int r, unsigned int time) {
switch (state) {
case STATE_IDLE:
if (++counter == DURATION_IDLE) {
counter = 0;
if(motor_sens[0] >= 0) {
pwm_motor_lock_vind1_left();
} else {
pwm_motor_lock_vind2_left();
}
if(motor_sens[1] >= 0) {
pwm_motor_lock_vind1_right();
} else {
pwm_motor_lock_vind2_right();
}
state = STATE_VIND1;
}
break;
case STATE_VBAT:
vbat[0] = l;
vbat[1] = r;
SET_EVENT(EVENT_MOTOR);
{
int i;
for( i = 0; i < 2; i++) {
if(motor_sens[i] >= 0) {
if(vind2[i] < vbat[i] - 1) {
vind[i] = vind2[i] - vbat[i];
} else {
vind[i] = vind1[i];
}
} else {
if(vind1[i] > 1) {
vind[i] = vind1[i];
} else {
vind[i] = vind2[i] - vbat[i];
}
}
vmVariables.vbat[i] = vbat[i];
if(vind[i] > 0 && motor_sens[i] > 0) {
if(++motor_sens[i] >= SENS_MAX)
motor_sens[i] = SENS_MAX;
}
if(vind[i] < 0 && motor_sens[i] < 0) {
if(--motor_sens[i] <= -SENS_MAX)
motor_sens[i] = -SENS_MAX;
}
if(vind[i]> 0 && motor_sens[i] <= 0)
motor_sens[i]++;
if(vind[i] < 0 && motor_sens[i] >= 0)
motor_sens[i]--;
}
// Now filter the vind ...
vind_filtered[0] -= vind_left[filter_p];
vind_filtered[1] -= vind_right[filter_p];
vind_filtered[0] += vind[0];
vind_filtered[1] += vind[1];
vind_left[filter_p] = vind[0];
vind_right[filter_p++] = vind[1];
if(filter_p >= 4)
filter_p = 0;
}
pid_motor_tick(vind,vbat);
pwm_motor_unlock_left();
pwm_motor_unlock_right();
state = STATE_PWM;
break;
case STATE_VIND1:
state = STATE_VIND2;
if(motor_sens[0] >= 0) {
pwm_motor_lock_vind2_left();
vind1[0] = l;
} else {
pwm_motor_lock_vind1_left();
vind2[0] = l;
}
if(motor_sens[1] >= 0) {
pwm_motor_lock_vind2_right();
vind1[1] = r;
} else {
pwm_motor_lock_vind1_right();
vind2[1] = r;
}
break;
case STATE_VIND2:
state = STATE_VBAT;
if(motor_sens[0] >= 0) {
vind2[0] = l;
} else {
vind1[0] = l;
}
if(motor_sens[1] >= 0) {
vind2[1] = r;
} else {
vind1[1] = r;
}
pwm_motor_lock_vbat_left();
pwm_motor_lock_vbat_right();
break;
case STATE_PWM:
if(time == 40 || time == 120 || time == 200 || time == 280
|| time == 360 || time == 440 || time == 520 || time == 600
|| time == 680 || time == 760) {
state = STATE_IDLE;
pwm_motor_lock_off_left();
pwm_motor_lock_off_right();
}
break;
}
}
