一个小的430的微小系统

最新推荐文章于 2024-10-08 12:50:54 发布
最新推荐文章于 2024-10-08 12:50:54 发布
阅读量719 收藏
点赞数
分类专栏： C语言 
/*
	@file
	@brief
	@author
	@date
*/
  
/*************************************************************************************/   
/** Author:linger                                                                   **/   
/** Email:ling_re@sina.com                                                          **/   
/** This file is part of the 'RTX-430' Real-Time Operating System Source Package    **/   
/*************************************************************************************/   
/**                                                                                 **/   
/** 千万注意：                                                                      **/   
/**              在中断程序开始处一定要调用 " RTX_TS|=RTX_TS_DELAY; " 这一语句      **/   
/**                                                                                 **/   
/*************************************************************************************/   
   
#include  <msp430x14x.h>   
   
#define  TIMESHARING        5        /* 每个任务的最大运行时间       */   
#define  RTX_STACKFREE      40       /* 当前任务的最小堆栈空间       */   
#define  RTX_MAXTASKN       10       /* 最大任务数                   */   
#define  INT_CLOCK          10000    /* 每个定时中断的时钟数         */   
#define  RAMBOTTOM          0x300    /* 最大 RAM 数                  */   
#define  RAMTOP             0x9FF    /* 最大 RAM 数                  */   
   
#define  RTX_TIMESHARING    (0 - TIMESHARING)   
#define  RTX_CLOCK          INT_CLOCK   
#define  RTX_RAMBOTTOM      RAMBOTTOM/2*2                  
#define  RTX_RAMTOP         RAMTOP/2*2                 
   
#define  K_SIG              1   
#define  K_TMO              2   
#define  SIG_EVENT          4   
#define  TMO_EVENT          8   
#define  K_READY            16   
#define  K_ACTIVE           32   
#define  K_ROBIN            64   
#define  K_IVL              128   
   
#define  B_WAITSIG          0   
#define  B_WAITTIM          1   
#define  B_SIGNAL           2   
#define  B_TIMEOUT          3   
#define  B_READY            4   
#define  B_ACTIVE           5   
#define  B_ROBIN            6   
#define  B_INTERVAL         7   
   
#define  RTX_TS_REQ         1   
#define  RTX_TS_DELAY       2         /* 进入中断处理程序后，要将 RTX_TS 中的该位置为 1 */   
   
unsigned int    STKP[RTX_MAXTASKN];   /* 指向前一任务堆栈的尾地址 */   
unsigned char   RTX_RobinTime;        /* 每个任务最长的运行周期 */   
unsigned char   TASK_Current;         /* 当前运行的任务号 */   
unsigned char   RTX_TS;   
unsigned int    RTX_SP;   
   
unsigned int    SAVE_SR;   
unsigned int    SAVE_PC;   
   
struct   
{   
   char  time;   
   char  st;   
}   
STATE[RTX_MAXTASKN];   
   
void timer0_comm(void);   
void clear_watchdog(void);   
void os_system_init(void);   
unsigned char task_switch(void);   
unsigned char os_system_start(void);   
unsigned char os_delete_task(unsigned char task_no);   
unsigned char os_send_signal(unsigned char task_no);   
unsigned char isr_send_signal(unsigned char task_no);   
unsigned char os_clear_signal(unsigned char task_no);   
unsigned char os_wait(unsigned type, unsigned timeout);   
unsigned char os_create_task(unsigned int proc_name, unsigned char task_no);   
   
extern int  getsp(void);              // Get Stack Pointer   
extern void putsp(int sp_value);      // Get Stack Pointer   
   
extern void save_pop(void);   
extern void save_push(void);   
extern void restore_sr(void);   
   
/*******************************************************************/   
   
