给小时钟打光

最新推荐文章于 2025-11-08 13:46:42 发布
原创 最新推荐文章于 2025-11-08 13:46:42 发布 · 174 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#360 #Linq #Windows

本文介绍了一个基于OpenGL的3D时钟渲染项目，通过加入灯光效果和旋转功能提升了时钟的真实感与互动性。文中详细展示了如何使用C#与OpenGL实现时钟的三维模型，并介绍了时钟在不同时间状态下的动态显示。
在昨天的基础上，加入了灯光和旋转，当打入灯光后，时钟立刻就有了立体感，并且按0可以切换灯光的关闭和打开，左右键可以让时钟进行旋转。明天加上探照灯的功能。

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using Tao.OpenGl;
using Tao.FreeGlut;
namespace homework3
{
    public partial class Form1 : Form
    {
        double second_rot = 0.0;
        double minit_rot = 0.0;
        double hour_rot = 0.0;
        double rot = 0.0;
        int status = 0;
        int light1_status = 1;
        DateTime mydatetime = new DateTime();
        public Form1()
        {
            InitializeComponent();
            this.simpleOpenGlControl1.InitializeContexts();
            Glut.glutInit();
        }
        private void setVolume()
        {
            Gl.glMatrixMode(Gl.GL_PROJECTION);
            Gl.glLoadIdentity();
            double aspect = (double)this.simpleOpenGlControl1.Size.Width / (double)this.simpleOpenGlControl1.Size.Height;
            Glu.gluPerspective(45.0, aspect, 0.1, 100.0);
            Gl.glViewport(0, 0, this.simpleOpenGlControl1.Width, this.simpleOpenGlControl1.Height);

        }
        private void myInit()
        {
            Gl.glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
            float[] global_ambient = new float[] { 0.2f, 0.2f, 0.0f };
            float[] light0_ambient = new float[4] {0.2f,0.2f,0.0f,1.0f };
            float[] light0_diffuse = new float[4] {0.7f,0.7f,0.0f,1.0f };
            float[] light0_specular = new float[4] {0.9f,0.9f,0.9f,1.0f};

            Gl.glLightModelfv(Gl.GL_LIGHT_MODEL_AMBIENT, global_ambient);
            Gl.glLightfv(Gl.GL_FRONT_AND_BACK, Gl.GL_AMBIENT, light0_ambient);
            Gl.glLightfv(Gl.GL_FRONT_AND_BACK, Gl.GL_DIFFUSE, light0_diffuse);
            Gl.glLightfv(Gl.GL_FRONT_AND_BACK, Gl.GL_SPECULAR, light0_specular);

            Gl.glColorMaterial(Gl.GL_FRONT_AND_BACK, Gl.GL_AMBIENT_AND_DIFFUSE);
            Gl.glEnable(Gl.GL_COLOR_MATERIAL);
            Gl.glEnable(Gl.GL_LIGHTING);
            Gl.glEnable(Gl.GL_LIGHT0);

            Gl.glEnable(Gl.GL_DEPTH_TEST);


            status = 0;
        }

        private void simpleOpenGlControl1_Load(object sender, EventArgs e)
        {
            myInit();
            setVolume();
            mydatetime = DateTime.Now;
            second_rot = mydatetime.Second * 6.0;
            minit_rot = mydatetime.Minute * 6.0;
            hour_rot = mydatetime.Hour * 30+mydatetime.Minute*0.5;

        }

