T168_111\device\Ribbon文件：RibbonDrv.c

最新推荐文章于 2024-10-03 00:41:24 发布

qq_33772147

最新推荐文章于 2024-10-03 00:41:24 发布

阅读量579

点赞数 14

本文链接：https://blog.csdn.net/qq_33772147/article/details/137270571

版权

RibbonDrv.c 。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

/******************************************************************************
* *
* M O D U L E D E F I N E *
* *
******************************************************************************/

#define RIBBONDRV_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 *
* *
******************************************************************************/

/* None */

/******************************************************************************
* *
* 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 "XMotor.h"
#include "XSensor.h"
#include "XTimer.h"
#include "XProFile.h"
#include "XVarBank.h"
#include "RibbonDrv.h"

#if defined(RIBBON_MODEL)

#define CLEAR_CAPTURE_STATUS               SetRibbonFlag(0)
#define CAPTURE_STATUS                       GetRibbonFlag()
#define CAPTURE_VALUE                       PWM_GetTimerCounter(PWM_TIMER0)

#define _EXT_INT_SRC 2

#define RIBBON_EMPTY_THRESHOLD       150   // for speed 7"
#define RIBBON_ENC_SIZE               4
#define RIBBON_ENC_HOLD_TIMES       (INT)(60 * MM_DOT)
#define RIBBON_ENC_HOLD               100

#define RIBBON_INTEN_MAX 3
#define RIBBON_INTEN_MIN 1 // 0 can't use

#if defined(AT91SAM9260)
#define RIBBON_DELAY               50000
#elif defined(SH7040)
#define RIBBON_DELAY               10000
#elif defined(N3290)
#define RIBBON_DELAY               2*10000 // ch_20220506

#endif

/******************************************************************************
* *
* L O C A L T Y P E D E F S *
* *
******************************************************************************/

/* None */

/******************************************************************************
* *
* L O C A L F U N C T I O N P R O T O T Y P E S *
* *
******************************************************************************/

/* None */

/******************************************************************************
* *
* 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 *
* *
******************************************************************************/

/* None */

/******************************************************************************
* *
* 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 *
* *
******************************************************************************/

STATIC BOOL CloseRibbonEnd;
STATIC BOOL CheckRibbonColorless;
STATIC BOOL CheckRibbonSilver;

STATIC BOOL CloseRibbonEncoder;
STATIC BOOL CheckRibbonEncoder;
STATIC BOOL TryRibbonEncoder;

STATIC UINT RibbonEncodeData[RIBBON_ENC_SIZE];
STATIC UINT RibbonEncodeIndex;
STATIC UINT RibbonEncodeUncap;
STATIC BOOL RibbonEncodeReady;

STATIC UINT StoreRibbonEncodeData[RIBBON_ENC_SIZE];
STATIC UINT StoreRibbonEncodeIndex;
STATIC UINT StoreRibbonEncodeUncap;

STATIC INT CaptureStatus;

STATIC INT RibbonCount=0;

STATIC UCHAR DetectRibbonStat = 0;           // ch_20220623
STATIC ULONG DetectRibbonInterval = 0;    // ch_20220623
STATIC WORD PrevEncodeData = 0;                // ch_20220623

STATIC VOID SetRibbonFlag(BYTE flag){

_PrintCfg *CalCfg = GrabPrintConfig();

CalCfg->my_encode_flag = flag;
}

STATIC BYTE GetRibbonFlag(VOID){

_PrintCfg *CalCfg = GrabPrintConfig();

return CalCfg->my_encode_flag;
}
STATIC VOID RibbonSenserGpioISR(void){

INT imask = DisableInterrupt(INTERRUPT_MASK);

_PrintCfg *CalCfg = GrabPrintConfig();

#ifdef DEBUG_PRNT
sysprintf("RibbonSenserGpioISR()...\n"); // ch_20220506
#endif

gpio_cleartriggersrc(GPIO_PORTE);

CalCfg->my_encode_flag = 1;

EnableInterrupt(imask);
}