interrupt [TIMERA0_VECTOR] void WD( void )   
{   
    unsigned int *i,*j;   
       
    clear_watchdog();   
       
    i=(unsigned int *)getsp();   
    j=i-1;   
    putsp((unsigned int)j);   
       
    *j=*i;   
    j++;   
    i++;   
       
    *j=*i;   
    j++;   
    i++;   
       
    *j=*i;   
    j++;   
    i++;   
       
    *j=*i;   
    j++;   
    i++;   
   
    *j=*i;   
    j++;   
    i++;   
       
    *j=*i;   
    j++;   
    i++;   
           
    SAVE_SR=*i;   
    *j=*i;   
    *i=(unsigned int)timer0_comm;   
}   
   
   
void timer0_comm(void)   
{     
     unsigned char i;   
     unsigned char stack_free;   
   
//Clear_watchdog:        
     clear_watchdog();   
        
//Update_Timer0:   
     CCR0+=RTX_CLOCK;   
   
//Chcec_Stack:   /* 堆栈检查，如果剩余堆栈 <  RTX_STACKFREE 转去错误处理程序 */   
   
     stack_free=TASK_Current==RTX_MAXTASKN ? RTX_RAMBOTTOM : STKP[TASK_Current+1];   
   
     stack_free=getsp()-stack_free;   
   
     if(stack_free<RTX_STACKFREE)   
       {   
           _DINT();   
           while(1)   
           {   
              /* ************此处加入堆栈溢出处理程序*************** */   
           };   
       }   
   
   
//Update_Check_Task_Timers:   
   
      for(i=0;i<RTX_MAXTASKN;i++)   
         {   
             STATE[i].time--;   
             _DINT();   
             if((STATE[i].st&K_TMO)&&(STATE[i].time==0))STATE[i].st|=K_READY+TMO_EVENT;   
             _EINT();   
         }   
   
//Check_Round_Robin_TimeOut:   
   
      if(RTX_TIMESHARING==0)     /* 没有任务切换 */   
        {   
            restore_sr();   
            return;   
        }   
   
      if(STATE[TASK_Current].time!=RTX_RobinTime) /* 没有任务切换 */   
        {   
            restore_sr();   
            return;   
        }   
   
      if(RTX_TS&RTX_TS_DELAY)   
        {   
           RTX_TS|=RTX_TS_REQ;   
           restore_sr();   
           return;   
        }   
   
     save_push();   
        
     _DINT();   
     STATE[TASK_Current].st|=K_ROBIN;   
     _EINT();   
   
     task_switch();   
}   
   
   
   