        private void simpleOpenGlControl1_Paint(object sender, PaintEventArgs e)
        {
            Gl.glClear(Gl.GL_COLOR_BUFFER_BIT | Gl.GL_DEPTH_BUFFER_BIT);
            Gl.glMatrixMode(Gl.GL_MODELVIEW);
            Gl.glLoadIdentity();

            Glu.gluLookAt(0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);

            Gl.glPushAttrib(Gl.GL_LIGHTING_BIT);
            float[] material_ambient = new float[4] { 0.2f, 0.2f, 0.0f, 1.0f };
            float[] material_diffuse = new float[4] { 0.7f, 0.7f, 0.0f, 1.0f };
            float[] material_specular = new float[4] { 0.8f, 0.8f, 0.0f, 1.0f };
            Gl.glMaterialfv(Gl.GL_FRONT_AND_BACK, Gl.GL_AMBIENT, material_ambient);
            Gl.glMaterialfv(Gl.GL_FRONT_AND_BACK, Gl.GL_DIFFUSE, material_diffuse);
            Gl.glMaterialfv(Gl.GL_FRONT_AND_BACK, Gl.GL_SPECULAR, material_specular);
            Gl.glMaterialf(Gl.GL_FRONT_AND_BACK, Gl.GL_SHININESS, 35.0f);
            Gl.glRotated(rot, 0.0, 1.0, 0.0);
            Gl.glColor3ub(0, 255, 0);
            Glut.glutSolidTorus(0.15, 1.5, 40, 40);

            Gl.glPushMatrix();
            Gl.glColor3ub(255, 255, 0);
            Gl.glScaled(1.0, 1.0, 0.1);
            Glut.glutSolidSphere(1.35, 40, 40);
            Gl.glPopMatrix();
            Gl.glPopAttrib();
            Gl.glTranslated(0.0, 0.0, 0.15);
            if (rot < 90 && rot > -90)
            {
                Gl.glPushMatrix();
                Gl.glColor3ub(255, 0, 0);
                Gl.glTranslated(0.0, 1.15, 0.0);
                Gl.glScaled(0.1, 1.0, 0.01);
                Glut.glutSolidCube(0.3);
                Gl.glPopMatrix();

                Gl.glPushMatrix();
                Gl.glColor3ub(255, 0, 0);
                Gl.glTranslated(-1.15 * Math.Sin(30 * Math.PI / 180.0), 1.15 * Math.Cos(30 * Math.PI / 180.0), 0.0);
                Gl.glRotated(30.0, 0.0, 0.0, 1.0);
                Gl.glScaled(0.1, 1.0, 0.01);
                Glut.glutSolidCube(0.3);
                Gl.glPopMatrix();

                Gl.glPushMatrix();
                Gl.glColor3ub(255, 0, 0);
                Gl.glTranslated(-1.15 * Math.Sin(60 * Math.PI / 180.0), 1.15 * Math.Cos(60 * Math.PI / 180.0), 0.0);
                Gl.glRotated(60.0, 0.0, 0.0, 1.0);
                Gl.glScaled(0.1, 1.0, 0.01);
                Glut.glutSolidCube(0.3);
                Gl.glPopMatrix();

                Gl.glPushMatrix();
                Gl.glColor3ub(255, 0, 0);
                Gl.glTranslated(-1.15, 0.0, 0.0);
                Gl.glRotated(90.0, 0.0, 0.0, 1.0);
                Gl.glScaled(0.1, 1.0, 0.01);
                Glut.glutSolidCube(0.3);
                Gl.glPopMatrix();

                Gl.glPushMatrix();
                Gl.glColor3ub(255, 0, 0);
                Gl.glTranslated(-1.15 * Math.Sin(120 * Math.PI / 180.0), 1.15 * Math.Cos(120 * Math.PI / 180.0), 0.0);
                Gl.glRotated(120.0, 0.0, 0.0, 1.0);
                Gl.glScaled(0.1, 1.0, 0.01);
                Glut.glutSolidCube(0.3);
                Gl.glPopMatrix();

                Gl.glPushMatrix();
                Gl.glColor3ub(255, 0, 0);
                Gl.glTranslated(-1.15 * Math.Sin(150 * Math.PI / 180.0), 1.15 * Math.Cos(150 * Math.PI / 180.0), 0.0);
                Gl.glRotated(150.0, 0.0, 0.0, 1.0);
                Gl.glScaled(0.1, 1.0, 0.01);
                Glut.glutSolidCube(0.3);
                Gl.glPopMatrix();

                Gl.glPushMatrix();
                Gl.glColor3ub(255, 0, 0);
                Gl.glTranslated(0, -1.15, 0.0);
                Gl.glRotated(180.0, 0.0, 0.0, 1.0);
                Gl.glScaled(0.1, 1.0, 0.01);
                Glut.glutSolidCube(0.3);
                Gl.glPopMatrix();

                Gl.glPushMatrix();
                Gl.glColor3ub(255, 0, 0);
                Gl.glTranslated(-1.15 * Math.Sin(210 * Math.PI / 180.0), 1.15 * Math.Cos(210 * Math.PI / 180.0), 0.0);
                Gl.glRotated(210.0, 0.0, 0.0, 1.0);
                Gl.glScaled(0.1, 1.0, 0.01);
                Glut.glutSolidCube(0.3);
                Gl.glPopMatrix();

                Gl.glPushMatrix();
                Gl.glColor3ub(255, 0, 0);
                Gl.glTranslated(-1.15 * Math.Sin(240 * Math.PI / 180.0), 1.15 * Math.Cos(240 * Math.PI / 180.0), 0.0);
                Gl.glRotated(240.0, 0.0, 0.0, 1.0);
                Gl.glScaled(0.1, 1.0, 0.01);
                Glut.glutSolidCube(0.3);
                Gl.glPopMatrix();

                Gl.glPushMatrix();
                Gl.glColor3ub(255, 0, 0);
                Gl.glTranslated(-1.15 * Math.Sin(270 * Math.PI / 180.0), 1.15 * Math.Cos(270 * Math.PI / 180.0), 0.0);
                Gl.glRotated(270.0, 0.0, 0.0, 1.0);
                Gl.glScaled(0.1, 1.0, 0.01);
                Glut.glutSolidCube(0.3);
                Gl.glPopMatrix();

                Gl.glPushMatrix();
                Gl.glColor3ub(255, 0, 0);
                Gl.glTranslated(-1.15 * Math.Sin(300 * Math.PI / 180.0), 1.15 * Math.Cos(300 * Math.PI / 180.0), 0.0);
                Gl.glRotated(300.0, 0.0, 0.0, 1.0);
                Gl.glScaled(0.1, 1.0, 0.01);
                Glut.glutSolidCube(0.3);
                Gl.glPopMatrix();

                Gl.glPushMatrix();
                Gl.glColor3ub(255, 0, 0);
                Gl.glTranslated(-1.15 * Math.Sin(330 * Math.PI / 180.0), 1.15 * Math.Cos(330 * Math.PI / 180.0), 0.0);
                Gl.glRotated(330.0, 0.0, 0.0, 1.0);
                Gl.glScaled(0.1, 1.0, 0.01);
                Glut.glutSolidCube(0.3);
                Gl.glPopMatrix();

                Gl.glPushMatrix();
                Gl.glColor3ub(0, 0, 255);
                Gl.glRotated(-hour_rot, 0.0, 0.0, 1.0);
                Gl.glTranslated(0.0, 0.3, 0.0);

                Gl.glScaled(0.1, 1.0, 0.05);
                Glut.glutSolidCube(1.0);
                Gl.glPopMatrix();

                Gl.glPushMatrix();
                Gl.glColor3ub(0, 0, 255);
                Gl.glRotated(-minit_rot, 0.0, 0.0, 1.0);
                Gl.glTranslated(0.0, 0.45, 0.0);
                Gl.glScaled(0.1, 1.8, 0.05);
                Glut.glutSolidCube(0.8);
                Gl.glPopMatrix();

                Gl.glPushMatrix();
                Gl.glColor3ub(255, 0, 255);
                Gl.glRotated(-second_rot, 0.0, 0.0, 1.0);
                Gl.glTranslated(0.0, 0.5, 0.0);
                Gl.glScaled(0.05, 2.4, 0.05);
                Glut.glutSolidCube(0.6);
                Gl.glPopMatrix();

                Gl.glPushAttrib(Gl.GL_LIGHTING_BIT);
                if (light1_status == 0)
                {
                    float[] light_position = new float[4] { (float)(-1.45 * Math.Sin(60 * Math.PI / 180.0)), (float)(-1.45 * Math.Cos(60 * Math.PI / 180.0)), 0.1f, 1.0f };
                    float[] light_direction = new float[3] { 0.0f, 0.0f, 0.0f };
                    Gl.glEnable(Gl.GL_COLOR_MATERIAL);

                    Gl.glLightfv(Gl.GL_LIGHT1, Gl.GL_POSITION, light_position);
                    Gl.glLightfv(Gl.GL_LIGHT1, Gl.GL_SPOT_DIRECTION, light_direction);
                    //Gl.glLightf(Gl.GL_LIGHT1, Gl.GL_SPOT_CUTOFF, (float)(Math.Atan(2.0) * 180.0 / Math.PI));

                    Gl.glPushMatrix();
                    Gl.glColor3ub(255, 255, 255);
                    Gl.glTranslated(-1.45 * Math.Sin(60 * Math.PI / 180.0), -1.45 * Math.Cos(60 * Math.PI / 180.0), 0.1);

                    Gl.glDisable(Gl.GL_LIGHTING);
                    Glut.glutSolidSphere(0.15, 20, 20);
                    Gl.glEnable(Gl.GL_LIGHTING);

                    Gl.glPopMatrix();
                    Gl.glDisable(Gl.GL_COLOR_MATERIAL);

                }
                Gl.glPopAttrib();
            }
        }

        private void timer1_Tick(object sender, EventArgs e)
        {
            second_rot += 6.0;
            if (second_rot % 360 == 0)
            {
                minit_rot += 6.0;
                hour_rot += 0.5;

            }
            this.simpleOpenGlControl1.Refresh();
        }

        private void simpleOpenGlControl1_KeyDown(object sender, KeyEventArgs e)
        {
            switch (e.KeyCode)
            {
                case Keys .D0:
                    if (status == 0)
                    {
                        Gl.glDisable(Gl.GL_LIGHT0);
                        status = 1;
                    }
                    else
                    {
                        Gl.glEnable(Gl.GL_LIGHT0);
                        Gl.glDisable(Gl.GL_LIGHT1);
                        status = 0;
                    }
                    break;
                  case Keys.Left:
                    if (rot >= 270 )
                        rot = -90;
                    rot += 5;

                    break;
                case Keys.Right:
                    if (rot <= -270)
                        rot = 90;
                    rot -= 5;
                    break;
                case Keys .D1:
                    if (light1_status == 1)
                   {

                       Gl.glEnable(Gl.GL_LIGHT1);
                       light1_status = 0;
                   }
                else 
                  {
                      Gl.glDisable(Gl.GL_LIGHT1);
                     light1_status = 1;
                  }
                    break;
                case Keys.D2:
                    break;
                case Keys.D3:
                    break;
                case Keys.D4:
                    break;

            }
            this.simpleOpenGlControl1.Refresh();
        }

            }
}


