Cortex-K60自学笔记（一）

最新推荐文章于 2022-05-12 11:11:17 发布
最新推荐文章于 2022-05-12 11:11:17 发布
阅读量913 收藏 4
点赞数
分类专栏： Cortex-K60 文章标签： 嵌入式 单片机 智能车
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43221499/article/details/83190378
版权

底层函数编写（gpio,uart）

写这篇博客算是自我激励吧，一直以来都没有说有特别大的决心去做一件事，想通过这种方式去让自己有所坚持，有所进步吧。我也觉得面对一件事，要么就不要开始，要么就尽己所能去做好。

gpio.h

#ifndef GPIO_H
#define GPIO_H


typedef struct
{
uint32  PDOR  ;		//端口数据输出寄存器
uint32  PSOR  ;		//端口数据置一寄存器
uint32  PCOR  ;		//端口数据清零寄存器
uint32  PTOR  ;     //端口数据反转寄存器
uint32  PDIR  ;  	//端口数据输入寄存器
uint32  PDDR  ;     //端口数据方向寄存器
}volatile *GPIO_MemMapPtr;


typedef struct PORT_MemMap
{
uint32 PCR[32];		//32个引脚
uint32 GPCLR;	 
uint32 GPCHR;
uint8 RESERVED_0[24];
uint32 ISFR;		//中断配置寄存器
}volatile *PORT_MemMapPtr;
//这里首先定义了两个结构体变量，一个是port register,一个是gpio register，印象特别深的是关于两者的差别，我的理解是port register 初始化通用的一些端口设置，gpio register用于初始化gpio的一些设置，比如说中断必须在port里面设置。

//这里的GPIO_Type *是和GPIO_MemMapPtr等价的
#define PTA                                      ((GPIO_Type *)PTA_BASE)
/** Peripheral PTB base address */
#define PTB_BASE                                 (0x400FF040u)
/** Peripheral PTB base pointer */
#define PTB                                      ((GPIO_Type *)PTB_BASE)
/** Peripheral PTC base address */
#define PTC_BASE                                 (0x400FF080u)
/** Peripheral PTC base pointer */
#define PTC                                      ((GPIO_Type *)PTC_BASE)
/** Peripheral PTD base address */
#define PTD_BASE                                 (0x400FF0C0u)
/** Peripheral PTD base pointer */
#define PTD                                      ((GPIO_Type *)PTD_BASE)
/** Peripheral PTE base address */
#define PTE_BASE                                 (0x400FF100u)
/** Peripheral PTE base pointer */
#define PTE                                      ((GPIO_Type *)PTE_BASE)



#define g_PORTA_BASE_PTR ((PORT_MemMapPtr)0x40049000u)
#define g_PORTB_BASE_PTR ((PORT_MemMapPtr)0x4004A000u)
#define g_PORTC_BASE_PTR ((PORT_MemMapPtr)0x4004B000u)
#define g_PORTD_BASE_PTR ((PORT_MemMapPtr)0x4004C000u)
#define g_PORTE_BASE_PTR ((PORT_MemMapPtr)0x4004D000u)

#define g_PTA_BASE_PTR ((GPIO_MemMapPtr)0x40049000u)
#define g_PTB_BASE_PTR ((GPIO_MemMapPtr)0x4004A000u)
#define g_PTC_BASE_PTR ((GPIO_MemMapPtr)0x4004B000u)
#define g_PTD_BASE_PTR ((GPIO_MemMapPtr)0x4004C000u)
#define g_PTE_BASE_PTR ((GPIO_MemMapPtr)0x4004D000u)


#define g_GPIO_PDOR_REG(base)   ((base)->PDOR)
#define g_GPIO_PSOR_REG(base)   ((base)->PSOR)
#define g_GPIO_PCOR_REG(base)   ((base)->PCOR)
#define g_GPIO_PTOR_REG(base)   ((base)->PTOR)
#define g_GPIO_PDIR_REG(base)   ((base)->PDIR)
#define g_GPIO_PDDR_REG(base)   ((base)->PDDR)
#define g_PORT_PCR_REG(port_ptr,port_bit) ((port_ptr)->PCR[port_bit])
#define g_PORT_ISFR_REG(base) ((base)->ISFR)


#define OUTPUT_L        0       
#define OUTPUT_H        1       
#define INPUT_PULL_DOWN (0|PORT_PCR_PE_MASK)                      
#define INPUT_PULL_UP   (PORT_PCR_PS_MASK|PORT_PCR_PE_MASK)       