unsigned char task_switch(void)   
{   
     unsigned char i;   
     unsigned int *j,*p1,*p2;   
   
     clear_watchdog();   
        
     RTX_SP=getsp();   
     p1=(unsigned int *)(RTX_SP+8);   
     p2=p1-1;   
          
     for(i=0;i<4;i++)   
        {         
           *p1=*p2;   
           p1--;   
           p2--;   
        }   
      
     RTX_SP+=2;   
     putsp(RTX_SP);   
     j=(unsigned int *)RTX_SP;   
          
     RTX_TS|=RTX_TS_DELAY;   
   
     i=TASK_Current;   
   
   
     while(1)   
     {   
        if ((++i)==(RTX_MAXTASKN))   
            i=0;   
        if (STATE[i].st&K_READY)   
            break;   
     }   
        
     while(TASK_Current<i)   
     {   
        TASK_Current++;   
           
        p1=(unsigned int *)STKP[TASK_Current];   
        p2=(unsigned int *)(TASK_Current==RTX_MAXTASKN ? RTX_RAMBOTTOM : STKP[TASK_Current+1]);   
   
        STKP[TASK_Current]=RTX_SP;   
           
        while(p1!=p2)   
        {   
           RTX_SP-=2;   
           putsp(RTX_SP);   
           j--;   
           p1--;   
           *j=*p1;   
        }   
     }   
   
     while(TASK_Current>i)   
     {   
        p1=(unsigned int *)(TASK_Current==RTX_MAXTASKN ? RTX_SP : STKP[TASK_Current+1]);   
        p2=(unsigned int *)STKP[TASK_Current];   
           
        while(j!=p2)   
        {   
           *p1=*j;   
           p1++;   
           j++;   
           RTX_SP+=2;   
           putsp(RTX_SP);   
        }   
        STKP[TASK_Current] = (unsigned int)p1;   
   
        TASK_Current--;   
     }   
   
     RTX_RobinTime = STATE[TASK_Current].time + RTX_TIMESHARING;   
        
     _DINT();   
        
     if(STATE[TASK_Current].st & K_ROBIN)   
       {   
          _EINT();   
          RTX_TS&=~RTX_TS_DELAY;   
          RTX_TS&=~RTX_TS_REQ;   
             
          save_pop();   
             
          return(0x00);   
       }   
   
     if((STATE[TASK_Current].st & K_SIG) && (STATE[TASK_Current].st & SIG_EVENT))   
       {   
          STATE[TASK_Current].st&=0xf0;   
          _EINT();   
          RTX_TS&=~RTX_TS_DELAY;   
          RTX_TS&=~RTX_TS_REQ;   
          return(SIG_EVENT);   
       }   
   
     if((STATE[TASK_Current].st & K_TMO) && (STATE[TASK_Current].st & TMO_EVENT))   
       {   
          STATE[TASK_Current].st&=0xf4;   
          _EINT();   
          RTX_TS&=~RTX_TS_DELAY;   
          RTX_TS&=~RTX_TS_REQ;   
          return(TMO_EVENT);   
       }   
   
     _EINT();   
     RTX_TS&=~RTX_TS_DELAY;   
     RTX_TS&=~RTX_TS_REQ;   
     return(0x00);   
}   
   
unsigned char os_wait(unsigned type, unsigned timeout)   
{   
   unsigned char st = 0;   
      
   clear_watchdog();   
   
   if(type==0)   
     {   
        _DINT();   
        STATE[TASK_Current].st &= ~ (st | K_SIG | K_TMO);   
        _EINT();   
        return (st);   
     }   
   
   TACTL&=~MC1;              
   
   if(type&K_IVL)   
     {   
        STATE[TASK_Current].time+=timeout;   
        if(!C)   
          {   
             st = TMO_EVENT;   
             _DINT();   
             STATE[TASK_Current].st &= ~ (st | K_SIG | K_TMO);   
             _EINT();   
             TACTL|=MC1;              
             return (st);   
          }   
        _DINT();   
        STATE[TASK_Current].st |= K_TMO;   
        _EINT();   
      }   
   
    if(type&K_TMO)   
      {   
         if(timeout==0)   
           {   
              st = TMO_EVENT;   
              _DINT();   
              STATE[TASK_Current].st &= ~ (st | K_SIG | K_TMO);   
              _EINT();   
              TACTL|=MC1;              
              return (st);   
           }   
         STATE[TASK_Current].time = timeout;   
   
         _DINT();   
         STATE[TASK_Current].st |= K_TMO;   
         _EINT();   
      }   
   
    if(type&K_SIG)   
      {   
         if(STATE[TASK_Current].st&SIG_EVENT)   
           {   
              st=SIG_EVENT;   
              _DINT();   
              STATE[TASK_Current].st &= ~ (st | K_SIG | K_TMO);   
              _EINT();   
              TACTL|=MC1;              
              return (st);   
           }   
         _DINT();   
         STATE[TASK_Current].st |= K_SIG;   
         _EINT();   
    }   
   
    _DINT();   
    STATE[TASK_Current].st &= ~K_READY;   
    _EINT();   
       
    TACTL|=MC1;              
    task_switch();   
       
    return(0xff);   
}   
   
   
unsigned char os_clear_signal(unsigned char task_no)   
{   
   unsigned char *p;   
      
   if (task_no>=RTX_MAXTASKN)return(0xff);   
      
   _DINT();   
      
   p=&STATE[task_no].st;   
   *p&=SIG_EVENT;   
      
   _EINT();   
      
   return(0);   
}   
   
