你的浏览器版本过低,可能导致网站不能正常访问!
为了你能正常使用网站功能,请使用这些浏览器。

STM8S SPI单线通信中断程序

[复制链接]
磊元lystudio 发布时间:2015-10-6 21:47
/*
6 Q7 s* w6 S6 L- L3 s************************************************************************************************************
5 l4 e6 |0 ~% J. c0 p# Z% o版权所有 (C),2010-2012,磊元科技有限公司
" t4 w' X* ^/ s6 b--------------------------------------------------------------------------------------------------# q* @4 W: K' T  v% Q' C& ^7 j
头文件名:        CommSpi.h
) G2 e3 \1 k4 c/ W0 S& v  I; w头文件名称:        串行外设接口(SPI接口)的头文件3 ]6 L' A( O4 v
程序版本:        1.0
2 k  t$ i4 h- \$ r; [文件功能:
0 R3 Z) z0 W, `) O    本文件是对串行外设接口(SPI接口)的源程序文件的编译控制声明、字符化常数和输入/输出引脚定义、
2 j5 }, O# Z; @- G  全局常量声明、全局数据结构类型定义、全局变量声明和函数原型声明的头文件。0 P+ K9 X8 ?3 Q2 p
文件说明:. V* u/ W! e: c8 [& b
    1.本文件中的所有标识符定义前缀字母表示意义如下:- b8 d& o, `2 S& A9 {# N2 g
      c  ---------- 常量
( M# `3 K7 o, Z8 m3 E& \      v  ---------- 变量
7 [- }  E: t: ?* b) w2 `      g  ---------- 全局变量(Global)8 }/ F) b8 I7 i5 @- \- V3 u
      l  ---------- 局部变量(Local)
) s0 ?/ N6 m  E6 ?) q" T  i      uc ---------- 数据类型(Unsigned Char)% u% t1 ]$ @5 }" K6 F
      ui ---------- 数据类型(Unsigned Word)
5 L3 E' s. H. d7 K6 k; L% d      p  ---------- 指针, f8 g$ g/ Y' U* n
      st ---------- 数据体; f; d. j3 S' f7 j) o6 n; U
      pt ---------- 指向数据体的指针
. H" ]4 i: x+ h, g' b' a# m            Pre --------- 条件编译预定义5 Z3 h; X4 h2 @0 \4 D
            MFH --------- 宏定义硬件操作函数7 N. Z* g$ L, x
            MFS --------- 宏定义软件操作和条件编译函数& ]) S, S+ U" G# {& S7 Q! p& a
            MFO --------- 宏定义其他函数
: {$ F* J7 x+ m6 d    2.注意:使用源程序的SPI接口接收和发送数据的函数之前,必须使能全局中断。
4 B  ^% q8 K; F- J    3.注意:本文件仅实现1条时钟线(SCK)和1条双向数据线(MOSI)的单工通信方式。
% K/ V! O7 b% _7 z主要函数列表:   
1 ~( v- }* V% u' N. w5 U- A# B    ▲.在主函数中运行的函数:% Q/ `9 f7 S9 i' ?" Y; l
      1.void UsartsInit(void)(USARTs端口和查询式串行通讯协议的初始化)
7 h# r3 w9 D. P, ~      2.void Rs422UsartsAskManage(void)(查询式RS422的通讯协议处理)5 ]+ s0 p- h1 b# x% d
    ▲.中断请求服务函数:
2 o1 H$ }" g3 o; {- o      1.void usart1_txc_isr(void)(发送结束中断方式发送数据的中断服务程序)& \! E3 ~) g8 D
      2.void usart1_rxc_isr(void)(接收结束中断方式接收数据的中断服务程序). s5 w3 k/ P  ^1 h) J5 x* W% Z
编译工具软件:      IAR Embedded Workbench for Atmel AVR 版本:5.20A 以上
; P/ }1 x) s5 H4 N. y链接文件:          1.SysCfg.h ------------ 系统运行结构定义配置的头文件。; x9 x* R: p2 h* E1 U
编作者:            磊元
4 I  A. f1 K1 R编制日期:          2009年4月8日$ y' C' d  m$ f; d7 J' i; L
--------------------------------------------------------------------------------------------------3 R! L- H  M! {7 e/ H% o) }- w% i
头文件版本历史:# s/ b7 f3 R1 h
2006年07月26日  〖磊元〗 -------- 版本 1.0 :原始版本(AVR)
1 [2 E) @5 G( I3 @. w# o2015年09月20日  〖磊元〗 -------- 版本 2.0 :扩增版本(STM8S)
& {( F+ W/ n+ ~" n************************************************************************************************************) D! x; A# c! b  A+ z3 D
*/% C( B+ ~' A) ?  F
#ifndef _COMMSPI_H_                                       // “_COMMSPI_H_”条件编译开始, f6 V8 Q" s1 _  o
#define _COMMSPI_H_
! f1 I& `2 q$ P0 d. V
, r/ }& `4 L4 c/ R8 f/*==========================================================================================================' N- H$ {( X- P/ n+ }# ?) |7 ]4 t0 I
                     本头文件包括的其他头文件6 ^  U; F5 W4 R
建议:包含本项目的文件使用 #include "文件名.扩展名" ,
) N- `& c' j$ _! }   包含系统库的文件使用 #include <文件名.扩展名> 。
% h9 V6 W$ D5 V7 \==========================================================================================================*/7 C7 d) l" K5 l. b! D4 \7 z
#include "SysCfg.h"                                       // 系统运行结构定义配置的头文件" H  f8 u9 T3 e) b* q% I

6 F* L- r  r; p( F4 B#ifdef __cplusplus7 ^( j4 N- d) Z  B( Q. @5 [
extern "C" {                                              // 声明接在下面的指令为C程序编译系统
8 U$ h1 e+ A6 n( K' O8 O9 R#endif
! Z3 S, N, G1 U- h% [1 ^
6 o( }# I2 z+ b. T! s/*==========================================================================================================
$ U% ]- ]  F( l, n2 j: K. {                       条件编译控制声明( p6 J8 _& i2 l7 f+ |, R
==========================================================================================================*/* C) X" J2 F% E. G6 e, S* Y
//#ifndef PreGlobalCompilerHardware                         // 非“全局统一的条件编译控制和硬件定义”条件编译; L. }, R7 t: e# ^  u
#if defined(PreGlobalWithRedundantCode)8 D1 c" o4 `. B  G. e1 J
/*------------------------------------------------------------------------------------------------
, v7 j% ]; b+ B3 F+ w4 v( D/ S8 k声明程序指令使用冗余代码的条件定义:; X5 r% b1 H; l3 @0 l0 f, @# \
------------------------------------------------------------------------------------------------*/
+ f9 O0 z; b2 T8 D' w2 `2 Q#define PreCommSpiWithRedundantCode                       // “使用冗余程序代码”条件定义
! Q% k, G) _. \6 R#endif4 m. [8 E  Q5 Z' |
/*------------------------------------------------------------------------------------------------! j3 P, n0 j6 S8 w% u
声明串行外设接口(SPI接口)工作于哪种方式的条件定义:
8 B1 w& e, K: m$ A) g注意:只能使用下面几个条件定义中的1个条件定义,不允许使用2个以上条件定义!!!
- J" R8 o% Q# \, V警告:此处的声明定义对于本源程序文件和其他源程序文件的编译有决定性作用,应慎重!! @" J3 N8 F4 |2 v
------------------------------------------------------------------------------------------------*/
; X- u0 \, g& u8 {4 n0 \#define PreCommSpiUseSingleMasterMode                          // “SPI接口工作于单主机方式”条件定义
9 m3 Q. J8 z* ]//#define PreCommSpiUseSingleSlaveMode                      // “SPI接口工作于单从机方式”条件定义: Q4 [, S7 F  O; M1 E+ v5 b6 p
//#define PreCommSpiUseMultiSlaveMode                            // “SPI接口工作于多从机方式”条件定义) V) o0 e* p2 P+ q
#if   (   (defined(PreCommSpiUseSingleMasterMode) || defined(PreCommSpiUseSingleSlaveMode)) \: b, p# u8 j5 E: ^( k) c
       && (defined(PreCommSpiUseSingleMasterMode) || defined(PreCommSpiUseMultiSlaveMode )) \% r2 y5 ~; z7 @4 c
       && (defined(PreCommSpiUseSingleSlaveMode ) || defined(PreCommSpiUseMultiSlaveMode )) )
, ~, z% V' t& x+ X#error 错误:<声明串行外设接口(SPI接口)工作于哪种方式的条件定义>不允许使用2个以上条件定义!!!
0 u- m; g% k& o  H#endif
5 \6 V& F; k( C+ Q/*------------------------------------------------------------------------------------------------
5 M3 Y$ m0 ^: A声明在应用中对于具有多个SPI接口的目标器件芯片,具体指定使用哪一个SPI端口的条件定义:
% V9 X8 R+ t1 x$ T" Z9 g% N------------------------------------------------------------------------------------------------*/  q, r" i  S( C/ z7 I+ X, e/ C3 O! l
#define PreCommSpiMultipleSpiEnable0                      // 使用SPI0接口的声明定义- q0 R& h4 [* c: Q
//#endif                                                    // “PreGlobalCompilerHardware”
0 W9 x# Q5 l0 p+ m: j2 o' ]0 y! t! ^  S) H( ]
/*==========================================================================================================. ~0 D/ w! V, v& ~
               各类字符化常数和硬件设计相关的输入/输出引脚定义
; [; n& j- K& H) P==========================================================================================================*/
, E( k8 K' u) d" z. B//#ifndef PreGlobalCompilerHardware                         // 非“全局统一的条件编译控制和硬件定义”条件编译
3 [- \4 r3 o; C8 T: J/*------------------------------------------------------------------------------------------------
# A% l* O) R( e5 T. K0 I; F- ?0 }' aSPI接口接口的输入/输出引脚定义:
$ k: l. c0 q& p7 i7 H  ^注:下列这些定义与硬件设计相关,如需改变控制的输入/输出引脚仅在此重新定义即可。
3 J6 Q& K$ v9 r; q  i# l: ^& M4 \0--A,1--B,2--C,3--D,4--E,5--F,6--G,7--H,8--I,9--J。
# D$ ?7 m, S" H7 \1 [0 h/ Z) }) A------------------------------------------------------------------------------------------------*/4 U8 E7 [3 i6 q3 X% M8 |3 d+ [* I
#if   (defined(PreMcuIs__AtMega64)  || defined(PreMcuIs__AtMega64A)  || \
& K: P- T4 y, A4 q+ M/ v       defined(PreMcuIs__AtMega128) || defined(PreMcuIs__AtMega128A) || \
! U( p" v; p. P8 R, ^       defined(PreMcuIs__AtMega162) || defined(PreMcuIs__AtMega162A)    )
  j( I. _2 A! B6 I6 z. T( a#elif (defined(PreMcuIs__STM8S207R6) || defined(PreMcuIs__STM8S208R6)  || \
7 W  S2 V% k& b5 l1 E" ~6 G       defined(PreMcuIs__STM8S207R8) || defined(PreMcuIs__STM8S208R8)  || \2 @: U- K8 o, T% C# g2 a* W0 H9 ^
       defined(PreMcuIs__STM8S207RB) || defined(PreMcuIs__STM8S208RB)     )
5 {4 \# t( u! J9 K4 n, _' p0 E#ifdef _USE_STM8_FWLIB_                                   // “使用 STM8 FWLib 的库文件”条件编译开始
& Z( F7 K4 g# j6 ?#define cSpi0Gpio             GPIOE
  @2 k  t, k% S/ e+ P1 k#define cSpi0SclPinBit        GPIO_PIN_1
1 G1 h; k9 Y/ E$ s# ]8 e" E. x5 N#define cSpi0SdaPinBit        GPIO_PIN_2
4 o$ s: I; W! }#else                                                     // “_USE_STM8_FWLIB_”1 a, j$ t5 i- @/ |
#define cDdrSpi0Mosi         P2DDR                       // SPI0主出/ 从入引脚的数据方向寄存器
" n, _+ X# V  H& Y' o#define cOdrSpi0Mosi         P2ODR                       // SPI0主出/ 从入引脚的输出数据寄存器
% T5 U, o7 ]6 _0 _#define cIdrSpi0Mosi         P2IDR                       // SPI0主出/ 从入引脚的输入数据寄存器& @$ |% E4 u! E) O3 x# O0 X0 g1 k
#define cPurSpi0Mosi         P2PUR                       // SPI0主出/ 从入引脚的上拉电阻寄存器(控制寄存器1)
4 r  X6 f1 h% C' [9 |! N9 M) ]. v5 K#define cCirSpi0Mosi         P2CIR                       // SPI0主出/ 从入引脚的控制中断寄存器(控制寄存器2)
, ]# E: D0 q/ N$ }# k7 I#define cPidSpi0Mosi         PI26                        // SPI0主出/ 从入引脚的引脚输入
0 }& A& z! G$ [1 _5 L, S#define cPodSpi0Mosi         PO26                        // SPI0主出/ 从入引脚的引脚输出
- \" ~! B8 @2 [- L#define cBitSpi0Mosi         BIT6                        // SPI0主出/ 从入引脚的引脚数字索引4 I7 l" F4 K1 E. D* L7 \: R- G
#define cDdrSpi0Miso         P2DDR                       // SPI0主入/ 从出引脚的数据方向寄存器
  G7 F& W! [' b#define cOdrSpi0Miso         P2ODR                       // SPI0主入/ 从出引脚的输出数据寄存器
7 F/ X8 |1 G- Z% m9 ]8 `; e8 ~! D#define cIdrSpi0Miso         P2IDR                       // SPI0主入/ 从出引脚的输入数据寄存器
0 F& ^# N0 S0 b3 X#define cPurSpi0Miso         P2PUR                       // SPI0主入/ 从出引脚的上拉电阻寄存器(控制寄存器1)
" T( c0 \9 [2 H  ]5 Z( O' n1 c8 E#define cCirSpi0Miso         P2CIR                       // SPI0主入/ 从出引脚的控制中断寄存器(控制寄存器2)
/ Y3 D' u4 W9 {1 v# a0 N( Y) N* P! P#define cPidSpi0Miso         PI27                        // SPI0主入/ 从出引脚的引脚输入
7 U: z5 V3 l3 m& o  T1 S#define cPodSpi0Miso         PO27                        // SPI0主入/ 从出引脚的引脚输出; F3 ^: a0 h8 C1 V) B4 k, z# o6 i
#define cBitSpi0Miso         BIT7                        // SPI0主入/ 从出引脚的引脚数字索引) |9 }3 f4 P' y, ~$ h8 J* {* \
#define cDdrSpi0Sclk         P2DDR                       // SPI0串行时钟引脚的数据方向寄存器% o8 H8 C; n5 w2 y0 `  s
#define cOdrSpi0Sclk         P2ODR                       // SPI0串行时钟引脚的输出数据寄存器
0 d9 V! c$ v. Q2 ~/ f#define cIdrSpi0Sclk         P2IDR                       // SPI0串行时钟引脚的输入数据寄存器
+ o" E% p9 Y0 y1 }/ e#define cPurSpi0Sclk         P2PUR                       // SPI0串行时钟引脚的上拉电阻寄存器(控制寄存器1)- t- g! A8 Z% ^- Q( S& S: C4 a
#define cCirSpi0Sclk         P2CIR                       // SPI0串行时钟引脚的控制中断寄存器(控制寄存器2)
  |* L" R0 ~. s9 w7 s( |#define cPidSpi0Sclk         PI25                        // SPI0串行时钟引脚的引脚输入
  c4 m3 B7 t6 U% t. C#define cPodSpi0Sclk         PO25                        // SPI0串行时钟引脚的引脚输出
, M5 a% w) O$ @8 ~  o0 W" y#define cBitSpi0Sclk         BIT5                        // SPI0串行时钟引脚的引脚数字索引
# ]( |& G0 }( K- X* a/ n7 C8 S#define cDdrHt1381Cs         P3DDR                       // SPI0 HT1381 片选引脚的数据方向寄存器
+ C! r9 p8 Y- Y, T#define cOdrHt1381Cs         P3ODR                       // SPI0 HT1381 片选引脚的输出数据寄存器
2 f8 ?# B" Z2 L% a- h1 z/ K7 ~0 ]- Q#define cIdrHt1381Cs         P3IDR                       // SPI0 HT1381 片选引脚的输入数据寄存器
  O$ N) W3 @! F  q8 ]# ^: A+ S) Z: U#define cPurHt1381Cs         P3PUR                       // SPI0 HT1381 片选引脚的上拉电阻寄存器(控制寄存器1)7 C  d. s; d7 I" w; q  O
#define cCirHt1381Cs         P3CIR                       // SPI0 HT1381 片选引脚的控制中断寄存器(控制寄存器2)5 ^% F5 `( A% ]2 h. C
#define cPidHt1381Cs         PI32                        // SPI0 HT1381 片选引脚的引脚输入, R0 x8 H( j: i) I$ x7 ^0 n
#define cPodHt1381Cs         PO32                        // SPI0 HT1381 片选引脚的引脚输出
3 E  b5 G7 e7 n8 G( o#define cBitHt1381Cs         BIT2                        // SPI0 HT1381 片选引脚的引脚数字索引7 S' \2 {& V  _0 E+ u* @+ Z& P0 B
#endif                                                    // “_USE_STM8_FWLIB_”. X. K% f( t9 M( S6 `: `
#else. M+ z- l- _' C9 o$ [
#error 错误:没有定义SPI接口接口的输入引脚端口!!!
) n! K9 y: b) @( R: @! J#endif                                                    // “PreMcuIs__......”
- |; B# W( \% U+ i( c: x/*------------------------------------------------------------------------------------------------
5 I2 q; b4 K3 X! p4 ]; eSPI接口收发数据缓冲区大小字符化定义:
2 U0 U% t7 c3 ^2 C3 U: t------------------------------------------------------------------------------------------------*/
. c0 c1 d/ {* H; n#define cSpi0BufSize          0x12                        // SPI接口接收和发送数据缓冲区大小* x4 @1 l) S: w1 D' T: e
//#endif                                                    // “PreGlobalCompilerHardware”
) l# G- p) x8 I5 z#ifdef PreCommSpiUseMultiSlaveMode                        // “SPI接口工作于多从机方式”条件编译结束1 g/ A* S6 j0 ~. p# M- V
#define cSpi0RxBufSize        (cSpi0BufSize + 1)          // SPI接口接收数据缓冲区大小
# K0 m1 {- ^" b, U#define cSpi0TxBufSize        (cSpi0BufSize + 2)          // SPI接口发送数据缓冲区大小- M8 H7 O7 k' D( Y* y
#else
' n  }' x* s( a. D" b#define cSpi0RxBufSize        (cSpi0BufSize + 0)          // SPI接口接收数据缓冲区大小
$ }5 q  K2 s; U7 @/ y' v. P#define cSpi0TxBufSize        (cSpi0BufSize + 1)          // SPI接口发送数据缓冲区大小: K5 n! d7 r, E! j
#endif. b6 K, n, H* X+ |  Z# b
//#ifndef PreGlobalCompilerHardware                         // 非“全局统一的条件编译控制和硬件定义”条件编译! W6 {$ N( [8 k5 E
#define cSpiErrorMax          0x10                        // SPI接口通讯收发作业最大发生错误次数值
0 u% n0 d1 `8 ]% u#define cSpiOverSec           0x08                        // 通讯任务超时时间的最大秒数值(8s)
9 W# F+ f( H8 x& D; S#define cSpiOverSpiOk         0x3A                        // 占用SPI接口超时时间的最大秒数值(58s)
$ V' G' l# s: N, Q4 u  R2 n//#endif                                                    // “PreGlobalCompilerHardware”
$ K8 s' _  z9 n8 c! B. ?- {#if   (defined(_IAR_EW_AVR_)). P: i9 L2 s' A2 @. Q
/*--------------------------------------------------------------------------------------
4 @4 k; W0 Q, Z9 ]# N# TSPI工作时的数据发送次序、时钟极性、时钟相位、SCK时钟速率配置定义:
8 z- V& |* Z: R5 k7 [- D! T7 X“DORD” ----- 数据发送次序,置位=数据的LSB首先发送;清位=数据的MSB首先发送。% y. k# a) s0 ?- v6 ]( \1 `
“CPOL” ----- 时钟极性,置位=空闲时SCK为高电平;清位=空闲时SCK为低电平。
: R! c) y8 B0 q* n% t: o& Y“CPHA” ----- 时钟相位,置位=在SCK的结束沿采样;清位=在SCK的起始沿采样。
8 Y' P5 K& ^3 K“SPR1、SPR0” ----- SCK时钟速率,00=1/4系统时钟频率;
0 F' a; b" \* }$ v& T9 O! A                                     01=1/16系统时钟频率;' E5 J2 ?, P/ u: M( t4 p
                                     10=1/64系统时钟频率;: W0 P: ?) b! j' M$ Q
                                     11=1/128系统时钟频率。) z8 |% c% V$ E
--------------------------------------------------------------------------------------*/
1 a0 q# ^  d+ i3 V// SPI配置寄存器的位屏蔽值$ P; }, N: F8 ^5 U
#define cSpiSpicrCfgMask      ((1<<DORD)|            \( _0 V7 H7 |6 I$ s6 h
                               (1<<CPOL)|(1<<CPHA)|  \# u% M! F  I% S, c+ A3 y
                               (1<<SPR1)|(1<<SPR0))+ \# L6 J# z' S, Z% D
#define cSpiSpicrConfig       ((1<<DORD)|            \
/ j3 u9 i% H) k; X  d! v* v                               (0<<CPOL)|(0<<CPHA)|  \: v  C0 V* V8 J5 z/ Y" L1 V
                               (0<<SPR1)|(1<<SPR0))4 O* A7 i0 H5 V. o6 T% f
