TDAPA::~TDAPA()
{
OutData(1); SckDelay();
OutSck(1); SckDelay();
OutEnaSck(0);
OutReset(1);
OutEnaReset(0);
if (ppdev_fd != -1) {
if (pa_type_is_serial)
tcsetattr(ppdev_fd, TCSADRAIN, &saved_modes);
else
par_release(ppdev_fd);
close(ppdev_fd);
ppdev_fd = -1;
} else
(void) ioport_disable(IOBASE, IOSIZE);
}
////////////////////////////////////////////////////////////////
// イベントコールバック関数
//
// 引数: id イベントID
// clock クロック
// 返値: なし
////////////////////////////////////////////////////////////////
void SUB6::EventCallback( int id, int clock )
{
switch( id ){
case EID_INTCHK: // 割込みチェック
if( (Status8049 == D8049_IDLE) && IntrFlag ){
int wt = WAIT_DATA;
PRINTD( SUB_LOG, "[8049][EventCallback] EID_INTCHK %02X->", Status8049 );
// 割込み要求を調べる
if ( IntrFlag & IR_JOY ) { Status8049 = D8049_JOY; wt += WAIT_JOY; }
else if( IntrFlag & IR_KEY1 ) { Status8049 = D8049_KEY1; }
else if( IntrFlag & IR_KEY12 ){ Status8049 = D8049_KEY12; }
else if( IntrFlag & IR_CMTR ) { Status8049 = D8049_CMTR; }
else if( IntrFlag & IR_CMTE ) { Status8049 = D8049_CMTE; }
else if( IntrFlag & IR_KEY2 ) { Status8049 = D8049_KEY2; }
else if( IntrFlag & IR_KEY3 ) { Status8049 = D8049_KEY3; }
else if( IntrFlag & IR_SIO ) { Status8049 = D8049_SIO; }
else if( IntrFlag & IR_TVR ) { Status8049 = D8049_TVRR; }
else if( IntrFlag & IR_DATE ) { Status8049 = D8049_DATE; }
if( Status8049 != D8049_IDLE )
vm->EventAdd( this, EID_VECTOR, wt, EV_LOOP|EV_STATE );
PRINTD( SUB_LOG, "%02X\n", Status8049 );
}
break;
case EID_VECTOR: // 割込みベクタ出力
// T0=IBF=H つまり8255のバッファが空いていなければリトライ
if( GetT0() ) break;
vm->EventDel( this, EID_VECTOR );
OutVector(); // 割込みベクタ出力
// 続いてデータ出力
vm->EventAdd( this, EID_DATA, WAIT_DATA, EV_LOOP|EV_STATE );
break;
case EID_DATA: // 割込みデータ出力
// T0=IBF=H つまり8255のバッファが空いていなければリトライ
if( GetT0() ) break;
vm->EventDel( this, EID_DATA );
OutData(); // 割込みデータ出力
break;
}
}
int
TDAPA::SendRecv(int b)
{
unsigned int mask, received=0;
for (mask = 0x80; mask; mask >>= 1) {
OutData(b & mask);
SckDelay();
/* MM 20020613: we used to read the bit here, but ... */
OutSck(1);
SckDelay();
/* ... here we have more room for propagation delays (almost the
whole SCK period, instead of half of it) - good for long cables,
slow RS232 drivers/receivers, opto-isolated interfaces, etc. */
if (InData())
received |= mask;
OutSck(0);
}
return received;
}
int run_main(int argc, char *argv[], int numprocs0, int myid0)
{
int MD_iter,i,j,po,ip;
char fileE[YOUSO10] = ".ene";
char fileDRC[YOUSO10] = ".md";
char fileMemory[YOUSO10];
char fileRestart[YOUSO10];
char operate[200];
double TStime,TEtime;
/* for idle CPUs */
int tag;
int complete;
MPI_Request request;
MPI_Status status;
/* for measuring elapsed time */
dtime(&TStime);
/* allocation of CompTime */
CompTime = (double**)malloc(sizeof(double*)*numprocs0);
for (i=0; i<numprocs0; i++){
CompTime[i] = (double*)malloc(sizeof(double)*30);
for (j=0; j<30; j++) CompTime[i][j] = 0.0;
}
if (myid0==Host_ID){
printf("\n*******************************************************\n");
printf("*******************************************************\n");
printf(" Welcome to OpenMX Ver. %s \n",Version_OpenMX);
printf(" Copyright (C), 2002-2009, T.Ozaki \n");
printf(" OpenMX comes with ABSOLUTELY NO WARRANTY. \n");
printf(" This is free software, and you are welcome to \n");
printf(" redistribute it under the constitution of the GNU-GPL.\n");
printf("*******************************************************\n");
printf("*******************************************************\n\n");
}
Init_List_YOUSO();
remake_headfile = 0;
ScaleSize = 1.2;
/****************************************************
Read the input file
****************************************************/
init_alloc_first();
CompTime[myid0][1] = readfile(argv);
MPI_Barrier(MPI_COMM_WORLD1);
/* initialize PrintMemory routine */
sprintf(fileMemory,"%s%s.memory%i",filepath,filename,myid0);
PrintMemory(fileMemory,0,"init");
PrintMemory_Fix();
/* initialize */
init();
fnjoint(filepath,filename,fileE);
fnjoint(filepath,filename,fileDRC);
/****************************************************
SCF-DFT calculations and MD and geometrical
optimization.
****************************************************/
MD_iter = 1;
do {
CompTime[myid0][2] += truncation(MD_iter,1);
if (ML_flag==1 && myid0==Host_ID) Get_VSZ(MD_iter);
if (Solver==4) {
TRAN_Calc_GridBound( mpi_comm_level1, atomnum, WhatSpecies, Spe_Atom_Cut1,
Ngrid1, Grid_Origin, Gxyz, tv, gtv, rgtv, Left_tv, Right_tv );
/* output: TRAN_region[], TRAN_grid_bound */
}
CompTime[myid0][3] += DFT(MD_iter,(MD_iter-1)%orbitalOpt_per_MDIter+1);
if (myid0==Host_ID) iterout(MD_iter,MD_TimeStep*MD_iter,fileE,fileDRC);
if (ML_flag==0) CompTime[myid0][4] += MD_pac(MD_iter,argv[1]);
MD_iter++;
} while(MD_Opt_OK==0 && MD_iter<=MD_IterNumber);
if ( TRAN_output_hks ) {
/* left is dummy */
TRAN_RestartFile(mpi_comm_level1, "write","left",filepath,TRAN_hksoutfilename);
}
/****************************************************
calculate Voronoi charge
****************************************************/
if (Voronoi_Charge_flag==1) Voronoi_Charge();
/****************************************************
making of a file *.frac for the fractional coordinates
****************************************************/
Make_FracCoord(argv[1]);
/****************************************************
generate Wannier functions added by Hongming Weng
****************************************************/
/* hmweng */
if(Wannier_Func_Calc){
if (myid0==Host_ID) printf("Calling Generate_Wannier...\n");fflush(0);
Generate_Wannier(argv[1]);
}
/****************************************************
Making of output files
****************************************************/
CompTime[myid0][20] = OutData(argv[1]);
/****************************************************
write connectivity, Hamiltonian, overlap, density
matrices, and etc. to a file, filename.scfout
****************************************************/
if (HS_fileout==1) SCF2File("write",argv[1]);
/* elapsed time */
dtime(&TEtime);
CompTime[myid0][0] = TEtime - TStime;
Output_CompTime();
for (i=0; i<numprocs0; i++){
free(CompTime[i]);
}
free(CompTime);
/* merge log files */
Merge_LogFile(argv[1]);
/* free arrays */
Free_Arrays(0);
/* print memory */
PrintMemory("total",0,"sum");
/****************************************************
reconstruct the original MPI group
****************************************************/
{
int *new_ranks;
MPI_Group new_group,old_group;
new_ranks = (int*)malloc(sizeof(int)*numprocs0);
for (i=0; i<numprocs0; i++) {
new_ranks[i]=i; /* a new group is made of original rank=0:Pnum[k]-1 */
}
MPI_Comm_group(MPI_COMM_WORLD1, &old_group);
/* define a new group */
MPI_Group_incl(old_group,numprocs0,new_ranks,&new_group);
MPI_Comm_create(MPI_COMM_WORLD1,new_group,&mpi_comm_level1);
MPI_Group_free(&new_group);
free(new_ranks); /* never forget cleaning! */
}
MPI_Barrier(MPI_COMM_WORLD1);
if (myid0==Host_ID){
printf("\nThe calculation was normally finished.\n");
}
return 0;
}
bool ActorEquipmentOverrider::OverrideHandler::HandleEquipment(ActorBodyModelData * ModelData,
TESForm* ModelSource,
TESObjectREFR * Ref,
TESNPC * NPC,
OverrideResultListT & OutResults) const
{
_MESSAGE("Handler %d | Filters: REF(%08X), NPC(%s %08X), RACE(%s %08X), ITEM(%s %08X)",
ID,
Filters.Reference ? Filters.Reference->refID : 0,
Filters.NPC ? InstanceAbstraction::GetFormName(Filters.NPC) : "",
Filters.NPC ? Filters.NPC->refID : 0,
Filters.Race ? InstanceAbstraction::GetFormName(Filters.Race) : "",
Filters.Race ? Filters.Race->refID : 0,
Filters.EquippedItem ? InstanceAbstraction::GetFormName(Filters.EquippedItem) : "",
Filters.EquippedItem ? Filters.EquippedItem->refID : 0);
gLog.Indent();
bool Result = false;
TESRace* Race = NPC->race.race;
UInt32 Female = NPC->actorBaseData.IsFemale();
// check filters
bool FiltersMatch = true;
if (Filters.Reference && Filters.Reference != Ref)
FiltersMatch = false;
else if (Filters.NPC && Filters.NPC != NPC)
FiltersMatch = false;
else if (Filters.Race && Filters.Race != Race)
FiltersMatch = false;
else if (Filters.EquippedItem && Filters.EquippedItem != ModelSource)
FiltersMatch = false;
if (FiltersMatch)
{
TESForm* OrgModelSource = ModelSource;
OBSEArrayElement HandlerResult;
// call function script and extract results
if (Interfaces::kOBSEScript->CallFunction(Handler, Ref, NULL, &HandlerResult, 4, OrgModelSource, NPC, Race, Female))
{
if (HandlerResult.IsValid())
{
OBSEArrayVarInterface::Array* ResultData = HandlerResult.Array();
if (ResultData)
{
UInt32 Size = Interfaces::kOBSEArrayVar->GetArraySize(ResultData);
if (Size == kResultArray__Size)
{
OBSEArrayElement Priority, OverrideModelSource;
Interfaces::kOBSEArrayVar->GetElement(ResultData, kResultArrayIndex_Priority, Priority);
Interfaces::kOBSEArrayVar->GetElement(ResultData, kResultArrayIndex_OverrideModelSource, OverrideModelSource);
if (Priority.IsValid() && Priority.GetType() == OBSEArrayElement::kType_Numeric &&
OverrideModelSource.IsValid() && OverrideModelSource.GetType() == OBSEArrayElement::kType_Form)
{
TESForm* Override = OverrideModelSource.Form();
double ApplyPriority = Priority.Number();
if (ApplyPriority < 0)
ApplyPriority = 0;
else if (ApplyPriority > 100)
ApplyPriority = 100;
if (Settings::kEquipmentOverrideCheckOverrideSourceType().i == 0 || Override->typeID == OrgModelSource->typeID)
{
TESBipedModelForm* NewBiped = OBLIVION_CAST(Override, TESForm, TESBipedModelForm);
SME_ASSERT(NewBiped);
TESModel* NewModel = &NewBiped->bipedModel[0];
if (Female)
NewModel = &NewBiped->bipedModel[1];
if (NewModel->nifPath.m_dataLen != 0)
{
OverrideHandler::Result OutData(ID, (UInt32)ApplyPriority, Override, NewModel);
OutResults.push_back(OutData);
Result = true;
_MESSAGE("Added override item with priority %d, model source %s (%08X), model %s",
(UInt32)ApplyPriority, InstanceAbstraction::GetFormName(Override), Override->refID, NewModel->nifPath.m_data);
}
else
{
_MESSAGE("Invalid path for override model source %08X", Override->refID);
}
}
else
{
_MESSAGE("Model source type mismatch. Expected %d but received %d", (UInt32)OrgModelSource->typeID, (UInt32)Override->typeID);
}
}
else
{
_MESSAGE("Couldn't extract result array arguments. Expected types %d and %d but received %d and %d",
(UInt32)OBSEArrayElement::kType_Numeric,
(UInt32)OBSEArrayElement::kType_Form,
(UInt32)Priority.GetType(), (UInt32)OverrideModelSource.GetType());
}
}
else
{
_MESSAGE("Unexpected result array size. Expected %d but received %d", (UInt32)kResultArray__Size, Size);
}
}
else
{
_MESSAGE("Handler script returned an invalid result of type %d", (UInt32)HandlerResult.GetType());
}
}
else
{
_MESSAGE("Handler script returned no result");
}
}
else
{
_MESSAGE("Handler script call failed for script %08X", Handler->refID);
}
}
else
{
_MESSAGE("Filter mismatch");
}
gLog.Outdent();
return Result;
}
//---------------------------------------------------------------------------
void __fastcall CComm::Execute()
{
m_Execute = 1;
int BitLen = pMod->m_BitLen;
//---- スレッドのコードをここに記述 ----
// Priority = tpLower;
while(1){
_try:;
if( Terminated == TRUE ){
return;
}
if( m_Command == COMM_CLOSE ){
m_Command = 0;
return;
}
if( m_CreateON == TRUE ){
if( !m_TxEnb ){
::Sleep(10);
}
else if( !TxBusy() ){
if( m_FirstGaurd ){ // 最初のガード時間の確保
m_FirstGaurd = 0;
::Sleep(250);
if( m_DisDiddle == -1 ) m_DisDiddle = 0;
}
else if( m_txcnt && (FSKDeff <= DEFFSOUND) ){ // 送信データあり
m_DisDiddle = pMod->m_DisDiddle;
m_Data = m_txbuf[m_txrp];
if( m_figout && (m_fig == 0x1b) && (m_Data != 0x1f) ){
m_Data = 0x1b;
}
else {
switch(m_Data){
case 0xff: // Mark
::Sleep((pMod->m_ReCount * 3 * 1000) / SampFreq);
NextBuf();
goto _try;
case 0xfe: // キャリア断続
NextBuf();
goto _try;
case 0xfd: // disable diddle
m_DisDiddle = 0;
NextBuf();
goto _try;
case 0xfc: // enable diddle
m_DisDiddle = 1;
NextBuf();
goto _try;
case 0x1b:
case 0x1f:
m_fig = m_Data;
break;
}
NextBuf();
}
m_figout = 0;
if( !pMod->m_CharWaitDiddle ){
WaitTXD(pMod->m_CharWait);
}
m_WaitTimerCount = 4;
OutData(m_Data);
}
else if( (BitLen < 6) && ((FSKDeff > DEFFSOUND) || (pMod->m_diddle && !m_DisDiddle)) ){
if( FSKDeff > DEFFSOUND ){
WaitTXD(pMod->m_CharWait);
}
else if( (sys.m_LWait == 2) || !pMod->m_WaitTimer || m_WaitTimerCount ){
if( !pMod->m_CharWaitDiddle ){
if( sys.m_LWait == 2 ){
WaitTXD(pMod->m_CharWait);
}
else if( pMod->m_DiddleWait ){
WaitTXD(pMod->m_DiddleWait);
}
}
}
m_idle = 1;
switch(pMod->m_diddle){
case 1: // BLK
if( pMod->m_RandomDiddle && !(rand() & 3) ){
m_Data = 0x1f;
if( pMod->m_BitLen <= 6 ) m_figout = 1;
}
else {
m_Data = 0x00;
}
break;
default: // LTR
if( pMod->m_RandomDiddle && !(rand() & 3) ){
m_Data = 0x00;
}
else {
m_Data = 0x1f;
if( pMod->m_BitLen <= 6 ) m_figout = 1;
}
break;
}
if( m_WaitTimerCount ) m_WaitTimerCount--;
OutData(m_Data);
}
else {
if( !m_idle ){
::Sleep((pMod->m_ReCount * pMod->m_BitLen)*1000/SampFreq);
}
m_idle = 1;
}
::Sleep(10);
}
else {
::Sleep(1);
}
}
else {
::Sleep(10);
}
}
}
