1 /*____________________________ epson-escpr-services.c ______________________________*/
2
3 /* 1 2 3 4 5 6 7 8 */
4 /*34567890123456789012345678901234567890123456789012345678901234567890123456789012345678*/
5 /*******************************************|********************************************/
6 /*
7 * Copyright (c) 2009 Seiko Epson Corporation All rights reserved.
8 *
9 * Copyright protection claimed includes all forms and matters of
10 * copyrightable material and information now allowed by statutory or judicial
11 * law or hereinafter granted, including without limitation, material generated
12 * from the software programs which are displayed on the screen such as icons,
13 * screen display looks, etc.
14 *
15 */
16 /*******************************************|********************************************/
17 /* */
18 /* Epson ESC/P-R Lib Internal Service Routines */
19 /* */
20 /* Public Function Calls */
21 /* -------------------------- */
22 /* EPS_ERR_CODE serAnalyzeStatus (Status, StatusInfo ); */
23 /* void serDelayThread (Milliseconds ); */
24 /* EPS_ERR_CODE serSleep (Milliseconds ); */
25 /* */
26 /*******************************************|********************************************/
27
28 /*------------------------------------ Includes -------------------------------------*/
29 /*******************************************|********************************************/
30 #include "epson-escpr-err.h"
31 #include "epson-escpr-mem.h"
32 #include "epson-escpr-media.h"
33 #include "epson-escpr-services.h"
34 #ifdef GCOMSW_CMD_ESCPAGE_S
35 #include "epson-escpage-s.h"
36 #endif
37 #ifdef GCOMSW_CMD_PCL
38 #include "epson-pcl.h"
39 #endif
40
41 #ifndef EPS_PARSE_CARTRIDGE
42 #define EPS_PARSE_CARTRIDGE(p1, p2, p3, p4) parseCartridge(p1, p2, p3, p4);
43 #endif
44
45
46 /*------------------------------------ Definition -----------------------------------*/
47 /*******************************************|********************************************/
48
49 #ifdef EPS_LOG_MODULE_SER
50 #define EPS_LOG_MODULE EPS_LOG_MODULE_SER
51 extern EPS_CMN_FUNC epsCmnFnc;
52 #else
53 #define EPS_LOG_MODULE 0
54 #endif
55
56
57 /*---------------------------- ESC/P-R Lib Global Variables --------------------------*/
58 /*******************************************|********************************************/
59
60 /*------------------------------ Local Global Variables ------------------------------*/
61 /*******************************************|********************************************/
62 typedef struct _tagSP_OBSERVER
63 {
64 const EPS_PRINTER_INN *printer; /* current printer */
65 EPS_UINT8 colorPlane; /* Image color plane */
66 }SP_OBSERVER;
67
68 static SP_OBSERVER g_observer = {0};
69
70 /*-------------------------------- Local Functions ----------------------------------*/
71 /*******************************************|********************************************/
72 #ifndef GCOMSW_EXTENTION
73 static EPS_UINT8* parseCartridge (EPS_UINT8 ParameterByte, EPS_UINT8* param,
74 EPS_INK_INFO* ink, EPS_INT32 cartridges[] );
75 #endif
76 static EPS_UINT32 pptops (EPS_UINT8* pp );
77
78
79 /*----------------------------------- Debug Dump -------------------------------------*/
80 /*******************************************|********************************************/
81 #define _DEBUG_BIN_STATUS_ 0 /* 0: OFF 1: ON */
82
83 #if _DEBUG_BIN_STATUS_ || _VALIDATE_SUPPORTED_MEDIA_DATA_
84 #define SerDebugPrintf(a) EPS_DBGPRINT( a )
85 #else
86 #define SerDebugPrintf(a)
87 #endif
88
89 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
90 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
91 /*%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%*/
92 /*-------------------- Public Functions ---------------------*/
93 /*%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%*/
94 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
95 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
96
97 /*******************************************|********************************************/
98 /* */
99 /* Function name: serParseDeviceID() */
100 /* */
101 /* Arguments */
102 /* --------- */
103 /* Name: Type: Description: */
104 /* deviceIDString EPS_INT8* I: DeviceID string */
105 /* manufacturer EPS_INT8* I: Manufacturer Name */
106 /* modelName EPS_INT8* I: Model Name */
107 /* */
108 /* Return value: */
109 /* 1 - Success */
110 /* -1 - Bad format or Not Supported device */
111 /* 0 - unknown */
112 /* */
113 /* Description: */
114 /* Get the manufacturer name and modelName from DeviceID string. */
115 /* */
116 /*******************************************|********************************************/
serParseDeviceID(EPS_INT8 * deviceIDString,EPS_INT32 strlength,EPS_INT8 * manufacturer,EPS_INT8 * modelName,EPS_INT32 * cmdLevel,EPS_UINT32 * lang,EPS_UINT32 * errorID)117 EPS_INT32 serParseDeviceID (
118
119 EPS_INT8* deviceIDString,
120 EPS_INT32 strlength,
121 EPS_INT8* manufacturer,
122 EPS_INT8* modelName,
123 EPS_INT32* cmdLevel,
124 EPS_UINT32* lang,
125 EPS_UINT32* errorID
126
127 ){
128 EPS_INT8* i = NULL;
129 EPS_INT8* j = NULL;
130 EPS_INT8* k = NULL;
131 EPS_INT8* p = NULL;
132 EPS_UINT32 tmpLang = EPS_LANG_UNKNOWN;
133
134 EPS_LOG_FUNCIN;
135
136 /*** Delete the data of the device ID length from string */
137 if(strlength < 2){
138 EPS_RETURN( -1 );
139 }
140 *(deviceIDString+strlength) = '\0';
141 if(deviceIDString[0] == 0x00 || deviceIDString[1] == 0x00){
142 deviceIDString += 2;
143 }
144 EPS_DBGPRINT(("DI : %s\n", deviceIDString))
145
146 /*** ================================================================================== */
147 /*** Step 1: Get Manufacturer Name */
148 /*** ================================================================================== */
149 if((i = strstr(deviceIDString, "MFG:")) != NULL) {
150 i += 4;
151 } else if((i = strstr(deviceIDString, "MANUFACTURER:")) != NULL) {
152 i += 13;
153 } else{
154 /* Invalid device ID. */
155 EPS_RETURN( -1 );
156 }
157 j = i;
158
159 while(*j != ';')
160 {
161 j++;
162
163 /* Emergency exit condition to prevent an infinite loop scenario; if we hit a */
164 /* carriage return, we've run too far */
165 if(*j == 0x0D || *j == 0x00) {
166 /* EPS_RETURN( -1 ); When there is not ';', assume the whole a value */
167 break;
168 }
169 }
170 /* Null-terminate the MFG substring. */
171 *j = 0;
172
173 if((strncmp(i, "EPSON", 5) != 0) && (strncmp(i, "Epson", 5) != 0) ){
174 *j = ';';
175 EPS_RETURN( -1 );
176 }
177
178 if(NULL != manufacturer){
179 /* Make sure the manufacturer name is not longer than 64 bytes. */
180 if(strlen(i) < 64) {
181 strcpy(manufacturer, i); /* If the name is OK, copy the whole string as-is */
182 }
183 else {
184 memcpy(manufacturer, i, 63); /* If the name is longer than 64 bytes, only copy */
185 } /* 63 bytes and leave the 64th as null terminator */
186 }
187
188 /* Return the string to its original format. */
189 *j = ';';
190
191
192 /*** ================================================================================== */
193 /*** Step 2: Get Model Name */
194 /*** ================================================================================== */
195 if(NULL != modelName){
196 if((i = strstr(deviceIDString, "MDL:")) != NULL) {
197 i += 4;
198 } else if((i = strstr(deviceIDString, "MODEL:")) != NULL) {
199 i += 6;
200 } else{
201 /* Invalid device ID. */
202 EPS_RETURN( -1 );
203 }
204 j = i;
205
206 while (*j != ';')
207 {
208 j++;
209
210 /* Emergency exit condition to prevent an infinite loop scenario; if we hit a */
211 /* carriage return, we've run too far */
212 if(*j == 0x0D || *j == 0x00){
213 /* Invalid device ID. */
214 /* EPS_RETURN( -1 ); */
215 break;
216 }
217 }
218
219 /* Null-terminate the MDL substring. */
220 *j = 0;
221
222 /* Make sure the model name is not longer than 64 bytes. */
223 if(strlen(i) < 64) {
224 strcpy(modelName, i); /* If the name is OK, copy the whole string as-is */
225 }
226 else {
227 memcpy(modelName, i, 63); /* If the name is longer than 64 bytes, only copy */
228 /* 63 bytes, leaving the 64th as null terminator */
229 }
230
231 *j = ';';
232 }
233
234
235 /*** ================================================================================== */
236 /*** Step 3: Check for ESC/PR Support */
237 /*** ================================================================================== */
238 if((i = strstr(deviceIDString, "CMD:")) == NULL) {
239 EPS_RETURN( 0 );
240 }
241 i += 4;
242 j = i;
243
244 while (*j != ';')
245 {
246 j++;
247
248 /* Emergency exit condition to prevent an infinite loop scenario; if we hit a */
249 /* carriage return, we've run too far */
250 if(*j == 0x0D || *j == 0x00){
251 /* Invalid device ID. */
252 /* EPS_RETURN( -1 ); */
253 break;
254 }
255 }
256 *j = '\0';
257
258 while( NULL != i ){
259 if((k = strstr(i, ",")) != NULL) {
260 *k = '\0';
261 }
262
263 if((p = strstr(i, "ESCPR")) != NULL) {
264 tmpLang = EPS_LANG_ESCPR;
265 if(NULL != cmdLevel){
266 sscanf(p+5, "%d", cmdLevel);
267 }
268 break;
269
270 #ifdef GCOMSW_CMD_ESCPAGE
271 } else if(strstr(i, "ESCPAGECOLOR") != NULL) {
272 tmpLang = EPS_LANG_ESCPAGE_COLOR;
273 if(NULL != cmdLevel){
274 *cmdLevel = 1;
275 }
276 break;
277
278 } else if(strstr(i, "ESCPAGE") != NULL) {
279 if(strstr(i, "ESCPAGES") == NULL) {
280 tmpLang = EPS_LANG_ESCPAGE;
281 if(NULL != cmdLevel){
282 *cmdLevel = 1;
283 }
284 /* break; ESC/Page Color takes priority */
285 #ifdef GCOMSW_CMD_ESCPAGE_S
286 } else{
287 if(TRUE == pageS_ParseLang(i, cmdLevel, &tmpLang)){
288 /* break; ESC/Page takes priority */
289 }
290 #endif
291 }
292
293 #ifdef GCOMSW_CMD_PCL
294 } else if( (strstr(i, "PCLXL") != NULL) && (strlen(i) == 5) ){
295 if(EPS_LANG_UNKNOWN == tmpLang){
296 tmpLang = EPS_LANG_PCL;
297 }
298 if(NULL != cmdLevel){
299 *cmdLevel = 1;
300 }
301 /*break; ESC/P-R, ESC/Page takes priority */
302 #endif
303
304 #endif /* GCOMSW_CMD_ESCPAGE */
305 }
306
307 if(k){
308 *k = ',';
309 i = k+1;
310 if(i >= j){
311 break;
312 }
313 } else{
314 break;
315 }
316 }
317 if(k)*k = ',';
318
319 *j = ';';
320
321 if(EPS_LANG_UNKNOWN == tmpLang){
322 EPS_RETURN( -1 );
323 }
324 if(NULL != lang){
325 *lang = tmpLang;
326 }
327
328 /*** ================================================================================== */
329 /*** Step 4: Error Group ID */
330 /*** ================================================================================== */
331 if(NULL != errorID){
332 if((i = strstr(deviceIDString, "ELG:")) != NULL) {
333 i += 4;
334 } else{
335 EPS_RETURN( 1 );
336 }
337 j = i;
338
339 while (*j != ';')
340 {
341 j++;
342 if(*j == 0x0D || *j == 0x00){
343 EPS_RETURN( 1 );
344 }
345 }
346
347 /* Null-terminate the MDL substring. */
348 *j = 0;
349
350 if(strlen(i) <= 4) {
351 sscanf(i, "%x", errorID);
352 }
353 *j = ';';
354 }
355
356 EPS_RETURN( 1 );
357 }
358
359 /*******************************************|********************************************/
360 /* */
361 /* Function name: serCheckLang() */
362 /* */
363 /* Arguments */
364 /* --------- */
365 /* Name: Type: Description: */
366 /* langString EPS_INT8* I: Print lang string */
367 /* lang EPS_UINT32* O: lang id */
368 /* */
369 /* Return value: */
370 /* TRUE - Success */
371 /* FALSE - Not Supported device */
372 /* */
373 /* Description: */
374 /* Get the printer status and analyze the status string. */
375 /* */
376 /*******************************************|********************************************/
serCheckLang(EPS_INT8 * langString,EPS_UINT32 * lang)377 EPS_BOOL serCheckLang (
378
379 EPS_INT8* langString,
380 EPS_UINT32* lang
381
382 ){
383 if( (strncmp(langString, "ESC-P/R", 7) == 0) ){
384 *lang = EPS_LANG_ESCPR;
385 return TRUE;
386 #ifdef GCOMSW_CMD_PCL
387 } else if( (strcmp(langString, "PCL 6") == 0) ){
388 *lang = EPS_LANG_PCL;
389 return TRUE;
390 #endif
391 }
392
393 return FALSE;
394 }
395
396 /*******************************************|********************************************/
397 /* */
398 /* Function name: serAnalyzeStatus() */
399 /* */
400 /* Arguments */
401 /* --------- */
402 /* Name: Type: Description: */
403 /* Status EPS_INT8* I: Printer Status string */
404 /* egID EPS_UINT32 I: printer error group id */
405 /* pstInfo EPS_STATUS_INFO* O: Printer Status information */
406 /* */
407 /* Return value: */
408 /* EPS_ERR_NONE - Success */
409 /* EPS_ERR_COMM_ERROR - Communication Error */
410 /* */
411 /* Description: */
412 /* Get the printer status and analyze the status string. */
413 /* */
414 /*******************************************|********************************************/
serAnalyzeStatus(EPS_INT8 * Status,EPS_UINT32 egID,EPS_STATUS_INFO * pstInfo)415 EPS_ERR_CODE serAnalyzeStatus (
416
417 EPS_INT8* Status,
418 EPS_UINT32 egID,
419 EPS_STATUS_INFO* pstInfo
420
421 ){
422 EPS_UINT8* Field;
423 EPS_UINT8* EndField;
424 EPS_INT32 i;
425
426 EPS_UINT8 Header;
427 EPS_UINT8 ParameterByte;
428 EPS_INT8* Ink;
429 EPS_INT8 Parameter[128];
430 EPS_BOOL mediaErr = FALSE;
431 EPS_UINT8 mediaErrNum, jamErrNum;
432 EPS_INT32 inkNum = 0;
433 EPS_INT32 nInkError = EPS_INKERR_NONE;
434
435 EPS_LOG_FUNCIN;
436
437 if((Field = (EPS_UINT8*)strstr(Status,"ST2")) == NULL ){
438 SerDebugPrintf(("EPS SER: Get Stat -> ST not found [%s]\r\n",Status));
439 EPS_RETURN( EPS_ERR_COMM_ERROR );
440 }
441
442 memset(pstInfo, 0, sizeof(EPS_STATUS_INFO));
443 pstInfo->nState = EPS_ST_IDLE;
444 pstInfo->nError = EPS_PRNERR_NOERROR;
445 pstInfo->nWarn = EPS_PRNWARN_NONE;
446 mediaErrNum = jamErrNum = 0;
447
448 #if _DEBUG_BIN_STATUS_
449 EPS_DUMP(Status, 256);
450 #endif
451 Field = Field + 5;
452 EndField = Field + (2+(*Field)+ ((*(Field+1))*256) );
453 Field = Field + 2;
454
455 while ( Field < EndField ) {
456
457 Header = (EPS_UINT8) Field[0];
458 ParameterByte = (EPS_UINT8) Field[1];
459 memcpy(Parameter, Field+2, (EPS_INT8)ParameterByte );
460
461 Field = Field + 2 + ParameterByte;
462
463 switch( Header ) {
464 case 0x01: /* ST */
465 switch( Parameter[0] ) {
466 case 0x00: pstInfo->nState = EPS_ST_ERROR; break;
467 case 0x01: pstInfo->nState = EPS_ST_SELF_PRINTING; break;
468 case 0x02: pstInfo->nState = EPS_ST_BUSY; break;
469 case 0x03: pstInfo->nState = EPS_ST_WAITING; break;
470 case 0x04: pstInfo->nState = EPS_ST_IDLE; break;
471 /* case 0x05: pstInfo->nState = EPS_ST_PAUSE; break;*/ /* Not supported by 2006 Model */
472 /* case 0x06: pstInfo->nState = EPS_ST_INKDRYING break;*/ /* Not supported by 2006 Model */
473 case 0x07: pstInfo->nState = EPS_ST_CLEANING; break;
474 case 0x08: pstInfo->nState = EPS_ST_FACTORY_SHIPMENT; break;
475 /* case 0x09: pstInfo->nState = EPS_ST_MOTOR_DRIVE_OFF; break;*/ /* Not supported by 2006 Model */
476 case 0x0A: pstInfo->nState = EPS_ST_SHUTDOWN; break;
477 /* case 0x0B: pstInfo->nState = EPS_ST_WAITPAPERINIT; break;*/ /* Not supported by 2006 Model */
478 /* case 0x0C: pstInfo->nState = EPS_ST_INIT_PAPER; break;*/ /* Not supported by 2006 Model */
479 case 0x0D: pstInfo->nState = EPS_ST_BUSY; break;
480 default:
481 pstInfo->nState = EPS_ST_ERROR;
482 if(pstInfo->nError == EPS_PRNERR_NOERROR){
483 pstInfo->nError = EPS_PRNERR_GENERAL;
484 }
485 break;
486 }
487 break;
488
489 case 0x02: /* ER */
490 EPS_DBGPRINT(("* ERR 0x%02X *\n", Parameter[0]))
491 switch(Parameter[0]) {
492 case 0x00: pstInfo->nError = EPS_PRNERR_FATAL; break;
493 case 0x01: pstInfo->nError = EPS_PRNERR_INTERFACE; break;
494 case 0x02:
495 if ( obsIsA3Model(EPS_MDC_STATUS) == TRUE ) {
496 pstInfo->nError = EPS_PRNERR_CDRGUIDEOPEN;
497 } else{
498 pstInfo->nError = EPS_PRNERR_COVEROPEN;
499 }
500 break;
501 /* case 0x03: pstInfo->nError = EPS_PRNERR_LEVERPOSITION; break;*/ /* Not supported by 2006 Model */
502 case 0x04: pstInfo->nError = EPS_PRNERR_PAPERJAM; break;
503 case 0x05: pstInfo->nError = EPS_PRNERR_INKOUT; break;
504 case 0x06: pstInfo->nError = EPS_PRNERR_PAPEROUT; break;
505 /* case 0x07: pstInfo->nError = EPS_PRNERR_INITIALIZESETTING; break;*/ /* Not supported by 2006 Model */
506 /* case 0x08: pstInfo->nError = EPS_PRNERR_UNKNOWN; break;*/ /* Not supported by 2006 Model */
507 case 0x09: pstInfo->nError = EPS_PRNERR_CDRGUIDEOPEN/*EPS_PRNERR_PAPERCHANGE_UNCOMP*/; break; /* supported by 2012 Model */
508 case 0x0A: pstInfo->nError = EPS_PRNERR_SIZE_TYPE_PATH/*EPS_PRNERR_PAPERSIZE*/;break;/* supported by 2008 Model */
509 /* case 0x0B: pstInfo->nError = EPS_PRNERR_RIBBONJAM; break;*/ /* Not supported by 2006 Model */
510 case 0x0C: pstInfo->nError = EPS_PRNERR_SIZE_TYPE_PATH; break;
511 /* case 0x0D: pstInfo->nError = EPS_PRNERR_PAPERTHICKLEVER; break;*/ /* Not supported by 2006 Model */
512 /* case 0x0E: pstInfo->nError = EPS_PRNERR_PAPERFEED; break;*/ /* Not supported by 2006 Model */
513 /* case 0x0F: pstInfo->nError = EPS_PRNERR_SIMMCOPY; break;*/ /* Not supported by 2006 Model */
514 case 0x10: pstInfo->nError = EPS_PRNERR_SERVICEREQ; break;
515 case 0x11: pstInfo->nError = EPS_PRNERR_ANY/*EPS_PRNERR_WAITTEAROFFRETURN*/; break;
516 case 0x12: pstInfo->nError = EPS_PRNERR_DOUBLEFEED; break;
517 /* case 0x13: pstInfo->nError = EPS_PRNERR_HEADHOT; break;*/ /* Not supported by 2006 Model */
518 /* case 0x14: pstInfo->nError = EPS_PRNERR_PAPERCUTMIS; break;*/ /* Not supported by 2006 Model */
519 /* case 0x15: pstInfo->nError = EPS_PRNERR_HOLDLEVERRELEASE; break;*/ /* Not supported by 2006 Model */
520 /* case 0x16: pstInfo->nError = EPS_PRNERR_NOT_CLEANING; break;*/ /* Not supported by 2006 Model */
521 case 0x17: pstInfo->nError = EPS_PRNERR_SIZE_TYPE_PATH/*EPS_PRNERR_PAPERCONFIG*/; break; /* supported by 2012 Model */
522 /* case 0x18: pstInfo->nError = EPS_PRNERR_PAPERSLANT; break;*/ /* Not supported by 2006 Model */
523 /* case 0x19: pstInfo->nError = EPS_PRNERR_CLEANINGNUMOVER; break;*/ /* Not supported by 2006 Model */
524 case 0x1A: pstInfo->nError = EPS_PRNERR_INKCOVEROPEN; break;
525 /* case 0x1B: pstInfo->nError = EPS_PRNERR_LFP_INKCARTRIDGE; break;*/ /* Not supported by 2006 Model */
526 /* case 0x1C: pstInfo->nError = EPS_PRNERR_CUTTER; break;*/ /* Not supported by 2006 Model */
527 /* case 0x1D: pstInfo->nError = EPS_PRNERR_CUTTERJAM; break;*/ /* Not supported by 2006 Model */
528 /* case 0x1E: pstInfo->nError = EPS_PRNERR_INKCOLOR; break;*/ /* Not supported by 2006 Model */
529 case 0x1E: pstInfo->nError = EPS_PRNERR_ANY/*EPS_PRNERR_INKCOLOR*/; break; /* Not supported by 2006 Model */
530 /* case 0x1F: pstInfo->nError = EPS_PRNERR_CUTTERCOVEROPEN; break;*/ /* Not supported by 2006 Model */
531 /* case 0x20: pstInfo->nError = EPS_PRNERR_LFP_INKLEVERRELEASE; break;*/ /* Not supported by 2006 Model */
532 /* case 0x22: pstInfo->nError = EPS_PRNERR_LFP_NOMAINTENANCETANK1; break;*/ /* Not supported by 2006 Model */
533 /* case 0x23: pstInfo->nError = EPS_PRNERR_CARTRIDGECOMBINATION; break;*/ /* Not supported by 2006 Model */
534 /* case 0x24: pstInfo->nError = EPS_PRNERR_LFP_COMMAND; break;*/ /* Not supported by 2006 Model */
535 /* case 0x25: pstInfo->nError = EPS_PRNERR_LEARCOVEROPEN; break;*/ /* Not supported by 2006 Model */
536 case 0x25: pstInfo->nError = EPS_PRNERR_COVEROPEN; break;
537 /* case 0x26: pstInfo->nError = EPS_PRNERR_MULTICENSORGAIN; break;*/ /* Not supported by 2006 Model */
538 /* case 0x27: pstInfo->nError = EPS_PRNERR_NOT_AUTOADJUST; break;*/ /* Not supported by 2006 Model */
539 /* case 0x28: pstInfo->nError = EPS_PRNERR_FAILCLEANING; break;*/ /* Not supported by 2006 Model */
540 case 0x29: pstInfo->nError = EPS_PRNERR_NOTRAY; break;
541 case 0x2A: pstInfo->nError = EPS_PRNERR_CARDLOADING; break;
542 case 0x2B:
543 if ( obsIsA3Model(EPS_MDC_STATUS) == TRUE ) {
544 pstInfo->nError = EPS_PRNERR_CDRGUIDEOPEN;
545 } else {
546 pstInfo->nError = EPS_PRNERR_CDDVDCONFIG; /* supported by 2008 Model */
547 }
548 break;
549 case 0x2C: pstInfo->nError = EPS_PRNERR_CARTRIDGEOVERFLOW; break;
550 /* case 0x2D: pstInfo->nError = EPS_PRNERR_LFP_NOMAINTENANCETANK2; break;*/ /* Not supported by 2006 Model */
551 /* case 0x2E: pstInfo->nError = EPS_PRNERR_INKOVERFLOW2; break;*/ /* Not supported by 2006 Model */
552 case 0x2F: pstInfo->nError = EPS_PRNERR_BATTERYVOLTAGE; break;
553 case 0x30: pstInfo->nError = EPS_PRNERR_BATTERYTEMPERATURE; break;
554 case 0x31: pstInfo->nError = EPS_PRNERR_BATTERYEMPTY; break;
555 case 0x32: pstInfo->nError = EPS_PRNERR_SHUTOFF; break; /* Not supported by 2006 Model */
556 case 0x33: pstInfo->nError = EPS_PRNERR_NOT_INITIALFILL; break; /* Not supported by 2006 Model */
557 case 0x34: pstInfo->nError = EPS_PRNERR_PRINTPACKEND; break; /* Not supported by 2006 Model */
558 /* case 0x35: pstInfo->nError = EPS_PRNERR_ABNORMALHEAT; break;*/ /* Not supported by 2006 Model */
559 case 0x37:
560 if ( obsIsA3Model(EPS_MDC_STATUS) == TRUE ) {
561 pstInfo->nError = EPS_PRNERR_COVEROPEN;
562 } else if(0x0D04 == egID || 0x0D84 == egID){
563 pstInfo->nError = EPS_PRNERR_COVEROPEN;
564 } else{
565 pstInfo->nError = EPS_PRNERR_SCANNEROPEN;
566 }
567 break;
568 case 0x38:
569 if ( obsIsA3Model(EPS_MDC_STATUS) == TRUE ) {
570 pstInfo->nError = EPS_PRNERR_CDDVDCONFIG;
571 } else if((0x0D00 <= egID && 0x0D05 >= egID) || 0x0E21 == egID){
572 pstInfo->nError = EPS_PRNERR_TRAYCLOSE;
573 } else{
574 pstInfo->nError = EPS_PRNERR_CDRGUIDEOPEN;
575 }
576 break;
577 case 0x44: pstInfo->nError = EPS_PRNERR_CDRGUIDEOPEN; break;
578 case 0x45: pstInfo->nError = EPS_PRNERR_CDREXIST_MAINTE; break;
579 case 0x46: pstInfo->nError = EPS_PRNERR_TRAYCLOSE; break;
580 case 0x47: pstInfo->nError = EPS_PRNERR_INKOUT; break; /* BlackPrint Error */
581
582 case 0x4C: pstInfo->nError = EPS_PRNERR_PAPEROUT; break;
583 case 0x4D: pstInfo->nError = EPS_PRNERR_CDDVDCONFIG; break;
584 case 0x4E: pstInfo->nError = EPS_PRNERR_FEEDERCLOSE; break;
585 case 0x55: mediaErr = TRUE; break;
586 case 0x56: pstInfo->nError = EPS_PRNERR_INTERRUPT_BY_INKEND; break;
587 case 0x57: pstInfo->nError = EPS_PRNERR_PAPEROUT; break;
588 case 0x5D: pstInfo->nError = EPS_PRNERR_NO_BATTERY; break;
589 case 0x5E: pstInfo->nError = EPS_PRNERR_LOW_BATTERY_FNC; break;
590 case 0x5F: pstInfo->nError = EPS_PRNERR_BATTERY_CHARGING; break;
591 case 0x60: pstInfo->nError = EPS_PRNERR_BATTERY_TEMPERATURE_HIGH;break;
592 case 0x61: pstInfo->nError = EPS_PRNERR_BATTERY_TEMPERATURE_LOW;break;
593 case 0x62: pstInfo->nError = EPS_PRNERR_ANY; break;
594
595 default:
596 pstInfo->nError = EPS_PRNERR_GENERAL;
597 break;
598 }
599 break;
600
601 case 0x04: /* WR */
602 /* ESC/P-R Lib does not notified the warning to application, */
603 /* so warning analysis dose not need to be done completely. */
604 pstInfo->nWarn = EPS_PRNWARN_NONE;
605 for(i = 0; i < ParameterByte; i++){
606 if( Parameter[i] >= 0x10 && Parameter[i] <= 0x1A ){
607 /* Ink Low Warning */
608 pstInfo->nWarn |= EPS_PRNWARN_INKLOW;
609 } else if( Parameter[i] >= 0x51 && Parameter[i] <= 0x5A ){
610 pstInfo->nWarn |= EPS_PRNWARN_DISABLE_CLEAN;
611 } else if( Parameter[i] >= 0x71 && Parameter[i] <= 0x7A ){
612 /*} else if( Parameter[i] == 0x44 ){ not use
613 pstInfo->nWarn |= EPS_PRNWARN_COLOR_INKOUT;*/
614 }
615 }
616 break;
617
618 case 0x0F: /* INK */
619 inkNum = Min((ParameterByte-1) / Parameter[0], EPS_INK_NUM);
620 Ink = Parameter+1;
621
622 for( i=0; i < inkNum; i++ ) {
623 switch( Ink[2] ) {
624 case 'w' :
625 case 'r' :
626 nInkError = EPS_PRNERR_CFAIL;
627 break;
628 case 'n' :
629 nInkError = EPS_PRNERR_CEMPTY;
630 break;
631 case 0:
632 nInkError = EPS_PRNERR_INKOUT;
633 default:
634 break;
635 }
636 Ink = Ink + Parameter[0];
637 }
638 break;
639
640 case 0x13: /* CANCEL REQUEST by Printer cancel botton */
641 switch((EPS_UINT8)Parameter[0]) {
642 case 0x81:
643 pstInfo->nCancel = EPS_CAREQ_CANCEL;
644 break;
645 default:
646 pstInfo->nCancel = EPS_CAREQ_NOCANCEL;
647 break;
648 }
649 break;
650 case 0x18: /* Stacker(tray) open status */
651 switch((EPS_UINT8)Parameter[0]) {
652 case 0x02: /* Closed*/
653 pstInfo->nPrepare = EPS_PREPARE_TRAYCLOSED;
654 break;
655 case 0x03: /* Open*/
656 pstInfo->nPrepare = EPS_PREPARE_TRAYOPENED;
657 break;
658 }
659 break;
660 case 0x1C: /* Temperature information */
661 switch((EPS_UINT8)Parameter[0]) {
662 case 0x01: /* The printer temperature is higher than 40C*/
663 pstInfo->nPrepare = EPS_PREPARE_OVERHEAT;
664 break;
665 case 0x00: /* The printer temperature is lower than 40C*/
666 pstInfo->nPrepare = EPS_PREPARE_NORMALHEAT;
667 break;
668 }
669 break;
670
671 case 0x35: /* Paper Jam error information */
672 jamErrNum = (EPS_UINT8)Parameter[0];
673 break;
674
675 case 0x3B: /* Media */
676 mediaErrNum = (EPS_UINT8)Parameter[0];
677 break;
678
679 default:
680 break;
681 }
682 }
683
684 if( TRUE == mediaErr && EPS_PRNERR_NOERROR == pstInfo->nError){
685 switch( mediaErrNum ){
686 case 0x01: pstInfo->nError = EPS_PRNERR_3DMEDIA_FACE; break;
687 case 0x02: pstInfo->nError = EPS_PRNERR_3DMEDIA_DIRECTION; break;
688 default: pstInfo->nError = EPS_PRNERR_PAPEROUT; break;
689 }
690 } else if ( EPS_PRNERR_PAPERJAM == pstInfo->nError ){
691 if( 0x10 == jamErrNum && (0x0D00 <= egID && 0x0D05 >= egID)){
692 pstInfo->nError = EPS_PRNERR_CDDVDCONFIG;
693 }
694 } else if ( EPS_PRNERR_PAPEROUT == pstInfo->nError ){
695 switch( jamErrNum ){
696 case 0x90:
697 if(0x0D04 == egID){
698 pstInfo->nError = EPS_PRNERR_MANUALFEED_SET_PAPER_NOLCD;
699 } else if(0x0D00 <= egID && 0x0D05 >= egID){
700 pstInfo->nError = EPS_PRNERR_MANUALFEED_SET_PAPER;
701 }
702 break;
703 case 0x91:
704 if(0x0D04 == egID){
705 pstInfo->nError = EPS_PRNERR_MANUALFEED_FAILED_NOLCD;
706 } else if(0x0D00 <= egID && 0x0D05 >= egID){
707 pstInfo->nError = EPS_PRNERR_MANUALFEED_FAILED;
708 }
709 break;
710 case 0x92:
711 if(0x0D04 == egID){
712 pstInfo->nError = EPS_PRNERR_MANUALFEED_EXCESSIVE_NOLCD;
713 } else if(0x0D00 <= egID && 0x0D05 >= egID){
714 pstInfo->nError = EPS_PRNERR_MANUALFEED_EXCESSIVE;
715 }
716 break;
717 case 0xA3:
718 pstInfo->nError = EPS_PRNERR_ROLLPAPER_TOOSHORT;
719 break;
720 default: break;
721 }
722 } else if(EPS_PRNERR_INKOUT == pstInfo->nError && EPS_INKERR_NONE != nInkError ){
723 pstInfo->nError = nInkError;
724 }
725
726 if ( EPS_PRNERR_CDDVDCONFIG == pstInfo->nError ){
727 if(0x0D04 == egID){
728 pstInfo->nError = EPS_PRNERR_CDDVDCONFIG_FEEDBUTTON;
729 } else if (0x0D00 <= egID && 0x0D05 >= egID){
730 pstInfo->nError = EPS_PRNERR_CDDVDCONFIG_STARTBUTTON;
731 }
732 }
733
734 if( EPS_CAREQ_CANCEL == pstInfo->nCancel ){
735 EPS_DBGPRINT(("*** Cancel Request (ignore error) ***\n"))
736 pstInfo->nState = EPS_ST_WAITING;
737 pstInfo->nError = EPS_PRNERR_NOERROR;
738 }
739
740
741 #if _DEBUG_BIN_STATUS_
742 SerDebugPrintf(("***** ST = %d\r\n", pstInfo->nState));
743 SerDebugPrintf(("***** ER = %d\r\n", pstInfo->nError));
744 SerDebugPrintf(("***** WR = %d\r\n", pstInfo->nWarn));
745 SerDebugPrintf(("***** CA = %d\r\n", pstInfo->nCancel));
746 SerDebugPrintf(("***** INK NUM = %d\r\n", pstInfo->nInkNo));
747 for(i = 0; i < pstInfo->nInkNo; i++){
748 SerDebugPrintf(("***** INK = %d\t%d\r\n", pstInfo->nColorType[i], pstInfo->nColor[i]));
749 }
750 #endif
751
752 EPS_RETURN( EPS_ERR_NONE );
753 }
754
755
756 /*******************************************|********************************************/
757 /* */
758 /* Function name: serGetSerialNo() */
759 /* */
760 /* Arguments */
761 /* --------- */
762 /* Name: Type: Description: */
763 /* cdBuff EPS_INT8* I: 'cd' command reply */
764 /* buflen EPS_INT32 I: 'cd' data length */
765 /* serialNo EPS_INT8* O: serial number */
766 /* */
767 /* Return value: */
768 /* EPS_ERR_NONE - Success */
769 /* */
770 /* Description: */
771 /* parse 'cd' command reply to get serial number string. */
772 /* */
773 /*******************************************|********************************************/
serGetSerialNo(EPS_INT8 * cdBuff,EPS_INT32 buflen,EPS_INT8 * serialNo)774 EPS_ERR_CODE serGetSerialNo (
775
776 EPS_INT8* cdBuff,
777 EPS_INT32 buflen,
778 EPS_INT8* serialNo
779
780 ){
781 EPS_ERR_CODE ret = EPS_ERR_NONE;
782 EPS_INT8* p = NULL;
783 EPS_INT32 datalen = 0;
784 EPS_UINT8 formVer = 0;
785
786 #define EPS_GET_SERIAL(POS, LEN) \
787 if(datalen >= POS+LEN){ \
788 strncpy(serialNo, p+POS, LEN); \
789 } else{ \
790 ret = EPS_ERR_COMM_ERROR; \
791 }
792
793 EPS_LOG_FUNCIN
794
795 /* verify */
796 if( buflen < 14 ){
797 EPS_RETURN( EPS_ERR_COMM_ERROR)
798 }
799 if( 0 != memcmp(cdBuff+buflen-2, ";\x0C", 2) ){
800 EPS_RETURN( EPS_ERR_COMM_ERROR)
801 }
802
803 p = strstr(cdBuff, "cd:");
804 if( NULL == p || buflen-(p-cdBuff) < 6 ){
805 EPS_RETURN( EPS_ERR_COMM_ERROR)
806 }
807 p += 5; /* skip head */
808
809 if( 0 == strncmp(p, "NA", 2) || 0 == strncmp(p, "BUSY", 4)){
810 EPS_RETURN( EPS_ERR_COMM_ERROR)
811 }
812
813 datalen = (EPS_INT32)*p + ((EPS_INT32)*(p+1) << 8);
814 p += 2; /* skip lenght field */
815
816 /* get version */
817 formVer = 0x07;
818 if( buflen-(EPS_INT32)(p-cdBuff) > datalen+2 && /* 2 = ";\x0C" */
819 *(cdBuff+buflen-4) == '/'){
820 formVer = *(cdBuff+buflen-3);
821 }
822
823 /* get serial number */
824 /* serialNo buffer size is EPS_ADDR_BUFFSIZE */
825 switch(formVer){
826 case 0x07:
827 /* EPS_GET_SERIAL(31, 18) not product serial */
828 break;
829 case 0x08:
830 case 0x10:
831 EPS_GET_SERIAL(31, 10)
832 break;
833
834 case 0x11:
835 default:
836 EPS_GET_SERIAL(46, 10)
837 break;
838 }
839
840 EPS_DBGPRINT(("Ser : %s\n", serialNo));
841
842 EPS_RETURN( ret )
843 }
844
845
serGetSerialNoFormST(EPS_INT8 * Status,EPS_INT8 * serialNo,EPS_INT32 fieldSize)846 EPS_ERR_CODE serGetSerialNoFormST (
847
848 EPS_INT8* Status,
849 EPS_INT8* serialNo,
850 EPS_INT32 fieldSize
851
852 ){
853 EPS_UINT8* Field;
854 EPS_UINT8* EndField;
855
856 EPS_UINT8 Header;
857 EPS_UINT8 ParameterByte;
858
859 EPS_LOG_FUNCIN;
860
861 memset(serialNo, 0, fieldSize);
862
863 if((Field = (EPS_UINT8*)strstr(Status,"ST2")) == NULL ){
864 SerDebugPrintf(("EPS SER: Get Stat -> ST not found [%s]\r\n",Status));
865 EPS_RETURN( EPS_ERR_COMM_ERROR );
866 }
867
868 Field = Field + 5;
869 EndField = Field + (2+(*Field)+ ((*(Field+1))*256) );
870 Field = Field + 2;
871
872 while ( Field < EndField ) {
873 Header = (EPS_UINT8) Field[0];
874 ParameterByte = (EPS_UINT8) Field[1];
875
876 if( 0x40 == Header ) {
877 if( fieldSize > ParameterByte){
878 memcpy(serialNo, Field+2, Min(ParameterByte, fieldSize-1));
879 EPS_RETURN( EPS_ERR_NONE );
880 }
881 break;
882 }
883
884 Field = Field + 2 + ParameterByte;
885 }
886
887 EPS_RETURN( EPS_ERR_OPR_FAIL );
888 }
889
890
891 /*******************************************|********************************************/
892 /* */
893 /* Function name: serGetSupplyInfo() */
894 /* */
895 /* Arguments */
896 /* --------- */
897 /* Name: Type: Description: */
898 /* Status EPS_INT8* I: 'st' command reply */
899 /* info EPS_SETTING_INFO* O: serial number */
900 /* */
901 /* Return value: */
902 /* EPS_ERR_NONE - Success */
903 /* */
904 /* Description: */
905 /* parse 'st' command reply to get paper setting status. */
906 /* */
907 /*******************************************|********************************************/
serGetSupplyInfo(EPS_UINT8 * Status,EPS_SUPPLY_INFO * info)908 EPS_ERR_CODE serGetSupplyInfo (
909
910 EPS_UINT8* Status,
911 EPS_SUPPLY_INFO* info
912
913 ){
914 EPS_UINT8* Field;
915 EPS_UINT8* EndField;
916
917 EPS_UINT8 Header;
918 EPS_UINT8 ParameterByte;
919 EPS_UINT8 formatVer;
920 EPS_UINT8* param;
921 EPS_INT32 unifiedCartridge[EPS_INK_NUM];
922 EPS_INT32 inkWarn[EPS_INK_NUM];
923 EPS_INT32 i;
924
925 #define EPS_PISS_SIZE (9)
926
927 EPS_LOG_FUNCIN;
928
929 memset(info, 0, sizeof(EPS_SUPPLY_INFO));
930 for(i = 0; i < EPS_INK_NUM; i++){
931 unifiedCartridge[i] = -1;
932 inkWarn[i] = EPS_INK_ST_NORMAL;
933 }
934
935 if((Field = (EPS_UINT8*)strstr((EPS_INT8*)Status, "ST2")) == NULL ){
936 SerDebugPrintf(("EPS SER: Get Stat -> ST not found [%s]\r\n",Status));
937 EPS_RETURN( EPS_ERR_COMM_ERROR );
938 }
939
940 Field = Field + 5;
941 EndField = Field + (2+(*Field)+ ((*(Field+1))*256) );
942 Field = Field + 2;
943
944 info->ink.number = -1;
945 info->paperSource.number = -1;
946 info->powerSource.type = EPS_POWER_SOUECE_NOT_SUPPORTED;
947
948 while ( Field < EndField ) {
949 Header = (EPS_UINT8) Field[0];
950 ParameterByte = (EPS_UINT8) Field[1];
951 param = Field + 2;
952 Field = Field + 2 + ParameterByte;
953
954 switch( Header ) {
955 case 0x04: /* WR */
956 for(i = 0; i < ParameterByte; i++){
957 if( param[i] >= 0x10 && param[i] <= 0x1A ){
958 /* Ink Low Warning */
959 inkWarn[ param[i]-0x10 ] = EPS_INK_ST_LOW;
960 } else if( param[i] >= 0x51 && param[i] <= 0x5A ){
961 inkWarn[ param[i]-0x51 ] = EPS_INK_ST_LOW;
962 } else if( param[i] >= 0x71 && param[i] <= 0x7A ){
963 inkWarn[ param[i]-0x71 ] = EPS_INK_ST_LOW;
964 }
965 }
966 break;
967
968 case 0x0F: /* INK */
969 param = EPS_PARSE_CARTRIDGE(ParameterByte, param, &info->ink, unifiedCartridge);
970 break;
971
972 case 0x3F: /* Paper Setting */
973 formatVer = *param;
974 if( 1 == formatVer ) {
975 info->paperSource.number = Min((ParameterByte-1)/EPS_PISS_SIZE, EPS_PAPERSOURCE_NUM);
976 param++;
977 for(i = 0; i < info->paperSource.number; i++){
978 info->paperSource.id[i] = pptops(param);
979 info->paperSource.mediaTypeID[i] = *(param + 2);
980 info->paperSource.mediaSizeID[i] = *(param + 3);
981 param += EPS_PISS_SIZE;
982 }
983 }
984 break;
985
986 case 0x22: /* Power Supply */
987 if( (5 == ParameterByte) && (0x00 == *(param+4)) ){ /* Genuine */
988 switch(*param){
989 case 0x00: info->powerSource.type = EPS_POWER_SOUECE_AC; break;
990 case 0x01: info->powerSource.type = EPS_POWER_SOUECE_BATTERY; break;
991 default: info->powerSource.type = EPS_POWER_SOUECE_UNKNOWN; break;
992 }
993 switch(*(param+2)){
994 case 0x01: info->powerSource.chargeState = EPS_CHARGE_STATE_CHARGING; break;
995 default:
996 case 0x00: info->powerSource.chargeState = EPS_CHARGE_STATE_NONE; break;
997 }
998 if((*(param+3) >= 0) && (*(param+3) <= 100)) {
999 info->powerSource.remaining = *(param+3);
1000 } else{
1001 info->powerSource.remaining = 0;
1002 }
1003 } else{
1004 info->powerSource.type = EPS_POWER_SOUECE_UNKNOWN;
1005 info->powerSource.chargeState = EPS_CHARGE_STATE_NONE;
1006 info->powerSource.remaining = 0;
1007 }
1008 break;
1009 }
1010 }
1011
1012 {
1013 EPS_INT32 warnIdx = 0;
1014 for(i = 0; i < info->ink.number; i++){
1015 if(EPS_INK_ST_NORMAL == info->ink.status[i]){
1016 if( EPS_INK_ST_NORMAL != inkWarn[warnIdx] ){
1017 info->ink.status[i] = inkWarn[warnIdx];
1018 }
1019 }
1020 if( i < info->ink.number-1 &&
1021 unifiedCartridge[i] != unifiedCartridge[i+1]){ /* Cartridge transition */
1022 warnIdx++;
1023 }
1024 }
1025 }
1026
1027 EPS_RETURN( EPS_ERR_NONE );
1028 }
1029
1030 #ifndef GCOMSW_EXTENTION
parseCartridge(EPS_UINT8 ParameterByte,EPS_UINT8 * param,EPS_INK_INFO * ink,EPS_INT32 cartridges[])1031 EPS_UINT8* parseCartridge(
1032
1033 EPS_UINT8 ParameterByte,
1034 EPS_UINT8* param,
1035 EPS_INK_INFO* ink,
1036 EPS_INT32 cartridges[]
1037
1038 ){
1039 EPS_UINT8 blockSize;
1040 EPS_INT32 i;
1041
1042 blockSize = *param;
1043 ink->number = Min((ParameterByte-1) / blockSize, EPS_INK_NUM);
1044
1045 param++;
1046
1047 for( i=0; i < ink->number; i++ ) {
1048 cartridges[i] = *param - 0x40; /* Positive number is unified cartridge index */
1049 if( cartridges[i] >= EPS_INK_NUM ){
1050 cartridges[i] = -1;
1051 }
1052
1053 switch( *(param+1) ) {
1054 case 0x00: ink->colors[i] = EPS_COLOR_BLACK; break;
1055 case 0x01: ink->colors[i] = EPS_COLOR_CYAN; break;
1056 case 0x02: ink->colors[i] = EPS_COLOR_MAGENTA; break;
1057 case 0x03: ink->colors[i] = EPS_COLOR_YELLOW; break;
1058 case 0x04: ink->colors[i] = EPS_COLOR_LIGHTCYAN; break;
1059 case 0x05: ink->colors[i] = EPS_COLOR_LIGHTMAGENTA; break;
1060 case 0x06: ink->colors[i] = EPS_COLOR_LIGHTYELLOW; break;
1061 case 0x07: ink->colors[i] = EPS_COLOR_DARKYELLOW; break;
1062 case 0x08: ink->colors[i] = EPS_COLOR_LIGHTBLACK; break;
1063 case 0x09: ink->colors[i] = EPS_COLOR_RED; break;
1064 case 0x0A: ink->colors[i] = EPS_COLOR_VIOLET; break;
1065 case 0x0B: ink->colors[i] = EPS_COLOR_CLEAR; break;
1066 case 0x0C: ink->colors[i] = EPS_COLOR_LIGHTLIGHTBLACK; break;
1067 case 0x0D: ink->colors[i] = EPS_COLOR_ORANGE; break;
1068 case 0x0E: ink->colors[i] = EPS_COLOR_GREEN; break;
1069 case 0x0F: ink->colors[i] = EPS_COLOR_WHITE; break;
1070 case 0x40: ink->colors[i] = EPS_COLOR_COMPOSITE; break;
1071 default:
1072 ink->colors[i] = EPS_COLOR_UNKNOWN;
1073 break;
1074 }
1075 switch( *param ) {
1076 case 0x0B: ink->colors[i] = EPS_COLOR_MATTEBLACK; break;
1077 default: break;
1078 }
1079
1080 switch( *(param+2) ) {
1081 case 'w' :
1082 case 'r' :
1083 ink->status[i] = EPS_INK_ST_FAIL;
1084 break;
1085 case 'n' :
1086 ink->status[i] = EPS_INK_ST_NOTPRESENT;
1087 break;
1088 case 'i' :
1089 ink->status[i] = EPS_INK_ST_NOREAD;
1090 break;
1091 case 'g' :
1092 ink->status[i] = EPS_INK_ST_NOTAVAIL;
1093 break;
1094 case 0:
1095 ink->status[i] = EPS_INK_ST_END;
1096 default:
1097 break;
1098 }
1099 ink->remaining[i] = EPS_INK_OBSOLETE;
1100
1101 param += blockSize;
1102 }
1103
1104 return param;
1105 }
1106 #endif
1107
pptops(EPS_UINT8 * pp)1108 EPS_UINT32 pptops(EPS_UINT8* pp)
1109 {
1110 switch(*pp){
1111 case 0x01:
1112 switch(*(pp+1)){
1113 case 0x00: return EPS_MPID_REAR; break;
1114 case 0x01: return EPS_MPID_FRONT1; break;
1115 case 0x02: return EPS_MPID_FRONT2; break;
1116 case 0x03: return EPS_MPID_FRONT3; break;
1117 case 0x04: return EPS_MPID_FRONT4; break;
1118 case 0xFF: return EPS_MPID_AUTO; break;
1119 }
1120 break;
1121 case 0x02:
1122 switch(*(pp+1)){
1123 case 0x00: return EPS_MPID_MANUAL; break;
1124 case 0x01: return EPS_MPID_CDTRAY; break;
1125 case 0x02: return EPS_MPID_MANUAL2;break;
1126 }
1127 break;
1128 case 0x03:
1129 switch(*(pp+1)){
1130 case 0x00: return EPS_MPID_ROLL; break;
1131 }
1132 break;
1133 }
1134 return EPS_MPID_NOT_SPEC;
1135 }
1136
1137
1138 /*******************************************|********************************************/
1139 /* */
1140 /* Function name: serDelayThread() */
1141 /* */
1142 /* Arguments */
1143 /* --------- */
1144 /* Name: Type: Description: */
1145 /* milliseconds EPS_UINT32 I: Sleep Period in microseconds */
1146 /* */
1147 /* Return value: */
1148 /* None */
1149 /* */
1150 /* Description: */
1151 /* Wait <milliseconds>. */
1152 /* If OS sleep function is used, change the unit of sleep time from milliseconds */
1153 /* to microseconds. */
1154 /* */
1155 /*******************************************|********************************************/
serDelayThread(EPS_UINT32 milliseconds,EPS_CMN_FUNC * epsCmnFnc)1156 void serDelayThread (
1157
1158 EPS_UINT32 milliseconds,
1159 EPS_CMN_FUNC* epsCmnFnc
1160
1161 ){
1162
1163 #ifdef GCOMSW_EPSON_SLEEP
1164 if (epsCmnFnc->sleep == serSleep) {
1165 epsCmnFnc->sleep((EPS_UINT32)milliseconds); /* Ignore return value of sleep func */
1166 } else{
1167 epsCmnFnc->sleep(milliseconds * 1000); /* Ignore return value of sleep func */
1168 }
1169 #else
1170 epsCmnFnc->sleep(milliseconds * 1000); /* Ignore return value of sleep func */
1171 #endif /* GCOMSW_EPSON_SLEEP */
1172
1173 }
1174
1175 /*******************************************|********************************************/
1176 /* */
1177 /* Function name: serSleep() */
1178 /* */
1179 /* Arguments */
1180 /* --------- */
1181 /* Name: Type: Description: */
1182 /* sleepPeriod EPS_UINT32 I: Sleep Period in milliseconds */
1183 /* */
1184 /* Return value: */
1185 /* EPS_ERR_NONE - Success */
1186 /* */
1187 /* Description: */
1188 /* ESC/P-R Lib original sleep function. */
1189 /* This function is used when "epsCmnFnc.sleep = NULL". */
1190 /* */
1191 /*******************************************|********************************************/
1192 #ifdef GCOMSW_EPSON_SLEEP
serSleep(EPS_UINT32 sleepPeriod)1193 EPS_ERR_CODE serSleep (
1194
1195 EPS_UINT32 sleepPeriod /* Sleep Period in milliseconds */
1196
1197 ){
1198
1199 /*** Declare Variable Local to Routine */
1200 EPS_INT32 idx; /* General loop/index varaible */
1201 EPS_INT32 endx;
1202 struct timeb sleepM;
1203
1204 /*** Initialize Local Variables */
1205 endx = sleepPeriod*printJob.sleepSteps;
1206 if (printJob.sleepSteps <= 0) endx = sleepPeriod/(-printJob.sleepSteps);
1207
1208 /*** Sleep for about the requested sleepPeriod */
1209 for (idx = 1; idx < endx; idx++) {ftime(&sleepM); }
1210
1211 /*** Return to Caller */
1212 return((EPS_ERR_CODE)EPS_ERR_NONE);
1213
1214 }
1215 #endif /* GCOMSW_EPSON_SLEEP */
1216
1217
1218 /*******************************************|********************************************/
1219 /* */
1220 /* Function name: obsSetPrinter() */
1221 /* */
1222 /* Arguments */
1223 /* --------- */
1224 /* Name: Type: Description: */
1225 /* printer EPS_PRINTER_INN8* I: Pointer to printer info */
1226 /* */
1227 /* Return value: */
1228 /* None */
1229 /* */
1230 /* Description: */
1231 /* set the observation target printer. */
1232 /* */
1233 /*******************************************|********************************************/
obsSetPrinter(const EPS_PRINTER_INN * printer)1234 void obsSetPrinter (
1235
1236 const EPS_PRINTER_INN* printer
1237
1238 ){
1239 g_observer.printer = printer;
1240 }
1241
1242
1243 /*******************************************|********************************************/
1244 /* */
1245 /* Function name: obsSetColorPlane() */
1246 /* */
1247 /* Arguments */
1248 /* --------- */
1249 /* Name: Type: Description: */
1250 /* colorPlane EPS_UINT8 I: color plane */
1251 /* */
1252 /* Return value: */
1253 /* None */
1254 /* */
1255 /* Description: */
1256 /* set color plane of current job. */
1257 /* */
1258 /*******************************************|********************************************/
obsSetColorPlane(EPS_UINT8 colorPlane)1259 void obsSetColorPlane (
1260
1261 EPS_UINT8 colorPlane
1262
1263 ){
1264 g_observer.colorPlane = colorPlane;
1265 }
1266
1267
1268 /*******************************************|********************************************/
1269 /* */
1270 /* Function name: obsClear() */
1271 /* */
1272 /* Arguments */
1273 /* --------- */
1274 /* Name: Type: Description: */
1275 /* N/A */
1276 /* */
1277 /* Return value: */
1278 /* None */
1279 /* */
1280 /* Description: */
1281 /* clear all property. */
1282 /* */
1283 /*******************************************|********************************************/
obsClear(void)1284 void obsClear (
1285
1286 void
1287
1288 ){
1289 g_observer.printer = NULL;
1290 g_observer.colorPlane = EPS_CP_FULLCOLOR;
1291 }
1292
1293
1294 /*******************************************|********************************************/
1295 /* */
1296 /* Function name: obsGetPageMode() */
1297 /* */
1298 /* Arguments */
1299 /* --------- */
1300 /* Name: Type: Description: */
1301 /* N/A */
1302 /* */
1303 /* Return value: */
1304 /* Means to page process. */
1305 /* */
1306 /* Description: */
1307 /* The means to page process is decided. */
1308 /* */
1309 /*******************************************|********************************************/
obsGetPageMode(void)1310 EPS_INT32 obsGetPageMode (
1311
1312 void
1313
1314 ){
1315 const EPS_INT8 *modelName = NULL;
1316
1317 if( NULL == g_observer.printer ){
1318 return EPS_PM_PAGE;
1319 }
1320
1321 if(EPS_CP_JPEG == g_observer.colorPlane )
1322 {
1323 modelName = g_observer.printer->modelName;
1324 if( (strcmp(modelName, "EP-801A" ) == 0) ||
1325 (strcmp(modelName, "Artisan 700" ) == 0) ||
1326 (strcmp(modelName, "Stylus Photo TX700W" ) == 0) ||
1327 (strcmp(modelName, "Stylus Photo PX700W" ) == 0) ||
1328 (strcmp(modelName, "EP-901F" ) == 0) ||
1329 (strcmp(modelName, "EP-901A" ) == 0) ||
1330 (strcmp(modelName, "Artisan 800" ) == 0) ||
1331 (strcmp(modelName, "Stylus Photo PX800FW") == 0) ||
1332 (strcmp(modelName, "Stylus Photo TX800FW") == 0) )
1333 {
1334 return EPS_PM_JOB;
1335 }
1336 }
1337
1338 return EPS_PM_PAGE;
1339 }
1340
1341
obsIsA3Model(EPS_INT32 ch)1342 EPS_BOOL obsIsA3Model (
1343
1344 EPS_INT32 ch
1345
1346 ){
1347 const EPS_INT8 *modelName = NULL;
1348
1349 modelName = g_observer.printer->modelName;
1350 if(EPS_MDC_STATUS == ch){ /* status code */
1351 if( (strcmp(modelName, "PX-5V" ) == 0) ||
1352 (strcmp(modelName, "Epson Stylus Photo R3000") == 0) ||
1353 (strcmp(modelName, "PX-7V" ) == 0) ||
1354 (strcmp(modelName, "Epson Stylus Photo R2000") == 0) ||
1355 (strcmp(modelName, "EP-4004" ) == 0) ||
1356 (strcmp(modelName, "Artisan 1430" ) == 0) ||
1357 (strcmp(modelName, "Epson Stylus Photo 1430") == 0) ||
1358 (strcmp(modelName, "Epson Stylus Photo 1500") == 0) )
1359 {
1360 return TRUE;
1361 }
1362 } else if(EPS_MDC_NOZZLE == ch){ /* nozzle patern */
1363 if( (strcmp(modelName, "PX-5V" ) == 0) ||
1364 (strcmp(modelName, "Epson Stylus Photo R3000") == 0) ||
1365 (strcmp(modelName, "PX-7V" ) == 0) ||
1366 (strcmp(modelName, "Epson Stylus Photo R2000") == 0) )
1367 {
1368 return TRUE;
1369 }
1370 }
1371
1372 return FALSE;
1373 }
1374
1375 static EPS_INT8 modelFY11Bussiness[][16] = {
1376 "PX-1600F", "WF-7510 Series", "WF-7511 Series", "WF-7515 Series",
1377 "PX-1700F", "WF-7520 Series", "WF-7521 Series", "WF-7525 Series",
1378 "PX-1200", "WF-7010 Series", "WF-7011 Series", "WF-7012 Series", "WF-7015 Series",
1379 "PX-B750F", "WP-4511 Series", "WP-4515 Series", "WP-4521 Series", "WP-4525 Series",
1380 "WP-4530 Series", "WP-4531 Series", "WP-4535 Series",
1381 "WP-4540 Series", "WP-4545 Series",
1382 "PX-B700", "WP-4015 Series", "WP-4011 Series", "WP-4020 Series", "WP-4025 Series"
1383 };
1384
obsEnableDuplex(EPS_INT32 sizeID)1385 EPS_BOOL obsEnableDuplex (
1386
1387 EPS_INT32 sizeID
1388
1389 ){
1390 const EPS_INT8 *modelName = NULL;
1391 EPS_INT32 i = 0;
1392
1393 if( !(sizeID == EPS_MSID_A4 ||
1394 sizeID == EPS_MSID_LETTER ||
1395 sizeID == EPS_MSID_B5 ))
1396 {
1397 modelName = g_observer.printer->modelName;
1398 for(i = 0; i < 28; i++){
1399 if( strcmp(modelName, modelFY11Bussiness[i]) == 0){
1400 return FALSE;
1401 }
1402 }
1403 }
1404
1405 return TRUE;
1406 }
1407
obsEnableAutoFeed(void)1408 EPS_BOOL obsEnableAutoFeed (
1409
1410 void
1411
1412 ){
1413 const EPS_INT8 *modelName = NULL;
1414 EPS_INT32 i = 0;
1415
1416 modelName = g_observer.printer->modelName;
1417 for(i = 0; i < 28; i++){
1418 if( strcmp(modelName, modelFY11Bussiness[i]) == 0){
1419 return TRUE;
1420 }
1421 }
1422
1423 return FALSE;
1424 }
1425 /*____________________________ epson-escpr-services.c ______________________________*/
1426
1427 /*34567890123456789012345678901234567890123456789012345678901234567890123456789012345678*/
1428 /* 1 2 3 4 5 6 7 8 */
1429 /*******************************************|********************************************/
1430 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
1431 /***** End of File *** End of File *** End of File *** End of File *** End of File ******/
1432 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
1433