//********************************************************************//
// Transmission d'une trame
//********************************************************************//
U8 tcCanVector::ReqTrameUU(tObjetCanUU* pObjetCan,tTrameCan* pTrameCan)
{
Vstatus StatutOld;
Vevent vEvent;
vEvent.tag = V_TRANSMIT_MSG;
vEvent.tagData.msg.id = pObjetCan->Id & ~cCanRemoteFrameFlag;
vEvent.tagData.msg.flags = pObjetCan->Id&cCanRemoteFrameFlag?VCAN_MSG_FLAG_REMOTE_FRAME:0;
vEvent.tagData.msg.dlc = pTrameCan->Longueur;
if ( pObjetCan->ModeHighVoltage == cTrue )
{
// On vide la file d'emission hard
ncdFlushTransmitQueue(m_gPortHandle,m_gChannelMask);
// On positionne le flag wake-up
vEvent.tagData.msg.flags = MSGFLAG_WAKEUP | MSGFLAG_OVERRUN;
}
memcpy(vEvent.tagData.msg.data,pTrameCan->Buffer,pTrameCan->Longueur);
StatutOld=m_StatutReq;
m_CanCardMutex.Lock();
m_StatutReq = ncdTransmit(m_gPortHandle, m_gChannelMask, &vEvent);
if (m_StatutReq == VERR_QUEUE_IS_FULL) // Queue pleine
{
m_StatutReq = 0; // Evite d'afficher un CanOk quand on peut à nouveau emettre
return cFaux;
}
else if (m_StatutReq != 0) // Erreur
{
if (m_StatutReq != StatutOld)
{
char Buffer[256];
sprintf(Buffer,"tcCanVector::ReqTrameUU> Emission failed (%04X)",m_StatutReq);
SetMsg(cErrorMsg,Buffer);
}
return cFaux;
}
else if (m_StatutReq != StatutOld) // Ok
{
SetMsg(cErrorMsg,"tcCanVector::ReqTrameUU> Bus CAN OK");
}
if (pObjetCan->FCallBackCon!=NULL) // On signale une fin d"émission par callback si demandée
{
pObjetCan->FCallBackCon(pObjetCan,pObjetCan->ParamCallBackCon);
}
m_CanCardMutex.Unlock();
return cVrai;
}
void Set(const t_symbol *r,const t_symbol *s,int ac,const t_atom *av)
{
FLEXT_ASSERT(r);
th = NULL;
recv = r;
SetMsg(s,ac,av);
}
void Idle(bool (*idlefun)(int argc,const t_atom *argv),int argc,const t_atom *argv)
{
FLEXT_ASSERT(idlefun);
th = NULL;
fun = idlefun;
SetMsg(NULL,argc,argv);
}
// exception
Interpolation::BadRange::BadRange(double x, const FloatRange& r)
: MerlinException(""),value(x),valid_range(r)
{
ostringstream buf;
buf<<value<<" not in interpolation range ("<<r.lower<<","<<r.upper<<')';
SetMsg(buf.str());
}
void EView::DeleteModel(EModel *M) {
EView *V;
EModel *M1;
char s[256];
if (M == 0)
return;
M->GetName(s, sizeof(s));
Msg(S_INFO, "Closing %s.", s);
V = ActiveView = this;
while (V) {
M1 = V->Model;
if (M1 == M) {
if (M->Next != M)
V->SelectModel(M->Next);
else
V->SelectModel(0);
}
V = V->Next;
if (V == ActiveView)
break;
}
delete M;
SetMsg(0);
return;
}
void Set(flext_base *t,int o,const t_symbol *s,int ac,const t_atom *av)
{
FLEXT_ASSERT(t);
th = t;
out = o;
SetMsg(s,ac,av);
}
INT_PTR CGeneralMsgBox::AfxMessageBox(LPCWSTR lpszText, LPCWSTR lpCaption, UINT uiFlags)
{
SetMsg(lpszText);
if (lpCaption == NULL)
lpCaption = AfxGetApp()->m_pszAppName;
INT_PTR rc = MessageBox(NULL, lpCaption, uiFlags);
return rc;
}
CSAXParseException::CSAXParseException(const string& msg, const XMLString& publicId, const XMLString& systemId, int lineNumber, int columnNumber, const CXMLException& e): CSAXException(e)
{
SetMsg(msg);
m_publicId = publicId;
m_systemId = systemId;
m_lineNumber = lineNumber;
m_columnNumber = columnNumber;
}
CSAXParseException::CSAXParseException(const string& msg, const CLocator& loc, const CXMLException& e): CSAXException(e)
{
SetMsg(msg);
m_publicId = loc.GetPublicId();
m_systemId = loc.GetSystemId();
m_lineNumber = loc.GetLineNumber();
m_columnNumber = loc.GetColumnNumber();
}
static void OnButtonInstall()
{
CrashAlwaysIf(gForceCrash);
if (gShowOptions)
OnButtonOptions();
KillSumatra();
if (!CheckInstallUninstallPossible())
return;
WCHAR *userInstallDir = win::GetText(gHwndTextboxInstDir);
if (!str::IsEmpty(userInstallDir))
str::ReplacePtr(&gGlobalData.installDir, userInstallDir);
free(userInstallDir);
// note: this checkbox isn't created if we're already registered as default
// (in which case we're just going to re-register)
gGlobalData.registerAsDefault = gHwndCheckboxRegisterDefault == nullptr ||
IsCheckboxChecked(gHwndCheckboxRegisterDefault);
// note: this checkbox isn't created when running inside Wow64
gGlobalData.installPdfFilter = gHwndCheckboxRegisterPdfFilter != nullptr &&
IsCheckboxChecked(gHwndCheckboxRegisterPdfFilter);
// note: this checkbox isn't created on Windows 2000 and XP
gGlobalData.installPdfPreviewer = gHwndCheckboxRegisterPdfPreviewer != nullptr &&
IsCheckboxChecked(gHwndCheckboxRegisterPdfPreviewer);
// note: this checkbox isn't created if the browser plugin hasn't been installed before
gGlobalData.keepBrowserPlugin = gHwndCheckboxKeepBrowserPlugin != nullptr &&
IsCheckboxChecked(gHwndCheckboxKeepBrowserPlugin);
// create a progress bar in place of the Options button
RectI rc(0, 0, dpiAdjust(INSTALLER_WIN_DX / 2), gButtonDy);
rc = MapRectToWindow(rc, gHwndButtonOptions, gHwndFrame);
gHwndProgressBar = CreateWindow(PROGRESS_CLASS, nullptr, WS_CHILD | WS_VISIBLE,
rc.x, rc.y, rc.dx, rc.dy,
gHwndFrame, 0, GetModuleHandle(nullptr), nullptr);
SendMessage(gHwndProgressBar, PBM_SETRANGE32, 0, GetInstallationStepCount());
SendMessage(gHwndProgressBar, PBM_SETSTEP, 1, 0);
// disable the install button and remove all the installation options
SafeDestroyWindow(&gHwndStaticInstDir);
SafeDestroyWindow(&gHwndTextboxInstDir);
SafeDestroyWindow(&gHwndButtonBrowseDir);
SafeDestroyWindow(&gHwndCheckboxRegisterDefault);
SafeDestroyWindow(&gHwndCheckboxRegisterPdfFilter);
SafeDestroyWindow(&gHwndCheckboxRegisterPdfPreviewer);
SafeDestroyWindow(&gHwndCheckboxKeepBrowserPlugin);
SafeDestroyWindow(&gHwndButtonOptions);
EnableWindow(gHwndButtonInstUninst, FALSE);
SetMsg(_TR("Installation in progress..."), COLOR_MSG_INSTALLATION);
InvalidateFrame();
gGlobalData.hThread = CreateThread(nullptr, 0, InstallerThread, nullptr, 0, 0);
}
ExcessiveParticleLoss::ExcessiveParticleLoss (const string& c_id, double threshold, size_t nlost, size_t nstart)
: MerlinException()
{
ostringstream buffer;
buffer << "CollimateParticleProcess Exception\n";
buffer << "particle loss threshold of " << 100*threshold << "% exceeded ";
buffer << '(' << nlost << '/' << nstart << ") at " << c_id;
SetMsg(buffer.str());
}
bool CBmpFile::Save(const char *fpath)
{
FILE *fp= NULL;
bool bOK= true;;
try
{
if(!mDib)
throw CImgFile::sMsgs[ERR_GENERAL];
fp = fopen(fpath, "wb");
if(!fp)
throw CImgFile::sMsgs[ERR_NO_FILE];
BITMAPINFOHEADER bmih= *dib_get_hdr(mDib);
int dibH= dib_get_height2(mDib), dibHa= dib_get_height(mDib);
int dibP= dib_get_pitch(mDib), dibPa= dibP;
int dibS= dibHa*dibPa, nclrs= dib_get_nclrs(mDib);
bmih.biHeight= dibHa;
bmih.biSizeImage= dibS;
// fill in fileheader
BITMAPFILEHEADER bmfh;
bmfh.bfType= BMP_TYPE;
bmfh.bfOffBits= sizeof(BITMAPFILEHEADER)+BMIH_SIZE+nclrs*RGB_SIZE;
bmfh.bfSize= bmfh.bfOffBits + dibS;
bmfh.bfReserved1= bmfh.bfReserved2= 0;
// write down header
fwrite(&bmfh, sizeof(BITMAPFILEHEADER), 1, fp);
fwrite(&bmih, BMIH_SIZE, 1, fp);
// write down palette
fwrite(dib_get_pal(mDib), RGB_SIZE, nclrs, fp);
// write down rows, with possible flipping
BYTE *dibL= dib_get_img(mDib);
if(dibH<0)
{
dibL += (dibHa-1)*dibPa;
dibP= -dibP;
}
for(int iy=0; iy<dibHa; iy++)
fwrite(dibL+iy*dibP, dibPa, 1, fp);
}
catch(const char *msg)
{
SetMsg(msg);
bOK= false;
}
if(fp)
fclose(fp);
return bOK;
}
void OnInstallationFinished()
{
DestroyWindow(gHwndButtonInstUninst);
gHwndButtonInstUninst = NULL;
DestroyWindow(gHwndProgressBar);
gHwndProgressBar = NULL;
if (gGlobalData.success) {
CreateButtonRunSumatra(gHwndFrame);
SetMsg(_TR("Thank you! SumatraPDF has been installed."), COLOR_MSG_OK);
} else {
CreateButtonExit(gHwndFrame);
SetMsg(_TR("Installation failed!"), COLOR_MSG_FAILED);
}
gMsgError = gGlobalData.firstError;
InvalidateFrame();
CloseHandle(gGlobalData.hThread);
}
void EView::Msg(int level, const char *s, ...) {
char msgbuftmp[MSGBUFTMP_SIZE];
va_list ap;
va_start(ap, s);
vsprintf(msgbuftmp, s, ap);
va_end(ap);
if (level != S_BUSY)
SetMsg(msgbuftmp);
}
void OnUninstallationFinished()
{
DestroyWindow(gHwndButtonInstUninst);
gHwndButtonInstUninst = NULL;
CreateButtonExit(gHwndFrame);
SetMsg(TAPP L" has been uninstalled.", gMsgError ? COLOR_MSG_FAILED : COLOR_MSG_OK);
gMsgError = gGlobalData.firstError;
InvalidateFrame();
CloseHandle(gGlobalData.hThread);
}
void OnInstallationFinished()
{
SafeDestroyWindow(&gHwndButtonInstUninst);
SafeDestroyWindow(&gHwndProgressBar);
if (gGlobalData.success) {
CreateButtonRunSumatra(gHwndFrame);
SetMsg(_TR("Thank you! SumatraPDF has been installed."), COLOR_MSG_OK);
} else {
CreateButtonExit(gHwndFrame);
SetMsg(_TR("Installation failed!"), COLOR_MSG_FAILED);
}
gMsgError = gGlobalData.firstError;
InvalidateFrame();
CloseHandle(gGlobalData.hThread);
if (gGlobalData.autoUpdate && gGlobalData.success) {
// click the Start button
PostMessage(gHwndFrame, WM_COMMAND, IDOK, 0);
}
}
static void OnButtonUninstall()
{
KillSumatra();
if (!CheckInstallUninstallPossible())
return;
// disable the button during uninstallation
EnableWindow(gHwndButtonInstUninst, FALSE);
SetMsg(L"Uninstallation in progress...", COLOR_MSG_INSTALLATION);
InvalidateFrame();
gGlobalData.hThread = CreateThread(NULL, 0, UninstallerThread, NULL, 0, 0);
}
ModelIterator3Helper(int max_) : max(max_) , cntr(0) {
SetMsg();
}
CSAXException::CSAXException(const string& msg, CXMLException& e): CXMLException(e)
{
SetMsg(msg);
}
int __fastcall UserCallback::UserCB(unsigned Action, const DZStrW& msg)
{
SetMsg(msg);
return UserCB(Action);
}
int UserCallback::UserCB(unsigned Action, const DZStrW& msg, const DZStrW& msg2)
{
SetMsg2(msg2);
SetMsg(msg);
return UserCB(Action);
}
tcCanVector::tcCanVector(tcTimerCan* pTimerCan,tcParamCan* pParamCan):tcCanUUDT(pTimerCan,pParamCan)
{
ASSERT(pParamCan != NULL);
if (!strcmp(pParamCan->CanCardName,cCanCardVECTORCanAC2PciXPort0))
{
pParamCan->Port = 0x0600;
}
else if (!strcmp(pParamCan->CanCardName,cCanCardVECTORCanAC2PciXPort1))
{
pParamCan->Port = 0x0601;
}
else if (!strcmp(pParamCan->CanCardName,cCanCardVECTORCanCardXPort0))
{
pParamCan->Port = 0x0200;
}
else if (!strcmp(pParamCan->CanCardName,cCanCardVECTORCanCardXPort1))
{
pParamCan->Port = 0x0201;
}
else if (!strcmp(pParamCan->CanCardName,cCanCardVECTORCanCardXLPort0))
{
pParamCan->Port = 0x0F00;
}
else if (!strcmp(pParamCan->CanCardName,cCanCardVECTORCanCardXLPort1))
{
pParamCan->Port = 0x0F01;
}
else if (!strcmp(pParamCan->CanCardName,cCanCardVECTORCanBoardXLPort0))
{
pParamCan->Port = 0x1900;
}
else if (!strcmp(pParamCan->CanCardName,cCanCardVECTORCanBoardXLPort1))
{
pParamCan->Port = 0x1901;
}
else if (!strcmp(pParamCan->CanCardName,cCanCardVECTORCanCaseXLPort0))
{
pParamCan->Port = 0x1500;
}
else if (!strcmp(pParamCan->CanCardName,cCanCardVECTORCanCaseXLPort1))
{
pParamCan->Port = 0x1501;
}
memcpy(&m_ParamCan,pParamCan,sizeof(m_ParamCan));
m_Arret=cFaux;
m_ThreadID=0;
int gHwType = pParamCan->Port>>8; // HWTYPE
int gHwChannel = (pParamCan->Port&0xFF)%2; // 2 ports par carte
int gHwIndex = (pParamCan->Port&0xFF)/2; // N° de carte
Vstatus Statut;
VsetAcceptance acc;
Vaccess gPermissionMask = 0;
m_gChannelMask = 0;
m_gPortHandle = INVALID_PORTHANDLE;
// m_iErrorFrameTimeoutTimerID = cNumeroTempoInvalide;
m_NbCarteChargee++;
// On initialise le Driver
Statut = ncdOpenDriver();
if (Statut!=VSUCCESS)
{
char Buffer[256];
sprintf(Buffer,"tcCanVector::tcCanVector> Can driver failed (%04X)",Statut);
SetMsg(cErrorMsg,Buffer);
return;
}
m_CartePresente = cVrai;
// On cherche le masque du canal Cancardx d'index 0 et de canal Port
m_gChannelMask = ncdGetChannelMask(gHwType,gHwIndex,gHwChannel);
if (m_gChannelMask==0)
{
char Buffer[256];
sprintf(Buffer,"tcCanVector::tcCanVector> %s not found",m_ParamCan.CanCardName);
SetMsg(cErrorMsg,Buffer);
return;
}
gPermissionMask = m_gChannelMask;
// On ouvre le port
Statut = ncdOpenPort(&m_gPortHandle,"JCAE",m_gChannelMask,m_gChannelMask,&gPermissionMask,pParamCan->QueueRead);
if (Statut!=VSUCCESS)
{
char Buffer[256];
sprintf(Buffer,"tcCanVector::tcCanVector> Can port failed (%04X)",Statut);
SetMsg(cErrorMsg,Buffer);
return;
}
if (gPermissionMask!=m_gChannelMask)
{
SetMsg(cErrorMsg,"tcCanVector::tcCanVector> Can card configuration unauthorized");
return;
}
// On configure la vitesse
Statut = ncdSetChannelBitrate(m_gPortHandle,m_gChannelMask,pParamCan->BaudRate);
if (Statut!=VSUCCESS)
{
char Buffer[256];
sprintf(Buffer,"tcCanVector::tcCanVector> Baudrate configuration failed (%04X)",Statut);
SetMsg(cErrorMsg,Buffer);
return;
}
// Inhiber les notifications TX et TXRQ
Statut = ncdSetChannelMode(m_gPortHandle,m_gChannelMask,0,0);
if (Statut!=VSUCCESS)
{
char Buffer[256];
sprintf(Buffer,"tcCanVector::tcCanVector> Tx and TXRQ disabling failed (%04X)",Statut);
SetMsg(cErrorMsg,Buffer);
return;
}
// On configure les masques d'acceptances
acc.mask = pParamCan->MaskStd; // relevant=1
acc.code = pParamCan->CodeStd;
Statut = ncdSetChannelAcceptance(m_gPortHandle,m_gChannelMask,&acc);
if (Statut!=VSUCCESS)
{
char Buffer[256];
sprintf(Buffer,"tcCanVector::tcCanVector> STD Mask id configuration failed (%04X)",Statut);
SetMsg(cErrorMsg,Buffer);
return;
}
acc.mask = 0x80000000 | pParamCan->MaskXtd; // relevant=1
acc.code = 0x80000000 | pParamCan->CodeXtd;
Statut = ncdSetChannelAcceptance(m_gPortHandle,m_gChannelMask,&acc);
if (Statut!=VSUCCESS)
{
char Buffer[256];
sprintf(Buffer,"tcCanVector::tcCanVector> XTD Mask id configuration failed (%04X)",Statut);
SetMsg(cErrorMsg,Buffer);
return;
}
// On vide la queue de réception
Statut = ncdFlushReceiveQueue(m_gPortHandle);
if (Statut!=VSUCCESS)
{
char Buffer[256];
sprintf(Buffer,"tcCanVector::tcCanVector> Reception queue erasing failed (%04X)",Statut);
SetMsg(cErrorMsg,Buffer);
return;
}
// On vide la queue de transmission
Statut = ncdFlushTransmitQueue(m_gPortHandle,m_gChannelMask);
if (Statut!=VSUCCESS)
{
char Buffer[256];
sprintf(Buffer,"tcCanVector::tcCanVector> Emission queue erasing failed (%04X)",Statut);
SetMsg(cErrorMsg,Buffer);
return;
}
// On crée l'évènement pour recevoir
m_gEventHandle = CreateEvent(NULL, FALSE, FALSE, NULL);
Statut = ncdSetNotification(m_gPortHandle,(unsigned long*)&m_gEventHandle, 1);
if (Statut!=VSUCCESS)
{
char Buffer[256];
sprintf(Buffer,"tcCanVector::tcCanVector> Reception event configuration failed (%04X)",Statut);
SetMsg(cErrorMsg,Buffer);
return;
}
// On initialise le corps du thread
m_hThread = CreateThread( NULL,0,CorpsThread,(LPVOID)this,0,&m_ThreadID);
if(m_hThread==INVALID_HANDLE_VALUE)
{
SetMsg(cErrorMsg,"tcCanVector::tcCanVector> Reception thread creation failed");
return;
}
// On active le canal
Statut = ncdActivateChannel(m_gPortHandle,m_gChannelMask);
if (Statut!=VSUCCESS)
{
char Buffer[256];
if(Statut == VERR_PORT_IS_OFFLINE)
{
sprintf(Buffer,"tcCanVector (Error : %04X) > !!!!!!!!!!!!!!!!! Please, Plug the CAN Cable !!!!!!!!!!!!!!!!!",Statut);
}
else
{
sprintf(Buffer,"tcCanVector::tcCanVector> Channel activation failed (%04X)",Statut);
}
SetMsg(cErrorMsg,Buffer);
return;
}
m_StatutReq = VSUCCESS;
m_InitOk=cVrai;
}
//********************************************************************//
// Reinit can card needed for BUS OFF by example
//********************************************************************//
void tcCanVector::ReinitCard()
{
m_CanCardMutex.Lock();
//---- Deactivate channel previously loaded ----
ncdDeactivateChannel(m_gPortHandle,m_gChannelMask);
ncdClosePort(m_gPortHandle);
m_gPortHandle = INVALID_PORTHANDLE;
ncdCloseDriver();
//---- Initialise channel -----
int gHwType = m_ParamCan.Port>>8; // HWTYPE
int gHwChannel = (m_ParamCan.Port&0xFF)%2; // 2 ports par carte
int gHwIndex = (m_ParamCan.Port&0xFF)/2; // N° de carte
Vstatus Statut;
VsetAcceptance acc;
Vaccess gPermissionMask = 0;
m_gPortHandle = INVALID_PORTHANDLE;
Statut = ncdOpenDriver();
if (Statut!=VSUCCESS)
{
char Buffer[256];
sprintf(Buffer,"tcCanVector::tcCanVector> Can driver failed (%04X)",Statut);
SetMsg(cErrorMsg,Buffer);
return;
}
// On cherche le masque du canal Cancardx d'index 0 et de canal Port
m_gChannelMask = ncdGetChannelMask(gHwType,gHwIndex,gHwChannel);
if (m_gChannelMask==0)
{
char Buffer[256];
sprintf(Buffer,"tcCanVector::tcCanVector> %s not found",m_ParamCan.CanCardName);
SetMsg(cErrorMsg,Buffer);
return;
}
gPermissionMask = m_gChannelMask;
// On ouvre le port
Statut = ncdOpenPort(&m_gPortHandle,"JCAE",m_gChannelMask,m_gChannelMask,&gPermissionMask,m_ParamCan.QueueRead);
if (Statut!=VSUCCESS)
{
char Buffer[256];
sprintf(Buffer,"tcCanVector::tcCanVector> Can port failed (%04X)",Statut);
SetMsg(cErrorMsg,Buffer);
return;
}
if (gPermissionMask!=m_gChannelMask)
{
SetMsg(cErrorMsg,"tcCanVector::tcCanVector> Can card configuration unauthorized");
return;
}
// On configure la vitesse
Statut = ncdSetChannelBitrate(m_gPortHandle,m_gChannelMask,m_ParamCan.BaudRate);
if (Statut!=VSUCCESS)
{
char Buffer[256];
sprintf(Buffer,"tcCanVector::tcCanVector> Baudrate configuration failed (%04X)",Statut);
SetMsg(cErrorMsg,Buffer);
return;
}
// Change Ack
Statut = ncdSetChannelOutput(m_gPortHandle,m_gChannelMask,(m_ParamCan.Spy==1)?OUTPUT_MODE_SILENT:OUTPUT_MODE_NORMAL);
if (Statut!=VSUCCESS)
{
char Buffer[256];
sprintf(Buffer,"tcCanVector::tcCanVector> spy configuration failed (%04X)",Statut);
SetMsg(cErrorMsg,Buffer);
return;
}
// Inhiber les notifications TX et TXRQ
Statut = ncdSetChannelMode(m_gPortHandle,m_gChannelMask,0,0);
if (Statut!=VSUCCESS)
{
char Buffer[256];
sprintf(Buffer,"tcCanVector::tcCanVector> Tx and TXRQ disabling failed (%04X)",Statut);
SetMsg(cErrorMsg,Buffer);
return;
}
// On configure les masques d'acceptances
acc.mask = m_ParamCan.MaskStd; // relevant=1
acc.code = m_ParamCan.CodeStd;
Statut = ncdSetChannelAcceptance(m_gPortHandle,m_gChannelMask,&acc);
if (Statut!=VSUCCESS)
{
char Buffer[256];
sprintf(Buffer,"tcCanVector::tcCanVector> STD Mask id configuration failed (%04X)",Statut);
SetMsg(cErrorMsg,Buffer);
return;
}
acc.mask = 0x80000000 | m_ParamCan.MaskXtd; // relevant=1
acc.code = 0x80000000 | m_ParamCan.CodeXtd;
Statut = ncdSetChannelAcceptance(m_gPortHandle,m_gChannelMask,&acc);
if (Statut!=VSUCCESS)
{
char Buffer[256];
sprintf(Buffer,"tcCanVector::tcCanVector> XTD Mask id configuration failed (%04X)",Statut);
SetMsg(cErrorMsg,Buffer);
return;
}
// On vide la queue de réception
Statut = ncdFlushReceiveQueue(m_gPortHandle);
if (Statut!=VSUCCESS)
{
char Buffer[256];
sprintf(Buffer,"tcCanVector::tcCanVector> Reception queue erasing failed (%04X)",Statut);
SetMsg(cErrorMsg,Buffer);
return;
}
// On vide la queue de transmission
Statut = ncdFlushTransmitQueue(m_gPortHandle,m_gChannelMask);
if (Statut!=VSUCCESS)
{
char Buffer[256];
sprintf(Buffer,"tcCanVector::tcCanVector> Emission queue erasing failed (%04X)",Statut);
SetMsg(cErrorMsg,Buffer);
return;
}
// On crée l'évènement pour recevoir
m_gEventHandle = CreateEvent(NULL, FALSE, FALSE, NULL);
Statut = ncdSetNotification(m_gPortHandle,(unsigned long*)&m_gEventHandle, 1);
if (Statut!=VSUCCESS)
{
char Buffer[256];
sprintf(Buffer,"tcCanVector::tcCanVector> Reception event configuration failed (%04X)",Statut);
SetMsg(cErrorMsg,Buffer);
return;
}
// On active le canal
Statut = ncdActivateChannel(m_gPortHandle,m_gChannelMask);
if (Statut!=VSUCCESS)
{
char Buffer[256];
sprintf(Buffer,"tcCanVector::tcCanVector> Channel activation failed (%04X)",Statut);
SetMsg(cErrorMsg,Buffer);
return;
}
m_StatutReq = VSUCCESS;
m_CanCardMutex.Unlock();
}
//********************************************************************//
// Can control
//********************************************************************//
U8 tcCanVector::Control(tCanControl CanControl,void* Param)
{
Vstatus Statut;
U8 ReturnValue = cFalse;
if (CanControl == cCanChangeBaudrateControl)
{
m_CanCardMutex.Lock();
// Deactivate channel
Statut = ncdDeactivateChannel(m_gPortHandle,m_gChannelMask);
if (Statut!=VSUCCESS)
{
char Buffer[256];
sprintf(Buffer,"tcCanVector::tcCanVector> Channel deactivation failed (%04X)",Statut);
SetMsg(cErrorMsg,Buffer);
return cFalse;
}
// Change Baudrate
Statut = ncdSetChannelBitrate(m_gPortHandle,m_gChannelMask,(U32)Param);
if (Statut!=VSUCCESS)
{
char Buffer[256];
sprintf(Buffer,"tcCanVector::tcCanVector> Baudrate configuration failed (%04X)",Statut);
SetMsg(cErrorMsg,Buffer);
return cFalse;
}
// Activate channel
Statut = ncdActivateChannel(m_gPortHandle,m_gChannelMask);
if (Statut!=VSUCCESS)
{
char Buffer[256];
sprintf(Buffer,"tcCanVector::tcCanVector> Channel activation failed (%04X)",Statut);
SetMsg(cErrorMsg,Buffer);
return cFalse;
}
m_CanCardMutex.Unlock();
ReturnValue = cTrue;
}
else if (CanControl == cCanAckControl)
{
m_CanCardMutex.Lock();
// Deactivate channel
Statut = ncdDeactivateChannel(m_gPortHandle,m_gChannelMask);
if (Statut!=VSUCCESS)
{
char Buffer[256];
sprintf(Buffer,"tcCanVector::tcCanVector> Channel deactivation failed (%04X)",Statut);
SetMsg(cErrorMsg,Buffer);
return cFalse;
}
// Change Ack
Statut = ncdSetChannelOutput(m_gPortHandle,m_gChannelMask,(((U32)Param==0)?OUTPUT_MODE_SILENT:OUTPUT_MODE_NORMAL));
if (Statut!=VSUCCESS)
{
char Buffer[256];
sprintf(Buffer,"tcCanVector::tcCanVector> Baudrate configuration failed (%04X)",Statut);
SetMsg(cErrorMsg,Buffer);
return cFalse;
}
// Activate channel
Statut = ncdActivateChannel(m_gPortHandle,m_gChannelMask);
if (Statut!=VSUCCESS)
{
char Buffer[256];
sprintf(Buffer,"tcCanVector::tcCanVector> Channel activation failed (%04X)",Statut);
SetMsg(cErrorMsg,Buffer);
return cFalse;
}
m_CanCardMutex.Unlock();
ReturnValue = cTrue;
}
return ReturnValue;
}
INT_PTR CGeneralMsgBox::AfxMessageBox(UINT uiIDPrompt, UINT uiFlags)
{
SetMsg(uiIDPrompt);
INT_PTR rc = MessageBox(NULL, AfxGetApp()->m_pszAppName, uiFlags);
return rc;
}
INT_PTR CGeneralMsgBox::MessageBox(LPCWSTR lpText, LPCWSTR lpCaption,
UINT uiFlags)
{
// Private member
UINT uiType = uiFlags & MB_TYPEMASK;
UINT uiIcon = uiFlags & MB_ICONMASK;
int iDefB = ((int)uiFlags & MB_DEFMASK) / 256;
if (lpText != NULL)
SetMsg(lpText);
if (lpCaption != NULL)
SetTitle(lpCaption);
else
SetTitle(IDS_ERROR);
if (uiIcon == 0)
uiIcon = MB_ICONEXCLAMATION;
SetStandardIcon(uiIcon);
int num_buttons(0);
int ButtonCmdIDs[3];
int ButtonCmdTexts[3];
switch (uiType) {
case MB_OK:
num_buttons = 1;
ButtonCmdIDs[0] = IDOK;
ButtonCmdTexts[0] = IDS_OK;
break;
case MB_OKCANCEL:
num_buttons = 2;
ButtonCmdIDs[0] = IDOK;
ButtonCmdIDs[1] = IDCANCEL;
ButtonCmdTexts[0] = IDS_OK;
ButtonCmdTexts[1] = IDS_CANCEL;
m_uiEscCmdId = IDCANCEL;
break;
case MB_ABORTRETRYIGNORE:
num_buttons = 3;
ButtonCmdIDs[0] = IDABORT;
ButtonCmdIDs[1] = IDRETRY;
ButtonCmdIDs[2] = IDIGNORE;
ButtonCmdTexts[0] = IDS_ABORT;
ButtonCmdTexts[1] = IDS_RETRY;
ButtonCmdTexts[2] = IDS_IGNORE;
break;
case MB_YESNOCANCEL:
num_buttons = 3;
ButtonCmdIDs[0] = IDYES;
ButtonCmdIDs[1] = IDNO;
ButtonCmdIDs[2] = IDCANCEL;
ButtonCmdTexts[0] = IDS_YES;
ButtonCmdTexts[1] = IDS_NO;
ButtonCmdTexts[2] = IDS_CANCEL;
m_uiEscCmdId = IDCANCEL;
break;
case MB_YESNO:
num_buttons = 2;
ButtonCmdIDs[0] = IDYES;
ButtonCmdIDs[1] = IDNO;
ButtonCmdTexts[0] = IDS_YES;
ButtonCmdTexts[1] = IDS_NO;
break;
case MB_RETRYCANCEL:
num_buttons = 2;
ButtonCmdIDs[0] = IDRETRY;
ButtonCmdIDs[1] = IDCANCEL;
ButtonCmdTexts[0] = IDS_RETRY;
ButtonCmdTexts[1] = IDS_CANCEL;
m_uiEscCmdId = IDCANCEL;
break;
case MB_CANCELTRYCONTINUE:
num_buttons = 3;
ButtonCmdIDs[0] = IDCANCEL;
ButtonCmdIDs[1] = IDTRYAGAIN;
ButtonCmdIDs[2] = IDCONTINUE;
ButtonCmdTexts[0] = IDS_CANCEL;
ButtonCmdTexts[1] = IDS_TRYAGAIN;
ButtonCmdTexts[2] = IDS_CONTINUE;
m_uiEscCmdId = IDCANCEL;
break;
default:
ASSERT(0);
}
if (iDefB > (num_buttons - 1))
iDefB = 0;
CString cs_text;
for (int n = 0; n < num_buttons; n++) {
cs_text.LoadString(ButtonCmdTexts[n]);
AddButton(ButtonCmdIDs[n], cs_text, n == iDefB ? TRUE : FALSE);
}
INT_PTR rc = DoModal();
return rc;
}
void CClientSocket::OnReceive(int nErrorCode)
{
// TODO: 在此添加专用代码和/或调用基类
HEADER head; //定义客户端发送的过来的一样的结构体
int nlen = sizeof HEADER; //计算结构体大小
char *pHead = NULL; //用于接受的结构体
pHead = new char[nlen]; //申请和结构体一样大小的内存空间
if(!pHead)
{
TRACE0("CClientSocket::OnReceive 内存不足！");
return;
}
memset(pHead,0, sizeof(char)*nlen ); //初始化
Receive(pHead,nlen); //收到内容，并赋值到pHead中，指定接受的空间大小
//以下是将接收大结构体进行强制转换成我们的结构体，
head.type = ((LPHEADER)pHead)->type;
head.SendLen = ((LPHEADER)pHead)->SendLen;
//head.to_user 是char[]类型，如果不进行初始化，可能会有乱码出现
memset(head.to,0,sizeof(head.to));
//讲接受的数据转换过后并赋值到head.to_user，以下同
strcpy(head.to,((LPHEADER)pHead)->to);
memset(head.from,0,sizeof(head.from));
strcpy(head.from,((LPHEADER)pHead)->from);
memset(head.beizhu,0,sizeof(head.beizhu));
strcpy(head.beizhu,((LPHEADER)pHead)->beizhu);
delete pHead; //使用完毕，指针变量的清除
pHead = NULL;
//接受正式数据内容
char* tHead = NULL;
tHead = new char[head.SendLen+1];
memset(tHead,0,sizeof(char)*(head.SendLen+1));
if(!tHead)
{
TRACE0("CClientSocket::OnRecive 内存不足！");
return;
}
if( Receive(tHead, head.SendLen)!=head.SendLen)
{
AfxMessageBox(_T("接收数据有误！"));
delete pHead;
return;
}
//根据消息类型，处理数据
switch(head.type)
{
case MSG_LOGOIN: //登陆消息
Logoin(tHead, head.SendLen,head.from,head.beizhu);
break;
case MSG_SEND: //发送消息
MSGTranslate(tHead, head.SendLen,head.to,head.from,head.beizhu);
break;
case MSG_REGIST:
Register(pHead, head.SendLen,head.from,head.beizhu);
break;
case MSG_MUPDATE:
SetMsg(pHead, head.SendLen,head.to,head.from,head.beizhu);
break;
default : break;
}
delete pHead;
CSocket::OnReceive(nErrorCode);
}
ModelIterator3Helper& operator ++() {
cntr++;
SetMsg();
return *this;
}
// Yes, you can use LoadImage too, but that creates a device
// dependent bitmap and you want to stay the fsck away from those.
bool CBmpFile::Load(const char *fpath)
{
FILE *fp= fopen(fpath, "rb");
CLDIB *dib= NULL;
try
{
if(!fp)
throw CImgFile::sMsgs[ERR_NO_FILE];
BITMAPFILEHEADER bmfh;
fread(&bmfh, sizeof(BITMAPFILEHEADER), 1,fp);
// Whoa, not a bitmap, back off
if(bmfh.bfType != BMP_TYPE) // 4D42h = "BM".
throw CImgFile::sMsgs[ERR_FORMAT];
BITMAPINFOHEADER bmih;
bool bCore;
// check for bm version first :(
fread(&bmih, 4, 1, fp);
if(bmih.biSize == sizeof(BITMAPCOREHEADER)) // crap! v2.x BMP
{
bCore= true;
bmih.biSize= BMIH_SIZE;
WORD wd;
fread(&wd, 2,1,fp);
bmih.biWidth= wd;
fread(&wd, 2,1,fp);
bmih.biHeight= wd;
fread(&bmih.biPlanes, 2,1,fp);
fread(&bmih.biBitCount, 2,1,fp);
memset(&bmih.biCompression, 0,
BMIH_SIZE-sizeof(BITMAPCOREHEADER));
}
else // normal v3.0 BMP
fread(&bmih.biWidth, BMIH_SIZE-4, 1, fp);
if(bmih.biPlanes > 1) // no color planes, plz
throw sMsgs[ERR_BMP_PLANES];
if(bmih.biCompression != BI_RGB) // no compression either
throw sMsgs[ERR_BMP_CPRS];
int dibP, dibHa, dibS;
dibHa= abs(bmih.biHeight);
dibP= dib_align(bmih.biWidth, bmih.biBitCount);
dibS= dibP*dibHa;
// set manually, just to be sure
bmih.biSizeImage= dibS;
// ditto for ClrUsed
if(bmih.biBitCount <=8 && bmih.biClrUsed == 0)
bmih.biClrUsed= 1<<bmih.biBitCount;
// now we set-up the full bitmap
dib= dib_alloc(bmih.biWidth, dibHa, bmih.biBitCount, NULL, true);
if(dib == NULL)
throw CImgFile::sMsgs[ERR_ALLOC];
// read the palette
fread(dib_get_pal(dib), RGB_SIZE, bmih.biClrUsed, fp);
// read image
fread(dib_get_img(dib), dibS, 1, fp);
if(bmih.biHeight>=0) // -> TD image
dib_vflip(dib);
} // </try>
catch(const char *msg)
{
SetMsg(msg);
dib_free(dib);
dib= NULL;
}
if(fp)
fclose(fp);
if(!dib)
return false;
// if we're here we've succeeded
SetMsg(CImgFile::sMsgs[ERR_NONE]);
dib_free(Attach(dib));
SetBpp(dib_get_bpp(dib));
SetPath(fpath);
return true;
}
/*-----------------------------------------------------------------------------
* Verarbeitung der Bustelegramme
*/
static void ProcessBus(UINT8 ret) {
TBusMsgType msgType;
UINT16 *pData;
UINT16 wordAddr;
BOOL rc;
BOOL msgForMe = FALSE;
if (ret == BUS_MSG_OK) {
msgType = spRxBusMsg->type;
switch (msgType) {
case eBusDevReqReboot:
case eBusDevReqUpdEnter:
case eBusDevReqUpdData:
case eBusDevReqUpdTerm:
if (spRxBusMsg->msg.devBus.receiverAddr == MY_ADDR) {
msgForMe = TRUE;
}
default:
break;
}
if (msgForMe == FALSE) {
return;
}
if (msgType == eBusDevReqReboot) {
/* Über Watchdog Reset auslösen */
/* Watchdogtimeout auf kurzeste Zeit (14 ms) stellen */
cli();
wdt_enable(WDTO_15MS);
/* warten auf Reset */
while (1);
} else {
switch (sFwuState) {
case WAIT_FOR_UPD_ENTER_TIMEOUT:
case WAIT_FOR_UPD_ENTER:
if (msgType == eBusDevReqUpdEnter) {
/* Applicationbereich des Flash löschen */
FlashErase();
/* Antwort senden */
SetMsg(eBusDevRespUpdEnter, spRxBusMsg->senderAddr);
BusSend(&sTxBusMsg);
sFwuState = WAIT_FOR_UPD_DATA;
}
break;
case WAIT_FOR_UPD_DATA:
if (msgType == eBusDevReqUpdData) {
wordAddr = spRxBusMsg->msg.devBus.x.devReq.updData.wordAddr;
pData = spRxBusMsg->msg.devBus.x.devReq.updData.data;
/* Flash programmieren */
rc = FlashProgram(wordAddr, pData, sizeof(spRxBusMsg->msg.devBus.x.devReq.updData.data) / 2);
/* Antwort senden */
SetMsg(eBusDevRespUpdData, spRxBusMsg->senderAddr);
if (rc == TRUE) {
/* Falls Programmierung des Block OK: empfangene wordAddr zurücksenden */
sTxBusMsg.msg.devBus.x.devResp.updData.wordAddr = wordAddr;
} else {
/* Problem bei Programmierung: -1 als wordAddr zurücksenden */
sTxBusMsg.msg.devBus.x.devResp.updData.wordAddr = -1;
}
BusSend(&sTxBusMsg);
} else if (msgType == eBusDevReqUpdTerm) {
/* programmiervorgang im Flash abschließen (falls erforderlich) */
rc = FlashProgramTerminate();
/* Antwort senden */
SetMsg(eBusDevRespUpdTerm, spRxBusMsg->senderAddr);
if (rc == TRUE) {
/* Falls Programmierung OK: success auf 1 setzen */
sTxBusMsg.msg.devBus.x.devResp.updTerm.success = 1;
} else {
/* Problem bei Programmierung: -1 als wordAddr zurücksenden */
sTxBusMsg.msg.devBus.x.devResp.updTerm.success = 0;
}
BusSend(&sTxBusMsg);
}
break;
default:
break;
}
}
}
}
