/*
4 ?! Z( `( u& y9 c% b% S************************************************************************************************************
& m( f* X" h' E版权所有 (C)，2010－2012，磊元科技有限公司
--------------------------------------------------------------------------------------------------
头文件名：      　　CommSpi.h
5 ?+ A( O7 [" t' q/ v* O; Y头文件名称：        串行外设接口（ＳＰＩ接口）的头文件
  V: Z3 C  X$ N+ x6 M* Z程序版本：　　      1.0
文件功能：
　　　　本文件是对串行外设接口（ＳＰＩ接口）的源程序文件的编译控制声明、字符化常数和输入／输出引脚定义、
　　全局常量声明、全局数据结构类型定义、全局变量声明和函数原型声明的头文件。
文件说明：
　　　　１．本文件中的所有标识符定义前缀字母表示意义如下：
　　　　　　c  ---------- 常量
　　　　　　v  ---------- 变量
　　　　　　g  ---------- 全局变量（Global）
) y7 X0 j$ v$ C' Q7 E9 k8 f( p　　　　　　l  ---------- 局部变量（Local）
$ h1 G' {& x9 r- }# M4 q" j- u　　　　　　uc ---------- 数据类型（Unsigned Char）
　　　　　　ui ---------- 数据类型（Unsigned Word）
! d4 x& w- G! k$ ^; S: e7 ]# c, n　　　　　　p  ---------- 指针
( |! P/ [  L6 G6 g" _　　　　　　st ---------- 数据体
( y( N2 g  R8 K4 l! F, U　　　　　　pt ---------- 指向数据体的指针
! @6 L- t9 O( E& ?& t6 ~6 A7 P! i            Pre --------- 条件编译预定义
  J) X7 k7 `; [  O            MFH --------- 宏定义硬件操作函数
$ }7 l" M" c2 z; X- b8 z            MFS --------- 宏定义软件操作和条件编译函数
            MFO --------- 宏定义其他函数
+ f; s' Z# t2 Y/ W. \9 a　　　　２．注意：使用源程序的ＳＰＩ接口接收和发送数据的函数之前，必须使能全局中断。
　　　　３．注意：本文件仅实现１条时钟线（SCK）和１条双向数据线（MOSI）的单工通信方式。
主要函数列表：　　　
  U0 e# L2 P1 g# l% i# k. M　　　　▲．在主函数中运行的函数：
　　　　　　１．void UsartsInit(void)（ＵＳＡＲＴｓ端口和查询式串行通讯协议的初始化）
$ t9 @3 \6 u) o5 g7 L　　　　　　２．void Rs422UsartsAskManage(void)（查询式ＲＳ４２２的通讯协议处理）
! @) |4 X9 {, p1 B8 O: s+ w/ Y　　　　▲．中断请求服务函数：
8 N2 c/ D) K& x+ P# g3 G- q　　　　　　１．void usart1_txc_isr(void)（发送结束中断方式发送数据的中断服务程序）
　　　　　　２．void usart1_rxc_isr(void)（接收结束中断方式接收数据的中断服务程序）
编译工具软件：      IAR Embedded Workbench for Atmel AVR 版本：5.20A 以上
( R; c8 z: C: _) N链接文件：          １．SysCfg.h ------------ 系统运行结构定义配置的头文件。
编作者：            磊元
编制日期：          2009年4月8日
--------------------------------------------------------------------------------------------------
- b" U6 R& B4 c. L头文件版本历史：
2006年07月26日  〖磊元〗 -------- 版本 1.0 ：原始版本（AVR）
( z, E  t- I+ B' g2 @2015年09月20日  〖磊元〗 -------- 版本 2.0 ：扩增版本（STM8S）
6 f' T- f) B/ X0 ^3 q8 ~2 _) h************************************************************************************************************
2 O( Z2 B3 K  H*/
2 [6 w! }& Y8 z0 o#ifndef _COMMSPI_H_                                       // “_COMMSPI_H_”条件编译开始
#define _COMMSPI_H_
, I7 Q: Y5 j% R' W" h% s
# o# O. ^8 |2 z7 U; U4 \' H/*==========================================================================================================
- F* z( X  ]" i/ t0 J, t3 ^　　　　　　　　　　　　　　　　　　　　　本头文件包括的其他头文件
+ y, A" K  p/ B' z% Z' O) t* _建议：包含本项目的文件使用 #include "文件名.扩展名" ，
" D" H# Z- s5 e6 h- L* ]3 j　　　包含系统库的文件使用 #include <文件名.扩展名> 。
( Q: O+ Z0 A% [! |+ O) c& @! N==========================================================================================================*/
& z" f5 ~, [7 N6 f- ^#include "SysCfg.h"                                       // 系统运行结构定义配置的头文件

5 S' @' j% i+ i: |5 `8 _7 j#ifdef __cplusplus
extern "C" {                                              // 声明接在下面的指令为Ｃ程序编译系统
& Y0 M7 Z4 b/ s  u#endif

" {4 d8 Z7 e: ~; ~1 w. B4 l/*==========================================================================================================
　　　　　　　　　　　　　　　　　　　　　　　条件编译控制声明
5 ^' S( X2 j, ?( y5 Z5 K+ K* S4 n% `==========================================================================================================*/
//#ifndef PreGlobalCompilerHardware                         // 非“全局统一的条件编译控制和硬件定义”条件编译
/ c7 T0 U% S# U$ g#if defined(PreGlobalWithRedundantCode)
) q* d4 j7 @7 j  g% W: m/*------------------------------------------------------------------------------------------------
声明程序指令使用冗余代码的条件定义：
------------------------------------------------------------------------------------------------*/
; t7 s4 L1 m8 m( u- E#define PreCommSpiWithRedundantCode                       // “使用冗余程序代码”条件定义
#endif
/*------------------------------------------------------------------------------------------------
声明串行外设接口（ＳＰＩ接口）工作于哪种方式的条件定义：
注意：只能使用下面几个条件定义中的１个条件定义，不允许使用２个以上条件定义！！！
警告：此处的声明定义对于本源程序文件和其他源程序文件的编译有决定性作用，应慎重！
------------------------------------------------------------------------------------------------*/
#define PreCommSpiUseSingleMasterMode                          // “ＳＰＩ接口工作于单主机方式”条件定义
9 V; x9 w4 m7 Q/ J3 d//#define PreCommSpiUseSingleSlaveMode                      // “ＳＰＩ接口工作于单从机方式”条件定义
//#define PreCommSpiUseMultiSlaveMode                            // “ＳＰＩ接口工作于多从机方式”条件定义
& E3 Y6 Z% B8 i" g#if   (   (defined(PreCommSpiUseSingleMasterMode) || defined(PreCommSpiUseSingleSlaveMode)) \
) |. B! J; _: `" g3 ]) a       && (defined(PreCommSpiUseSingleMasterMode) || defined(PreCommSpiUseMultiSlaveMode )) \
6 k  ^9 N, c& {4 l$ |       && (defined(PreCommSpiUseSingleSlaveMode ) || defined(PreCommSpiUseMultiSlaveMode )) )
#error 错误：＜声明串行外设接口（ＳＰＩ接口）工作于哪种方式的条件定义＞不允许使用２个以上条件定义！！！
#endif
$ n( j$ s3 N6 `; k/*------------------------------------------------------------------------------------------------
声明在应用中对于具有多个ＳＰＩ接口的目标器件芯片，具体指定使用哪一个ＳＰＩ端口的条件定义：
------------------------------------------------------------------------------------------------*/
#define PreCommSpiMultipleSpiEnable0                      // 使用ＳＰＩ０接口的声明定义
//#endif                                                    // “PreGlobalCompilerHardware”

/*==========================================================================================================
　　　　　　　　　　　　　　　各类字符化常数和硬件设计相关的输入／输出引脚定义
==========================================================================================================*/
//#ifndef PreGlobalCompilerHardware                         // 非“全局统一的条件编译控制和硬件定义”条件编译
/*------------------------------------------------------------------------------------------------
ＳＰＩ接口接口的输入／输出引脚定义：
( y/ }9 x+ I# Q3 ?' F* V注：下列这些定义与硬件设计相关，如需改变控制的输入／输出引脚仅在此重新定义即可。
1 t( j! d  O% X2 W/ n: r0－－A，1－－B，2－－C，3－－D，4－－E，5－－F，6－－G，7－－H，8－－I，9－－J。
------------------------------------------------------------------------------------------------*/
#if   (defined(PreMcuIs__AtMega64)  || defined(PreMcuIs__AtMega64A)  || \
       defined(PreMcuIs__AtMega128) || defined(PreMcuIs__AtMega128A) || \
6 w* j0 C; O9 ^  A       defined(PreMcuIs__AtMega162) || defined(PreMcuIs__AtMega162A)    )
: R" Z0 h9 B4 K#elif (defined(PreMcuIs__STM8S207R6) || defined(PreMcuIs__STM8S208R6)  || \
       defined(PreMcuIs__STM8S207R8) || defined(PreMcuIs__STM8S208R8)  || \
       defined(PreMcuIs__STM8S207RB) || defined(PreMcuIs__STM8S208RB)     )
  N" |3 h( s2 [2 S#ifdef _USE_STM8_FWLIB_                                   // “使用 STM8 FWLib 的库文件”条件编译开始
#define cSpi0Gpio             GPIOE
3 J- R1 l  U8 }" v& @9 `3 N#define cSpi0SclPinBit        GPIO_PIN_1
#define cSpi0SdaPinBit        GPIO_PIN_2
#else                                                     // “_USE_STM8_FWLIB_”
& @1 Z; {8 P& n  K0 ^& c6 O. F#define cDdrSpi0Mosi         P2DDR                       // ＳＰＩ０主出/ 从入引脚的数据方向寄存器
#define cOdrSpi0Mosi         P2ODR                       // ＳＰＩ０主出/ 从入引脚的输出数据寄存器
#define cIdrSpi0Mosi         P2IDR                       // ＳＰＩ０主出/ 从入引脚的输入数据寄存器
+ t+ ]& R$ e" V9 y! P' \#define cPurSpi0Mosi         P2PUR                       // ＳＰＩ０主出/ 从入引脚的上拉电阻寄存器（控制寄存器１）
#define cCirSpi0Mosi         P2CIR                       // ＳＰＩ０主出/ 从入引脚的控制中断寄存器（控制寄存器２）
3 `$ T0 O& ]$ d' b; R: m: R1 T) w#define cPidSpi0Mosi         PI26                        // ＳＰＩ０主出/ 从入引脚的引脚输入
#define cPodSpi0Mosi         PO26                        // ＳＰＩ０主出/ 从入引脚的引脚输出
#define cBitSpi0Mosi         BIT6                        // ＳＰＩ０主出/ 从入引脚的引脚数字索引
" J4 d4 H4 W4 W  W. S#define cDdrSpi0Miso         P2DDR                       // ＳＰＩ０主入/ 从出引脚的数据方向寄存器
, ?" R$ X6 I4 E6 E2 x#define cOdrSpi0Miso         P2ODR                       // ＳＰＩ０主入/ 从出引脚的输出数据寄存器
& M  L) Y0 t# X5 S; g8 S#define cIdrSpi0Miso         P2IDR                       // ＳＰＩ０主入/ 从出引脚的输入数据寄存器
#define cPurSpi0Miso         P2PUR                       // ＳＰＩ０主入/ 从出引脚的上拉电阻寄存器（控制寄存器１）
#define cCirSpi0Miso         P2CIR                       // ＳＰＩ０主入/ 从出引脚的控制中断寄存器（控制寄存器２）
) |, t0 v: o; P5 F1 K' B" }" q* Y#define cPidSpi0Miso         PI27                        // ＳＰＩ０主入/ 从出引脚的引脚输入
#define cPodSpi0Miso         PO27                        // ＳＰＩ０主入/ 从出引脚的引脚输出
#define cBitSpi0Miso         BIT7                        // ＳＰＩ０主入/ 从出引脚的引脚数字索引
#define cDdrSpi0Sclk         P2DDR                       // ＳＰＩ０串行时钟引脚的数据方向寄存器
#define cOdrSpi0Sclk         P2ODR                       // ＳＰＩ０串行时钟引脚的输出数据寄存器
# M. `8 [# f5 G6 r, G; `#define cIdrSpi0Sclk         P2IDR                       // ＳＰＩ０串行时钟引脚的输入数据寄存器
/ t6 i1 X5 u5 G7 s, r  a#define cPurSpi0Sclk         P2PUR                       // ＳＰＩ０串行时钟引脚的上拉电阻寄存器（控制寄存器１）
( a6 w! _" Z8 @. I9 o$ C! x( [#define cCirSpi0Sclk         P2CIR                       // ＳＰＩ０串行时钟引脚的控制中断寄存器（控制寄存器２）
#define cPidSpi0Sclk         PI25                        // ＳＰＩ０串行时钟引脚的引脚输入
#define cPodSpi0Sclk         PO25                        // ＳＰＩ０串行时钟引脚的引脚输出
: j: ^( P# R0 d4 I  `/ i3 S+ n* N, s#define cBitSpi0Sclk         BIT5                        // ＳＰＩ０串行时钟引脚的引脚数字索引
; O2 b# Y! h6 x#define cDdrHt1381Cs         P3DDR                       // ＳＰＩ０ HT1381 片选引脚的数据方向寄存器
#define cOdrHt1381Cs         P3ODR                       // ＳＰＩ０ HT1381 片选引脚的输出数据寄存器
#define cIdrHt1381Cs         P3IDR                       // ＳＰＩ０ HT1381 片选引脚的输入数据寄存器
+ `* f1 l. I0 ^* U+ Y; B! q' F( o#define cPurHt1381Cs         P3PUR                       // ＳＰＩ０ HT1381 片选引脚的上拉电阻寄存器（控制寄存器１）
#define cCirHt1381Cs         P3CIR                       // ＳＰＩ０ HT1381 片选引脚的控制中断寄存器（控制寄存器２）
# i, p: a8 a4 C8 p. h& [# ^" A#define cPidHt1381Cs         PI32                        // ＳＰＩ０ HT1381 片选引脚的引脚输入
4 ~* j! g' f' g3 V; w& }#define cPodHt1381Cs         PO32                        // ＳＰＩ０ HT1381 片选引脚的引脚输出
: B* W' M* z- G' v" B; g#define cBitHt1381Cs         BIT2                        // ＳＰＩ０ HT1381 片选引脚的引脚数字索引
#endif                                                    // “_USE_STM8_FWLIB_”
#else
; Y( [! S. [) J- G4 Y# ~#error 错误：没有定义ＳＰＩ接口接口的输入引脚端口！！！
; z; D8 I/ t5 U2 m7 _#endif                                                    // “PreMcuIs__......”
! c/ B% }. y, D, {7 E/*------------------------------------------------------------------------------------------------
ＳＰＩ接口收发数据缓冲区大小字符化定义:
& v- |& U& |5 y. `+ ^( I2 d0 g  f, D( ?8 @------------------------------------------------------------------------------------------------*/
! }! C" E( _( @! C! e0 K#define cSpi0BufSize          0x12                        // ＳＰＩ接口接收和发送数据缓冲区大小
  y. C6 A; g$ Q* X) K/ x//#endif                                                    // “PreGlobalCompilerHardware”
/ p; u/ C' s% B  d* s) o#ifdef PreCommSpiUseMultiSlaveMode                        // “ＳＰＩ接口工作于多从机方式”条件编译结束
+ O5 D% |, M% ^9 k#define cSpi0RxBufSize        (cSpi0BufSize + 1)          // ＳＰＩ接口接收数据缓冲区大小
9 w& N0 E# ^9 v; V% D: u* E#define cSpi0TxBufSize        (cSpi0BufSize + 2)          // ＳＰＩ接口发送数据缓冲区大小
0 I3 C! ^7 ~' s* g#else
7 V+ N7 D4 G# H2 t( t# l7 N0 T#define cSpi0RxBufSize        (cSpi0BufSize + 0)          // ＳＰＩ接口接收数据缓冲区大小
#define cSpi0TxBufSize        (cSpi0BufSize + 1)          // ＳＰＩ接口发送数据缓冲区大小
5 J, d# Z, y+ `! g3 L#endif
//#ifndef PreGlobalCompilerHardware                         // 非“全局统一的条件编译控制和硬件定义”条件编译
1 h$ u" Z' ?0 a' F  @/ n# a#define cSpiErrorMax          0x10                        // ＳＰＩ接口通讯收发作业最大发生错误次数值
#define cSpiOverSec           0x08                        // 通讯任务超时时间的最大秒数值（８ｓ）
# @1 k5 v2 F1 G. b* ]#define cSpiOverSpiOk         0x3A                        // 占用ＳＰＩ接口超时时间的最大秒数值（５８ｓ）
//#endif                                                    // “PreGlobalCompilerHardware”
#if   (defined(_IAR_EW_AVR_))
/*--------------------------------------------------------------------------------------
0 S) K7 L* q% |" AＳＰＩ工作时的数据发送次序、时钟极性、时钟相位、ＳＣＫ时钟速率配置定义：
“DORD” ----- 数据发送次序，置位＝数据的ＬＳＢ首先发送；清位＝数据的ＭＳＢ首先发送。
“CPOL” ----- 时钟极性，置位＝空闲时ＳＣＫ为高电平；清位＝空闲时ＳＣＫ为低电平。
“CPHA” ----- 时钟相位，置位＝在ＳＣＫ的结束沿采样；清位＝在ＳＣＫ的起始沿采样。
  r9 D8 y% V0 _, e“SPR1、SPR0” ----- ＳＣＫ时钟速率，００＝１／４系统时钟频率；
3 k% T# a* {0 N! i                                     ０１＝１／１６系统时钟频率；
* s4 l0 I  \5 J0 L' s9 o9 k9 ^                                     １０＝１／６４系统时钟频率；
7 d/ |6 F4 `0 \( F& R+ h$ J                                     １１＝１／１２８系统时钟频率。
--------------------------------------------------------------------------------------*/
" v9 i- `1 Y! r+ ~! g// ＳＰＩ配置寄存器的位屏蔽值
#define cSpiSpicrCfgMask      ((1<<DORD)|            \
                               (1<<CPOL)|(1<<CPHA)|  \
* P" H) g( ^4 H" p                               (1<<SPR1)|(1<<SPR0))
#define cSpiSpicrConfig       ((1<<DORD)|            \
                               (0<<CPOL)|(0<<CPHA)|  \
                               (0<<SPR1)|(1<<SPR0))
  P! h" K# c- D/ y#elif ((defined(_IAR_EW_MCS51_)) || (defined(_KEIL_UV_MCS51_)))
#elif (   defined(_IAR_EW_STM8_) \
       || defined(_COSMIC_STM8_) )                        // “......_STM8 编译器”条件编译开始
#ifdef _USE_STM8_FWLIB_                                   // “使用 STM8 FWLib 的库文件”条件编译开始
#else                                                     // “_USE_STM8_FWLIB_”
9 w; t" Y% ?. G2 H, Y& X/*------------------------------------------------------------------------------------------------
& `4 @2 o1 i( q- T* {0 [5 }ＳＰＩ工作时的数据发送次序、时钟极性、时钟相位、ＳＣＫ时钟速率配置定义：
“spiCPHA ” ----- 【DF】时钟相位控制位，０：数据锁存在第１个时钟沿，１：数据锁存在第２个时钟沿
3 ?4 r5 V4 p: d“spiCPOL ” ----- 【LH】时钟空闲极性（仅主机模式有效），０：空闲时ＳＣＫ为低电平，１：空闲时ＳＣＫ为高电平。
( h- G9 X- X( j) I) q“spiDORD ” ----- 【ML】发送数据次序，０：ＭＳＢ首先发送，１：ＬＳＢ首先发送
“spiCS2、spiCS1、spiCS0” ----- ＳＣＫ时钟速率，０００～１１＝１／２～１／２５６系统时钟频率。
------------------------------------------------------------------------------------------------*/
// ＳＰＩ配置寄存器的位屏蔽值
#define cSpiSpicrCfgMask      ((u8)( ((1<<spiCPHA )|                             \
9 c* C. F- I! e- N2 _                                      (1<<spiCPOL )|                             \
                                      (1<<spiCS0  )|(1<<spiCS1  )|(1<<spiCS2  )| \
                                      (1<<spiDORD )                              )))
( D" z% p8 G3 o% `' ?/ o) ?( [// ＳＰＩ配置＝数据锁存在第１个时钟沿、空闲时ＳＣＫ为低电平、ＬＳＢ首先发送
) {! O% r. n" t6 J#define cSpiSpicrCfgDLL256    ((0<<spiCPHA )|                             \
8 F" C0 T& P" f2 I% A. i& R                               (0<<spiCPOL )|                             \
* y; f9 @+ }: \  }0 h3 Q                               (1<<spiCS0  )|(1<<spiCS1  )|(1<<spiCS2  )| \
0 b3 c! g8 p0 ^7 e* s                               (1<<spiDORD )                              )
#define cSpiSpicrCfgDLL016    ((0<<spiCPHA )|                             \
                               (0<<spiCPOL )|                             \
' b  K- m+ @8 [* s                               (1<<spiCS0  )|(1<<spiCS1  )|(0<<spiCS2  )| \
% @# }! S" f1 B/ ~6 j                               (1<<spiDORD )                              )
#define cSpiSpicrCfgDLL032    ((0<<spiCPHA )|                             \
1 e% m" [( j- C+ p( Z                               (0<<spiCPOL )|                             \
" M# F% q6 a0 K$ d/ a$ e                               (0<<spiCS0  )|(0<<spiCS1  )|(1<<spiCS2  )| \
4 a/ L6 C- T( T# |                               (1<<spiDORD )                              )
9 ]8 F% ~# D! d2 X% }// ＳＰＩ配置＝数据锁存在第２个时钟沿、空闲时ＳＣＫ为低电平、ＬＳＢ首先发送
: g9 Q" z$ d; g* x3 ~/ l#define cSpiSpicrCfgFLL256    ((1<<spiCPHA )|                             \
                               (0<<spiCPOL )|                             \
7 j! n9 b1 R# }' Q. M2 f) n                               (1<<spiCS0  )|(1<<spiCS1  )|(1<<spiCS2  )| \
                               (1<<spiDORD )                              )
// ＳＰＩ配置＝数据数据锁存在第１个时钟沿、空闲时ＳＣＫ为高电平、ＬＳＢ首先发送
0 Z$ A+ q( o7 J+ U#define cSpiSpicrCfgDHL256    ((0<<spiCPHA )|                             \
                               (1<<spiCPOL )|                             \
                               (1<<spiCS0  )|(1<<spiCS1  )|(1<<spiCS2  )| \
. B+ O9 u2 x# T( A                               (1<<spiDORD )                              )
// ＳＰＩ配置＝数据数据锁存在第２个时钟沿、空闲时ＳＣＫ为高电平、ＬＳＢ首先发送
#define cSpiSpicrCfgFHL032    ((1<<spiCPHA )|                             \
8 {: m6 m$ h" M" Z2 L  z; X5 O$ d                               (1<<spiCPOL )|                             \
                               (0<<spiCS0  )|(0<<spiCS1  )|(1<<spiCS2  )| \
* x) B. C0 J+ A: i% d                               (1<<spiDORD )                              )
#endif                                                    // “_USE_STM8_FWLIB_”
) n) V# H8 R% X1 a2 R#else
#error 错误：
8 W6 q0 G: H8 c' J  @, Y. o' g#endif                                                    // “PreMcuIs__......”
/*------------------------------------------------------------------------------------------------
ＳＰＩ接口ＣＲＣ除数多项式值定义:
------------------------------------------------------------------------------------------------*/
* e% n9 T2 c! x+ H#define cSpiCrcPolynomial     ((u8)( 0x8C))               // ＳＰＩ的ＣＲＣ除数多项式值
' B: J: b7 b  X3 _( b
2 F% G, f! X- J# ~2 }