#define PORT_PCR_MUX(x)     (((uint32_t)(((uint32_t)(x))<<PORT_PCR_MUX_SHIFT))&PORT_PCR_MUX_MASK)

//typedef void (*GPIO_ISR_CALLBACK)(void);

//GPIO_ISR_CALLBACK GPIO_ISR[5];

uint8 g_LPLD_GPIO_Init(GPIO_Type * port ,uint8 pin,uint8 dir ,uint8 data);

void g_LPLD_GPIO_Set(GPIO_Type *port,uint8 pin,uint8 data);

uint32 g_LPLD_GPIO_Get(GPIO_Type *port,uint8 pin);

PORT_MemMapPtr ptToPort(GPIO_Type * port);

void delay_ms(long int time);

void gpio_turn (GPIO_Type * port,uint8 pin);

typedef void (*GPIO_ISR_CALLBACK)(void);

void port_isr(void);



#endif

对于头文件的梗，最想说的是关于拉普兰德v3库很多变量都变了，然后补各种变量，函数。但慢慢的写底层也看到的一些函数了解到了一些单片机原理，关于寄存器， 最直接的感受便是通过定位改变相应位的数值实现对零件的控制。

gpio.c



#include "common.h"
#include "gpio.h"



PORT_MemMapPtr ptToPort(GPIO_Type * port)
{
  if(port==PTA)
    return g_PORTA_BASE_PTR;
  else if(port==PTB)
    return g_PORTB_BASE_PTR;
  else if(port==PTC)
    return g_PORTC_BASE_PTR;
  else if(port==PTD)
    return g_PORTD_BASE_PTR;
  else if(port==PTE)
    return g_PORTE_BASE_PTR;
  else 
    return 0;
}


uint8 g_LPLD_GPIO_Init(GPIO_Type *port,uint8 pin,uint8 dir ,uint8 data)
{
  GPIO_Type *gpio_ptr=port;
  PORT_MemMapPtr port_ptr=ptToPort(port);
  ASSERT(port<PTE);
  ASSERT(pin<=31);
  ASSERT(dir<=1);
  ASSERT(data<=1);
  g_PORT_PCR_REG(port_ptr,pin)=PORT_PCR_MUX(1);		//设置端口复用
  

  GPIO_ISR_CALLBACK isr_func = port_isr;  	//关于这里首先是指定了中断函数
  enable_irq((IRQn_Type)(0 + PORTA_IRQn));	//接着是启用中断函数
  
  
  if(dir==DIR_OUTPUT)
  {
    g_GPIO_PDDR_REG(gpio_ptr)|=0x1u<<pin;
    if(data==OUTPUT_H)
      g_GPIO_PSOR_REG(gpio_ptr)=0x1u<<pin;
    else
      g_GPIO_PCOR_REG(gpio_ptr)=0x1u<<pin; 
  }
   
  else
  {
    g_GPIO_PDDR_REG(gpio_ptr)&=~(0x1u<<pin);
    if(data==INPUT_PULL_UP)
      g_PORT_PCR_REG(port_ptr,pin)|=PORT_PCR_PE_MASK|PORT_PCR_PS_MASK;
    else if(data==INPUT_PULL_DOWN)
      g_PORT_PCR_REG(port_ptr,pin)=PORT_PCR_PE_MASK;
    else
      g_PORT_PCR_REG(port_ptr,pin)&=~PORT_PCR_PE_MASK;
  }
   //这里其实也可以通过移位&实现对应位置设置
  return 1;
}


     
 void g_LPLD_GPIO_Set(GPIO_Type * port,uint8 pin,uint8 data)
 {
   GPIO_Type *gpio_ptr=port;
   gpio_ptr->PDOR = (gpio_ptr->PDOR & ~(0x01L<<pin)) | (uint32)(data << pin);
 }




 uint32 g_LPLD_GPIO_Get(GPIO_Type * port,uint8 pin)
 {
   GPIO_Type *gpio_ptr=port;
   return gpio_ptr->PDIR>=1?1:0;
 }
//一个简易的延时函数
void delay_ms(long int time)
{
  int i,j;
  for (i = 0; i<1000; i++)
  for(j = 0; j < 1000; j++);
     
}


