设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 电子技术分类讨论区 › 资料共享 › CIS扫描仪控制源码
返回列表 发新帖
查看: 1439|回复: 0
打印 上一主题 下一主题
收起左侧

CIS扫描仪控制源码

[复制链接]
跳转到指定楼层
楼主
ID:382223 发表于 2018-8-2 16:33 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
  1. /**
  2.   ******************************************************************************
  3.   * @file    motor control.c
  4.   * @author  MCD Application Team
  5.   * @version
  6.   * @date    12-May-2013
  7.   * @brief   This file provides all the Application firmware functions.
  8.   ******************************************************************************
  9.   * @attention
  10.   *
  11.   * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
  12.   * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
  13.   * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
  14.   * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
  15.   * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
  16.   * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
  17.   *
  18.   ******************************************************************************
  19.   */

  21. /* Includes ------------------------------------------------------------------*/


  24. #include "scan200dpi.h"
  25. #include "gpio.h"
  26. #include "globalVar.h"
  27. #include "commun.h"
  28. #include "usbd_hid_core.h"
  29. #include "readticket.h"
  30. #include "motor.h"
  31. #include "readticket.h"
  32. #include "adc.h"
  33. #include "timer.h"
  34. #include "usbd_hid_api.h"

  36. //#define nop5()  {__nop() __nop() __nop() __nop() __nop() __nop()}



  40.         
  41. volatile uint8_t cnt24 =1;
  42. volatile uint32_t Index23=0;

  44. void nop3(void)
  45. {
  46.         __nop();
  47. //        __nop();
  48. //        __nop();
  49.         
  50. }

  52. void nop5(void)
  53. {
  54.         __nop();
  55.         __nop();
  56.         __nop();
  57. //        __nop();
  58. //        __nop();        
  59. }

  61. void nop7(void)
  62. {
  63.         __nop();
  64.         __nop();
  65.         __nop();
  66.         __nop();
  67.         __nop();
  68. //        __nop();
  69. //        __nop();        
  70. }

  72. void nop9(void)
  73. {
  74.         __nop();
  75.         __nop();
  76.         __nop();
  77.         __nop();
  78.         __nop();
  79.         __nop();
  80.         __nop();
  81. //        __nop();
  82. //        __nop();        
  83. }

  85. void nop10(void)
  86. {
  87.         __nop();
  88.         __nop();
  89.         __nop();
  90.         __nop();
  91.         __nop();
  92.         __nop();
  93.         __nop();
  94. //        __nop();
  95. //        __nop();
  96. //        __nop();        
  97. }

  99. /******************************/

  101. #if 0
  102. void ScanOneLine200(void)
  103. {
  104.         __IO uint32_t i;
  105.         __IO uint8_t        OneByteData=0;
  106.         __IO uint32_t        temp=0;        


  109.         uint32_t        scanbufIndexStart;
  110.         uint32_t        scanbufIndexEnd;
  111.         checkpaperIndex=scan_buffer_Windex;
  112.         scanbufIndexStart=scan_buffer_Windex;
  113.         scanbufIndexEnd=scan_buffer_Windex+84;
  114.         scan_buffer_Windex+=256;
  115.         
  116.         
  117.         GPIOC813=ApiSetReaderParameter.ScanRefVoltageValue;

  119.         CISCNTLOW;
  120.         CISCLKLOW;        
  121.         CISSILOW;

  123.         scanEnter();
  124.         TIM2->SR = (uint16_t)~TIM_IT_Update;
  125.         TIM2->CNT=0;
  126.         TIM2->ARR = 330;//300;//TIM_SetAutoreload;
  127.         TIM2->CR1 |=0x0001;

  129.         /**************************************/
  130.         CISSIHIGH;//si  high
  131.         CISLEDON;
  132.         nnop8;
  133.         nnop8;
  134.         nnop8;
  135.         nnop8;
  136.         nnop8;
  137.         
  138.         CISCLKHIGH;        //clk high
  139.         nnop8;
  140.         nnop3;
  141.         
  142.         CISCLKLOW;        //clk low
  143.         nnop10;
  144.         CISSILOW;        //si low
  145.         nnop8;
  146. //        nnop8;
  147.         
  148.         
  149.         for(i=0;i<60;i++)
  150.         {
  151.                 CISCLKHIGH;        //clk high
  152.                 nnop4;
  153.                 CISCLKLOW;        //clk low
  154.                 nnop5;
  155.         }

  157.         for(i=0;i<8;i++)
  158.         {        
  159.                 CISCLKHIGH;        //clk high
  160.                 nnop6;
  161.                 //nnop1;
  162.                 CISCLKLOW;        //clk low
  163. //                nnop4;
  164.                 nnop10;
  165.                 //nnop6;
  166.         }
  167.         
  168.                 CISCLKHIGH;        //clk high
  169.                 nnop6;
  170.                 CISCLKLOW;        //clk low
  171.                 nnop2;        
  172.         
  173.         for(i=scanbufIndexStart;i<scanbufIndexEnd;i++) //  85
  174.         {
  175.                
  176.                          CISCLKHIGH;          //1
  177.                         OneByteData <<=1;        
  178.                         if ((GPIOE->IDR & GPIO_Pin_11) == (uint32_t)Bit_RESET)         //one bit data
  179.                                 OneByteData |=1;               
  180.                         CISCLKLOW;        
  181.                         nnop10;
  182. //                        nnop5;
  183.                         
  184.                         CISCLKHIGH;          //2
  185.                         OneByteData <<=1;        
  186.                         if ((GPIOE->IDR & GPIO_Pin_11) == (uint32_t)Bit_RESET)         //one bit data
  187.                                 OneByteData |=1;               
  188.                         CISCLKLOW;        
  189.                         nnop10;
  190. //                        nnop5;
  191.                         
  192.                         
  193.                         CISCLKHIGH;          //3
  194.                         OneByteData <<=1;        
  195.                         if ((GPIOE->IDR & GPIO_Pin_11) == (uint32_t)Bit_RESET)         //one bit data
  196.                                 OneByteData |=1;               
  197.                         CISCLKLOW;        
  198.                         nnop10;
  199. //                        nnop5;        

  201.                         CISCLKHIGH;          //4
  202.                         OneByteData <<=1;        
  203.                         if ((GPIOE->IDR & GPIO_Pin_11) == (uint32_t)Bit_RESET)         //one bit data
  204.                                 OneByteData |=1;               
  205.                         CISCLKLOW;        
  206.                         nnop10;
  207. //                        nnop5;                        
  208.         

  210.                         CISCLKHIGH;          //5
  211.                         OneByteData <<=1;        
  212.                         if ((GPIOE->IDR & GPIO_Pin_11) == (uint32_t)Bit_RESET)         //one bit data
  213.                                 OneByteData |=1;               
  214.                         CISCLKLOW;        
  215.                         nnop10;
  216. //                        nnop5;                        
  217.                         
  218.                         
  219.                         CISCLKHIGH;          //6
  220.                         OneByteData <<=1;        
  221.                         if ((GPIOE->IDR & GPIO_Pin_11) == (uint32_t)Bit_RESET)         //one bit data
  222.                                 OneByteData |=1;               
  223.                         CISCLKLOW;        
  224.                         nnop10;
  225. //                        nnop5;                        
  226.                         
  227.                         
  228.                         CISCLKHIGH;          //7
  229.                         OneByteData <<=1;        
  230.                         if ((GPIOE->IDR & GPIO_Pin_11) == (uint32_t)Bit_RESET)         //one bit data
  231.                                 OneByteData |=1;               
  232.                         CISCLKLOW;        
  233.                         nnop10;
  234. //                        nnop5;                        
  235.                         
  236.                         
  237.                         CISCLKHIGH;          //8
  238.                         OneByteData <<=1;        
  239.                         if ((GPIOE->IDR & GPIO_Pin_11) == (uint32_t)Bit_RESET)         //one bit data
  240.                                 OneByteData |=1;               
  241.                         CISCLKLOW;               
  242.                         ScanBuffer[i]=OneByteData;
  243.                         OneByteData=0;

  245.                         
  246.         }
  247.         
  248.         for(i=0;i<16;i++)
  249.         {        
  250.                 CISCLKHIGH;        //clk high
  251.                 nnop4;
  252.                 CISCLKLOW;        //clk low
  253.                 nnop8;
  254.         }

  256.         scanExit();
  257.         
  258. }

  260. #endif

  262. #if 1
  263. void ScanOneLine200(void)        //old protocol old scaner //470uS
  264. {
  265.         
  266.         uint32_t i;
  267.         uint8_t        OneByteData=0;
  268.         uint32_t        scanbufIndexStart;
  269.         uint32_t        scanbufIndexEnd;
  270.         checkpaperIndex=scan_buffer_Windex;
  271.         scanbufIndexStart=scan_buffer_Windex;
  272.         scanbufIndexEnd=scan_buffer_Windex+84;
  273.         //scan_buffer_Windex+=256;
  274.         scan_buffer_Windex+=128;

  276.         GPIOC813=ApiSetReaderParameter.ScanRefVoltageValue;

  278.         CISCNTLOW;

  280.         scanEnter();
  281.         TIM2->SR = (uint16_t)~TIM_IT_Update;
  282.         TIM2->CNT=0;
  283.         TIM2->ARR = 350;//330;//TIM_SetAutoreload;
  284.         TIM2->CR1 |=0x0001;
  285.         CISLEDON;

  287.         ADC_CLK_High();//GPIOB->BSRRL = GPIO_Pin_8; //C H
  288.         Delay(1);
  289.         ADC_CLK_Low();//GPIOB->BSRRH = GPIO_Pin_8; //C L
  290.         __nop();
  291.         ADC_SPO_High();//GPIOB->BSRRL = GPIO_Pin_9; //O H
  292.         __nop();
  293.         ADC_CLK_High();//GPIOB->BSRRL = GPIO_Pin_8;
  294.         Delay(1);
  295.         ADC_CLK_Low();//GPIOB->BSRRH = GPIO_Pin_8;
  296.         Delay(1);
  297.         ADC_CLK_High();//GPIOB->BSRRL = GPIO_Pin_8;
  298.         Delay(1);
  299.         ADC_CLK_Low();//GPIOB->BSRRH = GPIO_Pin_8;
  300.         __nop();
  301.         ADC_SPO_Low();//GPIOB->BSRRH = GPIO_Pin_9;
  302.         __nop();

  304.         for(i=0;i<56;i++)                //56 clocks before scan:0-55
  305.         {
  306.                 ADC_CLK_High();
  307.                         __nop();
  308.                         __nop();
  309.                         __nop();
  310.         

  312.                 ADC_CLK_Low();
  313.                         __nop();
  314.                         __nop();


  317.         }

  319.         for(i=0;i<8;i++)                //56 clocks before scan:0-55
  320.         {
  321.                 ADC_CLK_High();
  322.                         __nop();
  323.                         __nop();
  324.                         __nop();
  325.                         __nop();

  327.                 ADC_CLK_Low();
  328.                         __nop();
  329.                         __nop();
  330.                         __nop();
  331.                         __nop();
  332.                         __nop();

  334.         }

  336.         
  337.         for(i=scanbufIndexStart;i<scanbufIndexEnd;i++) //  216
  338.         {
  339.                
  340.                                 


  343.                         
  344.                          ADC_CLK_High();          //1
  345.                         OneByteData <<=1;        
  346.                         if ((GPIOE->IDR & GPIO_Pin_11) == (uint32_t)Bit_RESET)         //one bit data
  347.                                 OneByteData |=1;        
  348.                         else                           
  349.                                 __nop();
  350.                         ADC_CLK_Low();
  351.                         __nop();
  352.                         __nop();
  353.                         __nop();
  354.                         __nop();
  355.                         __nop();
  356.                         __nop();
  357.                         __nop();
  358.                         


  361.                         ADC_CLK_High();                //2
  362.                         OneByteData <<=1;        
  363.                         if ((GPIOE->IDR & GPIO_Pin_11) == (uint32_t)Bit_RESET)        //one bit data
  364.                                 OneByteData |=1;
  365.                         else                           
  366.                                 __nop();                        
  367.                         ADC_CLK_Low();
  368.                         __nop();
  369.                         __nop();
  370.                         __nop();
  371.                         __nop();
  372.                         __nop();
  373.                         __nop();
  374. //                        __nop();
  375.                         


  378.                         ADC_CLK_High();          //3
  379.                         OneByteData <<=1;        
  380.                         if ((GPIOE->IDR & GPIO_Pin_11) == (uint32_t)Bit_RESET)        //one bit data
  381.                                 OneByteData |=1;        
  382.                         else                           
  383.                                 __nop();                        
  384.                         ADC_CLK_Low();
  385.                         __nop();
  386.                         __nop();
  387.                         __nop();
  388.                         __nop();
  389.                         __nop();
  390.                         __nop();
  391. //                        __nop();

  393.                         
  394.                         ADC_CLK_High();          //4
  395.                         OneByteData <<=1;        
  396.                         if ((GPIOE->IDR & GPIO_Pin_11) == (uint32_t)Bit_RESET)  //one bit data
  397.                                 OneByteData |=1;
  398.                         else                           
  399.                                 __nop();                        
  400.                         ADC_CLK_Low();
  401.                         __nop();
  402.                         __nop();
  403.                         __nop();
  404.                         __nop();
  405.                         __nop();
  406.                         __nop();
  407. //                        __nop();

  409.                         
  410.                         ADC_CLK_High();           //5
  411.                         OneByteData <<=1;        
  412.                         if ((GPIOE->IDR & GPIO_Pin_11) == (uint32_t)Bit_RESET) //one bit data
  413.                                 OneByteData |=1;
  414.                         else                           
  415.                                 __nop();                        
  416.                         ADC_CLK_Low();
  417.                         __nop();
  418.                         __nop();
  419.                         __nop();
  420.                         __nop();
  421.                         __nop();
  422.                         __nop();
  423. //                        __nop();

  425.                         
  426.                         ADC_CLK_High();           //6
  427.                         OneByteData <<=1;        
  428.                         if ((GPIOE->IDR & GPIO_Pin_11) == (uint32_t)Bit_RESET)        //one bit data
  429.                                 OneByteData |=1;
  430.                         else                           
  431.                                 __nop();                        
  432.                         ADC_CLK_Low();
  433.                         __nop();
  434.                         __nop();
  435.                         __nop();
  436.                         __nop();
  437.                         __nop();
  438.                         __nop();
  439. //                        __nop();

  441.                         
  442.                         ADC_CLK_High();                 //7
  443.                         OneByteData <<=1;        
  444.                         if ((GPIOE->IDR & GPIO_Pin_11) == (uint32_t)Bit_RESET)         //one bit data
  445.                                 OneByteData |=1;
  446.                         else                           
  447.                                 __nop();                        
  448.                         ADC_CLK_Low();
  449.                         __nop();
  450.                         __nop();
  451.                         __nop();
  452.                         __nop();
  453.                         __nop();
  454.                         __nop();
  455. //                        __nop();

  457.                                                                                                                                        
  458.                          ADC_CLK_High();                  //8
  459.                         OneByteData <<=1;        
  460.                         if ((GPIOE->IDR & GPIO_Pin_11) == (uint32_t)Bit_RESET)          //one bit data
  461.                                 OneByteData |=1;
  462.                         else                           
  463.                                 __nop();                        
  464.                         ADC_CLK_Low();

  466.                 ScanBuffer[i]=OneByteData;          //j256
  467.                 OneByteData=0;

  469.         }
  470.         __nop();
  471. //        CISLEDOFF;
  472.         for(i=0;i<32;i++)                //add 32 clocks after scan
  473.         {
  474.                 ADC_CLK_High();
  475.                         __nop();
  476.                         __nop();
  477.                         __nop();
  478. //                        __nop();
  479. //                        __nop();
  480. //                        __nop();
  481. //                        __nop();
  482.                 ADC_CLK_Low();
  483.                         __nop();
  484.                         __nop();
  485.                         __nop();
  486.                         __nop();//

  488.         }
  489.         scanExit();
  490.         
  491.         //ScanBuffer[scanbufIndexStart+8]=0x0f;
  492.                 //ScanBuffer[scanbufIndexStart+41]=0xff;

  494. }
  495. #endif

  497. uint8_t rollFrontProcess(void);
  498. volatile uint32_t ValueLine=0;
  499. volatile uint32_t ValueCNT=0;
  500. extern volatile uint8_t SLEDF;

  502. volatile uint32_t ScanBufSendIndex=0;

  504. volatile uint8_t dotcnt=0;
  505. volatile uint8_t dotcnt2=0;

  507. /*************************************************/
  508. uint8_t ScanBy200dpiProcess(void)
  509. {
  510. //        uint32_t i;
  511. //        uint32_t startp=0;        
  512. //        uint32_t *p1;
  513. //        uint32_t *p2;
  514.         uint8_t (*CheckData)(uint16_t sdpi);        
  515. //        SendScanDataType *p=(SendScanDataType *)struCommuCon.byTxcBuf;
  516.         CheckData=CheckOneLineData;
  517.         
  518.         if(Light_Status!=0)                         //?????                                       
  519.         {
  520.                 if(rollFront.sRunFlag!=RESET)
  521.                 {
  522.                                 while(RunOneStepFlag!=SET);//wait         
  523.                                 RunOneStepFlag=RESET;        

  525. //                        while(MotRunStepEnable!=SET);
  526. //                        MotRunStepEnable=RESET;
  527. //                        StepMotorDrive8841();
  528. //                        TIM3->ARR = (uint32_t) AddSpeedTable[MotStepCount];//TIM_SetAutoreload(TIM3, AddSpeedTable[MotStepCount]);
  529. //                  TIM3->CR1 |= TIM_CR1_CEN;//TIM_Cmd(TIM3, ENABLE);
  530.                         
  531.                         ScanOneLine200();        
  532.                         scan_buffer_Windex=0;//roll                                
  533.                         rollFront.mCnt++;         //
  534. //                        rollFront.sCnt++;          //
  535.                         rollFront.sReplyDataFlag=SET;
  536.                         if ((*CheckData)(200)==1)
  537.                                 rollFront.CheckDataCnt++;           //
  538.                         else
  539.                                 rollFront.CheckDataCnt=0;           //


  542.                         if (MotStepCount < MotStepCountEnd)
  543.                                 MotStepCount+=2;


  546.         //
  547.                         if (rollFront.CheckDataCnt>=2)                                //2         find ticket
  548.                         {        
  549.                                 ReaderStatus=sNormal;
  550.                                 rollFront.sRunFlag=RESET;//
  551.                                 Read_Ticket_Front=RESET;
  552.                                 ReadTicketFlag=SET;         //enable read ticket
  553.                                 scan_line_count=0;          //clear scan line
  554.                                 scan_buffer_Windex=2560;
  555.                                 CIT_BUFFER_DATA_LINE=10;
  556.                                 //MotStepCountEnd=110;//MotStepCountEnd=ApiSetReaderParameter.ScanMaxSpeedStep;//MotStepCountEnd=120;//30-10m;//108;//25;
  557.                                 TIM7_Disable();
  558.                                 Tim7RunStatus=0;
  559.                                 
  560.                                 usbsenddataCount=0;
  561.                                 ScanBufSendIndex=0;

  563.                                 TIM6->ARR =3000;  //??????
  564.                                 TIM6->CNT=0;
  565.                                    TIM6_Enable();         
  566.                                 Tim6RunStatus=0;
  567.         
  568.                         }
  569.                         else        //rollFront.CheckDataCnt<2
  570.                         {
  571. //                                if(sReplyDataFlag!=RESET)
  572. //                                        rollFront.sCnt=0;
  573. //                                if(rollFront.sCnt>10)
  574. //                                {
  575. //                                        rollFront.sCnt=0;
  576. //                                        rollFront.sReplyDataFlag=SET;
  577. //                                }                        
  578.                                 
  579.                                 if(rollFront.mCnt>2000)//
  580.                                 {
  581.                                          #ifdef OldProtocol
  582.                                                  A4_Cmd_2(ReadFail);
  583.                                         #endif
  584.         
  585.                                         rollFront.mReplyDataFlag=SET;

  587. //                                        TIM7_Disable();
  588. //                                        Tim7RunStatus=0;
  589.                         
  590.                                 }                                       
  591.                                                 
  592.                         }

  594.                 }
  595.                 else
  596.                 {
  597.         
  598.                         if(Read_Ticket_Front!=RESET)//if(rollFront.sInitEnableFlag!=RESET)//has front flag
  599.                         {
  600.                                 rollFront.CheckDataCnt=0;
  601.                                 rollFront.mCnt=0;
  602.                                 rollFront.sCnt=0;
  603.                                 rollFront.mReplyDataFlag=RESET;
  604.                                 rollFront.sReplyDataFlag=RESET;
  605.                                 rollFront.sRunFlag=SET;
  606.                                 
  607.                                 ReaderStatus=sRollFront;//????????????0        
  608.                                 MotStepCount=0;//5;
  609.                                 MotStepCountEnd=84;//94;//50;//94;//80;//25;        
  610.                                 ScanOneLine200();
  611.                                 scan_buffer_Windex=0;//roll                        
  612.                                 MotorRunDirection=FORWARD;//forward
  613.                                 TIM3->CR1 |= TIM_CR1_CEN; //enable tim3        //1        
  614.                                 

  616. //                                TIM3->ARR = (uint32_t) AddSpeedTable[MotStepCount];//TIM_SetAutoreload(TIM3, AddSpeedTable[MotStepCount]);
  617. //                                TIM3->CR1 |= TIM_CR1_CEN;//TIM_Cmd(TIM3, ENABLE);
  618.                                 
  619.                                 TIM7->ARR =800;         //reinit tim7
  620.                                 TIM7->CNT=0;
  621.                                    TIM7_Enable();
  622.                                 Tim7RunStatus=2;
  623.                                 BUZZ_Off();
  624.                                                         
  625.                                 
  626.                
  627.                         }
  628.                 }

  630.                 if(ReadTicketFlag!=RESET)                                //?????ticket ????        
  631.                 {        
  632.                         while(RunOneStepFlag==RESET);               
  633.                         RunOneStepFlag=RESET; //one step
  634.                         
  635. //                        while(MotRunStepEnable!=SET);
  636. //                        MotRunStepEnable=RESET;
  637. //                        StepMotorDrive8841();
  638. //                        TIM3->ARR = (uint32_t) AddSpeedTable[MotStepCount];//TIM_SetAutoreload(TIM3, AddSpeedTable[MotStepCount]);
  639. //                  TIM3->CR1 |= TIM_CR1_CEN;//TIM_Cmd(TIM3, ENABLE);

  641.                         ScanOneLine200();
  642.                         
  643.                         //ScanBuffer[checkpaperIndex+112]=(1<<dotcnt2);
  644. //                        ScanBuffer[checkpaperIndex+110]=(1<<(dotcnt++));
  645. //                        if(dotcnt>7)
  646. //                        {        
  647. //                                dotcnt=0;
  648. ////                                dotcnt2++;
  649. ////                                if(dotcnt2>7)
  650. ////                                        dotcnt2=0;
  651. //                        }
  652. //                        if((scan_buffer_Windex-checkpaperIndex)==128)
  653. //                                ScanBuffer[checkpaperIndex+112]=0x05;
  654.                         
  655.                         checkpaperby200();
  656.                         if(scan_buffer_Windex>=SCAN_BUFFER_SIZE)//if(scan_buffer_Hindex>=240)          //80*256 buffer
  657.                                 scan_buffer_Windex=0;               
  658.                         //startp=(uint32_t)(CIT_BUFFER_DATA_LINE*128);
  659.                         CIT_BUFFER_DATA_LINE++;
  660.                         scan_line_count++;
  661.         
  662.                         if(CIT_BUFFER_DATA_LINE>=24)
  663.                         {               
  664.                                 CIT_BUFFER_DATA_LINE=0;
  665.                                 usbsenddataCount++;                                
  666.                                 //__nop();

  668.                         }
  669. //                                p2=(uint32_t *)&ScanBuffer[checkpaperIndex];
  670. //                                p1=(uint32_t *)&(p->TxDataBuf[startp]);//struCommuCon.byTxcBuf[startp];//
  671. //                                for(i=0;i<21;i++)//endp
  672. //                                {
  673. //                                        *p1=*p2;//0x0f0f0f0f;//*p2;//ScanBuffer[checkpaperIndex+i];//*p2;
  674. //                                        //*p2=0;
  675. //                                        p1++;
  676. //                                        p2++;
  677. //                                }


  680.                                 if(usbsenddataCount>12)
  681.                                 {
  682.                                         if(MotStepCountEnd>59)//300mm/s
  683.                                                 MotStepCountEnd--;        
  684.                                 }
  685.                                 else if(usbsenddataCount<5)
  686.                                 {
  687.                                         if(MotStepCountEnd<86)//108)//430mm/s
  688.                                                 MotStepCountEnd++;
  689.                                 }



  693.                         if(scan_line_count>4900)//rollcount)
  694.                         {
  695.                                 MotStop();
  696.                                 TIM3->CR1 &= (uint16_t)~TIM_CR1_CEN;//disable tim3        
  697.                                 //TICKET_READ_START=RESET;
  698.                                 PrintImageFlag=RESET;
  699.         /***/                   check_ticket_finish=RESET;
  700.                                 check_ticket_end_line=0;
  701.                                 scan_line_count=0;
  702.                                 check_ticket_end=SET;
  703.                         //        read_ticket_exit=SET;
  704.                                 Light_Status=0;
  705.                                 SLEDF=0;
  706.                                 Read_Ticket_Front=SET;
  707.                                 ReadTicketFlag=RESET;
  708.                                 SCANNER_ENABLE=SET;                                
  709.                                 TICKET_READ_PAUSE=SET;
  710.                                 TIM5_Enable();
  711.                                 nopapercount=0;
  712.                                 TicketReadPauseCount=0;
  713.                                 scan_buffer_Rindex=0;
  714.                                 scan_buffer_Windex=0;
  715.                                 CIT_BUFFER_DATA_LINE=0;
  716.                                 ReaderStatus=1;//??

  718.                                 ValueCNT=TIM6->CNT;
  719.                                    TIM6_Disable();
  720.                                 ValueLine=scan_line_count;
  721.         
  722.                                 
  723.                         }

  725.                 }
  726.         }

  728.         

  730.         if(ReplyScanDataFlag==RESET)
  731.                 return 0;
  732.         if(bySendFlag!=0)
  733.                 return 0;
  734.         switch(ReaderStatus)
  735.         {

  737.                 case sNormal:
  738.                         
  739.                         if(usbsenddataCount>0)
  740.                         {
  741.                                 usbsenddataCount--;
  742.                                 ReplyScanDataFlag=RESET;
  743.                                 bySendFlag =1;
  744. //                                ReplyScanDataProcess
  745. //                                   (ReaderStatus,
  746. //                                        (uint8_t *)(ScanBuffer+256*scan_buffer_Rindex),
  747. //                                        3072);
  748.                                 /*****************************/               
  749.                                 //ReplyScanDataHeadProcess();
  750.                                 ReplyScanDataProcess();        
  751.                                 
  752.                                 ScanBufSendIndex+=3072;
  753.                                 if(ScanBufSendIndex>=SCAN_BUFFER_SIZE)
  754.                                         ScanBufSendIndex=0;
  755.                                 /*****************************/
  756. //                                scan_buffer_Rindex+=12;
  757. //                                if(scan_buffer_Rindex>=240)
  758. //                                        scan_buffer_Rindex=0;
  759.                         }
  760.                         else if(read_ticket_exit!=RESET)
  761.                         {
  762.                                 ReplyScanDataFlag=RESET;
  763.                                 ReplyDataProcess
  764.                                    (CMDsStartReadticket,
  765.                                         ReaderStatus,
  766.                                         CommuPID,
  767.                                         ExecuteSuccess,
  768.                                         0,
  769.                                     0);
  770.                                                         
  771.                                 read_ticket_exit=RESET;
  772.                                 scan_buffer_Rindex=0;
  773.                                 scan_buffer_Windex=0;
  774.                                 CIT_BUFFER_DATA_LINE=0;        
  775.                         
  776.                         }

  778.                         
  779.                         break;
  780.                         
  781.                 case sInputBlock:
  782.                         
  783.                         ReplyScanDataFlag=RESET;
  784.                         usbsenddataCount=0;
  785.                         ReplyDataProcess
  786.                            (CMDsStartReadticket,
  787.                                 ReaderStatus,//??
  788.                                 CommuPID,
  789.                                 ExecuteSuccess,
  790.                                 0,
  791.                                 0);

  793.                         Beep(3);
  794.                         
  795.                         break;
  796.                         
  797.                 case sOutputBlock:
  798.                 case sSelfcheck:                        
  799.                 case sCoverOpen:
  800.                         
  801.                         break;
  802.                         
  803.                 case sRollFront:

  805.                 if(rollFront.mReplyDataFlag!=RESET)
  806.                 {
  807.                         rollFront.mReplyDataFlag=RESET;
  808.                         
  809.                         ReaderStatus=0;
  810.                         TICKET_READ_START=RESET;
  811.                         Light_Status=0;
  812.                         MotStop();
  813.                         TIM3->CR1 &= (uint16_t)~TIM_CR1_CEN;//disable tim3        
  814.                         MotSteps=1;
  815.                         TIM7_Disable();

  817. //                        DelayNms(10);                  //old qctest
  818.                         
  819.                         ReplyScanDataFlag=RESET;
  820.                         ReplyDataProcess
  821.                            (CMDsStartReadticket,
  822.                                 ReaderStatus,//
  823.                                 CommuPID,
  824.                                 Executefail,
  825.                                 0,
  826.                                 0);
  827.                         //Beep(3);
  828.                         rollFront.sRunFlag=RESET;
  829.                         TIM7_Disable();
  830.                         Tim7RunStatus=0;
  831.                         
  832.                         
  833.                 }
  834.                 else
  835.                 {
  836.                
  837.                         rollFront.sReplyDataFlag=RESET;
  838.                         ReplyScanDataFlag=RESET;
  839.                         ReplyDataProcess
  840.                            (CMDsStartReadticket,
  841.                                 ReaderStatus,//
  842.                                 CommuPID,
  843.                                 ExecuteSuccess,
  844.                                 0,
  845.                                 0);
  846.                
  847.                 }                        
  848.                         
  849.                         break;

  851.                 default:
  852.                         break;

  854.         }                        
  855.                         
  856.                 return 0;
  857. }


  860. uint8_t checkpaperby200(void)
  861. {

  863.         if(check_ticket_finish==RESET)//&&(BetTicketFlag==RESET))        //???
  864.         {
  865.                 if(scan_line_count<320)
  866.                         return 0;
  867.                 else
  868.                         check_ticket_finish=SET;
  869.                
  870.         }
  871.         else
  872.         {        

  874.                 if(CheckTicketComplete(2,6,(uint8_t *)&ScanBuffer[checkpaperIndex])==1)
  875. //                if(CheckTicketComplete(2,(uint8_t *)&ScanBuffer[checkpaperIndex],
  876. //                        (uint8_t *)&ScanBuffer[checkpaperIndex+42])==1)
  877.                         check_ticket_end_line++;
  878.                 else
  879.                         check_ticket_end_line=0;

  881.                 if(check_ticket_end_line>24)//(check_ticket_end_line>20)  //ticket end
  882.                 {
  883.                                 TIM3->CR1 &= (uint16_t)~TIM_CR1_CEN;//disable tim3                                
  884.                                 MotStop();

  886.                                 check_ticket_end_line=0;
  887.                                 //scan_line_count=0;  
  888.                                 check_ticket_end=SET;
  889.                                 read_ticket_exit=SET;
  890.                                 Light_Status=0;
  891.                                 SLEDF=0;
  892.                                 Read_Ticket_Front=SET;
  893.                                 ReadTicketFlag=RESET;
  894.                                 SCANNER_ENABLE=SET;                                
  895. //                                A4_Cmd_2();
  896.                                 TICKET_READ_PAUSE=SET;
  897.                                 TIM5_Enable();
  898.                                 nopapercount=0;
  899.                                 TicketReadPauseCount=0;
  900.                                 scan_buffer_Rindex=0;
  901.                                 scan_buffer_Windex=0;
  902.                                 CIT_BUFFER_DATA_LINE=0;
  903.                                 check_ticket_finish=RESET;
  904.                         //        printf(" exit ticket ");

  906.                                 ValueCNT=TIM6->CNT;
  907. //                                ValueARR=TIM6->ARR;
  908.                                    TIM6_Disable();
  909.                                 ValueLine=scan_line_count;
  910. //                                __nop();

  912.                         sendPrizeInformation(0,0);
  913.                 }        
  914.         }
  915.         return 1;
  916. }

  918. /*******************************************/

  920. uint8_t rollFrontProcess(void)//(uint16_t cdpi)
  921. {

  923.         uint8_t (*CheckData)(uint16_t sdpi);        
  924.         CheckData=CheckOneLineData;

  926.         if(rollFront.sRunFlag!=RESET)
  927.         {
  928.                 while(RunOneStepFlag!=SET);//wait         
  929.                 RunOneStepFlag=RESET;                                
  930.                 ScanOneLine200();        
  931.                 scan_buffer_Windex=0;//roll                                
  932.                 rollFront.mCnt++;         //
  933.                 rollFront.sCnt++;          //
  934.                 if ((*CheckData)(200)==1)
  935.                         rollFront.CheckDataCnt++;           //
  936.                 else
  937.                         rollFront.CheckDataCnt=0;           //
  938. //
  939.                 if (rollFront.CheckDataCnt>=2)                                //2         find ticket
  940.                 {        
  941.                         ReaderStatus=sNormal;
  942.                         rollFront.sRunFlag=RESET;//
  943.                         Read_Ticket_Front=RESET;
  944.                         ReadTicketFlag=SET;         //enable read ticket
  945.                         scan_line_count=0;          //clear scan line
  946.                         scan_buffer_Windex=2560;
  947.                         CIT_BUFFER_DATA_LINE=10;
  948.                         MotStepCountEnd=ApiSetReaderParameter.ScanMaxSpeedStep;//MotStepCountEnd=120;//30-10m;//108;//25;

  950.                 }
  951.                 else        //rollFront.CheckDataCnt<2
  952.                 {
  953.                         if(rollFront.sCnt>10)
  954.                         {
  955.                                 rollFront.sCnt=0;
  956.                                 rollFront.sReplyDataFlag=SET;
  957.                         }                        
  958.                         
  959.                         if(rollFront.mCnt>2000)//
  960.                         {
  961.                                  #ifdef OldProtocol
  962.                                          A4_Cmd_2(ReadFail);
  963.                                 #endif

  965.                                 rollFront.mReplyDataFlag=SET;
  966.                
  967.                         }
  968.                         

  970.                                        
  971.                 }
  972. //               
  973.         
  974.         }
  975.         else
  976.         {

  978.                 if(Read_Ticket_Front!=RESET)//if(rollFront.sInitEnableFlag!=RESET)//has front flag
  979.                 {
  980.                         rollFront.CheckDataCnt=0;
  981.                         rollFront.mCnt=0;
  982.                         rollFront.sCnt=0;
  983.                         rollFront.mReplyDataFlag=RESET;
  984.                         rollFront.sReplyDataFlag=RESET;
  985.                         rollFront.sRunFlag=SET;
  986.                         
  987.                         ReaderStatus=sRollFront;//????????????0        
  988.                         MotStepCount=0;//5;
  989.                         MotStepCountEnd=94;//80;//25;        
  990.                         ScanOneLine200();
  991.                         scan_buffer_Windex=0;//roll                        
  992.                         MotorRunDirection=FORWARD;//forward
  993.                         TIM3->CR1 |= TIM_CR1_CEN; //enable tim3        //1                                
  994.                         
  995.         
  996.                 }
  997.         }


  1000.         return 0;
  1001. }
复制代码
分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏 分享淘帖 顶顶 踩踩
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表