/*------------------------------------------------------------------------------------------------
MFHSpiModSpiOnn( ) --------- 使能ＳＰＩ接口模块
MFHSpiModSpiOff( ) --------- 禁止ＳＰＩ接口模块
6 H( ]- L# v( V+ I6 W  {MFHSpiModClkOnn( ) --------- 使能ＳＰＩ接口模块外设时钟
2 H, X: _; S- u% |: OMFHSpiModClkOff( ) --------- 禁止ＳＰＩ接口模块外设时钟
5 [* v5 ]' A- \: P! XMFHSpiFlgAllClr( ) --------- 清０ＳＰＩ接口全部中断标志位
MFHSpiIntAllClr( ) --------- 进入中断后，在中断句柄中，清０ＳＰＩ接口全部中断标志位（在中断服务程序中）
6 R; T$ O) y2 k4 y2 H0 pMFHSpiIntErrChk( ) --------- 检查ＳＰＩ接口错误中断状态值
MFHSpiIntWufChk( ) --------- 检查ＳＰＩ接口唤醒中断状态值
MFHSpiIntAllOnn( ) --------- 使能ＳＰＩ接口事件全部中断
MFHSpiIntTxdOnn( ) --------- 使能ＳＰＩ接口发送中断、错误中断
& o6 @8 z6 f0 |2 e8 {* T% uMFHSpiIntRxdOnn( ) --------- 使能ＳＰＩ接口接收中断、错误中断
MFHSpiIntAllOff( ) --------- 禁止ＳＰＩ接口事件全部中断
------------------------------------------------------------------------------------------------*/
. m$ X+ d; J) Q% W/ _) t/ {#if   (defined(_IAR_EW_AVR_))

( m7 ]  a$ ~! T#elif ((defined(_IAR_EW_MCS51_)) || (defined(_KEIL_UV_MCS51_)))
& g1 g6 P; L5 z9 t' N; ]
, [+ L6 u- t1 l$ k#elif (   defined(_IAR_EW_STM8_) \
       || defined(_COSMIC_STM8_) )                        // “......_STM8 编译器”条件编译开始
#ifdef _USE_STM8_FWLIB_                                   // “使用 STM8 FWLib 的库文件”条件编译开始

; H4 o) v9 N. ~! W+ o+ S4 |#else                                                     // “_USE_STM8_FWLIB_”
9 X' [9 r4 j* Q3 J$ J9 {#define MFHSpiModSpiOnn( )            SPICR1                       |= (u8)( ((1<<spiEN   )))            ;
// 因为ＳＰＩ接口模块被停止，无法控制ＳＣＫ引脚电平
#define MFHSpiModSpiOff( )            SPICR1                       &= (u8)(~((1<<spiEN   )))            ; \
* E' l9 E7 i6 ?  w+ p. e                                      if (SPICR1 & (u8)( ((1<<spiCPOL ))))                                \
                                      {                                                                   \
! U. n/ `3 G+ C! |7 Q                                        MFH_PIN_OUT_SETH_SpiSclk;                                         \
                                      }                                                                   \
, O/ T! J2 N2 M! t6 K$ ~                                      else                                                                \
                                      {                                                                   \
                                        MFH_PIN_OUT_CLRL_SpiSclk;                                         \
% r, |' T3 {5 ^                                      }
$ O/ x' S! w( n  ^#define MFHSpiModClkOnn( )            CLKPECR1                     |= (u8)( ((1<<clkSPI  )))            ;
#define MFHSpiModClkOff( )            CLKPECR1                     &= (u8)(~((1<<clkSPI  )))            ;
) j: J2 x% c, G' M: }' z#define MFHSpiFlgAllClr( )            SPISR                         = (u8)( ((0<<spiRXNE )|               \
. }, |8 @0 C9 Q1 a                                                                             (0<<spiDRE  )|               \
# `! i& t, @" B0 G9 }6 t# w                                                                             (0<<spiWUF  )|(0<<spiCRCEF)| \
, ^& p+ L" H. N) b  _0 e                                                                             (0<<spiMODF )|(0<<spiOVF  )| \
" z) \! K6 C9 e* _                                                                             (0<<spiBSY  ) ));
3 m# n) c+ D2 i4 B( k( w#define MFHSpiIntAllClr( )            SPISR                         = (u8)( ((0<<spiRXNE )|               \
                                                                             (0<<spiDRE  )|               \
0 F. r- C" n& A                                                                             (0<<spiWUF  )|(0<<spiCRCEF)| \
. v" Y- P/ ~' O, h5 v2 J                                                                             (0<<spiMODF )|(0<<spiOVF  )| \
                                                                             (0<<spiBSY  ) ));
#define MFHSpiIntErrChk( )            SPISR & (u8)( ((1<<spiCRCEF)|               \
                                                     (1<<spiMODF )|(1<<spiOVF  )) )
* u: ~" A' k) f, K) V" X#define MFHSpiIntWufChk( )            SPISR & (u8)( ((1<<spiWUF  )               ) )
#define MFHSpiIntAllOnn( )            SPIICR                        = (u8)( ((1<<spiWUIE )|(1<<spiERRIE)| \
( }: M, E: k5 I                                                                             (1<<spiRXIE )|               \
% h$ Y4 U* j  F1 `$ S9 C5 H                                                                             (1<<spiTXIE ) )              );
( J7 C! e) x# D2 r( |* k3 p* G#define MFHSpiIntTxdOnn( )            SPIICR                        = (u8)( ((0<<spiWUIE )|(1<<spiERRIE)| \
                                                                             (0<<spiRXIE )|               \
                                                                             (1<<spiTXIE ) )              );
, K) v* p8 b$ Y#define MFHSpiIntRxdOnn( )            SPIICR                        = (u8)( ((0<<spiWUIE )|(1<<spiERRIE)| \
                                                                             (1<<spiRXIE )|               \
                                                                             (0<<spiTXIE ) )              );
3 ?9 T% Z$ Y& l. r& R7 E( n#define MFHSpiIntAllOff( )            SPIICR                        = (u8)( ((0<<spiWUIE )|(0<<spiERRIE)| \
                                                                             (0<<spiRXIE )|               \
                                                                             (0<<spiTXIE ) )              );
#endif                                                    // “_USE_STM8_FWLIB_”
#else
#error 错误：
# |# j7 Y8 ]/ a& k$ e#endif                                                    // “PreMcuIs__......”
; D, K8 Q" S5 Q9 t6 Y, G

  W4 n0 _4 p1 M' u  |/ O# I' Y* `

  o2 \& ^. P0 V/*
' T: U( @& y9 w+ g* y4 K************************************************************************************************************
　　　　　　　　　　　　　　　　　　　　　　　程序指令代码清单
! u4 n: D2 b/ ^" ^6 F: Y************************************************************************************************************
*/
: a1 V, N% v. L; s2 T/*==========================================================================================================
+ x, G% v6 s6 ^5 [7 a, q$ |函数名称：　　串行外设接口（ＳＰＩ接口），使用中断方式接收和发送数据通信的初始化
函数功能：　　本函数用于串行外设接口（ＳＰＩ接口），使用中断方式接收和发送数据通信的初始化操作。
4 X; F+ I4 |$ S; U# f函数入口参数：没有
3 ?" ]- y/ l3 Z! y- Z! S' v5 s函数返回值：　没有
4 u8 V* g8 B( A调用函数：　　１．
备注：        １．本函数仅在主函数中调用一次即可。
6 Y9 A: P: q; q==========================================================================================================*/
0 K4 t- z/ ~  T6 ?* D. q- D% Rvoid  CommSpiInit (void)
  I' I: L) v" a) V{
& }! t3 o3 X  Z) K3 h" O/ ~  CommSpiDataStru           *pSpi;                        // 指向ＳＰＩ接口通讯收发数据处理变量的指针

: Q2 _0 D& \# ]" w3 S, c) l! p( e  pSpi                      = &gstvSpi;                   // 取ＳＰＩ接口通讯收发数据处理变量的首个地址
/ M% M, T7 F. ~2 `1 {#ifdef PreCommSpiUseSingleMasterMode                      // “ＳＰＩ接口工作于单主机方式”的条件编译
/*------------------------------------------------------------------------------------------------
% e1 T0 e, h; Z7 a; e$ u2 G“ＳＰＩ接口工作于主机方式”的初始化操作。
------------------------------------------------------------------------------------------------*/
* q% F8 R9 G/ L  h. Z+ R/ d- E  MFH_PIN_CFG_OUTL_SpiMosi;                               // 设置ＳＰＩ主出/ 从入引脚为输出引脚，并为Ｌ电平
$ ^0 O1 D& `; X& M% b+ x2 m; r( z  MFH_PIN_CFG_INPU_SpiMiso;                               // 设置ＳＰＩ主入/ 从出引脚为输入引脚，并使能上拉电阻
9 ?* V6 c3 q% C6 f5 x# }  MFH_PIN_CFG_OUTL_SpiSclk;                               // 设置ＳＰＩ串行时钟引脚为输出引脚，并确保为Ｌ电平（没有操作时）
5 M8 @/ G% Y& g3 F. J4 i+ r  MFH_PIN_CFG_OUTL_Ht1381Cs;                              // 设置ＳＰＩ HT1381 片选引脚为输出引脚，并为Ｌ电平（禁止）
3 U2 A7 x# S* y- m#if   (defined(_IAR_EW_AVR_))
0 u3 E3 n: s( u5 P$ f: I. h% p  SPCR = (0<<SPIE)|(1<<SPE)|                              // 禁止ＳＰＩ中断、ＳＰＩ使能、
0 i7 u. |3 {, g6 s* H: F+ F" U         (1<<MSTR)|                                       // 主机模式、
; ]) R$ ~. k. z/ Z+ p4 q" H         + cSpiSpicrConfig;                               // 数据次序、时钟极性、时钟相位、ＳＣＫ速率。
  SPSR = 0x00;                                            // 清除ＳＰＩ速度加倍
  temp = SPSR;                                            // 通过先读 SPSR，紧接着访问 SPDR 来清零ＳＰＩ
  temp = SPDR;                                            // 中断标志和写冲突标志，使ＳＰＩ空闲
6 t# J1 ]& l2 n  c0 U& D4 E# C! B  SFIOR &= ~(1<<PUD) ;                                    // 使能所有Ｉ／Ｏ端口的上拉电阻
#elif ((defined(_IAR_EW_MCS51_)) || (defined(_KEIL_UV_MCS51_)))
' U, D0 `8 q+ e$ `4 g
#elif (   defined(_IAR_EW_STM8_) \
       || defined(_COSMIC_STM8_) )                        // “......_STM8 编译器”条件编译开始
