题目大意

有函数 $S(n)$ 定义如下：

$$ S(n)=\sum{i=0}^{m-1} (-1)^i di^2=d0^2-d1^2+d2^2-d3^2+\cdots + (-1)^{m-1} d_{m-1}^2 $$

这里序列 ${di}$ 是正整数 $n \in [1,2\times 10^6]$ 的所有真约数（去重）的升序排列，求 $\sum{i=1}^n S(i)$

思路

我们先用样例 $n=6$ 打表看看有什么规律：

我们发现，其求和可以变成，

$$ \begin{aligned} \sum_{i=1}^6 S(i)&= 1^2+(1^2-2^2)+(1^2-3^2)+(1^2-2^2+4^2)+(1^2-5^2)+(1^2-2^2+3^2-6^2)\ &= 1^2\times 6 + (-2^2-2^2-2^2)+(-3^2+3^2)+4^2+(-5^2)+(-6^2)\ \end{aligned} $$

不难发现对于某个因子 $d$ 对于整体的贡献，就是其对于某个数 $x\in[1,n]$ 的升序排序的次序。例如因子 $2$ ，其整除的数有 ${2,4,6}$ 在这三个数的因子排序都是第2个，所以其贡献是 $-2^2\times 3$。

那么我们可以根据这个发现，先枚举 $[1,n]$ 的所有因子 $d$ ，然后枚举其倍数 ${d,2d,3d,\cdots | xd \le n}$ ，作一个计数器用于记录其出现的次数，然后根据其出现的次数作贡献即可。

即使用埃氏筛的思想，枚举倍数

[!NOTE]

这里还可以思考下是否存在 $O(n)$ 的线筛做法，我的思路是把每个数作质因数分解，看看是否存在递推（或者化归） $S(n)=S(p1)S(p2)\cdots S(pk)$ 或者 $S(n)=aS(p1)+bS(p2)\cdots +cS(pk)$ 的性质，然后就可以预处理质因数的 $S(n)$ 然后递推了。

但是我代几个数发现似乎并不存在这样的性质，所以这里就不展开了。

代码

using ll = long long;

void sol()
{
    ll n; scanf("%lld",&n);
    ll s=n;  // 先把1的贡献记上
    int cnt[n+1];  //当然还可以使用bool省空间
    memset(cnt,0,sizeof(cnt));
    for(ll i=2; i<=n; i++)
    {
        ll t=i*i;
        s+=(cnt[i]&1? -t:t);
        cnt[i]++;
        for(ll j=2*i; j<=n; j+=i)
        {
            s+=(cnt[j]&1? -t:t);
            cnt[j]++;
        }
    }
    printf("%lld",s);
        
    return;
}

这里外循环 $n$ 次，然后内循环每个 $i$ 执行 $\lfloor \frac{n}{i} \rfloor$ 次 ，总的次数是，

$$ \begin{aligned} T(n)&=\sum{i=1}^n \lfloor \frac{n}{i} \rfloor\ &=n\sum{i=1}^n \frac{1}{i}\ &\le n \int_{1}^{n} \frac{1}{x} dx =n\ln n \end{aligned} $$

即时间复杂度是 $O(n\log n)$ 在2e6下还是可以过的

最后

我们知道了枚举倍数的筛思想，下面引出埃氏筛（筛质数）：

埃氏筛是一种用于筛选质数的算法，其思路是：如果一个数 $n$ 是质数，那么它的倍数 $2n,3n,4n,\cdots$ 一定不是质数。因此，我们可以从 $2$ 开始，依次标记每个质数的倍数，最后剩下的数就是质数。

由于埃氏筛只对质数进行倍数枚举，其时间复杂度是 $O(n\log \log n)$

[!TIP]

类似的题目:

• [GESP202509 五级] 数字选取 筛质数模板题（大雾
• Bitwise Or vs LCM 这里要点放缩的小巧思
• [Brooklyn Round 1 & NNOI Round 1 A] Flying Flower 找到最优策略就好

前言：刷题时意外碰到这题，初见时以为是简单的数论题，求出通项公式再分析即可，但实际又由于出现根号问题无法直接分析。求助好友后才发现是图论题，觉得这种建图方式很有趣，故记录下来，并延申。

题意

ABC446E

题意就是对于一个序列有：

$$ s1=x \ s2=y \ s{i}= As{i-1} + Bs_{i-2} \ , \ i \geq 3 $$

求对于集合 $0\le x \ , \ y \le M-1$ ，x和y不同取值下，无限长的序列中不存在 $M \mid si$ （即 $si$ 不被 M 整除）的(x,y)取值个数。

思路

首先这个通项公式很好写出，就是：

$$ si=c1 \lambda1^i+c2 \lambda_2^i $$

其中 $\lambda1 \ , \ \lambda2$ 是方程 $x^2-Ax-B=0$ 的根， $c1 \ , \ c2$ 是由 $s1=x$ 和 $s2=y$ 决定的常数。

但是很显然是这个底数 $\lambda$ 不一定是整数，比如著名的斐波那契数列，其底数就是带有根号的黄金分割数，直接分析还需要考虑用二项定理展开，然后根据具体的 $c1$ 和 $c2$ 的值，消去根号才能分析，实属复杂。

注意到这里的模数M只有1000，尝试暴力会发现，我们需要分别枚举 $x$ 和 $y$ ，然后对于每个独立的(x,y)，计算在前M*M项数中是否存在%M==0

for(int i=0;i<M;i++)for(int j=0;j<M;j++)
{
    bool ok=true;
    vector<int> s(M*M+1);
    s[1]=i, s[2]=j;
    for(int k=3; k<=M*M; k++)
    {
        s[k]=((ll)A*s[k-1]+(ll)B*s[k-2])%M;
        if(s[k]==0)
        {  
            ok=false;
            break;
        }
    }
    if(ok) ans++;
}

但是这样的复杂度是 $O(M^4)$ ，显然TLE。

图

这里考虑所有的x和y的取值后，序列 ${s}$ 的值必然在模数 $M$ 内
我们作状态 $(u,v):=(s[i-1],s[i])$ ，那么有转移 $(s{i-2},s{i-1}) \to (s{i-1},si)$ ，也就是每个节点有且仅有一条出边（不一定只有一条入边），即外向基环树

那么不同对的(x,y)又应该如何考虑呢？

我们注意到对于 A=1, B=2; 我们取 $(x=0,y=1)$ 有

$$ (s1=0,s2=1) \ , \ (s2=1, s3=1+0=1) \ , \ (s3=1, s4=3)\cdots $$

注意这个节点 $(1,1)$ ，如果我们取 $(x=1,y=1)$ 在数值上也可以得到这个结果 $(s[1]=1,[2]=1)$
也就是说，对于该空间 $M^2$ 内，节点的数值既可以表示 $(x,y)$ 对，同时也是 $(s[i-1],s[i])$

对于该空间 $M^2$ 具体的节点是：

$$ \begin{array}{ccccc} (0,0) & (0,1) & (0,2) & \cdots & (0,M-1) \ (1,0) & (1,1) & (1,2) & \cdots & (1,M-1) \ \vdots & \vdots & \vdots & \ddots & \vdots \ (M-1,0) & (M-1,1) & (M-1,2) & \cdots & (M-1,M-1) \end{array} $$

当然其具体的连接关系为:

$$ (p \ ,\ q) \to (q\ ,\ Aq+Bp\pmod M) $$

题目求有多少个(x,y)产生的序列不含M的倍数，在这个状态空间中也就是确定一个起点(x,y)沿着其出边一直走， 并使其不能碰到x=0或者y=0，统计这样的路径。但是这样直接遍历每个节点（上面的方法），复杂度还是 $O(M^4)$ ，显然会超。

这里说明下一些应该知道的关系

• $M^2=$ 经过含0节点的路径数 $+$ 没经过含0节点的路径数
• 对于所有的 $(x,y)$ 或 $(x,0)$ 或 $(0,0)$ 作为起点的序列必然会经过含0节点
• 如果一个节点的后继是含0节点 那么其前驱的后继的后继也是会经过含0节点

那么必然地，

• 对于从0节点出发，反着走，经过的每个节点所对应的序列，都会经过0节点
  • 也就是从所有的0节点反着出发，经过的每个节点都视为必然有一条路径经过
    • 即经过每个节点计数+1

我们只要 $M^2$ 地遍历节点构造反图，然后从含0节点bfs搜索计数标记节点，然后 $M^2-\text{cnt}$ 即可

代码

inline int encode(int x, int y, int m)
{
    return x*m+y;
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int m,a,b; cin >> m >> a >> b;
    // 这里使用编码存(x,y) x*m+y
    vector<vector<int> > rg(m*m);
    for(int i=0; i<m; i++)
    {
        for(int j=0; j<m; j++)
        {
            int x1=i, y1=j;
            int x2=j, y2=((ll)a*j+(ll)b*i)%m;
            int u=encode(x1,y1,m);
            int v=encode(x2,y2,m);
            rg[v].push_back(u);
        }
    }
    vector<bool> vis(m*m,false);
    queue<int> q;
    
    for(int k=0; k<m; k++)
    {
        int u1=encode(0,k,m);
        if(!vis[u1])
        {
            vis[u1]=true;
            q.push(u1);
        }
        int u2=encode(k,0,m);
        if(!vis[u2])
        {
            vis[u2]=true;
            q.push(u2);
        }
    }
    
    int cnt=0;
    while(!q.empty())
    {
        int u=q.front(); q.pop();
        cnt++;
        for(int v:rg[u])if(!vis[v])
        {
            vis[v]=true;
            q.push(v);
        }
    }
    
    cout << m*m-cnt << endl;
    
    return 0;
}

总结

本题很巧妙地使用了状态空间将序列的集合和(x,y)初始选点的集合合并起来，使得在搜索图（序列结果）中恰好也统计了选点的个数，很妙！

而且注意到每个状态到下一个状态是唯一的，即每个结点只有一条出边，整个图由若干个 基环树 Functional Components 组成，这意味着从任何点出发，最终都会进入一个环。

扩展

下面引出一些数论问题和图论问题的重合部分：

序列的周期与相遇问题

给定 $x{n+1} := (Axn + C) \pmod M$，求序列从何时开始进入循环，循环长度是多少？

数论解法

该问题如果使用数论直接解的话十分复杂，这里只给出大概解法：

1) $C=0$ 时

如果 $C=0$ 即讨论 $xn = A^n x0 \pmod M$ 的周期和进入周期情况。