unsigned char os_send_signal(unsigned char task_no)   
{   
   unsigned char *p;   
      
   clear_watchdog();   
   
   if (task_no>=RTX_MAXTASKN)  return (0xff);   
   
   _DINT();   
      
   p=&STATE[task_no].st;   
   
   if(*p&K_ACTIVE)   
     {   
        if (*p&K_SIG)*p|=K_READY;   
     }   
   *p|=SIG_EVENT;   
   
   _EINT();   
   
   return(0);   
}   
   
   
unsigned char isr_send_signal(unsigned char task_no)   
{   
   unsigned char *p;   
      
   clear_watchdog();   
   
   if (task_no>=RTX_MAXTASKN)  return (0xff);   
   
   _DINT();   
      
   p=&STATE[task_no].st;   
   
   if(*p&K_ACTIVE)   
     {   
        if (*p&K_SIG)*p|=K_READY;   
     }   
   *p|=SIG_EVENT;   
   
   _EINT();   
   
   return(0);   
}   
   
   
unsigned char os_delete_task(unsigned char task_no)   
{   
    unsigned int *j,*p1,*p2;   
   
    clear_watchdog();   
       
    if(task_no>=RTX_MAXTASKN)return(0xff);   
   
    if(!(STATE[task_no].st & K_ACTIVE))return(0xff);   
   
    _DINT();   
    STATE[task_no].st &= ~(K_ACTIVE | K_READY | K_SIG | K_TMO | K_ROBIN);   
    _EINT();   
   
     
   
    if(TASK_Current==task_no)   
      {   
         RTX_SP=STKP[task_no];   
         putsp(RTX_SP);   
         task_switch();   
      }   
       
    if(TASK_Current<task_no)   
      {   
         p1=(unsigned int *)(task_no==RTX_MAXTASKN ? RTX_RAMBOTTOM : STKP[task_no+1]);   
         j=(unsigned int *)STKP[task_no];   
            
         do{   
              p2=(unsigned int *)(STKP[task_no]);        
              while(p1!=p2)   
              {   
                 *p1=*j;   
                 p1++;   
                 j++;   
              }   
              STKP[task_no]=(unsigned int)p1;   
              task_no--;   
           }while (TASK_Current!=task_no);   
         return (0);   
      }   
   
    if(TASK_Current>task_no)   
      {   
         p1=(unsigned int *)(STKP[task_no+1]);   
         j=(unsigned int *)(STKP[task_no]);   
         do{   
              task_no++;   
              STKP[task_no]=(unsigned int)(j);   
              p2=(unsigned int *)(task_no==TASK_Current ? RTX_SP : STKP[task_no+1]);   
              while(p1!=p2)   
              {   
                 j++;   
                 p1++;   
                 *j=*p1;   
              }   
           }while(TASK_Current!=task_no);   
         RTX_SP=(unsigned int)j;   
         putsp(RTX_SP);   
         return (0);   
      }   
         
   return(0xff);      
}   
   