#elif ((defined(_IAR_EW_MCS51_)) || (defined(_KEIL_UV_MCS51_)))) a7 j. G8 K" _" B5 `
#elif (   defined(_IAR_EW_STM8_) \
- _! `$ q9 A/ z4 M; X' R       || defined(_COSMIC_STM8_) )                        // “......_STM8 编译器”条件编译开始
7 e$ F3 s$ z1 O3 ?9 S. K#ifdef _USE_STM8_FWLIB_                                   // “使用 STM8 FWLib 的库文件”条件编译开始
8 |# {+ O: ~  g' J$ ^# m; Z: Q: l7 _#else                                                     // “_USE_STM8_FWLIB_”# J% ~' ^# r( T* M( C' O
/*------------------------------------------------------------------------------------------------
! S2 k" Z( N. `  s" a1 V! @SPI工作时的数据发送次序、时钟极性、时钟相位、SCK时钟速率配置定义:
6 H5 G% g2 |% W  l9 o/ s2 v' G“spiCPHA ” ----- 【DF】时钟相位控制位,0:数据锁存在第1个时钟沿,1:数据锁存在第2个时钟沿6 n! Q+ _: a7 D
“spiCPOL ” ----- 【LH】时钟空闲极性(仅主机模式有效),0:空闲时SCK为低电平,1:空闲时SCK为高电平。& E$ }  b7 S& {' ?7 f
“spiDORD ” ----- 【ML】发送数据次序,0:MSB首先发送,1:LSB首先发送0 R5 `/ q- Q3 L- Q% D! V0 h, l
“spiCS2、spiCS1、spiCS0” ----- SCK时钟速率,000~11=1/2~1/256系统时钟频率。5 A3 I: s6 I3 o1 @' F
------------------------------------------------------------------------------------------------*/6 J& r8 v7 i9 m( C. f
// SPI配置寄存器的位屏蔽值
1 h. o/ ~# \/ Q7 c% R% a#define cSpiSpicrCfgMask      ((u8)( ((1<<spiCPHA )|                             \7 k3 W* O0 c; x3 o7 N% X
                                      (1<<spiCPOL )|                             \- p  m! j2 I! q5 {  _
                                      (1<<spiCS0  )|(1<<spiCS1  )|(1<<spiCS2  )| \
7 L  {7 D+ ^8 }: P                                      (1<<spiDORD )                              )))# m% G3 `, _0 v3 r7 S4 A
// SPI配置=数据锁存在第1个时钟沿、空闲时SCK为低电平、LSB首先发送4 e, y* C% y8 X) J/ V
#define cSpiSpicrCfgDLL256    ((0<<spiCPHA )|                             \
7 ?! v% B" ~3 Z+ B( {, |                               (0<<spiCPOL )|                             \
' ~6 B3 f4 T& R: L( J- F5 u                               (1<<spiCS0  )|(1<<spiCS1  )|(1<<spiCS2  )| \
9 f' B, Y* P0 u% j5 D0 K. S7 J                               (1<<spiDORD )                              )
* s0 N+ X/ R- X2 u5 `: w#define cSpiSpicrCfgDLL016    ((0<<spiCPHA )|                             \
  m5 j, o* y1 i5 C: S                               (0<<spiCPOL )|                             \
9 R7 o0 d9 \- W. r                               (1<<spiCS0  )|(1<<spiCS1  )|(0<<spiCS2  )| \
; U) t3 |: n  h$ i                               (1<<spiDORD )                              )0 q  W7 \/ L, D. Y2 ~- x
#define cSpiSpicrCfgDLL032    ((0<<spiCPHA )|                             \' _4 [5 w. g8 E+ B; A9 y
                               (0<<spiCPOL )|                             \" b2 F  o& D8 P$ [! c
                               (0<<spiCS0  )|(0<<spiCS1  )|(1<<spiCS2  )| \
% b* d+ p9 y: Z5 l                               (1<<spiDORD )                              )
0 j% F4 A% o; P- [, l& H; Q/ \// SPI配置=数据锁存在第2个时钟沿、空闲时SCK为低电平、LSB首先发送' z# h' B; J; k( l& [+ |0 c( k& }
#define cSpiSpicrCfgFLL256    ((1<<spiCPHA )|                             \/ V, d0 n+ S- i! K  I& |
                               (0<<spiCPOL )|                             \
8 A. c$ r( S) m- X) A. H/ `: t                               (1<<spiCS0  )|(1<<spiCS1  )|(1<<spiCS2  )| \
- K: Q$ O, a2 t2 h% t                               (1<<spiDORD )                              )
( W, r/ W6 `% u5 E/ x" t: b// SPI配置=数据数据锁存在第1个时钟沿、空闲时SCK为高电平、LSB首先发送$ f. P/ h& i  ^* Y. [% _* M
#define cSpiSpicrCfgDHL256    ((0<<spiCPHA )|                             \
# o/ i7 `& S* C" m" B                               (1<<spiCPOL )|                             \
4 d8 e4 |7 m' M$ X8 u- X1 P                               (1<<spiCS0  )|(1<<spiCS1  )|(1<<spiCS2  )| \
* a1 y4 J: c1 F% g                               (1<<spiDORD )                              )
6 S( A! O! e( z* l- ~4 _1 L8 J// SPI配置=数据数据锁存在第2个时钟沿、空闲时SCK为高电平、LSB首先发送& x6 p; e6 E8 T7 C/ J
#define cSpiSpicrCfgFHL032    ((1<<spiCPHA )|                             \; B$ F. D: u5 E2 C
                               (1<<spiCPOL )|                             \0 R2 k$ T) U7 T
                               (0<<spiCS0  )|(0<<spiCS1  )|(1<<spiCS2  )| \
) O1 M' [4 m( j& ~( M# E) b! }" T                               (1<<spiDORD )                              )
, ^* G/ a$ z# e#endif                                                    // “_USE_STM8_FWLIB_”
- u/ m* i# U* @6 J) F# e7 M#else/ P* G8 H* q$ [/ E9 I
#error 错误:9 T: d+ `& Z8 G$ d
#endif                                                    // “PreMcuIs__......”% k: f3 [% P% R6 P% Y/ Q8 C6 F
/*------------------------------------------------------------------------------------------------
. L" W2 m( M9 @: C7 {5 v' C% DSPI接口CRC除数多项式值定义:2 U- s* N) X/ R: |
------------------------------------------------------------------------------------------------*/
1 j& O# I( O$ @9 X: P4 Q1 N#define cSpiCrcPolynomial     ((u8)( 0x8C))               // SPI的CRC除数多项式值
: K3 ?2 |5 N, x
. ?1 c* P6 R! q' S+ e7 |. j( k$ P6 v& |
赞 收藏 1 评论18 发布时间:2015-10-6 21:47

举报

18个回答
磊元lystudio 回答时间:2015-10-6 21:48:46
7 r3 \7 g% R: q
/*------------------------------------------------------------------------------------------------& H$ L& ?9 Z- ~& S  O+ _. j0 T
MFHSpiModSpiOnn( ) --------- 使能SPI接口模块
9 o* t, C! _/ J, I: U3 m& B8 R9 MMFHSpiModSpiOff( ) --------- 禁止SPI接口模块2 D, Y" {9 k* N1 q: r" `) w
MFHSpiModClkOnn( ) --------- 使能SPI接口模块外设时钟
% L* K; X: }3 \9 ~$ M. ^# L! b+ LMFHSpiModClkOff( ) --------- 禁止SPI接口模块外设时钟! [6 d8 l- ]8 |% ]. F
MFHSpiFlgAllClr( ) --------- 清0SPI接口全部中断标志位( e1 `- J/ ?4 u2 j1 |0 n, u: ^+ @! y
MFHSpiIntAllClr( ) --------- 进入中断后,在中断句柄中,清0SPI接口全部中断标志位(在中断服务程序中), o, B4 ~& i" ?$ M
MFHSpiIntErrChk( ) --------- 检查SPI接口错误中断状态值! O' O" f8 O; r
MFHSpiIntWufChk( ) --------- 检查SPI接口唤醒中断状态值9 {  v  w! _0 ]- w7 Q- v+ I
MFHSpiIntAllOnn( ) --------- 使能SPI接口事件全部中断- g, d$ n) Z5 e& c) [  y% {
MFHSpiIntTxdOnn( ) --------- 使能SPI接口发送中断、错误中断
  e- f& f: a& {2 b3 iMFHSpiIntRxdOnn( ) --------- 使能SPI接口接收中断、错误中断" v& B& r1 n' e8 |9 ?
MFHSpiIntAllOff( ) --------- 禁止SPI接口事件全部中断
! y9 q4 ~6 R7 U; L# H3 R& O( f------------------------------------------------------------------------------------------------*/
/ V7 m% O- S+ J/ }* e  _! V#if   (defined(_IAR_EW_AVR_))
3 R+ _2 ~! i5 p' j" p0 A' ^
% U* i0 x$ y# j  X/ X  Y#elif ((defined(_IAR_EW_MCS51_)) || (defined(_KEIL_UV_MCS51_)))* A6 i3 t" a1 a3 Z( o
; U2 c! P2 `6 G4 ]) g4 r# m
#elif (   defined(_IAR_EW_STM8_) \
6 V# m, M. l! L       || defined(_COSMIC_STM8_) )                        // “......_STM8 编译器”条件编译开始  c. f2 j) X7 h0 [2 |9 k: l% p* P
#ifdef _USE_STM8_FWLIB_                                   // “使用 STM8 FWLib 的库文件”条件编译开始
! V1 \( {6 _5 P7 n
0 f0 {2 X& [$ j2 q- ]1 n0 Q6 V- @( Z#else                                                     // “_USE_STM8_FWLIB_”
# y$ [. B+ j7 R/ B" V, N#define MFHSpiModSpiOnn( )            SPICR1                       |= (u8)( ((1<<spiEN   )))            ;
' m7 Z# l4 H& I! ?2 L; c7 i// 因为SPI接口模块被停止,无法控制SCK引脚电平
- [& b* X7 O" ~1 ]#define MFHSpiModSpiOff( )            SPICR1                       &= (u8)(~((1<<spiEN   )))            ; \
$ K% p2 g5 A$ y+ \  o$ P8 P                                      if (SPICR1 & (u8)( ((1<<spiCPOL ))))                                \8 |3 q! Q! {3 {4 T: s3 k: ^6 t- J
                                      {                                                                   \
1 {0 P" f1 L$ l7 C6 X$ f' D                                        MFH_PIN_OUT_SETH_SpiSclk;                                         \
8 S3 o; s: e1 U) F' g                                      }                                                                   \4 m) q. B  n7 j, W2 S- k
                                      else                                                                \
0 l; J5 j  j8 L- J                                      {                                                                   \8 Q: t: _9 l) f6 h' l% Y
                                        MFH_PIN_OUT_CLRL_SpiSclk;                                         \
; b+ c3 c; ~, x( g1 v" g0 d0 C                                      }
# h+ q5 u$ F0 q2 z, F: w#define MFHSpiModClkOnn( )            CLKPECR1                     |= (u8)( ((1<<clkSPI  )))            ;% \, m: F5 r8 ~) ]- {* z6 X" l$ W, o
#define MFHSpiModClkOff( )            CLKPECR1                     &= (u8)(~((1<<clkSPI  )))            ;, u' l, Y5 _. o! U" q
#define MFHSpiFlgAllClr( )            SPISR                         = (u8)( ((0<<spiRXNE )|               \
: ~1 g. Z0 F% E+ P                                                                             (0<<spiDRE  )|               \
7 E3 s9 e% T8 d9 l, P6 k/ |                                                                             (0<<spiWUF  )|(0<<spiCRCEF)| \$ n2 M6 L! L$ L# W0 `
                                                                             (0<<spiMODF )|(0<<spiOVF  )| \
2 w4 u' r( r5 O& s0 ~( h7 f7 I                                                                             (0<<spiBSY  ) ));
4 I7 E' r# x; r, P- l' F5 n; O#define MFHSpiIntAllClr( )            SPISR                         = (u8)( ((0<<spiRXNE )|               \
5 P; P# B7 n- V5 \" B                                                                             (0<<spiDRE  )|               \
9 d) p* ]# d1 H. _$ [9 r5 E                                                                             (0<<spiWUF  )|(0<<spiCRCEF)| \
( Y$ J7 d) o( s7 G9 U9 M) Z6 g" @- l* i                                                                             (0<<spiMODF )|(0<<spiOVF  )| \
9 z; I+ E& [2 K8 P9 Q                                                                             (0<<spiBSY  ) ));
9 o, ^- j4 t5 g; W; U' L#define MFHSpiIntErrChk( )            SPISR & (u8)( ((1<<spiCRCEF)|               \
# x3 ]* {0 e* ~( X3 r' ]                                                     (1<<spiMODF )|(1<<spiOVF  )) )4 N7 [! `0 r1 W
#define MFHSpiIntWufChk( )            SPISR & (u8)( ((1<<spiWUF  )               ) )$ U7 ^$ U: D! x( `
#define MFHSpiIntAllOnn( )            SPIICR                        = (u8)( ((1<<spiWUIE )|(1<<spiERRIE)| \
7 j5 I0 Q! h# Y' @- u1 r                                                                             (1<<spiRXIE )|               \
, c8 X. \3 {+ j# G                                                                             (1<<spiTXIE ) )              );
2 B7 p4 w; D9 T' o#define MFHSpiIntTxdOnn( )            SPIICR                        = (u8)( ((0<<spiWUIE )|(1<<spiERRIE)| \, |: k+ X6 a* v0 A, x, R0 ~) {
                                                                             (0<<spiRXIE )|               \
% f3 _% F/ J) u9 X3 R4 P: R                                                                             (1<<spiTXIE ) )              );
1 F2 H5 t" N4 d8 E# t#define MFHSpiIntRxdOnn( )            SPIICR                        = (u8)( ((0<<spiWUIE )|(1<<spiERRIE)| \& V1 U& G. |' F" D' H& y. N
                                                                             (1<<spiRXIE )|               \
7 H( t" N: ?* H$ c- V! U                                                                             (0<<spiTXIE ) )              );; }' \# ~8 u* Q* X* @5 |# ^$ A
#define MFHSpiIntAllOff( )            SPIICR                        = (u8)( ((0<<spiWUIE )|(0<<spiERRIE)| \
4 z0 h6 f; Z- a7 y$ |$ ^1 o" W                                                                             (0<<spiRXIE )|               \" G& R' [+ r3 v( w
                                                                             (0<<spiTXIE ) )              );