#ifdef _USE_STM8_FWLIB_                                   // “使用 STM8 FWLib 的库文件”条件编译开始
5 P4 V0 A: |6 y  I2C_Cmd(ENABLE);
- ?* k1 r# H/ D' W# ^$ T. s  I2C_Init(cSpi0BaudRate, cSpiOwnAddr, I2C_DUTYCYCLE_2, I2C_ACK_CURR, I2C_ADDMODE_7BIT, (cSysCpuClk / 1000000UL));
- T  {/ b1 }; @0 `5 a  I2C_ITConfig((I2C_IT_ERR | I2C_IT_EVT | I2C_IT_BUF), ENABLE);
: T$ [! d; Q8 |/ V1 S" A/ D* ^+ o#else                                                     // “_USE_STM8_FWLIB_”
: l% y5 _, m2 s' c' [//  SpiDeInit( );
! \$ r) I7 X. }- y  SPICR1          = (u8)( ((1<<spiMSTR )|                 // 主／从机模式＝主机，
                           (0<<spiEN   )|                 // 禁止ＳＰＩ接口模块，
1 y) D3 m# q" Y& s$ S" ^: X6 \                           cSpiSpicrCfgDLL256));          // ＳＰＩ配置＝数据锁存在第１个时钟沿、空闲时ＳＣＫ为低电平、ＬＳＢ首先发送
  SPICR2          = (u8)( ((1<<spiSSI  )|(1<<spiSSM  )|   // 内部从设备＝主模式，使能软件从机设备管理
' n" N7 M0 g8 N" a4 K                           (0<<spiRXTX )|                 // 只接收，０：全双工（同时发送和接收），１：输出禁止（只接收）
, e! O: N. z8 |; l: g2 ?7 @2 r                           (0<<spiCRCTX)|(0<<spiCRCEN)|   // 下一个发送的数据来自Tx缓冲区，禁止硬件ＣＲＣ计算
                           (0<<spiBDOE )|(1<<spiBDM  ) ));// 禁止双向模式下输出，使能单线双向数据模式
  SPICRCPR        = (u8)( cSpiCrcPolynomial);             // 置ＳＰＩＣＲＣ多项式寄存器的数值
. F1 Y, k1 @- s  SPIICR          = (u8)( ((0<<spiWUIE )|(0<<spiERRIE)|   // 禁止唤醒中断，禁止错误中断
                           (0<<spiRXIE )|                 // 禁止接收中断
0 X$ x4 |+ c2 O2 y" z                           (0<<spiTXIE) ));               // 禁止发送中断
#endif                                                    // “_USE_STM8_FWLIB_”
" S% ?2 |' w& S0 y( x. ?#else
#error 错误：
#endif                                                    // “PreMcuIs__......”
/ S, }& f, _  {" U$ p7 l#endif                                                    // “PreCommSpiUseSingleMasterMode”
* w$ J3 ?% |+ o+ X# {( M4 b8 i1 w#if defined(PreCommSpiUseSingleSlaveMode) || defined(PreCommSpiUseMultiSlaveMode)
4 h0 Q: I8 k) q, b  t8 [                                                          // “ＳＰＩ接口工作于从机方式”的条件编译
/*------------------------------------------------------------------------------------------------
4 P! a, G2 N* x% h# ~1 D5 g* n“ＳＰＩ接口工作于从机方式”的初始化操作。
2 A* K9 y" S+ N3 F4 a1 F' E5 X3 E------------------------------------------------------------------------------------------------*/
- w9 y' a$ X- E6 q  t- w  MFH_PIN_CFG_INHZ_SpiMosi;                               // 设置ＳＰＩ主出/ 从入引脚为输入引脚，并为高阻输入态
) ^/ T, n' D3 M# x+ @3 }6 J  p  MFH_PIN_CFG_OUTL_SpiMiso;                               // 设置ＳＰＩ主入/ 从出引脚为输出引脚，并为Ｌ电平
& R5 Q/ d! Z  t; X' `8 i& A/ F  MFH_PIN_CFG_INHZ_SpiSclk;                               // 设置ＳＰＩ串行时钟引脚为输入引脚，并使能上拉电阻
  M5 Z; B+ X" c% C5 L. _1 U/ G  MFH_PIN_CFG_INPU_Ht1381Cs;                              // 设置ＳＰＩ HT1381 片选引脚为输入引脚，并使能上拉电阻
#if   (defined(_IAR_EW_AVR_))
" Y" e( \. S1 y- v& O3 G  SPCR = (1<<SPIE)|(1<<SPE)|                              // ＳＰＩ中断使能、ＳＰＩ使能、
         (0<<MSTR)|                                       // 从机模式、
9 w$ N7 q% f$ Y: W         + cSpiSpicrConfig;                               // 数据次序、时钟极性、时钟相位、ＳＣＫ速率。
- u  |4 V& l. R9 m# `  SPSR = 0x00;                                            // 清除ＳＰＩ速度加倍
  temp = SPSR;                                            // 通过先读 SPSR，紧接着访问 SPDR 来清零ＳＰＩ
  temp = SPDR;                                            // 中断标志和写冲突标志，使ＳＰＩ空闲
#elif ((defined(_IAR_EW_MCS51_)) || (defined(_KEIL_UV_MCS51_)))
! W& s% @% |9 [; O' W- }, {* ~
( d9 A# N+ ]0 A# t6 t#elif (   defined(_IAR_EW_STM8_) \
       || defined(_COSMIC_STM8_) )                        // “......_STM8 编译器”条件编译开始
#ifdef _USE_STM8_FWLIB_                                   // “使用 STM8 FWLib 的库文件”条件编译开始
5 b' V% @3 a1 e( w' T  I2C_Cmd(ENABLE);
4 E- x- N9 `" ?- N; F  I2C_Init(cSpi0BaudRate, cSpiOwnAddr, I2C_DUTYCYCLE_2, I2C_ACK_CURR, I2C_ADDMODE_7BIT, (cSysCpuClk / 1000000UL));
( x$ V# O8 G1 w1 T& I" A; |  I2C_ITConfig((I2C_IT_ERR | I2C_IT_EVT | I2C_IT_BUF), ENABLE);
#else                                                     // “_USE_STM8_FWLIB_”
  SpiDeInit( );
  SPICR1          = (u8)( ((0<<spiMSTR )|                 // 主／从机模式＝从机，
; B1 T- K) u' U5 t3 M2 Y                           (0<<spiEN   )|                 // 禁止ＳＰＩ接口模块，
) ~* [6 }5 N, R                           cSpiSpicrCfgDLL256));          // ＳＰＩ配置＝数据锁存在第１个时钟沿、空闲时ＳＣＫ为低电平、ＬＳＢ首先发送
  SPICR2          = (u8)( ((1<<spiSSI  )|(1<<spiSSM  )|   // 内部从设备＝主模式，使能软件从机设备管理
5 a: C: m+ A: L: E* j                           (0<<spiRXTX )|                 // 只接收，０：全双工（同时发送和接收），１：输出禁止（只接收）
- e# b; L" S7 l2 a0 Y% h% D. E4 V                           (0<<spiCRCTX)|(0<<spiCRCEN)|   // 下一个发送的数据来自Tx缓冲区，禁止硬件ＣＲＣ计算
7 F8 X5 O9 @7 f; z                           (0<<spiBDOE )|(1<<spiBDM  ) ));// 禁止双向模式下输出，使能单线双向数据模式
  SPICRCPR        = (u8)( cSpiCrcPolynomial);             // 置ＳＰＩＣＲＣ多项式寄存器的数值
  SPIICR          = (u8)( ((0<<spiWUIE )|(0<<spiERRIE)|   // 禁止唤醒中断，禁止错误中断
                           (1<<spiRXIE )|                 // 使能接收中断
                           (0<<spiTXIE) ));               // 禁止发送中断
" I- Q4 P! a8 N' ^5 R#endif                                                    // “_USE_STM8_FWLIB_”
#else
& F: _; _/ g) p, X+ g$ r#error 错误：
6 Y$ [) e. A+ }: a* S% k1 I#endif                                                    // “PreMcuIs__......”
1 z$ ~  u# R6 Z( y& S6 E- G- C% W#endif                                                    // “PreCommSpiUse......SlaveMode”
/*------------------------------------------------------------------------------------------------
初始化各个标志位
: L2 U, d( ~2 W9 I' x  f7 g------------------------------------------------------------------------------------------------*/
- I9 f% J/ F1 v1 o& f  gbitSpi.Busy              =  CLEAR;                     // 清除“ＳＰＩ接口〖忙〗”标志
8 ], f9 t$ t5 G2 T- ^  gbitSpi.RxOk              =  CLEAR;                     // 清除“接收数据缓冲区己更新”标志
' J9 x5 ]8 P) q; M1 _! l* W  gbitSpi.RxOvf             =  CLEAR;                     // 清除“接收数据缓冲区溢出”标志
8 h3 p- S, _) ^: S5 T5 O  gbitSpi.Error             =  CLEAR;                     // 清除“通讯收发作业发生错误”标志
& o! ^9 ?6 c) ^4 x: b6 H  gbitSpi.Txd               =  CLEAR;                     // 清除“正在进行发送数据作业”标志
3 S  G: E! b5 j, x  gbitSpi.TxRdy             =  CLEAR;                     // 清除“发送数据作业准备结束标志”标志
$ h; ~  Q8 r0 K6 I  gbitSpi.OverS             =  CLEAR;                     // 清除“通讯任务时间超时”标志
  gbitSpi.SpiOk             =  CLEAR;                     // 清除“占用ＳＰＩ接口”标志
* }6 e7 w) V" ^. H
  // 初始化ＳＰＩ接口通讯收发数据处理变量
  MemClearSram(pSpi, sizeof(CommSpiDataStru));
# f) H; f' Y. O' L* D/ I. I( d}

$ a7 J- W$ I+ o/*==========================================================================================================
( A* z. ~: l$ S0 r4 ~# ^, M4 L2 a  G函数名称：　　ＳＰＩ接口工作于单主机方式，使用中断进行接收和发送数据的中断服务程序。
函数功能：　　本函数用于ＳＰＩ接口工作于单主机方式，使用中断进行接收和发送数据的中断服务程序。
" e* F$ N3 t) O# j函数入口参数：gbitSpi.Rxd ------------- “正在进行接收数据作业”标志。
　　　　　　　gstvSpi.TxSize ---------- 每次发送数据个数大小变量。
　　　　　　　gstvSpi.TxCnt ----------- 每次发送数据个数计数器变量。
4 W2 |1 u4 w2 N7 x, J* J2 g$ A" ]　　　　　　　gstvSpi.TxBuf[] --------- 每次发送数据缓冲区数组变量。
# O+ _# S! j: L/ Y              gstvSpi.RxSize ---------- 每次接收数据个数大小变量。
函数返回值：　没有
( k7 T) z8 U2 _! J. s函数出口参数：gbitSpi.Busy ------------ ＳＰＩ接口〖忙〗，出口值＝清位（可能）。
1 K: u4 ?! b! S* M! r7 f              gbitSpi.Error ----------- 通讯收发作业发生错误，出口值＝置位（可能）。
: T. X* h6 ?/ b% @1 F3 ]　　　　　　　gstvSpi.TxCnt ----------- 每次发送数据个数计数器变量，出口值＝gstvSpi.TxCnt。
' q7 z1 Y  D% F/ w  Y! ~5 I              gstvSpi.RxCnt ----------- 每次接收数据个数计数器变量，出口值＝gstvSpi.RxSize。
0 {! I2 k: a( D0 Q+ u              gstvSpi.RxBuf[] --------- 每次接收数据缓冲区变量，出口值＝从ＳＰＩ接口上接收到的数据。
3 t/ N7 q5 e. j% }: E调用函数：　　１．
备注：        １．注意：本函数需在ＳＰＩ接口中断请求的中断向量函数中调用。
, D0 z7 z& I# J' L3 e$ C                  　　　在调用之前需对该中断向量进行初始化，使能该中断。
　　　　　　　２．全部完成通讯收发作业后，本函数将禁止ＳＰＩ接口中断。
==========================================================================================================*/
#if   (   defined(_IAR_EW_AVR_)   \
       || defined(_IAR_EW_STM8_)  )
#pragma vector = int_SPI_vector
; i+ Z! C! p1 Z6 Q" [7 eINTERRUPT_KEY void  CommSpi_isr (void)
, _: _" H. ~  q#elif (defined(_KEIL_UV_MCS51_) )
void  CommSpi_isr (void) INTERRUPT_KEY int_SPI_vector using 0
#elif (   defined(_COSMIC_STM8_)  )
1 a6 i: d+ E8 c& IINTERRUPT_KEY void  CommSpi_isr (void)
#else
void CommSpiIsr(void);
& A8 q& N/ |5 [" ?" v1 F#endif                                                    // “_IAR_EW_......”
#if   (defined(_IAR_EW_AVR_))

#elif ((defined(_IAR_EW_MCS51_)) || (defined(_KEIL_UV_MCS51_)))
' V1 ]6 M& e, M- f' \/ {
8 L* m# y4 ^$ ]% K#elif (   defined(_IAR_EW_STM8_) \
       || defined(_COSMIC_STM8_) )                        // “......_STM8 编译器”条件编译开始
7 I/ y/ V# f3 r2 V{
1 F6 G# t5 l' c' a9 ]* s#if ((cSpiTxBufSize < 256) && (cSpiRxBufSize < 256))
! f0 K1 v9 x0 s4 k3 H- x  register unsigned char    cnt;                          // ＵＳＡＲＴ每次发送数据个数计数器变量
#else
  register unsigned int     cnt;
#endif
  CommSpiDataStru           *pSpi;                        // 指向ＳＰＩ接口通讯收发数据处理变量的指针

' b& w7 a5 I& h  if (MFHSpiIntErrChk( ))                                 // 检查ＳＰＩ接口是否存在错误？
# ?4 O. [2 ?% d$ s8 ~* K  {
    MFHSpiModSpiOff( );                                   // 禁止ＳＰＩ接口模块
: W& x9 x% X8 O/ T& s; v( V; u    MFHSpiIntAllClr( );                                   // 进入中断后，在中断句柄中，清０ＳＰＩ接口全部中断标志位（在中断服务程序中）
    MFHSpiIntAllOff( );                                   // 禁止ＳＰＩ接口事件全部中断
    gbitSpi.Error           =  SET;                       // 置“通讯收发作业发生错误”标志
3 |. A5 s* k2 W" y, l8 v& @! A) q  }
  else                                                    // ＳＰＩ接口没有错误
* f  R1 t: h3 B* e  {
) G% C: E% U/ {* C: \    pSpi                    = &gstvSpi;                   // 取ＳＰＩ接口通讯收发数据处理变量的首个地址
    if (gbitSpi.Txd == SET)                               // ＳＰＩ接口是否正在进行发送数据作业？
    {
( [6 q5 |# g0 `2 x( z4 s1 @6 L      cnt                   =  pSpi->TxCnt;               // 取ＳＰＩ接口每次发送数据个数计数器变量
      if (cnt >= pSpi->TxSize)                            // 检查是否己完成发送通讯任务的全部数据？
      {
, |- \2 D( h5 Z/ X% N+ M        // 不能在中断中等待，直至发送通讯作业全部完成后，才可以禁止ＳＰＩ接口模块
, ^5 J, x: g+ i+ ^3 O: c        gbitSpi.TxRdy       =  SET;                       // 置“发送数据作业准备结束标志”标志
, k2 b9 r7 {, |; T1 ^1 |7 |6 [3 N  e        MFHSpiIntAllClr( );                               // 进入中断后，在中断句柄中，清０ＳＰＩ接口全部中断标志位（在中断服务程序中）
        MFHSpiIntAllOff( );                               // 禁止ＳＰＩ接口事件全部中断
/ P4 B7 J% c$ Y+ ~  W- C) P3 u      }
      else
4 f$ p' L, C7 k- [+ d4 L. v* h      {
        SPIDR               =  pSpi->TxBuf[cnt];          // 从发送缓冲区中将发送数据写入到ＳＰＩ接口
        cnt++;                                            // ＳＰＩ接口每次发送数据个数计数器＋１
/ C  l" z- c0 i6 G# n0 g0 c: z        pSpi->TxCnt         =  cnt;                       // 返回ＳＰＩ接口每次发送数据个数计数器值
        MFHSpiIntAllClr( );                               // 进入中断后，在中断句柄中，清０ＳＰＩ接口全部中断标志位（在中断服务程序中）
9 q3 M+ a+ j& C9 |/ w+ Q2 a" {9 H      }
8 o  V  H" Z2 w/ Q! N    }
, s5 c7 y5 I8 R6 K8 x$ B    else
    {
      cnt                   =  pSpi->RxCnt;               // 取ＳＰＩ接口每次接收数据个数计数器变量
; u5 \. @! Q8 {) }. V      pSpi->RxBuf[cnt]      =  SPIDR;                     // 复制ＳＰＩ接口读取到的字节到接收数据缓冲区中
; x1 K2 G, _  X      cnt++;                                              // ＳＰＩ接口每次接收数据个数计数器＋１
      pSpi->RxCnt           =  cnt;                       // 返回ＳＰＩ接口每次接收数据个数计数器值
      MFHSpiIntAllClr( );                                 // 进入中断后，在中断句柄中，清０ＳＰＩ接口全部中断标志位（在中断服务程序中）
      if      (cnt >= pSpi->RxSize)                       // 检查是否完成需要读取的数据长度？
      {
2 }" Q1 t& N  u& z2 C$ F. i7 D/ |        MFHSpiModSpiOff( );                               // 禁止ＳＰＩ接口模块
        MFHSpiIntAllOff( );                               // 禁止ＳＰＩ接口事件全部中断
; s' m5 V& M* z5 {) l* }% I9 z        gbitSpi.Busy        =  CLEAR;                     // 清除“ＳＰＩ接口〖忙〗”标志
1 |4 q7 D! d) C2 W8 x& @9 o        gbitSpi.OverS       =  CLEAR;                     // 清除“通讯任务时间超时”标志
      }
    }
+ a* X5 n& F/ Z6 O2 N/ X( b  }
- G7 H2 d) ]2 h/ f# `9 r
- U, B4 b# z# t( V! f9 m( }9 I. ~: E  INTERRUPT_RETURN( );
$ Z- {1 H. v! U( t6 s7 R$ o}
#else
#error 错误：
. Y$ _; q% J/ J#endif                                                    // “PreMcuIs__......”

* ~3 o/ `5 l5 e* `
/*==========================================================================================================
函数功能：    本函数是用于ＳＰＩ接口工作于单主机方式，在ＳＰＩ接口的前一次通讯收发作业发生
' C4 L8 R5 r  n$ d6 v              失败时的处理操作函数。
§．本函数将在函数体中隐式调用下面这些相当于入口参数的全局变量和局部静态变量：
入口静态变量：sign：TRANS_ERROR --------------- ＳＰＩ接口通讯收发作业发生错误标志变量。
" O8 w2 V( Y; a: O+ R              gstvSpi0.Cycle ----------------- ＳＰＩ接口的重新启动通讯收发作业发生错误次
                                                数值变量。
§．本函数将在函数体中隐式修改下面这些相当于出口参数的全局变量和局部静态变量：
# g1 u! G, B' A7 x出口全局变量：sys_error_type：SYS_ERROR_TYPE_IS_GENERAL ----- 【普通】错误类型的位操作值
0 E& I9 }6 W( m9 n                                                标志，出口值＝置位（仅在重新启动收发作业
/ i  o; F9 S5 x3 E1 |! A% g( M                                                错误次数大于最大值时，才会置此变量值）。
' `/ @' R  j" y5 @              sys_error_value ----------------- 系统运行中产生各种错误类型的错误代码数值变量
                                                ，出口值＝SYS_ERROR_COMM_I2CBUS（仅在重新启动
                                                收发作业错误次数大于最大值时，才会置此变量值）。
出口静态变量：sign：TRANS_ERROR --------------- ＳＰＩ接口通讯收发作业发生错误标志，出口值＝
  Q0 V( I. c$ t4 Z% U$ A# w                                                清位。
              gstvSpi0.Cycle ----------------- ＳＰＩ接口的重新启动通讯收发作业发生错误次
) N8 t- ?4 }' j# ^0 \3 \- U                                                数值变量，出口值＝不确定。
              gstvSpi0.ErrNum ------------------- ＳＰＩ接口的通讯收发作业发生错误次数值变量，
0 I' a- O, ~( r* L1 j% @1 r6 F                                                出口值＝ ０。
5 ]7 N' J- ~8 W6 l调用内部函数：①．unsigned char CommSpiBusBusy(void)
                  （检查ＳＰＩ接口的总线状态函数）。
              ②．unsigned char I2C_Get_State_Info(void)
                  （读取ＳＰＩ接口前一个操作的总线状态信息函数）。
              ③．void CommSpiBusAgain(void)
( z5 q. h- }1 [                  （重新启动ＳＰＩ接口前一个通讯收发作业操作函数）。
备注：        ▲．注意：本函数为消息任务队列函数，要在主函数中不间断循环调用运行。
* u! L* _- }* b& S+ Z' b==========================================================================================================*/
#endif                                                    // “ＳＰＩ接口工作于单主机方式”条件编译结束
1 j8 p4 X' X+ \

2 x9 N+ d: q7 n# W. l2 E- c& |#if defined(PreCommSpiUseSingleSlaveMode) || defined(PreCommSpiUseMultiSlaveMode)
                                                          // “ＳＰＩ接口工作于从机方式”的条件编译

9 h% ]5 v6 u' T: c; \$ W! `+ ]#endif                                                    // “ＳＰＩ接口工作于从机方式”条件编译结束

