课程设计题十八：七彩呼吸灯

要求:

（1）	起始状态时，七个灯处于同频率“呼吸”状态。 修改：8个灯

（2）	按键1按下时，1号到8号依次由亮到暗“呼吸”。

（3）	按键2按下时，1号到8号依次由暗到亮“呼吸”。

（4）	按键3按下时，恢复起始亮法。
1 先做一个呼吸灯
由易到难，先做一个呼吸灯。

呼吸灯是让小灯从暗到亮变化，然后从亮回到暗。并一直循环。

51单片机只能依靠定时器完成PWM。并且基于PWM原理下，proteus无法仿真出小灯的亮暗，只能看实物。
#include "reg51.h"
#include <intrins.h>

/*
 * 10ms的PWM频率是100HZ
 * 高电平时间+低电平时间=10ms
 * 低电平时间越长，小灯亮度越高
 */
sbit		led0		= P2 ^ 0;

效果：


2 完成题目
（2）	按键1按下时，1号到8号依次由亮到暗“呼吸”。

（3）	按键2按下时，1号到8号依次由暗到亮“呼吸”。

（4）	按键3按下时，恢复起始亮法。
摄像头拍不清楚，肉眼看得更清楚。

项目一：FPGA的呼吸灯实现

          项目介绍：呼吸灯，就是想人们呼吸频率的一种led灯亮灭的一种表现形式。过程是慢慢变亮，然后变亮以后又慢慢变灭的一种过程。很多初学者会认为硬件逻辑语言怎么能控制电流的高低呢，让灯有多亮就调多亮，所以觉得不好实现，其实不用担心，呼吸灯捅破窗户纸就知道，其实是一个很简单的一个小项目，下面我将一步一步的讲解，并且实现。

          项目小知识讲解：本次项目会用到计数器，计时器在我上一个文章里有介绍，这里就不多说了。此外再回顾一下占空比的小知识，PWM（Pluse Width Modulation）脉冲宽度调制，是一种对模拟信号电平进行数字编码的方法。通过高分辨率计数器的使用，方波的占空比被调制用来对一个具体模拟信号的电平进行编码。并广泛应用在从测量、通信、功率控制与变换及LED照明等许多领域中。顾名思义，就是占空比可调的信号，那么什么是占空比呢？

       占空比（Duty Cycle or Duty Ratio），可以解释为，在一脉冲序列中（方波），正脉冲序列的持续时间与脉冲总周期的比值。也可理解为，电路释放能量的有效时间与总释放时间的比值。PWM是怎样实现调光呢？想要调节LED的亮度变化，实则是调节控制流经LED的电流。电流增大则LED亮度增强，反之减弱。但由于电流为模拟信号，所以这时就用到了PWM。



假设刚开始时占空比为1％，慢慢的占空比为2％、3％、4％……56％、57％……98％、99％、100％。

这就是LED灯亮的一个过程，我们可以让占空比为1％时，令LED灯亮，其余的部分让LED灭，慢慢的占空比越来越大，亮的部分也越来越多，这就是一个由灭到亮的一个过程。

假设刚开始时占空比为100％，慢慢的占空比为99％、98％、97％……64％、63％……2％、1％、0％。

这就是LED灯灭的一个过程，我们可以让占空比为99％时，令LED灯灭，其余的部分让LED亮，慢慢的占空比越来越小，灭的部分也越来越多，这就是一个由亮到灭的一个过程。

项目设计：

     首先我们要思考，如何设计这样描述的一个过程，很多人应该想到了用计数器，没错，确实要用到计数器。下面我们可以先画一下项目构思前的时序图。



自己手动画的，有点粗糙，就凑合的看一下吧.......时钟的线只是为了对齐，真实的时钟只对着2us计数的一个时钟周期的；比如说晶振为50MHZ，那么每一个时钟周期相当于1/50M=20ns，故第一个计数器为一个2us的计数器，每计100次之后清零；第二个计数器为2ms计数器，每当2us计数器计数100次时，2ms就会增加一次。同理2s计数器也是一样。