- D* U6 P6 _' A1 t9 }+ }# M: A#endif                                                    // “_USE_STM8_FWLIB_”, D" F6 O  T2 M2 |
#else
' D! Q( V/ U; H; B, A: k- N#error 错误:- }5 I4 c0 W) j
#endif                                                    // “PreMcuIs__......”
* b; R& R1 O. |5 I  _0 i" f
" ?/ s9 c" r) I: k# `7 q1 D) s) ^5 ^
# @8 `$ R2 N% ^. r' ^9 }" j
" c; v6 H: A" Y+ d: j  ^
/*
$ t- m" P6 Q, a************************************************************************************************************
0 r: Z0 G( d* B2 q3 Q+ s                       程序指令代码清单8 i/ w% w1 R2 G" ?8 l
************************************************************************************************************
( K/ t8 W4 O* n- a*/* `: Z& u) s% c2 B
/*==========================================================================================================
4 e3 \3 j! D. d% p2 e函数名称:  串行外设接口(SPI接口),使用中断方式接收和发送数据通信的初始化1 w( {3 E' K$ y* L7 t
函数功能:  本函数用于串行外设接口(SPI接口),使用中断方式接收和发送数据通信的初始化操作。
  v( l1 j; P9 Q" _; A/ l$ {" }+ X函数入口参数:没有# L, _- T- i8 J9 L" |
函数返回值: 没有$ t* T) ~9 i4 _5 S  ^
调用函数:  1.3 U2 {+ N( V5 T. X: P/ m
备注:        1.本函数仅在主函数中调用一次即可。- p  I5 ^8 h6 z" \7 R/ S5 b4 M" f
==========================================================================================================*/
9 s5 O/ k3 e# l) jvoid  CommSpiInit (void)
  A: w! q- M/ N( p% m; K, p{# W2 A) i/ u; t0 I! z# Z
  CommSpiDataStru           *pSpi;                        // 指向SPI接口通讯收发数据处理变量的指针" X; M) a7 Y  ~# w; [

; q) N1 u1 D9 d- ^  pSpi                      = &gstvSpi;                   // 取SPI接口通讯收发数据处理变量的首个地址
2 N/ R2 ^5 ]% f; `, f( n#ifdef PreCommSpiUseSingleMasterMode                      // “SPI接口工作于单主机方式”的条件编译" c$ j8 D0 ~* \  J! t) \4 T
/*------------------------------------------------------------------------------------------------5 t) h9 I0 z* u5 r* ?
“SPI接口工作于主机方式”的初始化操作。& E4 d4 Q: M7 k
------------------------------------------------------------------------------------------------*/
' j- {" I/ M4 x  MFH_PIN_CFG_OUTL_SpiMosi;                               // 设置SPI主出/ 从入引脚为输出引脚,并为L电平# {4 }: c1 V  E$ g+ z
  MFH_PIN_CFG_INPU_SpiMiso;                               // 设置SPI主入/ 从出引脚为输入引脚,并使能上拉电阻
2 X* z9 |" @3 o7 c6 @' U$ W  MFH_PIN_CFG_OUTL_SpiSclk;                               // 设置SPI串行时钟引脚为输出引脚,并确保为L电平(没有操作时)
: h% c. g7 p4 |1 ^  MFH_PIN_CFG_OUTL_Ht1381Cs;                              // 设置SPI HT1381 片选引脚为输出引脚,并为L电平(禁止)
. t1 {. v& v# K3 Z! H5 J#if   (defined(_IAR_EW_AVR_))
" l, v6 o: p4 N4 {  SPCR = (0<<SPIE)|(1<<SPE)|                              // 禁止SPI中断、SPI使能、+ {  d; g& H8 b0 I$ W' O: B
         (1<<MSTR)|                                       // 主机模式、5 n) O5 h7 V  v+ G6 `2 i0 n
         + cSpiSpicrConfig;                               // 数据次序、时钟极性、时钟相位、SCK速率。3 O9 Z9 |9 C. I
  SPSR = 0x00;                                            // 清除SPI速度加倍4 \7 g( E7 [0 i" a# {9 B7 K- [4 K
  temp = SPSR;                                            // 通过先读 SPSR,紧接着访问 SPDR 来清零SPI
4 X7 X/ i& z* ?! \& `: s) M  temp = SPDR;                                            // 中断标志和写冲突标志,使SPI空闲
, K; q4 r- U# [6 r/ @8 A  SFIOR &= ~(1<<PUD) ;                                    // 使能所有I/O端口的上拉电阻
( n- m6 k8 h" i1 y6 f1 M#elif ((defined(_IAR_EW_MCS51_)) || (defined(_KEIL_UV_MCS51_)))
3 q6 a/ t) d$ a6 U& `5 P
& D' z! f7 R7 ]2 \9 b8 B- ~#elif (   defined(_IAR_EW_STM8_) \
9 u  y  V) g+ S3 B3 S2 Y       || defined(_COSMIC_STM8_) )                        // “......_STM8 编译器”条件编译开始+ G. N8 B. C, p
#ifdef _USE_STM8_FWLIB_                                   // “使用 STM8 FWLib 的库文件”条件编译开始
( R( Q3 W" J( |' x1 ^+ }: N9 T8 ?) `  I2C_Cmd(ENABLE);1 u0 v1 k# ]+ @8 J
  I2C_Init(cSpi0BaudRate, cSpiOwnAddr, I2C_DUTYCYCLE_2, I2C_ACK_CURR, I2C_ADDMODE_7BIT, (cSysCpuClk / 1000000UL));- q& r2 K3 {$ F$ @
  I2C_ITConfig((I2C_IT_ERR | I2C_IT_EVT | I2C_IT_BUF), ENABLE);
; J+ L' b4 T, Y1 R#else                                                     // “_USE_STM8_FWLIB_”$ M3 R0 x! c3 w# k/ `' H. P$ q
//  SpiDeInit( );& S: h  m: `. M5 C: E/ J
  SPICR1          = (u8)( ((1<<spiMSTR )|                 // 主/从机模式=主机,
6 ?2 V- O6 }8 w% H* [0 D8 ^                           (0<<spiEN   )|                 // 禁止SPI接口模块,
( s# F3 g/ U8 s; j( C                           cSpiSpicrCfgDLL256));          // SPI配置=数据锁存在第1个时钟沿、空闲时SCK为低电平、LSB首先发送# Q5 ]6 A" F& [; W+ Z% K
  SPICR2          = (u8)( ((1<<spiSSI  )|(1<<spiSSM  )|   // 内部从设备=主模式,使能软件从机设备管理
' c2 J6 x4 Z4 S2 Q0 J3 ?3 q5 [: m9 [                           (0<<spiRXTX )|                 // 只接收,0:全双工(同时发送和接收),1:输出禁止(只接收)
: W& ]% o1 s7 q4 B                           (0<<spiCRCTX)|(0<<spiCRCEN)|   // 下一个发送的数据来自Tx缓冲区,禁止硬件CRC计算0 i  C. D4 P/ o4 f4 P% Y4 u' f) S
                           (0<<spiBDOE )|(1<<spiBDM  ) ));// 禁止双向模式下输出,使能单线双向数据模式2 W. R  Y0 j( i0 C. ^' ~$ [
  SPICRCPR        = (u8)( cSpiCrcPolynomial);             // 置SPICRC多项式寄存器的数值
2 g; `* g2 R1 [7 x5 u7 `! T  SPIICR          = (u8)( ((0<<spiWUIE )|(0<<spiERRIE)|   // 禁止唤醒中断,禁止错误中断
& M; e7 _0 z$ S! M' I                           (0<<spiRXIE )|                 // 禁止接收中断( R: _6 g& p! t. K: h5 l7 W
                           (0<<spiTXIE) ));               // 禁止发送中断
8 r, q& k# q  a/ w#endif                                                    // “_USE_STM8_FWLIB_”
& `- _2 u9 e  b" ^#else
0 k8 S6 ^( h/ o9 V& g# O#error 错误:. b' i. p" y+ S9 a2 ^* |
#endif                                                    // “PreMcuIs__......”
% z/ M2 p( n. O) }) j#endif                                                    // “PreCommSpiUseSingleMasterMode”
4 T8 E4 @1 W3 C7 z#if defined(PreCommSpiUseSingleSlaveMode) || defined(PreCommSpiUseMultiSlaveMode)$ c- b0 j% X( P9 {" {
                                                          // “SPI接口工作于从机方式”的条件编译
! f* i1 M2 h! }/*------------------------------------------------------------------------------------------------; K- M& K- p7 M/ ?$ a( X+ |
“SPI接口工作于从机方式”的初始化操作。9 A) p0 e6 V1 q+ d* D, Z/ ~# O
------------------------------------------------------------------------------------------------*/
# }9 v1 j! O% T7 }* I3 }' c  MFH_PIN_CFG_INHZ_SpiMosi;                               // 设置SPI主出/ 从入引脚为输入引脚,并为高阻输入态1 ~2 }+ u, s" r5 ]% u/ j
  MFH_PIN_CFG_OUTL_SpiMiso;                               // 设置SPI主入/ 从出引脚为输出引脚,并为L电平
4 }4 u% w! o& H  MFH_PIN_CFG_INHZ_SpiSclk;                               // 设置SPI串行时钟引脚为输入引脚,并使能上拉电阻6 z/ p5 D. p! P* g! I$ Z
  MFH_PIN_CFG_INPU_Ht1381Cs;                              // 设置SPI HT1381 片选引脚为输入引脚,并使能上拉电阻; l# w% S0 J0 f7 t. G! V1 i
#if   (defined(_IAR_EW_AVR_))* j8 O; y) t9 W" H# _0 }( {6 m3 c. o
  SPCR = (1<<SPIE)|(1<<SPE)|                              // SPI中断使能、SPI使能、0 Q! @3 E5 G( X' ~2 k
         (0<<MSTR)|                                       // 从机模式、
  {7 _2 X1 Q" E; p0 [+ _         + cSpiSpicrConfig;                               // 数据次序、时钟极性、时钟相位、SCK速率。* \% t% F* O/ u% n; y2 i& S' ]; X
  SPSR = 0x00;                                            // 清除SPI速度加倍
; V% U  {# L# c9 U0 ?  temp = SPSR;                                            // 通过先读 SPSR,紧接着访问 SPDR 来清零SPI. L. F8 m% }- D! J
  temp = SPDR;                                            // 中断标志和写冲突标志,使SPI空闲9 K; r6 `5 C+ c6 x
#elif ((defined(_IAR_EW_MCS51_)) || (defined(_KEIL_UV_MCS51_)))' |! }( _  N5 t

, E% H# Q# D4 ~( `# w#elif (   defined(_IAR_EW_STM8_) \
  p7 e: C8 \" B: V# q" e       || defined(_COSMIC_STM8_) )                        // “......_STM8 编译器”条件编译开始
1 j/ k. E0 A: `9 j* T3 k& d6 B' Y#ifdef _USE_STM8_FWLIB_                                   // “使用 STM8 FWLib 的库文件”条件编译开始6 [4 z' U0 {1 X5 n3 @% o
  I2C_Cmd(ENABLE);
. ?, x; j# s6 Y2 h% _% n$ L  U7 g  I2C_Init(cSpi0BaudRate, cSpiOwnAddr, I2C_DUTYCYCLE_2, I2C_ACK_CURR, I2C_ADDMODE_7BIT, (cSysCpuClk / 1000000UL));
5 k1 H4 |, v# |$ P  I2C_ITConfig((I2C_IT_ERR | I2C_IT_EVT | I2C_IT_BUF), ENABLE);+ S+ J: L: C# o3 z2 Z: g
#else                                                     // “_USE_STM8_FWLIB_”# P+ q. o2 y2 D; _$ M3 h
  SpiDeInit( );" E( X5 z* {: C
  SPICR1          = (u8)( ((0<<spiMSTR )|                 // 主/从机模式=从机,' W6 P6 {5 U0 f; m
                           (0<<spiEN   )|                 // 禁止SPI接口模块,& `( o" m5 D8 a3 r% |
                           cSpiSpicrCfgDLL256));          // SPI配置=数据锁存在第1个时钟沿、空闲时SCK为低电平、LSB首先发送
$ D1 W( u& |2 d3 ^% L  SPICR2          = (u8)( ((1<<spiSSI  )|(1<<spiSSM  )|   // 内部从设备=主模式,使能软件从机设备管理
+ X3 i7 K" V* \0 ?) w0 m                           (0<<spiRXTX )|                 // 只接收,0:全双工(同时发送和接收),1:输出禁止(只接收)
; N& V- ^4 g7 S5 k  j$ e                           (0<<spiCRCTX)|(0<<spiCRCEN)|   // 下一个发送的数据来自Tx缓冲区,禁止硬件CRC计算
1 y" F' {/ q5 s/ C                           (0<<spiBDOE )|(1<<spiBDM  ) ));// 禁止双向模式下输出,使能单线双向数据模式
5 @/ Z  l' t, i& s% j" o  SPICRCPR        = (u8)( cSpiCrcPolynomial);             // 置SPICRC多项式寄存器的数值% I* m/ t8 I: Z2 |9 k. V5 @
  SPIICR          = (u8)( ((0<<spiWUIE )|(0<<spiERRIE)|   // 禁止唤醒中断,禁止错误中断
5 y( o+ e2 e7 P- Y8 U" B                           (1<<spiRXIE )|                 // 使能接收中断
: `5 j2 P# Y" w- c% v" e/ B) N                           (0<<spiTXIE) ));               // 禁止发送中断
. W$ ^  n+ D% {% ]; E4 \#endif                                                    // “_USE_STM8_FWLIB_”" b# d/ U4 F; i, y' p: m0 d; r& ]5 y9 Y
#else7 o4 c. s9 E' `. Y; H  ]
#error 错误:
% b* k/ Z) v3 y1 A% ]- ?( i0 Z#endif                                                    // “PreMcuIs__......”) z7 e& ]8 K/ `0 u( P9 Y
#endif                                                    // “PreCommSpiUse......SlaveMode”( y. f2 G6 P/ i4 R% r
/*------------------------------------------------------------------------------------------------  C0 d; @" F, Z
初始化各个标志位# w- w, V! j. d% S6 r  W7 l
------------------------------------------------------------------------------------------------*/
% c/ q, r% B3 q( b  gbitSpi.Busy              =  CLEAR;                     // 清除“SPI接口〖忙〗”标志
0 R: T( q( j' B( ~" [  gbitSpi.RxOk              =  CLEAR;                     // 清除“接收数据缓冲区己更新”标志
# h7 C8 F: b1 t" A, ?0 K6 v  gbitSpi.RxOvf             =  CLEAR;                     // 清除“接收数据缓冲区溢出”标志7 [7 q& Y7 m( @  n- _$ M8 a. l
  gbitSpi.Error             =  CLEAR;                     // 清除“通讯收发作业发生错误”标志
5 E' s, k) e' p/ O  gbitSpi.Txd               =  CLEAR;                     // 清除“正在进行发送数据作业”标志4 k4 q/ j9 w2 J6 Z$ T/ G% [
  gbitSpi.TxRdy             =  CLEAR;                     // 清除“发送数据作业准备结束标志”标志8 k$ }$ o/ Z! k5 p
  gbitSpi.OverS             =  CLEAR;                     // 清除“通讯任务时间超时”标志! e3 ]- P* S0 L' r4 [. ?
  gbitSpi.SpiOk             =  CLEAR;                     // 清除“占用SPI接口”标志% n8 O) N1 B. n2 u% f5 ?; t

8 i/ S# R! L& L  N; c( Z  // 初始化SPI接口通讯收发数据处理变量
$ V6 G, j+ W; A1 L5 G  MemClearSram(pSpi, sizeof(CommSpiDataStru));: @6 i. B$ N% i1 y
}
磊元lystudio 回答时间:2015-10-6 21:50:21
1 |6 I1 o7 q' {' k9 c/ y! L
/*==========================================================================================================& D# `' z7 l0 g9 f) `- N# Q
函数名称:  SPI接口工作于单主机方式,使用中断进行接收和发送数据的中断服务程序。
9 w6 g3 G( p. I+ K8 u函数功能:  本函数用于SPI接口工作于单主机方式,使用中断进行接收和发送数据的中断服务程序。
, c& f# W% ]+ l6 v$ W函数入口参数:gbitSpi.Rxd ------------- “正在进行接收数据作业”标志。
, }& R# z$ ^' r- c6 }7 K       gstvSpi.TxSize ---------- 每次发送数据个数大小变量。0 v- d9 O6 J" D* j: c
       gstvSpi.TxCnt ----------- 每次发送数据个数计数器变量。0 N# s8 u  e" x, s3 Z+ S
       gstvSpi.TxBuf[] --------- 每次发送数据缓冲区数组变量。
: x5 E9 j7 Q1 U) L9 M              gstvSpi.RxSize ---------- 每次接收数据个数大小变量。3 z4 Z# t, ?- R4 M
函数返回值: 没有
2 p7 S+ L# f7 ?4 D函数出口参数:gbitSpi.Busy ------------ SPI接口〖忙〗,出口值=清位(可能)。) I; d) ?+ r$ h  y* I# @
              gbitSpi.Error ----------- 通讯收发作业发生错误,出口值=置位(可能)。
1 y, t; V+ N" n6 i       gstvSpi.TxCnt ----------- 每次发送数据个数计数器变量,出口值=gstvSpi.TxCnt。1 y* u9 c; ^2 p' N. c6 \( {/ l! T' _
              gstvSpi.RxCnt ----------- 每次接收数据个数计数器变量,出口值=gstvSpi.RxSize。
- r$ O5 T, R/ o              gstvSpi.RxBuf[] --------- 每次接收数据缓冲区变量,出口值=从SPI接口上接收到的数据。
" i$ k# V) [" P7 z( ~0 z! l调用函数:  1.
7 @# ]1 g3 S0 ~; W备注:        1.注意:本函数需在SPI接口中断请求的中断向量函数中调用。1 @, k; U$ i6 A: V  w( d
                     在调用之前需对该中断向量进行初始化,使能该中断。
" Q  Z, x, m3 T. [       2.全部完成通讯收发作业后,本函数将禁止SPI接口中断。
- W6 j0 k2 v* P' K: M1 w  e==========================================================================================================*/# c' }" K- Z0 n5 q+ D5 B
#if   (   defined(_IAR_EW_AVR_)   \. W( _! w2 x/ a# B, A1 ~
       || defined(_IAR_EW_STM8_)  )3 c7 t1 }3 o8 B$ V* W
#pragma vector = int_SPI_vector
6 {4 Q4 V" r/ o- ?* n# KINTERRUPT_KEY void  CommSpi_isr (void)* M# \  v. c# v7 G- _% e
#elif (defined(_KEIL_UV_MCS51_) )- R  e( T% r: l% F0 k- |
void  CommSpi_isr (void) INTERRUPT_KEY int_SPI_vector using 0! V+ s: X- [# n7 B. ~, o
#elif (   defined(_COSMIC_STM8_)  )
* J9 B0 j$ J& H4 d: ^5 t: TINTERRUPT_KEY void  CommSpi_isr (void)3 y; f: c. Q7 w. C" [- x( {
#else
: @& e# i; Q3 n1 p  ^' Evoid CommSpiIsr(void);
3 `6 [2 R3 X# P  u#endif                                                    // “_IAR_EW_......”
# N% x: c+ o3 S  n/ {. i#if   (defined(_IAR_EW_AVR_))
7 x5 n, [4 i7 u
" N0 J7 U# W5 m0 O; C6 h  u# c#elif ((defined(_IAR_EW_MCS51_)) || (defined(_KEIL_UV_MCS51_)))
9 W7 P& J/ o' c  S8 N6 }% K# s9 K$ E( C+ V, W4 s
#elif (   defined(_IAR_EW_STM8_) \6 g0 `* O0 h7 K7 L0 _
       || defined(_COSMIC_STM8_) )                        // “......_STM8 编译器”条件编译开始- i, G3 k* {# m- z
{" ^7 x- P; Y8 x0 w/ N! H$ z
#if ((cSpiTxBufSize < 256) && (cSpiRxBufSize < 256))
: R" w5 M, _- ], l* Q9 I  register unsigned char    cnt;                          // USART每次发送数据个数计数器变量
' {: H! Q/ l$ N" K: S#else) d' R% y: u% m1 `
  register unsigned int     cnt;8 k% S. g; V( B' p
#endif
0 B5 k) k( p% T$ P8 ]/ ~# {. q  CommSpiDataStru           *pSpi;                        // 指向SPI接口通讯收发数据处理变量的指针! a# d  q0 k' d. N0 I9 |

; _6 R8 z9 k- e4 l9 X  if (MFHSpiIntErrChk( ))                                 // 检查SPI接口是否存在错误?# l( r# P; Q3 s3 B& a. k  ?# ]
  {
! j! I1 g7 O2 O" V9 c2 q0 O2 m    MFHSpiModSpiOff( );                                   // 禁止SPI接口模块
) Q! r+ [' F* _3 o4 `    MFHSpiIntAllClr( );                                   // 进入中断后,在中断句柄中,清0SPI接口全部中断标志位(在中断服务程序中)) h# \' C8 C' q3 x+ D5 K
    MFHSpiIntAllOff( );                                   // 禁止SPI接口事件全部中断
% s# z: O4 b) q8 H. w2 l2 i    gbitSpi.Error           =  SET;                       // 置“通讯收发作业发生错误”标志
. O1 k/ K0 A: ~# J; U  }
% n9 |) H% x, W% M' a+ r  else                                                    // SPI接口没有错误
. x. x! q. L3 ~4 k  {
+ U" y6 Y# N6 @    pSpi                    = &gstvSpi;                   // 取SPI接口通讯收发数据处理变量的首个地址' G1 T- b5 m0 i8 p- Q& @
    if (gbitSpi.Txd == SET)                               // SPI接口是否正在进行发送数据作业?
; E% B9 n* _/ n0 w. b    {6 `" L! t: O5 \4 O- a$ A8 ]
      cnt                   =  pSpi->TxCnt;               // 取SPI接口每次发送数据个数计数器变量
3 w7 C! ~' C5 @! u! a      if (cnt >= pSpi->TxSize)                            // 检查是否己完成发送通讯任务的全部数据?5 Z. w. }" I+ Q: R7 S
      {' I0 e$ T$ f  W0 X6 m
        // 不能在中断中等待,直至发送通讯作业全部完成后,才可以禁止SPI接口模块7 z5 `! k+ ?8 @7 h7 T$ c, ]6 ]. F
        gbitSpi.TxRdy       =  SET;                       // 置“发送数据作业准备结束标志”标志
& ?; i8 a4 f% J" v! x) ?        MFHSpiIntAllClr( );                               // 进入中断后,在中断句柄中,清0SPI接口全部中断标志位(在中断服务程序中)
8 ]7 a; Q% F4 U        MFHSpiIntAllOff( );                               // 禁止SPI接口事件全部中断
$ X9 q" ^5 X; x1 ~6 G6 e; u; c+ C      }, m1 }4 s2 Z; O3 u) a
      else
6 r  r$ ~# N; S; `7 q( K' k      {
" T" o0 g8 g" x, [4 K9 {  ~( ~) N9 F" t        SPIDR               =  pSpi->TxBuf[cnt];          // 从发送缓冲区中将发送数据写入到SPI接口
4 F/ X( H: k2 o( O1 |& N& s, |        cnt++;                                            // SPI接口每次发送数据个数计数器+1' T9 e) I$ h* |9 j$ ~
        pSpi->TxCnt         =  cnt;                       // 返回SPI接口每次发送数据个数计数器值
" d2 p; B, R) f1 V        MFHSpiIntAllClr( );                               // 进入中断后,在中断句柄中,清0SPI接口全部中断标志位(在中断服务程序中)
: c% ^" S. |1 D1 ~/ O& [      }2 a$ y1 G- d) x8 Y' Q
    }  W& k5 b/ |) e+ J% G4 s
    else# L8 a  r2 q3 Q' A4 Q  H
    {
0 x1 l8 y& n  I* }# }4 Q2 c% v% q      cnt                   =  pSpi->RxCnt;               // 取SPI接口每次接收数据个数计数器变量
, I7 B/ w' s+ v- c# c      pSpi->RxBuf[cnt]      =  SPIDR;                     // 复制SPI接口读取到的字节到接收数据缓冲区中6 e+ p' k. t1 ]/ [
      cnt++;                                              // SPI接口每次接收数据个数计数器+1
1 F0 j4 [  S* S+ y7 {) G      pSpi->RxCnt           =  cnt;                       // 返回SPI接口每次接收数据个数计数器值- o, h/ E# z0 W6 z
      MFHSpiIntAllClr( );                                 // 进入中断后,在中断句柄中,清0SPI接口全部中断标志位(在中断服务程序中), m' W, M' a7 ~5 y
      if      (cnt >= pSpi->RxSize)                       // 检查是否完成需要读取的数据长度?
# O, X" q0 `- E! d* `3 ~# h8 ^      {
: b5 ~  l! m- a# m/ H7 q        MFHSpiModSpiOff( );                               // 禁止SPI接口模块
5 L$ I& ]7 H& B        MFHSpiIntAllOff( );                               // 禁止SPI接口事件全部中断
" z$ t" C3 F5 [3 U4 g& e        gbitSpi.Busy        =  CLEAR;                     // 清除“SPI接口〖忙〗”标志
* a0 q1 u6 q; ?/ B        gbitSpi.OverS       =  CLEAR;                     // 清除“通讯任务时间超时”标志
6 N* H* _. b$ P6 O* Z) M      }1 m4 \5 y5 ~) q/ n1 A( p+ d+ D
    }
& H6 W1 ^( A1 f, i* k  }
& ~1 r. Y' I( z2 g
/ u" M4 t/ X- j+ w) X" X  INTERRUPT_RETURN( );( V* ~/ m/ \. l7 A6 D1 ?0 \$ I
}
9 X" ~% y( x$ r#else* q& f/ H! f; d" m: ^
#error 错误:
9 _. H( _' Y& p( l* L# j% n, A9 Q6 b#endif                                                    // “PreMcuIs__......”) p* C! ^7 h) y
! k8 c3 o9 r' @- W  v
6 g, H" J" p' z
/*==========================================================================================================5 R: t- {2 @* w; F
函数功能:    本函数是用于SPI接口工作于单主机方式,在SPI接口的前一次通讯收发作业发生
6 s; p) V5 I+ I% t- j" e              失败时的处理操作函数。# y' P/ i! E8 M2 Y2 Q
§.本函数将在函数体中隐式调用下面这些相当于入口参数的全局变量和局部静态变量:
# P$ _3 T+ G9 H5 r入口静态变量:sign:TRANS_ERROR --------------- SPI接口通讯收发作业发生错误标志变量。
4 q8 h% e% B+ Q5 J              gstvSpi0.Cycle ----------------- SPI接口的重新启动通讯收发作业发生错误次7 R+ j8 w3 j7 L( _+ {& `! _3 T6 |
                                                数值变量。
$ N4 ]8 S" p! {% G! r§.本函数将在函数体中隐式修改下面这些相当于出口参数的全局变量和局部静态变量:6 P1 F" f+ ~5 _! J
出口全局变量:sys_error_type:SYS_ERROR_TYPE_IS_GENERAL ----- 【普通】错误类型的位操作值; x; \* x4 b) O) j/ f% K
                                                标志,出口值=置位(仅在重新启动收发作业
7 O! M+ G4 R# W2 o" o' m                                                错误次数大于最大值时,才会置此变量值)。
, \3 v1 J7 R# _. K: @0 ]- \              sys_error_value ----------------- 系统运行中产生各种错误类型的错误代码数值变量
5 S2 E1 K: b& B6 z                                                ,出口值=SYS_ERROR_COMM_I2CBUS(仅在重新启动
" K$ y: R' w2 [6 J" n- w8 a2 O                                                收发作业错误次数大于最大值时,才会置此变量值)。4 g% y: L" A; N3 P2 ?2 }9 g
出口静态变量:sign:TRANS_ERROR --------------- SPI接口通讯收发作业发生错误标志,出口值=
' B* s6 q) f" r7 m                                                清位。
" {0 J7 y* U. V' ]/ Y* ]              gstvSpi0.Cycle ----------------- SPI接口的重新启动通讯收发作业发生错误次: F$ c, Y. y. @7 j$ ]9 M% T* B
                                                数值变量,出口值=不确定。
- J. K8 c* s; G8 g! `              gstvSpi0.ErrNum ------------------- SPI接口的通讯收发作业发生错误次数值变量,
" l. X7 w- p. d                                                出口值= 0。! h6 g/ m4 g2 b/ s9 ^5 ~7 t
调用内部函数:①.unsigned char CommSpiBusBusy(void)
1 c4 U0 K) x% z* k4 W! z: p                  (检查SPI接口的总线状态函数)。5 Q0 S& I) N- T$ p
              ②.unsigned char I2C_Get_State_Info(void)
3 ?/ f& e) b$ v- K- w- A                  (读取SPI接口前一个操作的总线状态信息函数)。5 a, z5 K/ D! e
              ③.void CommSpiBusAgain(void)8 [  E! W# G* B9 E" x$ b
                  (重新启动SPI接口前一个通讯收发作业操作函数)。% m8 ]2 O  }; Y1 V, F& s: a: {7 V
备注:        ▲.注意:本函数为消息任务队列函数,要在主函数中不间断循环调用运行。: _* O( J' Y- g
==========================================================================================================*/
$ |' _- `5 K( }$ v; @5 W" J3 T#endif                                                    // “SPI接口工作于单主机方式”条件编译结束: L; q* G) [0 V& o1 _5 |

: x0 v5 X; K7 C/ [
4 [- z0 g* a7 h" a% b* B; B#if defined(PreCommSpiUseSingleSlaveMode) || defined(PreCommSpiUseMultiSlaveMode)
4 z4 _' m: S# e# s% J% P3 D+ A                                                          // “SPI接口工作于从机方式”的条件编译
. e5 @5 l; r+ J  T  p: _8 |
! R" \4 G+ g, v1 H' N#endif                                                    // “SPI接口工作于从机方式”条件编译结束
* r5 Z9 E' N4 z, F; b4 K/ L. k* l4 j$ [3 e* }
/*==========================================================================================================- Z- \) O( C: `) W- z! n
函数名称:  设置“占用SPI接口”标志; s! {: ]; A7 V% r' I, F# f' A
函数功能:  本函数用于设置“占用SPI接口”标志的函数。
" n; J5 O2 g* ?5 r% F: Q7 _6 @( w函数入口参数:没有3 [1 }$ ?: ?8 k) Z, e  ~
函数返回值: 没有' k3 k- M- D. s- z( s$ I# l3 z
调用函数:  1.& @+ P  b& O. p# h- a. h6 _
备注:        1.
. f' g% u" @1 U3 G9 p==========================================================================================================*/" x4 T( v2 G. Y7 Q5 y) N  G/ s$ `
void  CommSpiSetSpiOk (void): Q- v4 }4 b& V8 Y
{
) v. D' e) }3 h  gbitSpi.SpiOk       =  SET;                             // 置“占用SPI接口”标志8 f. y" v) K# H
  gstvSpi.OverSpi     =  RtcGetSecByte(cSpiOverSpiOk);    // 启动占用SPI接口计时秒表
3 Y6 r. y% J  `% |) m}
1 C% [) W2 R0 M8 O$ u) k  }" A. T8 n# ^/ P! c
/*==========================================================================================================
! \- c9 e: }& v  s函数名称:  清除“占用SPI接口”标志
: k3 W  n) c( f$ a函数功能:  本函数用于清除“占用SPI接口”标志的函数。
1 }8 _  x* O6 s) @5 f0 H8 \3 ~& @函数入口参数:没有
. e/ r6 o& {" H7 M# W2 R% N函数返回值: 没有* B& p6 C* a- L
调用函数:  1.5 d- l: V  \8 x+ r5 U7 @; y
备注:        1.6 {9 z) t) {6 a# |4 s: I
==========================================================================================================*/
# u! ~: K: u5 @( [7 l# t( P' ?void  CommSpiClrSpiOk (void)' B8 r' J4 P* [
{
1 V1 ~9 i3 C  p! e  gbitSpi.SpiOk       =  CLEAR;                           // 清除“占用SPI接口”标志
1 u3 a& E6 \( w3 Y- R9 F  gstvSpi.StepSpi     =  0;                               // SPI接口操作步骤指向第一步. [: h: Q9 R. R& ]0 b2 }5 b9 c
}
1 j( l7 z, r6 u0 K! w9 ?3 O7 Q; _$ j: E/ I/ e, f
/*==========================================================================================================
4 E& ?; L) z- w, U- K  i函数功能:    本函数是SPI接口通信接收和发送作业不间断循环调用运行函数。1 r7 S' [$ K5 C. ?! z8 ~
备注:        ▲.注意:本函数为消息任务队列函数,要在主函数中不间断循环调用运行。
! c$ B1 ]1 f! K. H/ Q; _: a              ▲.当SPI接口工作于从机方式时,SPI接口中断总是处于使能状态,以便+ D: l) ^; M6 h" O, H
                  SPI接口处于随时接收数据状态。/ W$ s+ m' C" l7 B- |
==========================================================================================================*/
! o) _" ]# Y  o+ p2 Tvoid  CommSpiCircleFunc (void)
! }% e; F8 v3 ?% e0 }* Z3 W{; H- d2 m3 [4 l2 @
#ifdef DEBUG
: B- k. v8 h) \1 \: _  unsigned char i;                           // 循环计数器变量
5 i" c, y8 r4 S$ R' A7 v: j" A, U  unsigned char j;
' d; U+ l' u8 ], H+ y& q  unsigned char hex_data[2];
3 t& P( Y0 |4 e/ |! ]  unsigned char *ptr;! T  B4 ?' F9 h+ u8 I9 y# g, ?
#endif
2 N; A% ~2 u0 R3 V* t8 {  unsigned char              i;                           // 循环计数器变量" h/ Y$ |9 e# o9 E/ N* h
  CommSpiDataStru           *pSpi;                        // 指向SPI接口通讯收发数据处理变量的指针4 [2 c0 f. c$ v

% r% N( l' t" U5 B2 w6 D  pSpi                      = &gstvSpi;                   // 取SPI接口通讯收发数据处理变量的首个地址  n* g- M! ~: k+ t3 s
#ifdef PreCommSpiUseSingleMasterMode                      // “SPI接口工作于单主机方式”的条件编译$ s7 @2 Z  N3 d* v" _
  if (   (gbitSpi.Error == SET)                           // 如果SPI接口通讯收发作业发生错误,, [$ P& z* o4 S4 H$ h
      && ( ! CommSpiBusBusy( )) )                         // 且SPI接口收发器处于空闲状态?8 t& k3 T0 J% c: x( V7 o
  {% ]( n. n2 X$ v* a
    if (pSpi->Cycle > cSpiErrorMax)                       // 检查重新启动收发作业错误次数是否大于最大值?9 B' f& [$ B" o7 [
    {3 x! [% ?" Z; g, N- g
      pSpi->Cycle           =  0x00;                      // SPI接口的重新启动收发作业发生错误次数清0
1 F; a  o0 {3 s2 n: J. ?! w      gbitSpi.Error         =  CLEAR;                     // 清除“通讯收发作业发生错误”标志
* R( B4 z! g/ {+ S      gbitSpi.Busy          =  CLEAR;                     // 清除“SPI接口〖忙〗”标志
2 e1 l- q5 a2 @* O#ifdef _SYSTEM_ERROR_MANAGE_H_2 \/ Q/ `" w6 j& Z
      sys_error_type       |=  SYS_ERROR_TYPE_IS_GENERAL; // 置【普通】错误类型消息任务标志位
) I/ A, V/ k0 ~      sys_error_value       =  SYS_ERROR_COMM_SPIBUS    ; // 置“SPI接口通信收发作业”错误代码值
4 {6 i! l6 I( [% V6 H+ o#endif: Q. T# z, y( P$ ?
    }$ Z: H1 y3 ?9 b& Y2 r. g
    else7 {: h4 A$ Y; [% ]& ]3 o1 {8 {
    {# S, e1 V! e7 n4 @+ b) r
      pSpi->Cycle++;                                      // SPI接口的重新启动收发作业发生错误次数值+1
5 ^' p( ^4 J+ C& ~2 C5 l      gbitSpi.Error         =  CLEAR;                     // 清除“通讯收发作业发生错误”标志7 S9 ^. H' B  w6 h" [) p
      CommSpiBusAgain( );                                 // 重新启动SPI接口前一个通讯收发作业操作* U$ m2 Q- Q8 x8 G9 B9 ?2 W. g
    }
, x2 y8 v6 q+ p$ L) C, g  }
( M$ }  N% u; l- V* y& C  // 等待,直至发送通讯作业全部完成处理后,才可以禁止SPI接口模块. F& C% ], w6 n" a
  if (   (gbitSpi.TxRdy == SET)                           // 如果SPI接口发送数据作业准备结束标志,6 Z- {8 `5 m0 R3 U
      && ( ! CommSpiBusBusy( )) )                         // 且SPI接口收发器处于空闲状态?
$ h9 `( C! {& B0 N. T  {# a8 @, c- C+ a5 f0 u$ F
    MFHSpiModSpiOff( );                                   // 禁止SPI接口模块+ ?, _+ ], f/ U# |
    MFHSpiFlgAllClr( );                                   // 清0SPI接口全部中断标志位
. C5 J; A1 n3 W& _! a9 H( X    MFHSpiIntAllOff( );                                   // 禁止SPI接口事件全部中断
& b7 d. F! M" }2 i# @% \    gbitSpi.Busy            =  CLEAR;                     // 清除“SPI接口〖忙〗”标志3 [' m- T  F3 G5 E! g$ `6 `
    gbitSpi.OverS           =  CLEAR;                     // 清除“通讯任务时间超时”标志; V1 n- e7 T% L4 u" d
    gbitSpi.TxRdy           =  CLEAR;                     // 清除“发送数据作业准备结束标志”标志+ t8 L1 ]- u3 I, r' P2 e
    MFH_PIN_CFG_INHZ_SpiMosi;                             // 设置SPI主出/ 从入引脚为输入引脚,并为高阻输入态
0 Q* M0 e) w7 N6 L: `1 i# D9 _0 k  }* w* \1 Z/ I; `, h1 g. y) r
  // 通讯任务时间超时计时处理,用以处理SPI接口直处于“BUSY”状态。; |) }# J# L$ O8 z5 y3 t
  if (gbitSpi.OverS == SET)
& t* X- u, w  |  {
1 A) v4 f( u7 Y3 Y3 B; z0 E( t    if (RtcSecByteOverflow(pSpi->OverS))                  // 如果通讯任务时间计时秒表时间已溢出?
5 }6 S2 g  l, B- K5 J! u    {8 {4 x3 c$ l, D: l" \) O
      MFHSpiModClkOff( );                                 // 禁止SPI接口模块外设时钟
0 o/ H8 t" j3 [# P7 Y" U" N      DelayUs(10);
, H" e2 m0 ]& A" Q: c0 J" R      MFHSpiModClkOnn( );                                 // 使能SPI接口模块外设时钟
* q' S# g5 }) m# \      DelayUs(10);$ P, b6 P6 ?7 f" O
      CommSpiInit( );                                     // 重新初始化SPI接口
: |3 N2 `  R/ G/ i- X0 ]3 E    }
, U: e* E! h- C* {. @  }, T7 ~8 i; |+ {- ]& T$ I/ t
  // 占用SPI接口超时计时处理,用以处理分时占用SPI接口。
* S4 {5 n4 L9 J& g- ]$ A' H4 k  if (gbitSpi.SpiOk == SET): y( h8 f; T# q* b' |
  {
1 w/ P7 T! ~% M  J+ }3 k1 L' c    if (RtcSecByteOverflow(pSpi->OverSpi))                // 如果通讯任务时间计时秒表时间已溢出?
5 J8 I8 B% G3 g- p, Q5 |' U    {
- N6 ]3 A6 a( b8 u: X      gbitSpi.SpiOk         =  CLEAR;                     // 清除“占用SPI接口”标志
7 O1 K: X3 r  D6 G9 d      gstvSpi.StepSpi       =  0;                         // SPI接口操作步骤指向第一步
2 {- n$ u: Y4 b    }
) v: G! j* w3 {$ l0 ]) V6 J  }( J  {8 {) L$ J' ^- N$ B
#endif                                                    // “PreCommSpiUseSingleMasterMode”
+ O/ O* R0 Z" M7 ~6 D+ v- g
  `: M+ `, n4 S4 K! s#if defined(PreCommSpiUseSingleSlaveMode) || defined(PreCommSpiUseMultiSlaveMode)
3 A- O+ O0 f; W( z* @4 L/ B                                                          // “SPI接口工作于从机方式”的条件编译
" K* h- @& D8 |  J* s! k3 e8 m+ [( f1 n) w. t3 {0 x" G0 _
#endif                                                    // “PreCommSpiUse......SlaveMode”( r9 z( E, D) o0 t
}  l) v  ]4 e) Q( A

/ J: }. S; U3 X, k9 r1 a+ ?( X' a; ?! x. ~$ m' R

- H1 m; `2 ~# M# {6 l* V2 t#ifdef __cplusplus
8 F& {3 {, |: K: C* f# ?# n. j# [}                                                         // extern "C" 链接指示符作用域结束0 W% v" w+ s6 c4 L: A
#endif' p% F7 r1 [, B* J- M% {

( W8 I9 q7 h. p+ J* h0 l( [# s: H
, r3 {1 J% d% S9 \. h/*' C; M$ W# P  U
************************************************************************************************************! }! Y8 V/ j( D9 e8 W3 }+ v
                     本C语言源程序文件到此结束* U; m! C, V, E4 R, s# P, N
************************************************************************************************************) u% t: R. U8 |3 U3 i  R0 M
*/; ?; h% U+ G  J3 @7 _, x
磊元lystudio 回答时间:2015-10-6 21:48:27

# y6 s8 E) ^* a3 }' t& E, ]$ l9 R0 R# O6 }* Y
/*
9 @4 x/ V: H( h" [$ Z" _6 C! V************************************************************************************************************; U# ]; _3 x# M
版权所有 (C),2010-2012,磊元科技有限公司
. b% s" `+ z. ]1 S. V--------------------------------------------------------------------------------------------------
2 |) K+ q0 |& j! @9 {7 s# g/ A3 D  S- s源程序文件名:   CommSpi.c2 ?/ {6 _6 }9 b9 u5 |! N. r+ |* N6 F; ]
源程序名称:    串行外设接口(SPI接口)的源程序文件
& {' U; ?# w# W程序版本:        1.0
- P0 t( y- U' f& d0 u! y) I1 w6 G程序功能:
0 n) H, Q& s2 d/ r. c8 a    本文件是串行外设接口(SPI接口)使用中断方式接收和发送数据通信的源程序文件。9 O9 @5 ]7 v) U+ X6 H5 y: U3 G
程序说明:
! x- W  F% y/ }+ L4 G- u    1.注意:使用源程序的SPI接口接收和发送数据的函数之前,必须使能全局中断。# `  ~# q/ n; O, p3 `  B. b
    2.注意:本文件仅实现1条时钟线(SCK)和1条双向数据线(MOSI)的单工通信方式。; Q7 k8 \0 [) k5 r" k" F7 H- N& f
: j0 X) J* f: b4 n6 X
主要函数列表:   
2 H0 A) L- G1 \6 V    ▲.在主函数中运行的函数:; h  C2 X, h9 G
      1.void Drv74595Init(void)5 J7 r+ S; C( Y8 g
                (串行输出端口初始化)
$ J# I. G0 H: G: ^+ R    ▲.芯片74HC595输出驱动函数:5 z/ p; R. g' c  ^/ p  F: o- U* g
      1.void Drv74595Drive(const unsigned char *pParallel): q" |: Q: `" F, _2 u
                (串入并出芯片74HC595输出驱动)$ n) Q6 u& j1 e5 @- R  f) D2 |
      2.void Drv74595Single(unsigned char Parallel, unsigned char Series): l! ?: Z7 I% I% a5 V! m: ~3 d$ |, b
                (串入并出芯片74HC595单个驱动)/ l/ H3 m4 i% i

2 P- x. ?' k* P9 a5 U2 r1 N链接子程序文件:  
: T1 X* t; X+ c( W7 m- D$ g+ H    1.
& v; J# q2 F( I/ q3 V: i2 s* s. I  c$ R0 l. f
编译工具软件:      IAR Embedded Workbench for Atmel AVR 版本:5.20A 以上# K1 Q7 s& _$ ]3 n

. G! g2 p* X" |  O编作者:            磊元: X! Y# P" a1 I
编制日期:          2009年4月8日& T2 Z9 {) K6 {
--------------------------------------------------------------------------------------------------
+ T5 V0 v0 h- I' [- d* p适用器件芯片类型:  ATmega 系列( Atmel 公司生产的 8 位 RISC 单片机)# n" b, G7 U4 ]
器件芯片时钟频率:  任意
* r% ^  q4 d0 i存储器模式:        大存储器模式- B4 \) u/ E& n" J' K$ E
外部扩展存储器大小:0【字节】; F* |, Q$ W2 X! |, y
调用堆栈大小:      6 【字节】  p3 C7 V8 W( l' X4 A
数据堆栈大小:      4 【字节】
5 @8 P; V6 C  a) p8 a--------------------------------------------------------------------------------------------------- E0 e; Q% G/ }& \# y# n3 F
源程序版本历史:
  X: \# B: v; _" g2006年07月26日  〖磊元〗 -------- 版本 1.0 :原始版本(AVR)
$ W# e. ]; c* B/ x! Q+ J2015年09月20日  〖磊元〗 -------- 版本 2.0 :扩增版本(STM8S)( w3 }& [* ]+ S/ E% G
************************************************************************************************************
. [  h, o7 k0 D*/
; B" |2 y2 G( V, P
5 J4 i# C! |. J9 q' C1 b/*==========================================================================================================+ Y; L: W& G$ w) |  U0 m
                        调试开关声明
$ t- \8 j) {6 ]& W/ s- H0 O" j==========================================================================================================*/1 ^! s" R/ [& e7 C7 b
//#define DEBUG
! f/ ?# Q$ ]1 }' `6 [. Z# e$ _
" k, l9 C6 f. J7 J& e: q0 Y, T
/ l! M, K  b2 \2 Q4 e) r! A* e/*==========================================================================================================2 Q, Q: n# k4 G" |2 X% ~
                      本源程序包括的头文件0 a! x" c" c6 k  B
建议:包含本项目的文件使用 #include "文件名.扩展名" ,
. q/ e4 n- _6 O  V' v' R! `   包含系统库的文件使用 #include <文件名.扩展名> 。" H$ ^' B- r% o* ^, p
==========================================================================================================*/
1 E$ f" B+ g$ E5 k; p0 x#include "CommSpi.h"                                      // 本源程序的头文件
1 b; b$ m1 O0 J8 `#include "DataMath.h"                                     // 算术运算及数制转换等数学算法的头文件
) c, Z: Y( `- ^  _, s#include "RtcTimer.h"                                     // 应用内部定时器计时的实时时钟的头文件
$ K4 q$ p; q4 \" d! a: h0 q* V
( D1 V% U+ Q- ]: x* l# s#ifdef __cplusplus  I4 y3 M9 S/ W3 e9 l+ N8 f# y
extern "C" {                                              // 声明接在下面的指令为C程序编译系统
% ?6 O2 J! U4 r8 u8 n# `3 j! F#endif
$ I* H7 \) h5 R9 q8 `) a6 \
, N0 v! Y  v  E% j$ |( A* z& }: h! ]( |4 |' C0 ]

. t/ a3 t7 ~) y8 t" Y5 _/*==========================================================================================================6 G7 z3 h8 I" s* M9 N% ]
                        全局常量定义
% H; M2 A' g4 [$ Q0 h==========================================================================================================*/
3 h% J: G' J9 F& e, ?( x. Y- S#if   (defined(_IAR_EW_AVR_))' ]0 \: z3 V& f4 J* ]4 Q
1 a' U! Q1 ~+ Q- ]- n5 L
#elif ((defined(_IAR_EW_MCS51_)) || (defined(_KEIL_UV_MCS51_)))' _! ~  _% `* ~5 b" {) ]+ H

" E4 p- U$ w& s6 \3 B0 F& f$ t' |3 T#elif (   defined(_IAR_EW_STM8_) \
% e5 Q- f3 X! L, j1 T2 i       || defined(_COSMIC_STM8_) )                        // “......_STM8 编译器”条件编译开始4 Z1 r; d$ a6 ^) }4 x$ f/ E
#ifdef _USE_STM8_FWLIB_                                   // “使用 STM8 FWLib 的库文件”条件编译开始
0 P9 U, Y# e) f* h& b) p) k9 h5 Z6 m9 ]% {9 K3 O' `
#else                                                     // “_USE_STM8_FWLIB_”
7 S: ]1 v: ^# n, }, E3 V6 O
  R% }! i4 @: q) q5 x- A7 N#endif                                                    // “_USE_STM8_FWLIB_”
& I0 n; j* _. {0 g% ?#else
# u8 ^' W3 d# G$ A& d#error 错误:
, f2 l6 P3 A7 u  h0 P#endif                                                    // “PreMcuIs__......”
+ M. e4 _+ G6 ^7 A4 ]9 M  a. @1 J) J+ Y" e

8 U; p$ f' _# K, C6 d* ^/*==========================================================================================================
. J. g7 o; a* z* N* N' {' `' h' \8 g( M                        全局变量定义0 C+ t8 `& y- x
==========================================================================================================*/
+ Q8 g* n7 j  H4 }, I5 S1 Y1 P* d/*------------------------------------------------------------------------------------------------
8 N& |4 t3 z/ OSPI接口通讯处理消息任务标志的全局变量定义:
. x/ B9 g1 n% V+ \: j------------------------------------------------------------------------------------------------*/
) w5 e- w2 E  \# Q4 r6 Pbdata CommSpi0FlagBits      gbitSpi0;
3 R3 x0 i1 B0 E# v
  L" `; G; M* ~5 c( S: t/*------------------------------------------------------------------------------------------------
0 z5 r& O* p. k8 ]SPI接口通讯收发数据处理的全局变量定义:" o1 @4 U9 k+ s
------------------------------------------------------------------------------------------------*/
; ~5 ]6 K% y& ~! @9 ]: Kxdata CommSpi0DataStru      gstvSpi0;
2 n4 T* ?: X) z/ U
, Q( u4 j5 |' T; b
6 k' F5 k! c) P4 m6 S& ^1 s$ I
9 C  n3 _. A5 d2 \4 X/ i5 I" l/*==========================================================================================================
/ g# L6 |2 u9 S0 }2 y2 P, |& z                  本源程序文件内部使用的字符化常数定义" k+ l/ z1 ]5 c( L2 e% q
==========================================================================================================*/! T. v. ^  i4 d5 ~" v- C. @! S
#if   defined(PreCommSpiMultipleSpiEnable0)               // “使用SPI接口0”条件编译开始3 x; ~; [  q) M0 F6 n
#define cDdrSpiMosi           cDdrSpi0Mosi
' K+ z! J) j& N% C#define cPurSpiMosi           cPurSpi0Mosi0 C3 T+ @1 f( X
#define cCirSpiMosi           cCirSpi0Mosi
/ L' W( Q2 m& {. N#define cOdrSpiMosi           cOdrSpi0Mosi
0 k' J4 R9 {6 H8 v- Q) N#define cIdrSpiMosi           cIdrSpi0Mosi
, m2 K$ s- T% U5 G3 e#define cPidSpiMosi           cPidSpi0Mosi3 b8 h0 j  m7 d0 K
#define cPodSpiMosi           cPodSpi0Mosi6 v9 l# u7 X: B3 R/ E( L
#define cBitSpiMosi           cBitSpi0Mosi8 Z+ b- y5 M. C# H3 W+ J# i
#define cDdrSpiMiso           cDdrSpi0Miso
, |  ^( a& K5 `! N' Q#define cPurSpiMiso           cPurSpi0Miso: `9 }- u. _3 t# a5 v7 v0 F
#define cCirSpiMiso           cCirSpi0Miso3 {& r3 c. u: s4 r
#define cOdrSpiMiso           cOdrSpi0Miso
& @  L$ T6 z* [' i* v. H( u#define cIdrSpiMiso           cIdrSpi0Miso
8 s* J4 y: c  P: n! |/ N( M5 B#define cPidSpiMiso           cPidSpi0Miso& [3 }) T/ c; |5 j  z
#define cPodSpiMiso           cPodSpi0Miso$ g% x3 W  ], l0 x- S' H
#define cBitSpiMiso           cBitSpi0Miso
) ~+ @* J% i& y' C3 R$ x7 d#define cDdrSpiSclk           cDdrSpi0Sclk% M4 g1 s) S# e
#define cPurSpiSclk           cPurSpi0Sclk- D, e" e7 Q$ k# q9 o7 n% A
#define cCirSpiSclk           cCirSpi0Sclk2 m2 x! n) O" u9 s2 _' h% _
#define cOdrSpiSclk           cOdrSpi0Sclk0 F  z; y9 s1 d. r7 h. k+ j
#define cIdrSpiSclk           cIdrSpi0Sclk
; Q& e! ?1 _# G- ~8 V* q#define cPidSpiSclk           cPidSpi0Sclk& o5 }* E  M* E2 \! R
#define cPodSpiSclk           cPodSpi0Sclk6 m+ q; Z5 H) a% B6 {* _) F6 Y
#define cBitSpiSclk           cBitSpi0Sclk0 I6 Y" {5 Q4 ~, b. V
#define cSpiRxBufSize         cSpi0RxBufSize( H5 e0 Q4 ~% D/ C% h4 U& @
#define cSpiTxBufSize         cSpi0TxBufSize
/ b$ N$ y9 r) a! b: a#define CommSpiDataStru       CommSpi0DataStru8 c2 F& O0 G' x' l) V+ h5 W
#define cSpiAddrNum           cSpi0AddrNum
  ?, ~2 {% A$ e' ~& C$ I#define gbitSpi               gbitSpi0
& j. a; {+ U4 @7 L#define gstvSpi               gstvSpi0; ^2 n0 q: t/ {9 G
#define gucvSpiEvent          gucvSpi0Event
# b* v+ {, [, n( z$ l$ L. |, M#elif defined(PreCommSpiMultipleSpiEnableS)               // “使用SPI接口s”条件编译开始2 `# o4 ^  }+ G$ a7 ^5 |* n

( D" {/ I1 I4 q8 \# p6 j9 J#endif                                                    // “使用SPI接口......”
. d, N+ X6 }$ y( r- B8 n. b1 ]4 S. X3 A( T

! v; i% o% U  A# R8 z8 L1 I8 X
. a/ ?7 f+ O3 a) v/*==========================================================================================================: q0 Y, w3 B& i
                  本源程序文件内部使用的数据结构类型定义" ?0 e8 k; s* _7 m0 E4 B
==========================================================================================================*/) R) C/ n5 X  s: C

* y/ S" Q+ S6 z- T
# d% E% C6 ]& g- {2 X. e) ?5 R8 U( N4 i
/*==========================================================================================================
3 M7 f+ q! u# v& ]8 _6 y                   本源程序文件内部使用的局部常量定义
6 v7 |- X' N/ z3 H/ P+ e/ l==========================================================================================================*/
0 v; T- [9 _& ?: n1 g, `& u
' n: K5 j" E# A5 K$ f5 T, q( P" {( ^% e/ P" o
; A. y2 b) A+ f) E+ g3 J0 Z9 K
/*==========================================================================================================6 M) @- Z, `5 T$ j5 o% w
                   本源程序文件内部使用的局部变量定义
4 j: r( q9 c* |* Q  t6 d9 D4 ^==========================================================================================================*/
6 _: z6 @& _8 U3 [/ D- p
% R6 f1 ]# t& P; Q7 L6 w1 N% n1 l$ y. O" u4 W7 I; q- U# K

1 m, v, W" F* }8 a6 _# Z/*==========================================================================================================2 x6 f* z, \# ]
                   本源程序文件内部使用的函数原型声明
1 H! I8 o  d( E4 Y: j& ?==========================================================================================================*/
! n+ U1 w3 l1 t, e1 vstatic void CommSpiBusAgain(void);/ f1 F1 k1 ^) X" w$ B1 k

8 l# r8 V" i4 P  `" S8 w' c, i% ]: t4 S0 s7 u8 z  P( A
) Y2 G/ x/ a' F: Q- V3 X5 M3 \) X
/*==========================================================================================================
2 s# }  |" v% A$ L, R                 本源程序文件内部使用的一些操作指令的宏定义; J% F' G# ]- i
==========================================================================================================*/5 Z4 L5 ]" G! q& l" [" X" ~' {; Y
/*------------------------------------------------------------------------------------------------
/ |1 P4 j2 B: U' @0 i/ m7 G输入/输出端口和引脚宏定义:(注:下列这些定义用以简化宏函数参数字符。)
% s8 z8 p7 A$ Y* k/ g------------------------------------------------------------------------------------------------*/0 \5 _0 `, K1 H+ V: v
#define MFH_PIN_CFG_INPU_SpiMosi                          MFH_PIN_CFG_INPU(cDdrSpiMosi, cPurSpiMosi, cCirSpiMosi, cOdrSpiMosi, cIdrSpiMosi, cBitSpiMosi)9 V* Y( Z1 B. J4 }) F, r
#define MFH_PIN_CFG_INHZ_SpiMosi                          MFH_PIN_CFG_INHZ(cDdrSpiMosi, cPurSpiMosi, cCirSpiMosi, cOdrSpiMosi, cIdrSpiMosi, cBitSpiMosi)& j& z' ~' g; ?. W% @: p
#define MFH_PIN_CFG_OOUT_SpiMosi                          MFH_PIN_CFG_OOUT(cDdrSpiMosi, cPurSpiMosi, cCirSpiMosi, cOdrSpiMosi, cIdrSpiMosi, cBitSpiMosi)
. Z' R8 M6 o" _1 K! q# C#define MFH_PIN_CFG_OUTH_SpiMosi                          MFH_PIN_CFG_OUTH(cDdrSpiMosi, cPurSpiMosi, cCirSpiMosi, cOdrSpiMosi, cIdrSpiMosi, cBitSpiMosi)
, D8 w, P, H4 _% i6 b#define MFH_PIN_CFG_OUTL_SpiMosi                          MFH_PIN_CFG_OUTL(cDdrSpiMosi, cPurSpiMosi, cCirSpiMosi, cOdrSpiMosi, cIdrSpiMosi, cBitSpiMosi)+ a& }6 G+ m7 A3 C- B9 H
#define MFH_PIN_OUT_SETH_SpiMosi                          MFH_PIN_OUT_SETH(cDdrSpiMosi, cPurSpiMosi, cCirSpiMosi, cOdrSpiMosi, cIdrSpiMosi, cBitSpiMosi)
7 j# K+ d9 p* U5 v#define MFH_PIN_OUT_CLRL_SpiMosi                          MFH_PIN_OUT_CLRL(cDdrSpiMosi, cPurSpiMosi, cCirSpiMosi, cOdrSpiMosi, cIdrSpiMosi, cBitSpiMosi)% B) N4 O7 f. y- q# o+ o/ v/ x- b
#define MFH_PIN_IN_STATE_SpiMosi                          MFH_PIN_IN_STATE(cDdrSpiMosi, cPurSpiMosi, cCirSpiMosi, cOdrSpiMosi, cIdrSpiMosi, cBitSpiMosi)
8 ]5 D3 }1 n" i7 C2 `- b$ V9 M; n, F- s8 p' C. n) x' F) U; x7 a
#define MFH_PIN_CFG_INPU_SpiMiso                          MFH_PIN_CFG_INPU(cDdrSpiMiso, cPurSpiMiso, cCirSpiMiso, cOdrSpiMiso, cIdrSpiMiso, cBitSpiMiso)4 X6 }$ V  u: Q: Z, V( ?8 S
#define MFH_PIN_CFG_INHZ_SpiMiso                          MFH_PIN_CFG_INHZ(cDdrSpiMiso, cPurSpiMiso, cCirSpiMiso, cOdrSpiMiso, cIdrSpiMiso, cBitSpiMiso)
! v+ j1 P' \6 _6 Q" F& B#define MFH_PIN_CFG_OOUT_SpiMiso                          MFH_PIN_CFG_OOUT(cDdrSpiMiso, cPurSpiMiso, cCirSpiMiso, cOdrSpiMiso, cIdrSpiMiso, cBitSpiMiso)
( q" i; }# I8 {  S9 ?! x) l3 ~#define MFH_PIN_CFG_OUTH_SpiMiso                          MFH_PIN_CFG_OUTH(cDdrSpiMiso, cPurSpiMiso, cCirSpiMiso, cOdrSpiMiso, cIdrSpiMiso, cBitSpiMiso)
* G3 G2 S, W7 L4 w; y$ I( U/ ]#define MFH_PIN_CFG_OUTL_SpiMiso                          MFH_PIN_CFG_OUTL(cDdrSpiMiso, cPurSpiMiso, cCirSpiMiso, cOdrSpiMiso, cIdrSpiMiso, cBitSpiMiso)% E1 G7 O! M8 l' ?  B  e8 K" X
#define MFH_PIN_OUT_SETH_SpiMiso                          MFH_PIN_OUT_SETH(cDdrSpiMiso, cPurSpiMiso, cCirSpiMiso, cOdrSpiMiso, cIdrSpiMiso, cBitSpiMiso)2 c  L( e( p3 Y" _) h5 S
#define MFH_PIN_OUT_CLRL_SpiMiso                          MFH_PIN_OUT_CLRL(cDdrSpiMiso, cPurSpiMiso, cCirSpiMiso, cOdrSpiMiso, cIdrSpiMiso, cBitSpiMiso)& ~5 I0 z) P+ `! K
#define MFH_PIN_IN_STATE_SpiMiso                          MFH_PIN_IN_STATE(cDdrSpiMiso, cPurSpiMiso, cCirSpiMiso, cOdrSpiMiso, cIdrSpiMiso, cBitSpiMiso)
8 U& k& L" _0 C2 c- C+ e  ~9 G  ?7 a7 c! E8 e, j$ `0 S! @
#define MFH_PIN_CFG_INPU_SpiSclk                          MFH_PIN_CFG_INPU(cDdrSpiSclk, cPurSpiSclk, cCirSpiSclk, cOdrSpiSclk, cIdrSpiSclk, cBitSpiSclk)* P+ E1 h( ^) y! p) X6 b  C- e
#define MFH_PIN_CFG_INHZ_SpiSclk                          MFH_PIN_CFG_INHZ(cDdrSpiSclk, cPurSpiSclk, cCirSpiSclk, cOdrSpiSclk, cIdrSpiSclk, cBitSpiSclk)
/ t2 _8 j6 Y; m#define MFH_PIN_CFG_OOUT_SpiSclk                          MFH_PIN_CFG_OOUT(cDdrSpiSclk, cPurSpiSclk, cCirSpiSclk, cOdrSpiSclk, cIdrSpiSclk, cBitSpiSclk)
5 i* X; \2 l& J5 p) G# _6 f#define MFH_PIN_CFG_OUTH_SpiSclk                          MFH_PIN_CFG_OUTH(cDdrSpiSclk, cPurSpiSclk, cCirSpiSclk, cOdrSpiSclk, cIdrSpiSclk, cBitSpiSclk)4 e& b6 {. D. B* P/ L9 G
#define MFH_PIN_CFG_OUTL_SpiSclk                          MFH_PIN_CFG_OUTL(cDdrSpiSclk, cPurSpiSclk, cCirSpiSclk, cOdrSpiSclk, cIdrSpiSclk, cBitSpiSclk)
2 z" B: N0 m! x! P#define MFH_PIN_OUT_SETH_SpiSclk                          MFH_PIN_OUT_SETH(cDdrSpiSclk, cPurSpiSclk, cCirSpiSclk, cOdrSpiSclk, cIdrSpiSclk, cBitSpiSclk)" q- Q% j5 F- ]& ^) K% ]+ C& e
#define MFH_PIN_OUT_CLRL_SpiSclk                          MFH_PIN_OUT_CLRL(cDdrSpiSclk, cPurSpiSclk, cCirSpiSclk, cOdrSpiSclk, cIdrSpiSclk, cBitSpiSclk)
% _  ^( r! K# }# M5 E5 ~#define MFH_PIN_IN_STATE_SpiSclk                          MFH_PIN_IN_STATE(cDdrSpiSclk, cPurSpiSclk, cCirSpiSclk, cOdrSpiSclk, cIdrSpiSclk, cBitSpiSclk)5 p' D- Q0 k: s6 a' r
6 W: d1 P$ v0 Z, i% Y0 ~5 {
#define MFH_PIN_CFG_INPU_Ht1381Cs                         MFH_PIN_CFG_INPU(cDdrHt1381Cs, cPurHt1381Cs, cCirHt1381Cs, cOdrHt1381Cs, cIdrHt1381Cs, cBitHt1381Cs)
/ E- V+ D  X4 p( u#define MFH_PIN_CFG_INHZ_Ht1381Cs                         MFH_PIN_CFG_INHZ(cDdrHt1381Cs, cPurHt1381Cs, cCirHt1381Cs, cOdrHt1381Cs, cIdrHt1381Cs, cBitHt1381Cs)
: |8 G6 j: |* w2 ~% e* |6 C( {#define MFH_PIN_CFG_OOUT_Ht1381Cs                         MFH_PIN_CFG_OOUT(cDdrHt1381Cs, cPurHt1381Cs, cCirHt1381Cs, cOdrHt1381Cs, cIdrHt1381Cs, cBitHt1381Cs). }) i: F. _2 G' q1 Y
#define MFH_PIN_CFG_OUTH_Ht1381Cs                         MFH_PIN_CFG_OUTH(cDdrHt1381Cs, cPurHt1381Cs, cCirHt1381Cs, cOdrHt1381Cs, cIdrHt1381Cs, cBitHt1381Cs): _5 N8 z7 h; m1 ]) q
#define MFH_PIN_CFG_OUTL_Ht1381Cs                         MFH_PIN_CFG_OUTL(cDdrHt1381Cs, cPurHt1381Cs, cCirHt1381Cs, cOdrHt1381Cs, cIdrHt1381Cs, cBitHt1381Cs)% h/ z5 J8 d. N  T3 p# R
#define MFH_PIN_OUT_SETH_Ht1381Cs                         MFH_PIN_OUT_SETH(cDdrHt1381Cs, cPurHt1381Cs, cCirHt1381Cs, cOdrHt1381Cs, cIdrHt1381Cs, cBitHt1381Cs)
* \  C3 A6 d; }#define MFH_PIN_OUT_CLRL_Ht1381Cs                         MFH_PIN_OUT_CLRL(cDdrHt1381Cs, cPurHt1381Cs, cCirHt1381Cs, cOdrHt1381Cs, cIdrHt1381Cs, cBitHt1381Cs)9 r  @9 B5 Z5 x+ x% u) Q# J
#define MFH_PIN_IN_STATE_Ht1381Cs                         MFH_PIN_IN_STATE(cDdrHt1381Cs, cPurHt1381Cs, cCirHt1381Cs, cOdrHt1381Cs, cIdrHt1381Cs, cBitHt1381Cs)
, f) h/ Z( Z9 B3 u; L  a
磊元lystudio 回答时间:2015-10-6 21:47:57

$ o6 E- L. Z2 N+ p, l3 S: h/*==========================================================================================================
. L( x9 F, R6 I/ H4 m# l                     全局变量数据结构类型定义
' j4 j2 C( I" p+ b' o) ?9 T7 c==========================================================================================================*/
9 k1 r$ R0 V/ J0 Y" s9 l9 ?/*------------------------------------------------------------------------------------------------
) x" ~4 z7 C+ u/ kSPI接口通讯处理消息任务标志的全局数据结构类型定义:$ Z+ Y8 w6 _/ D* ]  H
------------------------------------------------------------------------------------------------*/: D) L6 }1 V5 P9 m5 e
#define CommSpi0FlagDefaults                              \
; e  N9 d1 V# y" B: p, j                           {  CLEAR                      ,\
0 `7 |, o7 Q$ T. G( b                              CLEAR                      ,\
8 S0 m* ]9 ]6 p3 Q" {; l: B                              CLEAR                      ,\- ~* r6 e7 E6 d: Y# L1 ?) W, l% t
                              CLEAR                      ,\
* m9 f, m- C1 F1 `% `% |, a                              CLEAR                      ,\0 }1 ?/ C  p/ b% A* J
                              CLEAR                      ,\: N. T' F9 ?3 G% j, D  u
                              CLEAR                      ,\0 Y7 b1 Z, I" S1 m9 @
                              0  }                        // SPI接口0消息任务标志变量的默认初始化值! f+ }/ s! J* M6 M
typedef struct3 S5 u* I+ T% j: F9 h, x( S
{
# i( w& h8 j5 G& q  unsigned char Busy        : 1;                          // SPI接口〖忙〗" |0 C8 U* S6 P$ l1 a
  unsigned char RxOk        : 1;                          // 接收数据缓冲区己更新" H+ ?3 D2 Z6 |0 q4 ]# [( I
  unsigned char RxOvf       : 1;                          // 接收数据缓冲区溢出
; X6 i, {9 R# U! ^& P% T  unsigned char Error       : 1;                          // 通讯收发作业发生错误
# S  q$ N% K' H6 r- o4 j  unsigned char Txd         : 1;                          // 正在进行发送数据作业
1 \; v, B: [1 {# W1 B8 x, N9 I9 V  unsigned char TxRdy       : 1;                          // 发送数据作业准备结束标志* t- v1 G. Q8 Y7 f, ^- b' K( |. e
  unsigned char OverS       : 1;                          // 通讯任务时间超时6 M3 c; N0 |; d" g" I- [* B4 |% V
  unsigned char SpiOk       : 1;                          // 占用SPI接口(其他程序使用)
, i  w% ^& z& X. S3 n" A. ?} CommSpi0FlagBits;! }3 \8 A( i" g5 J1 R5 |8 Z* R
( o1 c% K; y, A2 `
/*------------------------------------------------------------------------------------------------
" J( B8 _2 M4 k5 s" N7 ^SPI接口通讯收发数据处理的全局数据结构类型定义:
% M( p. Q3 K+ [# [$ r------------------------------------------------------------------------------------------------*/' ?4 j5 \  A3 c
typedef struct( b( g- w6 r8 L2 w! q. E4 v  A6 f: R
{( L6 a' r) i  q! R$ a
  unsigned char             TxSize                      ; // 每次发送数据个数大小
$ ~  c) c7 a- b  unsigned char             TxCnt                       ; // 每次发送数据个数计数器- H. q% i; u( X& D  T- w0 a
  unsigned char             TxBuf[cSpi0RxBufSize]       ; // 每次发送数据缓冲区! ~. x; m$ y6 C1 D! D

- e2 k: K% ?" E9 B( j0 p  unsigned char             RxSize                      ; // 每次接收数据个数大小
( Z) ]8 m9 N& A1 D' Z7 N  unsigned char             RxCnt                       ; // 每次接收数据个数计数器
$ n, S5 f4 l2 A  p- j  _( G" J# l9 d  unsigned char             RxBuf[cSpi0TxBufSize]       ; // 每次接收数据缓冲区1 f3 H; J6 f% i" l
. E* u' D) X7 |* s# S1 G- h0 E& I: p
  unsigned char             OverS                       ; // 通讯任务时间超时的计时秒变量3 Q3 t/ @3 f: B1 D5 m
  unsigned char             Cycle                       ; // 重新启动通讯收发作业圈数8 \, L, x2 n0 U% O# K2 y
  unsigned char             OverSpi                     ; // 占用SPI接口超时的计时秒变量(其他程序使用), n3 u3 s: E( O, P/ M5 r
  unsigned char             StepSpi                     ; // SPI接口操作步骤(其他程序使用)! X/ o3 u8 b. g! X
} CommSpi0DataStru;
" l- ~8 X0 \( W  _4 U8 j# Q0 Y) }0 X! i  @3 g7 q# T
& _9 \7 B7 B7 s& u7 y6 O$ i
, Q. A! A0 A1 `* K$ r' L+ M
/*==========================================================================================================
; Z" c0 P% b" C. c$ [: A- _5 x                        全局常量声明7 u: J) x9 @4 A* q$ O1 A- ]: v
==========================================================================================================*/
/ M$ E4 |% T9 T; x5 p0 g* c9 D3 k; R

4 B( s4 f0 ^2 T) L
, t( i7 P8 n; e1 N9 b3 b" a! h/*==========================================================================================================
; q$ ^2 _( Q' {. o! y: \                        全局变量声明
7 Z; P4 m5 N3 L$ L- N==========================================================================================================*/
5 R* F4 s* Q+ A/*------------------------------------------------------------------------------------------------
, Z* p- d5 ^0 J% @; o$ GSPI接口通讯处理消息任务标志的全局变量声明:" R5 [& T% l3 Q& i- B) d
------------------------------------------------------------------------------------------------*/+ ~. D' F0 \4 _3 A8 ]4 o$ e+ @( R
extern bdata CommSpi0FlagBits      gbitSpi0;2 ?. ?4 ], M: M( F! G, a

- @4 L* Y4 r+ p2 V% I/*------------------------------------------------------------------------------------------------- p- J. c0 r- N7 y
SPI接口通讯收发数据处理的全局变量声明:; ?  F* \: L6 R7 C
------------------------------------------------------------------------------------------------*/
0 W! Z3 f) _0 U2 b6 E7 F* F0 m5 Qextern xdata CommSpi0DataStru      gstvSpi0;
9 Q- h, G- u& E/ Y4 z1 n* j2 F4 Q0 d. W: ~; Y1 O( {
* L+ a( j' W* X
0 @7 y2 r- ]+ A9 P, U
/*==========================================================================================================1 _% c# g1 ?6 M/ Y: o' d' ]9 F
                     源程序文件中的函数原型声明
4 O/ f  K4 l% Y/ [5 p. ^% e==========================================================================================================*/
5 e( |1 p3 s. w4 ^( A4 A% e/*------------------------------------------------------------------------------------------------
: W  J* W( `3 A6 |" V: n1 w6 Q) V  u8 l
------------------------------------------------------------------------------------------------*/
6 V! v* P2 r, Y3 m2 _void CommSpiInit(void);9 z6 A0 w5 o# O% ?' s7 R
1 \4 l, z# c  L+ s
/*------------------------------------------------------------------------------------------------
' k; V" M/ k/ V& j$ T! b8 H函数名称:  查询SPI接口通讯发送数据作业工作状态7 o  l* F% @8 [8 l0 r5 ~3 L- q6 A- p
函数功能:  本函数用于检查SPI接口通讯发送数据作业工作状态的函数。& B9 k& R4 k4 _, _: B
函数入口参数:没有. p: A+ i; q. A0 q3 `4 A$ D  L
函数返回值: SPI接口收发器的工作状态,0(空闲状态)。2 G# f) _1 U, L
调用函数:  1.
  k  j8 f1 a5 O备注:        1.
) @3 @* x- J. c  T$ T/ n------------------------------------------------------------------------------------------------*/0 R* q. d  K9 D# x
unsigned char CommSpiBusBusy(void);
* ~& S, F5 p0 ~6 K$ L7 o
) d$ ]$ q+ s( j' k1 B' l/ n. \/*------------------------------------------------------------------------------------------------
" }# J  C2 }5 b! m" h/ g" V函数名称:  设置SPI接口为标准/快速模式和占空比
% u+ ?. j- x/ N函数功能:  本函数用于设置SPI接口为标准/快速模式和占空比操作的函数。: M  R1 e- T8 q/ S, b  F, U- g
函数入口参数:Model ----------------- 标准/快速模式和占空比, ON(快速模式)/ OFF(标准模式)。* d$ Q( @% |9 [" c) ^' j3 y3 f
函数返回值: 没有
$ b% X0 V$ |7 h6 A调用函数:  1.  _. y1 ^( R6 o
备注:        1.; x6 X# y9 E2 c' P
------------------------------------------------------------------------------------------------*/
6 a2 m* S1 b5 B, c4 h& Svoid CommSpiBusModeDfLhMl(unsigned char Model);
( y* b, |  M( ~3 R
+ p2 a5 @; ]2 d! M9 c  F#ifdef PreCommSpiUseSingleMasterMode                      // “SPI接口工作于单主机方式”的条件编译: W" R: o$ g! C8 G% {; v
/*------------------------------------------------------------------------------------------------  [( y9 S0 l1 i

0 H) Z  Z! B8 Z6 R------------------------------------------------------------------------------------------------*/; M$ s- ~0 b0 q4 V( W& Z
#if cSpiTxBufSize < 256. }( \% O" H1 q, Q
void CommSpiTxWithData(unsigned char *pData, unsigned char Length);
3 M$ m: H. P. \' j5 {! ?#else
5 Q! I. u5 B9 y" T% C0 D# evoid CommSpiTxWithData(unsigned char *pData, unsigned int  Length);4 _6 H. e- w6 a( P% i: b0 }' M7 v
#endif
9 P- A8 S) Z/ m% X$ P; C' ~/ B1 g: s  X* T2 j+ x
/*------------------------------------------------------------------------------------------------% E6 K* B4 W; v( e) h. m7 M

% }% f4 e* L  ]9 J- A0 p------------------------------------------------------------------------------------------------*/
+ s3 Y# B. a$ h; z#if cSpiRxBufSize < 256& S$ o' B8 I% x3 j+ s6 \% L
void CommSpiRxWithData(unsigned char Length);
/ x  y" s: \5 c4 N2 L, K) r#else& s7 z  q/ @5 N3 h4 y
void CommSpiRxWithData(unsigned int  Length);
; ^0 D8 C# w! C7 a+ g' }% ?3 o/ p#endif. H# t! a% V$ Y

% r* i" k' v+ Q4 ]/*------------------------------------------------------------------------------------------------$ `% y: T( r! z& N1 H- ?3 N
函数名称:  SPI接口工作于单主机方式,使用中断进行接收和发送数据的中断服务程序。
8 Q0 m* t  V; e函数功能:  本函数用于SPI接口工作于单主机方式,使用中断进行接收和发送数据的中断服务程序。9 r0 ], }1 D  q; p$ \/ ^( m
函数入口参数:gbitSpi.Rxd ------------- “正在进行接收数据作业”标志。( X  S/ Y: a1 \4 s: S! {6 a
       gstvSpi.TxSize ---------- 每次发送数据个数大小变量。
  r+ D) p; u$ {; U) u8 {' @       gstvSpi.TxCnt ----------- 每次发送数据个数计数器变量。
0 b. Q7 t0 n: x- S! |9 {- m       gstvSpi.TxBuf[] --------- 每次发送数据缓冲区数组变量。" V4 H0 }# r) L
              gstvSpi.RxSize ---------- 每次接收数据个数大小变量。
  |3 ]" V& c' p$ t* G函数返回值: 没有
; K" B# c  ~  C& i* ^1 e函数出口参数:gbitSpi.Busy ------------ SPI接口〖忙〗,出口值=清位(可能)。0 Y  ~( q$ z* P- w1 {1 X8 h
              gbitSpi.Error ----------- 通讯收发作业发生错误,出口值=置位(可能)。9 G2 V5 {3 P: S1 J/ S, u6 y5 F
              gucvSpiEvent ------------ SPI接口的状态码变量,出口值= 不确定。& z: {$ t2 S5 z* ~; N. r. B& y/ Z2 K) |
       gstvSpi.TxCnt ----------- 每次发送数据个数计数器变量,出口值=gstvSpi.TxCnt。2 ~* H0 [* w4 j
       gstvSpi.ErrNum ---------- 通讯收发作业发生错误次数,出口值=不确定。
- S6 k7 L; A' z7 ?5 m8 Q* a              gstvSpi.RxCnt ----------- 每次接收数据个数计数器变量,出口值=gstvSpi.RxSize。5 b1 Q/ m( l& O3 u/ v
              gstvSpi.RxBuf[] --------- 每次接收数据缓冲区变量,出口值=从SPI接口上接收到的数据。0 b8 `/ q7 t- i. i+ L: H( ]" T
调用函数:  1.  r0 }5 {' e5 \# Y8 w
备注:        1.注意:本函数需在SPI接口中断请求的中断向量函数中调用。
* \4 a4 E) u: d. w                     在调用之前需对该中断向量进行初始化,使能该中断。6 T( L8 |# x# d+ I7 C
       2.全部完成通讯收发作业后,本函数将禁止SPI接口中断。
& j  Z6 h, x. Y( I- U  E1 Q) Z------------------------------------------------------------------------------------------------*/
! g7 Q" }2 U) l4 {& O7 p- r#if   (   defined(_IAR_EW_AVR_)   \
9 N% T; g5 L; O4 S) e7 ^5 p! a# M       || defined(_IAR_EW_MCS51_) \  i  `& F' U4 {; Z0 S& L' O
       || defined(_IAR_EW_STM8_)  )0 a- j, R0 U  {) F
#pragma vector = int_SPI_vector0 E% |% c6 W# n8 b( l$ B" h
INTERRUPT_KEY void CommSpi_isr(void);5 x$ h* X$ V5 f; d& _  i
#elif (defined(_KEIL_UV_MCS51_) )8 o; t( y( U; Z+ k# t; Q8 Y
4 o8 o0 l& p) m3 V
#elif (   defined(_COSMIC_STM8_)  )3 n' {% ]$ o0 P$ H5 J( ]# j
INTERRUPT_KEY void CommSpi_isr(void);4 o( A' z0 E" K6 ^7 k
#else4 }$ @( L8 x8 N) y
void CommSpiIsr(void);; j2 g5 p$ a0 O
#endif                                                    // “_IAR_EW_......”
; g% f3 c5 }+ D#endif                                                    // “SPI接口工作于单主机方式”条件编译结束! ~( C. w1 c3 B& Q6 C

; ~2 N: v% U# ^0 K# [#if defined(PreCommSpiUseSingleSlaveMode) || defined(PreCommSpiUseMultiSlaveMode), u+ F8 K* k" ]: b
                                                          // “SPI接口工作于从机方式”的条件编译# Z* P8 x. K  C% O8 Y' I8 i% Z  j
3 X* G# s, I- y% c
#endif                                                    // “SPI接口工作于从机方式”条件编译结束
# D8 I5 X4 e# x- e
; G2 e. I, `) E8 E0 |7 C9 H
& K, I. ~7 C: k1 H$ W6 E6 I$ A/*------------------------------------------------------------------------------------------------2 t$ N% Z7 R' x
函数名称:  设置“占用SPI接口”标志
6 O0 T/ `% d0 D2 {函数功能:  本函数用于设置“占用SPI接口”标志的函数。3 w0 c# v5 P! u0 U- C2 f% @
函数入口参数:没有
+ _0 m; e8 N, y: M函数返回值: 没有
- H. ~) P8 O* [5 j7 ]0 ]调用函数:  1., A% v1 M' I; p
备注:        1.7 i0 ~' j2 \9 p/ `, J% i, @
------------------------------------------------------------------------------------------------*/5 r% s4 H: w# }5 l" [1 v6 Q
void CommSpiSetSpiOk(void);
$ @* x! ~' B( n( M. u
) |+ j3 u" d+ \' I/*------------------------------------------------------------------------------------------------
8 v8 @2 ]7 u/ j2 \# S: g/ G/ c4 o3 e函数名称:  清除“占用SPI接口”标志
3 i& F! K" ]% O5 Z函数功能:  本函数用于清除“占用SPI接口”标志的函数。) M) g; @- m; X8 k. X
函数入口参数:没有' V( }3 M, T, [. I3 ~+ L: c
函数返回值: 没有- Q; A: I5 i  m4 z7 y
调用函数:  1.
! N: G8 s3 E0 H5 S0 y' p备注:        1.
8 E* C0 h: v$ P------------------------------------------------------------------------------------------------*/  P" B" f/ \7 Y5 c% O1 d/ @
void CommSpiClrSpiOk(void);
$ c" w  N  s9 I: C3 R. F2 `4 ]1 J+ v
/*------------------------------------------------------------------------------------------------2 A0 p& ?% G( i+ u) A7 Z: _
函数功能:    本函数是SPI接口通信接收和发送作业不间断循环调用运行函数。; h& m/ m6 a7 d* ^5 c% {
备注:        ▲.注意:本函数为消息任务队列函数,要在主函数中不间断循环调用运行。
4 h/ t6 ?7 ?8 a4 W+ v7 o+ q              ▲.当SPI接口工作于从机方式时,SPI接口中断总是处于使能状态,以便8 \# ?! o) k, V# _7 l* \8 }* q
                  SPI接口处于随时接收数据状态。0 R% V* r3 b$ @, }1 U' o
------------------------------------------------------------------------------------------------*/
* [9 m# n5 m0 \% `void CommSpiCircleFunc(void);
3 D6 P/ i, G$ \- H: H; J; B0 J/ T- n% n0 z5 g. ^

2 W; F0 w( ^' _( n
$ x9 U3 q) o* O( f# Y7 U#ifdef __cplusplus
+ ~: c) H* `0 V4 n# e2 B( a3 O}                                                         // extern "C" 链接指示符作用域结束! u+ h$ s( P; ^. \. G5 p9 b* C5 [
#endif
! b$ w8 @4 Q1 m0 y2 |# V7 Z/ Z  Q  b8 m$ ?% |  I. D
#endif                                                    // “_COMMSPI_H_”条件编译结束) j/ [5 @5 u9 h
+ W; @* T7 c' Q: f
. C+ r1 N+ x! i& S  J! m3 {( {
/*
0 E8 s* o0 x. J0 j7 y, N************************************************************************************************************) ?8 D' e" A  V
                       本头文件到此结束
9 Y: @4 e. i! w8 c; O  h5 Y************************************************************************************************************; V; e+ i1 q/ w& f0 k2 v6 j
*/
  r: x& w8 m% t6 }* G3 e2 U& Q- r+ w
0 B3 g$ `# d! w/ `2 f& ^* C% e1 ?: |0 Z' A. b2 |- |. x
0 _6 I, e+ T7 ?1 s& N
磊元lystudio 回答时间:2015-10-6 21:49:36
) q/ q* D+ c. m/ Z

4 m- N: S: _! b8 E( T0 e0 b/*==========================================================================================================$ y& i/ ~) G" K& r1 J
函数名称:  查询SPI接口通讯发送数据作业工作状态: f2 ~3 f5 U4 K; B! V$ w
函数功能:  本函数用于检查SPI接口通讯发送数据作业工作状态的函数。1 z! K: o$ K/ }/ I( u9 `$ z+ r
函数入口参数:没有7 w$ |! Q) P' A* {/ M# N
函数返回值: SPI接口收发器的工作状态,0(空闲状态)。* r% X0 [9 E/ j0 N+ \
调用函数:  1.0 q/ @3 {1 `! G6 y1 X! h: j3 t' q) B! f
备注:        1.; H" V! k( a3 _* E5 A+ K8 m3 h
==========================================================================================================*/! Q& l* b* A9 @6 }
unsigned char  CommSpiBusBusy (void)
: {% y  U5 V8 s/ M{: z: Y7 e# ?3 @! ^
#if   (defined(_IAR_EW_AVR_))/ s" I; ]; O- u0 V; R
  return (SPCR & (1<<SPIE)) ;                             // 如果SPI中断使能则收发器处于忙碌状态  s0 h; N$ G' h# ]7 v% j
#elif ((defined(_IAR_EW_MCS51_)) || (defined(_KEIL_UV_MCS51_)))+ Z5 M6 M# q2 Y3 ~/ w
$ x7 K8 h* i) x' U) W6 ]
#elif (   defined(_IAR_EW_STM8_) \
, A5 p) i" S2 b       || defined(_COSMIC_STM8_) )                        // “......_STM8 编译器”条件编译开始
4 G# {7 t5 _: K: q& [7 \& C" M#ifdef _USE_STM8_FWLIB_                                   // “使用 STM8 FWLib 的库文件”条件编译开始
. P; e4 u9 p/ _9 D  a. G5 U
& I6 e( i! z# H* E#else                                                     // “_USE_STM8_FWLIB_”% X5 ~: _: \! W5 o2 r
  return (SPISR & (u8)( ((1<<spiBSY  ))) );               // 如果SPI接口忙则总线处于忙碌状态- l: C$ @3 B5 q% }: T
#endif                                                    // “_USE_STM8_FWLIB_”
9 M) X: \4 t  A" V- k0 k& z) ~( L#else
, i% m+ z7 U5 P/ Q#error 错误:
% L7 ^% @% U5 t4 u; L5 s% B. T#endif                                                    // “PreMcuIs__......”
* ?2 R" h; A$ g+ ?' B* M! M}
( r; e+ k: x1 e% P. p
6 m8 Z/ J) h3 @+ F/*==========================================================================================================3 @3 k: C+ b8 p- x0 f
函数名称:  设置SPI接口的数据发送次序、时钟极性、时钟相位. R+ A1 W2 B( K2 }( n% b% G
函数功能:  本函数用于设置SPI接口的数据发送次序、时钟极性、时钟相位的函数。
+ s5 D9 s3 x: y& \& \6 V2 B; @函数入口参数:Model ----------------- 数据发送次序、时钟极性、时钟相位的设置值。
' n  e7 S& u. o5 V函数返回值: 没有+ [( z2 ^8 p" X! q) Y$ [5 G* o3 l
调用函数:  1.( `4 n# Q% e8 ]1 B  u. a2 [% P2 g
备注:        1.
) Y! G8 w! X7 @$ M; @==========================================================================================================*/' k% \0 b! r& H: V: d
void  CommSpiBusModeDfLhMl (unsigned char Model): S* R( Y" Y, M, C( H& R1 E
{
% V$ |: `2 _: o, b- v1 e* }) M#if   (defined(_IAR_EW_AVR_))
; ^8 B$ C2 j  Y9 \
4 Y- f8 P* D# ?#elif ((defined(_IAR_EW_MCS51_)) || (defined(_KEIL_UV_MCS51_)))4 u' ~% s6 s& O' \& C- Q+ V

4 t9 R, Y$ F1 v# O$ Q#elif (   defined(_IAR_EW_STM8_) \( Z& X% V$ {. f8 t
       || defined(_COSMIC_STM8_) )                        // “......_STM8 编译器”条件编译开始
3 j2 q# w- V. {8 Q- H3 u#ifdef _USE_STM8_FWLIB_                                   // “使用 STM8 FWLib 的库文件”条件编译开始4 X6 G. X' C9 P1 |: X9 s

2 @. j9 }4 D) ?' W#else                                                     // “_USE_STM8_FWLIB_”
" V8 ^" i5 O, ]3 Y  SPICR1         &= (u8)(~((1<<spiEN   )));               // 禁止SPI接口模块,& X# a7 L: n; K* c2 P0 [$ T5 a; j
  SPICR1         &= (u8)(~(cSpiSpicrCfgMask));            // 屏蔽非SPI配置寄存器的位值
  |; C+ }5 z9 i, _# e% t6 Y& z  SPICR1         |= (u8)( Model);                         // 导入SPI配置值
3 G! O& n3 c6 q$ U& R& L/ V  // 因为SPI接口模块还未使能,无法控制SCK引脚电平
1 M& q2 G( G: L  if (SPICR1 & (u8)( ((1<<spiCPOL ))))                    // 如果空闲时SCK为高电平?
7 q$ q8 o. }6 t' y  {
6 h+ P% g0 U$ f1 M6 U    MFH_PIN_OUT_SETH_SpiSclk;                             // 确保SPI串行时钟引脚为H电平(没有操作时)! q7 S- F  t) l& q) H
  }
- c/ t% f! I& O3 T  else* Y' W! P' h. Q# |  m# k
  {) H# N! r7 w5 c& N& Z4 ^* D
    MFH_PIN_OUT_CLRL_SpiSclk;                             // 确保SPI串行时钟引脚为L电平(没有操作时)& R4 P: e9 M4 M# S
  }
" a+ ~7 e  ^. a# t#endif                                                    // “_USE_STM8_FWLIB_”) j7 R! A9 d$ J
#else
/ e8 B. V0 H$ M$ O#error 错误:
; I( X' `1 _' ]#endif                                                    // “PreMcuIs__......”
* l6 f& F; ~& J- H8 f* z% S5 f, a}
8 v9 I4 M2 j3 k; w/ E  e' z
! b3 p+ F/ v) _#ifdef PreCommSpiUseSingleMasterMode                      // “SPI接口工作于单主机方式”的条件编译- N7 ^9 T; d2 d
/*==========================================================================================================
3 w: q& u3 z7 Y3 W函数名称:  SPI接口工作于单主机方式,重新启动SPI接口前一个通讯收发作业% z5 d) W; h5 J; |/ I4 w# S% x4 Z
函数功能:  本函数用于SPI接口工作于单主机方式,重新启动SPI接口前一个通讯收发作业操作的函数。
! ?$ d) ?8 R' M5 d5 C' T函数入口参数:gbitSpi.Txd ------------- “正在进行发送数据作业”标志。
9 `/ z) O! M9 F4 l函数返回值: 没有
, j6 {# X: N( P1 i8 U1 y函数出口参数:gstvSpi.TxBuf[0] ------ 每次发送数据缓冲区数组变量,出口值=要发送的地址。
' U5 ]8 L2 j1 J" O1 ]% a# q              gstvSpi.TxCnt --------- 每次发送数据个数计数器变量,出口值=0。9 ?/ t: M1 ]0 f) ^+ E0 o2 b
              gstvSpi.RxCnt --------- 每次接收数据个数计数器变量,出口值=0。. H+ v/ |: Y: z9 V2 p. R
调用函数:  1.
" N8 o" @' ^/ N' C/ Y' \: o7 }  k3 X备注:        1.调用本函数将SPI接口接收或者发送中断和错误中断请求。
; P7 W) S3 e+ I( _, k! [) ?' T& |==========================================================================================================*/
/ r+ q9 d0 `5 m' Q9 kstatic void  CommSpiBusAgain (void)
- u8 Q* l5 Q6 v! B) z: z{
% Y0 K9 \. f0 p#if cSpiTxBufSize < 256+ {9 i" u. v* ?- G) T' T
  register unsigned char    i;                            // 循环变量- ]: k9 a9 U! ]( L8 R* B7 @; M. _0 p
#else
. O$ {5 k4 }) A: b0 ]1 O0 \  register unsigned int     i;
9 |2 D" g. Y9 H2 W#endif
. X) E8 `" o$ Q8 T$ s0 P  A  unsigned char             temp;                         // 临时变量$ t/ ^5 p+ r& @. e
  CommSpiDataStru           *pSpi;                        // 指向SPI接口通讯收发数据处理变量的指针
8 ~! O$ h7 X& @: l, b9 l8 O
3 t) P0 w) h6 M  pSpi                      = &gstvSpi;                   // 取SPI接口通讯收发数据处理变量的首个地址/ X6 _8 y& D+ w( q: n3 ^

' R9 ~0 p4 k! D2 d  pSpi->TxCnt               =  0x01;                      // 每次发送数据计数器值清02 ^; n* X* _9 R
  pSpi->RxCnt               =  0x00;                      // SPI接口每次接收数据个数计数器清01 Q3 Q( [/ o8 \6 f) T: l2 |! W
  if (gbitSpi.Txd == SET)                                 // SPI接口是否正在进行发送数据作业?
) x1 [4 \. h% Y8 M4 [2 F  {3 e) ~3 `% y5 S' t. `
    MFH_PIN_CFG_OUTL_SpiMosi;                             // 设置SPI主出/ 从入引脚为输出引脚,并为L电平
: [) z/ A8 _- W% R5 M/ }5 {    MFHSpiFlgAllClr( );                                   // 清0SPI接口全部中断标志位6 \- q) v; M, H$ w0 a
    temp                    =  SPIDR;                     // 清0SPI接口接收中断标志
9 M9 ]) X4 ^+ G1 w) u    SPIDR                   =  pSpi->TxBuf[0];            // 从发送缓冲区中将发送数据写入到SPI接口
/ }# c/ u4 K7 n! f1 I/ M    MFHSpiIntTxdOnn( );                                   // 使能SPI接口发送中断、错误中断,唤醒中断& z; C1 y: k1 t5 c
#if   (defined(_IAR_EW_AVR_))
3 ~9 \( ^0 j+ W8 C
0 r4 u! n. E1 Z, ~+ R7 Z#elif ((defined(_IAR_EW_MCS51_)) || (defined(_KEIL_UV_MCS51_)))
- k% s0 Q- C) g3 |/ n1 I
1 p2 i7 z2 B# h  A/ t$ D7 c#elif (   defined(_IAR_EW_STM8_) \
; H/ v9 y: o' o( ?0 C  s- |( W       || defined(_COSMIC_STM8_) )                        // “......_STM8 编译器”条件编译开始
  d7 j% E1 Y, O+ O" n#ifdef _USE_STM8_FWLIB_                                   // “使用 STM8 FWLib 的库文件”条件编译开始
2 f, p8 r+ K7 ?3 c: m, O+ k+ c; I0 V3 j
#else                                                     // “_USE_STM8_FWLIB_”
: b. R/ P1 t/ o" r: d/ b8 ~    SPICR2        = (u8)( ((1<<spiSSI  )|(1<<spiSSM  )|   // 内部从设备=主模式,使能软件从机设备管理1 s/ x+ Y) U/ p3 N
                           (0<<spiRXTX )|                 // 全双工,0:全双工(同时发送和接收),1:输出禁止(只接收)
8 F" c  v7 G: B2 o; p5 T                           (0<<spiCRCTX)|(0<<spiCRCEN)|   // 下一个发送的数据来自Tx缓冲区,禁止硬件CRC计算& l6 \) R7 m; J
                           (1<<spiBDOE )|(1<<spiBDM  ) ));// 使能双向模式下输出,使能单线双向数据模式