/*==========================================================================================================
函数名称：　　设置“占用ＳＰＩ接口”标志
' G/ e" x7 ~, Y4 z函数功能：　　本函数用于设置“占用ＳＰＩ接口”标志的函数。
, o9 l  g2 I0 A- r7 p; v函数入口参数：没有
: S2 N! B' h$ N/ U函数返回值：　没有
/ o! d# F* e+ o6 {' o调用函数：　　１．
/ _5 Q9 Z) P8 t* h( f备注：        １．
: {0 A- S3 Q0 R  C, i$ ?  u+ _==========================================================================================================*/
- Q5 p7 V  U- k) \7 s7 I7 e" i9 C+ \void  CommSpiSetSpiOk (void)
" [7 U+ w. m6 A% \8 S: n{
: g! U5 @; R; c7 [4 g9 }" q6 c  gbitSpi.SpiOk       =  SET;                             // 置“占用ＳＰＩ接口”标志
! F& p! s2 C, W  U8 |  gstvSpi.OverSpi     =  RtcGetSecByte(cSpiOverSpiOk);    // 启动占用ＳＰＩ接口计时秒表
}
8 n. P- O5 X4 V; P( N
# H6 U4 ~5 c( M5 a, b. W) z/*==========================================================================================================
0 \$ L+ q6 |+ L2 F( |9 H函数名称：　　清除“占用ＳＰＩ接口”标志
函数功能：　　本函数用于清除“占用ＳＰＩ接口”标志的函数。
函数入口参数：没有
函数返回值：　没有
* C7 M) d1 w" q2 m调用函数：　　１．
# f" q* F; e6 ^3 Z; W, e# G备注：        １．
$ v( C: V2 k1 Y) C8 |==========================================================================================================*/
void  CommSpiClrSpiOk (void)
{
  gbitSpi.SpiOk       =  CLEAR;                           // 清除“占用ＳＰＩ接口”标志
2 K# ^  E8 ?; m7 ]; L9 H  gstvSpi.StepSpi     =  0;                               // ＳＰＩ接口操作步骤指向第一步
* z$ n2 `+ J& E% w}

$ ?& F4 F$ L& {( {' v/*==========================================================================================================
: h& f8 J% f' O函数功能：    本函数是ＳＰＩ接口通信接收和发送作业不间断循环调用运行函数。
备注：        ▲．注意：本函数为消息任务队列函数，要在主函数中不间断循环调用运行。
              ▲．当ＳＰＩ接口工作于从机方式时，ＳＰＩ接口中断总是处于使能状态，以便
                  ＳＰＩ接口处于随时接收数据状态。
& R% a- q& e: M- c9 z8 x3 X==========================================================================================================*/
void  CommSpiCircleFunc (void)
: F8 p4 D3 d/ k) Y; e3 h! W% ?% i{
#ifdef DEBUG
  unsigned char i;                           // 循环计数器变量
  unsigned char j;
( |% h7 X7 E7 A/ x  unsigned char hex_data[2];
' ]- X6 I8 ~7 _+ x8 j  unsigned char *ptr;
6 f7 y0 P& i/ N#endif
: M! T, l* W# h$ k3 G) T' V% z4 j  unsigned char              i;                           // 循环计数器变量
3 Q5 x3 b$ w9 y0 H0 [: Z  CommSpiDataStru           *pSpi;                        // 指向ＳＰＩ接口通讯收发数据处理变量的指针
6 ?, |* s# e2 X9 C
  pSpi                      = &gstvSpi;                   // 取ＳＰＩ接口通讯收发数据处理变量的首个地址
9 j* }9 H, ]3 a6 r#ifdef PreCommSpiUseSingleMasterMode                      // “ＳＰＩ接口工作于单主机方式”的条件编译
  if (   (gbitSpi.Error == SET)                           // 如果ＳＰＩ接口通讯收发作业发生错误，
      && ( ! CommSpiBusBusy( )) )                         // 且ＳＰＩ接口收发器处于空闲状态？
  {
1 S0 `, k6 y0 }* J    if (pSpi->Cycle > cSpiErrorMax)                       // 检查重新启动收发作业错误次数是否大于最大值？
* n0 |$ A9 g# I* C    {
      pSpi->Cycle           =  0x00;                      // ＳＰＩ接口的重新启动收发作业发生错误次数清０
      gbitSpi.Error         =  CLEAR;                     // 清除“通讯收发作业发生错误”标志
7 l- c0 p4 w9 O! p      gbitSpi.Busy          =  CLEAR;                     // 清除“ＳＰＩ接口〖忙〗”标志
#ifdef _SYSTEM_ERROR_MANAGE_H_
      sys_error_type       |=  SYS_ERROR_TYPE_IS_GENERAL; // 置【普通】错误类型消息任务标志位
2 @3 D# P0 b0 H4 R1 C( [4 A6 h      sys_error_value       =  SYS_ERROR_COMM_SPIBUS    ; // 置“ＳＰＩ接口通信收发作业”错误代码值
#endif
    }
" c" _. j9 }, R8 B' a5 r, y/ Z3 T    else
' K( C) `' u1 e" l* m( l' ^, G    {
      pSpi->Cycle++;                                      // ＳＰＩ接口的重新启动收发作业发生错误次数值＋１
      gbitSpi.Error         =  CLEAR;                     // 清除“通讯收发作业发生错误”标志
$ p. v, c/ Z2 P  l, w6 L8 {      CommSpiBusAgain( );                                 // 重新启动ＳＰＩ接口前一个通讯收发作业操作
    }
  }
  // 等待，直至发送通讯作业全部完成处理后，才可以禁止ＳＰＩ接口模块
  if (   (gbitSpi.TxRdy == SET)                           // 如果ＳＰＩ接口发送数据作业准备结束标志，
  L& p& H& r5 Z$ c      && ( ! CommSpiBusBusy( )) )                         // 且ＳＰＩ接口收发器处于空闲状态？
  {
0 N/ ~& N8 U& @    MFHSpiModSpiOff( );                                   // 禁止ＳＰＩ接口模块
    MFHSpiFlgAllClr( );                                   // 清０ＳＰＩ接口全部中断标志位
- ?# m* W+ J: t1 w8 f    MFHSpiIntAllOff( );                                   // 禁止ＳＰＩ接口事件全部中断
    gbitSpi.Busy            =  CLEAR;                     // 清除“ＳＰＩ接口〖忙〗”标志
" x5 `5 ]$ `: c) B    gbitSpi.OverS           =  CLEAR;                     // 清除“通讯任务时间超时”标志
% a# g; N8 x2 S; j/ p    gbitSpi.TxRdy           =  CLEAR;                     // 清除“发送数据作业准备结束标志”标志
! u4 w% P. P2 d: F    MFH_PIN_CFG_INHZ_SpiMosi;                             // 设置ＳＰＩ主出/ 从入引脚为输入引脚，并为高阻输入态
  }
/ K: D5 V9 |" M& W& e3 ^7 {4 m  // 通讯任务时间超时计时处理，用以处理ＳＰＩ接口直处于“BUSY”状态。
/ I( }/ {- ~) c/ E2 p7 h  }  if (gbitSpi.OverS == SET)
  {
    if (RtcSecByteOverflow(pSpi->OverS))                  // 如果通讯任务时间计时秒表时间已溢出？
' M2 D# I. q; r/ b" c2 G6 C    {
      MFHSpiModClkOff( );                                 // 禁止ＳＰＩ接口模块外设时钟
& U9 w1 ?- A. g  U+ o) e& j* s- R      DelayUs(10);
0 `" d( \( b& l      MFHSpiModClkOnn( );                                 // 使能ＳＰＩ接口模块外设时钟
      DelayUs(10);
5 \! L/ P5 U# L1 {* R4 W      CommSpiInit( );                                     // 重新初始化ＳＰＩ接口
2 A! l0 S% z% Z& S! s% ~& f    }
  }
  // 占用ＳＰＩ接口超时计时处理，用以处理分时占用ＳＰＩ接口。
( Q7 T/ ~# d  H  if (gbitSpi.SpiOk == SET)
  {
    if (RtcSecByteOverflow(pSpi->OverSpi))                // 如果通讯任务时间计时秒表时间已溢出？
: Q  w( F4 _4 r3 |/ Q# V    {
% L- @% g" W( n" c* B      gbitSpi.SpiOk         =  CLEAR;                     // 清除“占用ＳＰＩ接口”标志
5 C, h# g6 l! q; k; @) K: R      gstvSpi.StepSpi       =  0;                         // ＳＰＩ接口操作步骤指向第一步
    }
* o# g; g1 u% U. c* P+ k  }
% R. e$ z; a9 Y) N" Z2 v#endif                                                    // “PreCommSpiUseSingleMasterMode”
6 n8 S( g1 v3 N1 f8 z) _( K
#if defined(PreCommSpiUseSingleSlaveMode) || defined(PreCommSpiUseMultiSlaveMode)
                                                          // “ＳＰＩ接口工作于从机方式”的条件编译
- |! N# `* V6 B6 R5 l& h0 c
% p" S, Q- ?) `$ R- {( x#endif                                                    // “PreCommSpiUse......SlaveMode”
}



) c' c1 a% _) F8 V# Q8 _! B8 h6 `#ifdef __cplusplus
  G, S2 t  r$ B8 [- f( \3 P8 K}                                                         // extern "C" 链接指示符作用域结束
- e0 q' f) p. `& H3 Z' T2 f#endif

, N8 h, b" V# h( f! I- U7 b
/*
( h$ ^, z1 Y% }. O& m0 E# R/ E' A$ j2 j8 J************************************************************************************************************
　　　　　　　　　　　　　　　　　　　　 本Ｃ语言源程序文件到此结束
************************************************************************************************************
* w5 O1 i/ a$ N# K/ e0 M2 c*/

3 c8 y7 b# U7 h  w- K5 l* m8 G0 j/*
************************************************************************************************************
版权所有 (C)，2010－2012，磊元科技有限公司
4 U0 g$ y& t! V/ W: `7 p. q--------------------------------------------------------------------------------------------------
源程序文件名：　　　CommSpi.c
$ ?4 J: t( N- Q( c源程序名称：　　　　串行外设接口（ＳＰＩ接口）的源程序文件
程序版本：　　      1.0
程序功能：
　　　　本文件是串行外设接口（ＳＰＩ接口）使用中断方式接收和发送数据通信的源程序文件。
程序说明：
; v0 y7 d, g5 W. U; ~　　　　１．注意：使用源程序的ＳＰＩ接口接收和发送数据的函数之前，必须使能全局中断。
　　　　２．注意：本文件仅实现１条时钟线（SCK）和１条双向数据线（MOSI）的单工通信方式。

主要函数列表：　　　
　　　　▲．在主函数中运行的函数：
0 ]0 Q: Y. c0 |/ K( s　　　　　　１．void Drv74595Init(void)
                （串行输出端口初始化）
& e2 H- b8 ^0 N4 _; ^　　　　▲．芯片７４ＨＣ５９５输出驱动函数：
2 v: I# T6 n* p# q. X　　　　　　１．void Drv74595Drive(const unsigned char *pParallel)
$ t* E2 u, U6 P% n                （串入并出芯片７４ＨＣ５９５输出驱动）
　　　　　　２．void Drv74595Single(unsigned char Parallel, unsigned char Series)
                （串入并出芯片７４ＨＣ５９５单个驱动）

链接子程序文件：　　
　　　　１．

编译工具软件：      IAR Embedded Workbench for Atmel AVR 版本：5.20A 以上
; v7 N' c& v! k( Z, ^
编作者：            磊元
编制日期：          2009年4月8日
--------------------------------------------------------------------------------------------------
* B/ _4 [7 H$ \# D8 v! o' J3 O适用器件芯片类型：  ATmega 系列（ Atmel 公司生产的 8 位 RISC 单片机）
器件芯片时钟频率：  任意
存储器模式：        大存储器模式
- U. ?/ H& D; K; O) i8 N外部扩展存储器大小：0【字节】
调用堆栈大小：      6 【字节】
# n3 g) Q+ x7 |% m4 J8 D3 w数据堆栈大小：      4 【字节】
--------------------------------------------------------------------------------------------------
源程序版本历史：
2 }3 V4 a# P  p* T% f2006年07月26日  〖磊元〗 -------- 版本 1.0 ：原始版本（AVR）
2015年09月20日  〖磊元〗 -------- 版本 2.0 ：扩增版本（STM8S）
************************************************************************************************************
3 Z$ ~8 F! c5 _* g2 I3 Z*/

0 \  d% I* x5 O1 o% s( {/*==========================================================================================================
7 {$ O  U: {8 ?' L% a5 u　　　　　　　　　　　　　　　　　　　　　　　　调试开关声明
==========================================================================================================*/
//#define DEBUG
. P" p, u0 H" b

/*==========================================================================================================
　　　　　　　　　　　　　　　　　　　　　　本源程序包括的头文件
建议：包含本项目的文件使用 #include "文件名.扩展名" ，
　　　包含系统库的文件使用 #include <文件名.扩展名> 。
1 w+ z- ?; n+ G7 e/ E9 q* z- U$ s==========================================================================================================*/
#include "CommSpi.h"                                      // 本源程序的头文件
* z4 V( [, x) u8 {5 }' a#include "DataMath.h"                                     // 算术运算及数制转换等数学算法的头文件
#include "RtcTimer.h"                                     // 应用内部定时器计时的实时时钟的头文件

#ifdef __cplusplus
extern "C" {                                              // 声明接在下面的指令为Ｃ程序编译系统
, j4 c( C5 A/ p; _: T* F#endif
# I& v( Y7 u9 d) [9 M' N; Z, ]6 M/ ^
) W3 b; J6 B' u8 C, C
5 K. z8 c' @* d2 W7 F& ?2 F
/*==========================================================================================================
* }1 x1 E$ M) w( i2 V　　　　　　　　　　　　　　　　　　　　　　　　全局常量定义
==========================================================================================================*/
$ z. v; }, s- V% K% J3 A#if   (defined(_IAR_EW_AVR_))
1 `$ n1 t% D# m/ R& x) d/ Y, [% X1 v* ?
#elif ((defined(_IAR_EW_MCS51_)) || (defined(_KEIL_UV_MCS51_)))
; j0 Q2 u# y! T# W( R
: c' \* ~8 v2 s7 w5 j3 w5 R8 `* {# d#elif (   defined(_IAR_EW_STM8_) \
       || defined(_COSMIC_STM8_) )                        // “......_STM8 编译器”条件编译开始
2 m$ e! Z6 n$ ^! ^' k#ifdef _USE_STM8_FWLIB_                                   // “使用 STM8 FWLib 的库文件”条件编译开始

2 Z/ e  H- O/ V& P4 M#else                                                     // “_USE_STM8_FWLIB_”
  F$ ]5 k: l2 T) s5 m1 a