void gpio_turn (GPIO_Type * port,uint8 pin)
{      
    GPIO_Type *gpio_ptr=port;
    gpio_ptr->PTOR |=  (1 << pin);                                                                                         
}

void port_isr(void)
{
  if(LPLD_GPIO_IsPinxExt(PORTA, GPIO_Pin19))
  {
    //去抖
    delay_ms(10);
    if(PTA19_I==0)
    {
      PTA10_O=0;
      delay_ms(10);delay_ms(10);delay_ms(10);
      delay_ms(10);delay_ms(10);delay_ms(10);
      delay_ms(10);delay_ms(10);delay_ms(10);
    }
    else
    {
    PTA10_O=0;
      delay_ms(10);delay_ms(10);delay_ms(10);
      delay_ms(10);delay_ms(10);delay_ms(10);
      delay_ms(10);delay_ms(10);delay_ms(10);
    }
  } 
}                                                                 

uart.h

#ifndef UART_H
#define UART_H


typedef struct g_UART_MemMapPtr
{
  
  uint8 BDH;                                /**< UART Baud Rate Registers:High, offset: 0x0 */
  uint8 BDL;                                /**< UART Baud Rate Registers: Low, offset: 0x1 */
  uint8 C1;                                 /**< UART Control Register 1, offset: 0x2 */
  uint8 C2;                                 /**< UART Control Register 2, offset: 0x3 */
  uint8 S1;                                 /**< UART Status Register 1, offset: 0x4 */
  uint8 S2;                                 /**< UART Status Register 2, offset: 0x5 */
  uint8 C3;                                 /**< UART Control Register 3, offset: 0x6 */
  uint8 D;                                  /**< UART Data Register, offset: 0x7 */
  uint8 MA1;                                /**< UART Match Address Registers 1, offset: 0x8 */
  uint8 MA2;                                /**< UART Match Address Registers 2, offset: 0x9 */
  uint8 C4;                                 /**< UART Control Register 4, offset: 0xA */
  uint8 C5;                                 /**< UART Control Register 5, offset: 0xB */
  uint8 ED;                                 /**< UART Extended Data Register, offset: 0xC */
  uint8 MODEM;                              /**< UART Modem Register, offset: 0xD */
  uint8 IR;                                 /**< UART Infrared Register, offset: 0xE */
  uint8 RESERVED_0[1];
  uint8 PFIFO;                              /**< UART FIFO Parameters, offset: 0x10 */
  uint8 CFIFO;                              /**< UART FIFO Control Register, offset: 0x11 */
  uint8 SFIFO;                              /**< UART FIFO Status Register, offset: 0x12 */
  uint8 TWFIFO;                             /**< UART FIFO Transmit Watermark, offset: 0x13 */
  uint8 TCFIFO;                             /**< UART FIFO Transmit Count, offset: 0x14 */
  uint8 RWFIFO;                             /**< UART FIFO Receive Watermark, offset: 0x15 */
  uint8 RCFIFO;                             /**< UART FIFO Receive Count, offset: 0x16 */
  uint8 RESERVED_1[1];
  uint8 C7816;                              /**< UART 7816 Control Register, offset: 0x18 */
  uint8 IE7816;                             /**< UART 7816 Interrupt Enable Register, offset: 0x19 */
  uint8 IS7816;                             /**< UART 7816 Interrupt Status Register, offset: 0x1A */
  union
  {                                          /* offset: 0x1B */
    uint8 WP7816_T_TYPE0;                     /**< UART 7816 Wait Parameter Register, offset: 0x1B */
    uint8 WP7816_T_TYPE1;                     /**< UART 7816 Wait Parameter Register, offset: 0x1B */
  };
  uint8 WN7816;                             /**< UART 7816 Wait N Register, offset: 0x1C */
  uint8 WF7816;                             /**< UART 7816 Wait FD Register, offset: 0x1D */
  uint8 ET7816;                             /**< UART 7816 Error Threshold Register, offset: 0x1E */
  uint8 TL7816; 
  
}volatile *g_UART_MemMapPtr;