STATIC void RibbonEncodeGpioInt(void)
{

   PWM_TIME_DATA_T sPt;

   PFN_PWM_CALLBACK pfnOldcallback;

   gpio_setportdir(GPIO_PORTE   ,BIT9, 0);
   gpio_setportpull(GPIO_PORTE   ,BIT9, 0);

   // ch_20220725
//   gpio_setintmode(GPIO_PORTE   ,BIT9, 0, BIT9);//~{IOI}QXVP6O~}
//   gpio_setsrcgrp(GPIO_PORTE   ,BIT9, _EXT_INT_SRC);       //~{VP6OT4~}2
//
//   gpio_setdebounce(128, 1 << _EXT_INT_SRC);
//   gpio_setlatchtrigger(1 << _EXT_INT_SRC);
//
//   sysInstallISR(IRQ_LEVEL_7,_EXT_INT_SRC+2, (PVOID)RibbonSenserGpioISR);
//   sysSetInterruptType(_EXT_INT_SRC+2, POSITIVE_EDGE_TRIGGER);
//   sysSetLocalInterrupt(ENABLE_FIQ_IRQ);
//   sysEnableInterrupt(_EXT_INT_SRC+2);

}
STATIC WORD RibbonEncoder(VOID)
{
INT i, Data;
STATIC INT DataBkp = 0; // ch_20220725
STATIC UCHAR PrevLevel = 0; // ch_20220725
unsigned short PortVal = 0; // ch_20220725

_PrintCfg *CalCfg = GrabPrintConfig();

//   if (CAPTURE_STATUS) // ch_20220725
   gpio_readport(GPIO_PORTE, &PortVal); // ch_20220725
   if ((PortVal&BIT9)&&(0==PrevLevel)) // ch_20220725
   {
//        CLEAR_CAPTURE_STATUS; // ch_20220725
PrevLevel = 1; // ch_20220725

       Data = CalCfg->my_encode_count;

       if(RibbonCount!=0)
       {
       RibbonCount++;

if((RibbonCount%25) == 0)
{

       RibbonCount=1;
               SendPrintf("%d\n",CalCfg->my_last_en_count);
       }
       }

#if defined(TTP245P_PCB) ||defined(T045_PCB) ||defined(T40_PCB) || defined(TN3290_PCB)
       if (Data < RIBBON_EMPTY_THRESHOLD / 2)
           Data = RIBBON_EMPTY_THRESHOLD / 2;

       //if (Data > (RIBBON_EMPTY_THRESHOLD+5))
       //   Data = RIBBON_EMPTY_THRESHOLD;
#endif
       if (RibbonEncodeReady)   // between the two capture
       {
           RibbonEncodeData[RibbonEncodeIndex++] = Data;
           if (RibbonEncodeIndex == RIBBON_ENC_SIZE)
               RibbonEncodeIndex = 0;
       }
       RibbonEncodeReady = TRUE;

       if(Data <= (RIBBON_EMPTY_THRESHOLD / 2)){
           RibbonEncodeUncap++;
       }
       else
       RibbonEncodeUncap = 0;

   }
   else
   {
if (!(PortVal&BIT9)) // ch_20220725
   PrevLevel = 0; // ch_20220725

CalCfg->my_encode_count = RIBBON_ENC_HOLD;
RibbonEncodeUncap += 1;
}

   // encoder hold
   if (RibbonEncodeUncap > RIBBON_ENC_HOLD_TIMES)
   {
       ClearRibbonEncode();
       //SendPrintf("uncap-->%d",RibbonEncodeUncap);
       return RIBBON_ENC_HOLD;
   }

#if 1
   // encode data
   Data = 0;
   for(i = 0; i < RIBBON_ENC_SIZE; i++)
       Data += RibbonEncodeData[i];
   Data /= RIBBON_ENC_SIZE;

CalCfg->my_last_en_count = Data;
#endif
return Data;
}

STATIC BOOL RibbonExistInEncoder(VOID)
{
WORD Value;
LONG i;

#if defined(TTP245P_PCB) ||defined(T045_PCB) ||defined(T40_PCB) || defined(TN3290_PCB)
#if defined(XPH500B)||defined(XPH500E)
DCMotorRewindCtrl(TRUE, MOTOR_FORWARD, 60/*30*/); // ch_20220815 : changed to 60 from 30 cause cannot detect RIBBON sometimes.
#else
   DCMotorRewindCtrl(TRUE, MOTOR_FORWARD, 70);
#endif
   for (i = 0; i < RIBBON_ENC_HOLD_TIMES + 200; i++)
   {
       Trigger74123();
       DelayTime(RIBBON_DELAY);
       Value = RibbonEncoder();

#ifdef DEBUG_PRNT
sysprintf("%d\n", Value);
#endif

   }
   DCMotorRewindCtrl(FALSE, MOTOR_FORWARD, 0);

// SendPrintf("Y:%d\n",Value);
sysprintf("Y:%d\n", Value); // ch_20220505

if (Value == 0 || Value == RIBBON_ENC_HOLD)
return TRUE;
#endif

return FALSE;
}

