精华内容
下载资源
问答
  • 为了节省板子(偷懒)没有采用常规的74HC573锁存器一组一组扫描着输出,而是采用每个引脚专门控制一位,但引脚刚好又差了一个,无奈就了一个573,把变化最小的第一位数字和调时按钮接上面 左上角的2032BAT是接纽扣...
  • 为了节省板子(偷懒)没有采用常规的74HC573锁存器一组一组扫描着输出,而是采用每个引脚专门控制一位,但引脚刚好又差了一个,无奈就了一个573,把变化最小的第一位数字和调时按钮接上面 左上角的2032BAT是接纽扣...
  • 欢迎点击「算法与编程之美」↑关注我们!本文首发于微信公众号:"算法与编程之美",欢迎关注,及时了解更多此系列文章。欢迎加入团队圈子!与作者面对面!直接点击!介绍动态时钟,...

    欢迎点击「算法与编程之美」↑关注我们!

    本文首发于微信公众号:"算法与编程之美",欢迎关注,及时了解更多此系列文章。

    欢迎加入团队圈子!与作者面对面!直接点击!

    介绍

    动态时钟,就是通过CSS工具的美化效果和引入JavaScript,让网页呈现出钟表的动态效果,让它能够记录时间。通过改变背景颜色、指针颜色和阴影效果,让时钟呈现不同的颜色。

    思路解析

    制作动态时钟时,要注意以下细节:

    (1)使用box-shadow标签来设置时钟的轮廓和阴影。

    (2)用JS获取每个指针和它的时间,用到const限定符和querySelector方法。

    制作过程

    (1)创建一个主容器class="clock"的时钟,为每个指针命名。

    <div><!--时钟-->

                              <div>  <!--时针-->

                                       <div id="hr"></div>

                              </div>

                              <div>   <!--分针-->

                                       <div id="mn"></div>

                              </div>

                              <div>   <!--秒针-->

                                       <div id="sc"></div>

                              </div>

                      </div>

    (2)用CSS为时钟布置背景,在.clock使用Flex布局方式,并且让它水平、垂直方向都居中;引入时钟的背景图片,用background-size: cover把背景图片放大到适合容器的尺寸,让图片比例不变。

    *{

             margin:  0;

             padding:  0;

             box-sizing:  border-box;

    }

    body{

             display:  flex;

             justify-content:  center;

             align-items:  center;

             min-height:  100vh;

             background:  #091921;

    }

    .clock{

             width:  350px;

             height:  350px;

             display:  flex;

             justify-content:  center;

             align-items:  center;

             background:  url(img/clock.png);

             background-size:  cover;

             border:  4px solid #091921;

             border-radius:  50%;

             .clock{

             width:  350px;

             height:  350px;

             display:  flex;

             justify-content:  center;

             align-items:  center;

             background:  url(img/clock.png);

             background-size:  cover;

             border:  4px solid #091921;

             border-radius:  50%;

             box-shadow:  0 -15px 15px rgba(255,255,255,0.05),/*时钟上半部分外发光*/

                         inset 0 -15px 15px rgba(255,255,255,0.05),/*时钟下半部分内发光*/

                         0 15px 15px rgba(0,0,0,0.3),/*时钟下半部分外阴影*/

                         inset 0 15px 15px rgba(0,0,0,0.3);/*时钟上半部分内阴影*/

    }

    (3)使用 CSS3 中的 ":before" 伪元素为时钟添加实心小圆点,方便指针确认中心点。

    .clock:before{

             content:  ''; /*必须存在,使伪元素显示*/

             position:  absolute;

             width:  15px;

             height:  15px;

             background:  #fff;

             border-radius:  50%;

             z-index:  10000;/*使实心小圆点在视图的最上层,遮挡住指针交叉的部分*/

    }

    (4)为不同指针添加宽高和颜色。

    .clock .hour,.clock .min,.clock .sec{

             position:  absolute;

    }

    .clock .hour, .hr{

             width:  160px;

             height:  160px;

    }

    .clock .min, .mn{

             width:  190px;

             height:  190px;

    }

    .clock .sec, .sc{

             width:  230px;

             height:  230px;

    }

    .hr .mn .sc{

             display:  flex;

             justify-content:  center;

             /*align-items:  center;*/

             position:  absolute;

             border-radius:  50%;

    }

    .hr:before{

             content:  '';

             position:  absolute;

             width:  8px;

             height:  80px;

             background:  orangered;

             z-index:  10;

             border-radius:  6px 6px 0 0;

             margin-left:  76px;

    }

    .mn:before{

             content:  '';

             position:  absolute;

             width:  4px;

             height:  90px;

             background:  #fff;

             z-index:  11;

             border-radius:  6px 6px 0 0;

             margin-left:  93px;

    }

    .sc:before{

             content:  '';

             position:  absolute;

             width:  2px;

             height:  150px;

             background:  red;

             z-index:  11;

             border-radius:  6px 6px 0 0;

             margin-left:  114px;

    }

    图1

    (5)用JS获取到当前的时间,分别计算每个指针应该旋转的角度。其中,deg代表:度(一个圆 360 度)。

    const deg = 6;   /*获取每个指针*/

             const hr = document.querySelector("#hr");

             const mm = document.querySelector("#mn");

             const ss = document.querySelector("#sc");

             setInterval(() => {

                let day = new Date(); /*获取当前时间*/

                let hh = day.getHours() * 30;

                let mm = day.getMinutes() * deg;

                let ss = day.getSeconds() * deg;

                hr.style.transform = 'rotate('+(hh+mm/12)+'deg)';  /*计算每个指针应旋转的角度*/

                 mn.style.transform = 'rotate('+mm+'deg)';

                sc.style.transform = 'rotate('+ss+'deg)';

     

                })

    效果图:

    图2

    END

    实习主编   |   王楠岚

       责       编   |   江南沐雪

     where2go 团队


       

    微信号:算法与编程之美          

    长按识别二维码关注我们!

    温馨提示:点击页面右下角“写留言”发表评论,期待您的参与!期待您的转发!

    展开全文
  • 如何PPT中制作实时时钟

    千次阅读 2018-03-12 13:29:17
    1、在网上下载好实时时钟flash,将其与新建好的PPT放入同一个文件夹下2、找到文件--&gt;选项--&gt;快速访问工具栏--&gt;常用命令选择‘开发工具选项卡’--&gt;其他控件--&gt;添加--&gt;确定...

    1、在网上下载好实时时钟flash,将其与新建好的PPT放入同一个文件夹下


    2、找到文件-->选项-->快速访问工具栏-->常用命令选择‘开发工具选项卡’-->其他控件-->添加-->确定


    3、点击其他控件-->选择Shockwave Flash Object


    在PPT上画一部分区域


    右键属性-->Move中填写flash名称-->将Playing改为true


    保存PPT,直接打开放映就可以得到一个实时时钟,情况如下


    同理:插入其他flash动画也可以

    展开全文
  • 蓝牙时钟

    千次阅读 2016-04-08 10:17:47
    每一个蓝牙单元都有一个内部系统时钟,它决定了收、发信机的定时 和跳频。因蓝牙时钟取自一个自由运转的时钟,该时钟永不会被调整和关 闭。 作为与其它单元的同步,仅有时钟补偿值对该时钟作为相互同步的临 时蓝牙...
    每一个蓝牙单元都有一个内部系统时钟,它决定了收、发信机的定时
    
    和跳频。因蓝牙时钟取自一个自由运转的时钟,该时钟永不会被调整和关
    闭。  作为与其它单元的同步,仅有时钟补偿值对该时钟作为相互同步的临
    时蓝牙时钟。应当注意:蓝牙时钟与每天的时间无关,因此,它可用任何
    值初始化。蓝牙时钟作为蓝牙收、发信机的时钟,它的分辨度至少是TX或
    RX的时隙长度的一半或者312.5µs,该时钟周期约为一天。如果时钟用计
    数器来实现,那么28位计数器的计数值范围是2 的28次方-1。在312.5µs的各单
    元LSB点,给出的时钟频率是3.2KHz。
    在匹克网信道上的定时和跳频由主单元的蓝牙时钟来确定。当匹克网
    确立时,主单元时钟值通过通信链接传送给从单元,各从单元在自己的本
    地时钟上增加一个补偿值以求得与主时钟同步。由于时钟不能受控,所以
    该补偿值必须有规律的进行更新。
    在蓝牙接收机里,时钟确定了临界时间并激发事件。对蓝牙系统来说
    有四个时间段非常重要:312.5µs,625µs,1.25ms 和1.28S。这些时间段

    分别于定时器位CLK0、CLK1、CLK2和CLK3对应。如图所示:


    当CLK0、CLK1都为“0”时,主一从传输以偶数时隙开始。
    在不同的模式和状态里的蓝牙单元可具有不同的时钟特性:
    ● CLKN  本地时钟
    ● CLKE  预计时钟

    ● CLK  主时钟
    CLKN是一个自由运转的时钟,而且是所有其它时钟特性的参考。在
    高度活跃状态下,本地时钟用精度为+/-20ppm晶体振荡器产生。在低度活
    跃状态下,如待机(STANDBY)、保持(HOLD)、休眠(PARK),本地时
    钟可以用相对精度较差的+/-250 ppm  低功耗振荡器(LOP)产生。
    CLKE和CLK通过增加一个补偿值取自CLKN基准。CLKE是一个处
    理接收器的本地时钟估算呼叫单位,即:在呼叫CLKN上加补偿近于接收
    的CLKN。通过使用接收的CLKN,呼叫加速了链接建立。
    CLKE导出见图所示


    CLK是匹克网的主时钟,它用于匹克网中所有定时和时序安排。所有
    的蓝牙设备都使用CLK来安排它们传输和接收时序。CLK通过在本地时
    钟CLKN的基础上增加一个补偿值获得。因为CLK同它自己的本地时钟
    CLKN是完全等同的,所以对主单元来说,补偿值是“0”。而对各个从单
    元来说,都对自身的CLKN加上一个适当的补偿值,以求得与主单元的
    CLKN一致。虽然在蓝牙设备里所有CLKN都以相同的标称速率运行,但
    相互之间的漂移引起了CLK的不准确性。因此在从单元里的补偿必须定期
    的修改,以致CLK近似于主单元的CLKN。
    主单元和从单元的CLK导出如图所示



    展开全文
  • 转载请标明出处:https://blog.csdn.net/m0_38074457/article/details/85790550,本文...1、attrs.xml中添加自定义控件的属性 &lt;declare-styleable name="AlarmClockView"&gt; &lt;!--...

    转载请标明出处:https://blog.csdn.net/m0_38074457/article/details/85790550,本文出自【陈少华的博客】

    一、效果图

    二、控件结构

     三、代码实现

    1、attrs.xml中添加自定义控件的属性

       <declare-styleable name="AlarmClockView">
            <!--外圆颜色-->
            <attr name="outerCircleColor" format="reference|color" />
            <!--内圆颜色-->
            <attr name="innerCircleColor" format="reference|color" />
            <!--秒针颜色-->
            <attr name="secondHandColor" format="reference|color" />
            <!--分针颜色-->
            <attr name="minuteHandColor" format="reference|color" />
            <!--时针颜色-->
            <attr name="hourHandColor" format="reference|color" />
            <!--时钟分钟刻度颜色-->
            <attr name="minuteScaleColor" format="reference|color" />
            <!--时钟分钟5的倍数刻度颜色-->
            <attr name="scaleColor" format="reference|color" />
            <!--时钟下面实时时间文本颜色-->
            <attr name="dateValueColor" format="reference|color" />
            <!--是否显示时钟下实时时间文本-->
            <attr name="isShowTime" format="boolean" />
            <!--时钟占整体控件的大小比例-->
            <attr name="proportion" format="float" />
            <!--是否设置为夜间模式-->
            <attr name="night" format="boolean" />
        </declare-styleable>

    2、创建自定义控件AlarmClockView继承View(请结合具体代码来看)

    1)构造方法中通过initView获取初始化值。

    2)onSizeChanged方法中获取控件的宽高,并设置时钟的中心点坐标、半径等信息。

    3)onDraw方法中根据上图绘制流程对时钟进行绘制。

    4)调用start方法并设置监听启动闹钟,通过handler每隔1秒获取当前时间,并刷新控件。

    
    import android.content.Context;
    import android.content.res.TypedArray;
    import android.graphics.Canvas;
    import android.graphics.Color;
    import android.graphics.Paint;
    import android.graphics.RectF;
    import android.os.Build;
    import android.os.Handler;
    import android.support.annotation.Nullable;
    import android.support.annotation.RequiresApi;
    import android.util.AttributeSet;
    import android.view.View;
    import java.util.Calendar;
    
    /**
     * Created by HARRY on 2019/1/4 0004.
     */
    
    public class AlarmClockView extends View {
    
        /**
         * 秒针颜色
         */
        private int mSecondHandColor;
        /**
         * 分针颜色
         */
        private int mMinuteHandColor;
        /**
         * 时针颜色
         */
        private int mHourHandColor;
        /**
         * 分钟刻度颜色
         */
        private int mMinuteScaleColor;
        /**
         * 当分钟是5的倍数时刻度的颜色
         */
        private int mPointScaleColor;
        /**
         * 时钟底部时间文本颜色
         */
        private int mDateValueColor;
        /**
         * 时钟宽度
         */
        private int mClockWid;
        /**
         * 时钟最外层圆半径
         */
        private int mOuterRadius;
        /**
         * 时钟圆心x
         */
        private int mCenterX;
        /**
         * 时钟圆心y
         */
        private int mCenterY;
        /**
         * 控件宽
         */
        private int mWid;
        /**
         * 控件高
         */
        private int mHei;
        private Paint mPaint = new Paint();
        /**
         * 最外层圆颜色
         */
        private int mOuterCircleColor;
        /**
         * 内层圆颜色
         */
        private int mInnerCircleColor;
        /**
         * 内层半径
         */
        private int mInnerRadius;
        /**
         * 内外圆的间距
         */
        private int mSpace = 10;
        /**
         * 现在的时间小时
         */
        private int mHour;
        /**
         * 现在的时间分钟
         */
        private int mMinute;
        /**
         * 现在的时间秒
         */
        private int mSecond;
        /**
         * 时钟上刻度值的高度
         */
        private int mScaleValueHei;
        private String[] arr = {"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};
        /**
         * 现在的时间天
         */
        private int mDay;
        /**
         * 现在的时间周几
         */
        private int mWeek;
        /**
         * 现在的时间月
         */
        private int mMonth;
        /**
         * 现在的时间年
         */
        private int mYear;
        /**
         * 是否显示时钟底部的时间文本
         */
        private boolean mIsShowTime;
        /**
         * 真实的周几
         */
        private String mWeekStr;
        /**
         * 时间监听
         */
        private TimeChangeListener listener;
        /**
         * 时钟占空间整体的比例
         */
        private float mProportion;
        /**
         * 是否为夜间模式
         */
        private boolean mIsNight;
        private Context context;
        private AttributeSet attrs;
    
        /**
         * handler用来处理定时任务,没隔一秒刷新一次
         */
        private Handler mHandler = new Handler();
        private Runnable runnable = new Runnable() {
            @Override
            public void run() {
                mHandler.postDelayed(this, 1000);
                initCurrentTime();
            }
        };
        private int mApm;
    
        public AlarmClockView(Context context) {
            this(context, null);
        }
    
        public AlarmClockView(Context context, @Nullable AttributeSet attrs) {
            this(context, attrs, 0);
        }
    
        public AlarmClockView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
            super(context, attrs, defStyleAttr);
            initView(context, attrs);
        }
    
        @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
        public AlarmClockView(Context context, @Nullable AttributeSet attrs, int defStyleAttr, int defStyleRes) {
            super(context, attrs, defStyleAttr, defStyleRes);
            initView(context, attrs);
        }
    
        private void initView(Context context, AttributeSet attrs) {
            this.context = context;
            this.attrs = attrs;
            TypedArray array = context.obtainStyledAttributes(attrs, R.styleable.AlarmClockView);
            if (array != null) {
                mOuterCircleColor = array.getColor(R.styleable.AlarmClockView_outerCircleColor, getResources().getColor(R.color.gray));
                mInnerCircleColor = array.getColor(R.styleable.AlarmClockView_innerCircleColor, getResources().getColor(R.color.grayInner));
                mSecondHandColor = array.getColor(R.styleable.AlarmClockView_secondHandColor, getResources().getColor(R.color.green));
                mMinuteHandColor = array.getColor(R.styleable.AlarmClockView_minuteHandColor, getResources().getColor(R.color.black));
                mHourHandColor = array.getColor(R.styleable.AlarmClockView_hourHandColor, getResources().getColor(R.color.black));
                mMinuteScaleColor = array.getColor(R.styleable.AlarmClockView_minuteScaleColor, getResources().getColor(R.color.black));
                mPointScaleColor = array.getColor(R.styleable.AlarmClockView_scaleColor, getResources().getColor(R.color.black));
                mDateValueColor = array.getColor(R.styleable.AlarmClockView_dateValueColor, getResources().getColor(R.color.black));
                mIsShowTime = array.getBoolean(R.styleable.AlarmClockView_isShowTime, true);
                mProportion = array.getFloat(R.styleable.AlarmClockView_proportion, (float) 0.75);
                mIsNight = array.getBoolean(R.styleable.AlarmClockView_night, false);
                if (mProportion > 1 || mProportion < 0) {
                    mProportion = (float) 0.75;
                }
    
                if (mIsNight) {
                    setNightColor();
                }
                array.recycle();
            }
        }
    
        @Override
        protected void onSizeChanged(int w, int h, int oldw, int oldh) {
            super.onSizeChanged(w, h, oldw, oldh);
            mWid = w;
            mHei = h;
            //使闹钟的宽为控件宽的mProportion;
            mClockWid = (int) (w * mProportion);
            mOuterRadius = mClockWid / 2;
            mInnerRadius = mOuterRadius - mSpace;
            mCenterX = w / 2;
            mCenterY = mCenterX;
        }
    
        @Override
        protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
            super.onMeasure(widthMeasureSpec, heightMeasureSpec);
        }
    
        @Override
        protected void onDraw(Canvas canvas) {
            super.onDraw(canvas);
            //设置整体控件的背景为白色背景
            mPaint.setColor(Color.WHITE);
            canvas.drawRect(0, 0, mWid, mHei, mPaint);
    
            //画外层圆
            drawOuterCircle(canvas);
    
            //画内层圆
            drawInnerCircle(canvas);
    
            //画刻度
            drawTickMark(canvas);
    
            //画刻度值
            drawScaleValue(canvas);
    
            //画针
            drawHand(canvas);
    
            //画现在时间显示
            if (mIsShowTime) {
                drawCurrentTime(canvas);
            }
        }
    
        /**
         * 画时钟底部的时间文本
         *
         * @param canvas
         */
        private void drawCurrentTime(Canvas canvas) {
            mPaint.setColor(mDateValueColor);
            mPaint.setAntiAlias(true);
            mPaint.setTextSize(40);
    
            //使当前时间文本正好在时钟底部距离有2 * mSpace的位置
            Paint.FontMetricsInt fm = mPaint.getFontMetricsInt();
            int baseLineY = mCenterY + mOuterRadius - fm.top + 2 * mSpace;
    
            String apm = "";
            if (mApm == 0) {
                apm = "上午";
            } else {
                apm = "下午";
            }
    
            String time = "" + mYear + "年" + (mMonth + 1) + "月" + mDay + "日" + mWeekStr + apm + mHour + "点" + mMinute + "分" + mSecond + "秒";
            canvas.drawText(time, mCenterX, baseLineY, mPaint);
        }
    
        /**
         * 画时钟内的针
         *
         * @param canvas
         */
        private void drawHand(Canvas canvas) {
            //画时针
            canvas.save();
            int hourWid = 16;
            mPaint.setColor(mHourHandColor);
            mPaint.setStrokeWidth(hourWid);
    
            for (int i = 0; i < 12; i++) {
                if (i == mHour) {
                    //计算时针的偏移量
                    int offset = (int) (((float) mMinute / (float) 60) * (float) 30);
                    canvas.rotate(offset, mCenterX, mCenterY);
                    RectF rectF = new RectF(mCenterX - hourWid / 2, mCenterY - mInnerRadius + mScaleValueHei + 3 * mSpace, mCenterX + hourWid / 2, mCenterY);
                    canvas.drawRoundRect(rectF, hourWid / 2, hourWid / 2, mPaint);
                    break;
                } else {
                    canvas.rotate(30, mCenterX, mCenterY);
                }
            }
            canvas.restore();
    
            //画分针
            canvas.save();
            int minuteWid = 10;
            mPaint.setColor(mMinuteHandColor);
            mPaint.setStrokeWidth(10);
    
            for (int i = 0; i < 60; i++) {
                if (i == mMinute) {
                    //计算分针的偏移量
                    int offset = (int) ((float) mSecond / (float) 60 * (float) 6);
                    canvas.rotate(offset, mCenterX, mCenterY);
                    RectF rectF = new RectF(mCenterX - minuteWid / 2, mCenterY - mInnerRadius + 3 * mSpace, mCenterX + minuteWid / 2, mCenterY);
                    canvas.drawRoundRect(rectF, minuteWid / 2, minuteWid / 2, mPaint);
                    break;
                } else {
                    canvas.rotate(6, mCenterX, mCenterY);
                }
            }
            canvas.restore();
    
            //画秒针
            canvas.save();
            mPaint.setColor(mSecondHandColor);
            mPaint.setStrokeWidth(3);
    
            canvas.drawCircle(mCenterX, mCenterY, mSpace, mPaint);
    
            for (int i = 0; i < 60; i++) {
                if (i == mSecond) {
                    canvas.drawLine(mCenterX, mCenterY + 3 * mSpace, mCenterX, mCenterY - mInnerRadius + mSpace, mPaint);
                    break;
                } else {
                    canvas.rotate(6, mCenterX, mCenterY);
                }
            }
            canvas.restore();
    
        }
    
        /**
         * 画时钟内的刻度值
         *
         * @param canvas
         */
        private void drawScaleValue(Canvas canvas) {
            mPaint.setColor(mPointScaleColor);
            mPaint.setStyle(Paint.Style.FILL);
            mPaint.setStrokeWidth(5);
            mPaint.setAntiAlias(true);
            mPaint.setTextAlign(Paint.Align.CENTER);
            mPaint.setTextSize(30);
    
            //计算刻度值的文本高度
            Paint.FontMetricsInt fm = mPaint.getFontMetricsInt();
            mScaleValueHei = fm.bottom - fm.top;
    
            for (int i = 0; i < 12; i++) {
                String degree = (i + 1) + "";
                float[] temp = calculatePoint((i + 1) * 30, mInnerRadius - mSpace * 4 - mPaint.getTextSize() / 2);
                canvas.drawText(degree, temp[2] + mCenterX, mCenterY + temp[3] + mPaint.getTextSize() / 2, mPaint);
            }
        }
    
        /**
         * 计算线段的起始坐标
         *
         * @param angle
         * @param length
         * @return
         */
        private float[] calculatePoint(float angle, float length) {
            int POINT_BACK_LENGTH = 1;
            float[] points = new float[4];
            if (angle <= 90f) {
                points[0] = -(float) Math.sin(angle * Math.PI / 180) * POINT_BACK_LENGTH;
                points[1] = (float) Math.cos(angle * Math.PI / 180) * POINT_BACK_LENGTH;
                points[2] = (float) Math.sin(angle * Math.PI / 180) * length;
                points[3] = -(float) Math.cos(angle * Math.PI / 180) * length;
            } else if (angle <= 180f) {
                points[0] = -(float) Math.cos((angle - 90) * Math.PI / 180) * POINT_BACK_LENGTH;
                points[1] = -(float) Math.sin((angle - 90) * Math.PI / 180) * POINT_BACK_LENGTH;
                points[2] = (float) Math.cos((angle - 90) * Math.PI / 180) * length;
                points[3] = (float) Math.sin((angle - 90) * Math.PI / 180) * length;
            } else if (angle <= 270f) {
                points[0] = (float) Math.sin((angle - 180) * Math.PI / 180) * POINT_BACK_LENGTH;
                points[1] = -(float) Math.cos((angle - 180) * Math.PI / 180) * POINT_BACK_LENGTH;
                points[2] = -(float) Math.sin((angle - 180) * Math.PI / 180) * length;
                points[3] = (float) Math.cos((angle - 180) * Math.PI / 180) * length;
            } else if (angle <= 360f) {
                points[0] = (float) Math.cos((angle - 270) * Math.PI / 180) * POINT_BACK_LENGTH;
                points[1] = (float) Math.sin((angle - 270) * Math.PI / 180) * POINT_BACK_LENGTH;
                points[2] = -(float) Math.cos((angle - 270) * Math.PI / 180) * length;
                points[3] = -(float) Math.sin((angle - 270) * Math.PI / 180) * length;
            }
            return points;
        }
    
        /**
         * 画时钟的刻度线
         *
         * @param canvas
         */
        private void drawTickMark(Canvas canvas) {
            canvas.save();
    
            for (int i = 0; i < 60; i++) {
                if (i % 5 == 0) {
                    mPaint.setColor(mPointScaleColor);
                    mPaint.setStyle(Paint.Style.FILL);
                    mPaint.setStrokeWidth(5);
                    mPaint.setAntiAlias(true);
                    mPaint.setTextAlign(Paint.Align.CENTER);
                    mPaint.setTextSize(30);
    
                    canvas.drawLine(mCenterX, mSpace * 2 + mCenterY - mOuterRadius, mCenterX, mSpace * 4 + mCenterY - mOuterRadius, mPaint);
                } else {
                    mPaint.setColor(mMinuteScaleColor);
                    mPaint.setStyle(Paint.Style.FILL);
                    mPaint.setStrokeWidth(2);
                    mPaint.setAntiAlias(true);
    
                    canvas.drawLine(mCenterX, mSpace * 2 + mCenterY - mOuterRadius, mCenterX, mSpace * 3 + mCenterY - mOuterRadius, mPaint);
                }
    
                canvas.rotate(6, mCenterX, mCenterY);
            }
    
            canvas.restore();
        }
    
        /**
         * 画内圆
         *
         * @param canvas
         */
        private void drawInnerCircle(Canvas canvas) {
            mPaint.setColor(mInnerCircleColor);
            mPaint.setStyle(Paint.Style.FILL);
            mPaint.setAntiAlias(true);
            mPaint.setStrokeWidth(2);
    
            canvas.drawCircle(mCenterX, mCenterY, mInnerRadius, mPaint);
    
            if (mIsNight) {
                mPaint.setColor(Color.BLACK);
            } else {
                mPaint.setColor(Color.WHITE);
            }
            mPaint.setStyle(Paint.Style.FILL);
            mPaint.setAntiAlias(true);
    
            canvas.drawCircle(mCenterX, mCenterY, mInnerRadius - mSpace, mPaint);
        }
    
        /**
         * 画外圆
         *
         * @param canvas
         */
        private void drawOuterCircle(Canvas canvas) {
            mPaint.setColor(mOuterCircleColor);
            mPaint.setStyle(Paint.Style.STROKE);
            mPaint.setAntiAlias(true);
            mPaint.setStrokeWidth(2);
    
            canvas.drawCircle(mCenterX, mCenterY, mOuterRadius, mPaint);
        }
    
        /**
         * 获取当前时间
         */
        public void initCurrentTime() {
            Calendar mCalendar = Calendar.getInstance();
            resetTime(mCalendar);
            invalidate();
        }
    
        /**
         * 重置时间信息
         *
         * @param calendar
         */
        private void resetTime(Calendar calendar) {
            //因为获取的时间总是晚一秒,这里加上这一秒
            calendar.add(Calendar.SECOND, 1);
            mYear = calendar.get(Calendar.YEAR);
            mMonth = calendar.get(Calendar.MONTH);
            mDay = calendar.get(Calendar.DAY_OF_MONTH);
            mWeek = calendar.get(Calendar.DAY_OF_WEEK);
            mHour = calendar.get(Calendar.HOUR);
            mMinute = calendar.get(Calendar.MINUTE);
            mSecond = calendar.get(Calendar.SECOND);
    //        apm=0 表示上午,apm=1表示下午。
            mApm = calendar.get(Calendar.AM_PM);
            //1.数组下标从0开始;2.老外的第一天是从星期日开始的
            mWeekStr = arr[calendar.get(calendar.DAY_OF_WEEK) - 1];
    
            System.out.println("现在时间:小时:" + mHour + ",分钟:" + mMinute + ",秒:" + mSecond);
    
            if (listener != null) {
                listener.onTimeChange(calendar);
            }
        }
    
        /**
         * 运行闹钟
         *
         * @param listener
         */
        public void start(TimeChangeListener listener) {
            this.listener = listener;
            mHandler.postDelayed(runnable, 1000);
            initCurrentTime();
        }
    
        /**
         * 运行闹钟
         */
        public void start() {
            mHandler.postDelayed(runnable, 1000);
            initCurrentTime();
        }
    
        /**
         * 停止闹钟
         */
        public void stop() {
            mHandler.removeCallbacks(runnable);
        }
    
        /**
         * 设置是否为夜间模式
         *
         * @param isNight
         */
        public void setIsNight(boolean isNight) {
            mIsNight = isNight;
    
            judgeIsNight();
        }
    
        /**
         * 判断isNight属性下颜色值如何选择
         */
        private void judgeIsNight() {
            if (mIsNight) {
                setNightColor();
            } else {
                //这里没有night属性
                TypedArray array = context.obtainStyledAttributes(attrs, R.styleable.AlarmClockView);
                if (array != null) {
                    mOuterCircleColor = array.getColor(R.styleable.AlarmClockView_outerCircleColor, getResources().getColor(R.color.gray));
                    mInnerCircleColor = array.getColor(R.styleable.AlarmClockView_innerCircleColor, getResources().getColor(R.color.grayInner));
                    mSecondHandColor = array.getColor(R.styleable.AlarmClockView_secondHandColor, getResources().getColor(R.color.green));
                    mMinuteHandColor = array.getColor(R.styleable.AlarmClockView_minuteHandColor, getResources().getColor(R.color.black));
                    mHourHandColor = array.getColor(R.styleable.AlarmClockView_hourHandColor, getResources().getColor(R.color.black));
                    mMinuteScaleColor = array.getColor(R.styleable.AlarmClockView_minuteScaleColor, getResources().getColor(R.color.black));
                    mPointScaleColor = array.getColor(R.styleable.AlarmClockView_scaleColor, getResources().getColor(R.color.black));
                    mDateValueColor = array.getColor(R.styleable.AlarmClockView_dateValueColor, getResources().getColor(R.color.black));
                    mIsShowTime = array.getBoolean(R.styleable.AlarmClockView_isShowTime, true);
                    mProportion = array.getFloat(R.styleable.AlarmClockView_proportion, (float) 0.75);
                    if (mProportion > 1 || mProportion < 0) {
                        mProportion = (float) 0.75;
                    }
    
                    array.recycle();
                }
            }
        }
    
        /**
         * 设置夜晚时的颜色
         */
        private void setNightColor() {
            mMinuteHandColor = Color.WHITE;
            mHourHandColor = Color.WHITE;
    
            mMinuteScaleColor = Color.WHITE;
            mPointScaleColor = Color.WHITE;
    
            mInnerCircleColor = Color.BLACK;
        }
    
        public boolean getIsNight() {
            return mIsNight;
        }
    
        /**
         * 自定义时间
         *
         * @param calendar
         */
        public void setCurrentTime(Calendar calendar) {
            stop();
            resetTime(calendar);
            invalidate();
        }
    }
    
    import java.util.Calendar;
    
    /**
     * Created by HARRY on 2019/1/4 0004.
     */
    
    public interface TimeChangeListener {
        void onTimeChange(Calendar calendar);
    }
    

    三、项目中如何引用

    步骤1.将JitPack存储库添加到构建文件中

    项目的根build.gradle中添加以下代码:

    allprojects {
    	repositories {
    		...
    		maven { url 'https://jitpack.io' }
    	}
    }

    步骤2.build.gradle添加依赖项

    dependencies {
        implementation 'com.github.hnsycsxhzcsh:AlarmClockView:v1.5'
    }

    步骤3. 布局中引用控件

        <com.alarmclockview.AlarmClockView
            android:id="@+id/clock"
            app:proportion="0.6"
            android:layout_width="match_parent"
            android:layout_height="match_parent" />

    步骤4. activity中调用start启动闹钟并添加监听

            mClock = findViewById(R.id.clock);
            //运行闹钟
            mClock.start(new TimeChangeListener() {
                @Override
                public void onTimeChange(Calendar calendar) {
                    //根据calendar获取当前时间
    
                }
            });

    备注:

    可以在github上下载我的项目:https://github.com/hnsycsxhzcsh/AlarmClockView,如果我的博客对你有帮助的话,欢迎博客点赞支持,并在github右上角star支持!

     

     

     

     

     

    展开全文
  • 手机中的时钟大致分为逻辑电路主时钟和实时时钟两大类。逻辑电路的主时钟通常有13M、26M、和19.5M等;实时时钟一般为32.768KHz。无论是逻辑电路的主时钟还是实时时钟,均是手机正常工作的必要条件,由于手机各厂家...
  • Android 自定义View 属性动画实现的一个动画时钟
  • 当智能手机电源之后,电源电路两端就会产生3.7V的电压,这个电压直接为处理器内部的振荡器供电,随即时钟电路开始工作,为处理器芯片内部的微处理器电路中的开机模块提供所需的时钟频率。 这个过程中,最重要的...
  • Raspberry Pi:Model B/B+(已测),其他型号理论也可以,只不过可能要修改一下后面说到的shell脚本中的端口号 OS:Arch Linux ARM 『2』实时时钟与树莓派的关系 树莓派为了节约成本以及减小体积,没有板载的...
  • 已经模拟器,平板运行,可以通过,一般用作屏保显示,支持秒针,
  • 数字时钟是采用数字电路技术实现时、分、秒计时显示的装置,可以用数字同时显示时,分,秒的精确时间并实现准确校时,具备体积小、重量轻、抗干扰能力强、对环境要求高、高精确性、容易开发等特性,工业控制系统、...
  • 使用Qt创建一个时钟

    2020-05-27 12:28:30
    在网上找的好看的照片作为背景,用画板画表盘和各个指针,看起来效果挺不错。 主要代码 2.1、设置画家函数 2.2、背景部分 //添加背景图 QPixmap map(":/2.jpg"); //图片大小 QRect q(0,0,710,710); //图片...
  • PerfectWorldClock 世界时钟:程序内部自带世界15000个城市名称、所属时区、国家、归属洲,无论你走到哪里,都能找到自己所在的时区!另外,该程序自带漂亮的Widget,可以让自己的手机时钟界面更加漂亮! 附:程序...
  • 为了节省板子(偷懒)没有采用常规的74HC573锁存器一组一组扫描着输出,而是采用每个引脚专门控制一位,但引脚刚好又差了一个,无奈就了一个573,把变化最小的第一位数字和调时按钮接上面 左上角的2032BAT是接纽扣...
  •  最近一直学习前端知识,非常感谢慕课网的讲师Silva Zhou以及w3school的教程让我快速的学习到一门技能,今天学到了如何利用canvas来画出一个时钟,雕虫小技,大神勿喷。  对于canvas,w3shcool是这么描述的:...
  • 这个时钟小巧,可以放在桌面,也可以贴墙壁,甚至可以揣兜里,随身携带。来看看这个小家伙吧!!! 我的时钟还具备充电功能,采用microUSB(随便哪个手机充电器就可以了)进行充电,不必担心它没电(除非你...
  • 圆形时钟控件

    千次阅读 2017-03-27 16:18:38
    这是我一个项目中用到的时钟控件,也是在网上找的别人的代码,这记一下,为了以后用到的时候便于找到。 package com.example.administrator.wy_exclusivecalender.view;/** * Created by qby on 2017/1/21 ...
  • 时钟就是一个芯片的心脏,CPU的处理速度也是由时钟来直接决定,相比51单片机单一的时钟源,STM32具有强大的时钟系统,我们的所有的外设都离不开时钟时钟是学习STM32非常重要的部分。
  • NTP时钟服务器标准化考场系统应用 NTP时钟服务器标准化考场系统应用 第一章 背景介绍 我国教育改革不断深入,电子技术与计算机网络技术不断发展,招生考试的现代化管理水平也不断提高。各地全面推动电子化考场...
  • 硬件部分,由时钟电路+WiFi模块+MCU最小系统+OLED显示屏+稳压电路+按键电路组成,这里采用时钟电路是希望模块断网后还能获取一个比较精准的时间,并且电路设计增加了储能电容可以断电一个月后保持时间数据不...
  • ESP8266物联网时钟-需求分析

    千次阅读 2021-09-22 07:11:00
    本产品是定义为桌面时钟,一般场景是放在办公桌、床头、学生宿舍桌、书架、茶几等家用环境,可以方便用户随时查看当前时间、当前天气。 1、可以从网络中获取时间,自动校准时间 价值:高,可以解决普通时钟需要...
  • 之前写了一个极简版的JS 实现简单时钟特效 现在我们给它变漂亮,一些图片,给它美化美化 代码 <!DOCTYPE html> <!--时钟特效case--> <html> <head> <meta charset="UTF-8"> ...
  • 最近STM32写了一份串口通信的程序,但下载复位后串口却不能工作,初始化的代码如下: //发送/接收的GPIO、串口和中断的初始化结构体 GPIO_InitTypeDef GPIO_InitStructureTx; GPIO_InitTypeDef GPIO_...
  • 看到很炫的瑜伽人体时钟效果,感觉非常炫,就添加到了自己的博客里,怎么添加呢?在网上查到的方法都是插入下面代码<scriptcharset=”Shift_JIS”src=”...
  • 如何使用js实现电子时钟功能

    千次阅读 2020-03-28 16:20:58
    电子时钟网上常见的功能,学习date对象和定时器功能时,来完成一个电子时钟的制作是不错的选择。学习本教程之前,读者需要具备html和css技能,同时需要有简单的javascript基础。 先准备一个html元素,用来放置...
  • js 模拟时钟时区Whether you have coworkers, friends, or family in different time zones, keeping track of it all can take some effort. Windows lets you add multiple time zone clocks to the taskbar, ...
  • DS1302时钟

    千次阅读 2018-12-01 10:10:10
    STM32与DS1302设计时钟芯片,超详细 2017年12月19日 16:08:51 验精护士 阅读数:5510 DS1302 是DALLAS 公司推出的涓流充电时钟芯片,内含有一个实时时钟/日历和31 字节静态RAM ,通过简单的串行接口与单片机进行...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 31,515
精华内容 12,606
关键字:

如何在手机上添加时钟