我们可以看出，当cnt_2s>=cnt_2ms的部分刚好是我们上面所说的占空比的位置，而且当cnt_2s加到999的时候刚好占空比为100%，所以我们就会多了一个条件，当cnt_2s>=cnt_2ms，我们让LED亮，cnt_2s<cnt_2ms的部分我们让他灭。

一个完整的呼吸灯时间为2s，也就是，由亮变暗需要2s，由暗变亮需要2s；将 2s分为1000等份，也就是由亮变暗，需要1000次的变化，每次为2ms，将,2ms分为1000等份，占空比100%过渡到0%，需要100次的变化，每次为2us；

既然原理差不多有了解，下面我们就开始编程环节了：











上半段只是一个由灭到亮的一个过程，我们下面开始下下半段（有亮到灭的过程），很多人都会觉得那岂不是和上面一样再写很多程序嘛！！！！就不卖关子了，只需要加一个标志位flag就可以了。



记得加了标志位flag的时候，要把标志位flag的判断条件写在LED模块当中。

下面是仿真图



根据仿真图我们可以看到灯只在一小段是亮的，其余的时间都是灭的，故后面也是一样的结果。



上图是全亮的时候准备进行由亮到灭的过程。

 

项目二：双向流水呼吸灯的实现

项目设计：实现流水灯的现象，并且在流水的时候每个LED灯都实现呼吸灯的效果。为了实现这个效果，本次的设计是像踏步一样的小项目，第一个LED灯准备从最亮到灭的那个临界点，第二个LED灯就开始准备由灭到亮的一个过程，全程实现一个双向流水灯的效果，流水到最右边再返回。也就是说0S时第一个LED灯开始亮，到2S时再慢慢熄灭，此时第二个LED灯准备开始慢慢变亮到4S时慢慢熄灭，此时第三个LED灯准备慢慢变亮，以此类推..........

程序设计：流水呼吸灯的方法多种多样，仁者见仁，智者见智。比如将呼吸灯模块例化到顶层模块去设计；用状态机控制每个灯的过程；设置标志位信号，用位拼接的方法去完成呼吸流水灯。此次设计为了方便初学者理解，用一种最简单的方法，加一个计数器，去控制每个灯的变化。



让它每次在每个2S末尾处触发+1，在7的时候清零，共计8个2s；思路在项目设计处有说，只有在每块加一个条件，即可以实现效果，但是在每个cnt计数的时候，要注意第一个项目程序中的flag是1还是0；

效果大概和仿真时一样的（踏雪寻梅的效果），仿真图如下：



下面是用例化到顶层文件实现的流水呼吸灯的仿真：



 

一般很多人看着仿真图便可以将程序写出，若新手不懂的，可以自行下载一下程序，因为程序过长，我将源程序和仿真程序打包上传了，有兴趣的可以自行下载一下：

https://download.csdn.net/download/qq_40261818/10580989

              

 

 

           写博客是为了方便学弟学妹们学习以及初学者学习，也欢迎大家交流，请勿盗用，感谢尊重原创！

           谈合作项目等请加V zhanghs1313

 

呼吸灯原理简介 + FPGA实现呼吸灯
所谓呼吸灯，就是是指灯光在微电脑的控制之下完成由亮到暗再由暗到亮的逐渐变化，感觉好像是人在呼吸，主要用于起通知提醒的作用。

本文简要介绍一下呼吸灯的原理，最后附上FPGA的呼吸灯Verilog HDL代码。希望能给各位读者些许帮助。
呼吸灯的效果是灯逐渐由暗变亮再逐渐由亮变暗周而复始像人在呼吸一样。大家可能会想到如果能实现逐渐增加电压再逐渐减小电压就能轻松实现。但是FPGA的引脚电压只有“0”和“1”两个等级。因此通过FPGA引脚实现“正弦波式”信号输出是不现实的。所以事实上都是通过改变引脚单位时间内高电平的输出时间来实现呼吸灯，也就是让FPGA引脚输出一系列PWM波信号并不断改变PWM波的占空比。
呼吸灯分为两个阶段：