4 A$ o/ t/ y7 F: R/ w2 f  {#endif                                                    // “_USE_STM8_FWLIB_”
, N2 A: t& A* m' n; b% R#else
" w+ E, h7 c, Q+ {#error 错误:
3 M+ f" |5 y* h% P, p1 Q5 }% W#endif                                                    // “PreMcuIs__......
3 M$ W) n6 Z/ h2 h/ {  }/ h' b) H0 a1 W" K# Y
  else
' y! T8 w. r( ?$ j( g+ ?  {
6 X1 K  s) W5 h8 ~- y! ~    MFH_PIN_CFG_INHZ_SpiMosi;                             // 设置SPI主出/ 从入引脚为输入引脚,并为高阻输入态
  m. Y6 h5 c7 r, R+ K    MFHSpiFlgAllClr( );                                   // 清0SPI接口全部中断标志位
( I9 I  D' v9 H8 g1 k" `$ Z    SPIDR                     =  temp;                    // 清0SPI接口发送中断标志2 d4 C; K5 d2 G6 ^
    temp                      =  SPIDR;                   // 清0SPI接口接收中断标志
! s' P* d# a0 b8 X$ S4 a. x0 P+ u( e    MFHSpiIntRxdOnn( );                                   // 使能SPI接口接收中断、错误中断,唤醒中断
2 Z! z1 O6 c1 ~; w3 ]; I: i#if   (defined(_IAR_EW_AVR_))
* e) x5 b- D4 ~3 N$ G, E  }
" w, U5 d' `# O8 Y# I* {. V#elif ((defined(_IAR_EW_MCS51_)) || (defined(_KEIL_UV_MCS51_)))6 _; M3 b% o8 X& k: b* _: v* v
" |* F, t# P3 f* D
#elif (   defined(_IAR_EW_STM8_) \
2 ?, l- g5 T$ a3 b       || defined(_COSMIC_STM8_) )                        // “......_STM8 编译器”条件编译开始
( \$ C( W) E3 X% b2 ]' `#ifdef _USE_STM8_FWLIB_                                   // “使用 STM8 FWLib 的库文件”条件编译开始
6 U7 D- l  Y' ]# @7 t6 q1 g8 [  K. h1 j/ |% B3 S
#else                                                     // “_USE_STM8_FWLIB_”
. A5 ]3 T  w$ Y    SPICR2        = (u8)( ((1<<spiSSI  )|(1<<spiSSM  )|   // 内部从设备=主模式,使能软件从机设备管理
) m4 r% V. p6 |* G( a                           (1<<spiRXTX )|                 // 只接收,0:全双工(同时发送和接收),1:输出禁止(只接收)
( ?2 z& [8 f- \5 h) u# O                           (0<<spiCRCTX)|(0<<spiCRCEN)|   // 下一个发送的数据来自Tx缓冲区,禁止硬件CRC计算
2 l3 X% H" e, B6 J- I                           (0<<spiBDOE )|(1<<spiBDM  ) ));// 禁止双向模式下输出,使能单线双向数据模式
3 W3 u) H% g7 b3 @. E#endif                                                    // “_USE_STM8_FWLIB_”0 t! j( O3 ~- P5 d1 I7 j
#else) U1 n; R5 ~: E3 ]) `2 t* [7 O
#error 错误:
! z/ v4 P. t2 i/ z7 ]5 {#endif                                                    // “PreMcuIs__......”- F% @6 ]$ z+ {6 Q% q
  }4 Z+ P5 K; B  r- p5 o* A
  MFHSpiModSpiOnn( );                                     // 使能SPI接口模块
' v" Y1 ]7 ?0 m) s0 T$ M0 i: F* ~/ \+ X. u
  (void)temp;                                             // 用以阻止编译器产生[temp]未使用的警告消息* N* u* b: |% c( I& T* _/ U
}
# h8 d& S' t& k
磊元lystudio 回答时间:2015-10-6 21:50:03