unsigned char os_create_task(unsigned int proc_name, unsigned char task_no)   
{   
   unsigned int i;   
   unsigned int *j,*p1,*p2;   
     
   clear_watchdog();   
      
   if(task_no>=RTX_MAXTASKN)return(0xff);   
   
   if(STATE[task_no].st&K_ACTIVE)return(0xff);   
   
   STATE[task_no].st|=K_ACTIVE+K_READY;   
   
   i=TASK_Current;   
      
   RTX_SP=getsp();   
      
   while(i<task_no)   
   {   
      i++;   
      p1=(unsigned int *)STKP[i];   
      p2=(unsigned int *)(i==RTX_MAXTASKN ? RTX_RAMBOTTOM : STKP[i+1]);   
      p2--;   
      while(p1!=p2)   
      {   
     j=p1+5;   
     *j=*p1;   
         p1--;   
      }   
      STKP[i]+=10;   
   }   
      
   if(i>task_no)   
     {   
        RTX_SP-=10;   
        putsp(RTX_SP);   
     }      
   
   while(i>task_no)   
   {   
      p1=(unsigned int *)(i==TASK_Current ? RTX_SP : STKP[i+1]);   
      p2=(unsigned int *)STKP[i];   
      STKP[i]-=10;   
      while(p1!=p2)   
      {   
         j=p1+5;   
         *p1=*j;   
         p1++;   
      }   
      i--;   
   }   
   
      
   j=(unsigned int *)(STKP[task_no]-2);   
   *j=proc_name;   
      
   j++;   
   *j=0;   
   j++;   
   *j=0;   
   j++;   
   *j=0;   
   j++;   
   *j=0;   
       
   return(0);   
}   
   
   
unsigned char os_system_start(void)  /* 操作系统初始化 */   
{   
     unsigned char i;   
     unsigned int *j,*p1,*p2;   
   
     _DINT();   
       
     clear_watchdog();   
        
     RTX_TS&=~RTX_TS_REQ;   
   
     RTX_TS&=~RTX_TS_DELAY;   
   
     TASK_Current=0;   
   
     i=TASK_Current;   
   
     while(1)   
     {   
        if ((++i)==(RTX_MAXTASKN))i=0;   
        if (STATE[i].st&K_READY)break;   
     }   
   
     RTX_SP=getsp();   
     RTX_SP+=8;   
     putsp(RTX_SP);   
     j=(unsigned int *)RTX_SP;   
        
     while(TASK_Current<i)   
     {   
        TASK_Current++;   
           
        p1=(unsigned int *)STKP[TASK_Current];   
        p2=(unsigned int *)(TASK_Current==RTX_MAXTASKN ? RTX_RAMBOTTOM : STKP[TASK_Current+1]);   
   
        STKP[TASK_Current]=RTX_SP;   
           
        while(p1!=p2)   
        {   
           RTX_SP-=2;   
           putsp(RTX_SP);   
           j--;   
           p1--;   
           *j=*p1;   
        }   
     }   
   
     while(TASK_Current>i)   
     {   
        p1=(unsigned int *)(TASK_Current==RTX_MAXTASKN ? RTX_SP : STKP[TASK_Current+1]);   
        p2=(unsigned int *)STKP[TASK_Current];   
           
        while(j!=p2)   
        {   
           *p1=*j;   
           p1++;   
           j++;   
           RTX_SP+=2;   
           putsp(RTX_SP);   
        }   
        STKP[TASK_Current] = (unsigned int)p1;   
   
        TASK_Current--;   
      }   
   
      RTX_RobinTime=RTX_TIMESHARING;   
         
      TACTL=TASSEL1+TACLR;     //SMCL , CLREAR TAR    
      CCR0=RTX_CLOCK;   
      CCTL0|=CCIE;   
      TACTL|=MC1;   
         
      _EINT();   
   
      return(0x00);   
}   
   
   
void os_system_init(void)  /* 操作系统初始化 */   
{   
     unsigned char   i;   
   
     _DINT();   
        
        
     clear_watchdog();   
            
     for(i=0;i<RTX_MAXTASKN;i++)   
        {   
       STKP[i]=RTX_RAMBOTTOM;   
       STATE[i].st=0;   
    }   
        
     STKP[0]=getsp();   
        
     TASK_Current=0;   
}   
   
void clear_watchdog(void)   
{   
     if(!(WDTCTL&WDTTMSEL))WDTCTL=WDT_ARST_250;      /* WDT 250 MS */   
}   
   
/*******************************************************************/   
   
int task_test1(void)      /* 测试任务1 */   
{   
     char i;   
   
     while(1)   
     {   
        i++;   
        i++;   
        i++;   
        i++;   
        //os_wait(K_SIG,0);   
     };   
        
     return(0x1234);   
}   
   
void task_test2(void)      /* 测试任务2 */   
{   
     char i;   
   
     while(1)   
     {   
        i++;   
        i++;   
        i++;   
        i++;   
        //os_delete_task(2);   
     };   
}   
   