第一阶段：由暗到亮。就是输出的一系列PWM波占空比由0%到100%以1%为间隔递增，共100个周期PWM波。

第二阶段：由亮到暗。就是输出的一系列PWM波占空比由100%到0%以1%为间隔递减，共100个周期PWM波。

注意：

有两个100：一个100为占空比100%；另一个100为由0%到100%或100%到0%需要100个周期PWM波。
FPGA呼吸灯代码Breath_LED.v：
/*************************************************
// 文件说明:      led呼吸灯代码
// 创 建 人：     mnWu522
// 日期：         2020-2-11
// 修 改 人：                     
// 修改日期：     20xx-xx-xx
*************************************************/
module Breath_LED(
	input clk,
	output reg led
);

reg [12:0]cnt1;
reg [8:0]cnt2;
reg [8:0]cnt3;
reg flag;
initial flag <= 0;
initial cnt1 <= 0;
initial cnt2 <= 0;
initial cnt3 <= 0;

always @(posedge clk)
begin
	if(cnt1 == 5000)begin
		cnt2 <= cnt2 + 1;
		cnt1 <= 0;
	end else begin
		cnt1 <= cnt1 +1;
	end

	if(cnt2 == 99)begin
		cnt3 <= cnt3 + 1;
		cnt2 <= 0;
	end

	if(cnt3 == 99)begin
		flag <= ~flag;
		cnt3 <= 0;
	end

	if(cnt2 >= cnt3 && flag == 0)begin
		led <= 1;
	end else if(cnt2 <= cnt3 && flag == 0)begin
		led <= 0;
	end else if(cnt2 >= cnt3 && flag == 1)begin
		led <= 0;
	end else if(cnt2 <= cnt3 && flag == 1)begin
		led <= 1;
	end
end

endmodule

代码讲解：

该代码实现一个2s的呼吸灯，1s由暗到亮，1s由亮到暗。

由第二个100得一个PWM波周期为1s/100=10ms；

由第一个100得1%占空比为10ms/100=100us；

cnt1加到5000是因为本代码默认时钟为50MHz，5000/50000000Hz=100us，可根据FPGA实际情况自行修改。

