TPHDrv.c 。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
/******************************************************************************
* *
* M O D U L E D E F I N E *
* *
******************************************************************************/
#define TPHDrv_C
/******************************************************************************
* *
* C O M P I L E R D E F I N E D I N C L U D E F I L E S *
* *
******************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/******************************************************************************
* *
* U S E R D E F I N E D I N C L U D E F I L E S *
* *
******************************************************************************/
#include "Common.h"
#include "XCore.h"
#include "XADC.h"
#include "XTimer.h"
#include "XMotor.h"
#include "XProFile.h"
#include "TPHDrv.h"
/******************************************************************************
* *
* L O C A L D E F I N E S *
* *
******************************************************************************/
#define HEAT_TIMER_DIV 16UL
#define HEAT_CLOCK_TIME (PERIPHERAL_CLOCK / HEAT_TIMER_DIV)
#define HEAT_CHANGE_TIME (8 * HEAT_CLOCK_TIME / 1000000) // 8 us
#define HEAT_KEEP_TIME 100
#define STROBE_DELAY_TIME 100
#define TPH_DELAY_TIME 200
#define LATCH_DELAY_TIME 10
#define TPH_POWER_ON gpio_setportval(GPIO_PORTB,BIT11,BIT11)
#define TPH_POWER_OFF gpio_setportval(GPIO_PORTB,BIT11,0)
#define TPH_STROBE1_ON gpio_setportval(GPIO_PORTB,BIT8,BIT8)
#define TPH_STROBE1_OFF gpio_setportval(GPIO_PORTB,BIT8,0)
#define TPH_STROBE3_ON gpio_setportval(GPIO_PORTB,BIT7,BIT7)
#define TPH_STROBE3_OFF gpio_setportval(GPIO_PORTB,BIT7,0)
#define TPH_LATCH_HIGH gpio_setportval(GPIO_PORTB,BIT10,0);
#define TPH_LATCH_LOW gpio_setportval(GPIO_PORTB,BIT10,BIT10);
#include "..\..\appl\Parser\ParserUtil.h"
#define HISTORY_MAX_SPEED SPEED(7.5)
#define CAL_DOT_MAX_SPEED SPEED(7.5)
#define HISTORY_SECOND_MAX_SPEED SPEED(7.5)
#if defined(TTP245P) || defined(TDP245P)
#define HISTORY_COMPENSATE (FLOAT)32 // Percent
#define TEMP_COMPENSATE (FLOAT)99.3 // Percent
#define HEAT_SCALE (6 * 16)
#elif defined(TTP345) || defined(TDP345)
#define HISTORY_COMPENSATE (FLOAT)40 // Percent
#define TEMP_COMPENSATE (FLOAT)99.3 // Percent
#define HEAT_SCALE (6 * 16)
#elif defined(XPH500B) ||defined(DELUXE_2045) || defined(XPH400B)
#if defined(TPH_DPI_200)
#define HISTORY_COMPENSATE (FLOAT)32 // Percent
#define TEMP_COMPENSATE (FLOAT)99.0 // Percent
#define HEAT_SCALE (6 * 16)
#else
#define HISTORY_COMPENSATE (FLOAT)26 // Percent
#define TEMP_COMPENSATE (FLOAT)99.9 // Percent
#define HEAT_SCALE (6 * 16)
#endif
#elif defined(XPH500E) ||defined(DELUXE_3044)
#define HISTORY_COMPENSATE (FLOAT)40 // ¶þ´Î¼ÓÈÈ°Ù·Ö±È
#define TEMP_COMPENSATE (FLOAT)99.3 // ÏÂÒ»ÕżÓÈȱÈ
#define HEAT_SCALE (6 * 16)
#else
#define HISTORY_COMPENSATE (FLOAT)32 // Percent
#define TEMP_COMPENSATE (FLOAT)99.3 // Percent
#define HEAT_SCALE (6 * 16)
#endif
#define HEAT_PART 1
#define HEAT_TIMES 0
#define HISTORY_TIMES 0
#define HEAT_RESIST_MAX (FLOAT)0
#define HEAT_RESIST_MIN (FLOAT)0
#define STORAGE_WEIGHT 0
#define RADIATION_COEFFICIENT (FLOAT)0.952
#define SPEED_LEVEL (sizeof(HeatPercent) / sizeof(FLOAT))
#define MAX_HEAT_LEVEL 512
#define MAX_TEMP_LEVEL 64
#define PRINT_LINE_SHIFT_BYTE 0
#define LINE_REF_TOTAL 4
/******************************************************************************
* *
* L O C A L T Y P E D E F S *
* *
******************************************************************************/
enum {
HEAT_OFF,
HEAT_HALF_FIRST,
HEAT_HALF_LAST,
HEAT_FULL,
};
enum {
HEAT_NULL = 0,
SEND_FIRST_LINE, // 1
HEAT_FIRST_LINE, // 2
SEND_SECOND_FINISH, // 3
HEAT_FIRST_FINISH, // 4
HEAT_SECOND_LINE, // 5
SEND_TPH_DATA, // 6
HEAT_SWITCH, // 7
HEAT_SWITCH_ON, // 8
HEAT_SWITCH_OFF, // 9
};
/******************************************************************************
* *
* L O C A L F U N C T I O N P R O T O T Y P E S *
* *
******************************************************************************/
#define SetHeatTime(a) do{/*debug_printf("%s\n", __FUNCTION__);*/_SetHeatTime(a);}while(0)
STATIC VOID _SetHeatTime(WORD);
STATIC VOID HeatStorage(UINT);
STATIC VOID HeatRadiation(VOID);
/******************************************************************************
* *
* L O C A L I N I T I A L I Z E D D A T A D E F I N I T I O N S *
* *
******************************************************************************/
//--- TPH temperture level ---//
STATIC CONST WORD TempertureTable[] =
{
739,729,718,707,696,685,674,662,651,639,628,616,605,593,581,570, // 5 ¢J ~ 20 ¢J
558,546,535,523,512,501,489,478,467,456,445,435,424,414,403,393, // 21 ¢J ~ 36 ¢J
383,374,364,355,345,336,327,319,310,302,294,286,278,270,263,256, // 37 ¢J ~ 52 ¢J
248,242,235,228,222,216,210,204,198,192,187,182,177,172,167,162, // 53 ¢J ~ 68 ¢J
157,153,149,145,140,137,133,129,125,122,119,115,112,109,106,103, // 69 ¢J ~ 84 ¢J
100, 97, 95, 92, 90, 87, 85, 83, 80, 78, 76, 74, 72, 70, 68, 67, // 85 ¢J ~ 100 ¢J
};
#if defined(TTP245P) || defined(TDP245P) || defined(XP470B) \
|| defined(XP450B) || defined(DELUXE_2044) ||defined(XPDT425B) \
|| defined(XPDT108BLABEL) ||defined(XP460B)\
|| defined(XP490B) ||defined(XPDT427B)
#if defined(THP_15P)
STATIC FLOAT HeatPercent[] =
{
(FLOAT)45.0, // 1.5
(FLOAT)52.8, // 2
(FLOAT)57.9, // 2.5
(FLOAT)62.9, // 3
(FLOAT)65.0, // 3.5
(FLOAT)67.0, // 4
(FLOAT)68.9, // 4.5
(FLOAT)70.1, // 5
(FLOAT)73.7, // 5.5
(FLOAT)77.2, // 6
(FLOAT)79.1, // 6.5
(FLOAT)81.0, // 7
(FLOAT)83.0, // 7.5
(FLOAT)85.0, // 8
};
#elif defined(THP_9P)
STATIC FLOAT HeatPercent[] =
{
(FLOAT)51.1, // 1.5
(FLOAT)59.9, // 2
(FLOAT)65.7, // 2.5
(FLOAT)71.4, // 3
(FLOAT)73.8, // 3.5
(FLOAT)76.0, // 4
(FLOAT)78.2, // 4.5
(FLOAT)79.5, // 5
(FLOAT)83.6, // 5.5
(FLOAT)87.6, // 6
(FLOAT)89.8, // 6.5
(FLOAT)91.9, // 7
(FLOAT)94.2, // 7.5
(FLOAT)96.5, // 8
};
#endif
#elif defined(XPH500B) ||defined(DELUXE_2045) ||defined(XPH400B)
#if defined(TPH_MM_104)
STATIC FLOAT HeatPercent[] =
{
(FLOAT)54.6 , // 1.5
(FLOAT)64.1 , // 2
(FLOAT)70.2 , // 2.5
(FLOAT)76.3 , // 3
(FLOAT)78.9 , // 3.5
(FLOAT)81.3 , // 4
(FLOAT)83.6 , // 4.5
(FLOAT)85.0 , // 5
(FLOAT)89.4 , // 5.5
(FLOAT)93.7 , // 6
(FLOAT)96.0 , // 6.5
(FLOAT)98.3 , // 7
(FLOAT)99.0 , // 7.5
(FLOAT)99.0 , // 8
};
#else
STATIC FLOAT HeatPercent[] =
{
#if 1
// ch_20220421 : old.
// (FLOAT)58.9 , // 1.5
// (FLOAT)64.5 , // 2
// (FLOAT)69.9 , // 2.5
// (FLOAT)74.1 , // 3
// (FLOAT)76.1 , // 3.5
// (FLOAT)80.9 , // 4
// (FLOAT)94.5 , // 4.5
// (FLOAT)99.9 , // 5
// ch_20220421 : new.
// (FLOAT)(58.9 + (1*10)) , // 1.5
// (FLOAT)(64.5 + (1*10)) , // 2
// (FLOAT)(69.9 + (1*10)) , // 2.5
// (FLOAT)(74.1 + (1*10)) , // 3
// (FLOAT)(76.1 + (1*10)) , // 3.5
// (FLOAT)(80.9 + (1*10)) , // 4
// (FLOAT)(94.5 + (1*10)) , // 4.5
// (FLOAT)(99.9 + (1*10)) , // 5
// ch_20220610
// // ch_20220422 : The following value is OK for sale.
// (FLOAT)(58.9+(6*4)), // 0
// (FLOAT)(61.7+(6*4)), // 1
// (FLOAT)(64.5+(6*4)), // 2
// (FLOAT)(67.3+(4*12)), // 3
// (FLOAT)(70.1+(4*12)), // 4
// (FLOAT)(72.9+(4*12)), // 5
// (FLOAT)(75.7+(4*12+6)+18+6+6), // 6
// (FLOAT)(78.5+(4*12+6)+18+6+6), // 7
// (FLOAT)(81.3+(4*12+6)+18+6+6), // 8
// (FLOAT)(84.1+(5*12)+18+6+6), // 9
// (FLOAT)(86.9+(5*12)+18+6+6), // 10
// (FLOAT)(89.7+(5*12)+18+6+6), // 11
// (FLOAT)(92.5+(5*12)+18+6+6), // 12
// (FLOAT)(95.3+(5*12)+18+6+6), // 13
// (FLOAT)(99.9+(5*12)+18+6+6),//98.1 // 14
// ch_20220610 : The following value is OK for sale.
(FLOAT)(58.9+(5*3)), // 0
(FLOAT)(61.7+(5*3)), // 1
(FLOAT)(64.5+(5*3)), // 2
(FLOAT)(67.3+(5*3)), // 3
(FLOAT)(70.1+(5*3)), // 4
(FLOAT)(72.9+(5*3)), // 5
(FLOAT)(75.7+(5*3)), // 6
(FLOAT)(78.5+(5*3)+1+1), // 7
(FLOAT)(81.3+(5*3)+1+1), // 8
(FLOAT)(84.1+(5*3)+1+1), // 9
(FLOAT)(86.9+(5*3)+1+1), // 10
(FLOAT)(89.7+(5*3)+1+1), // 11
(FLOAT)(92.5+(5*3)+1+1), // 12
(FLOAT)(95.3+(5*3)+1+1), // 13
(FLOAT)(99.9+(5*3)+1+1),//98.1 // 14
(FLOAT)64.1 , // 5.5
(FLOAT)64.3 , // 6
(FLOAT)64.5 , // 6.5
(FLOAT)64.7 , // 7
(FLOAT)64.9 , // 7.5
(FLOAT)65.1 , // 8
// (FLOAT)53.9 , // 1.5
// (FLOAT)59.5 , // 2
// (FLOAT)64.9 , // 2.5
// (FLOAT)69.1 , // 3
// (FLOAT)71.1 , // 3.5
// (FLOAT)75.9 , // 4
// (FLOAT)79.5 , // 4.5
// (FLOAT)83.9 , // 5
// (FLOAT)84.1 , // 5.5
// (FLOAT)84.3 , // 6
// (FLOAT)84.5 , // 6.5
// (FLOAT)84.7 , // 7
// (FLOAT)84.9 , // 7.5
// (FLOAT)85.1 , // 8
#else
(FLOAT)53.9 , // 1.5
(FLOAT)59.5 , // 2
(FLOAT)65.2 , // 2.5
(FLOAT)70.8 , // 3
(FLOAT)78.3 , // 3.5
(FLOAT)85.7 , // 4
(FLOAT)93.7 , // 4.5
(FLOAT)101.7 , // 5
(FLOAT)106.9 , // 5.5
(FLOAT)111.9 , // 6
(FLOAT)114.7 , // 6.5
(FLOAT)117.5 , // 7
(FLOAT)120.4 , // 7.5
(FLOAT)123.3 , // 8
#endif
};
#endif
#elif defined(XPH500E) ||defined(DELUXE_3044)
STATIC FLOAT HeatPercent[] =
{
(FLOAT) 60.97, // 1
(FLOAT) 76.21, // 1.5
(FLOAT) 87.79, // 2
(FLOAT) 91.91, // 2.5
(FLOAT) 96.03, // 3
(FLOAT)100.29, // 3.5
(FLOAT)104.41, // 4
(FLOAT)106.39, // 4.5
(FLOAT)108.22, // 5
(FLOAT)109.74, // 5.5
(FLOAT)111.27, // 6
};
#elif defined(TTP345) || defined(TDP345)
STATIC FLOAT HeatPercent[] =
{
(FLOAT)40.0, // 1
(FLOAT)50.0, // 1.5
(FLOAT)57.6, // 2
(FLOAT)60.3, // 2.5
(FLOAT)63.0, // 3
(FLOAT)65.8, // 3.5
(FLOAT)68.5, // 4
(FLOAT)69.8, // 4.5
(FLOAT)71.0, // 5
(FLOAT)72.0, // 5.5
(FLOAT)73.0, // 6
};
#endif
STATIC CONST BYTE ByteDots[256] =
{
0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4,1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,
1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,4,5,5,6,5,6,6,7,5,6,6,7,6,7,7,8,
};
/******************************************************************************
* *
* L O C A L U N I T I A L I Z E D D A T A D E F I N I T I O N S *
* *
******************************************************************************/
// TPH Heat Time
STATIC WORD MaximumHeat[SPEED_LEVEL];
STATIC WORD HeatFirstTab[SPEED_LEVEL][MAX_HEAT_LEVEL];
STATIC WORD HeatSecondTab[SPEED_LEVEL][MAX_HEAT_LEVEL];
STATIC WORD HeatFirstTime;
STATIC WORD HeatSecondTime;
STATIC FLOAT HeatResistMax;
STATIC FLOAT HeatResistMin;
STATIC FLOAT HeatResistTable[TPH_WIDTH_DOT + 1];
STATIC BOOL IsCalcDots;
STATIC UINT HeatActDots;
// Heat Storage Coefficient
STATIC UINT HeatStorageCounter;
STATIC UINT HeatStorageWeight;
STATIC FLOAT RadiationCoefficient;
#if defined(__HITACHI__)
#pragma section SRAM
#endif
STATIC BYTE InvertByte[256];
// Print Line Buffer
STATIC DWORD *pPrintLine, *pHistoryLine;
STATIC DWORD PrintLineBuf[LINE_REF_TOTAL][TPH_WIDTH_INT];
STATIC DWORD PrintLineOffset;
STATIC DWORD HistoryBuf[TPH_WIDTH_INT];
STATIC DWORD HistorySecondBuf[TPH_WIDTH_INT];
STATIC BOOL HistorySecondControl;
STATIC WORD HeatThreeTime;
STATIC WORD PrtDirection;
STATIC WORD PrtMirror;
STATIC BYTE *pPrtCurImg;
STATIC WORD PrtStartLine;
STATIC WORD PrtEndLine;
STATIC WORD PrtCurrLine;
STATIC BOOL SendFirstLine;
STATIC BOOL HistoryControl;
STATIC INT HeatState;
STATIC BOOL TranCPLD;
#if defined(__HITACHI__)
#pragma section
#endif
STATIC FLOAT HistoryCompensate;
STATIC FLOAT TempCompensate;
STATIC SHORT HeatScale;
STATIC FLOAT DensityBase;
STATIC UINT HeatPart; // Part of the heating
STATIC UINT HeatTimes; // Heats up many times
STATIC UINT HistoryTimes;
STATIC UINT NoHeatCnt = 0; // ch_20220816
STATIC VOLATILE ULONG SurplusLines = 0; // ch_20220819
/******************************************************************************
*
* Function:
*
*
* Description:
*
*
* Input:
* None
*
* Output:
* None.
*
******************************************************************************/
extern VOID sysTimerISR(VOID);
VOID InitialTPHDrv(VOID)
{
UINT dummy;
FLOAT data;
CHAR key[128];
INT speed;
// _PrintCfg *SpeedCfg = GrabPrintConfig(); // ch_20220526
#if defined(AT91SAM9260)
/
// Initial Heat Timer
/
// Disable the Clock Counter
AT91C_BASE_TC3->TC_CCR = AT91C_TC_CLKDIS;
// Disable all interrupts
AT91C_BASE_TC3->TC_IDR = 0xFFFFFFFF;
// Clear the status register
dummy = AT91C_BASE_TC3->TC_SR;
// Select divider and compare trigger and clock disable with RC compare
AT91C_BASE_TC3->TC_CMR = AT91C_TC_CLKS_TIMER_DIV2_CLOCK | // MCK/8
AT91C_TC_CPCDIS |
AT91C_TC_WAVESEL_UP_AUTO |
AT91C_TC_WAVE;
// Enable the Clock counter
AT91C_BASE_TC3->TC_CCR = AT91C_TC_CLKEN;
// Validate the RC compare interrupt
AT91C_BASE_TC3->TC_IER = AT91C_TC_CPCS;
// Register timer interrupt handler
AT91F_AIC_ConfigureIt ( AT91C_BASE_AIC, // AIC base address
AT91C_ID_TC3, // Peripheral ID
HEAT_PRIORITY, // Priority
AT91C_AIC_SRCTYPE_INT_LEVEL_SENSITIVE, // Level sensitive
HeatTimerHandler );
// Enable TC3 interrupt
AT91F_AIC_EnableIt(AT91C_BASE_AIC, AT91C_ID_TC3);
/
// Initial TPH Transmission
/
// Configure SSC0
AT91F_SSC_Configure(
AT91C_BASE_SSC0, // SSC0 base address
PERIPHERAL_CLOCK, // Peripheral clock
TPH_TRANSMISSION_FREQUENCY, // Expected Baud Rate Frequency
0, // Receiver Clock Parameters
0, // Receiver mode Register to be programmed
AT91C_SSC_CKI | AT91C_SSC_CKO_DATA_TX, // Transmitter Clock Parameters
7); // Transmitter mode Register to be programmed
// Enable Transmitter
AT91F_SSC_EnableTx(AT91C_BASE_SSC0);
// Register interrupt handler
AT91F_AIC_ConfigureIt ( AT91C_BASE_AIC, // AIC base address
AT91C_ID_SSC0, // Peripheral ID
TPH_DATA_PRIORITY, // Priority
AT91C_AIC_SRCTYPE_INT_LEVEL_SENSITIVE, // Level sensitive
TPHTransmitHandler );
// Enable SSC0 interrupt
AT91F_AIC_EnableIt(AT91C_BASE_AIC, AT91C_ID_SSC0);
#elif defined(N3290)
sysSetTimerReferenceClock(TIMER0,sysGetExternalClock() * 1000);
outp32(REG_APBCLK, inp32(REG_APBCLK) | TMR0_CKE);
outp32(REG_APBIPRST, inp32(REG_APBIPRST) | TMR0RST);
outp32(REG_APBIPRST, inp32(REG_APBIPRST) & ~TMR0RST);
sysInstallISR(IRQ_LEVEL_1, IRQ_TMR0, (PVOID)HeatTimerHandler);
sysEnableInterrupt(IRQ_TMR0);
sysSetInterruptType(IRQ_TMR0, 1);
#endif
HeatFirstTime = 0;
HeatSecondTime = 0;
HeatThreeTime = 0;
PrtDirection = 0;
PrtMirror = 0;
PrtStartLine = 0;
PrtEndLine = 0;
PrtCurrLine = 0;
SendFirstLine = FALSE;
HistoryControl = FALSE;
HistorySecondControl = FALSE;
HeatState = HEAT_NULL;
for (speed = 0; speed < SPEED_LEVEL; speed++)
{
sprintf(key, "%s INCH HEAT PERCENTAGE", ToSpeedString(speed));
if (GetProfileInt(key, &data))
HeatPercent[speed] = data;
// HeatPercent[((SpeedCfg->Speed+1)>>1)-1][speed] = data; // ch_20220526
}
HistoryCompensate = HISTORY_COMPENSATE;
if (GetProfileInt("HISTORY RECOMPENSE PERCENTAGE", &data))
HistoryCompensate = data;
TempCompensate = TEMP_COMPENSATE;
if (GetProfileInt("TEMPERATURE RECOMPENSE PERCENTAGE", &data))
TempCompensate = data;
HeatScale = HEAT_SCALE;
if (GetProfileInt("SCALE OF HEAT", &data))
HeatScale = (SHORT)data;
if (HeatScale > MAX_HEAT_LEVEL - MAX_TEMP_LEVEL)
HeatScale = MAX_HEAT_LEVEL - MAX_TEMP_LEVEL;
//sysprintf("H_scale = %d\n", HeatScale); // ch_20220329
DensityBase = 0;
if (GetProfileInt("BASE DENSITY", &data))
DensityBase = data;
HeatPart = HEAT_PART;
if (GetProfileInt("PART OF HEAT", &data))
HeatPart = (SHORT)data;
HeatTimes = HEAT_TIMES;
if (GetProfileInt("TIMES OF HEAT", &data))
HeatTimes = (SHORT)data;
HistoryTimes = HISTORY_TIMES;
if (GetProfileInt("TIMES OF HISTORY", &data))
HistoryTimes = (SHORT)data;
HeatStorageCounter = 0;
HeatStorageWeight = STORAGE_WEIGHT;
if (GetProfileInt("WEIGHT OF STORAGE", &data))
{
HeatStorageWeight = (UINT)data;
RadiationCoefficient = RADIATION_COEFFICIENT;
if (GetProfileInt("COEFFICIENT OF RADIATION", &data))
RadiationCoefficient = data;
}
if (HeatStorageWeight)
StartPeriodFunc(HeatRadiation);
HeatResistMax = HEAT_RESIST_MAX;
if (GetProfileInt("MAX RESISTANT", &data))
HeatResistMax = data;
HeatResistMin = HEAT_RESIST_MIN;
if (GetProfileInt("MIN RESISTANT", &data))
HeatResistMin = data;
IsCalcDots = FALSE;
if (HeatStorageWeight)
IsCalcDots = TRUE;
if (HeatResistMax && HeatResistMin)
IsCalcDots = TRUE;
}
INT GetHeatScale(VOID)
{
return HeatScale;
}
STATIC VOID TPHHeat(INT Value)
{
//debug_printf("%d,",Value);
if (Value == HEAT_OFF)
{
//debug_printf("0");
#if defined(TPH_STROBE1_OFF)
TPH_STROBE1_OFF; DelayTime(STROBE_DELAY_TIME);
#endif
#if defined(TPH_STROBE2_OFF)
TPH_STROBE2_OFF; DelayTime(STROBE_DELAY_TIME);
#endif
#if defined(TPH_STROBE3_OFF)
TPH_STROBE3_OFF; DelayTime(STROBE_DELAY_TIME);
#endif
#if defined(TPH_STROBE4_OFF)
TPH_STROBE4_OFF; DelayTime(STROBE_DELAY_TIME);
#endif
}
else if (Value == HEAT_HALF_FIRST)
{
debug_printf("1");
#if defined(TPH_STROBE1_ON)
TPH_STROBE1_ON; DelayTime(STROBE_DELAY_TIME);
#endif
#if defined(TPH_STROBE2_ON)
TPH_STROBE2_ON; DelayTime(STROBE_DELAY_TIME);
#endif
#if defined(TPH_STROBE3_OFF)
TPH_STROBE3_OFF; DelayTime(STROBE_DELAY_TIME);
#endif
#if defined(TPH_STROBE4_OFF)
TPH_STROBE4_OFF; DelayTime(STROBE_DELAY_TIME);
#endif
}
else if (Value == HEAT_HALF_LAST)
{
debug_printf("2");
#if defined(TPH_STROBE1_OFF)
TPH_STROBE1_OFF; DelayTime(STROBE_DELAY_TIME);
#endif
#if defined(TPH_STROBE2_OFF)
TPH_STROBE2_OFF; DelayTime(STROBE_DELAY_TIME);
#endif
#if defined(TPH_STROBE3_ON)
TPH_STROBE3_ON; DelayTime(STROBE_DELAY_TIME);
#endif
#if defined(TPH_STROBE4_ON)
TPH_STROBE4_ON; DelayTime(STROBE_DELAY_TIME);
#endif
}
else if (Value == HEAT_FULL)
{
//debug_printf("3");
#if defined(TPH_STROBE1_ON)
TPH_STROBE1_ON; DelayTime(STROBE_DELAY_TIME);
#endif
#if defined(TPH_STROBE2_ON)
TPH_STROBE2_ON; DelayTime(STROBE_DELAY_TIME);
#endif
#if defined(TPH_STROBE3_ON)
TPH_STROBE3_ON; DelayTime(STROBE_DELAY_TIME);
#endif
#if defined(TPH_STROBE4_ON)
TPH_STROBE4_ON; DelayTime(STROBE_DELAY_TIME);
#endif
}
}
VOID StopTPH(VOID)
{
SendFirstLine = FALSE;
HeatState = HEAT_NULL;
TPHHeat(HEAT_OFF);
SetTPHPower(FALSE);
}
VOID SetTPHPower(INT Value)
{
if (Value)
TPH_POWER_ON; // enable TPH power
else
TPH_POWER_OFF; // disable TPH power
}
STATIC BYTE InvertByteData(BYTE data)
{
BYTE inv;
inv = (data & 0x01) << 7;
inv = inv | ((data & 0x02) << 5);
inv = inv | ((data & 0x04) << 3);
inv = inv | ((data & 0x08) << 1);
inv = inv | ((data & 0x10) >> 1);
inv = inv | ((data & 0x20) >> 3);
inv = inv | ((data & 0x40) >> 5);
inv = inv | ((data & 0x80) >> 7);
return inv;
}
//
STATIC VOID CopyTPHLine(BYTE *dst, BYTE *src)
{
BYTE *swap = (BYTE *)InvertByte;
INT i;
#if defined(AT91SAM9260) || defined(N3290)
if (PrtDirection ^ PrtMirror) //判断PrtDirection和PrtMirror的值是否相等,不相等执行
{
for (i = TPH_WIDTH_BYTE - PRINT_LINE_SHIFT_BYTE - 1; i >= 0; i--)
*dst++ = *(src + i);
}
else //PrtDirection和PrtMirror的值相等的情况
{
src+= PRINT_LINE_SHIFT_BYTE;
memcpy(dst, src, TPH_WIDTH_BYTE - PRINT_LINE_SHIFT_BYTE);
}
#elif defined(SH7040)
if (PrtDirection ^ PrtMirror)
{
dst += PRINT_LINE_SHIFT_BYTE;
memcpy(dst, src, TPH_WIDTH_BYTE - PRINT_LINE_SHIFT_BYTE);
}
else
{
src += PRINT_LINE_SHIFT_BYTE;
for (i = 0; i < TPH_WIDTH_BYTE - PRINT_LINE_SHIFT_BYTE; i++)
*dst++ = *(swap + *src++);
}
#endif
}
VOID SetDensityBase(FLOAT DBase,FLOAT TCompensate)
{
DensityBase = DBase;
TempCompensate = TCompensate;
CalculateHeatTable();
}
VOID SetHistoryCompensate(FLOAT HCompensate)
{
HistoryCompensate=HCompensate;
CalculateHeatTable();
}
VOID CalculateHeatTable(VOID)
{
FLOAT First, Second, Next;
FLOAT HeatRatio, BaseAdjust;
INT BasePeriod;
INT Speed, Heat;
INT HeatTotal;
INT i;
// _PrintCfg *SpeedCfg = GrabPrintConfig(); // ch_20220525
HeatTotal = HeatScale + MAX_TEMP_LEVEL;//HEAT_SCALE
First = ((FLOAT)100 - HistoryCompensate) / (FLOAT)100;
Second = HistoryCompensate / (FLOAT)100;//HISTORY_COMPENSATE
Next = TempCompensate / (FLOAT)100;//TEMP_COMPENSATE
BasePeriod = (INT)(DensityBase * HeatScale / 16);
BasePeriod = abs(BasePeriod);
BaseAdjust = (FLOAT)1;
for (i = 0; i < BasePeriod; i++)
{
if (DensityBase > 0)
BaseAdjust /= (FLOAT)Next;
else
BaseAdjust *= (FLOAT)Next;
}
for (Speed = 0; Speed < SPEED_LEVEL; Speed++)
{
/
// ch_20220601 : restore
// ch_20220526 : add
HeatRatio = BaseAdjust * HeatPercent[Speed] / (FLOAT)100;
//if (HeatRatio > (FLOAT)0.95)
// HeatRatio = (FLOAT)0.95;
// HeatRatio = BaseAdjust * HeatPercent[((SpeedCfg->Speed+1)>>1)-1][Speed] / (FLOAT)100;
/
MaximumHeat[Speed] = HEAT_CLOCK_TIME / (ToSpeedValue(Speed) * TPH_DPI);
HeatFirstTab[Speed][HeatTotal - 1] = (WORD)((FLOAT)MaximumHeat[Speed] * HeatRatio * First);
HeatSecondTab[Speed][HeatTotal - 1] = (WORD)((FLOAT)MaximumHeat[Speed] * HeatRatio * Second);
for (Heat = HeatTotal - 1; Heat > 0; Heat--)
{
HeatFirstTab[Speed][Heat - 1] = (WORD)((FLOAT)HeatFirstTab[Speed][Heat] * Next);
HeatSecondTab[Speed][Heat - 1] = (WORD)((FLOAT)HeatSecondTab[Speed][Heat] * Next);
}
#if defined(HEAT_CHANGE_TIME)
for (Heat = 0; Heat < HeatTotal; Heat++)
{
HeatFirstTab[Speed][Heat] += HEAT_CHANGE_TIME;
HeatSecondTab[Speed][Heat] += HEAT_CHANGE_TIME;
//debug_printf("Heat,%d,%d\r\n", HeatFirstTab[Speed][Heat],HeatSecondTab[Speed][Heat]);
}
//debug_printf("--");
#endif
}
//debug_printf("--\r\n");
for (i = TPH_WIDTH_DOT; i >= 0; i--)
{
HeatResistTable[i] = (HeatResistMax - HeatResistMin) * i / TPH_WIDTH_DOT + HeatResistMin;
//debug_printf("Heat:%d\r\n",HeatResistTable[i]);
}
//debug_printf("--\r\n");
for (i = 0; i < sizeof(InvertByte) / sizeof(BYTE); i++)
{
InvertByte[i] = InvertByteData(i);
//debug_printf("Inver:%d\r\n",InvertByte[i]);
}
}
WORD CalculateTPHTemp(WORD Value)
{
INT i;
for (i = 0; i < sizeof(TempertureTable) / sizeof(WORD); i++)
{
if (Value > TempertureTable[i])
break;
}
//debug_printf("c%d\n",i+5);
return (i + 5);
}
WORD CalculateTPHTempLevel(WORD Value)
{
WORD Level;
Level = CalculateTPHTemp(Value) - 5;
if (Level > MAX_TEMP_LEVEL - 1)
Level = MAX_TEMP_LEVEL - 1;
return Level;
}
VOID CalculateHeatTime(WORD Speed, WORD Density, WORD TempLevel)
{
SHORT HeatLevel;
FLOAT StorageCoefficient;
STATIC WORD HeatFirstTimeBkp = 0, HeatSecondTimeBkp = 0; // ch_20220531
STATIC ULONG LableQuantity = 0; // ch_202206023
_PrintCfg *pPrintingCfg = GrabPrintConfig(); // ch_20220815
//sysprintf("S_%d/D_%d\n", Speed, (WORD)pPrintingCfg->fDensity); // ch_20220815
HeatLevel = Density;
// if (HeatLevel > HeatScale - 1) // ch_20220708
// HeatLevel = HeatScale - 1; // ch_20220708
#if defined(TTP244M)
if (Speed == 0) // 1.5"
HeatLevel = HeatLevel * (HeatScale - 16) / HeatScale;
#elif defined(TTP342M)/* || defined(TTP342) || defined(B443_300) || defined(TTP342PP)*/
if (Speed == 2) // 2"
HeatLevel = HeatLevel * (HeatScale - 16) / HeatScale;
#endif
HeatLevel += MAX_TEMP_LEVEL - TempLevel;
if (HeatLevel > 150) // ch_20220727 : changed to 150 from 159 cause Power down. // ch_20220708
HeatLevel = 150; // ch_20220727 : changed to 150 from 159 cause Power down. // ch_20220708
/
// ch_20220815
// Special process for the different speed and density.
if (HeatLevel < 43) // ch_20220811
HeatLevel = 43; // ch_20220811
if (HeatLevel < 53) // ch_20220713
HeatLevel = 53; // ch_20220713
// if (HeatLevel < 63) // ch_20220812 // ch_20220713
// HeatLevel = 63; // ch_20220812 // ch_20220713
if (HeatLevel < 53) // ch_20220812 // ch_20220713
HeatLevel = 53; // ch_20220812 // ch_20220713
if ((5 == Speed)&&
((14 == ((WORD)pPrintingCfg->fDensity))||(13 == ((WORD)pPrintingCfg->fDensity))||
(15 == ((WORD)pPrintingCfg->fDensity)))) {
if (HeatLevel < 63)
HeatLevel = 63;
}
else if ((7 == Speed)&&(15 == ((WORD)pPrintingCfg->fDensity))) {
if (HeatLevel < 80)
HeatLevel = 80;
}
else {
if (HeatLevel < 53)
HeatLevel = 53;
}
/
HeatFirstTime = HeatFirstTab[Speed][HeatLevel];
HeatSecondTime = HeatSecondTab[Speed][HeatLevel];
/
// ch_20220816
if (NoHeatCnt) {
NoHeatCnt--;
HeatFirstTime = 1; HeatSecondTime = 1;
//sysprintf("C_L_S_%d\n", 0);
}
/
if (HeatTimes)
{
HeatFirstTime = (HeatFirstTime + HeatSecondTime) * HeatPart / HeatTimes;
HeatSecondTime = (MaximumHeat[Speed] - HEAT_KEEP_TIME * HEAT_CLOCK_TIME / 1000000) / HeatTimes;
if (HeatFirstTime >= HeatSecondTime)
HeatFirstTime = HeatSecondTime - 1;
HeatSecondTime -= HeatFirstTime;
}
// ch_20220531 : only for debug.
// if ((HeatFirstTime!=HeatFirstTimeBkp)||(HeatSecondTime!=HeatSecondTimeBkp)) {
//sysprintf("%d %d %d %d %d \n", ++LableQty, TempLevel, HeatLevel, HeatFirstTime,HeatSecondTime);
// HeatFirstTimeBkp = HeatFirstTime; HeatSecondTimeBkp = HeatSecondTime;
// }
//debug_printf("Cal:%d,%d,%d\n",HeatFirstTime,HeatSecondTime,HeatTimes);
}
/
VOID CalculatePrintPoint(BYTE Dir, BYTE Mirror, BYTE *pImg, WORD Len, WORD First, WORD Last, WORD Curr)
{
PrtDirection = Dir;
PrtMirror = Mirror;
if (PrtDirection)
{
//sysprintf("pd%d\n", PrtDirection); // 没执行
if (First > Len - 1) First = Len - 1;
if (Last > Len - 1) Last = Len - 1;
pPrtCurImg = pImg + (Last * TPH_WIDTH_BYTE);
PrtStartLine = (Len - 1) - Last;
PrtEndLine = (Len - 1) - First;
PrtCurrLine = Curr;
if (PrtCurrLine >= PrtStartLine && PrtCurrLine <= PrtEndLine)
pPrtCurImg -= (PrtCurrLine - PrtStartLine) * TPH_WIDTH_BYTE;
}
else
{
pPrtCurImg = pImg + (First * TPH_WIDTH_BYTE);
PrtStartLine = First;
PrtEndLine = Last;
PrtCurrLine = Curr;
if (PrtCurrLine >= PrtStartLine && PrtCurrLine <= PrtEndLine)
pPrtCurImg += (PrtCurrLine - PrtStartLine) * TPH_WIDTH_BYTE;
}
memset((BYTE *)PrintLineBuf, 0, sizeof(PrintLineBuf));
PrintLineOffset = 0;
CopyTPHLine((BYTE *)PrintLineBuf[2], pPrtCurImg);
if (PrtDirection)
pPrtCurImg -= TPH_WIDTH_BYTE;
else
pPrtCurImg += TPH_WIDTH_BYTE;
// ch_20220819
if (PrtEndLine) {
SurplusLines = PrtEndLine<<1; //剩余行数存储到全局变量 SurplusLines
//S_L_0 ,E_L_238, C_L_0 ,S_L_476
//sysprintf("S_L_%d\t,E_L_%d\t,C_L_%d\t,S_L_%d\n", PrtStartLine, PrtEndLine, PrtCurrLine, SurplusLines);
}
}
STATIC VOID CalculateHistorySecondControl(BOOL HistorySecond, BOOL LastLine)
{
DWORD *A, *B, *C;
CHAR * XA,*XB;
CHAR XH,XG;
CHAR i_START=0,i_END;
INT i,j;
if (LastLine)
{
CopyTPHLine((BYTE *)HistorySecondBuf,(BYTE *)pPrintLine);
return ;
}
if(HistorySecond)
{
A=pPrintLine;
B=HistoryBuf;
C=HistorySecondBuf;
for (i = 0; i < TPH_WIDTH_INT; i++)
*C++=(*A++)&(~(*B++));
XA=(CHAR *)HistorySecondBuf;
XB=(CHAR *)HistoryBuf;
for ( i = 0 ; i < TPH_WIDTH_INT*4 ; i++ )
{
if(i==TPH_WIDTH_INT*4-1)
i_END=0;
else
i_END=(*(XA+1))&0x1;
for ( ; j < 7; j++ )
{
if(i_START)
{
j++;
i_START=0;
}
if((3<<j)&(*XA))
{
XH|=(2<<j);
j++;
}
}
if(j==7&&i_END&&((*XA)&0x80))
i_START=1;
*XA++=XH|(*XB++);
}
}
}
///
STATIC VOID CalculateHistoryControl(BOOL History, BOOL LastLine) //<--PrintTPHLine(INT Speed, INT Density)
{
DWORD *His, *A, *B, *C, *D;
INT i, j, k;
UINT BitAvaliable = 0, BitContinueAvaliable = 0; // ch_20220811
STATIC UINT BitAvaliableBkp = 0, BitContinueAvaliableBkp = 0; // ch_20220811
STATIC UCHAR ConsecDotLineSum = 0; // ch_20220811
BYTE dst[104] = {0}; // ch_20220811
if (LastLine)
memset(PrintLineBuf[(PrintLineOffset+3) & 0x3], 0, TPH_WIDTH_BYTE);
else
CopyTPHLine((BYTE *)PrintLineBuf[(PrintLineOffset+3) & 0x3], pPrtCurImg);
His = (DWORD *)HistoryBuf;
A = (DWORD *)PrintLineBuf[(PrintLineOffset+0) & 0x3];
B = (DWORD *)PrintLineBuf[(PrintLineOffset+1) & 0x3];
C = (DWORD *)PrintLineBuf[(PrintLineOffset+2) & 0x3];
D = (DWORD *)PrintLineBuf[(PrintLineOffset+3) & 0x3];
PrintLineOffset += 1;
pPrintLine = C;
pHistoryLine = C;
if (History)
{
pHistoryLine = His;
for (i = 0; i < TPH_WIDTH_INT; i++)
*His++ = (~((*A++) | (*B++))) & ((*C++) | (*D++));
}
if (PrtDirection)
pPrtCurImg -= TPH_WIDTH_BYTE;
else
pPrtCurImg += TPH_WIDTH_BYTE;
// ch_20220811
CalculateConsecutiveActDots((BYTE*)pPrintLine, TPH_WIDTH_BYTE, &BitAvaliable, &BitContinueAvaliable); //计算打印的黑点
// if ((BitAvaliable != BitAvaliableBkp)||(BitContinueAvaliable != BitContinueAvaliableBkp)) {
// sysprintf("Dot_all:%d,con:%d,t:%d\n", BitAvaliable, BitContinueAvaliable, HeatFirstTime);
// BitAvaliableBkp = BitAvaliable; BitContinueAvaliableBkp = BitContinueAvaliable;
// }
sysprintf("BitAvaliable=%d\n", BitAvaliable);
if(BitContinueAvaliable >= 24) {
if (++ConsecDotLineSum >= 4) {
// memcpy(dst, pPrtCurImg-TPH_WIDTH_BYTE, TPH_WIDTH_BYTE); // ch_20220816
memcpy(dst, pPrtCurImg, TPH_WIDTH_BYTE); // ch_20220816
CalculateConsecutiveActDots(dst, TPH_WIDTH_BYTE, &BitAvaliable, &BitContinueAvaliable);
// if ((BitAvaliable != BitAvaliableBkp)||(BitContinueAvaliable != BitContinueAvaliableBkp)) {
// sysprintf("N_Dot_all:%d,con:%d,t:%d\n", BitAvaliable, BitContinueAvaliable, HeatFirstTime);
// BitAvaliableBkp = BitAvaliable; BitContinueAvaliableBkp = BitContinueAvaliable;
// }
if (0 == BitAvaliable) {
//sysprintf("C_L_S_%d\n", ConsecDotLineSum);
ConsecDotLineSum = 0;
HeatFirstTime = 1; HeatSecondTime = 1;
NoHeatCnt = 1; // ch_20220816
// HeatFirstTime = HeatFirstTime * 60/100;
}
}
}
else
ConsecDotLineSum = 0;
}
/******************************************************************************
* Heat Storage Coefficient
*
* In high-speed printing, a difference in temperature arises between the rise
* in temperature of the thermal head due to head activation and the temperature
* detected by the thermistor. Therefore, the activation pulse must be corrected
* by simulating a rise in the temperature of the thermal head.
* No correction is needed when the print ratio is low. When correction is not needed,
* set 1 as the heat storage coefficient.
*
* The heat storage coefficient is calculated as follows:
*
* 1) Prepare the heat storage counters to simulate heat storage.
* (a) Heat storage due to head activation
* The heat storage counter counts up in each print period as follows.
*
* T' = T + N
*
* T: Heat storage counter value
* N: Number of the activated dots
*
* (b) Radiation
* The heat storage counter value is multiplied by the radiation coefficient
* in each 10 msec.
*
* T' = T * K
*
* K: Radiation coefficient ( 0.952 )
*
* 2) Calculate the heat storage coefficient
*
* D = 1 - T / ( B * W )
*
* B: Number of entire dots
* W: Weight of storage ( 625 )
*
******************************************************************************/
UINT CalculateActDots(BYTE *Line, INT Length)
{
UINT ActDotSum = 0;
while (Length--)
ActDotSum += ByteDots[*(Line++)];
return ActDotSum;
}
// ch_20220811
//wdy 计算局部连续变黑加热点(最大连续的部分)
VOID CalculateConsecutiveActDots(BYTE *Line, INT Length,UINT *all_len,UINT *continue_len){
UINT ActDotSum = 0; //总数
UINT ActContinueDotSum = 0; //连续总数
UINT ActContinueMaxDot = 0; //连续总数最大值
BOOL ContinueFlag = FALSE; //是否连续
UINT i = 0;
for(i = 0; i < Length; i++){
//sysprintf("%x ", *(Line+i)); // ch_20220811
//计算有效总像素点
ActDotSum += ByteDots[*(Line+i)];
//计算连续最大像素点
if(ContinueFlag == FALSE){ //FALSE时判断 是否有8位大小的（即8个bit全是黑色的）
if(0x08 == ByteDots[*(Line+i)]){
ContinueFlag = TRUE;
ActContinueDotSum = 8;
}
}else {
if(0x08 == ByteDots[*(Line+i)]){
ActContinueDotSum += 8;
}else {
if(ActContinueDotSum > ActContinueMaxDot){
ActContinueMaxDot = ActContinueDotSum;
ContinueFlag = FALSE;
ActContinueDotSum = 0;
}
}
}
}
//sysprintf("\n"); // ch_20220811
*continue_len = ActContinueMaxDot;
*all_len = ActDotSum;
}
/* each print period */
VOID HeatStorage(UINT ActDots)
{
HeatStorageCounter += ActDots;
}
/* each 10 msec */
VOID HeatRadiation(VOID)
{
HeatStorageCounter *= RadiationCoefficient;
}
#if defined(TTP384M) || defined(DL9000)
STATIC VOID TransferToCPLD(BYTE *data)
{
BYTE *Send1, *Send2, *Send3, *Send4;
INT i;
AT91C_BASE_SSC0->SSC_TFMR |= AT91C_SSC_MSBF; // MSB
Send1 = (BYTE *)data;
Send2 = Send1 + 72;
Send3 = Send2 + 72;
Send4 = Send3 + 90;
for (i = 0; i < 90; i++)
{
// OutPort(TPH_DATA_PORT_1, *Send1++);
// OutPort(TPH_DATA_PORT_2, *Send2++);
// OutPort(TPH_DATA_PORT_3, *Send3++);
// OutPort(TPH_DATA_PORT_4, *Send4++);
// Use direct method for saving of time
*(VOLATILE BYTE *)0x30020000 = *Send1++; // TPH data port 1
*(VOLATILE BYTE *)0x30020002 = *Send2++; // TPH data port 2
*(VOLATILE BYTE *)0x30020004 = *Send3++; // TPH data port 3
*(VOLATILE BYTE *)0x30020006 = *Send4++; // TPH data port 4
AT91C_BASE_SSC0->SSC_THR = 0;
while ((AT91C_BASE_SSC0->SSC_SR & AT91C_SSC_TXEMPTY) == 0);
}
}
#endif
//0x0100 0000
STATIC VOID TransferToShiftReg(BYTE *data)//<-PrintTPHLine -> TPHTransmitHandler
{
int i;
#if defined(AT91SAM9260)
if (PrtDirection ^ PrtMirror)
AT91C_BASE_SSC0->SSC_TFMR &= ~AT91C_SSC_MSBF; // LSB
else
AT91C_BASE_SSC0->SSC_TFMR |= AT91C_SSC_MSBF; // MSB
for ( i = 0 ; i < TPH_WIDTH_BYTE; i++ )
{
if(data[i])
{
//debug_printf("-");
break;
}
}
AT91F_PDC_SetTx(AT91C_BASE_PDC_SSC0, (CHAR *)data, TPH_WIDTH_BYTE);
AT91F_SSC_EnableIt(AT91C_BASE_SSC0, AT91C_SSC_TXBUFE);
#elif defined(SH7040)
if (PrtDirection ^ PrtMirror)
{
SCI1.SCR.BIT.TIE = 1;
DMAC2.SAR = data + TPH_WIDTH_BYTE - 1;
DMAC2.DAR = (BYTE *)(&SCI1.TDR);
DMAC2.DMATCR = TPH_WIDTH_BYTE;
DMAC2.CHCR.LONG = 0x00012E05;
DMAC.DMAOR.WORD = 0x0001;
}
else
{
SCI1.SCR.BIT.TIE = 1;
DMAC2.SAR = data;
DMAC2.DAR = (BYTE *)(&SCI1.TDR);
DMAC2.DMATCR = TPH_WIDTH_BYTE;
DMAC2.CHCR.LONG = 0x00011E05;
DMAC.DMAOR.WORD = 0x0001;
}
#elif defined (N3290)
TPH_SpiStart((UINT)data,TPH_WIDTH_BYTE,PrtDirection ^ PrtMirror,(VOID *)TPHTransmitHandler);
#endif
}
WORD SurplusPrintLine(VOID)
{
return (PrtEndLine > PrtCurrLine ? PrtEndLine - PrtCurrLine : 0);
}
BOOL OverPrintLine(VOID)
{
return (PrtCurrLine > PrtEndLine ? TRUE : FALSE);
}
/
/*该函数的作用是打印一行热敏纸，并在需要时进行历史记录控制。首先判断当前行数是否在需要打印的范围内，如果是，
则根据当前速度和是否为最后一行来计算历史记录控制，并调用TransferToShiftReg函数将打印数据转换为位移寄存器中的位模式，
然后设置SendFirstLine和HistoryControl标志。最后，将当前行数加1，并检查是否需要重置处理器。
具体来说，如果当前行数达到了PrtEndLine，则表示已经打印完毕，整个打印过程结束。如果当前行数恰好等于需要打印的一半，
且SurplusLines等于(PrtEndLine-PrtStartLine)*2，则会调用ProcessorReset函数进行处理器重置。*/
//
VOID PrintTPHLine(INT Speed, INT Density)
{
if (PrtCurrLine >= PrtStartLine && PrtCurrLine <= PrtEndLine) //1.判断当前行数是否在需要打印的范围内
{
CalculateHistoryControl(Speed <= HISTORY_MAX_SPEED, PrtCurrLine == PrtEndLine); // 根据当前速度和是否为最后一行来计算历史记录控制
//debug_printf("a");
TransferToShiftReg((BYTE *)pPrintLine); //将打印数据转换为位移寄存器中的位模式
SendFirstLine = TRUE;
HistoryControl = (Speed <= HISTORY_MAX_SPEED);
HistorySecondControl=(Speed <= HISTORY_SECOND_MAX_SPEED);
}
PrtCurrLine += 1;
// ch_20220819
if ((PrtCurrLine == ((PrtEndLine-PrtStartLine)>>1))&&(SurplusLines == ((PrtEndLine-PrtStartLine)<<1)))
// sysprintf("S_L_%d\n", SurplusLines);
ProcessorReset(); //处理器重置
}
STATIC VOID _SetHeatTime(WORD time)//HeatTimerHandler
{
#if defined(AT91SAM9260)
//debug_printf("_%d\n",time);
// Disable the Clock Counter
AT91C_BASE_TC3->TC_CCR = AT91C_TC_CLKDIS;
// Set compare value
AT91C_BASE_TC3->TC_RC = time;
// Enable the Clock counter and Software trigger starts the clock
AT91C_BASE_TC3->TC_CCR = AT91C_TC_CLKEN | AT91C_TC_SWTRG;
#elif defined(SH7040)
CMT.CMSTR.BIT.STR1 = 0;
CMT1.CMCNT = 0;
CMT1.CMCOR = time;
CMT.CMSTR.BIT.STR1 = 1;
#elif defined(N3290)
outp32(REG_TCSR0, 0);
outpw(REG_TICR0,time);
outpw(REG_TCSR0, (inpw(REG_TCSR0) & 0x87FFFF00) | ((0x1 | 0xC)<<27));
#endif
}
VOID TPHTransmitHandler(VOID)//<- TransferToShiftReg
{
#if defined(AT91SAM9260)
UINT status = AT91C_BASE_SSC0->SSC_SR;
UINT mask = AT91C_BASE_SSC0->SSC_IMR;
UINT interrupt = status & mask;
//debug_printf("+");
if (interrupt & AT91C_SSC_TXBUFE)
TPHTransmitISR();
#elif defined(N3290)
TPH_SpiEnd();
TPHTransmitISR();
#endif
}
VOID TPHTransmitISR(VOID)
{
#if defined(AT91SAM9260)
AT91F_SSC_DisableIt(AT91C_BASE_SSC0, AT91C_SSC_TXBUFE);
DelayTime(TPH_DELAY_TIME);
//debug_printf("*");
#elif defined(SH7040)
SCI1.SCR.BIT.TIE = 0;
DMAC2.CHCR.BIT.TE = 0;
DMAC.DMAOR.WORD = 0x0000;
#elif defined(N3290)
if (SurplusLines) // ch_20220819
SurplusLines--; // ch_20220819
DelayTime(TPH_DELAY_TIME);
#endif
if (SendFirstLine) //<-PrintTPHLine
HeatState = SEND_FIRST_LINE; // Start heat sequence
SendFirstLine = FALSE;
switch (HeatState)
{
case SEND_FIRST_LINE:
TPH_LATCH_LOW;
DelayTime(LATCH_DELAY_TIME);
HeatState = HEAT_FIRST_LINE;
TPH_LATCH_HIGH;
SetHeatTime(HeatFirstTime);//-> HeatTimerISR HeatState = SEND_SECOND_FINISH; ¼ÓÈÈ
if (HeatTimes) // Heats up many times
{
#if defined(TTP384M) || defined(DL9000)
if (HeatPart == 2)
TPHHeat(HEAT_HALF_FIRST);
else
TPHHeat(HEAT_FULL);
#else
if (HistoryControl && HistoryTimes)
{
//debug_printf("b");
TransferToShiftReg((BYTE *)pHistoryLine);
}
if (HeatPart == 2)
TPHHeat(HEAT_HALF_FIRST);
else
TPHHeat(HEAT_FULL);
#endif
HeatState = HEAT_SWITCH;
}
else
{
TPHHeat(HEAT_FULL);
if (HistoryControl) //<-PrintTPHLine
{
//debug_printf("c");
TransferToShiftReg((BYTE *)pHistoryLine);//->TPHTransmitISR
}
else
HeatState = SEND_SECOND_FINISH;
}
break;
case HEAT_FIRST_LINE:
HeatState = SEND_SECOND_FINISH;
break;
case HEAT_FIRST_FINISH:
TPH_LATCH_LOW;
DelayTime(LATCH_DELAY_TIME);
HeatState = HEAT_SECOND_LINE;
TPH_LATCH_HIGH;
SetHeatTime(HeatSecondTime);
TPHHeat(HEAT_FULL);
break;
case SEND_TPH_DATA:
TPH_LATCH_LOW;
DelayTime(LATCH_DELAY_TIME);
HeatState = HEAT_NULL;
TPH_LATCH_HIGH;
break;
case HEAT_SWITCH:
case HEAT_SWITCH_ON:
case HEAT_SWITCH_OFF:
break;
default:
HeatState = HEAT_NULL;
break;
}
}
VOID HeatTimerHandler(VOID)//SetHeatTime _SetHeatTime
{
#if defined(AT91SAM9260)
UINT status = AT91C_BASE_TC3->TC_SR;
UINT mask = AT91C_BASE_TC3->TC_IMR;
UINT interrupt = status & mask;
//debug_printf("H");
if (interrupt & AT91C_TC_CPCS)
HeatTimerISR();
#elif defined(N3290)
if (inpw(REG_TISR) & 0x00000001)
{
outpw(REG_TISR, 0x01);//Çå³ý¶¨Ê±Æ÷±êÖ¾
outp32(REG_TCSR0, 0);
HeatTimerISR();
}
#endif
}
VOID HeatTimerISR(VOID)
{
STATIC INT SwitchTimes = 0;
#if defined(SH7040)
CMT1.CMCSR.BIT.CMF = 0; // clear heat isr flag
CMT.CMSTR.BIT.STR1 = 0; // stop heat timer
#endif
TPHHeat(HEAT_OFF);
switch (HeatState)
{
case SEND_FIRST_LINE:
break;
case HEAT_FIRST_LINE:
HeatState = HEAT_FIRST_FINISH;//<- TPHTransmitISR
break;
case SEND_SECOND_FINISH:
TPH_LATCH_LOW;
DelayTime(LATCH_DELAY_TIME);
HeatState = HEAT_SECOND_LINE;
TPH_LATCH_HIGH;
SetHeatTime(HeatSecondTime);
TPHHeat(HEAT_FULL);
break;
case HEAT_SECOND_LINE:
HeatState = HEAT_NULL;
break;
case HEAT_SWITCH:
SwitchTimes = HeatTimes;
case HEAT_SWITCH_ON:
if (SwitchTimes)
SwitchTimes -= 1;
if (SwitchTimes == 0)
HeatState = HEAT_NULL;
else
{
HeatState = HEAT_SWITCH_OFF;
SetHeatTime(HeatSecondTime);
}
break;
case HEAT_SWITCH_OFF:
#if defined(TTP384M) || defined(DL9000)
if (TranCPLD == FALSE)
#endif
if (HistoryControl && SwitchTimes == HistoryTimes)
{
TPH_LATCH_LOW;
DelayTime(LATCH_DELAY_TIME);
TPH_LATCH_HIGH;
}
HeatState = HEAT_SWITCH_ON;
SetHeatTime(HeatFirstTime);
if (HeatPart == 2)
TPHHeat((SwitchTimes % 2) ? HEAT_HALF_LAST : HEAT_HALF_FIRST);
else
TPHHeat(HEAT_FULL);
break;
default:
HeatState = HEAT_NULL;
break;
}
}
TPHDrv.h 。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
#ifndef TPHDRV_H
/******************************************************************************
* *
* M O D U L E D E F I N E *
* *
******************************************************************************/
#define TPHDRV_H
/******************************************************************************
* *
* C O M P I L E R D E F I N E D I N C L U D E F I L E S *
* *
******************************************************************************/
/* None */
/******************************************************************************
* *
* U S E R D E F I N E D I N C L U D E F I L E S *
* *
******************************************************************************/
#ifdef __cplusplus
extern "C" { /* Assume C declarations for C++ */
#endif /* __cplusplus */
/******************************************************************************
* *
* G L O B A L D E F I N E S *
* *
******************************************************************************/
/* None */
/******************************************************************************
* *
* S T R U C T U R E D E F I N I T I O N S *
* *
******************************************************************************/
/* None */
/******************************************************************************
* *
* G L O B A L V A R I A B L E S - N O I N I T I A L I Z E R S *
* *
******************************************************************************/
/* None */
/******************************************************************************
* *
* G L O B A L V A R I A B L E S - I N I T I A L I Z E R S *
* *
******************************************************************************/
/* None */
/******************************************************************************
* *
* F U N C T I O N P R O T O T Y P E S *
* *
******************************************************************************/
// ch_20220604
#define MIN_AD_VAL 67
#define MAX_AD_VAL 739
VOID InitialTPHDrv (VOID);
INT GetHeatScale(VOID);
VOID StopTPH(VOID);
VOID SetTPHPower(INT);
WORD CalculateTPHTemp(WORD);
WORD CalculateTPHTempLevel(WORD);
VOID CalculateHeatTable(VOID);
VOID CalculateHeatTime(WORD, WORD, WORD);
VOID CalculatePrintPoint(BYTE, BYTE, BYTE *, WORD, WORD, WORD, WORD);
WORD SurplusPrintLine(VOID);
BOOL OverPrintLine(VOID);
VOID PrintTPHLine(INT, INT);
VOID TPHTransmitHandler(VOID);
VOID TPHTransmitISR(VOID);
VOID HeatTimerHandler(VOID);
VOID HeatTimerISR(VOID);
WORD *ReadTPHResistance(VOID);
VOID SetDensityBase(FLOAT DBase,FLOAT TCompensate);
VOID SetHistoryCompensate(FLOAT HCompensate);
UINT CalculateActDots(BYTE *Line, INT Length);
VOID CalculateConsecutiveActDots(BYTE *Line, INT Length,UINT *all_len,UINT *continue_len);
#ifdef __cplusplus
} /* End of extern "C" { */
#endif /* __cplusplus */
#endif
561
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