#endif                                                    // “_USE_STM8_FWLIB_”
6 \+ q4 H1 Y& D  I: o( p#else
0 q2 P) J$ X/ q& Q7 k; d! f#error 错误：
#endif                                                    // “PreMcuIs__......”
# M7 B; T, N7 }3 O* }% @" P6 V; ~

/*==========================================================================================================
　　　　　　　　　　　　　　　　　　　　　　　　全局变量定义
==========================================================================================================*/
/*------------------------------------------------------------------------------------------------
- V$ @- E+ H* k" L- s% F$ D" sＳＰＩ接口通讯处理消息任务标志的全局变量定义：
------------------------------------------------------------------------------------------------*/
bdata CommSpi0FlagBits      gbitSpi0;
7 u% w  @) P% V3 S& _3 u
/*------------------------------------------------------------------------------------------------
ＳＰＩ接口通讯收发数据处理的全局变量定义：
1 W/ ]& u' `5 S4 I; _------------------------------------------------------------------------------------------------*/
( P1 Z* A3 N8 C% ~: g" ]xdata CommSpi0DataStru      gstvSpi0;
0 e6 D# G+ D  I
9 Y9 w( c7 g4 h3 }% m
/ r% ~3 g: x: p" I  T: @3 h& ]. g8 e
/*==========================================================================================================
　　　　　　　　　　　　　　　　　　本源程序文件内部使用的字符化常数定义
- a) y" Z+ L6 b) P7 U& H9 q==========================================================================================================*/
#if   defined(PreCommSpiMultipleSpiEnable0)               // “使用ＳＰＩ接口０”条件编译开始
" m" g; o: w! u8 x6 M0 V1 _4 c#define cDdrSpiMosi           cDdrSpi0Mosi
#define cPurSpiMosi           cPurSpi0Mosi
#define cCirSpiMosi           cCirSpi0Mosi
#define cOdrSpiMosi           cOdrSpi0Mosi
4 k  f! r0 Q; T' s9 U. o% N' u#define cIdrSpiMosi           cIdrSpi0Mosi
#define cPidSpiMosi           cPidSpi0Mosi
#define cPodSpiMosi           cPodSpi0Mosi
5 t/ l: J9 ]5 W$ Y#define cBitSpiMosi           cBitSpi0Mosi
. ?) Y# u8 a" y#define cDdrSpiMiso           cDdrSpi0Miso
2 y- u, y" ^" v: K- d. G#define cPurSpiMiso           cPurSpi0Miso
+ o% k- G' f% k#define cCirSpiMiso           cCirSpi0Miso
1 q. i2 f5 E) Y! \0 S#define cOdrSpiMiso           cOdrSpi0Miso
$ t; g; F9 h7 C$ C: h2 L4 v9 w#define cIdrSpiMiso           cIdrSpi0Miso
#define cPidSpiMiso           cPidSpi0Miso
% J3 t; |, U8 K; T% e9 O. u; t#define cPodSpiMiso           cPodSpi0Miso
#define cBitSpiMiso           cBitSpi0Miso
#define cDdrSpiSclk           cDdrSpi0Sclk
8 F" a& {: O) P+ h1 o#define cPurSpiSclk           cPurSpi0Sclk
6 `' F) Z& H- v# ^: G#define cCirSpiSclk           cCirSpi0Sclk
+ K8 x6 W# R4 K1 g4 A; ^( p#define cOdrSpiSclk           cOdrSpi0Sclk
4 `3 y4 l0 G3 c& j0 w; D; [' U0 c1 ]#define cIdrSpiSclk           cIdrSpi0Sclk
#define cPidSpiSclk           cPidSpi0Sclk
#define cPodSpiSclk           cPodSpi0Sclk
( y6 I; O7 z. c) F9 {% P' h#define cBitSpiSclk           cBitSpi0Sclk
#define cSpiRxBufSize         cSpi0RxBufSize
#define cSpiTxBufSize         cSpi0TxBufSize
% {8 h6 k% S7 Q* T# ^#define CommSpiDataStru       CommSpi0DataStru
#define cSpiAddrNum           cSpi0AddrNum
#define gbitSpi               gbitSpi0
0 g" @3 a; ?8 y" p% C' N' n! E+ ^#define gstvSpi               gstvSpi0
! d; c% e0 O. M1 N% P#define gucvSpiEvent          gucvSpi0Event
#elif defined(PreCommSpiMultipleSpiEnableS)               // “使用ＳＰＩ接口ｓ”条件编译开始
2 k* G6 D% I! u
#endif                                                    // “使用ＳＰＩ接口......”

# c( m- _" z+ t& n5 \# \, _

9 a' Q5 T& ^' o$ U/*==========================================================================================================
1 y# ]9 L+ G; y& }4 }) Y5 k1 B- ?　　　　　　　　　　　　　　　　　 本源程序文件内部使用的数据结构类型定义
$ \1 z# k9 l* Y- ^9 W7 `==========================================================================================================*/
- k# E, f/ B: g

$ {" v( D% r6 P2 w
/*==========================================================================================================
　　　　　　　　　　　　　　　　　　 本源程序文件内部使用的局部常量定义
==========================================================================================================*/
& N# L2 P& W  X9 T( [

2 v% I+ W2 \0 T- Q9 b/ U5 K. u
0 K" B2 J# O* e% |9 Z, [/*==========================================================================================================
　　　　　　　　　　　　　　　　　　 本源程序文件内部使用的局部变量定义
8 M; t' S6 H3 p" a==========================================================================================================*/
0 \' m3 F% ^/ [/ g; b" H
8 F. c$ F7 C+ x5 e

- G. s/ w( N9 m+ U6 v* S- S/*==========================================================================================================
　　　　　　　　　　　　　　　　　　 本源程序文件内部使用的函数原型声明
==========================================================================================================*/
static void CommSpiBusAgain(void);


! z) }3 o) N6 s" [% x9 P9 C( G
/*==========================================================================================================
. I# G  l' }) @! [( I2 h3 Q　　　　　　　　　　　　　　　　 本源程序文件内部使用的一些操作指令的宏定义
==========================================================================================================*/
/*------------------------------------------------------------------------------------------------
输入／输出端口和引脚宏定义：（注：下列这些定义用以简化宏函数参数字符。）
------------------------------------------------------------------------------------------------*/
! r8 H2 ?9 d+ ?' a( `" O#define MFH_PIN_CFG_INPU_SpiMosi                          MFH_PIN_CFG_INPU(cDdrSpiMosi, cPurSpiMosi, cCirSpiMosi, cOdrSpiMosi, cIdrSpiMosi, cBitSpiMosi)
. f# C, f6 P3 {$ N: k! q' u9 J#define MFH_PIN_CFG_INHZ_SpiMosi                          MFH_PIN_CFG_INHZ(cDdrSpiMosi, cPurSpiMosi, cCirSpiMosi, cOdrSpiMosi, cIdrSpiMosi, cBitSpiMosi)
#define MFH_PIN_CFG_OOUT_SpiMosi                          MFH_PIN_CFG_OOUT(cDdrSpiMosi, cPurSpiMosi, cCirSpiMosi, cOdrSpiMosi, cIdrSpiMosi, cBitSpiMosi)
#define MFH_PIN_CFG_OUTH_SpiMosi                          MFH_PIN_CFG_OUTH(cDdrSpiMosi, cPurSpiMosi, cCirSpiMosi, cOdrSpiMosi, cIdrSpiMosi, cBitSpiMosi)
#define MFH_PIN_CFG_OUTL_SpiMosi                          MFH_PIN_CFG_OUTL(cDdrSpiMosi, cPurSpiMosi, cCirSpiMosi, cOdrSpiMosi, cIdrSpiMosi, cBitSpiMosi)
#define MFH_PIN_OUT_SETH_SpiMosi                          MFH_PIN_OUT_SETH(cDdrSpiMosi, cPurSpiMosi, cCirSpiMosi, cOdrSpiMosi, cIdrSpiMosi, cBitSpiMosi)
7 E5 U0 u7 D' v, C/ r9 x) s. [#define MFH_PIN_OUT_CLRL_SpiMosi                          MFH_PIN_OUT_CLRL(cDdrSpiMosi, cPurSpiMosi, cCirSpiMosi, cOdrSpiMosi, cIdrSpiMosi, cBitSpiMosi)
#define MFH_PIN_IN_STATE_SpiMosi                          MFH_PIN_IN_STATE(cDdrSpiMosi, cPurSpiMosi, cCirSpiMosi, cOdrSpiMosi, cIdrSpiMosi, cBitSpiMosi)
7 s5 j" K3 O5 C9 _: `8 W5 q
2 q6 v& x, s6 |# `. w9 K#define MFH_PIN_CFG_INPU_SpiMiso                          MFH_PIN_CFG_INPU(cDdrSpiMiso, cPurSpiMiso, cCirSpiMiso, cOdrSpiMiso, cIdrSpiMiso, cBitSpiMiso)
#define MFH_PIN_CFG_INHZ_SpiMiso                          MFH_PIN_CFG_INHZ(cDdrSpiMiso, cPurSpiMiso, cCirSpiMiso, cOdrSpiMiso, cIdrSpiMiso, cBitSpiMiso)
#define MFH_PIN_CFG_OOUT_SpiMiso                          MFH_PIN_CFG_OOUT(cDdrSpiMiso, cPurSpiMiso, cCirSpiMiso, cOdrSpiMiso, cIdrSpiMiso, cBitSpiMiso)
3 K  ~' H9 i+ H5 S1 u#define MFH_PIN_CFG_OUTH_SpiMiso                          MFH_PIN_CFG_OUTH(cDdrSpiMiso, cPurSpiMiso, cCirSpiMiso, cOdrSpiMiso, cIdrSpiMiso, cBitSpiMiso)
6 L& ~, X: W1 J" b3 O" M, e$ H; p7 e#define MFH_PIN_CFG_OUTL_SpiMiso                          MFH_PIN_CFG_OUTL(cDdrSpiMiso, cPurSpiMiso, cCirSpiMiso, cOdrSpiMiso, cIdrSpiMiso, cBitSpiMiso)
- @6 ]# K) \# x6 E; \% [& C#define MFH_PIN_OUT_SETH_SpiMiso                          MFH_PIN_OUT_SETH(cDdrSpiMiso, cPurSpiMiso, cCirSpiMiso, cOdrSpiMiso, cIdrSpiMiso, cBitSpiMiso)
7 ]9 J3 \5 u9 s! s8 ]3 H#define MFH_PIN_OUT_CLRL_SpiMiso                          MFH_PIN_OUT_CLRL(cDdrSpiMiso, cPurSpiMiso, cCirSpiMiso, cOdrSpiMiso, cIdrSpiMiso, cBitSpiMiso)
1 [. q: \: N# S% p' X#define MFH_PIN_IN_STATE_SpiMiso                          MFH_PIN_IN_STATE(cDdrSpiMiso, cPurSpiMiso, cCirSpiMiso, cOdrSpiMiso, cIdrSpiMiso, cBitSpiMiso)

#define MFH_PIN_CFG_INPU_SpiSclk                          MFH_PIN_CFG_INPU(cDdrSpiSclk, cPurSpiSclk, cCirSpiSclk, cOdrSpiSclk, cIdrSpiSclk, cBitSpiSclk)
$ n" u! f) ~- y0 q#define MFH_PIN_CFG_INHZ_SpiSclk                          MFH_PIN_CFG_INHZ(cDdrSpiSclk, cPurSpiSclk, cCirSpiSclk, cOdrSpiSclk, cIdrSpiSclk, cBitSpiSclk)
#define MFH_PIN_CFG_OOUT_SpiSclk                          MFH_PIN_CFG_OOUT(cDdrSpiSclk, cPurSpiSclk, cCirSpiSclk, cOdrSpiSclk, cIdrSpiSclk, cBitSpiSclk)
0 h0 c& ~0 f5 P+ v4 A. N3 C$ ~$ _#define MFH_PIN_CFG_OUTH_SpiSclk                          MFH_PIN_CFG_OUTH(cDdrSpiSclk, cPurSpiSclk, cCirSpiSclk, cOdrSpiSclk, cIdrSpiSclk, cBitSpiSclk)
#define MFH_PIN_CFG_OUTL_SpiSclk                          MFH_PIN_CFG_OUTL(cDdrSpiSclk, cPurSpiSclk, cCirSpiSclk, cOdrSpiSclk, cIdrSpiSclk, cBitSpiSclk)
#define MFH_PIN_OUT_SETH_SpiSclk                          MFH_PIN_OUT_SETH(cDdrSpiSclk, cPurSpiSclk, cCirSpiSclk, cOdrSpiSclk, cIdrSpiSclk, cBitSpiSclk)
#define MFH_PIN_OUT_CLRL_SpiSclk                          MFH_PIN_OUT_CLRL(cDdrSpiSclk, cPurSpiSclk, cCirSpiSclk, cOdrSpiSclk, cIdrSpiSclk, cBitSpiSclk)
% R5 H( ?5 z+ G/ a2 U- [2 B#define MFH_PIN_IN_STATE_SpiSclk                          MFH_PIN_IN_STATE(cDdrSpiSclk, cPurSpiSclk, cCirSpiSclk, cOdrSpiSclk, cIdrSpiSclk, cBitSpiSclk)
5 f" v. x/ d: X' a- n' d1 s
9 u5 u5 Q" N; m! Z# o' M0 h#define MFH_PIN_CFG_INPU_Ht1381Cs                         MFH_PIN_CFG_INPU(cDdrHt1381Cs, cPurHt1381Cs, cCirHt1381Cs, cOdrHt1381Cs, cIdrHt1381Cs, cBitHt1381Cs)
#define MFH_PIN_CFG_INHZ_Ht1381Cs                         MFH_PIN_CFG_INHZ(cDdrHt1381Cs, cPurHt1381Cs, cCirHt1381Cs, cOdrHt1381Cs, cIdrHt1381Cs, cBitHt1381Cs)
#define MFH_PIN_CFG_OOUT_Ht1381Cs                         MFH_PIN_CFG_OOUT(cDdrHt1381Cs, cPurHt1381Cs, cCirHt1381Cs, cOdrHt1381Cs, cIdrHt1381Cs, cBitHt1381Cs)
#define MFH_PIN_CFG_OUTH_Ht1381Cs                         MFH_PIN_CFG_OUTH(cDdrHt1381Cs, cPurHt1381Cs, cCirHt1381Cs, cOdrHt1381Cs, cIdrHt1381Cs, cBitHt1381Cs)
8 J% U9 M) _9 o9 ^' ]#define MFH_PIN_CFG_OUTL_Ht1381Cs                         MFH_PIN_CFG_OUTL(cDdrHt1381Cs, cPurHt1381Cs, cCirHt1381Cs, cOdrHt1381Cs, cIdrHt1381Cs, cBitHt1381Cs)
- y" O! \5 f* e! F1 M* N#define MFH_PIN_OUT_SETH_Ht1381Cs                         MFH_PIN_OUT_SETH(cDdrHt1381Cs, cPurHt1381Cs, cCirHt1381Cs, cOdrHt1381Cs, cIdrHt1381Cs, cBitHt1381Cs)
#define MFH_PIN_OUT_CLRL_Ht1381Cs                         MFH_PIN_OUT_CLRL(cDdrHt1381Cs, cPurHt1381Cs, cCirHt1381Cs, cOdrHt1381Cs, cIdrHt1381Cs, cBitHt1381Cs)
3 X8 I) \3 q$ |. i/ q' j#define MFH_PIN_IN_STATE_Ht1381Cs                         MFH_PIN_IN_STATE(cDdrHt1381Cs, cPurHt1381Cs, cCirHt1381Cs, cOdrHt1381Cs, cIdrHt1381Cs, cBitHt1381Cs)

/*==========================================================================================================
　　　　　　　　　　　　　　　　　　　　　全局变量数据结构类型定义
, U# Y+ p: N5 H  A==========================================================================================================*/
/*------------------------------------------------------------------------------------------------
9 @3 Q' u/ y: j& iＳＰＩ接口通讯处理消息任务标志的全局数据结构类型定义：
------------------------------------------------------------------------------------------------*/
#define CommSpi0FlagDefaults                              \
8 K' R) _5 j0 U, ]  N% \5 u+ l$ r* q$ ]                           {  CLEAR                      ,\
                              CLEAR                      ,\
                              CLEAR                      ,\
                              CLEAR                      ,\
                              CLEAR                      ,\
                              CLEAR                      ,\
                              CLEAR                      ,\
1 y+ x3 r2 u1 j: g; y* i  M+ e                              0  }                        // ＳＰＩ接口０消息任务标志变量的默认初始化值
' Y" S: d( a* z( S) U/ rtypedef struct
{
9 E, L3 t. r. k  unsigned char Busy        : 1;                          // ＳＰＩ接口〖忙〗
( @3 x. D! o2 j' H7 n# o9 L1 Y) o  unsigned char RxOk        : 1;                          // 接收数据缓冲区己更新
  unsigned char RxOvf       : 1;                          // 接收数据缓冲区溢出
  unsigned char Error       : 1;                          // 通讯收发作业发生错误
  unsigned char Txd         : 1;                          // 正在进行发送数据作业
  unsigned char TxRdy       : 1;                          // 发送数据作业准备结束标志
  unsigned char OverS       : 1;                          // 通讯任务时间超时
3 s9 g* ^4 C+ y  unsigned char SpiOk       : 1;                          // 占用ＳＰＩ接口（其他程序使用）
} CommSpi0FlagBits;
8 K8 ?# D7 @- c
& t9 Y1 v7 F$ i/*------------------------------------------------------------------------------------------------
% t7 `* A% t, j" }4 OＳＰＩ接口通讯收发数据处理的全局数据结构类型定义：
4 S- P! A, k/ \8 _' f0 b) [& V5 @------------------------------------------------------------------------------------------------*/
% T( Y& S+ e! {2 d& F+ i; i( ~, L6 h' T7 ltypedef struct
, ?* |5 g: q5 k5 Y{
7 l$ X# Z: u" h  unsigned char             TxSize                      ; // 每次发送数据个数大小
  unsigned char             TxCnt                       ; // 每次发送数据个数计数器
  unsigned char             TxBuf[cSpi0RxBufSize]       ; // 每次发送数据缓冲区

  unsigned char             RxSize                      ; // 每次接收数据个数大小
# v6 J. A  U1 M5 D% j$ ^  unsigned char             RxCnt                       ; // 每次接收数据个数计数器
  unsigned char             RxBuf[cSpi0TxBufSize]       ; // 每次接收数据缓冲区
& @. B7 \& k0 C/ _
. D; g% q8 T) y3 B$ g1 ^  unsigned char             OverS                       ; // 通讯任务时间超时的计时秒变量
  unsigned char             Cycle                       ; // 重新启动通讯收发作业圈数
1 X7 }: C+ O; r. y* r1 Z! _% f  unsigned char             OverSpi                     ; // 占用ＳＰＩ接口超时的计时秒变量（其他程序使用）
2 I/ r" ]# G  C! Q0 k  unsigned char             StepSpi                     ; // ＳＰＩ接口操作步骤（其他程序使用）
} CommSpi0DataStru;
, n/ q+ P1 }- g. H- l' s
: Z+ X* ?9 \' t+ J9 B# Q! Q
4 m( W7 L1 A! y& M' f0 {8 h
& w, J. b" K% e$ P7 s7 p  a0 K/*==========================================================================================================
　　　　　　　　　　　　　　　　　　　　　　　　全局常量声明
==========================================================================================================*/

, Y% @- |, j( {4 F8 C1 `

3 |& e/ Z( g6 T$ |5 }3 n+ G/*==========================================================================================================
1 s4 H% l) _0 O( ]8 F6 ?　　　　　　　　　　　　　　　　　　　　　　　　全局变量声明
==========================================================================================================*/
/*------------------------------------------------------------------------------------------------
ＳＰＩ接口通讯处理消息任务标志的全局变量声明：
------------------------------------------------------------------------------------------------*/
extern bdata CommSpi0FlagBits      gbitSpi0;
1 Q! _' W! f( K8 S' L" L
/*------------------------------------------------------------------------------------------------
ＳＰＩ接口通讯收发数据处理的全局变量声明：
------------------------------------------------------------------------------------------------*/
extern xdata CommSpi0DataStru      gstvSpi0;
7 @! i, J/ g) _8 s0 v
0 d0 G* U' K+ T1 r: i
! w( L* e  g! C9 o  M
/*==========================================================================================================
　　　　　　　　　　　　　　　　　　　　 源程序文件中的函数原型声明
==========================================================================================================*/
/*------------------------------------------------------------------------------------------------
3 o6 S% E, s% g4 u- w. e
; Y& f( w. J  X9 I* k+ W------------------------------------------------------------------------------------------------*/
void CommSpiInit(void);

! ^4 X1 d9 U8 j/ E2 l4 w/*------------------------------------------------------------------------------------------------
. p1 t9 `5 J$ n1 \函数名称：　　查询ＳＰＩ接口通讯发送数据作业工作状态
9 q2 t: p4 X' Y函数功能：　　本函数用于检查ＳＰＩ接口通讯发送数据作业工作状态的函数。
函数入口参数：没有
函数返回值：　ＳＰＩ接口收发器的工作状态，０（空闲状态）。
% }7 q& D4 B0 x/ }  u调用函数：　　１．
8 V' N- ]5 N6 R8 x# _0 j9 o备注：        １．
+ N( [+ `0 ?# E: s( m------------------------------------------------------------------------------------------------*/
! A, q/ `. g) F; yunsigned char CommSpiBusBusy(void);
0 A0 {5 E6 y  _3 r/ e. N0 b/ m6 X# k
8 d9 G7 @, b" u4 W7 w/*------------------------------------------------------------------------------------------------
函数名称：　　设置ＳＰＩ接口为标准／快速模式和占空比
函数功能：　　本函数用于设置ＳＰＩ接口为标准／快速模式和占空比操作的函数。
% o) S, E- A5 R1 P- h函数入口参数：Model ----------------- 标准／快速模式和占空比， ON（快速模式）／ OFF（标准模式）。
函数返回值：　没有
调用函数：　　１．
备注：        １．
) E+ L3 k9 e, M5 X/ n9 p" C1 \------------------------------------------------------------------------------------------------*/
: Z! b! R- p. ]2 t; S  h5 evoid CommSpiBusModeDfLhMl(unsigned char Model);

#ifdef PreCommSpiUseSingleMasterMode                      // “ＳＰＩ接口工作于单主机方式”的条件编译
0 K. R9 ~7 J; A1 L+ n/*------------------------------------------------------------------------------------------------
% t- r1 y2 P  R4 a  R) ^
$ E( Y5 K  N# b5 t+ Y2 L* I% [------------------------------------------------------------------------------------------------*/
#if cSpiTxBufSize < 256
void CommSpiTxWithData(unsigned char *pData, unsigned char Length);
#else
void CommSpiTxWithData(unsigned char *pData, unsigned int  Length);
#endif

/*------------------------------------------------------------------------------------------------
) Q2 Z+ i8 B( g3 i. b, t7 D) c
6 ]2 k, ~6 c5 o1 @: \+ E------------------------------------------------------------------------------------------------*/
#if cSpiRxBufSize < 256
void CommSpiRxWithData(unsigned char Length);
#else
+ G6 K0 n0 u* r# B& pvoid CommSpiRxWithData(unsigned int  Length);
% Z! l8 D0 `( y/ S" L* U#endif

: ~4 _9 F9 H2 Z$ g' V/*------------------------------------------------------------------------------------------------
函数名称：　　ＳＰＩ接口工作于单主机方式，使用中断进行接收和发送数据的中断服务程序。
7 O! k/ j9 |7 h$ z% D. _函数功能：　　本函数用于ＳＰＩ接口工作于单主机方式，使用中断进行接收和发送数据的中断服务程序。
函数入口参数：gbitSpi.Rxd ------------- “正在进行接收数据作业”标志。
　　　　　　　gstvSpi.TxSize ---------- 每次发送数据个数大小变量。
　　　　　　　gstvSpi.TxCnt ----------- 每次发送数据个数计数器变量。
　　　　　　　gstvSpi.TxBuf[] --------- 每次发送数据缓冲区数组变量。
              gstvSpi.RxSize ---------- 每次接收数据个数大小变量。
函数返回值：　没有
函数出口参数：gbitSpi.Busy ------------ ＳＰＩ接口〖忙〗，出口值＝清位（可能）。
( b% }! J, S$ V* G0 K$ q              gbitSpi.Error ----------- 通讯收发作业发生错误，出口值＝置位（可能）。
              gucvSpiEvent ------------ ＳＰＩ接口的状态码变量，出口值＝ 不确定。
7 l% `* U: F9 A9 J0 I　　　　　　　gstvSpi.TxCnt ----------- 每次发送数据个数计数器变量，出口值＝gstvSpi.TxCnt。
6 d* i: r* \( m/ d2 l0 `3 d　　　　　　　gstvSpi.ErrNum ---------- 通讯收发作业发生错误次数，出口值＝不确定。
8 j, z3 Y: o" {8 C5 B              gstvSpi.RxCnt ----------- 每次接收数据个数计数器变量，出口值＝gstvSpi.RxSize。
8 ~3 L& ~6 F) w/ l4 p% [; F7 A              gstvSpi.RxBuf[] --------- 每次接收数据缓冲区变量，出口值＝从ＳＰＩ接口上接收到的数据。
% d7 E, Y7 T2 e5 M5 n$ c7 e调用函数：　　１．
备注：        １．注意：本函数需在ＳＰＩ接口中断请求的中断向量函数中调用。
                  　　　在调用之前需对该中断向量进行初始化，使能该中断。
　　　　　　　２．全部完成通讯收发作业后，本函数将禁止ＳＰＩ接口中断。
; P, H' `+ x% R% k------------------------------------------------------------------------------------------------*/
#if   (   defined(_IAR_EW_AVR_)   \
! ^/ l4 Y* e2 W6 i, X+ k1 O, [       || defined(_IAR_EW_MCS51_) \
- n" b' u% P5 D: g, D       || defined(_IAR_EW_STM8_)  )
#pragma vector = int_SPI_vector
INTERRUPT_KEY void CommSpi_isr(void);
. d% ~1 e$ |( m% M5 F#elif (defined(_KEIL_UV_MCS51_) )

, z4 z/ l4 e" q) |6 M#elif (   defined(_COSMIC_STM8_)  )
INTERRUPT_KEY void CommSpi_isr(void);
#else
void CommSpiIsr(void);
- B' J% L2 K7 @#endif                                                    // “_IAR_EW_......”
#endif                                                    // “ＳＰＩ接口工作于单主机方式”条件编译结束

) b! w" N8 W" l, A% _#if defined(PreCommSpiUseSingleSlaveMode) || defined(PreCommSpiUseMultiSlaveMode)
                                                          // “ＳＰＩ接口工作于从机方式”的条件编译

#endif                                                    // “ＳＰＩ接口工作于从机方式”条件编译结束

3 D: F& `- J% q  F0 ~6 X) J
/*------------------------------------------------------------------------------------------------
2 \  p, u0 I: [0 r- u函数名称：　　设置“占用ＳＰＩ接口”标志
函数功能：　　本函数用于设置“占用ＳＰＩ接口”标志的函数。
" U0 B8 V$ M" _" N4 z函数入口参数：没有
  c/ w0 b+ c( r$ F% f* p函数返回值：　没有
. ~* ~2 V, n  B" n调用函数：　　１．
备注：        １．
1 H) ^( _: q6 g- t4 G2 o------------------------------------------------------------------------------------------------*/
( T; [) B9 g! T6 b+ O- Avoid CommSpiSetSpiOk(void);

" `% S- v4 |5 u# o. c/*------------------------------------------------------------------------------------------------
函数名称：　　清除“占用ＳＰＩ接口”标志
函数功能：　　本函数用于清除“占用ＳＰＩ接口”标志的函数。
+ q, U" t; e2 n% B7 _函数入口参数：没有
. d7 v( ~& o& B/ F! i$ v; H函数返回值：　没有
调用函数：　　１．
备注：        １．
4 {1 c$ r" u: n" d; h0 h------------------------------------------------------------------------------------------------*/
- ~4 r5 `' T4 i- Y3 {* o1 Zvoid CommSpiClrSpiOk(void);

5 e1 Q) O" ]9 J* Q4 F/*------------------------------------------------------------------------------------------------
. ~" {/ Z& l5 F函数功能：    本函数是ＳＰＩ接口通信接收和发送作业不间断循环调用运行函数。
+ b; }7 o+ J: N. V3 T备注：        ▲．注意：本函数为消息任务队列函数，要在主函数中不间断循环调用运行。
              ▲．当ＳＰＩ接口工作于从机方式时，ＳＰＩ接口中断总是处于使能状态，以便
                  ＳＰＩ接口处于随时接收数据状态。
$ Y5 a! t0 Y7 u1 Q------------------------------------------------------------------------------------------------*/
void CommSpiCircleFunc(void);
) n* n- ^2 i0 h, F8 P
9 n' J5 g0 i7 u  f# K

4 o( ~& u% N2 K, ^/ J#ifdef __cplusplus
}                                                         // extern "C" 链接指示符作用域结束
#endif

#endif                                                    // “_COMMSPI_H_”条件编译结束
  W4 L+ r& k& {1 i  |* Y/ q
: K# P4 q( i1 Z  C+ Q
: X0 f7 |  W( I7 X( Q/*
# f( O5 u5 c3 N8 r( |************************************************************************************************************
) w0 h2 x7 g) C4 Z  c: [9 N　　　　　　　　　　　　　　　　　　　　　　　本头文件到此结束
************************************************************************************************************
*/
! h# P" j5 d! t$ l1 ?

/ {; G. k! w  \7 j- V/ l
4 v  U/ e8 [9 a7 B& ~$ h, R, l+ f

/*==========================================================================================================
函数名称：　　查询ＳＰＩ接口通讯发送数据作业工作状态
7 M" C7 F0 A3 @9 n% J1 a! u函数功能：　　本函数用于检查ＳＰＩ接口通讯发送数据作业工作状态的函数。
函数入口参数：没有
函数返回值：　ＳＰＩ接口收发器的工作状态，０（空闲状态）。
4 o5 v  x9 R2 S$ J# u; O5 W; w! F( i% H调用函数：　　１．
备注：        １．
==========================================================================================================*/
unsigned char  CommSpiBusBusy (void)
{
4 h1 r: H6 [% ]1 n2 K* L2 H0 U#if   (defined(_IAR_EW_AVR_))
  return (SPCR & (1<<SPIE)) ;                             // 如果ＳＰＩ中断使能则收发器处于忙碌状态
#elif ((defined(_IAR_EW_MCS51_)) || (defined(_KEIL_UV_MCS51_)))

#elif (   defined(_IAR_EW_STM8_) \
0 F3 q% j; F  C% |- O& r& X3 v       || defined(_COSMIC_STM8_) )                        // “......_STM8 编译器”条件编译开始
6 R3 ?5 @7 W1 h1 ~- j#ifdef _USE_STM8_FWLIB_                                   // “使用 STM8 FWLib 的库文件”条件编译开始
; M: b, j& I8 C2 `: t6 n% q+ i* B
#else                                                     // “_USE_STM8_FWLIB_”
6 U3 H1 i( `9 i& f0 R0 G  return (SPISR & (u8)( ((1<<spiBSY  ))) );               // 如果ＳＰＩ接口忙则总线处于忙碌状态
#endif                                                    // “_USE_STM8_FWLIB_”
#else
#error 错误：
#endif                                                    // “PreMcuIs__......”
, L7 t; V  E$ S/ v5 G4 X}

/*==========================================================================================================
8 V0 y1 X/ C; l' n5 B函数名称：　　设置ＳＰＩ接口的数据发送次序、时钟极性、时钟相位
1 R- ~" n8 N2 {; l+ W7 F函数功能：　　本函数用于设置ＳＰＩ接口的数据发送次序、时钟极性、时钟相位的函数。
函数入口参数：Model ----------------- 数据发送次序、时钟极性、时钟相位的设置值。
函数返回值：　没有
调用函数：　　１．
备注：        １．
==========================================================================================================*/
void  CommSpiBusModeDfLhMl (unsigned char Model)
{
#if   (defined(_IAR_EW_AVR_))
0 |2 c  C4 Q1 i/ @4 H8 a
, F" `) ]* |9 f  ?. d#elif ((defined(_IAR_EW_MCS51_)) || (defined(_KEIL_UV_MCS51_)))

% Q  j" X4 X1 b#elif (   defined(_IAR_EW_STM8_) \
       || defined(_COSMIC_STM8_) )                        // “......_STM8 编译器”条件编译开始
#ifdef _USE_STM8_FWLIB_                                   // “使用 STM8 FWLib 的库文件”条件编译开始

#else                                                     // “_USE_STM8_FWLIB_”
; \& `$ y: A7 @" i! s% p  `  SPICR1         &= (u8)(~((1<<spiEN   )));               // 禁止ＳＰＩ接口模块，
/ O6 l7 p  L' O+ y  z  SPICR1         &= (u8)(~(cSpiSpicrCfgMask));            // 屏蔽非ＳＰＩ配置寄存器的位值
+ g! ~, P7 s6 _& t0 E& h6 s! D: T  SPICR1         |= (u8)( Model);                         // 导入ＳＰＩ配置值
- v( v7 C6 L1 J* u: v0 O+ K  // 因为ＳＰＩ接口模块还未使能，无法控制ＳＣＫ引脚电平
+ a" T" v3 E/ k9 w1 Y! s7 G% z  if (SPICR1 & (u8)( ((1<<spiCPOL ))))                    // 如果空闲时ＳＣＫ为高电平？
5 [2 S: X/ o" z! Y( ~  {
    MFH_PIN_OUT_SETH_SpiSclk;                             // 确保ＳＰＩ串行时钟引脚为Ｈ电平（没有操作时）
! x; w6 l) N* @# }  C  }
2 w6 z1 z+ Y' A9 J8 v% q  else
  {
    MFH_PIN_OUT_CLRL_SpiSclk;                             // 确保ＳＰＩ串行时钟引脚为Ｌ电平（没有操作时）
  }
# g. }9 z  J$ w4 ?2 g% |#endif                                                    // “_USE_STM8_FWLIB_”
) M3 w, I3 U3 s#else
#error 错误：
#endif                                                    // “PreMcuIs__......”
}

#ifdef PreCommSpiUseSingleMasterMode                      // “ＳＰＩ接口工作于单主机方式”的条件编译
/*==========================================================================================================
函数名称：　　ＳＰＩ接口工作于单主机方式，重新启动ＳＰＩ接口前一个通讯收发作业
0 r) U6 V; {. h2 Z- B函数功能：　　本函数用于ＳＰＩ接口工作于单主机方式，重新启动ＳＰＩ接口前一个通讯收发作业操作的函数。
. L/ H* B2 k7 h' r1 S函数入口参数：gbitSpi.Txd ------------- “正在进行发送数据作业”标志。
1 L9 `8 `+ ~9 O& w: H函数返回值：　没有
( G, Y' I( P1 T3 ~- R) _函数出口参数：gstvSpi.TxBuf[0] ------ 每次发送数据缓冲区数组变量，出口值＝要发送的地址。
              gstvSpi.TxCnt --------- 每次发送数据个数计数器变量，出口值＝０。
              gstvSpi.RxCnt --------- 每次接收数据个数计数器变量，出口值＝０。
7 z9 `) u9 i- w  P8 j1 X调用函数：　　１．
备注：        １．调用本函数将ＳＰＩ接口接收或者发送中断和错误中断请求。
==========================================================================================================*/
( o2 S0 V) b+ y2 astatic void  CommSpiBusAgain (void)
/ ~8 }' Q5 R1 m# b{
#if cSpiTxBufSize < 256
  register unsigned char    i;                            // 循环变量
$ @1 g) [# ^$ e9 ]8 P#else
0 Y+ v) x1 p' I4 R# H  register unsigned int     i;
#endif
' ]9 F% Z7 p4 W- O# ?' n  unsigned char             temp;                         // 临时变量
8 r0 J9 R) p0 s) }6 v- M  CommSpiDataStru           *pSpi;                        // 指向ＳＰＩ接口通讯收发数据处理变量的指针

  pSpi                      = &gstvSpi;                   // 取ＳＰＩ接口通讯收发数据处理变量的首个地址