STATIC BOOL RibbonExistInSensor(VOID)
{

_PrintCfg *pPrtCfg = GrabPrintConfig();
BOOL HasRibbon = TRUE;

   EnableSensor(RIBBON_SENSOR, pPrtCfg->RibbonInten, 0, pPrtCfg->RibbonRef);
   DelayTime(RIBBON_DELAY);
   if (GetSensorSignal(RIBBON_SENSOR) == SENSOR_DETECTED)
       HasRibbon = FALSE;

DisableSensor(RIBBON_SENSOR);

return HasRibbon;

}

STATIC BOOL SilverExistInSensor(VOID)
{
_PrintCfg *pPrtCfg = GrabPrintConfig();
BOOL HasRibbon = TRUE;

HasRibbon = FALSE;

return HasRibbon;
}

VOID InitialRibbon(VOID)//~{3uJ<;/F$4x~}
{
FLOAT data;

#if 1
RibbonEncodeGpioInt();
#endif

   CloseRibbonEnd = FALSE;
   if (GetProfileInt("RIBBON END CLOSE", &data))
       CloseRibbonEnd = (BOOL)data;

CheckRibbonColorless = FALSE;
CheckRibbonSilver = FALSE;

   CloseRibbonEncoder = FALSE;
   if (GetProfileInt("RIBBON ENCODER CLOSE", &data))
       CloseRibbonEncoder = (BOOL)data;

CheckRibbonEncoder = FALSE;
TryRibbonEncoder = FALSE;

ClearRibbonEncode();
}

VOID ClearRibbonEncode(VOID)
{
INT i;
_PrintCfg *CalCfg = GrabPrintConfig();

CLEAR_CAPTURE_STATUS;
//CAPTURE_VALUE = 0;

CalCfg->my_encode_count = 100;

   for (i = 0; i < RIBBON_ENC_SIZE; i++)
       RibbonEncodeData[i] = 0;
   RibbonEncodeIndex = 0;
   RibbonEncodeUncap = 0;
   RibbonEncodeReady = FALSE;
}

VOID StoreRibbonEncode(VOID)
{
   INT i;

   for (i = 0; i < RIBBON_ENC_SIZE; i++)
       StoreRibbonEncodeData[i] = StoreRibbonEncodeData[i];
   StoreRibbonEncodeIndex = RibbonEncodeIndex;
   StoreRibbonEncodeUncap = RibbonEncodeUncap;
}

VOID RestoreRibbonEncode(VOID)
{
   INT i;

   for (i = 0; i < RIBBON_ENC_SIZE; i++)
       RibbonEncodeData[i] = StoreRibbonEncodeData[i];
   RibbonEncodeIndex = StoreRibbonEncodeIndex;
   RibbonEncodeUncap = StoreRibbonEncodeUncap;
}

VOID StopTryRibbonEncoder(VOID)
{
TryRibbonEncoder = FALSE;
}

BOOL GetRibbonCheck(INT kind)
{
   if (kind == CHECK_RIBBON_COLORLESS)
       return CheckRibbonColorless;
   if (kind == CHECK_RIBBON_SILVER)
       return CheckRibbonSilver;
   if (kind == CHECK_RIBBON_ENCODER)
       return CheckRibbonEncoder;

return FALSE;
}

BOOL DetectRibbonInten(VOID)
{
   _PrintCfg *pPrtCfg = GrabPrintConfig();
   BOOL Signal;
   INT Inten;

return TRUE;
}