$ z6 A3 d/ B8 p/*==========================================================================================================
) ~- T/ ]9 B$ l. w1 p函数名称:  启动SPI接口应用中断方式发送数据# b- ^5 p4 q) I. @9 Z
函数功能:  本函数用于启动SPI接口使用中断方式,进行通讯发送数据作业操作的函数。
! |( g$ j* [0 l, ], d0 e* n' M函数入口参数:*pData ------------------ 指向首个要发送数据在SRAM中的地址指针。
4 z0 P, C9 g& f% s1 H+ y              Length ------------------ 要发送数据的数据总长度。/ n# o- j* R. ?# O4 C5 `
函数返回值: 没有  d# F) ^, h5 C: z/ p
函数出口参数:gbitSpi.Busy ------------ SPI接口〖忙〗,出口值=置位。
4 A2 I1 }  h" F6 I1 V9 i8 C6 v              gbitSpi.Txd ------------- “正在进行发送数据作业”标志,出口值=置位。8 v* Z1 s( L. n* ~# z0 P& ]4 m' c
       gstvSpi.TxSize ---------- 每次发送数据个数大小变量,出口值=Length。: a2 Z: Q* k5 L6 k6 r& _& H
       gstvSpi.TxCnt ----------- 每次发送数据个数计数器变量,出口值=0。
+ n2 r7 y6 ~$ Y6 l: h  d& U6 k       gstvSpi.TxBuf[] --------- 每次发送数据缓冲区数组变量,出口值=要发送的数据。( k+ F4 X0 e/ @! g3 V9 f3 o
       gstvSpi.Cycle ----------- 重新启动通讯收发作业圈数,出口值=0。( Y0 x0 G) |) ~  H. P
调用函数:  1.' r+ C0 B" U$ l0 d8 C
备注:        1.注意:调用本函数之前,必须确定SPI接口在空闲状态。即必须先调用$ K' ^" ]4 N1 B- |
            “unsigned char CommSpiBusBusy(void)”函数,来检查SPI接口的工作状态,
+ E% I& i& x# y; H& W/ E            只有SPI接口处于空闲状态,才允许调用本函数。
0 S6 |9 z: ]7 h  P       2.调用本函数将SPI接口发送中断和错误中断请求。( n9 D1 u0 S. k+ V0 Z7 _+ S7 r, M
==========================================================================================================*/  r8 j/ H" W- s  a  Y: ]0 N  I
#if cSpiTxBufSize < 2568 D, Y/ a" d6 V5 K- K
void  CommSpiTxWithData (unsigned char *pData, unsigned char Length); R1 s" B3 ]( D+ e; S& A
#else# _7 {. ~7 O1 `# v9 L& v
void  CommSpiTxWithData (unsigned char *pData, unsigned int  Length)
0 ]4 L+ S& w+ ^1 W, |" A6 n#endif& w4 p  W0 U- `; k0 Z. v" }
{
# }/ N" B; q/ t$ Q+ s- u/ p#if cSpiTxBufSize < 256
: P6 N. u3 M# Z  register unsigned char    i;                            // 循环变量5 Y4 o0 c& I" ~# W+ B: {0 u
#else
& X! E8 U% {) S8 r$ B* h  register unsigned int     i;7 `* Y- T- a0 E" {7 }
#endif4 ^% X4 G3 n7 S$ ^
  unsigned char             temp;                         // 临时变量
4 E$ T7 F( N5 S7 u8 p3 W  CommSpiDataStru           *pSpi;                        // 指向SPI接口通讯收发数据处理变量的指针& ?; ?* j2 c+ ^
' q* F& b" k: ^4 e" k
  pSpi                      = &gstvSpi;                   // 取SPI接口通讯收发数据处理变量的首个地址* o9 F% q' A9 p, k- T! c
) W  u! W( y6 L/ f6 p$ ^
#ifdef PreCommSpiWithRedundantCode                        // “使用冗余程序代码”条件编译开始
' b2 O$ x% S) o$ X1 U2 k3 b& R  if (   (Length >= (cSpiTxBufSize - 0))
! a  L3 o! F9 Y4 C+ [/ y0 z. ?      || (Length == 0)                   )4 w5 E$ O, a8 t7 |* x" ~7 `; ?* A
  {
/ b# p( b! B9 o( [! X% X    return;
6 d8 c8 a: Y  H( R  }" M5 J3 G: N% v) O# n! \
#endif                                                    // “PreCommSpiWithRedundantCode”/ c/ t- r. t( q& r7 H' Z6 }

/ @/ Y3 a5 `- ^  X//  while(CommSpiBusBusy( ));                               // 等待直到对TWI下一个收发作业准备就绪为止
- Y$ I5 K2 z1 C0 w$ d+ ?- b: x1 o3 ?$ J9 M$ Q& Q( D
  gbitSpi.Busy              =  SET;                       // 置“SPI接口〖忙〗”标志
% X1 z: R5 X9 O  H  W1 N5 ^8 [  gbitSpi.Txd               =  SET;                       // 置“正在进行发送数据作业”标志
* m0 f1 }2 m+ p! D0 w( k0 i  gbitSpi.OverS             =  SET;                       // 置“通讯任务时间超时”标志
7 h9 Y, \) k) A9 ]  pSpi->OverS               =  RtcGetSecByte(cSpiOverSec);// 启动通讯任务时间计时秒表
' w# \7 R. B- e8 W) l: F  MemCopySramToSram(pData, &pSpi->TxBuf[0], Length);      // 复制发送的数据序列到发送数据缓冲区中
- m3 Q; N6 [8 i$ {  pSpi->TxSize              =  Length;                    // 置每次发送数据个数大小值
5 T& R& d6 U2 p" v  pSpi->TxCnt               =  0x01;                      // 每次发送数据计数器值清04 i9 g) k) `3 }$ o6 i% t- \
  pSpi->Cycle               =  0x00;                      // 重新启动通讯收发作业圈数清0
! Q; f3 y$ ~5 ^" f$ n# Z) U  {  MFH_PIN_CFG_OUTL_SpiMosi;                               // 设置SPI主出/ 从入引脚为输出引脚,并为L电平
% U7 m: m) W$ Y2 {( n# B8 S  MFHSpiFlgAllClr( );                                     // 清0SPI接口全部中断标志位
7 @! j: R* M% f0 m) _. W  temp                      =  SPIDR;                     // 清0SPI接口接收中断标志- N- Z- w. _5 M+ Z5 A) a2 L6 t9 N
  SPIDR                     =  pSpi->TxBuf[0];            // 从发送缓冲区中将发送数据写入到SPI接口
% H" e& }4 L) V( ^  MFHSpiIntTxdOnn( );                                     // 使能SPI接口发送中断、错误中断,唤醒中断
9 L% A8 b+ R0 @5 I9 A. ^( t#if   (defined(_IAR_EW_AVR_))
3 T* J2 l$ R7 C, Y  m
5 e: P& R3 x- B  A#elif ((defined(_IAR_EW_MCS51_)) || (defined(_KEIL_UV_MCS51_)))
- Y" j* A2 C( I$ J7 h8 H0 F$ w" Q* F* ^; z4 s- z4 p) V# p+ W. e
#elif (   defined(_IAR_EW_STM8_) \
4 d" I& W' ?' E& T0 u       || defined(_COSMIC_STM8_) )                        // “......_STM8 编译器”条件编译开始3 m9 f- y6 `0 t& U0 z2 x
#ifdef _USE_STM8_FWLIB_                                   // “使用 STM8 FWLib 的库文件”条件编译开始  t) J1 t( D) ]- U
$ _, ?- x1 H: e
#else                                                     // “_USE_STM8_FWLIB_”
! ]( h: j1 ~& ]: u3 t# x( P  SPICR2          = (u8)( ((1<<spiSSI  )|(1<<spiSSM  )|   // 内部从设备=主模式,使能软件从机设备管理2 I9 H# p3 L2 X. Y( o/ c; n
                           (0<<spiRXTX )|                 // 全双工,0:全双工(同时发送和接收),1:输出禁止(只接收)2 z( N" V1 p1 e3 _0 Q
                           (0<<spiCRCTX)|(0<<spiCRCEN)|   // 下一个发送的数据来自Tx缓冲区,禁止硬件CRC计算
  A) {% J+ y: m0 ?. c* b1 F                           (1<<spiBDOE )|(1<<spiBDM  ) ));// 使能双向模式下输出,使能单线双向数据模式