#ifndef UART0_BASE
#define UART0_BASE                               (0x4006A000u)
/** Peripheral UART0 base pointer */
#define UART0                                    ((g_UART_MemMapPtr)UART0_BASE)
/** Peripheral UART1 base address */
#define UART1_BASE                               (0x4006B000u)
/** Peripheral UART1 base pointer */
#define UART1                                    ((g_UART_MemMapPtr)UART1_BASE)
/** Peripheral UART2 base address */
#define UART2_BASE                               (0x4006C000u)
/** Peripheral UART2 base pointer */
#define UART2                                    ((g_UART_MemMapPtr)UART2_BASE)
/** Peripheral UART3 base address */
#define UART3_BASE                               (0x4006D000u)
/** Peripheral UART3 base pointer */
#define UART3                                    ((g_UART_MemMapPtr)UART3_BASE)
/** Peripheral UART4 base address */
#define UART4_BASE                               (0x400EA000u)
/** Peripheral UART4 base pointer */
#define UART4                                    ((g_UART_MemMapPtr)UART4_BASE)
/** Peripheral UART5 base address */
#define UART5_BASE                               (0x400EB000u)
/** Peripheral UART5 base pointer */
#define UART5                                    ((g_UART_MemMapPtr)UART5_BASE)

#endif

typedef enum UARTn
{
  g_UART0=UART0_BASE,
  g_UART1=UART1_BASE,
  g_UART2=UART2_BASE,
  g_UART3=UART3_BASE,
  g_UART4=UART4_BASE,
  g_UART5=UART5_BASE,
}UARTn;

typedef struct SIM_Type
{
  uint32 SOPT1;                             /**< System Options Register 1, offset: 0x0 */
  uint8 RESERVED_0[4096];
  uint32 SOPT2;                             /**< System Options Register 2, offset: 0x1004 */
  uint8 RESERVED_1[4];
  uint32 SOPT4;                             /**< System Options Register 4, offset: 0x100C */
  uint32 SOPT5;                             /**< System Options Register 5, offset: 0x1010 */
  uint32 SOPT6;                             /**< System Options Register 6, offset: 0x1014 */
  uint32 SOPT7;                             /**< System Options Register 7, offset: 0x1018 */
  uint8 RESERVED_2[8];
  uint32 SDID;                              /**< System Device Identification Register, offset: 0x1024 */
  uint32 SCGC1;                             /**< System Clock Gating Control Register 1, offset: 0x1028 */
  uint32 SCGC2;                             /**< System Clock Gating Control Register 2, offset: 0x102C */
  uint32 SCGC3;                             /**< System Clock Gating Control Register 3, offset: 0x1030 */
  uint32 SCGC4;                             /**< System Clock Gating Control Register 4, offset: 0x1034 */
  uint32 SCGC5;                             /**< System Clock Gating Control Register 5, offset: 0x1038 */
  uint32 SCGC6;                             /**< System Clock Gating Control Register 6, offset: 0x103C */
  uint32 SCGC7;                             /**< System Clock Gating Control Register 7, offset: 0x1040 */
  uint32 CLKDIV1;                           /**< System Clock Divider Register 1, offset: 0x1044 */
  uint32 CLKDIV2;                           /**< System Clock Divider Register 2, offset: 0x1048 */
  uint32 FCFG1;                             /**< Flash Configuration Register 1, offset: 0x104C */
  uint32 FCFG2;                             /**< Flash Configuration Register 2, offset: 0x1050 */
  uint32 UIDH;                              /**< Unique Identification Register High, offset: 0x1054 */
  uint32 UIDMH;                             /**< Unique Identification Register Mid-High, offset: 0x1058 */
  uint32 UIDML;                             /**< Unique Identification Register Mid Low, offset: 0x105C */
  uint32 UIDL;                              /**< Unique Identification Register Low, offset: 0x1060 */
} volatile *g_SIM_Type;

#define SIM_BASE                                 (0x40047000u)
#define SIM                                      ((SIM_Type *)SIM_BASE)
#define SIM_SCGC4_REG(base)                      ((base)->SCG4)
uint32 SCGC4;     
#define SIM_SCGC4                                SIM_SCGC4_REG(SIM_BASE_PTR)


#define UART_C2_REG(base)                        ((base)->C2)
#define UART_C1_REG(base)                        ((base)->C1)
#define UART_BDH_REG(base)                       ((base)->BDH)
#define UART_BDL_REG(base)                       ((base)->BDL)
#define UART_C4_REG(base)                        ((base)->C4)
#define UART_D_REG(base)                         ((base)->D)
#define UART_PFIFO_REG(base)                     ((base)->PFIFO)