VOID CheckRibbonExists(BOOL Inten, BOOL Encoder)
{
_PrintCfg *pPrtCfg = GrabPrintConfig();
BOOL HasRibbon;

HasRibbon = RibbonExistInSensor();

   CheckRibbonColorless = TRUE;
   if (CloseRibbonEnd || !HasRibbon)
       CheckRibbonColorless = FALSE;

   CheckRibbonEncoder = TRUE;
   if (CloseRibbonEncoder)
       CheckRibbonEncoder = FALSE;

TryRibbonEncoder = FALSE;

   if (Encoder)
   {
#if defined(TTP245P_PCB) ||defined(T045_PCB) ||defined(T40_PCB) || defined(TN3290_PCB)
       pPrtCfg->RibbonFlag = TRUE;
       if (CloseRibbonEncoder)
       {
           if (!CheckRibbonColorless){
               pPrtCfg->RibbonFlag = FALSE;

#ifdef DEBUG_PRNT
               sysprintf("CloseRibbonEncoder = 1 and CheckRibbonColorless = 0\n");
#endif
           }
       }
       else if (!RibbonExistInEncoder())
       {
           pPrtCfg->RibbonFlag = FALSE;
           CheckRibbonEncoder = FALSE;

#ifdef DEBUG_PRNT
sysprintf("RibbonExistInEncoder out of RIBBON_ENC_HOLD\n");
#endif
}

#endif
   }
}
BOOL CheckRibbonJam(VOID)
{
   _PrintCfg *pPrtCfg = GrabPrintConfig();
   BOOL state = TRUE;
   WORD EncodeData;

if (GetPreMotorDir() == MOTOR_BACKWARD)
return state;

   if (CheckRibbonEncoder && pPrtCfg->RibbonEncoder)
   {
       EncodeData = RibbonEncoder();   // check ribbon near end sensor

       // check encode error, speed too fast
//       if((EncodeData >= RIBBON_EMPTY_THRESHOLD) || (EncodeData == RIBBON_ENC_HOLD)) // ch_20220526
       if (EncodeData >= RIBBON_EMPTY_THRESHOLD) // ch_20220526
       {
   if(RibbonCount)
   {
   SendPrintf("error:%d\n",EncodeData);
   }
           ClearRibbonEncode();
           if (TryRibbonEncoder)
           {
               pPrtCfg->RibbonFlag = FALSE;
               CheckRibbonEncoder = FALSE;
               TryRibbonEncoder = FALSE;
           }
           else
               state = FALSE;
       }
       if (TryRibbonEncoder && EncodeData != (RIBBON_EMPTY_THRESHOLD * 2))
           TryRibbonEncoder = FALSE;
   }

return state;
}

BOOL CheckRibbonEmpty(VOID)
{
   STATIC WORD ColorlessCount = 0;
   STATIC WORD SilverCount = 0;
   STATIC BOOL CheckSilver = FALSE;

BOOL state = TRUE;

if (GetPreMotorDir() == MOTOR_BACKWARD)
return state;

   if (CheckRibbonSilver && CheckSilver)
   {
       if (GetSensorSignal(RIBBON_SENSOR) == SENSOR_UNDETECTED)   // is silver
           SilverCount++;
       else
           SilverCount = 0;

       // longer then .5" x 2 without seeing ribbon
       if (SilverCount > (WORD)(TPH_DPI / 2))
       {
           SilverCount = 0;
           state = FALSE;
       }
   }
   else if (CheckRibbonColorless)
   {
       if (GetSensorSignal(RIBBON_SENSOR) == SENSOR_DETECTED)
           ColorlessCount++;
       else
           ColorlessCount = 0;

       // longer then .5" without seeing ribbon
       if (ColorlessCount > (WORD)(TPH_DPI / 2))
       {
           ColorlessCount = 0;
           state = FALSE;
       }
   }

   return state;
}

#if 1
// ch_2022623
VOID ClrRibbonVars(VOID) {
   DetectRibbonStat = 0;
   DetectRibbonInterval = 0;
   PrevEncodeData = 0;
}