4 c8 w2 R7 Q) w#endif                                                    // “_USE_STM8_FWLIB_”
4 y' `2 @8 O1 r! T# t2 `#else
1 h3 \2 J5 A" p' G#error 错误:0 B$ `) o; r9 X) i  U+ |
#endif                                                    // “PreMcuIs__......”3 ~) N% d3 V) j# t: J: s5 k& A
  MFHSpiModSpiOnn( );                                     // 使能SPI接口模块1 T- O' m# Z7 d# ?) M
6 |' s! |& `- a* |' j1 t- z
  (void)temp;                                             // 用以阻止编译器产生[temp]未使用的警告消息* K+ x+ p6 A' L% S' ?
}
8 ?+ ], U8 T1 O/ x; y; j3 y1 m4 ?$ B4 |7 W' [2 @0 u* X( R
/*==========================================================================================================7 @5 M" G0 S$ u# m
函数名称:  启动SPI接口应用中断方式接收数据
# e' R" ^2 o: h8 j函数功能:  本函数用于启动SPI接口使用中断方式,进行通讯接收数据作业操作的函数。
1 {% g- @* {+ S$ B1 l2 p5 N5 ^函数入口参数:Object ------------------ 要接收数据的的目标设备地址值。
1 T# h+ u4 w$ `              Length ------------------ 要接收数据的数据总长度。
  s$ V; j  l4 m7 S) i, B函数返回值: 没有
* F- ?( e1 r. L& n6 d. P: w函数出口参数:gbitSpi.Busy ------------ SPI接口〖忙〗,出口值=置位。
+ D3 c( W2 z0 R. T; B  d% L: ?              gbitSpi.Txd ------------- “正在进行发送数据作业”标志,出口值=清位。
/ R1 S$ V" F4 U3 j6 Z# C& J       gstvSpi.TxSize ---------- 每次发送数据个数大小变量,出口值=Length。
) D5 Z3 L9 e7 g$ j# }       gstvSpi.TxCnt ----------- 每次发送数据个数计数器变量,出口值=0。
9 ^$ I/ h) G+ O' n- W$ r& w       gstvSpi.TxBuf[] --------- 每次发送数据缓冲区数组变量,出口值=全部为0x00。
0 g- [( Z  H8 i5 A% d! N       gstvSpi.Cycle ----------- 重新启动通讯收发作业圈数,出口值=0。& i" N( t# v+ ^% [- l3 O
              gstvSpi.RxSize ---------- 每次接收数据个数大小变量,出口值=Length。9 U+ T( P( O4 x5 s
              gstvSpi.RxCnt ----------- 每次接收数据个数计数器变量,出口值=0。( y9 V4 N. Y( n/ w3 ?
调用函数:  1.& b" K- q- ?+ G3 A9 L# p% _
备注:        1.注意:调用本函数之前,必须确定SPI接口在空闲状态。即必须先调用
, m8 C  L& j$ f: U+ z+ _) T            “unsigned char CommSpiBusBusy(void)”函数,来检查SPI接口的工作状态,/ X  [$ n8 l7 `' H8 Y
            只有SPI接口处于空闲状态,才允许调用本函数。
6 @. k+ W) }/ p& a+ F       2.调用本函数将SPI接口接收中断和错误中断请求。
3 ], O0 ?6 h1 s6 G; m==========================================================================================================*/$ I8 h% ]1 O/ m9 x* s
#if cSpiRxBufSize < 2561 V8 g5 `+ d1 I, d6 T. w+ c) m
void  CommSpiRxWithData (unsigned char Length)
6 D) o$ ^& S; w#else6 P4 G. E0 M2 q( J8 x% A* p
void  CommSpiRxWithData (unsigned int  Length)
. c0 Z0 n; H6 j" ?#endif
# h. t! A/ W3 \% E{
( Z# ~( C' [. U# _5 \#if cSpiRxBufSize < 256# Q. H5 a7 g; y' [% l& T8 r' {; w
  register unsigned char    i;                            // 循环变量
* ?6 Y' \4 I# X( s#else* g& [8 u, w; O% k! D
  register unsigned int     i;! z3 H) L! p; b/ ~% B- _# ]