, I- N+ i2 C6 y4 r% g: |
# e8 b" ~( F4 A# f0 y+ i  pSpi->TxCnt               =  0x01;                      // 每次发送数据计数器值清０
( T4 }( ?" r0 k/ v: e  pSpi->RxCnt               =  0x00;                      // ＳＰＩ接口每次接收数据个数计数器清０
  if (gbitSpi.Txd == SET)                                 // ＳＰＩ接口是否正在进行发送数据作业？
  {
    MFH_PIN_CFG_OUTL_SpiMosi;                             // 设置ＳＰＩ主出/ 从入引脚为输出引脚，并为Ｌ电平
3 _1 U* T( d7 v2 ^& h% }( H    MFHSpiFlgAllClr( );                                   // 清０ＳＰＩ接口全部中断标志位
# e9 z1 J; J0 _0 }7 L    temp                    =  SPIDR;                     // 清０ＳＰＩ接口接收中断标志
! X; ?$ G7 n8 W8 c: G7 L$ R    SPIDR                   =  pSpi->TxBuf[0];            // 从发送缓冲区中将发送数据写入到ＳＰＩ接口
    MFHSpiIntTxdOnn( );                                   // 使能ＳＰＩ接口发送中断、错误中断，唤醒中断
#if   (defined(_IAR_EW_AVR_))
$ l; C) s7 k6 E+ V5 ]( @. _! u
% n. S9 _: A1 q8 w. ^8 Z  n#elif ((defined(_IAR_EW_MCS51_)) || (defined(_KEIL_UV_MCS51_)))
6 k" g! T; [& i1 i- ]# ?) v4 d, f
#elif (   defined(_IAR_EW_STM8_) \
* `9 G: H% i9 x/ M, q       || defined(_COSMIC_STM8_) )                        // “......_STM8 编译器”条件编译开始
1 ]  n$ A, I' g6 g#ifdef _USE_STM8_FWLIB_                                   // “使用 STM8 FWLib 的库文件”条件编译开始
  X, ]' g+ T8 D- v+ O5 P$ c. }( w  X
# E  c$ L: i8 z4 X8 I' T#else                                                     // “_USE_STM8_FWLIB_”
3 a# D" b; [+ l. I) e4 P/ y    SPICR2        = (u8)( ((1<<spiSSI  )|(1<<spiSSM  )|   // 内部从设备＝主模式，使能软件从机设备管理
                           (0<<spiRXTX )|                 // 全双工，０：全双工（同时发送和接收），１：输出禁止（只接收）
$ e  `' ~9 r" G  ~. S4 Z                           (0<<spiCRCTX)|(0<<spiCRCEN)|   // 下一个发送的数据来自Tx缓冲区，禁止硬件ＣＲＣ计算
                           (1<<spiBDOE )|(1<<spiBDM  ) ));// 使能双向模式下输出，使能单线双向数据模式