void task_test3(void)      /* 测试任务3 */   
{   
     char i;   
   
     while(1)   
     {   
        i++;   
        i++;   
        i++;   
        i++;   
     };   
}   
   
void main(void)   
{   
     os_system_init();                             /* 系统初始化 */   
     os_create_task((unsigned int)task_test1,1);   /* 任务创建   */   
     os_create_task((unsigned int)task_test2,2);   /* 任务创建   */   
     os_create_task((unsigned int)task_test3,3);   /* 任务创建   */   
     os_system_start();                            /* 系统运行   */   
}

RTX 51 FULL源码学习（2.1）
sxhheh的博客
05-22 1832
在学习源码之前，先来看一看RTX 51 FULL源文件的组成，以及各个模块的功能，对RTX 51有一个整体的了解！
c51实时操作系统（短小精悍）
trtos的专栏
08-01 2593
#include #include #define INT_REGBANK 1 #define TIMESHARING 5 #define RTX_STACKFREE 20 #define RTX_MAXTASKN 10 #define RTX_RAMTOP 0xFF #define INT_CLOCK 10000 #define RTX_TIMESHARING (0 - TIMESHARIN
RTX51实时操作系统源码
04-20
RTX51实时操作系统内核源代码 This file is part of the 'RTX-51' Real-Time Operating System Source Package
MSP430G2553最小系统板(PCB)
Once_day的回忆
05-10 9233
MSP430G2553最小系统板设计(原理图+PCB) Author：Once Day“漫漫长路，有人对你微笑过嘛…” Date：北部市保留地，2022年5月9日 文章目录MSP430G2553最小系统板设计(原理图+PCB)1.概述2.参数性能3.最小系统板设计3.1功能需求3.2 具体电路的设计3.3 PCB绘制注：本内容收集整理于互联网，仅供学习交流之用！ 1.概述 这是TI的低功耗单片机的一种，外设和封装较小，适合低成本应用场所。 上面是一种常见的Ti开发套件，自带了TI的采用 EnergyTra
对于MSP430F5529时钟系统的理解
Henax_blog
07-25 2035
大一下学期才开始自学单片机，真真切切的感受到自己是个弱鸡，专业知识一点不会，看个书都费劲，周围又没有什么人可以交流交流或者带带我，那个酸爽就别提了，学的我一度想挠黑板。没办法，那也只能硬着头皮学，就是硬看，多看几遍或者看上一段时间就差不多才能理解意思。中断、IO口还比较好理解，到了时钟系统就一脸懵，看了好多遍，一直到暑假才算大致理解了，写篇博文当做梳理，也希望能帮到大家。 首先理解一下时钟系统到...
探秘JesFs：小巧而强大的嵌入式串行文件系统
gitblog_00070的博客
06-06 849
探秘JesFs：小巧而强大的嵌入式串行文件系统 在物联网（IoT）的世界里，小型化、智能化的设备日益普及，它们需要处理各种语言数据、图形和设置信息。传统的固件集成方式已经无法满足需求，尤其是在需要频繁更新和安全性的背景下。而这就引出了我们的主角——JesFs，一个由Jo开发的用于标准串行NOR-Flash的嵌入式文件系统。 一、项目简介 JesFs 是专为"真正的小型"设备设...
苹果微信小程序服务器错误403,解决微信小程序调用豆瓣API出现403
weixin_42363277的博客
08-11 1924
一、403错误出现说明最近开始研究微信小程序，看网上大家的学习案例都是豆瓣的电影小项目，琢磨着自己也仿照写一个。首先使用了豆瓣的电影API，访问地址为// 小程序调用豆瓣API方法const _this = thiswx.request({url: 'http://api.douban.com/v2/movie/in_theaters',header: {'content-type': 'appl...
基于MSP430金属探测仪检测器报警系统设计
QQ2193276455的博客
06-14 767
*单片机设计介绍，基于MSP430金属探测仪检测器报警系统设计。
单片机设计基于MSP430金属探测仪检测器报警系统
QQ1928499906的博客
10-08 1825
💗博主介绍：✌全网粉丝10W+,优快云特邀作者、博客专家、优快云新星计划导师，一名热衷于单片机技术探索与分享的博主、专注于 精通51/STM32/MSP430/AVR等单片机设计 主要对象是咱们电子相关专业的大学生，希望您们都共创辉煌！✌💗👇🏻 精彩专栏 推荐订阅👇🏻单片机设计精品实战案例✅。
基于msp430单片机的饮料瓶检漏系统.pdf
11-29
通过对大量试验数据的分析，可以确定一个明显的压力阈值，以此判断瓶子是否泄漏。系统能够实时检测样本，及时发出报警信号，并可触发后续的不合格产品剔除机制。 硬件设计部分，系统主要由MSP430F149单片机、气缸和...
一种基于MSP430单片机的交流频率检测系统
08-27
而测周法则相反，它在待测信号的一个周期内统计标准高频信号的个数，从而计算频率。然而，这两种方法均依赖于时基信号的精度，尤其是在需要极高精度的应用场景中，时基信号的微小波动都会对测量结果造成显著影响。 ...
参考资料-基于Msp430单片机的多通道应变测试系统研究.zip
01-18
《基于Msp430单片机的多通道应变测试系统研究》是一个深入探讨电子工程领域中的一个重要主题——应变测试技术的参考资料。该系统利用Msp430单片机作为核心控制器，实现对多个应变信号的实时采集、处理和分析。下面将...
微小电容检测系统设计：基于MS3110电容检测芯片
总结而言，本文提出的电容检测系统是传感技术领域的一个重要进展，它利用集成芯片MS3110实现了对微小电容的高精度检测，为电容式传感器的开发和应用提供了有力的支持。未来，随着技术的进一步发展，类似这样的检测...
spnavcfg-0.3.1-1.el8.tar.gz
08-19
# 适用操作系统：Centos8 #Step1、解压 tar -zxvf xxx.el8.tar.gz #Step2、进入解压后的目录，执行安装 sudo rpm -ivh *.rpm
一个涵盖患者、疾病与药物关系的权威医疗 RDF 数据集
08-19
资源下载链接为： https://pan.quark.cn/s/7d4480e88650 一个涵盖患者、疾病与药物关系的权威医疗 RDF 数据集（最新、最全版本！打开链接下载即可用！）
【汽车电子电气】整车线束设计优化：从3D建模到降本增效的全流程解析及挑战应对了汽车电子电气
最新发布
08-19
内容概要：本文详细阐述了汽车线束设计在整车电气系统中的重要性和设计流程。线束作为整车电子电气架构的物理实现，承担着连接ECU、传感器、执行器等模块的功能，贯穿车辆的动力、安全、智能驾驶等多个领域。文章从线束设计的核心作用、设计流程、核心挑战及降本措施四个方面展开。核心作用包括功能实现、安全保障、性能优化和成本控制；设计流程涵盖3D线束设计、电气原理设计和2D线束设计三个阶段；核心挑战涉及复杂系统集成、轻量化与成本平衡及试装验证；降本措施则通过国产化替代和设计优化来实现。 适合人群：从事汽车电子电气系统设计、开发及制造的工程师和技术人员，尤其是具备一定工作经验的研发人员。 使用场景及目标：①了解线束设计在整个汽车电气系统中的作用及其设计流程；②掌握线束设计的关键技术和挑战，如复杂系统集成、轻量化设计等；③学习如何通过国产化替代和设计优化降低成本并提高产品质量。 其他说明：本文不仅提供了详细的线束设计理论知识，还结合实际案例介绍了具体的实施路径和方法，旨在帮助读者全面理解和掌握线束设计的相关技术。阅读过程中，建议结合实际工程经验，重点关注设计流程中的关键技术点和降本措施的具体实施方案。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值