#endif
0 U0 y$ t! i6 q  unsigned char             temp;                         // 临时变量
0 u3 _9 x' [7 d" H  CommSpiDataStru           *pSpi;                        // 指向SPI接口通讯收发数据处理变量的指针' i3 d. U* j. [& L( V/ P/ @! f0 E

% i2 @" u1 h$ c4 @( L! E  pSpi                      = &gstvSpi;                   // 取SPI接口通讯收发数据处理变量的首个地址
3 a. [2 Q* Z; H6 _: r) p#ifdef PreCommSpiWithRedundantCode                        // “使用冗余程序代码”条件编译开始
  |6 H3 X  S/ B' ?  if (   (Length > cSpiRxBufSize) )                       // 检查要接收数据的总个数是否超过缓冲区长度?
8 w+ W2 w; I/ {: V( W% _. j5 x  {
" L1 V) F  q2 o6 R. b5 B% t" G    Length                  =  cSpiRxBufSize;             // 截断要接收数据的总个数
7 F: M& k7 H( J) I  O  }
* E& y, x# m8 y7 d#endif                                                    // “PreCommSpiWithRedundantCode”! u: R9 u5 b3 E! j7 x

& d( U3 V" A! f//  while(CommSpiBusBusy( ));                               // 等待直到对TWI下一个收发作业准备就绪为止
$ E* C1 n4 W- Q, R- z' |; T( o6 t" w0 ]% p* S5 m3 h8 {
  gbitSpi.Busy              =  SET;                       // 置“SPI接口〖忙〗”标志0 b9 ]# P7 s5 R& }5 U
  gbitSpi.Txd               =  CLEAR;                     // 清除“正在进行发送数据作业”标志
9 x- t- K. r, A& K! _" U" H  gbitSpi.OverS             =  SET;                       // 置“通讯任务时间超时”标志
4 N3 t; t# z+ \" z: v  pSpi->OverS               =  RtcGetSecByte(cSpiOverSec);// 启动通讯任务时间计时秒表
$ S3 ^  o0 L4 R2 c" l' h) x! h4 O//  MemClearSram(pSpi->TxBuf, Length);                      // 复制发送的数据序列到发送数据缓冲区中9 {1 ?! u6 ?" c1 ]$ Y; j2 q5 Q
//  pSpi->TxSize              =  Length;                    // 置每次发送数据个数大小值+ T2 G- k/ h: i/ ]
//  pSpi->TxCnt               =  0x00;                      // 每次发送数据计数器值清0
$ j" H, L3 u' H' P+ ]; k( m6 @8 M5 o  pSpi->Cycle               =  0x00;                      // 重新启动通讯收发作业圈数清0
2 h' m5 Y3 X4 \# B- e/ Z( C: \" R% G$ @  K( k2 o6 Y+ N* M- z/ \
  pSpi->RxSize              =  Length;                    // 置SPI接口每次接收数据个数大小的值' m; d2 ^* G6 d: W1 }
  pSpi->RxCnt               =  0x00;                      // SPI接口每次接收数据个数计数器清0  z' Z# B2 @6 J" @6 S

; b; c. ]' S0 ]& E% Z  MFH_PIN_CFG_INHZ_SpiMosi;                               // 设置SPI主出/ 从入引脚为输入引脚,并为高阻输入态
$ R- `  q8 j* n6 |# d5 X  MFHSpiFlgAllClr( );                                     // 清0SPI接口全部中断标志位
7 j8 i$ y! a0 _  X8 g% z( B  SPIDR                     =  temp;                      // 清0SPI接口发送中断标志3 A% Y$ C: E7 A
  temp                      =  SPIDR;                     // 清0SPI接口接收中断标志3 {# @* o6 M) h" P1 Z" J
  MFHSpiIntRxdOnn( );                                     // 使能SPI接口接收中断、错误中断,唤醒中断
1 K' s  H8 _3 l! d) t#if   (defined(_IAR_EW_AVR_))9 {: x8 h- G7 c. Q9 d6 n

% Q" J! u  _8 m$ T1 s* h+ ^#elif ((defined(_IAR_EW_MCS51_)) || (defined(_KEIL_UV_MCS51_)))
; Y- V( j+ ]  q: c# P- |
. m3 K. B' W1 y+ ?$ e" f% b( i#elif (   defined(_IAR_EW_STM8_) \8 q3 D6 r$ R7 \/ G9 h* n, }. D
       || defined(_COSMIC_STM8_) )                        // “......_STM8 编译器”条件编译开始
8 x4 E5 |5 p" l5 I#ifdef _USE_STM8_FWLIB_                                   // “使用 STM8 FWLib 的库文件”条件编译开始1 ?) M  p0 t: p

- p( M$ ~( \4 r% M" A#else                                                     // “_USE_STM8_FWLIB_”* R' L2 h3 }; L
  SPICR2          = (u8)( ((1<<spiSSI  )|(1<<spiSSM  )|   // 内部从设备=主模式,使能软件从机设备管理
" X8 V* O6 U0 `/ H                           (1<<spiRXTX )|                 // 只接收,0:全双工(同时发送和接收),1:输出禁止(只接收)
4 x* ?; l! O: k% l3 v/ a7 Z; e                           (0<<spiCRCTX)|(0<<spiCRCEN)|   // 下一个发送的数据来自Tx缓冲区,禁止硬件CRC计算  V3 a3 R" S7 w; j9 z+ c( M/ p
                           (0<<spiBDOE )|(1<<spiBDM  ) ));// 禁止双向模式下输出,使能单线双向数据模式) J6 i, Z3 N/ t7 p