7 Y2 t0 [$ ^3 N; u9 Z+ f% V/ H#endif                                                    // “_USE_STM8_FWLIB_”
3 L) @& N+ W8 |# r  K6 `( G  u( T#else
#error 错误：
+ u+ W( X5 Y( g! F#endif                                                    // “PreMcuIs__......
+ ~6 Q& z/ {# N  }
2 C- a/ R, S# I" k4 L, C  else
  m) S4 q% H% D9 P  {
! R9 _  {* P! B. d% j$ A    MFH_PIN_CFG_INHZ_SpiMosi;                             // 设置ＳＰＩ主出/ 从入引脚为输入引脚，并为高阻输入态
    MFHSpiFlgAllClr( );                                   // 清０ＳＰＩ接口全部中断标志位
% h! Q" M* H8 r; q    SPIDR                     =  temp;                    // 清０ＳＰＩ接口发送中断标志
    temp                      =  SPIDR;                   // 清０ＳＰＩ接口接收中断标志
    MFHSpiIntRxdOnn( );                                   // 使能ＳＰＩ接口接收中断、错误中断，唤醒中断
#if   (defined(_IAR_EW_AVR_))

#elif ((defined(_IAR_EW_MCS51_)) || (defined(_KEIL_UV_MCS51_)))
1 T6 z* B  j2 M( j- ~' @
# _& `+ z) m* F' ~) t5 O* r1 a#elif (   defined(_IAR_EW_STM8_) \
       || defined(_COSMIC_STM8_) )                        // “......_STM8 编译器”条件编译开始
#ifdef _USE_STM8_FWLIB_                                   // “使用 STM8 FWLib 的库文件”条件编译开始
! H* K: r4 @' D: p; s8 h/ T
#else                                                     // “_USE_STM8_FWLIB_”
4 q9 h1 ?; Q5 A" q    SPICR2        = (u8)( ((1<<spiSSI  )|(1<<spiSSM  )|   // 内部从设备＝主模式，使能软件从机设备管理
4 K, I! y, _7 T  k                           (1<<spiRXTX )|                 // 只接收，０：全双工（同时发送和接收），１：输出禁止（只接收）
                           (0<<spiCRCTX)|(0<<spiCRCEN)|   // 下一个发送的数据来自Tx缓冲区，禁止硬件ＣＲＣ计算
5 o8 i% G' U7 D6 A9 d4 _                           (0<<spiBDOE )|(1<<spiBDM  ) ));// 禁止双向模式下输出，使能单线双向数据模式
, C0 T" Y( s& P# Y  b" k9 Z- {#endif                                                    // “_USE_STM8_FWLIB_”
#else
#error 错误：
! M8 k8 g" m' W4 v: h% x#endif                                                    // “PreMcuIs__......”
: }4 E/ ^3 R% k  }
  MFHSpiModSpiOnn( );                                     // 使能ＳＰＩ接口模块

5 o! }. P+ ]: U1 m  (void)temp;                                             // 用以阻止编译器产生［temp］未使用的警告消息
}
! p  Z. a4 O. |' N% h

) }. x  C! {4 o6 S  w/*==========================================================================================================
2 M6 G) }, P0 W: N函数名称：　　启动ＳＰＩ接口应用中断方式发送数据
, S# f% W7 C) @1 f' O4 L函数功能：　　本函数用于启动ＳＰＩ接口使用中断方式，进行通讯发送数据作业操作的函数。
% H/ I0 z5 G5 t" h9 ^函数入口参数：*pData ------------------ 指向首个要发送数据在ＳＲＡＭ中的地址指针。
              Length ------------------ 要发送数据的数据总长度。
函数返回值：　没有
( w7 j' V0 I' [/ s函数出口参数：gbitSpi.Busy ------------ ＳＰＩ接口〖忙〗，出口值＝置位。
/ Z; N9 z% O. y8 k' {              gbitSpi.Txd ------------- “正在进行发送数据作业”标志，出口值＝置位。
　　　　　　　gstvSpi.TxSize ---------- 每次发送数据个数大小变量，出口值＝Length。
/ b7 y* ~* D# r5 n; ?& f　　　　　　　gstvSpi.TxCnt ----------- 每次发送数据个数计数器变量，出口值＝0。
+ d3 p1 F, @2 }5 x  r( |/ f　　　　　　　gstvSpi.TxBuf[] --------- 每次发送数据缓冲区数组变量，出口值＝要发送的数据。
　　　　　　　gstvSpi.Cycle ----------- 重新启动通讯收发作业圈数，出口值＝0。
调用函数：　　１．
备注：        １．注意：调用本函数之前，必须确定ＳＰＩ接口在空闲状态。即必须先调用
　　　　　　　　　　　　“unsigned char CommSpiBusBusy(void)”函数，来检查ＳＰＩ接口的工作状态，
　　　　　　　　　　　　只有ＳＰＩ接口处于空闲状态，才允许调用本函数。
3 b' W$ S2 p& R( H) J　　　　　　　２．调用本函数将ＳＰＩ接口发送中断和错误中断请求。
% l. r! R; y) t==========================================================================================================*/
#if cSpiTxBufSize < 256
void  CommSpiTxWithData (unsigned char *pData, unsigned char Length)
% }4 |) y4 \! p+ Q( l, J2 d. y$ s#else
" j' ~5 o& X+ f, E3 j2 \, ivoid  CommSpiTxWithData (unsigned char *pData, unsigned int  Length)
0 `) G& r, O* i! ~#endif
{
5 D' F; V9 Y8 t* u1 K7 X#if cSpiTxBufSize < 256
6 g: V9 d) Q5 N( _8 E  O, D0 \! [  register unsigned char    i;                            // 循环变量
#else
  register unsigned int     i;
#endif
! g5 m% f0 Y% S! q4 ]  unsigned char             temp;                         // 临时变量
  CommSpiDataStru           *pSpi;                        // 指向ＳＰＩ接口通讯收发数据处理变量的指针

2 T6 f# o, C+ A) `" _  pSpi                      = &gstvSpi;                   // 取ＳＰＩ接口通讯收发数据处理变量的首个地址

' U; n" H: ^* e' h' N- T#ifdef PreCommSpiWithRedundantCode                        // “使用冗余程序代码”条件编译开始
4 Q& o" e* i' ~5 h2 ?  F" k. `8 P  if (   (Length >= (cSpiTxBufSize - 0))
$ Q- k" C6 U( f3 S% b5 K" X7 c      || (Length == 0)                   )
# h+ l: K9 d8 |  V, y) f, y% n  {
5 e" P% a) h6 |% {& u6 J    return;
  }
( T- I0 W- H7 x* d) z#endif                                                    // “PreCommSpiWithRedundantCode”
/ F. o! v, _$ F4 n  E+ O& M4 K
/ R0 w  J: r7 Q) M//  while(CommSpiBusBusy( ));                               // 等待直到对ＴＷＩ下一个收发作业准备就绪为止
9 q$ k; X, j3 ?% ]& [& T
5 ~( y" m/ b0 T3 F' V4 D  gbitSpi.Busy              =  SET;                       // 置“ＳＰＩ接口〖忙〗”标志
  gbitSpi.Txd               =  SET;                       // 置“正在进行发送数据作业”标志
, w- J% ]' L- Q- t  gbitSpi.OverS             =  SET;                       // 置“通讯任务时间超时”标志
  pSpi->OverS               =  RtcGetSecByte(cSpiOverSec);// 启动通讯任务时间计时秒表
& n. i: M! ?+ w) t+ Y& D7 @  MemCopySramToSram(pData, &pSpi->TxBuf[0], Length);      // 复制发送的数据序列到发送数据缓冲区中
  pSpi->TxSize              =  Length;                    // 置每次发送数据个数大小值
/ x0 q! E( G/ \& M  pSpi->TxCnt               =  0x01;                      // 每次发送数据计数器值清０
  pSpi->Cycle               =  0x00;                      // 重新启动通讯收发作业圈数清０
  MFH_PIN_CFG_OUTL_SpiMosi;                               // 设置ＳＰＩ主出/ 从入引脚为输出引脚，并为Ｌ电平
$ f5 E7 L& J1 H& c, P, o  P  MFHSpiFlgAllClr( );                                     // 清０ＳＰＩ接口全部中断标志位
  temp                      =  SPIDR;                     // 清０ＳＰＩ接口接收中断标志
  SPIDR                     =  pSpi->TxBuf[0];            // 从发送缓冲区中将发送数据写入到ＳＰＩ接口
0 Z0 A$ c0 ]( N  MFHSpiIntTxdOnn( );                                     // 使能ＳＰＩ接口发送中断、错误中断，唤醒中断
#if   (defined(_IAR_EW_AVR_))
, k* r- M, y3 D/ c
#elif ((defined(_IAR_EW_MCS51_)) || (defined(_KEIL_UV_MCS51_)))
( f$ }: ~6 e& k
* h: b& y4 e! D5 o' m#elif (   defined(_IAR_EW_STM8_) \
       || defined(_COSMIC_STM8_) )                        // “......_STM8 编译器”条件编译开始
#ifdef _USE_STM8_FWLIB_                                   // “使用 STM8 FWLib 的库文件”条件编译开始
5 c3 B; d' J: n) q
#else                                                     // “_USE_STM8_FWLIB_”
# U( P; y( Y9 s4 u7 n  SPICR2          = (u8)( ((1<<spiSSI  )|(1<<spiSSM  )|   // 内部从设备＝主模式，使能软件从机设备管理
                           (0<<spiRXTX )|                 // 全双工，０：全双工（同时发送和接收），１：输出禁止（只接收）
                           (0<<spiCRCTX)|(0<<spiCRCEN)|   // 下一个发送的数据来自Tx缓冲区，禁止硬件ＣＲＣ计算
7 S9 \$ @# ~# d5 _1 b                           (1<<spiBDOE )|(1<<spiBDM  ) ));// 使能双向模式下输出，使能单线双向数据模式
4 O3 b; z( G5 j4 d+ W, m" s% X! b9 {#endif                                                    // “_USE_STM8_FWLIB_”
#else
#error 错误：
0 X& A2 U1 C1 {. n7 r7 b5 u#endif                                                    // “PreMcuIs__......”
  MFHSpiModSpiOnn( );                                     // 使能ＳＰＩ接口模块

  (void)temp;                                             // 用以阻止编译器产生［temp］未使用的警告消息
}
) n" F1 R2 ^& c% b5 y6 }
# C4 w( v: b( @; G2 ~: z/*==========================================================================================================
函数名称：　　启动ＳＰＩ接口应用中断方式接收数据
函数功能：　　本函数用于启动ＳＰＩ接口使用中断方式，进行通讯接收数据作业操作的函数。
函数入口参数：Object ------------------ 要接收数据的的目标设备地址值。
+ ?7 j4 |  q% a0 _' R$ s9 t5 l! S              Length ------------------ 要接收数据的数据总长度。
# E3 J+ R# b7 k; y函数返回值：　没有
函数出口参数：gbitSpi.Busy ------------ ＳＰＩ接口〖忙〗，出口值＝置位。
4 f( N& T9 y) H" `              gbitSpi.Txd ------------- “正在进行发送数据作业”标志，出口值＝清位。
: d' y/ T+ J2 n! r　　　　　　　gstvSpi.TxSize ---------- 每次发送数据个数大小变量，出口值＝Length。
　　　　　　　gstvSpi.TxCnt ----------- 每次发送数据个数计数器变量，出口值＝0。
6 _3 Z( {+ X9 h. L. J　　　　　　　gstvSpi.TxBuf[] --------- 每次发送数据缓冲区数组变量，出口值＝全部为0x00。
7 ]' ~8 n+ M* P+ a# w7 B　　　　　　　gstvSpi.Cycle ----------- 重新启动通讯收发作业圈数，出口值＝0。
              gstvSpi.RxSize ---------- 每次接收数据个数大小变量，出口值＝Length。
: O! @( ~, G* u  h7 B+ S9 P+ ~              gstvSpi.RxCnt ----------- 每次接收数据个数计数器变量，出口值＝０。
调用函数：　　１．
备注：        １．注意：调用本函数之前，必须确定ＳＰＩ接口在空闲状态。即必须先调用
　　　　　　　　　　　　“unsigned char CommSpiBusBusy(void)”函数，来检查ＳＰＩ接口的工作状态，
3 }+ V( o7 h9 K4 K　　　　　　　　　　　　只有ＳＰＩ接口处于空闲状态，才允许调用本函数。
　　　　　　　２．调用本函数将ＳＰＩ接口接收中断和错误中断请求。
==========================================================================================================*/
; ]% y2 }5 M5 w8 s#if cSpiRxBufSize < 256
void  CommSpiRxWithData (unsigned char Length)
9 V" |# \/ I+ `' u( D#else
void  CommSpiRxWithData (unsigned int  Length)
8 P1 G7 k6 o8 k3 M#endif
{
#if cSpiRxBufSize < 256
6 t4 n1 r% q- U. Q- }1 Z  register unsigned char    i;                            // 循环变量
#else
& g  C5 c+ j6 J1 s7 s( g% ~  register unsigned int     i;
#endif
  unsigned char             temp;                         // 临时变量
" ~; [5 j  _5 C. W  CommSpiDataStru           *pSpi;                        // 指向ＳＰＩ接口通讯收发数据处理变量的指针

  pSpi                      = &gstvSpi;                   // 取ＳＰＩ接口通讯收发数据处理变量的首个地址
#ifdef PreCommSpiWithRedundantCode                        // “使用冗余程序代码”条件编译开始
1 v' l) ~& H0 `- S6 m, j  if (   (Length > cSpiRxBufSize) )                       // 检查要接收数据的总个数是否超过缓冲区长度？
. e8 e+ M% b; o& ?  {
    Length                  =  cSpiRxBufSize;             // 截断要接收数据的总个数
2 w  N- s; J( _2 P% A8 }# [  }
#endif                                                    // “PreCommSpiWithRedundantCode”
# O( x5 c$ |5 g1 w( ]
. o8 j$ K# m: G: A" c//  while(CommSpiBusBusy( ));                               // 等待直到对ＴＷＩ下一个收发作业准备就绪为止

3 p0 G2 n6 j- h& M* b( ^) s  \  gbitSpi.Busy              =  SET;                       // 置“ＳＰＩ接口〖忙〗”标志
  gbitSpi.Txd               =  CLEAR;                     // 清除“正在进行发送数据作业”标志
  gbitSpi.OverS             =  SET;                       // 置“通讯任务时间超时”标志
  pSpi->OverS               =  RtcGetSecByte(cSpiOverSec);// 启动通讯任务时间计时秒表
//  MemClearSram(pSpi->TxBuf, Length);                      // 复制发送的数据序列到发送数据缓冲区中
//  pSpi->TxSize              =  Length;                    // 置每次发送数据个数大小值
//  pSpi->TxCnt               =  0x00;                      // 每次发送数据计数器值清０
2 i$ C! i1 x3 U6 v4 J, f  pSpi->Cycle               =  0x00;                      // 重新启动通讯收发作业圈数清０
. J" j3 X% Q) ]
6 ^% s5 j# Y) Z. V* Y  pSpi->RxSize              =  Length;                    // 置ＳＰＩ接口每次接收数据个数大小的值
( ^% ^4 e3 g& A8 ^! a/ B/ q  pSpi->RxCnt               =  0x00;                      // ＳＰＩ接口每次接收数据个数计数器清０
, F0 ^- U3 m2 P) P% X! }0 \
- M# J  Y2 f; ?6 D& v  MFH_PIN_CFG_INHZ_SpiMosi;                               // 设置ＳＰＩ主出/ 从入引脚为输入引脚，并为高阻输入态
* I6 _$ {3 d( ?: m, B9 h8 b  MFHSpiFlgAllClr( );                                     // 清０ＳＰＩ接口全部中断标志位
  SPIDR                     =  temp;                      // 清０ＳＰＩ接口发送中断标志
  K  }( R; R7 r3 }( g- V  temp                      =  SPIDR;                     // 清０ＳＰＩ接口接收中断标志
  MFHSpiIntRxdOnn( );                                     // 使能ＳＰＩ接口接收中断、错误中断，唤醒中断
#if   (defined(_IAR_EW_AVR_))
% \7 s2 G9 j3 ?+ ]) x: T' r
#elif ((defined(_IAR_EW_MCS51_)) || (defined(_KEIL_UV_MCS51_)))
9 x5 P# L5 f4 M7 _
9 H7 @  {" Z' G8 p6 ~#elif (   defined(_IAR_EW_STM8_) \
. k" J! e2 C0 a+ U; \' m       || defined(_COSMIC_STM8_) )                        // “......_STM8 编译器”条件编译开始
+ `9 w+ e5 p4 [#ifdef _USE_STM8_FWLIB_                                   // “使用 STM8 FWLib 的库文件”条件编译开始

- ^3 G- \7 s+ P0 p+ @7 a#else                                                     // “_USE_STM8_FWLIB_”
  SPICR2          = (u8)( ((1<<spiSSI  )|(1<<spiSSM  )|   // 内部从设备＝主模式，使能软件从机设备管理
                           (1<<spiRXTX )|                 // 只接收，０：全双工（同时发送和接收），１：输出禁止（只接收）
                           (0<<spiCRCTX)|(0<<spiCRCEN)|   // 下一个发送的数据来自Tx缓冲区，禁止硬件ＣＲＣ计算
8 e# d% A* U, b' \6 r. l                           (0<<spiBDOE )|(1<<spiBDM  ) ));// 禁止双向模式下输出，使能单线双向数据模式
4 N7 S# R- O) d/ p: v/ e#endif                                                    // “_USE_STM8_FWLIB_”
#else
#error 错误：
#endif                                                    // “PreMcuIs__......”
  MFHSpiModSpiOnn( );                                     // 使能ＳＰＩ接口模块
4 p5 h7 B  y3 z: b* N4 c, p. ?; J
  (void)temp;                                             // 用以阻止编译器产生［temp］未使用的警告消息
( q# R; s! i/ L9 ~8 A* s2 f}
: q: \( v$ u0 C  F2 w

__IO_REG8_BIT(SPICR1    , 0x5200, __READ_WRITE, __BITS_SPI_CR1      );// ＳＰＩ控制寄存器１
( Q5 F' A6 s7 C2 C3 e6 F__IO_REG8_BIT(SPICR2    , 0x5201, __READ_WRITE, __BITS_SPI_CR2      );// ＳＰＩ控制寄存器２
. ?1 K' F5 y( R' K__IO_REG8_BIT(SPIICR    , 0x5202, __READ_WRITE, __BITS_SPI_ICR      );// ＳＰＩ中断控制寄存器
__IO_REG8_BIT(SPISR     , 0x5203, __READ_WRITE, __BITS_SPI_SR       );// ＳＰＩ状态寄存器
__IO_REG8    (SPIDR     , 0x5204, __READ_WRITE                      );// ＳＰＩ数据寄存器（SPI_DR）
) [+ _! q6 |0 i& z3 {) K3 F: ]__IO_REG8    (SPICRCPR  , 0x5205, __READ_WRITE                      );// ＳＰＩＣＲＣ多项式寄存器（SPI_CRCPR）
( I& T: ], ~& q9 x& U. @: A5 N5 W" o: R+ C__IO_REG8    (SPICRCRR  , 0x5206, __READ                            );// ＳＰＩ接收ＣＲＣ寄存器（SPI_RXCRCR）
__IO_REG8    (SPICRCTR  , 0x5207, __READ                            );// ＳＰＩ发送ＣＲＣ寄存器（SPI_TXCRCR）
: f" k  Y" n6 w* |% D, v
/*------------------------------------------------------------------------------------------------
　　　　　　　　　串行外围设备接口（SPI）
0 `0 V9 D# p9 d7 E# ?9 V- y------------------------------------------------------------------------------------------------*/
// SPICR1（SPI_CR1）——— ＳＰＩ控制寄存器１
#define spiCPHA               0                           // 时钟相位控制位，０：数据锁存在下降沿.，１：数据锁存在上升沿
: @8 y( T4 g- U) V$ |& ?#define spiCPOL               1                           // 时钟空闲极性（仅主机模式有效），０：空闲时SCK 为低电平，１：空闲时SCK 为高电平。
#define spiMSTR               2                           // 主／从机模式选择
4 F/ y1 S0 @. p* W% u, h7 o#define spiCS0                3                           // 波特率预分频器选择控制位０
#define spiCS1                4                           // 波特率预分频器选择控制位１
) O, \* H; _! S) [  M#define spiCS2                5                           // 波特率预分频器选择控制位２
. v8 Z; F0 o% }/ r; ?. G: t#define spiEN                 6                           // ＳＰＩ启动／停止使能位
5 H" U8 _5 ?3 L3 N#define spiDORD               7                           // 发送数据次序（ＬＳＢ／ＭＳＢ字节先后顺序）

// SPICR2（SPI_CR2）——— ＳＰＩ控制寄存器２
- B/ w" y( ^3 B4 f- l8 y& Y#define spiSSI                0                           // 内部从设备选择
  V# u* O$ d5 m& G7 N. ^#define spiSSM                1                           // 软件从机设备管理
3 x0 w6 C/ B% u  N9 A9 G#define spiRXTX               2                           // 只接收，０：全双工（同时发送和接收），１：输出禁止（只接收）
#define spiCRCTX              4                           // 接着发送ＣＲＣ，０：下一个发送的数据来自Tx缓冲区，１：下一个发送的数据来自SPICRCTR。
% \; T, B, D7 I1 Y% l2 b2 J#define spiCRCEN              5                           // 硬件ＣＲＣ计算启动／停止使能位
3 V) n% |4 B  }, E' j#define spiBDOE               6                           // 双向模式下输出使能
. o5 P- w3 V( O* V" F- z* C; ~#define spiBDM                7                           // 双向数据模式使能
' f* ^1 U' O9 U" u" c
// SPIICR（SPI_ICR）——— ＳＰＩ中断控制寄存器
8 S/ I, N, ]5 X3 `( F#define spiWUIE               4                           // 唤醒中断使能位
#define spiERRIE              5                           // 错误中断使能位
#define spiRXIE               6                           // 接收中断使能位
#define spiTXIE               7                           // 发送中断使能位

4 Z' ^- r! }8 N0 g4 C, q! r+ ?// SPISR（SPI_SR）——— ＳＰＩ状态寄存器
3 z4 J' r# B2 t#define spiRXNE               0                           // 接收缓冲区非空标志
#define spiDRE                1                           // 发送缓冲区空标志
$ ?4 V7 H% Y6 H5 U' V#define spiWUF                3                           // 唤醒标志
% N" c, Y* _' s3 Z; L" M#define spiCRCEF              4                           // ＣＲＣ错误标志
* T: V1 f7 p# h4 K#define spiMODF               5                           // 模式错误标志
#define spiOVF                6                           // 溢出标志位
#define spiBSY                7                           // 总线忙标志

多谢分享，好长哈

好长。。。

谢谢分享

帮顶                              

修改一个错误，在驱动HT1621时发现的，会导致HT1621驱动不正常。
先输出ＳＣＫ引脚电平，再停止ＳＰＩ接口模块，原来的顺序反了。
9 t% O7 r+ }: _; M, \6 M5 M- h: Z// 因为ＳＰＩ接口模块被停止，无法控制ＳＣＫ引脚电平
3 s1 Y5 h" \" A7 y0 M( `5 R  Z#define MFHSpiModSpiOff( )            if (SPICR1 & (u8)( ((1<<spiCPOL ))))                                \
4 [, Q. A' ?& _$ s  }  g* n0 c3 _                                      {                                                                   \
                                        MFH_PIN_OUT_SETH_SpiSclk;                                         \
4 M0 x. v1 z) [& n' G                                      }                                                                   \
9 g2 ~) P6 V/ i& M0 [* m! s2 j                                      else                                                                \
  ^% g* U, V; u. @5 V: `% `; G                                      {                                                                   \
                                        MFH_PIN_OUT_CLRL_SpiSclk;                                         \
                                      }                                                                   \
                                      SPICR1                       &= (u8)(~((1<<spiEN   )))            ;

哥能打包分享下驱动1621的例程吗？

打包没有办法，因为HT1621 字符液晶模块的字段涉及公司的利益，给你一段写入操作供参考：
#ifdef PreHt1621AccessingUseCommSpi                       // “HT1621 字符液晶使用ＳＰＩ接口访问”条件编译
4 ~: I* C5 e* @' n  // 写入全部的字段数值变量静态随机数据缓冲区数值
1 m* V% [& k# @: @6 b# B4 J0 L+ u% ~  if (   (gbitHt1621.WrRam == SET)
      && (gbitSpi.Busy == CLEAR)     )
0 C; H  G/ \: K! N+ @  {
! k7 m- ^: D3 |- |5 v4 k8 B    switch (gstvSpi.StepSpi)                              // 判断ＳＰＩ接口操作步骤值？
/ [" ^+ y. ]" X! I4 K0 R    {
/ O8 `* P+ _! }      case 0:                                             // 步骤１：发送“禁止 HT1381 写入保护”操作命令
      {
        HSB(cHt1621SegSize) =  (cHt1621WriteRev >> 1);
#ifdef PreHt1621IdleWrPinAsInput                          // “写使能信号引脚空闲时为输入引脚”条件编译
        MFH_PIN_CFG_OUTL_Ht1621Wr;                        // 设置 HT1621 写使能引脚为输出引脚，并确保为Ｌ电平（没有操作时）
#else
        MFH_PIN_OUT_CLRL_Ht1621Wr;                        // 确保 HT1621 写使能引脚为Ｌ电平（没有操作时）
! [. L, P5 M3 l. H0 }#endif                                                    // “PreHt1621IdleWrPinAsInput”
        MFH_PIN_OUT_CLRL_Ht1621Cs;                        // 使能 HT1621 片选信号（Ｌ电平）
        Ht1621SendBitMsb(cHt1621Write, 1);                // 写入标志码“101（数据写入模式）”的第１位
        CommSpiTxWithData(&HSB(cHt1621SegSize), 1);       // 写入标志码“101”的第２～３位和“Addr”的高 6 位
: d0 g6 q: d( W3 u/ e( `
//#ifdef PreHt1621IdleWrPinAsInput                          // “写使能信号引脚空闲时为输入引脚”条件编译
//        MFH_PIN_CFG_OUTL_Ht1621Wr;                        // 设置 HT1621 写使能引脚为输出引脚，并确保为Ｌ电平（没有操作时）
1 ^: s3 I0 t/ Y//#else
  g, Y& s# D- I' U& z//        MFH_PIN_OUT_CLRL_Ht1621Wr;                        // 确保 HT1621 写使能引脚为Ｌ电平（没有操作时）
//#endif                                                    // “PreHt1621IdleWrPinAsInput”
; I' W1 L# D  |" V* l1 s4 s//        MFH_PIN_OUT_CLRL_Ht1621Cs;                        // 使能 HT1621 片选信号（Ｌ电平）
8 T: O6 ?4 m, H- C, i& d" h2 w//        Ht1621SendBitMsb(cHt1621Write, 3);                // 写入标志码“101（数据写入模式）”
//        Ht1621SendBitMsb(0x00, 6);                        // 写入“Addr”的高 6 位
1 B: r( ^2 i0 w( ^        gstvSpi.StepSpi++;                                // ＳＰＩ接口操作步骤指向下一步
        break;
      }
" m" P( V: l+ `& _0 J, k0 V. \      case 1:                                             // 步骤２：连续写入“全部的字段数值变量静态随机数据缓冲区”中的数据
      {
4 x0 b/ c( [6 d7 B9 M        CommSpiTxWithData(&HSB(0), cHt1621SegSize);
        gstvSpi.StepSpi++;                                // ＳＰＩ接口操作步骤指向下一步
        break;
      }
6 l2 Z- E% y2 u6 R      case 2:                                             // 步骤３：
      {
        MFH_PIN_OUT_SETH_Ht1621Cs;                        // 禁止 HT1621 片选信号（Ｈ电平）
: U6 t& y# z9 ], Q0 R; _        gstvSpi.StepSpi++;                                // ＳＰＩ接口操作步骤指向下一步
% \, K, p9 i7 d4 m8 L9 X2 b# _) i        break;
) P' V/ r/ q; }9 X$ l      }
      default:
      {
! F* y& z' R3 w* r        gbitHt1621.WrRdy    =  CLEAR;                     // 清除“写入输出映射缓冲区的数据准备就绪”标志
        gbitHt1621.WrRam    =  CLEAR;                     // 清除“正在写入输出映射缓冲区的数据”标志
        CommSpiClrSpiOk( );                               // 清除“占用ＳＰＩ接口”标志
        break;
1 y7 Q& V' @( m4 w4 F8 K      }
    }
  }
  if (   (gbitHt1621.WrRdy == SET)
      && (gbitHt1621.WrRam == CLEAR)
      && (gbitSpi.SpiOk == CLEAR)    )
  {
' q' K6 F" ]7 z/ @( i' v" U    CommSpiSetSpiOk( );                                   // 设置“占用ＳＰＩ接口”标志
0 O% c0 F0 f' I$ s* B; }1 u0 U    CommSpiBusModeDfLhMl(cSpiSpicrCfgDLL256);             // 设置ＳＰＩ接口为数据锁存在第１个时钟沿、空闲时ＳＣＫ为低电平、ＬＳＢ首先发送
    gbitHt1621.WrRdy        =  CLEAR;                     // 清除“写入输出映射缓冲区的数据准备就绪”标志
* g# A7 m9 V0 E" o. X" h; Q7 u+ D    gbitHt1621.WrRam        =  SET;                       // 置“正在写入输出映射缓冲区的数据”标志
  }
#endif                                                    // “PreHt1621AccessingUseCommSpi”