// ch_20220611
UCHAR CheckRibbonStat(VOID)
{
   _PrintCfg *pPrtCfg = GrabPrintConfig();
   UCHAR state = 0;
   WORD EncodeData;
   STATIC WORD EncodeDataBkp = 555; // ch_20220622

if (GetPreMotorDir() == MOTOR_BACKWARD)
return state;

   if (CheckRibbonEncoder && pPrtCfg->RibbonEncoder)
   {
       EncodeData = RibbonEncoder();   // check ribbon near end sensor

///
// ch_20220622 : only for debug
//if (EncodeDataBkp != EncodeData) {
//   EncodeDataBkp = EncodeData;
//   sysprintf("R%d\n", EncodeData); // ch_20220604
//}
///

       // check encode error, speed too fast
//       if((EncodeData >= RIBBON_EMPTY_THRESHOLD) || (EncodeData == RIBBON_ENC_HOLD)) // ch_20220526
       if (EncodeData >= RIBBON_EMPTY_THRESHOLD) // ch_20220526
       {
//#ifdef DEBUG_PRNT
//sysprintf("R_%d\n", EncodeData); // ch_20220506
//#endif
   if(RibbonCount)
   {
   SendPrintf("error:%d\n",EncodeData);
   }
           ClearRibbonEncode();
           if (TryRibbonEncoder)
           {
               pPrtCfg->RibbonFlag = FALSE;
               CheckRibbonEncoder = FALSE;
               TryRibbonEncoder = FALSE;

               state &= ~(1<<1);
           }
           else
               state |= (1<<1);
       }

//       if (99 == PrevEncodeData) { // ch_20220617
       switch (DetectRibbonStat) { // ch_20220623
           case 0: // ch_20220623
//               if (PrevEncodeData >= 99) { // ch_20220722
               if (PrevEncodeData == 100/*99*/) { // ch_20220723 : changed to 100.
//                   if (0 == EncodeData) { // ch_20220722
                   if ((0 == EncodeData) || (100 == EncodeData)) { // ch_20220722
                       if (++DetectRibbonInterval >= 10) { // ch_20220725
                           DetectRibbonInterval = 0;
                           PrevEncodeData = 0;
//                           state |= (1<<0); // ch_20220623
                           DetectRibbonStat = 1; // ch_20220623
                       }
                   }
                   else {
                       DetectRibbonInterval = 0;
                       PrevEncodeData = 0;
                       state &= ~(1<<0);
                   }
               }
               else if (PrevEncodeData != EncodeData) {
                   PrevEncodeData = EncodeData;
                   DetectRibbonInterval = 0;
                   state &= ~(1<<0);
               }
               break;
       //
       // ch_20220623
           case 1:
//               if (0 == EncodeData) { // ch_20220722
               if ((0 == EncodeData) || (100 == EncodeData)) { // ch_20220722
                   if (++DetectRibbonInterval >= 400) {
                       DetectRibbonInterval = 0;
                       DetectRibbonStat = 2;
                   }
               }
               else {
                   DetectRibbonStat = 0;
                   PrevEncodeData = EncodeData; // ch_20220722
                   DetectRibbonInterval = 0;
                   state &= ~(1<<0);
               }
               break;
           case 2:
//               if (0 == EncodeData) { // ch_20220722
               if ((0 == EncodeData) || (100 == EncodeData)) { // ch_20220722
                   if (++DetectRibbonInterval >= 1100) { // ch_20220725
                       DetectRibbonInterval = 0;
                       ClearRibbonEncode(); // ch_20220725
                       state |= (1<<0);
                       DetectRibbonStat = 0;
                   }
               }
               else {
                   DetectRibbonStat = 0;
                   PrevEncodeData = EncodeData; // ch_20220722
                   DetectRibbonInterval = 0;
                   state &= ~(1<<0);
               }
               break;
           default:
               break;
       }
       //
//sysprintf("Prev_%d,EnC_%d\n", PrevEncodeData, EncodeData);

       if (TryRibbonEncoder && EncodeData != (RIBBON_EMPTY_THRESHOLD * 2))
           TryRibbonEncoder = FALSE;
   }

return state;
}
#endif

#endif

RibbonDrv.h 。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

#ifndef RIBBONDRV_H

/******************************************************************************
* *
* M O D U L E D E F I N E *
* *
******************************************************************************/

#define RIBBONDRV_H

/* None */

#ifdef __cplusplus
extern "C" { /* Assume C declarations for C++ */
#endif /* __cplusplus */

/******************************************************************************
* *
* G L O B A L D E F I N E S *
* *
******************************************************************************/

#define CHECK_RIBBON_COLORLESS       0
#define CHECK_RIBBON_SILVER           1
#define CHECK_RIBBON_ENCODER       2

/******************************************************************************
* *
* 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 *
* *
******************************************************************************/

VOID InitialRibbon(VOID);
VOID ClearRibbonEncode(VOID);
VOID StopTryRibbonEncoder(VOID);
BOOL GetRibbonCheck(INT);
BOOL DetectRibbonInten(VOID);
VOID CheckRibbonExists(BOOL, BOOL);
INT CheckRibbonJam(VOID);
INT CheckRibbonEmpty(VOID);
UCHAR CheckRibbonStat(VOID); // ch_20220611
VOID ClrRibbonVars(VOID); // ch_20220623

VOID StoreRibbonEncode(VOID);
VOID RestoreRibbonEncode(VOID);

#ifdef __cplusplus
} /* End of extern "C" { */
#endif /* __cplusplus */

#endif