#endif                                                    // “_USE_STM8_FWLIB_”  W2 {# r9 K9 r( A! A
#else& P) e& G% R; g% t9 C
#error 错误:( T  z) f; ~0 i7 ?6 q* s" A" x% U
#endif                                                    // “PreMcuIs__......”- {4 [4 j5 P; q% M
  MFHSpiModSpiOnn( );                                     // 使能SPI接口模块
7 y" x1 T- f; _/ ]& F& }) r* U; a) f6 X9 {0 G
  (void)temp;                                             // 用以阻止编译器产生[temp]未使用的警告消息
* t7 O) P8 w  h+ Q5 J& I& L9 B; y}8 }4 ]5 ~" m0 `9 N# w$ c
磊元lystudio 回答时间:2015-10-6 21:52:09
__IO_REG8_BIT(SPICR1    , 0x5200, __READ_WRITE, __BITS_SPI_CR1      );// SPI控制寄存器11 m$ ~  K2 w* @2 P6 \
__IO_REG8_BIT(SPICR2    , 0x5201, __READ_WRITE, __BITS_SPI_CR2      );// SPI控制寄存器2: A: Z) ]2 |3 ?+ _& I
__IO_REG8_BIT(SPIICR    , 0x5202, __READ_WRITE, __BITS_SPI_ICR      );// SPI中断控制寄存器
& Q* U/ n: B7 P2 w__IO_REG8_BIT(SPISR     , 0x5203, __READ_WRITE, __BITS_SPI_SR       );// SPI状态寄存器7 ^0 w1 }6 O! N* {6 `( h5 y- T
__IO_REG8    (SPIDR     , 0x5204, __READ_WRITE                      );// SPI数据寄存器(SPI_DR)1 ?6 _# f6 m) {- R( V
__IO_REG8    (SPICRCPR  , 0x5205, __READ_WRITE                      );// SPICRC多项式寄存器(SPI_CRCPR)
6 j% F: q- ]$ W4 ___IO_REG8    (SPICRCRR  , 0x5206, __READ                            );// SPI接收CRC寄存器(SPI_RXCRCR)+ X9 E7 r+ a3 r9 I; }9 B% ~7 U
__IO_REG8    (SPICRCTR  , 0x5207, __READ                            );// SPI发送CRC寄存器(SPI_TXCRCR), {- a& I8 _2 f# ?: h
5 H1 p* v' L+ d/ Z: A) q
/*------------------------------------------------------------------------------------------------
' g, Z' E% F* a9 h9 z. i         串行外围设备接口(SPI)- v4 ~1 `, p6 B! y
------------------------------------------------------------------------------------------------*/# j2 W; ?. g6 I0 N$ C) k; r
// SPICR1(SPI_CR1)——— SPI控制寄存器1
" ]# q+ [, ]8 s#define spiCPHA               0                           // 时钟相位控制位,0:数据锁存在下降沿.,1:数据锁存在上升沿
" [, l! u8 Q' Q& f#define spiCPOL               1                           // 时钟空闲极性(仅主机模式有效),0:空闲时SCK 为低电平,1:空闲时SCK 为高电平。* B% N- g; N+ |0 r+ _
#define spiMSTR               2                           // 主/从机模式选择" J6 `- n8 [4 o' G! }
#define spiCS0                3                           // 波特率预分频器选择控制位07 f7 @* t! T' v
#define spiCS1                4                           // 波特率预分频器选择控制位1! @. [: x7 H& w% m+ @1 [5 P0 ?
#define spiCS2                5                           // 波特率预分频器选择控制位2
0 z) O4 p. n5 T  h6 d) p* O#define spiEN                 6                           // SPI启动/停止使能位8 n- a7 B) @6 W; }2 o
#define spiDORD               7                           // 发送数据次序(LSB/MSB字节先后顺序)! n/ X* ?! \! k+ O0 \
" y" J1 o' h  c9 U) a2 X9 L
// SPICR2(SPI_CR2)——— SPI控制寄存器2
: E* n3 |5 c( B# z% k#define spiSSI                0                           // 内部从设备选择6 Q7 L) R) x4 d% V& y4 B5 C7 o
#define spiSSM                1                           // 软件从机设备管理
* f/ s; A  L$ `2 I& `3 q% M, E, O#define spiRXTX               2                           // 只接收,0:全双工(同时发送和接收),1:输出禁止(只接收)- ?, s. ?, F! ]& p. ^4 ?/ z
#define spiCRCTX              4                           // 接着发送CRC,0:下一个发送的数据来自Tx缓冲区,1:下一个发送的数据来自SPICRCTR。+ D$ U2 T4 [, _9 c  S1 p
#define spiCRCEN              5                           // 硬件CRC计算启动/停止使能位
5 U6 g/ I0 I; ]5 l0 u2 s+ J#define spiBDOE               6                           // 双向模式下输出使能. t- u# n# a: M' Q/ J) @
#define spiBDM                7                           // 双向数据模式使能" d# ]4 P* z3 [" Z/ F; _
' x9 m& l" S; Z  l2 o0 F8 O+ U
// SPIICR(SPI_ICR)——— SPI中断控制寄存器
: z; Z4 X: r8 D8 m" [$ k#define spiWUIE               4                           // 唤醒中断使能位2 @. F# Z) A0 @! m% y% W/ f# P
#define spiERRIE              5                           // 错误中断使能位+ Y( I3 }4 {+ t& T
#define spiRXIE               6                           // 接收中断使能位
, j' j% Q% \  g( K6 ~7 o) S) X( X#define spiTXIE               7                           // 发送中断使能位
( c! B) {$ p5 u( h" |2 f  b5 j6 V
// SPISR(SPI_SR)——— SPI状态寄存器
, M# V& }2 \9 ]: ]& r#define spiRXNE               0                           // 接收缓冲区非空标志/ c4 ]7 q+ ?5 n: c. C, H
#define spiDRE                1                           // 发送缓冲区空标志& ]* z( s/ k% ^" X
#define spiWUF                3                           // 唤醒标志- S; k( K4 G$ x, L1 b: \
#define spiCRCEF              4                           // CRC错误标志' G% |  @! S* e$ L
#define spiMODF               5                           // 模式错误标志
9 t9 T7 x$ N. ]! Y6 K' J#define spiOVF                6                           // 溢出标志位% {0 w- J9 T4 }6 s! E, i
#define spiBSY                7                           // 总线忙标志
lkl0305 回答时间:2015-10-6 22:28:53
多谢分享,好长哈 4.png 3.png 2.png 1.png 0.png 5.png
皈依 回答时间:2015-10-7 14:13:45
好长。。。
JackieLaura 回答时间:2015-10-8 09:18:53
谢谢分享
stmcu.org.png
你好我好大家好! 回答时间:2015-10-8 11:12:45
帮顶                              
磊元lystudio 回答时间:2015-10-9 10:34:33
修改一个错误,在驱动HT1621时发现的,会导致HT1621驱动不正常。
9 o3 m3 P3 F, |: Z& i! j& G先输出SCK引脚电平,再停止SPI接口模块,原来的顺序反了。: D7 S% z/ Y7 d, n; V/ N0 o8 _
// 因为SPI接口模块被停止,无法控制SCK引脚电平
4 x6 c5 {- y$ q% O  o#define MFHSpiModSpiOff( )            if (SPICR1 & (u8)( ((1<<spiCPOL ))))                                \
) e( P$ O. p9 W9 [8 G8 y                                      {                                                                   \
# T1 x( d/ ?. i9 O" i  P                                        MFH_PIN_OUT_SETH_SpiSclk;                                         \7 A2 u  g9 n# \
                                      }                                                                   \
5 j% i4 p+ K$ i% w: u* N                                      else                                                                \2 O- ]7 X3 g7 y4 f. K0 a* |7 X
                                      {                                                                   \
( `& H2 {4 _- ~$ Z- I8 q! t4 U: V                                        MFH_PIN_OUT_CLRL_SpiSclk;                                         \
, R0 u+ c! ]$ ?$ t                                      }                                                                   \, l2 k2 _3 y& m" Y' L
                                      SPICR1                       &= (u8)(~((1<<spiEN   )))            ;
懂事儿 回答时间:2016-3-16 11:22:41
哥能打包分享下驱动1621的例程吗?
磊元lystudio 回答时间:2016-3-19 01:24:07
打包没有办法,因为HT1621 字符液晶模块的字段涉及公司的利益,给你一段写入操作供参考:
8 i% @  u. {! ]% R2 w6 ~#ifdef PreHt1621AccessingUseCommSpi                       // “HT1621 字符液晶使用SPI接口访问”条件编译( m6 ^! E$ U8 |, a" f! i
  // 写入全部的字段数值变量静态随机数据缓冲区数值/ c) f- U9 E3 B7 c+ K' a$ J, N! A
  if (   (gbitHt1621.WrRam == SET)* r% Q! J% d% R! p& W# K
      && (gbitSpi.Busy == CLEAR)     )( T& t7 I- ]1 k5 C) B9 A" _
  {0 W  D# S" D) J2 O2 q& r
    switch (gstvSpi.StepSpi)                              // 判断SPI接口操作步骤值?! x6 c' j0 f' S) @; ?/ c
    {
" I# Q5 T' h  t5 M+ A      case 0:                                             // 步骤1:发送“禁止 HT1381 写入保护”操作命令$ C, t, L, Y& Z, m8 c; l$ P
      {- }! ^; v, N& l: _: j& Q" {
        HSB(cHt1621SegSize) =  (cHt1621WriteRev >> 1);
- X1 G) x. u& ^; n3 o) z#ifdef PreHt1621IdleWrPinAsInput                          // “写使能信号引脚空闲时为输入引脚”条件编译
+ T! y8 Z$ ^2 I, c/ p1 x# m" w  W/ m        MFH_PIN_CFG_OUTL_Ht1621Wr;                        // 设置 HT1621 写使能引脚为输出引脚,并确保为L电平(没有操作时)
' n, \: E" L9 d8 `, h% K. M3 h3 x#else3 |* D$ {; }4 I; ~: _
        MFH_PIN_OUT_CLRL_Ht1621Wr;                        // 确保 HT1621 写使能引脚为L电平(没有操作时)
6 \% Y& }  J6 E, Q! q+ c. D/ {% C#endif                                                    // “PreHt1621IdleWrPinAsInput”1 D; n( C% A7 J* W4 ?
        MFH_PIN_OUT_CLRL_Ht1621Cs;                        // 使能 HT1621 片选信号(L电平)
) M% b6 v3 \3 K8 w, {5 T        Ht1621SendBitMsb(cHt1621Write, 1);                // 写入标志码“101(数据写入模式)”的第1位
/ c4 B! F: }8 _/ a  U7 `        CommSpiTxWithData(&HSB(cHt1621SegSize), 1);       // 写入标志码“101”的第2~3位和“Addr”的高 6 位0 q! _; `/ d: |: i) U$ V
9 F" r3 e. G4 b( L
//#ifdef PreHt1621IdleWrPinAsInput                          // “写使能信号引脚空闲时为输入引脚”条件编译1 L) e* |8 _, \8 t( a
//        MFH_PIN_CFG_OUTL_Ht1621Wr;                        // 设置 HT1621 写使能引脚为输出引脚,并确保为L电平(没有操作时)
8 k6 l& w- ~6 m//#else& K  s8 S: x2 [$ T6 \) D
//        MFH_PIN_OUT_CLRL_Ht1621Wr;                        // 确保 HT1621 写使能引脚为L电平(没有操作时)
4 V; e0 s2 b- x" j9 q0 f1 h//#endif                                                    // “PreHt1621IdleWrPinAsInput”% g1 ]5 v& I4 ~6 l! f" z
//        MFH_PIN_OUT_CLRL_Ht1621Cs;                        // 使能 HT1621 片选信号(L电平)5 u/ i: Q6 S5 b) L. ^9 {) C
//        Ht1621SendBitMsb(cHt1621Write, 3);                // 写入标志码“101(数据写入模式)”
* p1 J- l4 J2 O+ i+ t//        Ht1621SendBitMsb(0x00, 6);                        // 写入“Addr”的高 6 位
) ~: _& x' O( o6 l5 }3 _- Y        gstvSpi.StepSpi++;                                // SPI接口操作步骤指向下一步' o- V0 C2 _: C( r( S- f
        break;
9 B$ S0 n  T% t+ I      }- i. L6 j$ _  h* @
      case 1:                                             // 步骤2:连续写入“全部的字段数值变量静态随机数据缓冲区”中的数据. S7 q  ^( n% y! B
      {
$ O- h- E' G1 z/ G        CommSpiTxWithData(&HSB(0), cHt1621SegSize);4 k* u3 r1 i& C& f& b
        gstvSpi.StepSpi++;                                // SPI接口操作步骤指向下一步* H8 u7 ]( H( D# l* ]
        break;
1 o' v1 s0 X4 I6 D      }
; {) q& o0 B5 f" N% D% I      case 2:                                             // 步骤3:
7 G$ h5 Z" H% |+ U. A# L      {
9 d# K+ T. n6 H) R1 A0 C1 O        MFH_PIN_OUT_SETH_Ht1621Cs;                        // 禁止 HT1621 片选信号(H电平)
) A4 A- R9 y9 q6 Z4 W        gstvSpi.StepSpi++;                                // SPI接口操作步骤指向下一步
; h; ]/ i) t8 e5 T& L        break;- L: ~2 b7 d! n& c
      }
9 y& X. ]+ a2 S- q5 ^6 v      default:
/ |2 F4 |2 k+ |( y" G      {: x8 W( l. f8 W2 m) w
        gbitHt1621.WrRdy    =  CLEAR;                     // 清除“写入输出映射缓冲区的数据准备就绪”标志
$ ^( R" [* |- _8 M; k8 R! P        gbitHt1621.WrRam    =  CLEAR;                     // 清除“正在写入输出映射缓冲区的数据”标志
" K0 t( ?* t7 h. ?& C        CommSpiClrSpiOk( );                               // 清除“占用SPI接口”标志  Q$ t4 t* o: o6 M& ^
        break;
) T" S9 o- j7 u% Y# r      }
9 w: u' b4 v4 v    }3 D2 ?# J% f2 S8 Y' v4 G) x
  }
2 G2 E9 |% T# o. i* ^7 y  U( |  if (   (gbitHt1621.WrRdy == SET)
; c7 ]+ e: y  q5 F) Q      && (gbitHt1621.WrRam == CLEAR)
: X( Z; L5 f3 D  O      && (gbitSpi.SpiOk == CLEAR)    )! _" P2 Z/ @' ^9 t( [
  {8 ^+ Y0 e- i6 {+ u
    CommSpiSetSpiOk( );                                   // 设置“占用SPI接口”标志( l0 N. q) v3 X* H& A. w
    CommSpiBusModeDfLhMl(cSpiSpicrCfgDLL256);             // 设置SPI接口为数据锁存在第1个时钟沿、空闲时SCK为低电平、LSB首先发送
; H) j0 K3 c$ b    gbitHt1621.WrRdy        =  CLEAR;                     // 清除“写入输出映射缓冲区的数据准备就绪”标志
  z; a0 n; ^: z! c3 q1 s2 i    gbitHt1621.WrRam        =  SET;                       // 置“正在写入输出映射缓冲区的数据”标志) J1 }! ^) t' s, q' l7 w
  }  z  c1 t; J& @3 y) m# p4 I
#endif                                                    // “PreHt1621AccessingUseCommSpi”
12下一页

所属标签

相似技术帖

关于
我们是谁
投资者关系
意法半导体可持续发展举措
创新与技术
意法半导体官网
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
官方最新发布
人形机器人运动控制、感知与智能配电
半导体创新技术与应用方向
EE架构与软件定义汽车
12V/48V 汽车智能配电(SPD)
区域控制单元(ZCU)与分区架构
关注我们
st-img 微信公众号
st-img 手机版