android呼吸灯效果设计思路
使用颜色渐变，使其边缘灯光区，与背景色无缝连接
使用属性动画，控制呼吸灯的发光
效果图如下：
GIF.gif
代码文件
package com.tian.criminalintent;
import android.animation.Animator;
import android.animation.AnimatorListenerAdapter;
import android.animation.ArgbEvaluator;
import android.animation.ValueAnimator;
import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.LinearGradient;
import android.graphics.Paint;
import android.graphics.RadialGradient;
import android.graphics.Shader;
import android.support.annotation.Nullable;
import android.util.AttributeSet;
import android.util.Log;
import android.view.View;
/**
* Created by XuZhen on 2019/5/13 18:02
*/
public class BreatheView extends View {
private int mInsideViewWidth = dp2px(getContext(), 70);
private int mInsideViewHeight = dp2px(getContext(), 40);
private int mLightDiffusionWidth = dp2px(getContext(), 20);  //扩散区宽度
private int mTextColor = Color.parseColor("#ffffff"); //默认字体颜色为白色
private int mTextSize = sp2px(getContext(), 22);
private int mInsideColor = Color.parseColor("#9FB6FF");//内部图形颜色，为蓝色
private boolean isLight = false; //控制是否开启动画
private int[] colors = {Color.parseColor("#9FB6FF"), Color.parseColor("#A7BAFE"), Color.parseColor("#F26882"), Color.parseColor("#F8DF57")};//变动颜色
private int mOutsideColor;
private Paint mTextPaint;
private Paint mInsideViewPaint;
private Paint mOutsideRectPaint;
private float mOutsideRectHeight;
private Paint mOutsideCirclePaint;
private int mRealWidth;
private int mRealHeight;
private LinearGradient mLinearGradient;
private RadialGradient mRadialGradient;
private String mBreatheViewText;
private ValueAnimator mGoLightAnim;
private ValueAnimator mBackLightAnim;
private ValueAnimator mColorAnim;
private int mColor;
private int mEndGraidentColor = Color.parseColor("#2e2e3D");
public BreatheView(Context context) {
this(context, null);
}
public BreatheView(Context context, @Nullable AttributeSet attrs) {
this(context, attrs, 0);
}
public BreatheView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
obtainAttributes(attrs);
initPaint();
}
/**
* 步骤一：根据xml属性，设置控件的属性
*
* @param attrs
*/
private void obtainAttributes(AttributeSet attrs) {
TypedArray typedArray = getContext().obtainStyledAttributes(attrs, R.styleable.BreatheView);
mInsideViewWidth = typedArray.getDimensionPixelSize(R.styleable.BreatheView_insideViewWidth, mInsideViewWidth);
mInsideViewHeight = typedArray.getDimensionPixelSize(R.styleable.BreatheView_insideViewHeight, mInsideViewHeight);
mLightDiffusionWidth = (int) typedArray.getDimension(R.styleable.BreatheView_lightDiffusionWidth, mLightDiffusionWidth);
mTextSize = typedArray.getDimensionPixelSize(R.styleable.BreatheView_BreatheViewTextSize, mTextSize);
mTextColor = typedArray.getColor(R.styleable.BreatheView_BreatheViewTextColor, mTextColor);
//控件文字
mBreatheViewText = typedArray.getString(R.styleable.BreatheView_BreatheViewText);
//内部颜色
mInsideColor = typedArray.getColor(R.styleable.BreatheView_BreatheViewInsideColor, mInsideColor);
//是否开启灯光扩散，在xml中设置
isLight = typedArray.getBoolean(R.styleable.BreatheView_BreatheViewIsLight, isLight);
typedArray.recycle();//回收资源
}
/**
* 步骤二：初始化绘制控件的笔触
*/
private void initPaint() {
//文本文字
mTextPaint = new Paint();
mTextPaint.setStyle(Paint.Style.FILL);
mTextPaint.setAntiAlias(true);
mTextPaint.setColor(mTextColor);
mTextPaint.setTextSize(mTextSize);
//内部的图形
mInsideViewPaint = new Paint();
mInsideViewPaint.setStyle(Paint.Style.FILL);
mInsideViewPaint.setAntiAlias(true);
mInsideViewPaint.setColor(mInsideColor);
//外部方区域图形
mOutsideColor = mInsideColor;
mOutsideRectPaint = new Paint();
mOutsideRectHeight = mInsideViewHeight;
mLinearGradient = new LinearGradient(0, 0, 0, mOutsideRectHeight,
new int[]{Color.WHITE, mOutsideColor, Color.WHITE}, new float[]{0, 0.5f, 1}, Shader.TileMode.CLAMP);
mOutsideRectPaint.setShader(mLinearGradient);
mOutsideRectPaint.setStyle(Paint.Style.FILL);
mOutsideRectPaint.setAntiAlias(true);
mOutsideRectPaint.setColor(mOutsideColor);
//外部的圆形区域
mOutsideCirclePaint = new Paint();
mOutsideCirclePaint.setStyle(Paint.Style.FILL);
mOutsideCirclePaint.setAntiAlias(true);
mOutsideCirclePaint.setColor(mOutsideColor);
mRadialGradient = new RadialGradient(mOutsideRectHeight / 2, mOutsideRectHeight / 2,
mOutsideRectHeight / 2, mOutsideColor, Color.WHITE, Shader.TileMode.CLAMP);
mOutsideCirclePaint.setShader(mRadialGradient);
}
/**
* 第三步，测试控件大小
*
* @param widthMeasureSpec
* @param heightMeasureSpec
*/
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
int height = getPaddingBottom() + getPaddingTop() + Math.abs(mLightDiffusionWidth * 2) + mInsideViewHeight;
int width = getPaddingLeft() + getPaddingRight() + mInsideViewWidth + mInsideViewHeight / 2 + mLightDiffusionWidth;
mRealWidth = resolveSize(width, widthMeasureSpec);
mRealHeight = resolveSize(height, heightMeasureSpec);
setMeasuredDimension(mRealWidth, mRealHeight);
}
@Override
protected void onSizeChanged(int w, int h, int oldw, int oldh) {
super.onSizeChanged(w, h, oldw, oldh);
}
/**
* 第四步，绘制控件
*
* @param canvas
*/
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
//变色
mInsideViewPaint.setColor(mInsideColor);
mInsideViewPaint.setAlpha(150);
canvas.translate(mInsideViewHeight / 2 + mLightDiffusionWidth + getPaddingLeft(), mRealHeight >> 1);
canvas.save();//保存图层
if (isLight) {
mOutsideCirclePaint.setColor(mOutsideColor);
mOutsideRectPaint.setColor(mOutsideColor);
mOutsideCirclePaint.setAlpha(150);
mOutsideRectPaint.setAlpha(150);
//绘制外部的长方形
canvas.translate(0, -mOutsideRectHeight / 2);
canvas.drawRect(0, 0, mInsideViewWidth, mOutsideRectHeight, mOutsideRectPaint);
//绘制外部的半圆
canvas.translate(-mOutsideRectHeight / 2, 0);
canvas.drawArc(0, 0, (int) mOutsideRectHeight, (int) mOutsideRectHeight, 90, 180, true, mOutsideCirclePaint);
canvas.restore();
canvas.save();
}
//绘制内部的长方形与半圆
canvas.translate(0, -(mInsideViewHeight >> 1));
canvas.drawRect(0, 0, mInsideViewWidth, mInsideViewHeight, mInsideViewPaint);
canvas.translate(-(mInsideViewHeight / 2), 0);
canvas.drawArc(0, 0, mInsideViewHeight, mInsideViewHeight, 90, 180, true, mInsideViewPaint);
canvas.restore();
canvas.save();
canvas.translate(0, -(mInsideViewHeight >> 1));
//文字的x轴坐标
float stringWidth = mTextPaint.measureText(mBreatheViewText);
float x = (mInsideViewWidth - stringWidth) / 2;
//文字的y轴坐标
Paint.FontMetrics fontMetrics = mTextPaint.getFontMetrics();
float y = (float) mInsideViewHeight / 2 + (Math.abs(fontMetrics.ascent) - fontMetrics.descent) / 2;
canvas.drawText(mBreatheViewText, x, y, mTextPaint);
canvas.restore();
}
/**
* 这边是设置动画，动画分成两个部分，第一部分，是扩散出去，第二部分是扩散回来，同时颜色渐变
*/
public void startLightAnim() {
mGoLightAnim = ValueAnimator.ofFloat(0f, mLightDiffusionWidth);
mGoLightAnim.setDuration(1500);
//动态开始设置扩散出去动画
mGoLightAnim.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
@Override
public void onAnimationUpdate(ValueAnimator animation) {
 TODO: 动画里面里面不应该不停的new对象，对内存会造成影响，,需要优化
mOutsideRectHeight = (int) (mInsideViewHeight + (float) animation.getAnimatedValue() * 2);
setGradient();
invalidate();
}
});
mGoLightAnim.addListener(new AnimatorListenerAdapter() {
@Override
public void onAnimationEnd(Animator animation) {
super.onAnimationEnd(animation);
if (!isLight) {
return;
}
mGoLightAnim.setStartDelay(1500);
mGoLightAnim.start();
}
});
//扩散回来的颜色动画
mBackLightAnim = ValueAnimator.ofFloat(mLightDiffusionWidth, 0f);
mBackLightAnim.setDuration(1500);
mBackLightAnim.setStartDelay(1500);
mBackLightAnim.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
@Override
public void onAnimationUpdate(ValueAnimator animation) {
mOutsideRectHeight = (int) (mInsideViewHeight + (float) animation.getAnimatedValue() * 2);
setGradient();
invalidate();
}
});
mBackLightAnim.addListener(new AnimatorListenerAdapter() {
@Override
public void onAnimationEnd(Animator animation) {
super.onAnimationEnd(animation);
if (!isLight) {
return;
}
mBackLightAnim.setDuration(1500);
mBackLightAnim.start();
}
});
//第二部分颜色渐变动画
int i = (int) (Math.random() * 3);
mColor = colors[i];
mColorAnim = ValueAnimator.ofObject(new ArgbEvaluator(), mInsideColor, mColor);
mColorAnim.setDuration(1500);
mColorAnim.setStartDelay(1500);
mColorAnim.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
@Override
public void onAnimationUpdate(ValueAnimator animation) {
mInsideColor = ((Integer) animation.getAnimatedValue());
mOutsideColor = mInsideColor;
invalidate();
}
});
mColorAnim.addListener(new AnimatorListenerAdapter() {
@Override
public void onAnimationEnd(Animator animation) {
super.onAnimationEnd(animation);
if (!isLight) {
return;
}
int i = (int) (Math.random() * 3);
mColor = colors[i];
Log.e("TAG", i + "");
mColorAnim.setObjectValues(mInsideColor, mColor);
mColorAnim.setStartDelay(1500);
mColorAnim.start();
}
});
mGoLightAnim.start();
mBackLightAnim.start();
mColorAnim.start();
isLight = true;
}
/**
* 重新设置Gradient
*/
private void setGradient() {
mLinearGradient = new LinearGradient(0, 0, 0, mOutsideRectHeight,
new int[]{mEndGraidentColor, mOutsideColor,mEndGraidentColor}, new float[]{0, 0.5f, 1}, Shader.TileMode.CLAMP);
mOutsideRectPaint.setShader(mLinearGradient);
mRadialGradient = new RadialGradient(mOutsideRectHeight / 2, mOutsideRectHeight / 2,
mOutsideRectHeight / 2, mOutsideColor, mEndGraidentColor, Shader.TileMode.CLAMP);
mOutsideCirclePaint.setShader(mRadialGradient);
}
/**
* 设置渐变底色
* @param endGraidentColor
*/
public void setEndGraidentColor(int endGraidentColor) {
mEndGraidentColor = endGraidentColor;
}
/**
* 关闭动画
*/
public void cancelLightAnim() {
isLight = false;//关闭动画
if (mGoLightAnim != null) {
mGoLightAnim.cancel();
}
if (mBackLightAnim != null) {
mBackLightAnim.cancel();
}
if (mColorAnim != null) {
mColorAnim.cancel();
}
mOutsideRectHeight = mInsideViewHeight;
mInsideColor = mColor;
mOutsideColor = mColor;
invalidate();
}
/**
* dp转换成px，scale为像素密度，density越高，分辨率越高
*
* @param context 获取屏幕
* @param dpVal
* @return
*/
public static int dp2px(Context context, int dpVal) {
final float scale = context.getResources().getDisplayMetrics().density;
return (int) (dpVal * scale + 0.5f);
}
/**
* sp转换成px，fontSCale为文字像素密度，fontScale越高，分辨率越高
*
* @param context
* @param spVal
* @return
*/
public static int sp2px(Context context, int spVal) {
final float fontScale = context.getResources().getDisplayMetrics().scaledDensity;
return (int) (spVal * fontScale + 0.5f);
}
}
attrs: