INCA使用教程

原创 汽车ECU开发 2023-09-23 08:05
对于VCU或者是发动机标定工程师,INCA简直是跟亲人一样熟悉,基本上每天都要跟它打交道。
今天正好闲来有空,趁此机会,来分享一波INCA的基本使用操作。其基本的流程如下图所示。

下面来详细记录一下各个步骤。
首先从打开软件开始,映入眼前的页面如下图所示,如此熟悉的页面。

图1 INCA软件界面

1. 点击菜单栏左上角数据库—>新建,然后在对话框中输入数据库的名字,再点击OK,第一步就完成了。

2. 导入A2L标定文件以及s19文件。A2L包含了需要标定或者观测变量的数据结构、地址长度以及参数名称,s19文件包含了由数据和代码组成的ECU控制程序。

加载完成A2L和S19后,在界面右侧显示的是刚读取的s19文件,而左侧是A2L文件。

3.创建工作区以及实验。

4.在工作区中添加项目,选择刚刚加入的a2l文件,然后自动跳出一个添加设备的对话框,选择对应的型号。


5.在项目中添加dbc,主要用于解析数据,然后再点击配置硬件,进入配置界面,再右键插入,选择CAN-Monitor,选取刚刚添加的dbc。


6.以上,基本的工程已经准备好了,可以连接硬件,进行标定了。点击设备搜索,选择自己的设备,然后再点击初始化硬件。

7.开始标定,进入实验环境界面,然后添加自己所需标定或者观测的变量即可,再切换一下WP和RP,来实现修改标定值。

后台回复“ECU030”获取INCA操作文档

推荐阅读

国内主机整车EEA架构汇总

谈谈整车控制器对油门信号处理的理解

浅谈电机控制器及其功能

谈谈电池管理系统的功能

谈谈整车控制器的功能

谈谈整车OTA系统的理解

五千字说清汽车基础软件及国产现状

谈谈Bootloader自更新

电子电气架构设计需要考虑哪些方面?

汽车E/E架构的网络安全分析

自动驾驶域控制器信息梳理

分享不易,恳请点个【👍】和【在看】

汽车ECU开发 专注于汽车电子ECU软件开发,技术分享。
评论 (0)
  • 14、小电流贴片共模电感更换需要注意些什么.
    14、小电流贴片共模电感更换需要注意些什么.
  • 安科瑞 ASCB1系列智能微型断路器样本
    ASCB1 系列智能微型断路器是安科瑞电气股份有限公司全新推出的智慧用电产品,产品由智能微型断路器与智能网关两部分组成,可用于对用电线路的关键电气因素,如电压、电流、功率、温度、漏电、能耗等进行实时监测,具有远程操控、预警保护、短路保护、电能计量统计、故障定位等功能,应用于户内建筑物及类似场所的工业、商业、民用建筑及基础设施等领域低压终端配电网络。
  • 基于单片机的TFT-LCD液晶显示控制芯片选型表
    基于单片机的TFT-LCD液晶显示控制芯片选型表
  • 首个基于Transformer的分割检测+视觉大模型视频课程(23年新课+源码+课件)
    自动驾驶是高安全型应用,需要高性能和高可靠的深度学习模型,Vision Transformer是理想的选摔。现在主流的自动驾驶感知算法基本都使用了Vision Transformer相关技术,比如分割、2D/3D检测,以及最近大火的大模型 (如SAM),Vision Transformer在自动驾驶领域的落地方面遍地开花。5一方面,在自动驾驶或图像处理相关算法岗位的面试题中,Vision Transformer是必考题,需要对其理论知识有深入理解,并且在项目中真实的使用过相关技术。

    Transformer出自于Google于2017年发表的论文《Attention is all you need》,最开始是用于机器翻译,并且取得了非常好的效果。但是自提出以来,Transformer不仅仅在NLP领域大放异彩,并且在CV、RS等领域也取得了非常不错的表现。尤其是2020年,绝对称得上是Transformer的元年,比如在CV领域,基于Transformer的模型横扫各大榜单,完爆基于CNN的模型。为什么Transformer模型表现如此优异?它的原理是什么?它成功的关键又包含哪些?本文将简要地回答一下这些问题。

    我们知道Transformer模型最初是用于机器翻译的,机器翻译应用的输入是某种语言的一个句子,输出是另外一种语言的句子。
    var i *int = nil
    fmt.Println("i.size:", unsafe.Sizeof(i)) //8

    var i8 *int8 = nil
    fmt.Println("i8.size:", unsafe.Sizeof(i8)) //8

    var s *string = nil
    fmt.Println("s.size:", unsafe.Sizeof(s)) //8

    var ps *struct{} = nil
    fmt.Println("ps.size:", unsafe.Sizeof(ps)) //8

    var si []int = nil
    var si1 []int = nil
    fmt.Println("si.size:", unsafe.Sizeof(si)) //24

    var ii interface{} = nil
    fmt.Println("ii.size:", unsafe.Sizeof(ii)) //16
    我们以生成我,爱,机器,学习,翻译成<bos>,i,love,machine,learning,<eos>这个例子做生成过程来解释。
    训练:

    把“我/爱/机器/学习”embedding后输入到encoder里去,最后一层的encoder最终输出的outputs [10, 512](假设我们采用的embedding长度为512,而且batch size = 1),此outputs 乘以新的参数矩阵,可以作为decoder里每一层用到的K和V;
    将<bos>作为decoder的初始输入,将decoder的最大概率输出词向量A1和‘i’做cross entropy(交叉熵)计算error。
    将<bos>,“i” 作为decoder的输入,将decoder的最大概率输出词 A2 和‘love’做cross entropy计算error。
    将<bos>,“i”,“love” 作为decoder的输入,将decoder的最大概率输出词A3和’machine’ 做cross entropy计算error。
    将<bos>,“i”,"love ",“machine” 作为decoder的输入,将decoder最大概率输出词A4和‘learning’做cross entropy计算error。
    将<bos>,“i”,"love ",“machine”,“learning” 作为decoder的输入,将decoder最大概率输出词A5和终止符做cross entropy计算error。
    那么并行的时候是怎么做的呢,我们会有一个mask矩阵在这叫seq mask,因为他起到的作用是在decoder编码我们的target seq的时候对每一个词的生成遮盖它之后的词的信息。
    func main() {
    s := []string{"a", "b", "c"}
    fmt.Println("s:origin", s)
    changes1(s)
    fmt.Println("s:f1", s)

    changes2(s)
    fmt.Println("s:f2", s)

    changes3(s)
    fmt.Println("s:f3", s)
    }

    func changes1(s []string) {
    var tmp = []string{"x", "y", "z"}
    s = tmp
    }

    func changes2(s []string) {
    // item只是一个副本,不能改变s中元素的值
    for i, item := range s {
    item = "d"
    fmt.Printf("item=%s;s[%d]=%s", item, i, s[i])
    }
    }

    func changes3(s []string) {
    for i := range s {
    s[i] = "d"
    }
    }

    首先我们需要为每个输入向量(也就是词向量)创建3个向量,分别叫做Query、Key、Value。那么如何创建呢?我们可以对输入词向量分别乘上3个矩阵来得到Q、K、V向量,这3个矩阵的参数在训练的过程是可以训练的。注意Q、K、V向量的维度是一样的,但是它们的维度可以比输入词向量小一点,比如设置成64,其实这步也不是必要的,这样设置主要是为了与后面的Mulit-head注意力机制保持一致(当使用8头注意力时,单头所处理的词向量维度为512/8=64,此时Q、K、V向量与输入词向量就一致了)。我们假设输入序列为英文的"Thinking Machines"
    想要深度理解Attention机制,就需要了解一下它产生的背景、在哪类问题下产生,以及最初是为了解决什么问题而产生。

    首先回顾一下机器翻译领域的模型演进历史:

    机器翻译是从RNN开始跨入神经网络机器翻译时代的,几个比较重要的阶段分别是: Simple RNN, Contextualize RNN,Contextualized RNN with attention, Transformer(2017),下面来一一介绍。

    「Simple RNN」 :这个encoder-decoder模型结构中,encoder将整个源端序列(不论长度)压缩成一个向量(encoder output),源端信息和decoder之间唯一的联系只是: encoder output会作为decoder的initial states的输入。这样带来一个显而易见的问题就是,随着decoder长度的增加,encoder output的信息会衰减。
    func main(){
    var c = make(chan int)
    fmt.Printf("c.pointer=%p\n", c) //c.pointer=0xc000022180
    go func() {
    c <- 1
    addChannel(c)
    close(c)
    }()

    for item := range c {
    //item: 1
    //item: 2
    fmt.Println("item:", item)
    }
    }

    func addChannel(done chan int) {
    done <- 2
    fmt.Printf("done.pointer=%p\n", done) //done.pointer=0xc000022180
    }
    在测试模型的时候,Test:decoder没有label,采用自回归一个词一个词的输出,要翻译的中文正常从encoder并行输入(和训练的时候一样)得到每个单词的embedding,然后decoder第一次先输入bos再此表中的id,得到翻译的第一个单词,然后自回归,如此循环直到预测达到eos停止标记
    type visit struct {
    a1  unsafe.Pointer
    a2  unsafe.Pointer
    typ Type
    }

    func deepValueEqual(v1, v2 Value, visited map[visit]bool) bool {
    if !v1.IsValid() || !v2.IsValid() {
    return v1.IsValid() == v2.IsValid()
    }
    if v1.Type() != v2.Type() {
    return false
    }

    // We want to avoid putting more in the visited map than we need to.
    // For any possible reference cycle that might be encountered,
    // hard(v1, v2) needs to return true for at least one of the types in the cycle,
    // and it's safe and valid to get Value's internal pointer.
    hard := func(v1, v2 Value) bool {
    switch v1.Kind() {
    case Pointer:
    if v1.typ.ptrdata == 0 {
    // not-in-heap pointers can't be cyclic.
    // At least, all of our current uses of runtime/internal/sys.NotInHeap
    // have that property. The runtime ones aren't cyclic (and we don't use
    // DeepEqual on them anyway), and the cgo-generated ones are
    // all empty structs.
    return false
    }
    fallthrough
    case Map, Slice, Interface:
    // Nil pointers cannot be cyclic. Avoid putting them in the visited map.
    return !v1.IsNil() && !v2.IsNil()
    }
    return false
    }

    if hard(v1, v2) {
    // For a Pointer or Map value, we need to check flagIndir,
    // which we do by calling the pointer method.
    // For Slice or Interface, flagIndir is always set,
    // and using v.ptr suffices.
    ptrval := func(v Value) unsafe.Pointer {
    switch v.Kind() {
    case Pointer, Map:
    return v.pointer()
    default:
    return v.ptr
    }
    }
    addr1 := ptrval(v1)
    addr2 := ptrval(v2)
    if uintptr(addr1) > uintptr(addr2) {
    // Canonicalize order to reduce number of entries in visited.
    // Assumes non-moving garbage collector.
    addr1, addr2 = addr2, addr1
    }

    // Short circuit if references are already seen.
    typ := v1.Type()
    v := visit{addr1, addr2, typ}
    if visited[v] {
    return true
    }

    // Remember for later.
    visited[v] = true
    }

    switch v1.Kind() {
    case Array:
    for i := 0; i < v1.Len(); i++ {
    if !deepValueEqual(v1.Index(i), v2.Index(i), visited) {
    return false
    }
    }
    return true
    case Slice:
    if v1.IsNil() != v2.IsNil() {
    return false
    }
    if v1.Len() != v2.Len() {
    return false
    }
    if v1.UnsafePointer() == v2.UnsafePointer() {
    return true
    }
    // Special case for []byte, which is common.
    if v1.Type().Elem().Kind() == Uint8 {
    return bytealg.Equal(v1.Bytes(), v2.Bytes())
    }
    for i := 0; i < v1.Len(); i++ {
    if !deepValueEqual(v1.Index(i), v2.Index(i), visited) {
    return false
    }
    }
    return true
    case Interface:
    if v1.IsNil() || v2.IsNil() {
    return v1.IsNil() == v2.IsNil()
    }
    return deepValueEqual(v1.Elem(), v2.Elem(), visited)
    case Pointer:
    if v1.UnsafePointer() == v2.UnsafePointer() {
    return true
    }
    return deepValueEqual(v1.Elem(), v2.Elem(), visited)
    case Struct:
    for i, n := 0, v1.NumField(); i < n; i++ {
    if !deepValueEqual(v1.Field(i), v2.Field(i), visited) {
    return false
    }
    }
    return true
    case Map:
    if v1.IsNil() != v2.IsNil() {
    return false
    }
    if v1.Len() != v2.Len() {
    return false
    }
    if v1.UnsafePointer() == v2.UnsafePointer() {
    return true
    }
    for _, k := range v1.MapKeys() {
    val1 := v1.MapIndex(k)
    val2 := v2.MapIndex(k)
    if !val1.IsValid() || !val2.IsValid() || !deepValueEqual(val1, val2, visited) {
    return false
    }
    }
    return true
    case Func:
    if v1.IsNil() && v2.IsNil() {
    return true
    }
    // Can't do better than this:
    return false
    case Int, Int8, Int16, Int32, Int64:
    return v1.Int() == v2.Int()
    case Uint, Uint8, Uint16, Uint32, Uint64, Uintptr:
    return v1.Uint() == v2.Uint()
    case String:
    return v1.String() == v2.String()
    case Bool:
    return v1.Bool() == v2.Bool()
    case Float32, Float64:
    return v1.Float() == v2.Float()
    case Complex64, Complex128:
    return v1.Complex() == v2.Complex()
    default:
    // Normal equality suffices
    return valueInterface(v1, false) == valueInterface(v2, false)
    }
    }
    这便是encoder的整体计算流程图了,Transformer模型中堆叠了多个这样的encoder,无非就是输出连接输入罢了,常规操作。
    最后再附上一个Transformer的代码实现,读者有兴趣可以跟着自己复现一下Transformer模型的代码。
       package main

       import (
           "log"
           "sync"
       )

       func init() {
           log.SetFlags(log.Lshortfile)
       }
       func main() {
           lock := sync.Mutex{}

           //Go 1.18 新增,是一种非阻塞模式的取锁操作。当调用 TryLock() 时,
           //该函数仅简单地返回 true 或者 false,代表是否加锁成功
           //在某些情况下,如果我们希望在获取锁失败时,并不想停止执行,
           //而是可以进入其他的逻辑就可以使用TryLock()
           log.Println("TryLock:", lock.TryLock())
           //已经通过TryLock()加锁,不能再次加锁
           lock.Lock()

       }

  • ECG前置电路设计
    TI出的一个经验文档,讲的很不错
  • 特斯拉电路图.rar
    特斯拉电路图,欢迎大家下载
  • [完结19章]SpringBoot开发双11商品服务系统
    今天给大家分享一下关于SpringBoot开发双11商品服务系统的整个流程,我将深度还原大厂实习期技术成长全流程,让你收获大厂项目开发全流程与实战经验,具备应对大流量场景问题的解决能力,全面助力提升实习/转正/跳槽表现力与成功率。


    Spring Boot是由Pivotal团队提供的全新框架,其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置,从而使开发人员不再需要定义样板化的配置。通过这种方式,Spring Boot致力于在蓬勃发展的快速应用开发领域(rapid application development)成为领导者。

    目的
    让大家更容易使用 spring,更容易集成各种常用的中间件、开源软件。
    SpringBoot 基于 Spring 开发, SpringBoot 本身并不提供 Spring 框架的核心特性以及扩展功能,只是用于快速、敏捷地开发新一代基于 Spring 框架的应用程序。
    SpringBoot 不是用来替代 spring 的解决方案,而是和 spring 框架紧密结合提升 spring 开发者体验的工具。

    准备测试数据
    我们先导入准备好的测试数据,这个测试数据是一份商品数据。

    字段包含商品id,name(商品名)
    last_month_sales(最近一个月的销量)
    favorites(收藏数)这几个字段,我们主要是通过商品名来搜索。
    首先我先先创建一个商品索引
    PUT goods
    {
      "settings": {
        "number_of_shards": 1,
        "number_of_replicas": 0
      },
      "mappings": {
        "properties": {
          "id": {
            "type": "keyword",
            "doc_values": false,
            "norms": false,
            "similarity": "boolean"
          },
          "name": {
            "type": "text"
          },
            "price": {
            "type": "double"
          },
          "last_month_sales": {
            "type": "long"
          },
          "favorites": {
            "type": "long"
          },
          "year":{
            "type": "short"
          }
        }
      }
    }
    千里之行,始于足下。想要舒舒服服地使用Spring框架,就要把它的开发环境配置好,这对它好,也对我好。

    1. jdk 的配置       
    使用 IDEA 进行开发,在 IDEA 中配置 jdk 的方式很简单,打开 File->Project Structure选择 SDKs。
    在 JDK home path 中选择本地 jdk 的安装目录。
    在 Name 中为 jdk 自定义名字通过以上三步骤,即可导入本地安装的 jdk。如果是使用 STS 或者 eclipse 可以通过两步骤添加:
    window->preference->java->Instralled JRES 来添加本地 jdk。
    window-->preference-->java-->Compiler 选择 jre,和 jdk 保持一致。
    PUT test_index/_doc/1
    {
      "string_field":"imooc",
      "int_field": 100,
      "float_field":3.14,
      "bool_field":true,
      "date_field":"2022/03/16",
      "obj_field":{"key1":"value1","key2":100},
      "array_field1":[100,3.14],
      "array_field2":[100,"200"],
      "array_field3":["2022/03/16","100"],
      "array_field4":["100","2022/03/16"],
      "null_field":null
      }
      创建 Spring Boot 项目后需要进行 maven 配置。打开 File->settings,搜索 maven,配置一下本地的 maven 信息。在 Maven home directory 中选择本地 Maven 的安装路径;在 User settings file 中选择本地 Maven 的配置文件所在路径。在配置文件中配置一下国内阿里的镜像,这样在下载 maven 依赖时,速度会变得很快。
    {
      "test_index" : {
        "mappings" : {
          "properties" : {
            "array_field" : {
              "type" : "text",
              "fields" : {
                "keyword" : {
                  "type" : "keyword",
                  "ignore_above" : 256
                }
              }
            },
            "bool_field" : {
              "type" : "boolean"
            },
            "date_field" : {
              "type" : "date",
              "format" : "yyyy/MM/dd HH:mm:ss||yyyy/MM/dd||epoch_millis"
            },
            "float_field" : {
              "type" : "float"
            },
            "int_field" : {
              "type" : "long"
            },
            "obj_field" : {
              "properties" : {
                "key1" : {
                  "type" : "text",
                  "fields" : {
                    "keyword" : {
                      "type" : "keyword",
                      "ignore_above" : 256
                    }
                  }
                },
                "key2" : {
                  "type" : "long"
                }
              }
            },
            "string_field" : {
              "type" : "text",
              "fields" : {
                "keyword" : {
                  "type" : "keyword",
                  "ignore_above" : 256
                }
              }
            }
          }
        }
      }
    }

    从以上结果中,我们可以看到 Spring Boot 通过MVN方式自动为项目配置了对应的 springframework、logging、jackson 以及 Tomcat 等依赖,而这些正是我们在开发 Web 项目时所需要的。

    那么细心的同学可能会发现一个问题,即在以上 pom.xml 的配置中,引入依赖 spring-boot-starter-web 时,并没有指明其版本(version),但在依赖列表中,我们却看到所有的依赖都具有版本信息,那么这些版本信息是在哪里控制的呢? 
    {
      "_index" : "test_index",
      "_id" : "1",
      "_version" : 1,
      "_seq_no" : 0,
      "_primary_term" : 1,
      "found" : true,
      "_source" : {
        "string_field" : "Chan",
        "int_field" : 100,
        "int_string_field" : "100",
        "float_field" : 3.14,
        "bool_field" : true,
        "date_field" : "2022/03/16",
        "obj_field" : {
          "key1" : "value1",
          "key2" : 100
        },
        "array_field" : [
          "value1",
          "100"
        ],
        "null_field" : null
      }
    }
    spring-boot-starter-parent 是所有 Spring Boot 项目的父级依赖,它被称为 Spring Boot 的版本管理中心,可以对项目内的部分常用依赖进行统一管理。

    <parent>    

            <groupId>org.springframework.boot</groupId>    

            <artifactId>spring-boot-starter-parent</artifactId>    

            <version>2.5.6</version>    

            <relativePath/> 

    </parent>

    Spring Boot 项目可以通过继承 spring-boot-starter-parent 来获得一些缺省的配置内容,它主要提供了以下特性:

    默认 JDK 版本(Java 8)

    默认字符集(UTF-8)

    依赖管理功能

    资源过滤

    默认插件配置识别 

    application.properties 或 application.yml 类型的配置文件
    DELETE test_index

    PUT test_index
    {
      "mappings": {
        "dynamic":false 
      }
    }
    GET test_index/_search
    {
      "query": {
       "term": {
         "field1.field2": {
           "value": "imooc ES"
         }
       }
      }
    }

    GET test_index/_doc/4

    DELETE test_index

    PUT test_index
    {
      "mappings": {
        "dynamic":"strict" 
      }
    }


    POST test_index/_doc/2
    {
      "field1":{
       "field2":"imooc ES" 
      }
    }

    GET test_index/_search
    {
      "query": {
       "term": {
         "field1.field2": {
           "value": "imooc ES"
         }
       }
      }
    }

    GET test_index/_doc/4

    以下就是本文的全部内容,感谢大家观看
  • XPM52C规格书 65W USB PD 多协议降压芯片
    XPM52C 是一款集成同步开关的降压转换器,支持多种输出快充协议、支持 USB Type-C 和 PD 等多种快充协议,包括 USB Type-C 和 PD 协议,高通 QC2.0/3.0/3.0+,华 为 FCP/SCP/HVSCP,VOOC 2.0/4.0 协议,联发科 PE,三星 AFC,USB BC1.2 DCP 以及 Apple 2.4A 充电规范,为车载充电器、各种快充适配器、智能排插等供电设备提供完 整的解决方案。
  • Wayking RadarSensors_LRR7710_中英文产品手册
    Wayking RadarSensors_LRR7710_中英文产品手册
  • [完结19章]SpringBoot开发双11商品服务系统教程下载
    如何使用SpringBoot开发一款关于双11商品服务的系统?今天就给大家说道说道,希望对大家的学习有所帮助!
    1.什么是SpringBoot?
    Spring 的诞⽣是为了简化 Java 程序的开发的,⽽ Spring Boot 的诞⽣是为了简化 Spring 程序开发的。
    Spring Boot是由Pivotal团队提供的基于Spring的框架,该框架使用了特定的方式来进行配置,从而使开发人员不再需要定义样板化的配置。Spring Boot集成了绝大部分目前流行的开发框架,就像Maven集成了所有的JAR包一样,Spring Boot集成了几乎所有的框架,使得开发者能快速搭建Spring项目。
    2.SpringBoot的优点
    快速集成框架,Spring Boot 提供了启动添加依赖的功能,⽤于秒级集成各种框架。
    内置运⾏容器,⽆需配置 Tomcat 等 Web 容器,直接运⾏和部署程序。
    快速部署项⽬,⽆需外部容器即可启动并运⾏项⽬。
    可以完全抛弃繁琐的 XML,使⽤注解和配置的⽅式进⾏开发。
    ⽀持更多的监控的指标,可以更好的了解项⽬的运⾏情况

    后端配置
    1.1创建Springboot工程
    打开idea->file->new->project
    选择spring Initializer进行配置,java版本选择8,点击next
    - internal 应用代码
        - controllers 控制器模块
          - admin 后端控制器
          - front 前端控制器
        - listen redis监听器
        - models 模型模块
        - service 服务模块
          - product_serive 商品服务
          - wechat_menu_serive 微信公众号菜单服务
          ......
    - conf 公共配置
      -config.yml yml配置文件
      -config.go 配置解析,转化成对应的结构体
      
    - middleware 中间件
        - AuthCheck.go  jwt接口权限校验
    - cors.go 跨域处理
    ......
    - pkg 程序应用包
      - app
      - base
      - casbin
      - jwt
      - qrcode
      - wechat
      .....
    - routere 路由
    - logs 日志存放
    - runtime 资源目录
    首先,我仔细分析了需求,并且根据业务逻辑设计了合适的接口。
    对于多表关联查询,我使用了MyBatis的注解来编写SQL语句,并通过@One和@Many等注解来实现结果集的映射。
    对于数据分页,我使用了MyBatis-Plus提供的Page对象,并结合相关方法来实现数据分页查询。
    2. 上课中的优秀项目
    在课堂上,我完成了一个优秀的项目,主要是学生实体类的增删改查功能。通过这个项目,我巩固了对Spring Boot框架的理解和掌握。
    具体实现如下:
    //初始化redis
    err := cache.InitRedis(cache.DefaultRedisClient, &redis.Options{
    Addr:        global.CONFIG.Redis.Host,
    Password:    global.CONFIG.Redis.Password,
    IdleTimeout: global.CONFIG.Redis.IdleTimeout,
    }, nil)
    if err != nil {
    if err != nil {
    global.LOG.Error("InitRedis error ", err, "client", cache.DefaultRedisClient)
    panic(err)
    }
    panic(err)
    }

    //初始化mysql
    err = db.InitMysqlClient(db.DefaultClient, global.CONFIG.Database.User,
    global.CONFIG.Database.Password, global.CONFIG.Database.Host,
    global.CONFIG.Database.Name)
    if err != nil {
    global.LOG.Error("InitMysqlClient error ", err, "client", db.DefaultClient)
    panic(err)
    }
    global.Db = db.GetMysqlClient(db.DefaultClient).DB

    开发步骤
    SpringBoot 开发起来特别简单,分为如下几步:
    创建新模块,选择Spring初始化,并配置模块相关基础信息
    选择当前模块需要使用的技术集
    开发控制器类
    运行自动生成的Application类
    知道了 SpringBoot 的开发步骤后,接下来我们进行具体的操作
    shutdown.NewHook().Close(
    //关闭http server
    func() {
    ctx, cancel := context.WithTimeout(context.Background(), time.Second*10)
    defer cancel()
    if err := server.Shutdown(ctx); err != nil {
    logging.Error("http server shutdown err", err)
    }
    },

    func() {
    //关闭kafka producer(特别是异步生产者,强制关闭会导致丢消息)
    if err := mq.GetKafkaSyncProducer(mq.DefaultKafkaSyncProducer).Close(); err != nil {
    logging.Error("kafka shutdown err", err)
    }
    },
    func() {
    //关闭mysql
    if err := db.CloseMysqlClient(db.DefaultClient); err != nil {
    logging.Error("mysql shutdown err", err)
    }
    },
    func() {
    //关闭redis
    if err := cache.GetRedisClient(cache.DefaultRedisClient).Close(); err != nil {
    logging.Error("redis shutdown err", err)
    }
    },
    )
    //也可以自己实现优雅关闭
    //signals := make(chan os.Signal, 0)
    //signal.Notify(signals, syscall.SIGHUP, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT)
    //s := <-signals
    //global.LOG.Warn("shop receive system signal:", s)
    //ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
    //defer cancel()
    //err := server.Shutdown(ctx)
    //if err != nil {
    // global.LOG.Error("http server error", err)
    //}
    //mq.GetKafkaSyncProducer(mq.DefaultKafkaSyncProducer).Close()

    选择 Spring Initializr ,用来创建 SpringBoot 工程
    以前我们选择的是 Maven ,今天选择 Spring Initializr 来快速构建 SpringBoot 工程。而在 Module SDK 这一项选择我们安装的 JDK 版本。
    type StoreProduct struct {
    Image        string         `json:"image" valid:"Required;"`
    SliderImage  string         `json:"slider_image" valid:"Required;"`
    StoreName    string         `json:"store_name" valid:"Required;"`
    StoreInfo    string         `json:"store_info" valid:"Required;"`
    Keyword      string         `json:"keyword" valid:"Required;"`
    CateId       int            `json:"cate_id" valid:"Required;"`
    ProductCate  *StoreCategory `json:"product_cate" gorm:"foreignKey:CateId;association_autoupdate:false;association_autocreate:false"`
    Price        float64        `json:"price" valid:"Required;"`
    VipPrice     float64        `json:"vip_price" valid:"Required;"`
    OtPrice      float64        `json:"ot_price" valid:"Required;"`
    Postage      float64        `json:"postage" valid:"Required;"`
    UnitName     string         `json:"unit_name" valid:"Required;"`
    Sort         int16          `json:"sort" valid:"Required;"`
    Sales        int            `json:"sales" valid:"Required;"`
    Stock        int            `json:"stock" valid:"Required;"`
    IsShow       *int8          `json:"is_show" valid:"Required;"`
    IsHot        *int8          `json:"is_hot" valid:"Required;"`
    IsBenefit    *int8          `json:"is_benefit" valid:"Required;"`
    IsBest       *int8          `json:"is_best" valid:"Required;"`
    IsNew        *int8          `json:"is_new" valid:"Required;"`
    Description  string         `json:"description" valid:"Required;"`
    IsPostage    *int8          `json:"is_postage" valid:"Required;"`
    GiveIntegral int            `json:"give_integral" valid:"Required;"`
    Cost         float64        `json:"cost" valid:"Required;"`
    IsGood       *int8          `json:"is_good" valid:"Required;"`
    Ficti        int            `json:"ficti" valid:"Required;"`
    Browse       int            `json:"browse" valid:"Required;"`
    IsSub        *int8          `json:"is_sub" valid:"Required;"`
    TempId       int64          `json:"temp_id" valid:"Required;"`
    SpecType     int8           `json:"spec_type" valid:"Required;"`
    IsIntegral   *int8          `json:"isIntegral" valid:"Required;"`
    Integral     int32          `json:"integral" valid:"Required;"`
    BaseModel
    }

    //定义商品消息结构
    type ProductMsg struct {
    Operation string `json:"operation"`
    *StoreProduct
    }
    切换web服务器
    现在我们启动工程使用的是 tomcat 服务器,那能不能不使用 tomcat 而使用 jetty 服务器,jetty 在我们 maven 高级时讲 maven 私服使用的服务器。而要切换 web 服务器就需要将默认的 tomcat 服务器给排除掉,怎么排除呢?使用 exclusion 标签
    func (e *StoreProductController) Post(c *gin.Context) {
    var (
    dto  dto2.StoreProduct
    appG = app.Gin{C: c}
    )
    httpCode, errCode := app.BindAndValid(c, &dto)
    if errCode != constant.SUCCESS {
    appG.Response(httpCode, errCode, nil)
    return
    }
    productService := product_service.Product{
    Dto: dto,
    }
    model, err := productService.AddOrSaveProduct()
    if err != nil {
    appG.Response(http.StatusInternalServerError, constant.FAIL_ADD_DATA, nil)
    return
    }

    //发消息队列
    defer func() {
    operation := product.OperationCreate
    if dto.Id > 0 {
    operation = product.OperationUpdate
    }
    productMsg := models.ProductMsg{
    operation,
    &model,
    }
    msg, _ := json.Marshal(productMsg)
    p, o, e := mq.GetKafkaSyncProducer(mq.DefaultKafkaSyncProducer).Send(&sarama.ProducerMessage{
    Topic: product.Topic,
    Key:   mq.KafkaMsgValueStrEncoder(strconv.FormatInt(dto.Id, 10)),
    Value: mq.KafkaMsgValueEncoder(msg),
    },
    )
    if e != nil {
    global.LOG.Error("send product msg error ", e, "partition :", p, "offset :", o, "id :", dto.Id)
    }
    }()

    appG.Response(http.StatusOK, constant.SUCCESS, nil)

    }


  • 托马斯微积分第十版中文
    电子书为扫描版本,自己手动添加书签作为目录供参考
  • 近日,英国伦敦的可持续倡议(SMI)公布了2023年《地球宪章》徽章获奖名单。在这个名单中,全球共17家企业入选,中国企业仅占两席。最值得注目的是,海尔智家作为唯一获奖的中国家电企业,荣登榜单。 据了解,《地球宪章》徽章由现任英国国王查尔斯三世于2021年发起,旨在表彰对全球环境的可持续发展做出突出贡献的企业,鼓励企业将自然、人类和地球置于核心位置,通过创新和可持续的商业模式,共同应对全球气候挑战。获奖企业由来自环境、商业、政治和慈善界的全球专家小组经过严苛的评选选出。 海尔
    锦缎研究院 2023-12-06 12:41 53浏览
  •     今天看到一个麦肯锡的统计数据,2021年中国出口的电子产品占世界34%。越来越多的PCB组件在中国造出来,然后送往全世界。作为电子工程师,除了增加修养,不断实现良好的设计,也要减少电子垃圾,对国际上的主要环保要求有所了解。    ROHS  Restriction of Hazardous Substances  有毒物质限制        这个标准针对 6 类电子产品中常见的的有毒物质,
    电子知识打边炉 2023-12-06 22:21 107浏览
  • 来源:虹科汽车电子 虹科技术丨BabyLIN产品如何轻松搞定K线协议实现? 原文链接:https://mp.weixin.qq.com/s/LR7VHFQajjyw6s6bVDJmsg 欢迎关注虹科,为您提供最新资讯!   导读 为了实现K线通信,SDF-V3在协议部分中定义了新的协议类型KLine Raw。所有能够运行SDF-V3文件(LinWorks版本在V.2.29.4以上)并使用最新固件(固件版本在V.6.18以上)的BabyLIN设备都可以执行KLine Raw
    虹科电子科技 2023-12-06 14:42 106浏览
  • 光耦合器是一种在现代科技中发挥关键作用的设备,其应用领域横跨通信、医疗、工业等多个行业。光耦合器通过巧妙地将光电子器件结合起来,实现了光与电的高效转换和传输,为光电子领域的发展提供了强大的支持。光耦合器是什么光耦合器是一种用于隔离、耦合和传输光信号的器件。其主要功能是将一个光学系统的光信号转换成电信号,或者将电信号转换为光信号,以实现光与电之间的高效转换。在各类光电子设备中,光耦合器起到了桥梁的作用,实现了不同部分之间的无缝衔接。光耦合器的原理及结构光耦合器的基本原理是通过光电二极管和光电晶体管
    克里雅半导体科技 2023-12-06 10:58 31浏览
  • 国产光耦是近年来中国电子产业中备受关注的领域之一。在全球电子市场的竞争中,中国光电行业正逐渐崭露头角。本文将详细分析国产光耦的发展趋势,探讨其未来发展的关键因素与前景。国产光耦的现状国产光耦是一种用于电气隔离和信号传输的关键电子元器件,广泛应用于通信、工控、医疗、消费电子等领域。随着中国电子制造业的不断壮大,国产光耦在市场上逐渐崭露头角。目前,国产光耦已经实现了从技术到市场的多方面突破,主要体现在以下几个方面:1. 技术创新国产光耦制造商不断投入研发,推动光耦技术的创新与升级。新材料的应用、封装
    克里雅半导体科技 2023-12-06 10:56 36浏览
  • 近日,在传感器专家网的压力传感器专业交流群组中,有相关专家交流了目前我国压力传感器的一些情况。交流中指出,目前国内已有一些企业在做MEMS压力传感器芯片,在该领域国内相关企业总体来说技术差不多,精度等关键技术指标彼此间相差不大,但与国外压力传感器芯片巨头相比,精度等指标却有较大差距。传感器专家网https://www.sensorexpert.com.cn专注于传感器技术领域,致力于对全球前沿市场动态、技术趋势与产品选型进行专业垂直的服务,是国内领先的传感器产品查询与媒体信息服务平台。基于传感器
    传感器专家网 2023-12-06 11:03 52浏览
  • ​无论当下看不看机会,把握行情肯定是没错。 通过岗位数量,岗位要求(如对学历,技术点的要求)来了解行情是有效途径之一。 可以找我了解更多全国岗位。 【嵌入式软件工程师】 上海,风电行业国资企业,对学历有要求。 岗位职责: 1. 负责产品全周期研发,包括市场调研、客户需求技术转化、产品设计、产品制造、产品安装调试、产品测试验证和产品认证; 2. 负责产品失效根因分析,提供有效解决方案; 3. 负责组织供应商选择和产品质量管控; 4. 组织编制产品开发技
    落子无悔 2023-12-06 13:27 61浏览
  • 摘要:根据CINNO Research产业统计数据,Q3'23国内智能手机屏下指纹识别占比创历史新高达45%,而侧边指纹识别占比较去年同期下降12%,后置指纹识别占比下降至1%,而前置指纹已淡出国内智能手机指纹识别市场。根据CINNO Research产业统计数据,受华为、荣耀热门机型销售的影响,Q3'23国内智能手机指纹识别搭载率上升至84%。图示:中国市场智能手机指纹识别技术别占比趋势来源: CINNO Research月度中国市场智能手机指纹识别应用趋势报告2023年第三季度,国内OLED
    CINNOResearch 2023-12-06 12:53 91浏览
  • 背景   随着汽车行业的不断迭代发展,市场及消费者对汽车提出了更高的要求,智能网联、自动驾驶等新技术的应用推动整车厂对车载芯片、汽车软件等方面投入了更多的精力,SOA(面向服务的架构)逐渐成为大多整车厂顺应市场趋势和技术趋势的首选。SOA架构使服务间的通讯变得更加简单,ECU更新、软件升级等变得更加灵活,使系统的健壮性和拓展性获得了大幅提高。但是在SOA架构开发阶段,由于市面上的IDL(接口描述语言)众多,例如FIDL、Protobuf、vCDL、ARXML、OMG IDL、CAN
    北汇信息 2023-12-06 11:41 73浏览
  • #这段代码是一个基于C语言的嵌入式程序,用于在HPMicro平台上运行。它的主要功能是初始化一个LED灯,并使其以一定的时间间隔闪烁。#以下是对代码的解析:#```c#include #include "board.h"#include "hpm_debug_console.h"#define LED_FLASH_PERIOD_IN_MS 300int main(void){    int u;    board_init(); // 初始化板子 
    丙丁先生 2023-12-06 14:22 105浏览
  • 导语:CINNO Research统计数据表明,Q3'23全球半导体设备厂商市场规模前十大公司合计超250亿美元,同比下降9%,环比增长3%。CINNO Research统计数据表明,Q3'23全球半导体设备厂商市场规模Top10营收合计超250亿美元,同比下降9%,环比增长3%。Q3'23全球半导体设备厂商市场规模排名Top10与1H'23的Top10设备商相比,日立高新(Hitachi High-Tech)排名跌出Top10,泰瑞达(Teradyne)排名回归第十。荷兰公司阿斯麦(ASML)
    CINNOResearch 2023-12-06 14:04 105浏览
我要评论
0
0
点击右上角,分享到朋友圈 我知道啦
请使用浏览器分享功能 我知道啦