我们先把 $x0$ 消掉，考虑同余式 $A^nx0 \equiv A^{n+k}x0 \pmod M$ ，那么同时除以其最小公倍数 $g=\gcd(x0,M)$ 得到 ：

$$ A^n \frac{x0}{g} \equiv A^{n+k} \frac{x0}{g} \pmod {\frac{M}{g}} $$

注意到 $\gcd(\frac{x0}{g} ,\frac{M}{g})=1$ ，所以 $\frac{x0}{g}$ 在模 $\frac{M}{g}$ 下有逆元，上式同时乘以 $\frac{x_0}{g}$ 的逆元，得到：

$$ A^n \equiv A^{n+k} \pmod {m} \ , \ (\ m=\frac{M}{g}\ ) \tag{*} $$

然后考虑模m意义下对A幂的影响，提取出关键因子，考虑 $m$ 的质因数分解，设 $m=p1^{q1}p2^{q2}\cdots pn^{qn}$ ，并定：

$$ m1=\prod{1 \le i \le n, pi | A} pi^{qi} \ m2=\prod{1 \le i \le n, pi \nmid A} pi^{qi} \ $$

也就是将 $M$ 分解为含整除 $A$ 的质因数和不含整除 $A$ 的质因数，那么 $(*)$ 式成立当且仅当（CRT）：

$$ A^n \equiv A^{n+k} \pmod {m1} \ A^n \equiv A^{n+k} \pmod {m2} \ $$

• 对于模 $m2$ 的项， $\gcd(A,m2)=1$ ，由欧拉定理有：

  $$ A^{\varphi(m2)} \equiv 1 \pmod {m2} $$

  即在对于这个模数来说，序列 $A \pmod{m2}$ 是循环的，且最小正周期 $t$ 为 $A \pmod{m2}$ 的阶，记作：

  $$ T=\delta{m2}(A) $$

  这里阶满足 $\delta{m2}(A) | \varphi(m2)$ 即阶为 $m2$ 的欧拉函数的约数，这样可以用程序快速求出。
  例如先初始化阶等于其欧拉函数，尝试是否满足 $A^{\delta{m2}(A)} \equiv 1 \pmod {m2}$ ，然后不断除以 $\varphi(m2)$ 的每个质因子，直到不能满足余数为1，此时上个阶即为所求。

• 对于模 $m1$ 的项，由于其所有素因子均能整除 $A$，设存在足够大的 $n$ 使得 $A^n$ 包含 $m1$ 所需的所有素因子幂次。
  即此时 $n$ 满足：

  $$ A^n \equiv 0 \pmod {m_1} $$

  那么对于之后的 $n+k \ , \ k>1$ ， $A^{n+k} \pmod{m_1}$ 仍然满足上述条件。
  我们找到其预周期也就是找到最小的 $t$，使得对于所有 $n \ge t$，都有：

  $$a^n \equiv a^{n+k} \pmod{M_1}$$

  我们记 $vp(x)$ 为 $x$ 的 $p$ 进赋值（即x中质因子p的最高幂次），则对于 $A^n \equiv 0 \pmod{p^{vp(m_1)}}$ 满足：

  $$n\cdot vp(A) \ge vp(m) \Rightarrow n \ge \left \lceil \frac{vp(m)}{vp(A)} \right \rceil$$

  因此，进入周期 $T$ 的最小预周期 $t$ 为：

  $$ t=\max{p|m1} \left \lceil \frac{vp(m)}{vp(A)} \right \rceil $$

  若 $m_1=1$ （即 $\gcd(A,m)=1$ ），则 $t=0$ ，这也印证了当A和m互质时，直接进入大循环。

2) $C \ne 0$ 时

{% note primary no-icon %}

引理：线性同余方程的齐次化 Homogenization Lemma

给定线性同余递归序列 $x{n+1} \equiv Axn + C \pmod M$ ，若满足 $\gcd(A-1, M) = 1$ ，则该序列可以通过坐标平移 $yn = xn - x^*$ 完美等价于齐次序列（即 $C=0$ 的形式）：

$$ y{n+1} \equiv Ayn \pmod M $$

其中 $x^*$ 为递归映射的不动点。

证明:

我们需要找到一个常数 $x^$ ，使得当 $x_n = x^$ 时， $x_{n+1}$ 也等于 $x^*$ 。根据递推式：

$$ x^ \equiv Ax^ + C \pmod M $$

整理得：

$$ (1-A)x^* \equiv C \pmod M $$

又 $\gcd(1-A, M) =\gcd(A-1, M) = 1$ ，那么 $(1-A)$ 在模M下有逆元，即：

$$ x^* \equiv C(1-A)^{-1} \pmod M $$

那么将坐标平移 $yn = xn - x^*$ ，并带入原式，得：

$$ \begin{aligned} & y{n+1}+x^* \equiv A(yn+x^) + C \pmod M \ \Rightarrow & y_{n+1}+x^ \equiv Ayn + (Ax^*+C) \pmod M \ \Rightarrow & y{n+1}+x^ \equiv Ay_n + x^ \pmod M \ , \ \because \ Ax^+C \equiv x^ \pmod M \ \Rightarrow & y{n+1} \equiv Ayn \pmod M \ , \ \text{Subtract x* from both sides} \end{aligned} $$

也就是只要找到 $x^*$ ，就可以将原递推式等价于齐次递推式，从而利用上述方法求解。

{% endnote %}

由引理，可得如果 $\gcd(A-1, M) = 1$ 那么我们直接将递推式齐次化（也就是使得C=0），然后化归为前面的问题，求解即可。

但是如果 $\gcd(A-1, M) \ne 1$ ，即 $(A-1)$ 没有逆元，我们可以尝试扩大模数，令 $zn:=(A-1)xn+C$ ，那么 $z_{n+1}$ 可以表示为：

$$ \begin{aligned} z{n+1}&=(A-1)x{n+1}+C \ &=(A-1)(Axn+C)+C \ &=A(A-1)xn+AC \ &=A\left [(A-1)xn+C \right ] \ &=Azn
\end{aligned} $$

神奇地，$z_{n}$ 的递推关系竟然是齐次的，由于z相对于x被扩大了(A-1)，那么其模数也应该扩大到 $M(A-1)$ :

$$ z{n+1} \equiv Azn \pmod {M(A-1)} \ , \ z0=(A-1)x0+C $$

这与前面齐次的解法一样。

图论解法

这个问题就很显然了，我们直接作状态空间 $xn$ 由于是模M的，所以 $xn={ 0,1,2\cdots M-1 }$ ，其连接关系就是 $x{n+1} = (Axn + C) \pmod M$ 。
我们要求的是进入周期的步长 $t$ ，即从 $x_0=C \pmod M$ 出发，第一次到达环的步长。然后环的长度就是周期 $T$ 。

程序

using ll = long long;

ll A,C,M;

inline ll f(ll x)
{
    return (A*x+C)%M;
}

signed main()
{
    cin >> A >> C >> M;
    // floyd
    ll sl=f(0);
    ll fa=f(sx); // 快慢指针
    while(sl!=fa)
    {
        sl=f(sl);
        fa=f(f(fa));
    }
    // sx,nx都在环上相遇
    // 且i,j到环的入口距离相同
    ll t=0; // 预周期
    ll i=f(0), j=sl;
    // 让i处于x0的位置，j在环入口，不断移动直到相遇
    while(i!=j)
    {
        i=f(i);
        j=f(j);
        t++;
    }
    ll T=1; // 周期
    j=f(i);  // j从环入口下一个结点开始
    while(i!=j) j=f(j), T++;
    
    cout << "pre period:" << t << endl;
    cout << "period:" << T << endl;

    return 0;
}

当然还有直接使用dsu的解法：

using ll = long long;

ll A, C, M;

inline ll f(ll x)
{
    return (A * x + C) % M;
}

signed main()
{
    cin >> A >> C >> M;
    vector<ll> dsu(M, -1);
    ll x=f(0), s=0;
    while(1)
    {
        if(dsu[x]!=-1)
        {
            ll t=dsu[x];     // 预周期
            ll T=s-dsu[x];   // 周期

            cout << t << " " << T << endl;
            break;
        }

        dsu[x]=s;
        x=f(x);
        s++;
    }

    return 0;
}

这里解释下这个简洁的dsu为什么可以完成：

我们假设有这样一个序列，

                            t                             s
x[0] → x[1] → x[2] → … → x[t-1] → x[t] → x[t+1] → … → x[t+T-1]
                              ↑__________________________|
                                         T = s-t

这里在x[t-1]进入环，那么dsu从x[0]开始计数，数到x[t+T-1]时计数步数为s，由x=f(x)进入x[t-1]这个已经被dsu标记过，那么此时dsu[t-1]的计数步数就是预周期t，s-t就是周期。

质因数分解

对于质因数分解，我们最直接就是使用试除法，枚举不大于 $\sqrt{m}$ 的质因子，然后不断除，直到不能整除为止，但是时间复杂度是 $O(\sqrt{m})$ ，对于大数来说显然是不够的。

vector<int> p,ep;
void f(int x)
{
    for(int p=2; p*p<=n; p++)if(n%p==0)
    {
        int c=0;
        while(n%p==0) n/=p,c++;
        p.push_back(p), ep.push_back(c);
    }
    if(n>1) p.push_back(n), ep.push_back(1);
}

数论解法

我们考虑一个奇合数 $n$ 其能被分解成 $n=a\times b$ ，那么其必然是两个平方数的差：

$$ n=x^2-y^2=(x+y)(x-y) $$

这个方法我们可以先让 $x:=\sqrt n $ ，不断向上枚举x，直到 $x^2-n$ 是个完全平方数为止，那么 $y=\sqrt{x^2-n}$ ，然后 $a=x+y$ ， $b=x-y$ ，就可以得到 $n$ 的一个因数分解。
然后继续按照上面的逻辑分解a和b，直到分解到质数为止。

这种方法对于n的两个因子十分接近时，效率会很高。

但是反之，如果n的两个因子差距很大，我们需要枚举到很大的x才能找到这个完全平方数，我们可以考虑同余式：

$$ \begin{aligned} &x^2-y^2=n \ \Rightarrow & x^2-y^2\equiv 0 \pmod n \ \Rightarrow & x^2 \equiv y^2 \pmod n \ \end{aligned} $$

那么我们只要找到 $n | x^2-y^2$ 即可，或者构造 $x^2 \equiv y^2 \pmod n$ 的解，比如随机或者构造平方。

我们考虑利用最大公约数提取因子，如果n整除 (x-y)(x+y) ，这并不代表n一定整除这其中某一个因子。而我们为了质因数分解，肯定不希望(x-y)或者(x+y)不是n的平凡因子（即因子不是1或者n本身），我们需要保证n的因子都分步在这两项中。

我们假设 $n = p \cdot q$（$p, q$ 为互异的质数），那么由CRT有：

$$ \begin{cases} x^2 \equiv y^2 \pmod p \ x^2 \equiv y^2 \pmod q \end{cases} $$

因为 $p$ 是质数，那么 $\Z_p$ 是个域，二次方程 $x^2 - y^2 = 0$ 只有两个解（域上的多项式性质）：

$$ x \equiv y \pmod p \quad \text{OR} \quad x \equiv -y \pmod p $$

同理，对于模 $q$ 也有：

$$ x \equiv y \pmod q \quad \text{OR} \quad x \equiv -y \pmod q $$

也就是在模n的意义下这四个解：

• 平凡解

$$ \begin{cases} x \equiv y \pmod p \ x \equiv y \pmod q \ \end{cases} \Rightarrow (x-y) \equiv 0 \pmod n \ \gcd(x-y, n)=n \text{ which we don't want} \ \begin{cases} x \equiv -y \pmod p \ x \equiv -y \pmod q \ \end{cases} \Rightarrow (x+y) \equiv 0 \pmod n \ \gcd(x+y, n)=n \text{ which we don't want} \ $$

• 非平凡解

$$ \begin{cases} x \equiv y \pmod p \ x \equiv -y \pmod q \ \end{cases} \Rightarrow x \not \equiv \pm y \pmod n \ \text{Thus } \gcd(x-y,n)=p \text{ which we want} \ \begin{cases} x \equiv -y \pmod p \ x \equiv y \pmod q \ \end{cases} \Rightarrow x \not \equiv \pm y \pmod n \ \text{Thus } \gcd(x+y,n)=q \text{ which we want} \ $$

因此我们对于 $n | x^2-y^2$ 再加以非平凡解限定的条件 $x \not \equiv \pm y \pmod n$ ，此时n的一部分因子必然在左右两项都有分布。

具体的分解过程如下：

• 寻找，找到一对 $(x, y)$ 使得 $x^2 \equiv y^2 \pmod n$
• 提取，计算 $g = \gcd(x-y, n)$
• 拆分， $n := g \times (\frac{n}{g})$。我们将 $a$ 和 $b = \frac{n}{a}$ 视为新的待分解数
• 终止，如果某个数通过 Miller-Rabin 等算法检测为质数，则停止对该分支的迭代

即产生了一颗递归树——因子分解树。

程序

using ll = long long;

ll mul(ll a, ll b, ll mod)
{
    return (__int128)a * b % mod;
}

ll qpow(ll a, ll b, ll mod)
{
    ll res=1;
    while(b)
    {
        if(b&1) res=mul(res, a, mod);
        a=mul(a, a, mod);
        b >>= 1;
    }
    return res;
}

bool MillerRabin(ll n)
{
    if (n < 2) return false;
    for (ll p : {2, 3, 5, 7, 11, 13, 17, 19, 23})
    {
        if (n % p == 0) return n == p;
    }

    ll d = n - 1, s = 0;
    while ((d & 1) == 0)
    {
        d >>= 1;
        s++;
    }

    auto check = [&](ll a)
    {
        ll x = qpow(a, d, n);
        if (x == 1 || x == n - 1) return true;
        for (int i = 1; i < s; i++)
        {
            x = mul(x, x, n);
            if (x == n - 1) return true;
        }
        return false;
    };

    for (ll a : {2, 325, 9375, 28178, 450775, 9780504, 1795265022})
    {
        if (a % n == 0) continue;
        if (!check(a)) return false;
    }

    return true;
}

ll PollardRho(ll n)
{
    if(~n&1) return 2;
    while(1)
    {
        ll x=rand()%(n-2)+2;
        ll y=x;
        ll c=rand()%(n-1)+1;

        auto f=[&](ll x)
        {
            return (mul(x, x, n)+c)%n;
        };

        ll d=1;

        while(d==1)
        {
            x=f(x);
            y=f(f(y));
            d=__gcd(abs(x - y), n);
        }
        if(d!=n) return d;
    }
}

map<ll,int> mp; // <p,ep>

// 质因数分解
void factor(ll n)
{
    if(n==1) return;

    if(MillerRabin(n))
    {
        mp[n]++;
        return;
    }

    // 用PollardRho分解
    ll d=PollardRho(n);
    factor(d);
    factor(n/d);
}

图论解法

原题大意

给出一个大数$N$其形式为：

$$ \overbrace{c{k-1}; c{k-1}; \cdots; c{k-1}}^{l{k-1}}\cdots\overbrace{c1; c1; \cdots; c1}^{l1}\overbrace{c0; c0; \cdots; c0}^{l0} \tag{*} $$

其中 $ci\in{0,1,\cdots,9} \ , \ 1 \le li \le 10^9 , \ 1 \le k \le 10^5$

求 $\lfloor \frac{N}{M} \rfloor \pmod {10007} $

思路

我们考虑将向下取整符号去掉，

$$ \because \ n=q \cdot m+r \ (0 \le r < m) \tag{**} \ \therefore \ q=\frac{n-r}{m}=\frac{n-n\mod m}{m} \ $$

对于 $\text{ans}:=\lfloor \frac{n}{m} \rfloor \pmod {M} $ 可以化成：

$$ \begin{aligned} \text{ans} :&= (n-n\mod m)\cdot \text{inv}(m) \pmod {M} \ &=[\ (n \mod M - (n\mod m)\mod M +M) \mod M ]\cdot \text{inv}(m) \pmod {M} \ \end{aligned} $$

我们记 $ \text{inv}(m) $ 为 $m$ 在模 $M$ 意义下的逆元 ，并令：

$$ rm:=n \mod m \ rM:=n \mod M $$

又由 $(*)$ 式可知：

$$ \begin{aligned} rM&=\overbrace{c{k-1}; c{k-1}; \cdots; c{k-1}}^{l{k-1}}\cdots\overbrace{c1; c1; \cdots; c1}^{l1}\overbrace{c0; c0; \cdots; c0}^{l0} \pmod {M} \ &=\sum{i=0}^{k-1} ci 10^{l0+l1+\cdots+l{i-1}}\sum{j=0}^{li-1} 10^{j} \pmod {M} \ , \ \ \text{let} \ \ si=\sum{j=0}^{i-1} lj \ &=\sum{i=0}^{k-1}ci10^{si}\sum{j=0}^{li-1}10^j \pmod {M} \ &=\sum{i=0}^{k-1}10^{si}\cdot G(l_i,M) \pmod {M} \ \end{aligned} $$

这里 $G(li,M)$ 表示 $ci\cdot(10^0+10^1+\cdots+10^{l_i-1})\pmod M$
可以使用几何级数的递推公式求出：

$$ G(n,M)=\begin{cases} G(l/2,M) \cdot (10^{l/2} + 1) \pmod M & l \text{ is even} \ G(l-1) \cdot 10 + c_i \pmod M & l \text{ is odd} \end{cases} $$

同理：

$$ \begin{aligned} rm&=\overbrace{c{k-1}; c{k-1}; \cdots; c{k-1}}^{l{k-1}}\cdots\overbrace{c1; c1; \cdots; c1}^{l1}\overbrace{c0; c0; \cdots; c0}^{l0} \pmod {m} \ &=\sum{i=0}^{k-1}ci10^{si}\sum{j=0}^{li-1}10^j \pmod {m} \ &=\sum{i=0}^{k-1}10^{si}\cdot G(l_i,m) \pmod {m} \ \end{aligned} $$

然后将 $rm$ 和 $rM$ 改成递推的形式（从高位到低位），就可以在 $O(k)$ 的时间复杂度内求出答案。

$$ \begin{aligned} rm&:=(rm\cdot 10^{li}+G(li\ ,\ m)\ ) \pmod m \ rM&:=(rM\cdot 10^{li}+G(li \ ,\ M)\ ) \pmod M \ \end{aligned} $$

代码

const ll M=10007;

ll qpow(ll a, ll b, ll m)
{
    ll res=1;
    a%=m;
    while(b)
    {
        if(b&1)res=res*a%m;
        a=a*a%m;
        b>>=1;
    }
    return res;
}

ll inv(ll x)
{
    return qpow(x,M-2,M);
}

ll sum(ll l, ll m)
{
    if(l==0)return 0;
    if(l==1)return 1;
    if(~l&1)return sum(l>>1, m)*(qpow(10, l>>1, m)+1)%m;
    return (sum(l-1,m)*10+1)%m;
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    ll k,m; cin >> k >> m;
    vector<pll> A(k);
    for(int i=k-1; i>=0; i--)
        cin >> A[i].first >> A[i].second;

    ll a=0, rm=0, p=1, pm=1;
    
    // 这里是从低位到高位递推的
    for(auto [c,l]:A)
    {
        ll ca=c*sum(l,M)%M;
        a=(a+ca*p)%M;
        p=p*qpow(10,l,M)%M;
        
        ll cm=c*sum(l,m)%m;
        rm=(rm+cm*pm)%m;
        pm=pm*qpow(10,l,m)%m;
    }
    
    ll ans=(a-(rm%M)+M)%M*inv(m)%M;
    cout<<ans;

    return 0;
}

扩展

M不是质数

如果M不是质数，但 $gcd(m,M)≠1$ 那么逆元 $ \text{inv}(m) $ 可以用扩展欧几里得算法求出；
但 $gcd(m,M)≠1$ 时，逆元根本不存在，这是 $(**)$ 式可以变形成：

$$ m \cdot q \equiv (rM-rm) \pmod M \tag{*} $$

一个关于q的线性同余方程组，可以先提取公因子 $g=gcd(m,M)$ 归一化，

$$ \frac{m}{g} \equiv \frac{(rM-rm)}{g} \pmod {\frac{M}{g}} $$

此时 $gcd(\frac{m}{g} , \frac{M}{g})=1$ ，就可以用扩展欧几里得算法求出特解，

$$ q0 \equiv \frac{(rM-r_m)}{g} \cdot \text{inv}(\frac{m}{g}) \pmod {\frac{M}{g}} $$

在加上 $k$ 个 $\frac{M}{g}$ ，就可以得到通解：

$$ q=q_0+k \cdot \frac{M}{g} \ , \ k=0,1,2,\cdots, g-1 $$

但是 $k$ 是由 $n$ 唯一确定的，只通过 $rm \ , \ rM $ 而不计算 n/m 时是无法直接确定k的，应该换个思路。

显然这里 $gcd(n,M)>1$ 对于周期为 $M$ 的 $rM$ 以及周期为 $m$ 的 $rm$ 来说，将周期扩大到其最小公倍数 $mM$ 。
这样当n加上m时 $\lfloor n/m \rfloor$ 就增加1，继续增加到 $nM$ 后此时商就变成了M，在模M意义下又回到了0，当然是符合向下取整后取余的。
具体地，我们设n对 $mM$ 的商为Q余数为R，那么有：

$$ n=Q(m\cdot M)+R \ , \ 0 \le R < mM $$

我们要算的是 $\lfloor \frac{n}{m} \rfloor \pmod M$。将 $n$ 代入，得：

$$ \begin{aligned} \lfloor \frac{n}{m} \rfloor \pmod M &= \lfloor \frac{Q(m\cdot M)+R}{m} \rfloor \pmod M \ &= \left(QM + \lfloor \frac{R}{m} \rfloor \right) \pmod M \ &= 0+ \lfloor \frac{R}{m} \rfloor \pmod M \ &=\frac{n \pmod {m \cdot M} }{m} \pmod M \end{aligned} $$

这样完美避开了逆元和k无法确定的问题。

m和l变大

如果 $1 \le m,l \le 10^{18}$ ，最暴力的方法就是直接使用大数模拟完成，例如以下程序：

#include <bits/stdc++.h>
using namespace std;

using i128 = __int128;
using ll = long long;

i128 mul(i128 a, i128 b, i128 m)
{
    i128 res=0;
    while(b)
    {
        if(b&1) res=(res+a)%m;
        a=(a+a)%m;
        b>>=1;
    }
    return res;
}

pair<i128,i128> calc(i128 l,i128 m)
{
    if(l==0) return {1%m,0};
    if(l==1) return {10%m,1%m};
    auto [p,s]=calc(l>>1,m);
    i128 p2=mul(p,p,m), s2=(mul(s,p,m)+s)%m;
    if(~l&1) return {p2,s2};
    else return {mul(p2,10,m),(mul(s2,10,m)+1)%m};
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    int k;ll m,M;
    cin >> k >> m >> M;

    i128 mM=(i128)m*M, cur=0;
    for(int i=0;i<k;i++)
    {
        ll c,l; cin >> c >> l;
        auto [p,g]=calc(l,mM);
        i128 add=mul((i128)c,g,mM);
        cur=(mul(cur,p,mM)+add)%mM;
    }

    i128 ans=(cur/m)%M;
    cout<<(ll)ans;
}

但是很不幸，由于防止过程中乘法溢出，这里使用了模数乘法，导致最后的时间复杂度变成 $O(k \log l \cdot \log (m\cdot M))$ ，显然会T。

如果预处理 $10^i$ 模 $m\cdot M$ 的各项/和，但由于范围过大防止溢出，还是只能通过模数乘法来计算，时间复杂度仍然不变。

拆模

{% note info no-icon %}

引理：

今有一长度为 $l$ 的十进制数 $n$ ，

$$ n:=\sum{i=0}^{l-1}di10^i \ ,\ 0 \le c_i < 10 $$

那么其 $\lfloor n/m \rfloor \mod M$ 的结果可以表示为：

$$ \begin{aligned} \lfloor n/m \rfloor \pmod M &= \lfloor \frac{\sum{i=0}^{l-1}di10^{i}}{m} \rfloor \pmod M \ &=\lfloor \frac{\sum{i=2}^{l-1}di10^{i}}{m} +\frac{(d1d0){10}}{m} \rfloor \pmod M \ &=\lfloor \frac{\sum{i=2}^{l-1}di10^{i-2}}{m} \cdot 10^2 +\frac{(d1d0){10}}{m} \rfloor \pmod M \ \end{aligned} $$

我们记数字的前i位（高i位）为 $ni:=\sum{j=l-i-1}^{l-1}d_j10^j$ ，那么有：

$$ \begin{aligned} qi:&=\lfloor \frac{ni}{m} \rfloor \pmod M = \lfloor \frac{\sum{j=l-i-1}^{l-1}dj10^{j-2}}{m} \rfloor \pmod M \ ri:&=ni \pmod m =\sum{j=l-i-1}^{l-1}dj10^{j-2} \pmod m \ ni&=qi \cdot m+ri \ ,\ 0 \le ri < m \end{aligned} $$

令 $n0=d{l-1}$ 不难发现有递推公式：

$$ \begin{aligned} n{i+1}&=ni\cdot 10+d{l-i-1}\ r{i+1}&=n_{i+1} \pmod m \

   &=(10q_im+10r_i+d_{l-i-1}) \pmod m \
   &=10r_i+d_{l-i-1} \pmod m \

q{i+1}&=\lfloor \frac{n{i+1}}{m} \rfloor \pmod M \

   &=\lfloor \frac{10q_im+10r_i+d_{l-i-1}}{m} \rfloor \pmod M \
   &=10q_i +\lfloor \frac{10r_i+d_{l-i-1}}{m} \rfloor \pmod M \

\end{aligned} $$

这样就可以递推处理商了，而且很好地避免了逆元等情况。

{% endnote %}

为了处理乘法范围过大，同时复杂度又不能接受，由上面的引理我们可以想到维护 $q\ ,\ r$ 模M，通过之前的递推公式，我们知道从高位到低位读入时有：

$$ \begin{aligned} n{i+1}&=ni\cdot 10^{li}+ci \sum{j=0}^{li-1}10^j \ \end{aligned} $$

那么其商和余数的递推公式可以写成：

$$ \begin{aligned} r{i+1}&=(10^{li} ri+ci\sum{j=0}^{li-1}10^j) \pmod m \ q{i+1}&=\left( 10^{li}qi + \left \lfloor \frac{10^{li} ri+ci\sum{j=0}^{li-1}10^j}{m} \right \rfloor \right) \pmod M \end{aligned} $$

这里使用预处理 $10^i$ 分别模M和m的个项和合，然后把长度 $l$ 用二进制拆成若干个 $2^i$ 的和，这样就可以在 $O(k \log l)$ 的时间复杂度内求出答案。

{% note warning no-icon %}

#include <bits/stdc++.h>
using namespace std;

using i128 = __int128;
using ll = long long;

const int LOG=60;
vector<ll> p10m(LOG), p10M(LOG);
vector<ll> s10m(LOG), s10M(LOG);

void init(ll m, ll M)
{
    p10m[0]=10%m,p10M[0]=10%M;
    s10m[0]=1%m,s10M[0]=1%M;

    for(int i=1;i<LOG;i++)
    {
        p10m[i]=(i128)p10m[i-1]*p10m[i-1]%m;
        p10M[i]=(i128)p10M[i-1]*p10M[i-1]%M;
        s10m[i]=((i128)s10m[i-1]*p10m[i-1]+s10m[i-1])%m;
        s10M[i]=((i128)s10M[i-1]*p10M[i-1]+s10M[i-1])%M;
    }
}

pair<i128,i128> calc(i128 l,i128 mod,
                     const vector<ll>& p10,
                     const vector<ll>& s10)
{
    i128 p=1,s=0;
    for(int i=0;l;i++,l>>=1)
        if(l&1)
        {
            p=p*p10[i]%mod;
            s=(s*p10[i]+s10[i])%mod;
        }
    return {p,s};
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    int k;ll m,M;
    cin >> k >> m >> M;
    init(m,M);  
    i128 r=0, q=0;
    for(int i=0;i<k;i++)
    {
        ll c,l; 
        cin >> c >> l;
        auto [p,s]=calc(l,m,p10m,s10m);
        auto [P,S]=calc(l,M,p10M,s10M);  
        i128 t=(i128)p*r+(i128)c*s;
        r=t%m;
        q=((i128)P*q+t/m) % M;
    }
    cout << (ll)q;
}

但是这样写WA了，原因是对于 $q{i+1}$ 的向下取整的分子应该是除了 $ri$ 剩下都不应该取模，以上程序计算 $10^{li} ri+ci\sum{j=0}^{l_i-1}10^j$ 时，对于10的次幂以及和都做了取模处理，这显然是错误的。

如果使用模数为 $mM$ ，同样地，中间过程计算的积肯定会溢出，此时又用懒乘法，导致时间复杂度又变回去了。

{% endnote %}

{% note success no-icon %}

下面给出正确至少可以ac的代码 虽然是pypy版本 ，直接完整地算出其分子：

import sys

def sol():
    it=iter(map(int, sys.stdin.read().split()))
    try:
        K=next(it); m=next(it); M=next(it)
    except StopIteration: return

    mM = m * M
    P, S = [10%mM], [1%mM]
    for i in range(62):
        S.append((S[i]*P[i]+S[i])%mM)
        P.append((P[i]*P[i])%mM)

    r, q = 0, 0
    for _ in range(K):
        c, l = next(it), next(it)
        p, s, i = 1, 0, 0
        l = l
        while l:
            if l&1:
                s=(s*P[i]+S[i])%mM
                p=(p*P[i])%mM
            l>>=1
            i+=1
        t = r*p+c*s
        q = (q*(p%M)+(t%mM//m))%M # 这里利用之前的结论扩大模数mM
        r = t%m
        
    sys.stdout.write(str(q))

if __name__ == "__main__":
    sol()

得益于pypy的JIT，这个代码既可以简洁地保持高精度，又可以在2.5s内跑完。

{% endnote %}

拆彻底

该渲染由 Shiro API 生成，可能存在排版问题，最佳体验请前往：https://blog.teslongxiao.cn/posts/default/20250305

module adder(
    input  [7:0] a,
    input  [7:0] b,
    output [7:0] y
);

assign y = a + b;

endmodule  

module example(
    input a,b,
    output y;
);

endmodule;   // 结束模块关键字是必要的

module example(a,b,c);
    input a,b;
    output c;

endmodule;  

module example(input a1,a2,a3, output y1, y2);
    assign y1=a1, y2=a1, y2=a3; // 这里逗号用法和C/Cpp一样
endmodule;

看完了？说点什么呢

前言

使用助飞的wifi模块直接修改main中的ssid和pwd，在串口通信日志中显示无法连接，遂修改其源码进行debug

代码

我添加了具体的调试信息，包括首次使用前扫描WIFI SSID、idle的INT引脚上拉和延长等待时间，具体调试信息例如：

[wifi_spi] wifi_scan result:
SSID:i-WZU RSSI:-66
SSID:WZU-free RSSI:-66
SSID:i-WZU RSSI:-66
SSID:banpaixitong RSSI:-66
SSID:banpaixitong RSSI:-65
SSID:banpa
[wifi_spi] target SSID 'nutin' NOT found
[wifi_spi] wifi_connect: ssid='nutin' pass='121144169' len=18
[wifi_spi] set_parameter start, cmd=0x10, len=18
[wifi_spi] set_parameter: slave ready for write
[wifi_spi] set_parameter: header+data written
[wifi_spi] wait_idle timeout, level=0
[wifi_spi] set_parameter: idle wait timeout after write
[wifi_spi] wait_idle timeout, level=0
[wifi_spi] wifi_connect result=1 ip=
[wifi_spi] error: wifi_connect failed (code=1)
[MAIN] wifi_spi_init attempt 1 failed
[MAIN] wifi_ssid: nutin, password: 121144169
[MAIN] retrying...

[wifi_spi] init: performing reset...
[wifi_spi] init: reset done, mutex set idle
[wifi_spi] init: get firmware version...
[wifi_spi] firmware version: V2.0.0

[wifi_spi] mac address: 9C:13:9E:C5:5F:18

[wifi_spi] attempt wifi_connect -> ssid: nutin, password: 121144169
[wifi_spi] set_parameter start, cmd=0x12, len=0
[wifi_spi] set_parameter: slave ready for write
[wifi_spi] set_parameter: header+data written
[wifi_spi] set_parameter: slave ready after write
[wifi_spi] set_parameter: reply command=0x80
[wifi_spi] set_parameter: reply OK
[wifi_spi] wifi_scan result:
SSID:banpaixitong RSSI:-66
SSID:DIRECT-50-HP M227f LaserJet RSSI:-66
SSID:TP-LINK-A1 RSSI:-65
SSID:WZU-free RSSI:-65
SSID:WZU-f
[wifi_spi] target SSID 'nutin' NOT found
[wifi_spi] wifi_connect: ssid='nutin' pass='121144169' len=18
[wifi_spi] set_parameter start, cmd=0x10, len=18
[wifi_spi] set_parameter: slave ready for write
[wifi_spi] set_parameter: header+data written
[wifi_spi] wait_idle timeout, level=0
[wifi_spi] set_parameter: idle wait timeout after write
[wifi_spi] wait_idle timeout, level=0
[wifi_spi] wifi_connect result=1 ip=
[wifi_spi] error: wifi_connect failed (code=1)
[MAIN] wifi_spi_init attempt 2 failed
[MAIN] wifi_ssid: nutin, password: 121144169
[MAIN] retrying...

zf_device_wifi_spi.c

/*********************************************************************************************************************
* STC32G144K Opensourec Library 即（STC32G144K 开源库）是一个基于官方 SDK 接口的第三方开源库
* Copyright (c) 2025 SEEKFREE 逐飞科技
*
* 本文件是STC32G144K开源库的一部分
*
* STC32G144K 开源库 是免费软件
* 您可以根据自由软件基金会发布的 GPL（GNU General Public License，即 GNU通用公共许可证）的条款
* 即 GPL 的第3版（即 GPL3.0）或（您选择的）任何后来的版本，重新发布和/或修改它
*
* 本开源库的发布是希望它能发挥作用，但并未对其作任何的保证
* 甚至没有隐含的适销性或适合特定用途的保证
* 更多细节请参见 GPL
*
* 您应该在收到本开源库的同时收到一份 GPL 的副本
* 如果没有，请参阅<https://www.gnu.org/licenses/>
*
* 额外注明：
* 本开源库使用 GPL3.0 开源许可证协议 以上许可申明为译文版本
* 许可申明英文版在 libraries/doc 文件夹下的 GPL3_permission_statement.txt 文件中
* 许可证副本在 libraries 文件夹下 即该文件夹下的 LICENSE 文件
* 欢迎各位使用并传播本程序 但修改内容时必须保留逐飞科技的版权声明（即本声明）
*
* 文件名称          
* 公司名称          成都逐飞科技有限公司
* 版本信息          查看 libraries/doc 文件夹内 version 文件 版本说明
* 开发环境          MDK FOR C251
* 适用平台          STC32G144K
* 店铺链接          https://seekfree.taobao.com/
*
* 修改记录
* 日期              作者           备注
* 2025-11-20        大W            first version
********************************************************************************************************************/
/*********************************************************************************************************************
* 接线定义：
*                   ------------------------------------
*                   模块管脚            单片机管脚
*                   RST                 查看 zf_device_wifi_spi.h 中 WIFI_SPI_RST_PIN 宏定义
*                   INT                 查看 zf_device_wifi_spi.h 中 WIFI_SPI_INT_PIN 宏定义
*                   CS                  查看 zf_device_wifi_spi.h 中 WIFI_SPI_CS_PIN 宏定义
*                   MISO                查看 zf_device_wifi_spi.h 中 WIFI_SPI_MISO_PIN 宏定义
*                   SCK                 查看 zf_device_wifi_spi.h 中 WIFI_SPI_SCK_PIN 宏定义
*                   MOSI                查看 zf_device_wifi_spi.h 中 WIFI_SPI_MOSI_PIN 宏定义
*                   5V                  5V 电源
*                   GND                 电源地
*                   其余引脚悬空
*                   ------------------------------------
*********************************************************************************************************************/

#include "stdio.h"
#include "zf_common_clock.h"
#include "zf_common_debug.h"
#include "zf_common_fifo.h"
#include "zf_driver_delay.h"
#include "zf_driver_gpio.h"
#include "zf_driver_spi.h"
#include "zf_device_type.h"

#include "zf_device_wifi_spi.h"

#define WIFI_CONNECT_TIME_OUT       10000       // 单位毫秒
#define SOCKET_CONNECT_TIME_OUT     50000       // 单位毫秒
#define OTHER_TIME_OUT              1000        // 单位毫秒

#if ((WIFI_SPI_RECVIVE_SIZE < 32) || (WIFI_SPI_RECVIVE_SIZE > 4088))
    #error "WIFI_SPI_RECVIVE_SIZE must be >= 32 or <= 4088"
#endif

#if (WIFI_SPI_RECVIVE_SIZE >= WIFI_SPI_RECVIVE_FIFO_SIZE)
    #error "WIFI_SPI_RECVIVE_FIFO_SIZE must be > WIFI_SPI_RECVIVE_SIZE"
#endif


#if (WIFI_SPI_TRANSFER_SIZE != 4088)
    #error "WIFI_SPI_TRANSFER_SIZE must be == 4088"
#endif



char wifi_spi_version[12] = {0};                      // 保存模块固件版本信息
char wifi_spi_mac_addr[20] = {0};                     // 保存模块MAC地址信息
char wifi_spi_ip_addr_port[25] = {0};                 // 保存模块IP地址与端口信息

static fifo_struct  wifi_spi_fifo = {0};
static uint8        wifi_spi_buffer[WIFI_SPI_RECVIVE_FIFO_SIZE] = {0};
static volatile     wifi_spi_state_enum wifi_spi_mutex = {0};
//-------------------------------------------------------------------------------------------------------------------
// 函数简介     等待WIFI SPI就绪
// 参数说明     wait_time       最大等待时间 单位毫秒
// 返回参数     uint8           状态 0-成功 1-错误
// 使用示例     内部使用，用户无需关心
// 备注信息     
//-------------------------------------------------------------------------------------------------------------------
static uint8 wifi_spi_wait_idle (uint32 wait_time)
{
    uint32 time = 0;
    uint8 level;
    
    wait_time = wait_time*100;
    while(1)
    {
        level = gpio_get_level(WIFI_SPI_INT_PIN);
        if(level)
            break;
        system_delay_us(10);
        time++;
        if(wait_time <= time)
        {
            printf("[wifi_spi] wait_idle timeout, level=%d\r\n", level);
            break;
        }
    }
    return (wait_time <= time);
}

//-------------------------------------------------------------------------------------------------------------------
// 函数简介     写入数据到WIFI SPI
// 参数说明     *buffer1        第一组需要发送的数据缓冲区地址
// 参数说明     length1         第一组数据长度
// 参数说明     *buffer2        第二组需要发送的数据缓冲区地址
// 参数说明     length2         第二组数据长度
// 返回参数     void           
// 使用示例     内部使用，用户无需关心
// 备注信息     
//-------------------------------------------------------------------------------------------------------------------
static void wifi_spi_dma_write (const uint8 *buffer1, uint16 length1, const uint8 *buffer2, uint16 length2)
{
    WIFI_SPI_CS(0);
    if(NULL != buffer1)
    {
        spi_dma_write_8bit_array(WIFI_SPI_INDEX, buffer1, length1);
    }
    if(NULL != buffer2)
    {
        spi_dma_write_8bit_array(WIFI_SPI_INDEX, buffer2, length2);
    }
    WIFI_SPI_CS(1);
}

//-------------------------------------------------------------------------------------------------------------------
// 函数简介     WIFI SPI 发送与接收同时进行（命令收发）
// 参数说明     *packets        发送与接收的地址
// 参数说明     length          需要接收的长度
// 返回参数     void           
// 使用示例     内部使用，用户无需关心
// 备注信息     
//-------------------------------------------------------------------------------------------------------------------
static void wifi_spi_dma_transfer_command (wifi_spi_packets_struct *packets, uint16 length)
{
    WIFI_SPI_CS(0);
    
    spi_dma_transfer_8bit(WIFI_SPI_INDEX, (uint8 *)&(packets->head), (uint8 *)&(packets->head), sizeof(wifi_spi_head_struct));
    
    if(length)
    {
        spi_dma_transfer_8bit(WIFI_SPI_INDEX, (const uint8 *)(packets->buffer), packets->buffer, length);
    }
    // 大小端不一致，高低字节交换
    packets->head.length = (uint16)((packets->head.length&0xFF) << 8) | ((packets->head.length >> 8) & 0xFF);
    
    WIFI_SPI_CS(1);
}

//-------------------------------------------------------------------------------------------------------------------
// 函数简介     WIFI SPI 发送与接收同时进行(数据收发)
// 参数说明     *write_data     发送的数据缓冲区地址
// 参数说明     *read_data      接收到的数据的存储地址
// 参数说明     length          需要接收的长度
// 返回参数     void           
// 使用示例     内部使用，用户无需关心
// 备注信息     
//-------------------------------------------------------------------------------------------------------------------
static void wifi_spi_dma_transfer_data (const uint8 *write_data, wifi_spi_packets_struct *read_data, uint16 length)
{
    WIFI_SPI_CS(0);
    
    read_data->head.command = WIFI_SPI_DATA;
    // 大小端不一致，高低字节交换
    read_data->head.length  = (uint16)((length&0xFF) << 8) | ((length >> 8) & 0xFF);;
    
    spi_dma_transfer_8bit(WIFI_SPI_INDEX, (uint8 *)&(read_data->head), (uint8 *)&(read_data->head), sizeof(wifi_spi_head_struct));
    
    if(WIFI_SPI_RECVIVE_SIZE < length)
    {
        spi_dma_transfer_8bit(WIFI_SPI_INDEX, write_data, read_data->buffer, WIFI_SPI_RECVIVE_SIZE);
        spi_dma_write_8bit_array(WIFI_SPI_INDEX, &write_data[WIFI_SPI_RECVIVE_SIZE], length - WIFI_SPI_RECVIVE_SIZE);
    }
    else
    {
        // 将需要发送的数据拷贝到读取缓冲区，避免出现write_data越界访问
        memcpy(read_data->buffer, write_data, length);
        spi_dma_transfer_8bit(WIFI_SPI_INDEX, read_data->buffer, read_data->buffer, WIFI_SPI_RECVIVE_SIZE);
    }
    
    // 大小端不一致，高低字节交换
    read_data->head.length = (uint16)((read_data->head.length&0xFF) << 8) | ((read_data->head.length >> 8) & 0xFF);
    
    WIFI_SPI_CS(1);
}

//-------------------------------------------------------------------------------------------------------------------
// 函数简介     WIFI SPI 参数设置
// 参数说明     command         命令类型
// 参数说明     *buffer         参数地址
// 参数说明     length          参数长度
// 参数说明     wait_time       最大等待时间 单位100微妙
// 返回参数     uint8           状态 0-成功 1-错误
// 使用示例     内部使用，用户无需关心
// 备注信息     
//-------------------------------------------------------------------------------------------------------------------
static uint8 wifi_spi_set_parameter (wifi_spi_packets_command_enum command, uint8 *buffer, uint16 length, uint32 wait_time)
{
    uint8 return_state;
    wifi_spi_head_struct head;
    return_state = 1;
    printf("[wifi_spi] set_parameter start, cmd=0x%02X, len=%d\r\n", command, length);
    do
    {
        head.command = command;
        head.length  = length;
        
        // 等待从机准备就绪
        if(wifi_spi_wait_idle(wait_time))
        {
            printf("[wifi_spi] set_parameter: idle wait timeout before write\r\n");
            break;
        }
        printf("[wifi_spi] set_parameter: slave ready for write\r\n");

        wifi_spi_dma_write(&head.command, sizeof(wifi_spi_head_struct), buffer, length);
        printf("[wifi_spi] set_parameter: header+data written\r\n");
        if(wifi_spi_wait_idle(wait_time))
        {
            printf("[wifi_spi] set_parameter: idle wait timeout after write\r\n");
            break;
        }
        printf("[wifi_spi] set_parameter: slave ready after write\r\n");
        // 接收应答信号

        head.command = WIFI_SPI_DATA;
        head.length = 0;
        wifi_spi_dma_transfer_command((wifi_spi_packets_struct *)&head, head.length);
        system_delay_us(20);
        printf("[wifi_spi] set_parameter: reply command=0x%02X\r\n", head.command);
        if(WIFI_SPI_REPLY_OK == head.command)
        {
            return_state = 0;
            printf("[wifi_spi] set_parameter: reply OK\r\n");
        }
        else
        {
            printf("[wifi_spi] set_parameter: reply not OK\r\n");
        }
    }while(0);
    
    return return_state;
}

//-------------------------------------------------------------------------------------------------------------------
// 函数简介     WIFI SPI 模块信息获取
// 参数说明     command         命令类型
// 参数说明     *buffer         保存接收到的参数地址
// 参数说明     wait_time       最大等待时间 单位100微妙
// 返回参数     uint8           状态 0-成功 1-错误
// 使用示例     内部使用，用户无需关心
// 备注信息     
//-------------------------------------------------------------------------------------------------------------------
static uint8 wifi_spi_get_parameter (wifi_spi_packets_command_enum command, wifi_spi_packets_struct *read_data, uint32 wait_time)
{
    uint8 return_state;

    return_state = 1;
    do
    {
        // 等待从机准备就绪
        if(wifi_spi_wait_idle(wait_time))
        {
            break;
        }
        read_data->head.command = command;
        wifi_spi_dma_write(&(read_data->head.command), WIFI_SPI_RECVIVE_SIZE, NULL, 0);

        if(wifi_spi_wait_idle(wait_time))
        {
            break;
        }
        read_data->head.command = WIFI_SPI_DATA;
        read_data->head.length = 0;
        wifi_spi_dma_transfer_command(read_data, WIFI_SPI_RECVIVE_SIZE);
        return_state = 0;
    }while(0);
    return return_state;
}

//-------------------------------------------------------------------------------------------------------------------
// 函数简介     WIFI SPI 固件版本获取
// 参数说明     void            端口号
// 返回参数     uint8           状态 0-成功 1-错误
// 使用示例     
// 备注信息     调用函数之后，固件版本信息以字符串形式保存在wifi_spi_version数组中
//-------------------------------------------------------------------------------------------------------------------
static uint8 wifi_spi_get_version (void)
{
    uint8 return_state;
    wifi_spi_packets_struct temp_packets = {0};

    return_state = wifi_spi_get_parameter(WIFI_SPI_GET_VERSION, &temp_packets, OTHER_TIME_OUT);
    if((0 == return_state) && (WIFI_SPI_REPLY_VERSION == temp_packets.head.command))
    {
        memcpy(wifi_spi_version, temp_packets.buffer, temp_packets.head.length);
    }
    return return_state;
}

//-------------------------------------------------------------------------------------------------------------------
// 函数简介     WIFI SPI MAC地址获取
// 参数说明     void            端口号
// 返回参数     uint8           状态 0-成功 1-错误
// 使用示例     
// 备注信息     调用函数之后，MAC地址信息以字符串形式保存在wifi_spi_mac_addr数组中
//-------------------------------------------------------------------------------------------------------------------
static uint8 wifi_spi_get_mac_addr (void)
{
    uint8 return_state;
    wifi_spi_packets_struct temp_packets;

    return_state = wifi_spi_get_parameter(WIFI_SPI_GET_MAC_ADDR, &temp_packets, OTHER_TIME_OUT);
    if((0 == return_state) && (WIFI_SPI_REPLY_MAC_ADDR == temp_packets.head.command))
    {
        memcpy(wifi_spi_mac_addr, temp_packets.buffer, temp_packets.head.length);
    }
    return return_state;
}

//-------------------------------------------------------------------------------------------------------------------
// 函数简介     WIFI SPI IP地址与端口号获取
// 参数说明     void            端口号
// 返回参数     uint8           状态 0-成功 1-错误
// 使用示例     
// 备注信息     调用函数之后，IP地址与端口号信息以字符串形式保存在wifi_spi_ip_addr_port数组中
//              需要在连接Socket之后调用此函数才能正常获取信息
//-------------------------------------------------------------------------------------------------------------------
static uint8 wifi_spi_get_ip_addr_port (void)
{
    uint8 return_state;
    wifi_spi_packets_struct temp_packets;

    return_state = wifi_spi_get_parameter(WIFI_SPI_GET_IP_ADDR, &temp_packets, OTHER_TIME_OUT);
    if((0 == return_state) && (WIFI_SPI_REPLY_IP_ADDR == temp_packets.head.command))
    {
        memcpy(wifi_spi_ip_addr_port, temp_packets.buffer, temp_packets.head.length);
    }
    return return_state;
}

//-------------------------------------------------------------------------------------------------------------------
// 函数简介     WIFI SPI 获取系统时间
// 参数说明     time_format     时间格式
// 返回参数     *buffer         保存时间字符串地址 缓冲区大小至少需要30个字节
// 返回参数     buffer_size     缓冲区大小 
// 返回参数     uint8           状态 0-成功 1-错误
// 使用示例     
// 备注信息     需要连接有网络的热点之后才能获取到正确的时间，并且在调用这个函数之前需要确保WIFI模块中需要接收的数据已经全部接收完毕
// 备注信息     仅WIFI SPI 外接天线版本支持
// 备注信息     输出的信息为字符串信息，可直接printf到串口助手查看
//-------------------------------------------------------------------------------------------------------------------
uint8 wifi_spi_get_time (wifi_spi_time_enum time_format, char *buffer, uint8 buffer_size)
{
    uint8 return_state = 1;
    wifi_spi_packets_struct temp_packets;
    uint8 send_cmd, receive_cmd;
    
    // 接收时间的数组必须大于30个字节
    // 并且模块固件必须是V2版本
    if((30 <= buffer_size) && (!strncmp(wifi_spi_version, "V2", 2)))
    {
        send_cmd = WIFI_SPI_GET_TIME1 + time_format - WIFI_SPI_UTC_0;
        receive_cmd = WIFI_SPI_REPLY_TIME1 + time_format - WIFI_SPI_UTC_0;

        return_state = wifi_spi_get_parameter(send_cmd, &temp_packets, OTHER_TIME_OUT);
        if((0 == return_state) && (receive_cmd == temp_packets.head.command))
        {
            return_state = strncmp((const char *)temp_packets.buffer, "OK", 2);
            if(0 == return_state)
            {
                memcpy(buffer, &temp_packets.buffer[3], temp_packets.head.length - 3);
                buffer[temp_packets.head.length - 3] = 0;
            }
        }
    }
    return return_state;
}

//-------------------------------------------------------------------------------------------------------------------
// 函数简介     WIFI SPI 扫描热点
// 参数说明     *buffer         保存扫描到的热点信息 包含名称与信号强度，每个信号强度后面会跟一个换行符
// 参数说明     buffer_size     缓冲区的长度
// 返回参数     uint8           状态 0-成功 1-错误
// 使用示例     
// 备注信息     仅WIFI SPI 外接天线版本支持
// 备注信息     输出的信息为字符串信息，可直接printf到串口助手查看
// 备注信息     每一行包含一个wifi名称与密码 
//-------------------------------------------------------------------------------------------------------------------
uint8 wifi_spi_wifi_scan (char *buffer, uint16 buffer_size)
{
    uint8 return_state = 0;

    
    // 模块必须是V2版本的固件才支持此功能
    if(!strncmp(wifi_spi_version, "V2", 2))
    {
        return_state = wifi_spi_set_parameter(WIFI_SPI_SET_WIFI_SCAN, NULL, 0, WIFI_CONNECT_TIME_OUT);
        
        if(0 == return_state)
        {
        #if (0 == WIFI_SPI_READ_TRANSFER)
            wifi_spi_send_buffer(NULL, 0);
        #endif
            while(0 == wifi_spi_read_buffer((uint8 *)buffer, buffer_size))
            {
                system_delay_ms(10);
            }
        }
    }
    
    return return_state;
}

//-------------------------------------------------------------------------------------------------------------------
// 函数简介     WIFI SPI 设置连接的WiFi信息并尝试连接WiFi
// 参数说明     *wifi_ssid      WIFI名称
// 参数说明     *pass_word      WIFI密码
// 返回参数     uint8           状态 0-成功 1-错误
// 使用示例     wifi_spi_wifi_connect("SEEKFREE", "SEEKFREE123");
// 备注信息     wifi_spi_wifi_connect("SEEKFREE", NULL); // 连接没有密码的WIFI热点
//-------------------------------------------------------------------------------------------------------------------
// helper: simple substring search (returns 1 if found)
static uint8 wifi_spi_str_contains(const char *haystack, const char *needle)
{
    const char *p, *q;
    if(NULL == haystack || NULL == needle)
        return 0;
    while(*haystack)
    {
        p = haystack;
        q = needle;
        while(*p && *q && (*p == *q))
        {
            p++;
            q++;
        }
        if(!*q) // reached end of needle
            return 1;
        haystack++;
    }
    return 0;
}

uint8 wifi_spi_wifi_connect (char *wifi_ssid, char *pass_word)
{
    uint8 return_state;
    uint8 temp_buffer[64];
    uint16 length;
    char scan_buf[128];

    // 在尝试连接之前先扫描附近的热点
    scan_buf[0] = '\0';
    return_state = wifi_spi_wifi_scan(scan_buf, sizeof(scan_buf)-1);
    if(0 == return_state)
    {
        printf("[wifi_spi] wifi_scan result:\r\n%s\r\n", scan_buf);
        if(wifi_spi_str_contains(scan_buf, wifi_ssid))
        {
            printf("[wifi_spi] target SSID '%s' found\r\n", wifi_ssid);
        }
        else
        {
            printf("[wifi_spi] target SSID '%s' NOT found\r\n", wifi_ssid);
        }
    }
    else
    {
        printf("[wifi_spi] wifi_scan error %d\r\n", return_state);
    }

    if(NULL != pass_word)
    {
        // WIFI热点有密码发送热点名称与密码
        length = sprintf((char *)temp_buffer, "%s\r\n%s\r\n", wifi_ssid, pass_word);
    }
    else
    {
        // WIFI热点没有密码只需要发送热点名称
        length = sprintf((char *)temp_buffer, "%s\r\n", wifi_ssid);
    }
    
    /* debug info */
    printf("[wifi_spi] wifi_connect: ssid='%s' pass='%s' len=%d\r\n", wifi_ssid, (pass_word?pass_word:"(none)"), length);
    return_state = wifi_spi_set_parameter(WIFI_SPI_SET_WIFI_INFORMATION, temp_buffer, length, WIFI_CONNECT_TIME_OUT);
    
    // 本机IP地址与端口号信息以字符串形式保存在wifi_spi_ip_addr_port数组中
    wifi_spi_get_ip_addr_port();
    printf("[wifi_spi] wifi_connect result=%d ip=%s\r\n", return_state, wifi_spi_ip_addr_port);
    
    return return_state;
}

//-------------------------------------------------------------------------------------------------------------------
// 函数简介     WIFI SPI 设置连接的Socket信息并尝试连接Socket
// 参数说明     *transport_type 传输类型
// 参数说明     *ip_addr        IP地址
// 参数说明     *port           目标端口号
// 参数说明     *local_port     本机端口号
// 返回参数     uint8           状态 0-成功 1-错误
// 使用示例     wifi_spi_socket_connect("TCP", "192.168.2.5", "8080", "6060");
// 备注信息     
//-------------------------------------------------------------------------------------------------------------------
uint8 wifi_spi_socket_connect (char *transport_type, char *ip_addr, char *port, char *local_port)
{
    uint8 return_state;
    uint8 temp_buffer[41];
    uint16 length;
    
    printf("[wifi_spi] socket_connect: transport=%s target=%s:%s local=%s\r\n", transport_type, ip_addr, port, local_port);
    length = sprintf((char *)temp_buffer, "%s\r\n%s\r\n%s\r\n%s\r\n", transport_type, ip_addr, port, local_port);
        
    return_state = wifi_spi_set_parameter(WIFI_SPI_SET_SOCKET_INFORMATION, temp_buffer, length, SOCKET_CONNECT_TIME_OUT);
    
    // 本机IP地址与端口号信息以字符串形式保存在wifi_spi_ip_addr_port数组中
    wifi_spi_get_ip_addr_port();
    printf("[wifi_spi] socket_connect result=%d ip=%s\r\n", return_state, wifi_spi_ip_addr_port);
    
    return return_state;
}

//-------------------------------------------------------------------------------------------------------------------
// 函数简介     WIFI SPI 断开Socket连接
// 参数说明     void            
// 返回参数     uint8           状态 0-成功 1-错误
// 使用示例     wifi_spi_socket_disconnect();
// 备注信息
//-------------------------------------------------------------------------------------------------------------------
uint8 wifi_spi_socket_disconnect (void)
{
    wifi_spi_packets_struct temp_packets;

    return wifi_spi_get_parameter(WIFI_SPI_CLOSE_SOCKET, &temp_packets, OTHER_TIME_OUT);
}

//-------------------------------------------------------------------------------------------------------------------
// 函数简介     WIFI SPI 软复位
// 参数说明     void            
// 返回参数     uint8           状态 0-成功 1-错误
// 使用示例     
// 备注信息     
//-------------------------------------------------------------------------------------------------------------------
uint8 wifi_spi_reset (void)
{
    uint8 return_state;
    wifi_spi_head_struct head;
    return_state = 1;
    do
    {
        head.command = WIFI_SPI_RESET;
        head.length  = 0xA5A5;
        return_state = wifi_spi_wait_idle(OTHER_TIME_OUT);
        if(return_state)
        {
            break;
        }
        wifi_spi_dma_write(&head.command, sizeof(wifi_spi_head_struct), NULL, 0);
    }while(0);
    
    return return_state;
}

//-------------------------------------------------------------------------------------------------------------------
// 函数简介     WIFI SPI UDP模式时立即发送函数
// 参数说明     void
// 返回参数     uint8           状态 0-成功 1-错误
// 使用示例     
// 备注信息     在UDP模式下模块收到数据后会等待2毫秒，2毫秒后未收到数据则将数据通过socket发送到网络，如果希望立即发送则在数据传输完毕后调用此函数
//-------------------------------------------------------------------------------------------------------------------
uint8 wifi_spi_udp_send_now (void)
{
    uint8 return_state = 1;
    wifi_spi_packets_struct temp_packets;
    
    if(WIFI_SPI_IDLE == wifi_spi_mutex)
    {
        // 将通讯状态设置为忙
        wifi_spi_mutex = WIFI_SPI_BUSY;
        do
        {
            if(wifi_spi_wait_idle(OTHER_TIME_OUT))
            {
                break;
            }

            // 立即开始socket发送
            temp_packets.head.command = WIFI_SPI_UDP_SEND;
            temp_packets.head.length = 0;
            wifi_spi_dma_transfer_command(&temp_packets, WIFI_SPI_RECVIVE_SIZE);
            
            // 检查收到的包中是否有数据
            if((WIFI_SPI_REPLY_DATA_START == temp_packets.head.command) || (WIFI_SPI_REPLY_DATA_END == temp_packets.head.command))
            {
                // 保存接收到的数据
                if(temp_packets.head.length)
                {
                    fifo_write_buffer(&wifi_spi_fifo, temp_packets.buffer, temp_packets.head.length);
                }
            }
            
            // 等待应答信号
            if(wifi_spi_wait_idle(OTHER_TIME_OUT))
            {
                break;
            }
            
            // 接收应答信号
            temp_packets.head.command = WIFI_SPI_DATA;
            temp_packets.head.length = 0;
            wifi_spi_dma_transfer_command(&temp_packets, temp_packets.head.length);
            
            if(WIFI_SPI_REPLY_OK == temp_packets.head.command)
            {
                return_state = 0;
            }
            
        }while(0);
        
        // 将通讯状态设置为空闲
        wifi_spi_mutex = WIFI_SPI_IDLE;
    } 
    
    return return_state;
}

//-------------------------------------------------------------------------------------------------------------------
// 函数简介     WIFI SPI 数据块发送函数并同步接收数据
// 参数说明     *buff           需要发送的数据地址
// 参数说明     length          发送长度
// 返回参数     uint32          剩余未发送的长度
// 使用示例     wifi_spi_send_buffer(buffer, 100);
// 备注信息     
//-------------------------------------------------------------------------------------------------------------------
uint32 wifi_spi_send_buffer (const uint8 *buffer, uint32 length)
{
    uint16 send_length;
    wifi_spi_packets_struct temp_packets;
    
    // 检查WIFI SPI状态，如果在其他中断或者线程中已经发起了通讯，则本次不能发送数据
    if(WIFI_SPI_IDLE == wifi_spi_mutex)
    {
        // 将通讯状态设置为忙
        wifi_spi_mutex = WIFI_SPI_BUSY;
        
        while(length)
        {
            send_length = length > WIFI_SPI_TRANSFER_SIZE ? WIFI_SPI_TRANSFER_SIZE : length;
            
            if(wifi_spi_wait_idle(OTHER_TIME_OUT))
            {
                break;
            }
            
            wifi_spi_dma_transfer_data(buffer, &temp_packets, send_length);
            
            // 检查收到的包中是否有数据
            if((WIFI_SPI_REPLY_DATA_START == temp_packets.head.command) || (WIFI_SPI_REPLY_DATA_END == temp_packets.head.command))
            {
                // 保存接收到的数据
                if(temp_packets.head.length)
                {
                    fifo_write_buffer(&wifi_spi_fifo, temp_packets.buffer, temp_packets.head.length);
                }
            }
            
            length -= send_length;
            buffer += send_length;
        }
        
        // 检查最后一次的接收是否将所有的数据都接收完毕
        while(WIFI_SPI_REPLY_DATA_START == temp_packets.head.command)
        {
            if(wifi_spi_wait_idle(OTHER_TIME_OUT))
            {
                break;
            }
            
            // 继续读取模块剩余数据
            temp_packets.head.command = WIFI_SPI_DATA;
            temp_packets.head.length  = 0;
            wifi_spi_dma_transfer_command(&temp_packets, WIFI_SPI_RECVIVE_SIZE);
            // 检查收到的包中是否有数据
            if((WIFI_SPI_REPLY_DATA_START == temp_packets.head.command) || (WIFI_SPI_REPLY_DATA_END == temp_packets.head.command))
            {
                // 保存接收到的数据
                if(temp_packets.head.length)
                {
                    fifo_write_buffer(&wifi_spi_fifo, temp_packets.buffer, temp_packets.head.length);
                }
            }
        }
        wifi_spi_mutex = WIFI_SPI_IDLE;
    }
    return length;
}

//-------------------------------------------------------------------------------------------------------------------
// 函数简介     WIFI SPI 字符串发送函数并同步接收数据
// 参数说明     *string           需要发送的字符串
// 返回参数     void          
// 使用示例     wifi_spi_send_string("123");
// 备注信息     
//-------------------------------------------------------------------------------------------------------------------
void wifi_spi_send_string(const char *string)
{
    wifi_spi_send_buffer((uint8*)string, strlen(string));
}
    
//-------------------------------------------------------------------------------------------------------------------
// 函数简介     WIFI SPI 读取缓冲区
// 参数说明     *buff           接收缓冲区
// 参数说明     length          读取数据长度
// 返回参数     uint32          实际读取数据长度
// 使用示例     wifi_spi_read_buffer(buffer, 100);
// 备注信息     
//-------------------------------------------------------------------------------------------------------------------
uint32 wifi_spi_read_buffer (uint8 *buffer, uint32 length)
{
    uint32 fifo_read_length;
    uint32 write_length = 0;
    wifi_spi_packets_struct temp_packets;

    zf_assert(NULL != buffer);

    // 首先判断FIFO中是否有数据，如果有则先从FIFO读取
    if(fifo_used(&wifi_spi_fifo))
    {
        fifo_read_length = fifo_used(&wifi_spi_fifo);
        fifo_read_length = length < fifo_read_length ? length : fifo_read_length;
        fifo_read_buffer(&wifi_spi_fifo, buffer, &fifo_read_length, FIFO_READ_AND_CLEAN);
        
        buffer += fifo_read_length;
        length -= fifo_read_length;
        write_length += fifo_read_length;
    }
    
#if(1 == WIFI_SPI_READ_TRANSFER)
    if(WIFI_SPI_IDLE == wifi_spi_mutex)
    {
        wifi_spi_mutex = WIFI_SPI_BUSY;                         // 将通讯状态设置为忙
        
        do
        {
            if( (WIFI_SPI_RECVIVE_SIZE > wifi_spi_fifo.siz) || // 如果缓冲区空间不够则不再读取
                (wifi_spi_wait_idle(OTHER_TIME_OUT))            // 超时退出
              )
            {
                break;
            }
            
            temp_packets.head.command = WIFI_SPI_DATA;
            temp_packets.head.length  = 0;
            wifi_spi_dma_transfer_command(&temp_packets, WIFI_SPI_RECVIVE_SIZE);
            // 检查收到的包中是否有数据
            if( ((WIFI_SPI_REPLY_DATA_START == temp_packets.head.command) || (WIFI_SPI_REPLY_DATA_END == temp_packets.head.command)) &&
                (temp_packets.head.length)
              )
            {
                if(length)
                {
                    fifo_read_length = length >= temp_packets.head.length ? temp_packets.head.length : length;
                    memcpy(buffer, temp_packets.buffer, (uint32)fifo_read_length);
                    buffer += fifo_read_length;
                    length -= fifo_read_length;
                    write_length += fifo_read_length;
                    if(fifo_read_length < temp_packets.head.length) // 外部缓冲不足多余部分写入FIFO
                    {
                        fifo_write_buffer(&wifi_spi_fifo, temp_packets.buffer + fifo_read_length, temp_packets.head.length - fifo_read_length);
                    }
                }
                else                                                // 全部写入FIFO
                {
                    fifo_write_buffer(&wifi_spi_fifo, temp_packets.buffer, temp_packets.head.length);
                }
            }
        }while(WIFI_SPI_REPLY_DATA_START == temp_packets.head.command);
        wifi_spi_mutex = WIFI_SPI_IDLE;
    }
#endif
    
    return write_length;
}

//-------------------------------------------------------------------------------------------------------------------
// 函数简介     WiFi 模块初始化
// 参数说明     *wifi_ssid      目标连接的 WiFi 的名称 字符串形式
// 参数说明     *pass_word      目标连接的 WiFi 的密码 字符串形式
// 返回参数     uint8           模块初始化状态 0-成功 1-错误
// 使用示例     wifi_spi_init("SEEKFREE", "SEEKFREE123");
// 备注信息     wifi_spi_init("SEEKFREE", NULL); // 连接没有密码的WIFI热点
//-------------------------------------------------------------------------------------------------------------------
uint8 wifi_spi_init (char *wifi_ssid, char *pass_word)
{
    uint8 return_state = 0;


    fifo_init(&wifi_spi_fifo, FIFO_DATA_8BIT, wifi_spi_buffer, WIFI_SPI_RECVIVE_FIFO_SIZE);
    spi_dma_init(WIFI_SPI_INDEX, SPI_MODE3, WIFI_SPI_SPEED, WIFI_SPI_SCK_PIN, WIFI_SPI_MOSI_PIN, WIFI_SPI_MISO_PIN, SPI_CS_NULL);//硬件SPI初始化

    gpio_init(WIFI_SPI_CS_PIN,  GPO, 1, GPO_PUSH_PULL);
    gpio_init(WIFI_SPI_RST_PIN, GPO, 1, GPO_PUSH_PULL);
    gpio_init(WIFI_SPI_INT_PIN, GPI, 0, GPI_PULL_DOWN);
    
    // 复位
    printf("[wifi_spi] init: performing reset...\r\n");
    gpio_set_level(WIFI_SPI_RST_PIN, 0);
    system_delay_ms(10);
    gpio_set_level(WIFI_SPI_RST_PIN, 1);
    
    // 等待模块初始化
    system_delay_ms(100);
    wifi_spi_mutex = WIFI_SPI_IDLE;
    printf("[wifi_spi] init: reset done, mutex set idle\r\n");

    do
    {
        // 固件版本信息以字符串形式保存在wifi_spi_version数组中
        printf("[wifi_spi] init: get firmware version...\r\n");
        return_state = wifi_spi_get_version();
        if(return_state)
        {
            printf("[wifi_spi] error: get_version failed (code=%d)\r\n", return_state);
            break;
        }
        else
        {
            printf("[wifi_spi] firmware version: %s\r\n", wifi_spi_version);
        }
      
        // MAC地址信息以字符串形式保存在wifi_spi_mac_addr数组中
        wifi_spi_get_mac_addr();
        printf("[wifi_spi] mac address: %s\r\n", wifi_spi_mac_addr);

        if(NULL == wifi_ssid)
        {
            // 初始化的时候不需要连接WIFI
            printf("[wifi_spi] no SSID provided, skip wifi connect\r\n");
            break;
        }

        printf("[wifi_spi] attempt wifi_connect -> ssid: %s, password: %s\r\n", wifi_ssid, (pass_word?pass_word:"(none)"));
        return_state = wifi_spi_wifi_connect(wifi_ssid, pass_word);
        if(return_state)
        {
            printf("[wifi_spi] error: wifi_connect failed (code=%d)\r\n", return_state);
            break;
        }
        else
        {
            // 获取并打印本机 IP 信息
            wifi_spi_get_ip_addr_port();
            printf("[wifi_spi] wifi connected, ip: %s\r\n", wifi_spi_ip_addr_port);
        }
        
    #if(1 == WIFI_SPI_AUTO_CONNECT)
        printf("[wifi_spi] AUTO_CONNECT enabled, attempting TCP socket connect to %s:%s\r\n", WIFI_SPI_TARGET_IP, WIFI_SPI_TARGET_PORT);
        return_state = wifi_spi_socket_connect("TCP", WIFI_SPI_TARGET_IP, WIFI_SPI_TARGET_PORT, WIFI_SPI_LOCAL_PORT);
        if(return_state)  
        {
            printf("[wifi_spi] error: auto TCP socket_connect failed (code=%d)\r\n", return_state);
            break;
        }
        else
        {
            printf("[wifi_spi] auto TCP socket connected, local/remote: %s\r\n", wifi_spi_ip_addr_port);
        }
    #endif
        
    #if(2 == WIFI_SPI_AUTO_CONNECT)
        return_state = wifi_spi_socket_connect("UDP", WIFI_SPI_TARGET_IP, WIFI_SPI_TARGET_PORT, WIFI_SPI_LOCAL_PORT);
        if(return_state)
        {
            break;
        }
    #endif
    }while(0);

    return return_state;
}

main.c

    while(wifi_spi_init(WIFI_SSID_TEST, WIFI_PASSWORD_TEST))
    {
+       init_attempt++;
+       printf("[MAIN] wifi_spi_init attempt %d failed\r\n", init_attempt);  
+       if(wifi_pw)
+           printf("[MAIN] wifi_ssid: %s, password: %s\r\n", WIFI_SSID_TEST, wifi_pw);
+       else
+           printf("[MAIN] wifi_ssid: %s, password: (none)\r\n", WIFI_SSID_TEST);

+       printf("[MAIN] retrying...\r\n\r\n");
        system_delay_ms(100);                                                   // 初始化失败 等待 100ms
    }

结论

该wifi scan输出缓存只有128字节，输出没有我的热点不代表没有找到，看样子还是没有把GPIO INT拉高。

后续发现队友可以成功连接wifi，说明该程序的wifi_spi_set_parameter函数中两个中断没有问题，此时才视角回到wifi源头（热点），看手机上开启了第六代技术(802.11ax)导致这种单片机无法使用新技术，一直在尝试连接然后超时了，之后关闭这个选项单片机就成功连接上TCP服务器，但是看main里面的摄像头开启函数，无输出log，查看具体的摄像头init发现应该是找搜寻设备，应该还是超时了，进程一直卡在搜索中，具体没写debug的log，之后还需添加log进行调试。