void uart_init(UARTn uartn,uint32 baud,uint32 PORT_TX,uint32 PORT_RX);
void uart_send1(UARTn uartn,uint8 ch);
void uart_sendn(UARTn uarrtn,uint16 len,uint8 *buff);
void uart_re1(UARTn uartn,uint8 fp);
void uart_ren(UARTn uarrtn,uint16 len,uint8 *buff);
void uart_enable_re_init(UARTn uartn);
void uart_disable_re_init(UARTn uartn);

#endif

uart.c

#include "common.h"
#include "uart.h"

void uart_init(UARTn uartn,uint32 baud,uint32 PORT_TX,uint32 PORT_RX)
{
     register uint16 sbr,brfa;
     uint8 temp;
     uint32 sysclk;
     
     switch(uartn)
     {
     case g_UART0:
        SCGC4|=SIM_SCGC4_UART0_MASK;  
        
        if(PORT_TX==PTA1)
        PORTA->PCR[2] = PORT_PCR_MUX(2);         
        else if(PORT_TX == PTA2)
          PORTA->PCR[2] = PORT_PCR_MUX(2); 
        else if(PORT_TX == PTA14)
          PORTA->PCR[14] = PORT_PCR_MUX(3); 
        else
          PORTB->PCR[17] = PORT_PCR_MUX(3); 

        if(PORT_RX == PTA1)
          PORTA->PCR[1] = PORT_PCR_MUX(2); 
        else if(PORT_RX == PTA15)
          PORTA->PCR[15] = PORT_PCR_MUX(3); 
        else
          PORTB->PCR[16] = PORT_PCR_MUX(3); 
        
        
       UART_C2_REG((g_UART_MemMapPtr)uartn)&=~(0|UART_C2_TE_MASK|UART_C2_RE_MASK);
       UART_C1_REG((g_UART_MemMapPtr)uartn)|=(0|UART_C1_PE_MASK|UART_C1_PT_MASK);
       
       
       if((uartn==g_UART0)||(uartn==g_UART1))
       {
       sysclk=g_core_clock*1000;
       }
       else
       {
       sysclk=g_core_clock*1000;
       }
       sbr=(uint16)(sysclk/(baud*16));
       if(sbr>0x1FFF)
         sbr=0x1FFF;
       brfa=(sysclk/baud)-(sbr*16);
       temp=UART_BDH_REG((g_UART_MemMapPtr)uartn)&(~UART_BDH_SBR_MASK);
       UART_BDH_REG((g_UART_MemMapPtr)uartn)=temp|UART_BDH_SBR(sbr>>8);
       UART_BDL_REG((g_UART_MemMapPtr)uartn)=UART_BDL_SBR(sbr);
       temp=UART_C4_REG((g_UART_MemMapPtr)uartn)&(~UART_C4_BRFA_MASK);
       UART_C4_REG((g_UART_MemMapPtr)uartn)=temp|UART_C4_BRFA(brfa);
       UART_PFIFO_REG((g_UART_MemMapPtr)uartn)|=(0|UART_PFIFO_TXFE_MASK|UART_PFIFO_RXFE_MASK);
       UART_C2_REG((g_UART_MemMapPtr)uartn)|=(0|UART_C2_TE_MASK|UART_C2_RE_MASK);
     }
}



void uart_send1(UARTn uartn,uint8 ch)
{
while(!(((g_UART_MemMapPtr)uartn)->S1&UART_S1_TDRE_MASK));
UART_D_REG((g_UART_MemMapPtr)uartn)=ch;
}


void uart_sendn(UARTn uartn,uint16 len,uint8 *buff)
{
for(int n=0;n<len;n++)
{
uart_send1(uartn,*(buff++));
}
}


