void UdpData(U8_T type)
{
// header 2 bytes
memset(&Scan_Infor,0,sizeof(STR_SCAN_CMD));
if(type == 0)
Scan_Infor.cmd = 0x6500;
else if(type == 1)
Scan_Infor.cmd = 0x6700;
Scan_Infor.len = 0x1D00;
//serialnumber 4 bytes
Scan_Infor.own_sn[0] = (U16_T)Modbus.serialNum[0] << 8;
Scan_Infor.own_sn[1] = (U16_T)Modbus.serialNum[1] << 8;
Scan_Infor.own_sn[2] = (U16_T)Modbus.serialNum[2] << 8;
Scan_Infor.own_sn[3] = (U16_T)Modbus.serialNum[3] << 8;
//nc
if(Modbus.mini_type == MINI_CM5)
Scan_Infor.product = (U16_T)PRODUCT_CM5 << 8;
else
Scan_Infor.product = (U16_T)PRODUCT_MINI_BIG << 8;
//modbus address
Scan_Infor.address = (U16_T)Modbus.address << 8;
//Ip
Scan_Infor.ipaddr[0] = (U16_T)Modbus.ip_addr[0] << 8;
Scan_Infor.ipaddr[1] = (U16_T)Modbus.ip_addr[1] << 8;
Scan_Infor.ipaddr[2] = (U16_T)Modbus.ip_addr[2] << 8;
Scan_Infor.ipaddr[3] = (U16_T)Modbus.ip_addr[3] << 8;
//port
Scan_Infor.modbus_port = swap_word(Modbus.tcp_port);
// software rev
Scan_Infor.firmwarerev = swap_word(SW_REV / 10 + SW_REV % 10);
// hardware rev
Scan_Infor.hardwarerev = swap_word(Modbus.hardRev);
Scan_Infor.instance_low = (U16_T)(Instance); // hight byte first
Scan_Infor.panel_number = panel_number; // 36
Scan_Infor.instance_hi = (U16_T)(Instance >> 16); // hight byte first
Scan_Infor.bootloader = 0; // 0 - app, 1 - bootloader, 2 - wrong bootloader
Scan_Infor.BAC_port = Modbus.Bip_port; //
Scan_Infor.zigbee_exist = zigbee_exist; // 0 - inexsit, 1 - exist
state = 1;
scanstart = 0;
}
FileHeader *get_file_header( FILE *in )
/*
** Creates a FileHeader structure and fills it with data beginning at the
** current file location in 'in'. Obviously, it's best if you've already
** advanced to where a FileHeader is stored in the file. If an error
** occurs, NULL is returned.
*/
{
FileHeader *fileHdr;
if( fileHdr = (FileHeader *)malloc( FileHdrSize ) )
{
if( FileHdrSize == fread( (void *)fileHdr, sizeof( ubyte ),
FileHdrSize, in ) || ask( "Read error on file header" ) )
{
CheckSum crc;
crc = calc_crc( (ubyte *)fileHdr,
FileHdrSize - sizeof( CheckSum ), INIT_CRC );
#ifdef SWAP
/* We MUST calculate the checksum BEFORE we swab the data! */
swap_long( (ulong *)&fileHdr->fType );
swap_long( (ulong *)&fileHdr->fCreator );
swap_word( (uword *)&fileHdr->FndrFlags );
swap_long( &fileHdr->creationDate );
swap_long( &fileHdr->modDate );
swap_long( &fileHdr->rsrcLength );
swap_long( &fileHdr->dataLength );
swap_long( &fileHdr->compRLength );
swap_long( &fileHdr->compDLength );
swap_word( &fileHdr->rsrcCRC );
swap_word( &fileHdr->dataCRC );
swap_word( &fileHdr->hdrCRC );
#endif
if( crc == fileHdr->hdrCRC ||
ask( "Bad checksum on file header" ) )
{
ubyte len = (ubyte)*(fileHdr->fName);
/* Convert the Pascal-style name string to C-style */
memmove( fileHdr->fName, fileHdr->fName + 1, len );
*(fileHdr->fName + len) = '\0';
return( fileHdr );
}
}
free( fileHdr );
}
else
clean_exit( "Out of memory!" );
return( NULL );
}
void near CTIFFInfo::SwapData(TIFF_DATA* pData, SHORT nType)
{
if (m_Info.byte_order != BYTE_ORDER_IBM)
{
switch (nType)
{
case TIFF_SHORT:
{
swap_word((LPWORD)&pData->Short);
break;
}
case TIFF_LONG:
{
swap_long(&pData->Long);
break;
}
case TIFF_RATIONAL:
{
swap_long(&pData->Rational.numerator);
swap_long(&pData->Rational.denominator);
break;
}
default:
{
break;
}
}
}
}
static void near
swap_dword(DWORD* l)
{
#ifdef _WIN32
WORD tmp = ((WORD*)l)[0];
((WORD*)l)[0] = ((WORD*)l)[1];
((WORD*)l)[1] = tmp;
swap_word(((WORD *)l)+0);
swap_word(((WORD *)l)+1);
#else
_asm
{
les bx, dword ptr l
mov ax, es:[bx+0]
mov dx, es:[bx+2]
xchg ah, al
xchg dh, dl
mov es:[bx+2], ax
mov es:[bx+0], dx
}
#endif
}
ERRORCODE PSDHelper::SeekImageResource(StorageDevice* pFile, WORD wSearchID, DWORD& dwDataSize)
{
ERRORCODE error;
// Seek to the start of the image resources section.
ST_DEV_POSITION lPos = m_Record.m_lImageResourcesSection;
ST_DEV_POSITION lEnd = m_Record.m_lLayerMaskSection-4;
// Swap the word to look for. This is better than swapping everything else.
swap_word(&wSearchID);
while (lPos < lEnd)
{
// Seek to the current resource.
if ((error = pFile->seek(lPos, ST_DEV_SEEK_SET)) != ERRORCODE_None)
{
break;
}
DWORD dwType;
WORD wID;
CString csName;
if ((error = pFile->read(&dwType, sizeof(dwType))) != ERRORCODE_None
|| (error = pFile->read(&wID, sizeof(wID))) != ERRORCODE_None
|| (error = ReadPString(pFile, csName)) != ERRORCODE_None
|| (error = pFile->read(&dwDataSize, sizeof(dwDataSize))) != ERRORCODE_None)
{
// Got an error. Break out now.
break;
}
swap_dword(&dwDataSize);
// We have the data. See if it's the one we're looking for.
if (wID == wSearchID)
{
// Found it!
break;
}
pFile->tell(&lPos);
lPos += dwDataSize;
if (dwDataSize & 1)
{
lPos++;
}
}
return (lPos >= lEnd) ? ERRORCODE_DoesNotExist : error;
}
SitHeader *get_sit_header( FILE *in )
/*
** This function creates a SitHeader structure and initializes it with the
** data stored at the beginning of the file 'in'. If an error occurs, this
** routine returns NULL.
*/
{
SitHeader *sitHdr;
fseek( in, InfoSize, SEEK_SET );
if( sitHdr = (SitHeader *)malloc( SitHdrSize ) )
{
if( SitHdrSize == fread( (void *)sitHdr, sizeof( byte ),
SitHdrSize, in ) || ask( "Read error on SIT header" ) )
{
#ifdef SWAP
swap_long( (ulong *)&sitHdr->signature );
swap_word( &sitHdr->numFiles );
swap_long( &sitHdr->arcLength );
swap_long( (ulong *)&sitHdr->signature2 );
#endif
/*
** Verify the signature and version of this file's SitHeader.
** If not version 1, we may not be able to decompress this
** archive.
*/
if( sitHdr->signature == 0x53495421 &&
sitHdr->signature2 == 0x724c6175 )
{
if( sitHdr->version <= SIT_VERSION ||
ask( "This archive wasn't created with StuffIt version 1" ) )
return( sitHdr );
}
else
clean_exit( "This file is not a StuffIt archive" );
}
free( sitHdr );
}
else
clean_exit( "Out of memory!" );
return( NULL );
}
void process_xif_ifd(IFD_Type *ifd_ptr, TIFF_Hdr_Type *tiff_hdr, unsigned short segment_size, unsigned char *endofsegment_ptr) {
int i;
unsigned short entry_count;
unsigned short tag;
unsigned short type;
unsigned count;
unsigned value;
unsigned int remaining_size;
remaining_size = endofsegment_ptr - (unsigned char *)ifd_ptr;
if (remaining_size > segment_size)
_terminate(-1);
entry_count=swap_short(ifd_ptr->Count);
if (entry_count *12 + sizeof(entry_count) > remaining_size) {
printf("Invalid IFD count value\n");
_terminate(-1);
}
printf("# of arrays: @d\n", entry_count);
for (i=0; i< entry_count; ++i) {
tag = swap_short(ifd_ptr->Entry[i].Tag);
type = swap_short(ifd_ptr->Entry[i].Type);
count = swap_word(ifd_ptr->Entry[i].Count);
value = swap_word(ifd_ptr->Entry[i].Value);
printf("Tag: @x (", tag);
print_xif_tag_text(tag);
printf(")\n");
printf("Type: @x (", type);
print_type(type);
printf(")\n");
printf("Count: @d\n", count);
#ifdef PATCHED
if (type==2) {
if ( ((char *)ifd_ptr+value > (char *)tiff_hdr+segment_size) ||
((char *)ifd_ptr+value < (char *)ifd_ptr ))
{
printf("Value: 0\n");
return;
}
}
#endif
if (type == 2) {
#ifdef PATCHED
if ( strlen( (char*)(ifd_ptr) + value ) > 2048 ) {
((char*)(ifd_ptr))[value+2048] = '\x00';
}
#endif
printf("Value: @s\n", (char *)(ifd_ptr) + value);
}
else {
printf("Value: @u\n", value);
}
}
}
ERRORCODE PSDHelper::init(GRAPHIC_CREATE_STRUCT_PTR gcs)
{
ERRORCODE error = ERRORCODE_None;
/* We need a file to read. */
StorageDevicePtr pSource;
ReadOnlyFile file;
if (gcs == NULL || (pSource = gcs->pSourceDevice) == NULL)
{
/* Go directly to disk. */
file.set_name(graphic->m_csFileName);
file.set_read_buffer(4096);
pSource = &file;
}
/* Read the header. */
PSDHeader Header;
TRY
{
if ((error = pSource->read(&Header, sizeof(Header))) != ERRORCODE_None)
{
ThrowErrorcodeException(error);
}
// Swap everything.
swap_word(&Header.m_wChannels);
swap_dword(&Header.m_dwRows);
swap_dword(&Header.m_dwColumns);
swap_word(&Header.m_wDepth);
swap_word(&Header.m_wMode);
// Validate that we support this number of channels.
if (Header.m_wChannels > MAX_CHANNELS)
{
ThrowErrorcodeException(ERRORCODE_IllegalType);
}
// Fill out the header.
graphic->record.x_size = (USHORT)Header.m_dwColumns;
graphic->record.y_size = (USHORT)Header.m_dwRows;
graphic->record.x_resolution = 200; // Default for now...
graphic->record.y_resolution = 200; // ...read later
graphic->record.storage = GRAPHIC_STORAGE_FILE;
// Fill out our info.
m_Record.m_wChannels = Header.m_wChannels;
m_Record.m_wDepth = Header.m_wDepth;
m_Record.m_wMode = Header.m_wMode;
// Initialize the start of line variables.
#if 0
for (int i = 0; i < 9; i++)
{
m_Record.m_Lines[i].line = MulDiv((int)Header.m_dwRows, i, 8);
m_Record.m_Lines[i].offset = 0L;
}
#endif
DWORD dwSize;
//
// Process the color mode data section.
//
// Read the section size.
if ((error = pSource->read(&dwSize, sizeof(dwSize))) != ERRORCODE_None)
{
ThrowErrorcodeException(error);
}
swap_dword(&dwSize);
pSource->tell(&m_Record.m_lColorDataSection);
// Skip to the next section.
pSource->seek(m_Record.m_lColorDataSection + (ST_DEV_POSITION)dwSize, ST_DEV_SEEK_SET);
//
// Process the image resources section.
//
// Read the section size.
if ((error = pSource->read(&dwSize, sizeof(dwSize))) != ERRORCODE_None)
{
ThrowErrorcodeException(error);
}
swap_dword(&dwSize);
pSource->tell(&m_Record.m_lImageResourcesSection);
// Skip to the next section.
pSource->seek(m_Record.m_lImageResourcesSection + (ST_DEV_POSITION)dwSize, ST_DEV_SEEK_SET);
//
// Process the layer and mask section.
//
// Read the section size.
if ((error = pSource->read(&dwSize, sizeof(dwSize))) != ERRORCODE_None)
{
ThrowErrorcodeException(error);
}
swap_dword(&dwSize);
pSource->tell(&m_Record.m_lLayerMaskSection);
//
// Read the image resources we care about.
//
// Read the resolution information.
ReadResolution(pSource);
// Skip to the next section.
pSource->seek(m_Record.m_lLayerMaskSection + (ST_DEV_POSITION)dwSize, ST_DEV_SEEK_SET);
//
// Process the image data section.
//
pSource->tell(&m_Record.m_lImageDataSection);
// Read the compression value.
if ((error = pSource->read(&m_Record.m_wCompression, sizeof(m_Record.m_wCompression))) != ERRORCODE_None)
{
ThrowErrorcodeException(error);
}
//
// Compute the sizes of all data channels.
//
if (m_Record.m_wCompression)
{
//
// Compression requires special handling.
//
// We are compressed; read the compression counts.
LPWORD pCounts = NULL; // Needs to be NULL at start.
if ((error = ReadCompressionCounts(pSource, pCounts)) != ERRORCODE_None)
{
ThrowErrorcodeException(error);
}
// Run through all channels and compute compressed sizes.
LPWORD p = pCounts;
int nRows = graphic->record.y_size;
for (WORD wChannel = 0; wChannel < m_Record.m_wChannels; wChannel++)
{
// Compute the size of this channel.
long lChannelSize = 0;
for (int nRow = 0; nRow < nRows; nRow++)
{
lChannelSize += *p++;
}
// Save the channel size in the record.
m_Record.m_lChannelSizes[wChannel] = lChannelSize;
}
// Free the count data.
GlobalFreePtr(pCounts);
}
else
{
//
// Not compressed. All channels are the same size.
//
DWORD dwChannelSize = Header.m_dwColumns * Header.m_dwRows;
// Set them all to the same size.
for (WORD wChannel = 0; wChannel < m_Record.m_wChannels; wChannel++)
{
m_Record.m_lChannelSizes[wChannel] = (long)dwChannelSize;
}
}
}
CATCH(CErrorcodeException, e)
{
error = e->m_error;
}
AND_CATCH_ALL(e)
{
error = ERRORCODE_IntError;
}
END_CATCH_ALL
return error;
}
/*----------------------------------------------------------------------------*\
\*----------------------------------------------------------------------------*/
static pwr_tStatus IoCardWrite (
io_tCtx ctx,
io_sAgent *ap,
io_sRack *rp,
io_sCard *cp
)
{
io_sLocal *local;
pwr_sClass_Ssab_PIDuP *op;
int ii;
int sts;
pwr_tTime now;
unsigned short diff;
card_dyn c_dyn;
card_par c_par;
int paramc = 0;
int dynparc = 0;
unsigned short *datap;
local = (io_sLocal *) cp->Local;
op = (pwr_sClass_Ssab_PIDuP *) cp->op;
if (!local->Valid) return 1;
diff = local->Istat[0] ^ local->Istat[1];
if (diff & setup_req_mask) paramc = 1, dynparc = 1;
/* Check if static parameters has changed */
if ((local->objP->PidAlg != local->Par.PidAlg) ||
(local->objP->Inverse != local->Par.Inverse) ||
(local->objP->PidGain != local->Par.PidGain) ||
(local->objP->IntTime != local->Par.IntTime) ||
(local->objP->DerTime != local->Par.DerTime) ||
(local->objP->DerGain != local->Par.DerGain) ||
(local->objP->BiasGain != local->Par.BiasGain) ||
(local->objP->MinOut != local->Par.MinOut) ||
(local->objP->MaxOut != local->Par.MaxOut) ||
(local->objP->EndHys != local->Par.EndHys) ||
(local->objP->ProcFiltTime != local->Par.ProcFiltTime) ||
(local->objP->ProcMax != local->ProcRange.Max) ||
(local->objP->ProcMin != local->ProcRange.Min) ||
(local->objP->AoMax != local->AoRange.Max) ||
(local->objP->AoMin != local->AoRange.Min) ||
(local->Par.inc3pGain != local->objP->Inc3pGain) ||
(local->Par.MinTim != local->objP->MinTim) ||
(local->Par.MaxTim != local->objP->MaxTim) ||
(local->Par.MaxInteg != local->objP->MaxInteg)) paramc = 1;
/* Check if dynamic parameters has changed */
if ((local->objP->SetVal != local->Dyn.SetVal) ||
(local->objP->Bias != local->Dyn.BiasD) ||
(local->objP->ForcVal != local->Dyn.ForcVal) ||
(local->objP->IntOff != local->Dyn.IntOff) ||
(local->objP->Force != local->Dyn.Force)) dynparc = 1;
/* Move parameters to local */
if (paramc && ((diff & setup_mask) == 0)) {
local->Par.inc3pGain = local->objP->Inc3pGain;
local->Par.MinTim = local->objP->MinTim;
local->Par.MaxTim = local->objP->MaxTim;
local->Par.MaxInteg = local->objP->MaxInteg;
local->ProcRange.Max = local->objP->ProcMax;
local->ProcRange.Min = local->objP->ProcMin;
local->ProcRange.RawMax = local->objP->ProcRawMax;
local->ProcRange.RawMin = local->objP->ProcRawMin;
if (local->ProcRange.RawMax != local->ProcRange.RawMin) {
local->Par.AVcoeff[0] = (local->ProcRange.Max - local->ProcRange.Min) /
(local->ProcRange.RawMax - local->ProcRange.RawMin);
local->Par.AVcoeff[1] = local->ProcRange.Min -
local->ProcRange.RawMin * local->Par.AVcoeff[0];
}
local->BiasRange.Max = local->objP->BiasMax;
local->BiasRange.Min = local->objP->BiasMin;
local->BiasRange.RawMax = local->objP->BiasRawMax;
local->BiasRange.RawMin = local->objP->BiasRawMin;
if (local->BiasRange.RawMax != local->BiasRange.RawMin) {
local->Par.BVcoeff[0] = (local->BiasRange.Max - local->BiasRange.Min) /
(local->BiasRange.RawMax - local->BiasRange.RawMin);
local->Par.BVcoeff[1] = local->BiasRange.Min -
local->BiasRange.RawMin * local->Par.BVcoeff[0];
}
local->AoRange.Max = local->objP->AoMax;
local->AoRange.Min = local->objP->AoMin;
local->AoRange.RawMax = local->objP->AoRawMax;
local->AoRange.RawMin = local->objP->AoRawMin;
if (local->AoRange.Max != local->AoRange.Min)
{
local->Par.OVcoeff[0] = (local->AoRange.RawMax - local->AoRange.RawMin) /
(local->AoRange.Max - local->AoRange.Min);
local->Par.OVcoeff[1] = local->AoRange.RawMin -
local->AoRange.Min * local->Par.OVcoeff[0];
}
local->PosRange.Max = local->objP->PosMax;
local->PosRange.Min = local->objP->PosMin;
local->PosRange.RawMax = local->objP->PosRawMax;
local->PosRange.RawMin = local->objP->PosRawMin;
if (local->PosRange.RawMax != local->PosRange.RawMin) {
local->Par.PVcoeff[0] = (local->PosRange.Max - local->PosRange.Min) /
(local->PosRange.RawMax - local->PosRange.RawMin);
local->Par.PVcoeff[1] = local->PosRange.Min -
local->PosRange.RawMin * local->Par.PVcoeff[0];
}
local->Par.PidAlg = local->objP->PidAlg;
local->Par.Inverse = local->objP->Inverse;
local->Par.PidGain = local->objP->PidGain;
local->Par.IntTime = local->objP->IntTime;
local->Par.DerTime = local->objP->DerTime;
local->Par.DerGain = local->objP->DerGain;
local->Par.BiasGain = local->objP->BiasGain;
local->Par.MinOut = local->objP->MinOut;
local->Par.MaxOut = local->objP->MaxOut;
local->Par.EndHys = local->objP->EndHys;
local->Par.ErrSta = local->objP->ErrSta;
local->Par.ErrSto = local->objP->ErrSto;
local->Par.pos3pGain = local->objP->Pos3pGain;
local->Par.ProcFiltTime = local->objP->ProcFiltTime;
local->Par.BiasFiltTime = local->objP->BiasFiltTime;
local->Par.PosFiltTime = local->objP->PosFiltTime;
/* Write parameters to card */
c_par.PidAlg = local->Par.PidAlg;
c_par.Inverse = local->Par.Inverse;
swap_word((unsigned int *) &c_par.inc3pGain, (unsigned int *) &local->Par.inc3pGain);
swap_word((unsigned int *) &c_par.MinTim, (unsigned int *) &local->Par.MinTim);
swap_word((unsigned int *) &c_par.MaxTim, (unsigned int *) &local->Par.MaxTim);
swap_word((unsigned int *) &c_par.MaxInteg, (unsigned int *) &local->Par.MaxInteg);
swap_word((unsigned int *) &c_par.AVcoeff[0], (unsigned int *) &local->Par.AVcoeff[0]);
swap_word((unsigned int *) &c_par.AVcoeff[1], (unsigned int *) &local->Par.AVcoeff[1]);
swap_word((unsigned int *) &c_par.BVcoeff[0], (unsigned int *) &local->Par.BVcoeff[0]);
swap_word((unsigned int *) &c_par.BVcoeff[1], (unsigned int *) &local->Par.BVcoeff[1]);
swap_word((unsigned int *) &c_par.OVcoeff[0], (unsigned int *) &local->Par.OVcoeff[0]);
swap_word((unsigned int *) &c_par.OVcoeff[1], (unsigned int *) &local->Par.OVcoeff[1]);
swap_word((unsigned int *) &c_par.PidGain, (unsigned int *) &local->Par.PidGain);
swap_word((unsigned int *) &c_par.IntTime, (unsigned int *) &local->Par.IntTime);
swap_word((unsigned int *) &c_par.DerTime, (unsigned int *) &local->Par.DerTime);
swap_word((unsigned int *) &c_par.DerGain, (unsigned int *) &local->Par.DerGain);
swap_word((unsigned int *) &c_par.BiasGain, (unsigned int *) &local->Par.BiasGain);
swap_word((unsigned int *) &c_par.MinOut, (unsigned int *) &local->Par.MinOut);
swap_word((unsigned int *) &c_par.MaxOut, (unsigned int *) &local->Par.MaxOut);
swap_word((unsigned int *) &c_par.EndHys, (unsigned int *) &local->Par.EndHys);
swap_word((unsigned int *) &c_par.PVcoeff[0], (unsigned int *) &local->Par.PVcoeff[0]);
swap_word((unsigned int *) &c_par.PVcoeff[1], (unsigned int *) &local->Par.PVcoeff[1]);
swap_word((unsigned int *) &c_par.ErrSta, (unsigned int *) &local->Par.ErrSta);
swap_word((unsigned int *) &c_par.ErrSto, (unsigned int *) &local->Par.ErrSto);
swap_word((unsigned int *) &c_par.pos3pGain, (unsigned int *) &local->Par.pos3pGain);
swap_word((unsigned int *) &c_par.ProcFiltTime, (unsigned int *) &local->Par.ProcFiltTime);
swap_word((unsigned int *) &c_par.BiasFiltTime, (unsigned int *) &local->Par.BiasFiltTime);
swap_word((unsigned int *) &c_par.PosFiltTime, (unsigned int *) &local->Par.PosFiltTime);
for (ii = local->par_ind, datap = (unsigned short *)&c_par; ii < local->stat_ind; ii++, datap++) {
sts = ssabpid_write(ii, datap, local);
if ( sts == -1) {
/* Increase error count and check error limits */
time_GetTime(&now);
if (op->ErrorCount > op->ErrorSoftLimit) {
/* Ignore if some time has expired */
if (now.tv_sec - local->ErrTime.tv_sec < 600)
op->ErrorCount++;
}
else
op->ErrorCount++;
local->ErrTime = now;
if ( op->ErrorCount == op->ErrorSoftLimit)
errh_Error( "IO Error soft limit reached on card '%s'", cp->Name);
continue;
}
}
/* Update status word */
if ((diff & setup_req_mask) != 0) local->Istat[0] ^= setup_req_mask;
local->Istat[0] ^= setup_mask;
} /* End - if new parameters */
/* Send dynamic parameters ? */
if (dynparc && ((diff & dyn_mask) == 0)) {
/* Move parameters to local */
local->Dyn.SetVal = local->objP->SetVal;
local->Dyn.BiasD = local->objP->Bias;
local->Dyn.ForcVal = local->objP->ForcVal;
local->Dyn.IntOff = local->objP->IntOff;
local->Dyn.Force = local->objP->Force;
/* Write parameters to card */
swap_word((unsigned int *) &c_dyn.SetVal, (unsigned int *) &local->Dyn.SetVal);
swap_word((unsigned int *) &c_dyn.BiasD, (unsigned int *) &local->Dyn.BiasD);
swap_word((unsigned int *) &c_dyn.ForcVal, (unsigned int *) &local->Dyn.ForcVal);
c_dyn.Force = local->Dyn.Force;
c_dyn.IntOff = local->Dyn.IntOff;
for (ii = local->dyn_ind, datap = (unsigned short *)&c_dyn; ii < local->par_ind; ii++, datap++) {
sts = ssabpid_write(ii, datap, local);
if ( sts == -1) {
/* Increase error count and check error limits */
time_GetTime(&now);
if (op->ErrorCount > op->ErrorSoftLimit) {
/* Ignore if some time has expired */
if (now.tv_sec - local->ErrTime.tv_sec < 600)
op->ErrorCount++;
}
else
op->ErrorCount++;
local->ErrTime = now;
if ( op->ErrorCount == op->ErrorSoftLimit)
errh_Error( "IO Error soft limit reached on card '%s'", cp->Name);
continue;
}
}
/* Update status word */
local->Istat[0] ^= dyn_mask;
} /* End if nya dyn par */
/* Update status-word */
local->Istat[0] &= typ_mask;
local->Istat[0] |= ao_mask;
if (local->objP->UseInc3p) local->Istat[0] |= inc3p_mask;
if (local->objP->UsePos3p) local->Istat[0] |= pos3p_mask;
if (local->objP->UseDynBias) local->Istat[0] |= dyn_bias_mask;
if (local->objP->UseAo) local->Istat[0] |= stall_freeze_mask;
else local->Istat[0] |= stall_cont_mask;
datap = &local->Istat[0];
sts = ssabpid_write(0, datap, local);
if ( sts == -1)
op->ErrorCount++;
if ( op->ErrorCount >= op->ErrorHardLimit)
{
errh_Error( "IO Error hard limit reached on card '%s', IO stopped", cp->Name);
ctx->Node->EmergBreakTrue = 1;
return IO__ERRDEVICE;
}
return 1;
}
/*----------------------------------------------------------------------------*\
\*----------------------------------------------------------------------------*/
static pwr_tStatus IoCardRead (
io_tCtx ctx,
io_sAgent *ap,
io_sRack *rp,
io_sCard *cp
)
{
io_sLocal *local;
pwr_sClass_Ssab_PIDuP *op;
int sts, ii;
card_stat c_stat;
unsigned short *datap;
unsigned short diff;
pwr_tTime now;
local = (io_sLocal *) cp->Local;
op = (pwr_sClass_Ssab_PIDuP *) cp->op;
sts = ssabpid_read(0, &local->Istat[0], local);
if (sts != -1) {
sts = ssabpid_read(1, &local->Istat[1], local);
}
if (sts == -1) {
op->ErrorCount++;
local->Valid = 0;
} else local->Valid = 1;
diff = local->Istat[0] ^ local->Istat[1];
memset(&c_stat, 0, sizeof(c_stat));
if (local->Valid && (diff & act_dat_mask)) {
for (ii = local->stat_ind, datap = (unsigned short *) &c_stat; ii < local->ran_ind; ii++, datap++) {
sts = ssabpid_read(ii, datap, local);
if ( sts == -1) {
/* Increase error count and check error limits */
time_GetTime(&now);
if (op->ErrorCount > op->ErrorSoftLimit) {
/* Ignore if some time has expired */
if (now.tv_sec - local->ErrTime.tv_sec < 600)
op->ErrorCount++;
}
else
op->ErrorCount++;
local->ErrTime = now;
if ( op->ErrorCount == op->ErrorSoftLimit)
errh_Error( "IO Error soft limit reached on card '%s'", cp->Name);
continue;
}
}
/* Move data to PidX-object */
swap_word((unsigned int *) &local->objP->ProcVal, (unsigned int *) &c_stat.ProcVal);
swap_word((unsigned int *) &local->objP->PosVal, (unsigned int *) &c_stat.PosVal);
swap_word((unsigned int *) &local->objP->OutVal, (unsigned int *) &c_stat.OutVal);
swap_word((unsigned int *) &local->objP->ControlDiff, (unsigned int *) &c_stat.ControlDiff);
if (local->objP->BiasGain != 0) swap_word((unsigned int *) &local->objP->Bias, (unsigned int *) &c_stat.Bias);
local->objP->EndMin = c_stat.EndMin;
local->objP->EndMax = c_stat.EndMax;
// local->objP->ScanTime = c_stat.ScanTime;
local->Istat[0] ^= act_dat_mask;
}
if ( op->ErrorCount >= op->ErrorHardLimit)
{
errh_Error( "IO Error hard limit reached on card '%s', IO stopped", cp->Name);
ctx->Node->EmergBreakTrue = 1;
return IO__ERRDEVICE;
}
return 1;
}
int main(int cgc_argc, char *cgc_argv[]) {
unsigned ret_code;
unsigned short SOM;
unsigned short marker;
unsigned short segment_size;
unsigned short tagMark;
unsigned short byte_align;
unsigned char *tiff_header;
unsigned char *xif_data;
void *tmp_ptr;
void *gps_info_ptr;
unsigned offset;
TIFF_Hdr_Type *tiff_hdr;
IFD_Type *IFD;
IFD_Type *xif_ifd_ptr;
unsigned char *endofsegment_ptr;
int i;
swap_short = 0;
swap_word = 0;
// cgc_read the first two bytes and check for the Start of Message marker
ret_code = receive_bytes((unsigned char *)&SOM, sizeof(SOM));
if (ret_code == -1 ) {
cgc_printf("did not receive bytes\n");
_terminate(-1);
}
if (SOM != 0xFFF8) {
puts("Did not find SOM marker");
_terminate(-1);
}
else {
puts("SOM marker found");
}
// Now look for the next marker, which can be SAP0 or SAP1
ret_code = receive_bytes((unsigned char *)&marker, sizeof(marker));
if (ret_code == -1 ) {
cgc_printf("did not receive bytes\n");
_terminate(-1);
}
// SAP0
if (marker == 0xFFF0) {
cgc_printf("SAP0 marker found\n");
ret_code = receive_bytes((unsigned char *)&segment_size, sizeof(segment_size));
if (ret_code == -1 ) {
cgc_printf("did not receive bytes\n");
_terminate(-1);
}
if (segment_size <=2) {
cgc_printf("Invalid segment size\n", segment_size);
_terminate(-1);
}
// now cgc_read and discard the rest of the SAP0 header
xif_data = malloc(segment_size-sizeof(segment_size));
if ((int)xif_data == 0) {
cgc_printf("Unable to allocate memory\n");
_terminate(-1);
}
// cgc_read the rest of SAP0 and discard
ret_code=receive_bytes((unsigned char *)xif_data, segment_size-sizeof(segment_size));
if (ret_code == -1) {
cgc_printf("unable to read SAP0 segment\n");
_terminate(-1);
}
free(xif_data);
xif_data = 0;
// now cgc_read the next marker, which should be SAP1
ret_code = receive_bytes((unsigned char *)&marker, sizeof(marker));
if (ret_code == -1 ) {
cgc_printf("did not receive bytes\n");
_terminate(-1);
}
} // SAP0 header
// look for the SAP1 marker now
if (marker != 0xffF1) {
cgc_printf("Did not find SAP1 marker\n");
_terminate(-1);
}
else {
cgc_printf("SAP1 marker found\n");
}
// cgc_read the length of the overall segment
ret_code = receive_bytes((unsigned char *)&segment_size, sizeof(segment_size));
if (ret_code == -1 ) {
cgc_printf("did not receive bytes\n");
_terminate(-1);
}
cgc_printf("sizeof section is @d\n", segment_size);
if (segment_size <= 0) {
cgc_printf("Invalid segment size\n");
_terminate(-1);
}
xif_data = malloc(segment_size);
if ((int)xif_data == 0) {
cgc_printf("Unable to allocate memory\n");
_terminate(-1);
}
ret_code=receive_bytes((unsigned char *)xif_data, segment_size);
if (ret_code == -1) {
cgc_printf("unable to read SAP1 segment\n");
_terminate(-1);
}
// tiff header + xif header + the count of IFD segments
if (segment_size < sizeof(TIFF_Hdr_Type) + 6 + 2) {
cgc_printf("not enough data received\n");
_terminate(-1);
}
tiff_hdr = (TIFF_Hdr_Type *)(xif_data+6);
endofsegment_ptr = (unsigned char *)xif_data + segment_size;
if (tiff_hdr->Byte_Order == 0x4949) {
cgc_printf("Intel formatted integers\n");
swap_short = intel_swap_short;
swap_word = intel_swap_word;
}
else if (tiff_hdr->Byte_Order == 0x4d4d) {
cgc_printf("Motorola formatted integers\n");
swap_short = motorola_swap_short;
swap_word = motorola_swap_word;
}
#ifdef PATCHED
else {
cgc_printf("Invalid header values\n");
_terminate(-1);
}
#endif
cgc_printf("TagMark = @x\n", swap_short(tiff_hdr->Fixed));
offset = swap_word(tiff_hdr->Offset_to_IFD);
cgc_printf("Offset = @x\n", swap_word(tiff_hdr->Offset_to_IFD));
if (offset > segment_size) {
cgc_printf("Invalid offset\n");
_terminate(-1);
}
IFD = (void *)(tiff_hdr) + swap_word(tiff_hdr->Offset_to_IFD);
// how many array entries are there
IFD->Count = swap_short(IFD->Count);
cgc_printf("# of compatility arrays: @d\n", IFD->Count);
if (IFD->Count * 12 > segment_size - sizeof(TIFF_Hdr_Type) - 6 - 2) {
cgc_printf("Invalid number of IFD entries\n");
_terminate(-1);
}
// loop through all of the entries in the array
for (i=0; i< (IFD->Count); ++i) {
cgc_printf("Tag: @x (", swap_short(IFD->Entry[i].Tag));
print_tag_text(swap_short(IFD->Entry[i].Tag));
cgc_printf(")\n");
cgc_printf("Type: @x (", swap_short(IFD->Entry[i].Type));
print_type(swap_short(IFD->Entry[i].Type));
cgc_printf(")\n");
cgc_printf("Count: @d\n", swap_word(IFD->Entry[i].Count));
if (swap_short(IFD->Entry[i].Type) == 2) {
if (swap_word(IFD->Entry[i].Value) < segment_size - 8 && swap_word(IFD->Entry[i].Value) > 0)
#ifdef PATCHED
{
if ( cgc_strlen( (char *)(tiff_hdr) + swap_word(IFD->Entry[i].Value)) > 2048) {
((char *)(tiff_hdr))[swap_word(IFD->Entry[i].Value)+2048] = '\x00';
}
#endif
cgc_printf("Value: @s\n", (char *)(tiff_hdr) + swap_word(IFD->Entry[i].Value));
#ifdef PATCHED
}
#endif
else
cgc_printf("Value: 0\n");
}
else {
cgc_printf("Value: @u\n", swap_word(IFD->Entry[i].Value));
}
if (swap_short(IFD->Entry[i].Tag) == 0x8825) {
gps_info_ptr = (void *)tiff_hdr + swap_word(IFD->Entry[i].Value);
process_gps_ifd(gps_info_ptr, tiff_hdr, segment_size, endofsegment_ptr);
}
else if (swap_short(IFD->Entry[i].Tag) == 0x8769) {
xif_ifd_ptr = (void *)tiff_hdr + swap_word(IFD->Entry[i].Value);
process_xif_ifd(xif_ifd_ptr, tiff_hdr, segment_size, endofsegment_ptr);
}
}
puts("Finished processing");
} // main
ERRORCODE near CTIFFInfo::ReadTags(void)
{
ERRORCODE error;
TIFF_HEADER header;
TIFF_IFD ifd;
TIFF_FILE_ENTRY entry;
TIFF_ENTRY_PTR pEntry;
WORD wEntryCount;
LONG lIfdAddress, lEntryOffset;
/* If we have already read the tags, don't read them again. */
if (m_Info.valid)
{
return ERRORCODE_None;
}
/* Initialize data to defaults */
SetDefaults();
m_Info.unused_offset = 0L;
#if 0
if (type == GRAPHIC_TYPE_EPS)
{
if ((error = m_pDevice->seek(0x14, ST_DEV_SEEK_SET)) != ERRORCODE_None
|| (error = m_pDevice->read(&m_Info.offset, sizeof(m_Info.offset))) != ERRORCODE_None)
{
return error;
}
}
#endif
/*
// Seek to the start and read in the header.
*/
if ((error = m_pDevice->seek(0, ST_DEV_SEEK_SET)) != ERRORCODE_None
|| (error = m_pDevice->read(&header, sizeof(TIFF_HEADER))) != ERRORCODE_None)
{
return error;
}
/* Save the byte order for later. */
if ((m_Info.byte_order = header.byte_order) != BYTE_ORDER_IBM)
{
swap_word(&header.version);
}
/* Make sure header is reasonable */
if (header.version != TIFF_VERSION)
{
return ERRORCODE_IllegalType;
}
/* Start at the first IFD in the TIFF file. */
lIfdAddress = header.ifd0_address;
/* Step through and read in all the IFD's */
while (lIfdAddress != 0L)
{
if (header.byte_order != BYTE_ORDER_IBM)
{
swap_long(&lIfdAddress);
}
/* Move to the beginning of the IFD. */
/* Read in top of IFD (entry count) */
if ((error = m_pDevice->seek(lIfdAddress, ST_DEV_SEEK_SET)) != ERRORCODE_None
|| (error = m_pDevice->read(&ifd, sizeof(TIFF_IFD))) != ERRORCODE_None)
{
return error;
}
if (header.byte_order != BYTE_ORDER_IBM)
{
swap_word(&(ifd.entry_count));
}
/* Read in the entries. */
for (wEntryCount = ifd.entry_count; wEntryCount != 0; wEntryCount--)
{
m_pDevice->tell(&lEntryOffset);
/* Read in entry */
if ((error = m_pDevice->read(&entry, sizeof(TIFF_FILE_ENTRY))) != ERRORCODE_None)
{
return error;
}
/* Correct the byte order if it is wrong. */
if (m_Info.byte_order != BYTE_ORDER_IBM)
{
swap_word((LPWORD)&(entry.tag));
swap_word((LPWORD)&(entry.type));
swap_long(&(entry.length));
}
/* What kind of field have we got? */
if ((pEntry = FindEntry(entry.tag)) != NULL_TIFF_ENTRY)
{
/* Copy the data. THIS IS A STRUCTURE COPY. */
pEntry->entry = entry;
/* Say this entry was read. */
pEntry->entry_valid = TRUE;
pEntry->entry_offset = lEntryOffset;
if (pEntry->entry.length == 0)
{
/* This is a fix for some bad TIFF files. */
pEntry->entry.length = 1;
}
}
}
/* Read the next IFD offset. */
#ifdef MULTIPLE_IFDS
if (read(file, &lIfdAddress, sizeof(lIfdAddress)) != sizeof(lIfdAddress))
{
lIfdAddress = 0L; /* Just terminate. */
}
#else
lIfdAddress = 0L; /* Always quit after the first IFD */
#endif
}
m_Info.valid = TRUE;
return ERRORCODE_None;
}