呵呵，洗个澡，然后复习组合数学，下个礼拜又要进行第二次组合数学的期中考试，还有SE的阶段性考试，哎，又要累了。。。
xuyuanchen
关注
MATLAB算法实战应用案例精讲-【人工智能】机器视觉（概念篇）（最终篇）
qq_36130719的博客
04-26 2462
机器视觉逐渐渗入社会生活的方方面面，在人脸识别、图片识别、视频监控、3C应用等各领域几乎都能看到机器视觉的身影，对于工业领域而言，机器视觉的应用更是大大降低了高危作业的危险系数，保障了工业生产的安全性和高效性。
小时钟
xuyuanchen的博客
05-25 138
用opengl做了个小时钟，明天开始做进阶功能给它打光。 [code="C#"] using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; usin...
AI检测生物钟，精准医疗或成最大“受惠者”
脑极体
09-16 389
网络上有一份人尽皆知的人体排毒表，上面正儿八经地“规定”了人体各种脏器的工作时间，并且还说只要不睡觉它们就不工作。这份精确到小时的“民间科普”让很多人深信不疑，每当熬夜至...
机器视觉工业缺陷检测(光源，相机，镜头，算法)
datayx的文章
10-11 2万+
向AI转型的程序员都关注了这个号????????????机器学习AI算法工程 公众号：datayx一般机器视觉系统：相机、镜头、光源、运动系统。 视觉工业检测大体分为工件尺寸测量与定位，...
线阵相机、镜头及光源的选型
u013485792的专栏
11-04 9399
线阵相机顾名思义就是取像是成线性的。 它的传感器是成线型的。 举个例子： 比如面阵相机的分辨率是640*480就是说这个相机横向有640个像元，纵向有480个像元。 而线阵相机分辨率只体现在横向，比如2048像素的线阵相机就是说横向有2048个像元，纵向大多数为1。（RGB相机和TDI相机除外） 关于线阵相机的传感器 70年代大多数使用的是MOS，而从70年代末CCD开始迅速发展，一直到...
重启·新机遇-2023海外短视频直播行业TikTok社媒千人峰会顺利举办
hesixinchuang的博客
04-04 1922
众多行业精英、技术专家、海内外跨境电商创新生态伙伴聚集在天安云谷，分享出海新时代TikTok社媒营销的思考。 禾思新创Maxine Go 3月11日，琅琊领航联盟海外短视频直播行业TikTok社媒千人峰会在深圳天安云谷顺利举办。大会现场人山人海、交流声此起彼伏，十分热闹。 禾思新创Maxine Go 这次大会，是由琅琊领航联盟主办，由联盟成员商创科技、禾思新创、功喜跨境、风惠科技、E出海等首批成员共同承办，并由TK增长会、跨境指南、TK大咖社、钛动科技、Tikduddy、探电大咖会等联合发
AI智能棋盘开发Arduino Core快速原型验证
weixin_42451850的博客
11-08 864
本文介绍如何利用Arduino Core和ESP32在48小时内快速构建低成本AI智能棋盘原型。通过电阻阵列感应落子，WiFi/MQTT传输数据，结合本地与云端AI分析，实现对局识别、实时反馈与OTA升级，验证硬件创新的高效闭环。
五分钟商学院(基础---商业篇)
热门推荐
m0_57105290的博客
08-03 3万+
五分钟商学院的学习笔记
中戏学霸导演创立，2分钟上手，仅成立半年，这个AI视频平台为什么崛起？
07-17 925
在该平台里，用户不需在ChatGPT、Runway、剪映等不同类型的平台跳转，也无需开通各类平台的SaaS会员，其极简的风格能让人们短时间内学会搭建工作流进行AI视频制作。以某新兴电商平台为例，巴西卖家在平台推出新的营销功能时，短时间内大量运用该功能推广商品，通过观察商品的浏览量、订单量等数据，来判断该功能是否能有效提升销售业绩，进而验证市场对这种营销方式的需求。ComfyUI这种平台的“反人类”设计（指该产品过于程序员化，小白用户上手难度太高）、要抽象出导演闹钟的形式逻辑，最后用最简单的方式产品化。
【网络安全--- 面试题】网络安全常问150道面试题（可能有点小错误）
m0_67844671的博客
09-07 7058
本人精心整理的网络安全150到面试题，包括常见漏洞有关，内网渗透有关，工具的使用，应急响应等等（可能有一些小错误，欢迎大家指出来，一起交流）
【四旋翼飞行器】【模拟悬链机器人的动态】设计和控制由两个四旋翼飞行器推动的缆绳研究（Matlab代码实现）
11-26
【四旋翼飞行器】【模拟悬链机器人的动态】设计和控制由两个四旋翼飞行器推动的缆绳研究（Matlab代码实现）内容概要：本文围绕“设计和控制由两个四旋翼飞行器推动的缆绳系统”展开研究，通过建立动力学模型并利用Matlab进行仿真，模拟类似悬链机器人的动态行为。研究重点在于多无人机协同控制、缆绳张力分析及系统稳定性控制，结合非线性动力学与控制理论，实现对柔性连接负载的精确操控。文中提供了完整的Matlab代码实现，便于复现实验结果，适用于复杂空中作业任务的仿真验证。; 适合人群：具备一定控制理论基础和Matlab编程能力的研究生、科研人员及从事无人机协同控制、机器人系统开发的工程技术人员。; 使用场景及目标：①研究多无人机协同搬运与柔性负载控制；②掌握缆绳系统动力学建模与仿真方法；③应用于空中机器人、工业吊装、救援运输等实际场景的控制系统设计与优化； 阅读建议：建议结合Matlab代码逐模块分析，重点关注动力学建模、控制律设计与仿真结果验证部分，可进一步扩展至更多无人机协同或复杂环境干扰下的鲁棒性研究。
基于遗传算法的梯级水电站群联合火电厂优化调度研究（Python代码实现）
11-26
基于遗传算法的梯级水电站群联合火电厂优化调度研究（Python代码实现）内容概要：本文研究了基于遗传算法的梯级水电站群联合火电厂优化调度问题，旨在通过智能优化方法实现电力系统中水火电资源的协调调度，提升能源利用效率与调度经济性。文中构建了考虑水电站间水力联系、水库库容约束、机组出力特性及火电厂运行成本的综合优化模型，并采用遗传算法进行求解，给出了完整的Python代码实现。该方法能够有效处理复杂的非线性、多约束、多变量调度问题，具备良好的收敛性和实
无人机基于改进粒子群算法的无人机路径规划研究[和遗传算法、粒子群算法进行比较]（Matlab代码实现）
最新发布
11-26
【无人机】基于改进粒子群算法的无人机路径规划研究[和遗传算法、粒子群算法进行比较]（Matlab代码实现）内容概要：本文围绕基于改进粒子群算法的无人机路径规划展开研究，重点探讨了在复杂环境中利用改进粒子群算法（PSO）实现无人机三维路径规划的方法，并将其与遗传算法（GA）、标准粒子群算法等传统优化算法进行对比分析。研究内容涵盖路径规划的多目标优化、避障策略、航路点约束以及算法收敛性和寻优能力的评估，所有实验均通过Matlab代码实现，提供了完整的仿真验证流程。文章还提到了多种智能优化算法在无人机路径规划中的应用比较，突出了改进PSO在收敛速度和全局寻优方面的优势。; 适合人群：具备一定Matlab编程基础和优化算法知识的研究生、科研人员及从事无人机路径规划、智能优化算法研究的相关技术人员。; 使用场景及目标：①用于无人机在复杂地形或动态环境下的三维路径规划仿真研究；②比较不同智能优化算法（如PSO、GA、蚁群算法、RRT等）在路径规划中的性能差异；③为多目标优化问题提供算法选型和改进思路。; 阅读建议：建议读者结合文中提供的Matlab代码进行实践操作，重点关注算法的参数设置、适应度函数设计及路径约束处理方式，同时可参考文中提到的多种算法对比思路，拓展到其他智能优化算法的研究与改进中。
图像重建使用FDK的三维谢普洛根幻影重建（Matlab代码实现）
11-26
【图像重建】使用FDK的三维谢普洛根幻影重建（Matlab代码实现）内容概要：本文介绍了使用FDK算法在Matlab环境中实现三维谢普洛根幻影（Shepp-Logan phantom）图像重建的技术方法，重点展示了图像重建过程中的关键步骤与代码实现。该资源属于一系列图像处理与医学成像技术研究的一部分，涵盖了从投影数据生成到反投影重建的完整流程，帮助读者理解CT图像重建的基本原理与FDK算法的应用细节。; 适合人群：具备一定Matlab编程基础，从事医学图像处理、计算机断层成像（CT）或相关领域研究的研究生、科研人员及工程技术人员。; 使用场景及目标：①学习和掌握FDK算法在三维图像重建中的具体实现；②理解Shepp-Logan幻影模型在仿真成像中的作用；③为医学图像重建、算法验证与教学演示提供可运行的Matlab代码参考； 阅读建议：建议结合Matlab代码逐行调试，理解投影（正弦图）生成与滤波反投影的每一步操作，同时可延伸学习其他重建算法（如FBP
【大数据搜索技术】Elasticsearch7.8安装部署与集群管理：基于CentOS的分布式搜索引擎配置及性能优化实践
11-26
内容概要：本文详细介绍了Elasticsearch 7.8的安装部署及核心功能应用，涵盖环境准备、解压配置、启动优化、集群搭建、分片管理、健康监控等内容，并结合Kibana和Logstash构建完整的ELK日志分析体系。文章还讲解了中文分词器IK的使用、快照备份与恢复机制，以及如何通过Filebeat采集Nginx等服务的日志数据并进行可视化展示，系统性地呈现了Elasticsearch在实际生产环境中的部署与运维流程。; 适合人群：具备Linux基础和一定运维经验的技术人员，尤其是从事日志分析、搜索系统搭建或中间件维护的开发与运维工程师；适合初学者入门Elasticsearch及相关生态组件。; 使用场景及目标：①掌握Elasticsearch单节点与集群环境的安装与配置；②理解索引、分片、副本等核心概念并应用于实际业务；③构建基于Filebeat+Logstash+ES+Kibana的日志采集与分析链路；④实现数据的备份恢复与中文检索功能； 阅读建议：建议按照文档顺序逐步操作，重点关注配置参数调优与常见错误处理（如权限、虚拟内存限制），动手实践集群部署与日志采集流程，结合Kibana进行数据验证与可视化分析，加深对ELK生态协同工作的理解。
commonapi-dbus-demo
11-26
commonapi-dbus-demo
DeepSeek+7大场景+50大案例+全套提示词
11-26
DeepSeek+7大场景+50大案例+全套提示词
EtherNet/IP协议测试与实现源码库
11-26
标题中的"EthernetIP-master.zip"压缩文档涉及工业自动化领域的以太网通信协议EtherNet/IP。该协议由罗克韦尔自动化公司基于TCP/IP技术架构开发，已广泛应用于ControlLogix系列控制设备。该压缩包内可能封装了协议实现代码、技术文档或测试工具等核心组件。 根据描述信息判断，该资源主要用于验证EtherNet/IP通信功能，可能包含测试用例、参数配置模板及故障诊断方案。标签系统通过多种拼写形式强化了协议主题标识，其中"swimo6q"字段需结合具体应用场景才能准确定义其技术含义。 从文件结构分析，该压缩包采用主分支命名规范，符合开源项目管理的基本特征。解压后预期可获取以下技术资料： 1. 项目说明文档：阐述开发目标、环境配置要求及授权条款 2. 核心算法源码：采用工业级编程语言实现的通信协议栈 3. 参数配置文件：预设网络地址、通信端口等连接参数 4. 自动化测试套件：包含协议一致性验证和性能基准测试 5. 技术参考手册：详细说明API接口规范与集成方法 6. 应用示范程序：展示设备数据交换的标准流程 7. 工程构建脚本：支持跨平台编译和部署流程 8. 法律声明文件：明确知识产权归属及使用限制 该测试平台可用于构建协议仿真环境，验证工业控制器与现场设备间的数据交互可靠性。在正式部署前开展此类测试，能够有效识别系统兼容性问题，提升工程实施质量。建议用户在解压文件后优先查阅许可协议，严格遵循技术文档的操作指引，同时需具备EtherNet/IP协议栈的基础知识以深入理解通信机制。 资源来源于网络分享，仅用于学习交流使用，请勿用于商业，如有侵权请联系我删除！
嵌入式51单片机实时时钟 pcf8563完整代码
11-26
本项目提供了一套基于51单片机与pcf8563芯片实现的实时时钟（RTC）的完整代码。该代码能够实现日期、星期、闹钟的查看与调整，并具备整点报时功能。此外，它还支持电源拔插时间不重置（内置电池供电维持时间变化），确保时间在断电后依然准确。 功能特点 实现实时时钟，断电后时间由内置电池维持。 查看和调整日期、星期、闹钟。 支持整点报时功能。 闹钟可以设置为每天同一时间或特定星期几的特定时间。 代码支持查看秒表，但未实现（可通过外部中断或定时器T1实现）。 使用说明 初始化与设置： 首次使用时，需通过按键进入设置模式，调整当前时间、日期和闹钟。 时间查看： 在非设置模式下，可以通过相应的按键查看当前时间、日期和星期。 闹钟设置： 闹钟支持设置为每天同一时间或特定星期几的特定时间。 闹钟响起时，可以通过按键关闭。 整点报时： 每到整点，系统会自动报时，但若闹钟设置的时间与整点时间相同，则不会报时。 注意事项 代码中存在一处小瑕疵：当闹钟设置的时间正好是整点时，整点报时与闹钟不会同时触发。这个问题可以通过修改代码轻松解决。 由于显示和中断处理较为复杂，秒表功能未实现。 代码中包含部分注释，有助于理解各个功能模块的实现。
unity里给3d模型单独打光
09-15
在Unity中给3D模型单独打光，主要是指为单个或少数几个模型创建独立的光照效果，这可以通过几种不同的方法来实现。以下是一些基本方法： 1. 使用点光源、聚光灯或者方向光等不同类型的光源直接照射模型，通过调整...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值