DIY ESP8266 WIFI自动校时LED点阵滚动时钟，支持OTA升级/自动调节亮度

zengcym · 发表于 2019-12-25 17:51:27

爱科技、爱创意、爱折腾、爱极致，我们都是技术控

您需要登录才可以下载或查看，没有账号？立即注册

x

今天再给大家分享一个连接WIFI自动校时的LED点阵滚动时钟，参考外网程序加自己修改，主要特点：
1.无需RTC芯片，WIFI连接外网NTP服务器，定期更新时间，只要有网络，永远不用调整时间。
2.使用WIFI管理器热点配置WIF密码；
3.秒部分向下滚动显示，在分钟的固定时间横向滚动显示日期及星期；
4.带有LDR光敏电阻检测环境亮度自动调整显示屏的亮度；
5.增加OTA升级，调试更新固件无需连接USB线；
6.增加WIFI连接指示灯，提示联网状态。

之前分享的两个基于ESP8266的小制作：
ESP8266 安卓APP自定义控制WS2812B彩灯串
ESP8266 驱动圆形60串WS2812全彩LED制作的模拟走时动画时钟
软件配置，库安装，WIFI管理器设置等请参考第一帖，本帖不在赘述。

照例，先放效果图：

硬件接线图：

除了NodeMCU开发板外，使用的主要部件有两个：
1. LDR光敏电阻，用于检测环境光线，如果有旧的声控灯头，直接拆里面的使用。
QQ截图20191225172527.jpg

2.MAX7219驱动的8*8矩阵点阵，该IC使用串行口驱动，芯片可级联多级驱动，一般有单位，或者4位、6位等，我们需要使用6位（可以使用一个4位再加一个2位），即组成48*8点阵。

点阵显示PCB为自己Layout，捷配或嘉立创打样
QQ截图20191226094224.png

PCB附件下载：

MAX7219-8X16 V0.zip (91.53 KB, 下载次数: 96)

8*8点阵资料，使用共阴点阵

软件代码：

//MatrixClock
//OTA,WiFiManager
//without RTC
//LDR-A0,自动亮度
//开机LOGO
/*
===================
MAX7219 to ESP8266
===================
VCC - 5V
GND - GND
CS - D8
DIN - D7
CLK - D5
===========================================
LDR light sensor module to ESP8266
============================================
VCC - 3.3V
GND - GND
OUT - A0
========================================================
WiFi led to ESP8266
========================================================
D3--|<|---[1K]--3.3v
*/
#include <SPI.h>
#include <Ticker.h>
#include <ArduinoOTA.h>
#include <DNSServer.h>
#include <ESP8266WiFi.h>
#include <ESP8266WebServer.h>
#include <WiFiManager.h>
#include <WifiUDP.h>
#include <Wire.h>
#include <NTPClient.h> //更新get year, month, day
//Beijin time define
#define NTP_OFFSET 8*3600 //+8h，北京时间
#define NTP_INTERVAL 12*60*60*1000 //12*60*60*1000 12 hours 更新
#define NTP_ADDRESS "ntp1.aliyun.com"
//#define NTP_ADDRESS "time1.cloud.tencent.com"
/*************************************************************************************************
time.pool.aliyun.com
time1.aliyun.com
time2.aliyun.com
time3.aliyun.com
time4.aliyun.com
time5.aliyun.com
time6.aliyun.com
time7.aliyun.com
time1.cloud.tencent.com
time2.cloud.tencent.com
time3.cloud.tencent.com
time4.cloud.tencent.com
time5.cloud.tencent.com
*************************************************************************************************/
#define wf_led 2 // 0,D3
#define CS 15 // D8=cs Pin(SPI) D5=CLK, D7=DI
#define anzMAX 6 // number of led matrix Modules
unsigned short maxPosX = anzMAX * 8 - 1; //计算最大位置
unsigned short LEDarr[anzMAX][8]; //要显示的字符矩阵（40 * 8）
unsigned short helpArrMAX[anzMAX * 8]; //字符的辅助数组
unsigned short helpArrPos[anzMAX * 8]; //字符的辅助数组pos
unsigned int z_PosX = 0; //xPosition 用于时间显示
unsigned int d_PosX = 0; //xPosition 用于日期显示
bool f_tckr1s = false;
bool f_tckr1h = false;
bool f_tckr50ms = false;
bool f_tckr24h = false;
#define DATATIME_PRINT
#define CHINESE_CALENDAR //中国日历显示方式 1900-01-01，星期
#define LDR_SENSOR
#define LDR_DEBUG
#ifdef LDR_SENSOR
int A0LDR = A0; // A0 analoog LDR in
#endif
// The object for the Ticker
Ticker tckr;
// Set up the NTP UDP client
WiFiUDP ntpUDP;
NTPClient timeClient(ntpUDP, NTP_ADDRESS, NTP_OFFSET, NTP_INTERVAL);
// other displays -------------------------------------
//#define REVERSE_HORIZONTAL // Parola, Generic and IC-Station 反转水平
//#define REVERSE_VERTICAL // IC-Station display 反转垂直
//#define ROTATE_90 // Generic display 旋转90度
/*
p A B C D E F G 7 6 5 4 3 2 1 0 G F E D C B A p G F E D C B A p
------------------------ ------------------------ ------------------------ ------------------------
0 |o o o o o o o o| p |o o o o o o o o| 0 |o o o o o o o o| 7 |o o o o o o o o|
1 |o o o o o o o o| A |o o o o o o o o| 1 |o o o o o o o o| 6 |o o o o o o o o|
2 |o o o o o o o o| B |o o o o o o o o| 2 |o o o o o o o o| 5 |o o o o o o o o|
3 |o o o o| C |o o o o| 3 |o o o o| 4 |o o o o|
4 |o o FC-16 o o| D |o o Generic o o| 4 |o o Parola o o| 3 |o o IC-Station o o|
5 |o o o o| E |o o o o| 5 |o o o o| 2 |o o o o|
6 |o o o o o o o o| F |o o o o o o o o| 6 |o o o o o o o o| 1 |o o o o o o o o|
7 |o o o o o o o o| G |o o o o o o o o| 7 |o o o o o o o o| 0 |o o o o o o o o|
------------------------ ------------------------ ------------------------ ------------------------
*/
#ifdef CHINESE_CALENDAR
//months
char M_arr[12][4] = {
{ '.', '0', '1', '.' },
{ '.', '0', '2', '.' },
{ '.', '0', '3', '.' },
{ '.', '0', '4', '.' },
{ '.', '0', '5', '.' },
{ '.', '0', '6', '.' },
{ '.', '0', '7', '.' },
{ '.', '0', '8', '.' },
{ '.', '0', '9', '.' },
{ '.', '1', '0', '.' },
{ '.', '1', '1', '.' },
{ '.', '1', '2', '.' }
};
//days
char WT_arr[7][3] = {
{ 'S', 'u', 'n'},
{ 'M', 'o', 'n'},
{ 'T', 'u', 'e'},
{ 'W', 'e', 'd'},
{ 'T', 'h', 'u'},
{ 'F', 'r', 'i'},
{ 'S', 'a', 't'}
};
#else
//months
char M_arr[12][5] = { { '.', 'J', 'a', 'n', '.' }, { '.', 'F', 'e', 'b', '.' },
{ '.', 'M', 'a', 'r', '.' }, { '.', 'A', 'p', 'r', '.' }, { '.', 'M', 'a', 'y', ' ' }, { '.', 'J', 'u', 'n', 'e' }, { '.', 'J', 'u', 'l', 'y' },
{ '.', 'A', 'u', 'g', '.' }, { '.', 'S', 'e', 'p', 't' }, { '.', 'O', 'c', 't', '.' }, { '.', 'N', 'o', 'v', '.' }, { '.', 'D', 'e', 'c', '.' }
};
//days
char WT_arr[7][4] = { { 'S', 'u', 'n', ',' }, { 'M', 'o', 'n', ',' }, { 'T', 'u', 'e', ',' }, { 'W', 'e', 'd', ',' }, { 'T', 'h', 'u', ',' },
{ 'F', 'r', 'i', ',' }, { 'S', 'a', 't', ',' }
};
#endif
// 8x8矩阵中的字符集5x8，0,0在右上角
unsigned short const font1[96][9] = { {
0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // 0x20, Space
{ 0x07, 0x04, 0x04, 0x04, 0x04, 0x04, 0x00, 0x04, 0x00 }, // 0x21, !
{ 0x07, 0x09, 0x09, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00 }, // 0x22, "
{ 0x07, 0x0a, 0x0a, 0x1f, 0x0a, 0x1f, 0x0a, 0x0a, 0x00 }, // 0x23, #
{ 0x07, 0x04, 0x0f, 0x14, 0x0e, 0x05, 0x1e, 0x04, 0x00 }, // 0x24, $
{ 0x07, 0x19, 0x19, 0x02, 0x04, 0x08, 0x13, 0x13, 0x00 }, // 0x25, %
{ 0x07, 0x04, 0x0a, 0x0a, 0x0a, 0x15, 0x12, 0x0d, 0x00 }, // 0x26, &
{ 0x07, 0x04, 0x04, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00 }, // 0x27, '
{ 0x07, 0x02, 0x04, 0x08, 0x08, 0x08, 0x04, 0x02, 0x00 }, // 0x28, (
{ 0x07, 0x08, 0x04, 0x02, 0x02, 0x02, 0x04, 0x08, 0x00 }, // 0x29, )
{ 0x07, 0x04, 0x15, 0x0e, 0x1f, 0x0e, 0x15, 0x04, 0x00 }, // 0x2a, *
{ 0x07, 0x00, 0x04, 0x04, 0x1f, 0x04, 0x04, 0x00, 0x00 }, // 0x2b, +
{ 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x02 }, // 0x2c, ,
{ 0x07, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x00 }, // 0x2d, -
{ 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x00 }, // 0x2e, .
{ 0x07, 0x01, 0x01, 0x02, 0x04, 0x08, 0x10, 0x10, 0x00 }, // 0x2f, /
{ 0x07, 0x0e, 0x11, 0x13, 0x15, 0x19, 0x11, 0x0e, 0x00 }, // 0x30, 0
{ 0x07, 0x04, 0x0c, 0x04, 0x04, 0x04, 0x04, 0x0e, 0x00 }, // 0x31, 1
{ 0x07, 0x0e, 0x11, 0x01, 0x02, 0x04, 0x08, 0x1f, 0x00 }, // 0x32, 2
{ 0x07, 0x0e, 0x11, 0x01, 0x06, 0x01, 0x11, 0x0e, 0x00 }, // 0x33, 3
{ 0x07, 0x02, 0x06, 0x0a, 0x12, 0x1f, 0x02, 0x02, 0x00 }, // 0x34, 4
{ 0x07, 0x1f, 0x10, 0x1e, 0x01, 0x01, 0x11, 0x0e, 0x00 }, // 0x35, 5
{ 0x07, 0x06, 0x08, 0x10, 0x1e, 0x11, 0x11, 0x0e, 0x00 }, // 0x36, 6
{ 0x07, 0x1f, 0x01, 0x02, 0x04, 0x08, 0x08, 0x08, 0x00 }, // 0x37, 7
{ 0x07, 0x0e, 0x11, 0x11, 0x0e, 0x11, 0x11, 0x0e, 0x00 }, // 0x38, 8
{ 0x07, 0x0e, 0x11, 0x11, 0x0f, 0x01, 0x02, 0x0c, 0x00 }, // 0x39, 9
{ 0x04, 0x00, 0x03, 0x03, 0x00, 0x03, 0x03, 0x00, 0x00 }, // 0x3a, :
{ 0x07, 0x00, 0x0c, 0x0c, 0x00, 0x0c, 0x04, 0x08, 0x00 }, // 0x3b, ;
{ 0x07, 0x02, 0x04, 0x08, 0x10, 0x08, 0x04, 0x02, 0x00 }, // 0x3c, <
{ 0x07, 0x00, 0x00, 0x1f, 0x00, 0x1f, 0x00, 0x00, 0x00 }, // 0x3d, =
{ 0x07, 0x08, 0x04, 0x02, 0x01, 0x02, 0x04, 0x08, 0x00 }, // 0x3e, >
{ 0x07, 0x0e, 0x11, 0x01, 0x02, 0x04, 0x00, 0x04, 0x00 }, // 0x3f, ?
{ 0x07, 0x0e, 0x11, 0x17, 0x15, 0x17, 0x10, 0x0f, 0x00 }, // 0x40, @
{ 0x07, 0x04, 0x0a, 0x11, 0x11, 0x1f, 0x11, 0x11, 0x00 }, // 0x41, A
{ 0x07, 0x1e, 0x11, 0x11, 0x1e, 0x11, 0x11, 0x1e, 0x00 }, // 0x42, B
{ 0x07, 0x0e, 0x11, 0x10, 0x10, 0x10, 0x11, 0x0e, 0x00 }, // 0x43, C
{ 0x07, 0x1e, 0x09, 0x09, 0x09, 0x09, 0x09, 0x1e, 0x00 }, // 0x44, D
{ 0x07, 0x1f, 0x10, 0x10, 0x1c, 0x10, 0x10, 0x1f, 0x00 }, // 0x45, E
{ 0x07, 0x1f, 0x10, 0x10, 0x1f, 0x10, 0x10, 0x10, 0x00 }, // 0x46, F
{ 0x07, 0x0e, 0x11, 0x10, 0x10, 0x13, 0x11, 0x0f, 0x00 }, // 0x37, G
{ 0x07, 0x11, 0x11, 0x11, 0x1f, 0x11, 0x11, 0x11, 0x00 }, // 0x48, H
{ 0x07, 0x0e, 0x04, 0x04, 0x04, 0x04, 0x04, 0x0e, 0x00 }, // 0x49, I
{ 0x07, 0x1f, 0x02, 0x02, 0x02, 0x02, 0x12, 0x0c, 0x00 }, // 0x4a, J
{ 0x07, 0x11, 0x12, 0x14, 0x18, 0x14, 0x12, 0x11, 0x00 }, // 0x4b, K
{ 0x07, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x1f, 0x00 }, // 0x4c, L
{ 0x07, 0x11, 0x1b, 0x15, 0x11, 0x11, 0x11, 0x11, 0x00 }, // 0x4d, M
{ 0x07, 0x11, 0x11, 0x19, 0x15, 0x13, 0x11, 0x11, 0x00 }, // 0x4e, N
{ 0x07, 0x0e, 0x11, 0x11, 0x11, 0x11, 0x11, 0x0e, 0x00 }, // 0x4f, O
{ 0x07, 0x1e, 0x11, 0x11, 0x1e, 0x10, 0x10, 0x10, 0x00 }, // 0x50, P
{ 0x07, 0x0e, 0x11, 0x11, 0x11, 0x15, 0x12, 0x0d, 0x00 }, // 0x51, Q
{ 0x07, 0x1e, 0x11, 0x11, 0x1e, 0x14, 0x12, 0x11, 0x00 }, // 0x52, R
{ 0x07, 0x0e, 0x11, 0x10, 0x0e, 0x01, 0x11, 0x0e, 0x00 }, // 0x53, S
{ 0x07, 0x1f, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x00 }, // 0x54, T
{ 0x07, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x0e, 0x00 }, // 0x55, U
{ 0x07, 0x11, 0x11, 0x11, 0x11, 0x11, 0x0a, 0x04, 0x00 }, // 0x56, V
{ 0x07, 0x11, 0x11, 0x11, 0x15, 0x15, 0x1b, 0x11, 0x00 }, // 0x57, W
{ 0x07, 0x11, 0x11, 0x0a, 0x04, 0x0a, 0x11, 0x11, 0x00 }, // 0x58, X
{ 0x07, 0x11, 0x11, 0x0a, 0x04, 0x04, 0x04, 0x04, 0x00 }, // 0x59, Y
{ 0x07, 0x1f, 0x01, 0x02, 0x04, 0x08, 0x10, 0x1f, 0x00 }, // 0x5a, Z
{ 0x07, 0x0e, 0x08, 0x08, 0x08, 0x08, 0x08, 0x0e, 0x00 }, // 0x5b, [
{ 0x07, 0x10, 0x10, 0x08, 0x04, 0x02, 0x01, 0x01, 0x00 }, // 0x5c, '\'
{ 0x07, 0x0e, 0x02, 0x02, 0x02, 0x02, 0x02, 0x0e, 0x00 }, // 0x5d, ]
{ 0x07, 0x04, 0x0a, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00 }, // 0x5e, ^
{ 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x00 }, // 0x5f, _
{ 0x07, 0x04, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00 }, // 0x60, `
{ 0x07, 0x00, 0x0e, 0x01, 0x0d, 0x13, 0x13, 0x0d, 0x00 }, // 0x61, a
{ 0x07, 0x10, 0x10, 0x10, 0x1c, 0x12, 0x12, 0x1c, 0x00 }, // 0x62, b
{ 0x07, 0x00, 0x00, 0x00, 0x0e, 0x10, 0x10, 0x0e, 0x00 }, // 0x63, c
{ 0x07, 0x01, 0x01, 0x01, 0x07, 0x09, 0x09, 0x07, 0x00 }, // 0x64, d
{ 0x07, 0x00, 0x00, 0x0e, 0x11, 0x1f, 0x10, 0x0f, 0x00 }, // 0x65, e
{ 0x07, 0x06, 0x09, 0x08, 0x1c, 0x08, 0x08, 0x08, 0x00 }, // 0x66, f
{ 0x07, 0x00, 0x0e, 0x11, 0x13, 0x0d, 0x01, 0x01, 0x0e }, // 0x67, g
{ 0x07, 0x10, 0x10, 0x10, 0x16, 0x19, 0x11, 0x11, 0x00 }, // 0x68, h
{ 0x05, 0x00, 0x02, 0x00, 0x06, 0x02, 0x02, 0x07, 0x00 }, // 0x69, i
{ 0x07, 0x00, 0x02, 0x00, 0x06, 0x02, 0x02, 0x12, 0x0c }, // 0x6a, j
{ 0x07, 0x10, 0x10, 0x12, 0x14, 0x18, 0x14, 0x12, 0x00 }, // 0x6b, k
{ 0x05, 0x06, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x00 }, // 0x6c, l
{ 0x07, 0x00, 0x00, 0x0a, 0x15, 0x15, 0x11, 0x11, 0x00 }, // 0x6d, m
{ 0x07, 0x00, 0x00, 0x16, 0x19, 0x11, 0x11, 0x11, 0x00 }, // 0x6e, n
{ 0x07, 0x00, 0x00, 0x0e, 0x11, 0x11, 0x11, 0x0e, 0x00 }, // 0x6f, o
{ 0x07, 0x00, 0x00, 0x1c, 0x12, 0x12, 0x1c, 0x10, 0x10 }, // 0x70, p
{ 0x07, 0x00, 0x00, 0x07, 0x09, 0x09, 0x07, 0x01, 0x01 }, // 0x71, q
{ 0x07, 0x00, 0x00, 0x16, 0x19, 0x10, 0x10, 0x10, 0x00 }, // 0x72, r
{ 0x07, 0x00, 0x00, 0x0f, 0x10, 0x0e, 0x01, 0x1e, 0x00 }, // 0x73, s
{ 0x07, 0x08, 0x08, 0x1c, 0x08, 0x08, 0x09, 0x06, 0x00 }, // 0x74, t
{ 0x07, 0x00, 0x00, 0x11, 0x11, 0x11, 0x13, 0x0d, 0x00 }, // 0x75, u
{ 0x07, 0x00, 0x00, 0x11, 0x11, 0x11, 0x0a, 0x04, 0x00 }, // 0x76, v
{ 0x07, 0x00, 0x00, 0x11, 0x11, 0x15, 0x15, 0x0a, 0x00 }, // 0x77, w
{ 0x07, 0x00, 0x00, 0x11, 0x0a, 0x04, 0x0a, 0x11, 0x00 }, // 0x78, x
{ 0x07, 0x00, 0x00, 0x11, 0x11, 0x0f, 0x01, 0x11, 0x0e }, // 0x79, y
{ 0x07, 0x00, 0x00, 0x1f, 0x02, 0x04, 0x08, 0x1f, 0x00 }, // 0x7a, z
{ 0x07, 0x06, 0x08, 0x08, 0x10, 0x08, 0x08, 0x06, 0x00 }, // 0x7b, {
{ 0x07, 0x04, 0x04, 0x04, 0x00, 0x04, 0x04, 0x04, 0x00 }, // 0x7c, |
{ 0x07, 0x0c, 0x02, 0x02, 0x01, 0x02, 0x02, 0x0c, 0x00 }, // 0x7d, }
{ 0x07, 0x08, 0x15, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00 }, // 0x7e, ~
{ 0x07, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x00 } // 0x7f, DEL
};
struct DateTime {
unsigned short second1, second2, second12, min1, min2, min12, hour1, hour2, hour12;
unsigned short day1, day2, day12, mon1, mon2, mon12, year1, year2, year12, WT;
} MEZ;
//*************************************************************************************************
const unsigned short InitArr[7][2] = {
{ 0x0C, 0x00 }, // display off
{ 0x00, 0xFF }, // no LEDtest
{ 0x09, 0x00 }, // BCD off
{ 0x0F, 0x00 }, // normal operation
{ 0x0B, 0x07 }, // start display
{ 0x0A, 0x04 }, // brightness
{ 0x0C, 0x01 } // display on
};
//**************************************************************************************************
void max7219_init() //all MAX7219 init
{
unsigned short i, j;
for (i = 0; i < 7; i++) {
digitalWrite(CS, LOW);
delayMicroseconds(1);
for (j = 0; j < anzMAX; j++) {
SPI.write(InitArr[i][0]); //register
SPI.write(InitArr[i][1]); //value
}
digitalWrite(CS, HIGH);
}
}
//**************************************************************************************************
void max7219_set_brightness(unsigned short br) //brightness MAX7219
{
unsigned short j;
if (br < 16) {
digitalWrite(CS, LOW);
delayMicroseconds(1);
for (j = 0; j < anzMAX; j++) {
SPI.write(0x0A); //register
SPI.write(br); //value
}
digitalWrite(CS, HIGH);
}
}
//**************************************************************************************************
void helpArr_init(void) //helperarray init
{
unsigned short i, j, k;
j = 0;
k = 0;
for (i = 0; i < anzMAX * 8; i++) {
helpArrPos[i] = (1 << j); //bitmask
helpArrMAX[i] = k;
j++;
if (j > 7) {
j = 0;
k++;
}
}
}
//**************************************************************************************************
void clear_Display() //clear all
{
unsigned short i, j;
for (i = 0; i < 8; i++) //8 rows
{
digitalWrite(CS, LOW);
delayMicroseconds(1);
for (j = anzMAX; j > 0; j--) {
LEDarr[j - 1][i] = 0; //LEDarr clear
SPI.write(i + 1); //current row
SPI.write(LEDarr[j - 1][i]);
}
digitalWrite(CS, HIGH);
}
}
//*********************************************************************************************************
void rotate_90() // for Generic displays
{
for (uint8_t k = anzMAX; k > 0; k--) {
uint8_t i, j, m, imask, jmask;
uint8_t tmp[8] = {0, 0, 0, 0, 0, 0, 0, 0};
for ( i = 0, imask = 0x01; i < 8; i++, imask <<= 1) {
for (j = 0, jmask = 0x01; j < 8; j++, jmask <<= 1) {
if (LEDarr[k - 1][i] & jmask) {
tmp[j] |= imask;
}
}
}
for (m = 0; m < 8; m++) {
LEDarr[k - 1][m] = tmp[m];
}
}
}
//**************************************************************************************************
void refresh_display() //take info into LEDarr
{
unsigned short i, j;
#ifdef ROTATE_90
rotate_90();
#endif
for (i = 0; i < 8; i++) //8 rows
{
digitalWrite(CS, LOW);
delayMicroseconds(1);
for (j = anzMAX; j > 0; j--) {
SPI.write(i + 1); //current row
#ifdef REVERSE_HORIZONTAL
SPI.setBitOrder(LSBFIRST); // bitorder for reverse columns
#endif
#ifdef REVERSE_VERTICAL
SPI.write(LEDarr[j - 1][7 - i]);
#else
SPI.write(LEDarr[j - 1][i]);
#endif
#ifdef REVERSE_HORIZONTAL
SPI.setBitOrder(MSBFIRST); // reset bitorder
#endif
}
digitalWrite(CS, HIGH);
}
}
//**************************************************************************************************
void char2Arr(unsigned short ch, int PosX, short PosY) { //characters into arr
int i, j, k, l, m, o1, o2, o3, o4; //in LEDarr
PosX++;
k = ch - 32; //ASCII position in font
if ((k >= 0) && (k < 96)) //character found in font
{
o4 = font1[k][0]; //character width
o3 = 1 << (o4 - 2);
for (i = 0; i < o4; i++) {
if (((PosX - i <= maxPosX) && (PosX - i >= 0))
&& ((PosY > -8) && (PosY < 8))) //within matrix?
{
o1 = helpArrPos[PosX - i];
o2 = helpArrMAX[PosX - i];
for (j = 0; j < 8; j++) {
if (((PosY >= 0) && (PosY <= j)) || ((PosY < 0) && (j < PosY + 8))) //scroll vertical
{
l = font1[k][j + 1];
m = (l & (o3 >> i)); //e.g. o4=7 0zzzzz0, o4=4 0zz0
if (m > 0)
LEDarr[o2][j - PosY] = LEDarr[o2][j - PosY] | (o1); //set point
else
LEDarr[o2][j - PosY] = LEDarr[o2][j - PosY] & (~o1); //clear point
}
}
}
}
}
}
//**************************************************************************************************
void timer50ms() {
static unsigned int cnt50ms = 0;
static unsigned int cnt1s = 0;
static unsigned int cnt1h = 0;
f_tckr50ms = true;
cnt50ms++;
if (cnt50ms == 20) {
f_tckr1s = true; // 1 sec
cnt1s++;
cnt50ms = 0;
}
if (cnt1s == 3600) { // 1h
f_tckr1h = true;
cnt1h++;
cnt1s = 0;
}
if (cnt1h == 24) { // 1d
f_tckr24h = true;
cnt1h = 0;
}
}
//**************************************************************************************************
void WiFisetup() {
//WiFiManager
//Local intialization. Once its business is done, there is no need to keep it around
WiFiManager wifiManager;
//wifiManager.resetSettings();
wifiManager.setAPStaticIPConfig(IPAddress(10, 0, 1, 1), IPAddress(10, 0, 1, 1), IPAddress(255, 255, 255, 0));
//wifiManager.autoConnect("Wifi Clock");
// wifiManager.setTimeout(180);
wifiManager.setConfigPortalTimeout(60); //1 minute
if (!wifiManager.autoConnect("Wifi Clock"))
{
Serial.println(F("Failed to connect. Reset and try again..."));
delay(3000);
ESP.reset(); //重置并重试
delay(5000);
}
//if you get here you have connected to the WiFi
digitalWrite(wf_led, LOW); //blue led on if wifi connected
Serial.println("WiFi Connected!");
Serial.print("IP ssid: ");
Serial.println(WiFi.SSID());
Serial.print("IP addr: ");
Serial.println(WiFi.localIP());
}
//**************************************************************************************************
void Otasetup() {
ArduinoOTA.onStart([]() {
Serial.println("OTA Update Start");
});
ArduinoOTA.onProgress([](unsigned int progress, unsigned int total) {
Serial.print("Progress: ");
Serial.println((progress / (total / 100)));
// clear_Display();
char2Arr('O', 45, 0); //OTA
char2Arr('T', 39, 0);
char2Arr('A', 33, 0);
char2Arr('.', 25, 0);
char2Arr('.', 19, 0);
char2Arr('.', 13, 0);
refresh_display();
});
ArduinoOTA.onEnd([]() {
Serial.println("OTA End,Restart......");
});
ArduinoOTA.onError([](ota_error_t error) {
Serial.printf("Error[%u]: ", error);
if (error == OTA_AUTH_ERROR) Serial.println("Auth Failed");
else if (error == OTA_BEGIN_ERROR) Serial.println("Begin Failed");
else if (error == OTA_CONNECT_ERROR) Serial.println("Connect Failed");
else if (error == OTA_RECEIVE_ERROR) Serial.println("Receive Failed");
else if (error == OTA_END_ERROR) Serial.println("End Failed");
});
ArduinoOTA.begin();
}
//**************************************************************************************************
#ifdef LDR_SENSOR
void Setintens()
{
// int intens = ((1024 - analogRead(A0LDR)) / 300);
int intens = ((analogRead(A0LDR) - 400) / 12); //480-663 亮-暗
if (intens < 8) {
intens = 10;
}
else if (intens == 8 || intens == 9 || intens == 10 || intens == 11 ) {
intens = 8;
}
else if (intens == 12 || intens == 13 || intens == 14 || intens == 15) {
intens = 5;
}
else if (intens == 16 || intens == 17 || intens == 18 || intens == 19) {
intens = 3;
}
else if (intens > 19) {
intens = 1; //整理亮度值，值越大亮度越高
}
#ifdef LDR_DEBUG
Serial.print("A0LDR: ");
Serial.print(analogRead(A0LDR));
Serial.print(" intens: ");
Serial.println(intens);
#endif
max7219_set_brightness(intens);
}
#endif
//**************************************************************************************************
void setup ()
{
pinMode(wf_led, OUTPUT); //wifi led
digitalWrite(wf_led, HIGH); // led off
pinMode(CS, OUTPUT);
digitalWrite(CS, HIGH);
Serial.begin(115200); // most ESP-01's use 115200 but this could vary
SPI.begin();
helpArr_init();
max7219_init();
clear_Display();
tckr.attach(0.05, timer50ms); // every 50 msec
#ifdef LDR_SENSOR
Setintens(); // set intensiteit naar LDR.
#endif
/*
char2Arr('.', 41, 0); //LOGO
char2Arr('C', 37, 0);
char2Arr('L', 31, 0);
char2Arr('O', 25, 0);
char2Arr('C', 19, 0);
char2Arr('K', 13, 0);
char2Arr('.', 6, 0);
refresh_display();
*/
char2Arr('.', 41, 0); //LOGO
char2Arr('H', 37, 0);
char2Arr('e', 31, 0);
char2Arr('l', 25, 0);
char2Arr('l', 19, 0);
char2Arr('o', 13, 0);
char2Arr('.', 6, 0);
refresh_display();
delay(1500);
clear_Display();
char2Arr('W', 45, 0); //WIFI
char2Arr('i', 38, 0);
char2Arr('F', 33, 0);
char2Arr('i', 27, 0);
char2Arr('.', 20, 0);
char2Arr('.', 13, 0);
char2Arr('.', 6, 0);
refresh_display();
WiFisetup();
timeClient.begin(); // Start the NTP UDP client
Otasetup();
}
void loop()
{
unsigned int second1 = 0, second2 = 0, min1 = 0, min2 = 0, hour1 = 0, hour2 = 0;
unsigned int second11 = 0, second12 = 0, second21 = 0, second22 = 0;
unsigned int min11 = 0, min12 = 0, min21 = 0, min22 = 0;
unsigned int hour11 = 0, hour12 = 0, hour21 = 0, hour22 = 0;
signed int x = 0; //x1,x2;
signed int y = 0, y1 = 0, y2 = 0;
bool updown = false;
unsigned int sc1 = 0, sc2 = 0, sc3 = 0, sc4 = 0, sc5 = 0, sc6 = 0;
bool f_scrollend_y = false;
unsigned int f_scroll_x = false;
unsigned short year, day, month, hour, minute, second, week;
z_PosX = maxPosX;
d_PosX = -8;
// x=0; x1=0; x2=0;
refresh_display();
updown = true;
if (updown == false) {
y2 = -9;
y1 = 8;
}
if (updown == true) { //scroll up to down
y2 = 8;
y1 = -8;
}
while (true) {
yield();
ArduinoOTA.handle(); //ArduinoOTA
/*
if (f_tckr1h == true) // check each hour if wifi is connected
{
if (WiFi.status() != WL_CONNECTED)
{
digitalWrite(wf_led,HIGH); //led off
}
else
{
digitalWrite(wf_led,LOW); //led on
}
f_tckr1h == false;
}
*/
if (f_tckr1s == true) // flag 1second
{
if (WiFi.status() != WL_CONNECTED)
{
digitalWrite(wf_led, HIGH); //led off
Serial.println("WiFi Disconnect!");
}
else
{
digitalWrite(wf_led, LOW); //led on
}
int WiFi_status;
WiFi_status = digitalRead(wf_led);
if (WiFi_status) {
Serial.print("WiFi status: ");
Serial.println(WiFi_status);
}
#ifdef LDR_SENSOR
Setintens(); // set intensiteit naar LDR.
#endif
if (timeClient.update()) { // update the NTP client and get the UNIX UTC timestamp
year = timeClient.getYear();
month = timeClient.getMonth();
day = timeClient.getDate();
week = timeClient.getDay();
hour = timeClient.getHours();
minute = timeClient.getMinutes();
second = timeClient.getSeconds();
MEZ.WT = week;
MEZ.second1 = second % 10;
MEZ.second2 = second / 10;
MEZ.second12 = second;
MEZ.min1 = minute % 10;
MEZ.min2 = minute / 10;
MEZ.min12 = minute;
MEZ.hour1 = hour % 10;
MEZ.hour2 = hour / 10;
MEZ.hour12 = hour;
MEZ.day12 = day;
MEZ.day1 = day % 10;
MEZ.day2 = day / 10;
MEZ.mon12 = month;
MEZ.mon1 = month % 10;
MEZ.mon2 = month / 10;
MEZ.year12 = year;
MEZ.year1 = year % 10; //Single
MEZ.year2 = year / 10 % 10; //Ten
}
#ifdef DATATIME_PRINT
Serial.print(MEZ.year12);
Serial.print("-");
Serial.print(MEZ.mon12);
Serial.print("-");
Serial.print(MEZ.day12);
Serial.print(" ");
Serial.print(MEZ.hour12);
Serial.print(":");
Serial.print(MEZ.min12);
Serial.print(":");
Serial.print(MEZ.second12);
Serial.print(",");
Serial.println(MEZ.WT);
#endif
second1 = MEZ.second1;
second2 = MEZ.second2;
min1 = MEZ.min1;
min2 = MEZ.min2;
hour1 = MEZ.hour1;
hour2 = MEZ.hour2;
y = y2; //scroll updown
sc1 = 1;
second1++;
if (second1 == 10) {
sc2 = 1;
second2++;
second1 = 0;
}
if (second2 == 6) {
min1++;
second2 = 0;
sc3 = 1;
}
if (min1 == 10) {
min2++;
min1 = 0;
sc4 = 1;
}
if (min2 == 6) {
hour1++;
min2 = 0;
sc5 = 1;
}
if (hour1 == 10) {
hour2++;
hour1 = 0;
sc6 = 1;
}
if ((hour2 == 2) && (hour1 == 4)) {
hour1 = 0;
hour2 = 0;
sc6 = 1;
}
second11 = second12;
second12 = second1;
second21 = second22;
second22 = second2;
min11 = min12;
min12 = min1;
min21 = min22;
min22 = min2;
hour11 = hour12;
hour12 = hour1;
hour21 = hour22;
hour22 = hour2;
f_tckr1s = false;
// if (MEZ.second12 == 20 || MEZ.second12 == 40 || MEZ.second12 == 00) //设置循环显示时间点
if (MEZ.second12 == 40) //设置循环显示时间点，40s时
f_scroll_x = true;
} // end 1s
if (f_tckr50ms == true) {
f_tckr50ms = false;
if (f_scroll_x == true) {
z_PosX++;
d_PosX++;
if (d_PosX == 86) // char2Arr(WT_arr[MEZ.WT][2], d_PosX - 80, 0);
z_PosX = 0;
if (z_PosX == maxPosX) {
f_scroll_x = false;
d_PosX = -8;
}
}
if (sc1 == 1) {
if (updown == 1)
y--;
else
y++;
char2Arr(48 + second12, z_PosX - 42, y);
char2Arr(48 + second11, z_PosX - 42, y + y1);
if (y == 0) {
sc1 = 0;
f_scrollend_y = true;
}
}
else
char2Arr(48 + second1, z_PosX - 42, 0);
if (sc2 == 1) {
char2Arr(48 + second22, z_PosX - 36, y);
char2Arr(48 + second21, z_PosX - 36, y + y1);
if (y == 0)
sc2 = 0;
}
else
char2Arr(48 + second2, z_PosX - 36, 0);
char2Arr(':', z_PosX - 32, 0);
if (sc3 == 1) {
char2Arr(48 + min12, z_PosX - 25, y);
char2Arr(48 + min11, z_PosX - 25, y + y1);
if (y == 0)
sc3 = 0;
}
else
char2Arr(48 + min1, z_PosX - 25, 0);
if (sc4 == 1) {
char2Arr(48 + min22, z_PosX - 19, y);
char2Arr(48 + min21, z_PosX - 19, y + y1);
if (y == 0)
sc4 = 0;
}
else
char2Arr(48 + min2, z_PosX - 19, 0);
char2Arr(':', z_PosX - 15 + x, 0);
if (sc5 == 1) {
char2Arr(48 + hour12, z_PosX - 8, y);
char2Arr(48 + hour11, z_PosX - 8, y + y1);
if (y == 0)
sc5 = 0;
}
else
char2Arr(48 + hour1, z_PosX - 8, 0);
if (sc6 == 1) {
char2Arr(48 + hour22, z_PosX - 2, y);
char2Arr(48 + hour21, z_PosX - 2, y + y1);
if (y == 0)
sc6 = 0;
}
else
char2Arr(48 + hour2, z_PosX - 2, 0);
#ifdef CHINESE_CALENDAR
char2Arr('2', d_PosX - 5, 0); //year
char2Arr('0', d_PosX - 11, 0);
char2Arr(48 + MEZ.year2, d_PosX - 17, 0);
char2Arr(48 + MEZ.year1, d_PosX - 23, 0);
char2Arr(M_arr[MEZ.mon12 - 1][0], d_PosX - 30, 0);
char2Arr(M_arr[MEZ.mon12 - 1][1], d_PosX - 35, 0);
char2Arr(M_arr[MEZ.mon12 - 1][2], d_PosX - 41, 0);
char2Arr(M_arr[MEZ.mon12 - 1][3], d_PosX - 48, 0);
char2Arr(48 + MEZ.day2, d_PosX - 53, 0); //day
char2Arr(48 + MEZ.day1, d_PosX - 59, 0);
char2Arr(WT_arr[MEZ.WT][0], d_PosX - 68, 0); //day of the week
char2Arr(WT_arr[MEZ.WT][1], d_PosX - 74, 0);
char2Arr(WT_arr[MEZ.WT][2], d_PosX - 80, 0);
#else
char2Arr(WT_arr[MEZ.WT][0], d_PosX - 5, 0); //day of the week
char2Arr(WT_arr[MEZ.WT][1], d_PosX - 11, 0);
char2Arr(WT_arr[MEZ.WT][2], d_PosX - 17, 0);
char2Arr(WT_arr[MEZ.WT][3], d_PosX - 23, 0);
char2Arr(48 + MEZ.day2, d_PosX - 27, 0); //day
char2Arr(48 + MEZ.day1, d_PosX - 33, 0);
char2Arr(M_arr[MEZ.mon12 - 1][0], d_PosX - 39, 0); //month
char2Arr(M_arr[MEZ.mon12 - 1][1], d_PosX - 43, 0);
char2Arr(M_arr[MEZ.mon12 - 1][2], d_PosX - 49, 0);
char2Arr(M_arr[MEZ.mon12 - 1][3], d_PosX - 55, 0);
char2Arr(M_arr[MEZ.mon12 - 1][4], d_PosX - 61, 0);
char2Arr('2', d_PosX - 68, 0); //year
char2Arr('0', d_PosX - 74, 0);
char2Arr(48 + MEZ.year2, d_PosX - 80, 0);
char2Arr(48 + MEZ.year1, d_PosX - 86, 0);
#endif
refresh_display(); //alle 50ms
if (f_scrollend_y == true) {
f_scrollend_y = false;
}
} //end 50ms
if (y == 0) {
// do something else
}
} //end while(true)
//this section can not be reached
}

复制代码

代码下载：

MatrixClock-ota.zip (7.3 KB, 下载次数: 115)

库下载：（特别说明：<NTPClient.h>库增加了直接获取 year, month, day函数，库管理器联网下载的库不可用）

NTPClient.zip (7.13 KB, 下载次数: 134)

一些配置说明：

#define NTP_OFFSET 8*3600 //+8h，北京时间
#define NTP_INTERVAL 12*60*60*1000 //12*60*60*1000 12 hours 更新
#define NTP_ADDRESS "ntp1.aliyun.com"
//#define NTP_ADDRESS "time1.cloud.tencent.com"

复制代码

时区调整，北京时间+8
时间更新间隔，代码中是12小时
NTP服务器地址：阿里云，可选腾讯等

#define wf_led 2 // 0,D3
#define CS 15 // D8=cs Pin(SPI) D5=CLK, D7=DI

复制代码

WIFI状态指示LED脚，MAX7219 CS脚引脚定义

#define DATATIME_PRINT
#define CHINESE_CALENDAR //中国日历显示方式 1900-01-01，星期
#define LDR_SENSOR
#define LDR_DEBUG

复制代码

打印时间宏定义
中国日历宏定义，注释掉为西方国家日期格式：12 Mar 2019.
LDR光线检测宏定义，注释掉为不使用LDR光线检测。
LDR光线检测调试宏定义，用于使用不同LDR时打印光线对应亮度，调试。

if (!wifiManager.autoConnect("Wifi Clock"))

复制代码

同样的，WIFI热点名称定义

#ifdef LDR_SENSOR
void Setintens()
{
// int intens = ((1024 - analogRead(A0LDR)) / 300);
int intens = ((analogRead(A0LDR) - 400) / 12); //480-663 亮-暗
if (intens < 8) {
intens = 10;
}
else if (intens == 8 || intens == 9 || intens == 10 || intens == 11 ) {
intens = 8;
}
else if (intens == 12 || intens == 13 || intens == 14 || intens == 15) {
intens = 5;
}
else if (intens == 16 || intens == 17 || intens == 18 || intens == 19) {
intens = 3;
}
else if (intens > 19) {
intens = 1; //整理亮度值，值越大亮度越高
}
#ifdef LDR_DEBUG
Serial.print("A0LDR: ");
Serial.print(analogRead(A0LDR));
Serial.print(" intens: ");
Serial.println(intens);
#endif
max7219_set_brightness(intens);
}
#endif

复制代码

LDR光线检测调整亮度函数，不同的LDR需要细调。

/*
char2Arr('.', 41, 0); //LOGO
char2Arr('C', 37, 0);
char2Arr('L', 31, 0);
char2Arr('O', 25, 0);
char2Arr('C', 19, 0);
char2Arr('K', 13, 0);
char2Arr('.', 6, 0);
refresh_display();
*/
char2Arr('.', 41, 0); //LOGO
char2Arr('H', 37, 0);
char2Arr('e', 31, 0);
char2Arr('l', 25, 0);
char2Arr('l', 19, 0);
char2Arr('o', 13, 0);
char2Arr('.', 6, 0);
refresh_display();
delay(1500);
clear_Display();
char2Arr('W', 45, 0); //WIFI
char2Arr('i', 38, 0);
char2Arr('F', 33, 0);
char2Arr('i', 27, 0);
char2Arr('.', 20, 0);
char2Arr('.', 13, 0);
char2Arr('.', 6, 0);
refresh_display();
WiFisetup();
timeClient.begin(); // Start the NTP UDP client
Otasetup();

复制代码

LOGO显示，可自由调整，注意字符显示的位置及数量。

if (MEZ.second12 == 40) //设置循环显示时间点，40s时

复制代码

滚动显示日期、星期的时间点，代码中为40秒时滚动显示，滚动时间大概8秒左右。

视频效果，来自坛友仿制：https://www.mydigit.cn/thread-294319-1-1.html

WiFi点阵时钟视频效果.mp4 (1.05 MB, 下载次数: 3)

补充内容 (2022-1-20 10:03):
52# 有lupo88坛友修改的共阳点阵程序，可参考， 55#为文中PCB原文件，EDA软件为pads2005.

触景情伤 · 发表于 2019-12-25 19:13:28

编译环境都搞不了的表示就看看了…

慕名而来 · 发表于 2019-12-25 20:16:25

触景情伤发表于 2019-12-25 19:13
编译环境都搞不了的表示就看看了…

新手玩ESP8266用阿尔杜一诺的人最多资源也最多，其他的资源少些，我弄了一阵子lua，虽然wifi校时也没问题但是因为没能深入就撂下了，模块一直在吃灰。

zengcym · 发表于 2019-12-26 06:58:09

触景情伤发表于 2019-12-25 19:13
编译环境都搞不了的表示就看看了…

Arduino资源很多，精华就是各种库，不需要很复杂的环境搭建，官网的版本安装外加ESP8266补丁安装就好，不需要设置路径获取环境，因为连接的外网有时不稳定而安装失败。

寂寞地铁 · 发表于 2019-12-26 09:04:25

最近我也在做这个，楼主做的真好~

cykhyk · 发表于 2019-12-26 16:44:47

正好手上有控制板和8*32的屏想仿制1个，请教要改哪里，刚接触8266

cykhyk · 发表于 2019-12-26 16:56:25

手上正好有8266模块和8*32的屏，想仿制一个，请教需要修改哪些位置

zengcym · 发表于 2019-12-26 17:53:15

cykhyk 发表于 2019-12-26 16:56
手上正好有8266模块和8*32的屏，想仿制一个，请教需要修改哪些位置

#define anzMAX 6 // number of led matrix Modules

复制代码

修改为（未验证）：#define anzMAX 4

cykhyk · 发表于 2019-12-27 08:18:06

zengcym 发表于 2019-12-26 17:53
修改为（未验证）：#define anzMAX 4

仿制成功，因屏幕比较小没法显示秒，谢谢楼主分享。

muziwenwu · 发表于 2020-1-9 19:27:47

不错，感谢lz
试验一个看看

muziwenwu · 发表于 2020-1-9 19:30:16

网上看到一个用8*32的点阵屏幕，秒用小字显示的，可以节省2块点阵屏，看起来也听美观的。不过那个加上断网还显示的芯片。
lz能不能在这个基础上改改代码也搞一个。
淘宝关键字“hack实验室”

muziwenwu · 发表于 2020-1-9 21:41:03

zengcym 发表于 2019-12-26 17:53
修改为（未验证）：#define anzMAX 4

我试了有点问题，最左边多了2个点。
lz能不能搞成4块点阵屏幕显示秒的。

4块点阵屏读秒

另外建议把星期几的英文改成大写数字哇，这样一眼就看懂了

lyy-cy · 发表于 2020-1-9 23:00:40

muziwenwu 发表于 2020-1-9 21:41
我试了有点问题，最左边多了2个点。
lz能不能搞成4块点阵屏幕显示秒的。

亚克力哪里买的？老铁？给个链接。
我也在做这个，已经基本成功。

zzj80 · 发表于 2020-1-10 01:38:07

这是什么字体？还挺好看的

muziwenwu · 发表于 2020-1-10 23:48:38

亚克力找tb定制啊，量下尺寸

ppg201314 · 发表于 2020-1-12 19:14:03

MAX7219 CS脚引脚定义可以修改吗怎么改呢楼主

zzj80 · 发表于 2020-1-15 14:05:05

pcb是什么软件？AD09打不开啊

654810320 · 发表于 2020-1-22 20:36:11

厉害了厉害了厉害了厉害了厉害了厉害了厉害了

suiyuan7906 · 发表于 2020-2-21 15:12:52

OTA怎么弄，没弄明白，新人求指教，谢谢

fryefryefrye · 发表于 2020-2-25 12:12:58

本帖最后由 fryefryefrye 于 2020-2-25 12:14 编辑

muziwenwu 发表于 2020-1-9 21:41
我试了有点问题，最左边多了2个点。
lz能不能搞成4块点阵屏幕显示秒的。

星期这个东西，写成阿拉伯数字，感觉太山寨了。特别是周日，你说显示多少？0,7还是8？要不就给个16*16的点阵，显示汉字。
我自己做的钟，也是显示英文的。都写代码的人了，这点英语应该没问题吧。

[Arduino] DIY ESP8266 WIFI自动校时LED点阵滚动时钟，支持OTA升级/自动调节亮度

爱科技、爱创意、爱折腾、爱极致，我们都是技术控

打赏

相关帖子

账号		自动登录	找回密码
密码			立即注册