void uart_re1(UARTn uartn,uint8 fp)
{
while(!(((g_UART_MemMapPtr)uartn)->S1)&UART_S1_RDRF_MASK);
fp=(((g_UART_MemMapPtr)uartn)->D);

       
void uart_enable_re_init(UARTn uartn)
{
(((g_UART_MemMapPtr)uartn)->C2)|=UART_C2_TIE_MASK;
if(uartn == g_UART2)
enable_irq((int) (( ( (UART0_BASE/*(uint32)uartn*/)>>12 )&0x0000000Fu ) - 0x0000000A + (uint32)UART0_RX_TX_IRQn));
}
         
         
void uart_disable_re_init(UARTn uartn)
{
UART_C2_REG((g_UART_MemMapPtr)uartn)&=~UART_C2_TIE_MASK;
if(!(UART_C2_REG((g_UART_MemMapPtr)uartn))&(UART_C2_TIE_MASK|UART_C2_TCIE_MASK))
disable_irq((int) (( ( (UART0_BASE/*(uint32)uartn*/)>>12 )&0x0000000Fu ) - 0x0000000A + (uint32)UART0_RX_TX_IRQn));
}

main.c

#include "common.h"
#include "gpio.h"
   
enum LEDn
{
LEDG=10,
LEDR=11,
LEDB=12,
};
enum led_status
{
  led_on=1,
  led_down=0,
};


void main (void)
{
 //printf("hello world");
  g_LPLD_GPIO_Init(PTA ,LEDG ,DIR_OUTPUT ,1);
    g_LPLD_GPIO_Init(PTA ,LEDR ,DIR_OUTPUT ,1);
    g_LPLD_GPIO_Init(PTA ,LEDB ,DIR_OUTPUT ,1);
  while(1)
  {
    
    delay_ms(50);
    g_LPLD_GPIO_Set(PTA ,LEDB ,0);
    delay_ms(50);
    g_LPLD_GPIO_Set(PTA ,LEDB ,1);
    delay_ms(50);
    g_LPLD_GPIO_Set(PTA ,LEDG ,0);
    delay_ms(50);
    g_LPLD_GPIO_Set(PTA ,LEDG ,1);
    delay_ms(50);
    g_LPLD_GPIO_Set(PTA ,LEDR ,0);
    delay_ms(50);
    g_LPLD_GPIO_Set(PTA ,LEDR ,1); 
  } 
}

总结：上面的很多都是自己敲的，最后都最后实现流水灯真的很不易，很多bug都是学长帮助改的，但当真正的实现一些功能，还是觉得很值的。希望接下来自己能更加的努力，争取能够完成十二月份的校内赛。

limezc
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c语言 gpio指针定义,#define GPIOA ((GPIO_TypeDef *) GPIOA_BASE)这句话的具体作用是什么啊...
weixin_36392230的博客
05-25 8549
一、 GPIO_Init函数解析 11、参数GPIO_TypeDef 12、参数GPIO_InitStruct 23、函数代码详解 44、备注 6一、GPIO_Init函数解析首先来看一下GPIO_Init函数的原型void GPIO_Init(GPIO_TypeDef* GPIOx, GPIO_InitTypeDef* GPIO_InitStruct)。这个函数的实现是在Stm32f10x_gp...
K60学习笔记（1）——启动文件分析
Joshua Lee的博客
03-03 3729
初始化函数 上电复位 -&gt;中断向量表：在vectors.c裡面定义，在vectors.h文件里。 在vectors.h裡面两行： #define VECTOR_000 (vector_entry)__BOOT_STACK_ADDRESS // ARM core Initial Supervisor SP #define VE...
((GPIO_TypeDef *) GPIOB_BASE)或((GPIO_TypeDef *) xxxx)
qq_35370790的博客
03-24 9696
#define GPIOA ((GPIO_TypeDef*)GPIOA_BASE)1）GPIOA_BASE被强制转换为地址，空间以GPIO_TypeDef的类型进行构建，首址为GPIOA_BASE，空间内有成员，之间依各自固有类型顺序分配相应空间；2）GPIOA宏展开，即为紧跟其后的具体内容，这样它就是一个指针了：指向以GPIOA_BASE为首址的结构体空间。所以您给出GPIOA-&gt;某成员，...
基于S32K146与xr20m1172的
YZL_YJX的博客
05-12 720
S32K146利用SPI与xr20m1172进行通信的小demo
s32k144 isystem linux,S32K144之时钟配置
weixin_36304087的博客
05-14 1289
一般来说，时钟精度、稳定性取决于所采用的时钟源，就MCUS32K来说如内部振荡器SIRC，FIRC，128KLPO，外部晶振等，跟所使用的外设(FTM, LPIT，LPT，RTC等)和哪一路输出时钟(SYS_CLK，BUS_CLK，SPLLDVI1_CLK等)没有直接关系。由于S32K144提供的时钟源和配置方法比较多，那么如何有效配置得到自己想要的时钟呢？下面以S32K144为例，从时钟定义图...
ARM-CORTEX-M4自学笔记：基于K60
09-05
《ARM-CORTEX-M4自学笔记：基于K60》这本书深入浅出地探讨了飞思卡尔（现为恩智浦半导体）Kinetis系列中的K60微处理器，为读者提供了一条全面掌握该处理器及其开发技术的道路。ARM Cortex-M4是ARM公司设计的一种高...
Cortex-M4自学笔记
03-10
**知识点详解：Cortex-M4自学笔记——基于Kinetis K60** 1. **Cortex-M4架构解析** - Cortex-M4是ARM公司推出的一款高性能、低功耗的微处理器内核，专为实时操作系统（RTOS）设计。它在Cortex-M3的基础上加入了...
《Cortex-M4自学笔记-基于Kinetis K60》配套材料
03-08
《Cortex-M4自学笔记-基于Kinetis K60》是一本专注于嵌入式系统开发的书籍，主要围绕ARM公司的Cortex-M4处理器架构及其在NXP（原飞思卡尔）Kinetis K60系列微控制器上的应用展开。Kinetis K60是一款高性能、低功耗的...
整理的Cortex-M4 K60资料
09-05
飞思卡尔（现已被NXP半导体收购）的K60系列微控制器是基于Cortex-M4内核的芯片，它提供了一系列丰富的外设接口和功能，包括CAN、USB、以太网、ADC、DAC、PWM等，适用于各种嵌入式应用。K60微控制器的设计旨在提供高...
K60——寄存器
diaotaoning2896的博客
01-15 462
（1）PTx_BASE_PTR为GPIO寄存器结构体基址指针(PTR即point to register，x=A/B/C/D/E) /* GPIO - Peripheral instance base addresses */ /** Peripheral PTA base pointer */ #define PTA_BASE_PTR ...
基于K60的arm-cortex-m4
09-04
很好的学习资料，针对k60的相关操作，希望对你们有所帮助
单片机K60核心板原理图
03-22
K60核心板原理图，144P。
K60单片机核心板原理图
04-21
MK60N512...单片机最小系统核心板原理图，原理图为文档模式
飞思卡尔每个模块使用方法
03-04
This application note is an introduction to the Kinetis EA series MCUs for automotive solutions. This document gives an explanation of the main modules of the Kinetis EA devices so that a project can be started. The application note is divided into the following sections: • Introduction • Internal Clock Source (ICS) • General purpose input/output (GPIO) • Universal Asynchronous Receiver/Transmitter (UART) • FlexTimer Module (FTM) • Analog-to-digital converter (ADC) • Keyboards Interrupts (KBI)
S32K144 EVB之GPIO
xlbtlmy的博客
10-24 4582
开发环境 IAR7.8 + FreeRTOS V8.2.1 + S32K144-EVB 以下是startup_S32K144.s中的汇编启动代码：Reset_Handler CPSID I ; Mask interrupts ;; Init the rest of the registers LDR R1,=0
智能车学习（八）——菜单的实现
weixin_33705053的博客
01-08 995
一、代码分享 1、头文件 #ifndef __MENU_H #define __MENU_H /***********宏定义************/ //页面声明 typedef enum Menu_Page_Enum { MainMenu = 0, SubMenu1 = 1, SubMenu2 = 2, SubMenu3 = 3, ...
k60单片机_K60芯片解锁说明
weixin_39834281的博客
12-03 2439
K60芯片解锁说明芯片锁住了怎么办？这里汇总一些新手必读说明1 使用龙邱jlink下载器，下载器接线问题，龙邱核心板的下载接口丝印层都有一个白色凸口，对应龙邱下载器排线的凸口。⑴ 每个工程里面都包涵两种配置MK60DN 和MK60FX，请选好自己单片机的对应配置，不然会下载失败并且导致芯片上锁。⑵芯片锁住会显示如下错误信息⑶ 安装 IAR 的时候，一般会自动安装 Jli...
K60学习笔记二：PORT中断
qq_24085431的博客
03-29 7376
1.C预备知识 关于断言： 断言其实就是一个宏定义void assert_failed(char * ,int ); //断言失败执行的函数 #if define(DEBUG) //在DEBUG模式下进行调用 #define ASSERT(expr) if(!(expr)) \ assert_failed(_FILE_,_LINE
三天快速入门Cortex-M4：Kinetis K60单片机教程
K60单片机是飞思卡尔（现NXP）Kinetis系列的一部分，基于ARM Cortex-M4内核，是一款高性能、低功耗的微控制器。Cortex-M4处理器拥有浮点运算单元（FPU），支持单指令多数据（SIMD）操作，适合处理复杂的数学和控制...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值