[活动专区] 【AT-START-F425测评】+接入以太网

#include "spi.h"                                                  

//SPI口初始化

//这里针是对SPI1的初始化







void SPI1_Init(void)

{

        spi_init_type  spi_init_struct;

        gpio_init_type         gpio_initstructure;

  

        crm_periph_clock_enable(CRM_SPI1_PERIPH_CLOCK, TRUE);

    crm_periph_clock_enable(CRM_GPIOA_PERIPH_CLOCK, TRUE);

    gpio_pin_mux_config(GPIOA, GPIO_PINS_SOURCE5, GPIO_MUX_0);

    gpio_pin_mux_config(GPIOA, GPIO_PINS_SOURCE6, GPIO_MUX_0);

    gpio_pin_mux_config(GPIOA, GPIO_PINS_SOURCE7, GPIO_MUX_0);

        gpio_default_para_init(&gpio_initstructure);

        

        gpio_initstructure.gpio_out_type       = GPIO_OUTPUT_PUSH_PULL;

        gpio_initstructure.gpio_pull           = GPIO_PULL_DOWN;

    gpio_initstructure.gpio_mode           = GPIO_MODE_MUX;

    gpio_initstructure.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;

    gpio_initstructure.gpio_pins = GPIO_PINS_5;

    gpio_init(GPIOA, &gpio_initstructure);



    gpio_initstructure.gpio_out_type       = GPIO_OUTPUT_PUSH_PULL;

    gpio_initstructure.gpio_pull           = GPIO_PULL_UP;

    gpio_initstructure.gpio_mode           = GPIO_MODE_MUX;

    gpio_initstructure.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;

    gpio_initstructure.gpio_pins = GPIO_PINS_6;

    gpio_init(GPIOA, &gpio_initstructure);



    gpio_initstructure.gpio_out_type       = GPIO_OUTPUT_PUSH_PULL;

    gpio_initstructure.gpio_pull           = GPIO_PULL_UP;

    gpio_initstructure.gpio_mode           = GPIO_MODE_MUX;

    gpio_initstructure.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;

    gpio_initstructure.gpio_pins = GPIO_PINS_7;

    gpio_init(GPIOA, &gpio_initstructure);



         gpio_bits_set(GPIOA,GPIO_PINS_5|GPIO_PINS_6|GPIO_PINS_7);



        spi_default_para_init(&spi_init_struct);

    spi_init_struct.transmission_mode = SPI_TRANSMIT_FULL_DUPLEX;

    spi_init_struct.master_slave_mode = SPI_MODE_MASTER;

    spi_init_struct.mclk_freq_division = SPI_MCLK_DIV_8;

    spi_init_struct.first_bit_transmission = SPI_FIRST_BIT_LSB;

    spi_init_struct.frame_bit_num = SPI_FRAME_8BIT;

    spi_init_struct.clock_polarity = SPI_CLOCK_POLARITY_LOW;

    spi_init_struct.clock_phase = SPI_CLOCK_PHASE_2EDGE;

    spi_init_struct.cs_mode_selection = SPI_CS_SOFTWARE_MODE;

    spi_init(SPI1, &spi_init_struct);



//    spi_init_struct.master_slave_mode = SPI_MODE_SLAVE;

    spi_init(SPI1, &spi_init_struct);

    spi_enable(SPI1, TRUE);

        SPI1_ReadWriteByte(0xff);//启动传输                 

}   





//SPIx 读写一个字节

//TxData:要写入的字节

//返回值:读取到的字节

u8 SPI1_ReadWriteByte(u8 TxData)

{                

        u8 retry=0;                                         

        while (spi_i2s_flag_get(SPI1, SPI_I2S_TDBE_FLAG) == RESET) //检查指定的SPI标志位设置与否:发送缓存空标志位

                {

                retry++;

                if(retry>200)return 0;

                }                          

        spi_i2s_data_transmit(SPI1, TxData); //通过外设SPIx发送一个数据

        retry=0;



        while (spi_i2s_flag_get(SPI1, SPI_I2S_RDBF_FLAG) == RESET)//检查指定的SPI标志位设置与否:接受缓存非空标志位

                {

                retry++;

                if(retry>200)return 0;

                }                                                              

        return spi_i2s_data_receive(SPI1); //返回通过SPIx最近接收的数据                                            

}

#include "timer.h"

#include "at32f425_clock.h"

#include "lwip_comm.h"



 



extern u32 lwip_localtime;        //lwip本地时间计数器,单位:ms

//通用定时器3中断初始化

//arr：自动重装值。

//psc：时钟预分频数

//定时器溢出时间计算方法:Tout=((arr+1)*(psc+1))/Ft us.

//Ft=定时器工作频率,单位:Mhz

//这里使用的是定时器3!

void TIM3_Int_Init(u16 arr,u16 psc)

{



        crm_periph_clock_enable(CRM_TMR1_PERIPH_CLOCK, TRUE); //时钟使能

        

        //定时器TIM3初始化

     tmr_base_init(TMR1, arr, psc);

     tmr_cnt_dir_set(TMR1, TMR_COUNT_UP);



     /* overflow interrupt enable */

     tmr_interrupt_enable(TMR1, TMR_OVF_INT, TRUE);



      /* tmr1 overflow interrupt nvic init */

      nvic_priority_group_config(NVIC_PRIORITY_GROUP_4);

      nvic_irq_enable(TMR1_BRK_OVF_TRG_HALL_IRQn, 5, 0);



       /* enable tmr1 */

      tmr_counter_enable(TMR1, TRUE);                



//  crm_clkout_div_set(CRM_CLKOUT_DIV_1);



//  /* config clkout clock */

//  crm_clock_out_set(CRM_CLKOUT_PLL_DIV_4);        

}



//定时器3中断服务函数



void TMR1_BRK_OVF_TRG_HALL_IRQHandler(void)

{

  if(tmr_flag_get(TMR1, TMR_OVF_FLAG) != RESET)

  {

    /* add user code... */

     at32_led_toggle(LED2);

         lwip_localtime +=10; //加10

    tmr_flag_clear(TMR1, TMR_OVF_FLAG);

  }

}

#include "malloc.h"





//内存池(4字节对齐)

__align(4) u8 mem1base[MEM1_MAX_SIZE];                                                                                                        //内部SRAM内存池

__align(4) u8 mem2base[MEM2_MAX_SIZE] __attribute__((at(0X68000000)));                                        //外部SRAM内存池

//内存管理表

u16 mem1mapbase[MEM1_ALLOC_TABLE_SIZE];                                                                                                        //内部SRAM内存池MAP

u16 mem2mapbase[MEM2_ALLOC_TABLE_SIZE] __attribute__((at(0X68000000+MEM2_MAX_SIZE)));        //外部SRAM内存池MAP

//内存管理参数           

const u32 memtblsize[2]={MEM1_ALLOC_TABLE_SIZE,MEM2_ALLOC_TABLE_SIZE};                //内存表大小

const u32 memblksize[2]={MEM1_BLOCK_SIZE,MEM2_BLOCK_SIZE};                                        //内存分块大小

const u32 memsize[2]={MEM1_MAX_SIZE,MEM2_MAX_SIZE};                                                        //内存总大小





//内存管理控制器

struct _m_mallco_dev mallco_dev=

{

        my_mem_init,                                //内存初始化

        my_mem_perused,                        //内存使用率

        mem1base,mem2base,                //内存池

        mem1mapbase,mem2mapbase,//内存管理状态表

        0,0,                                          //内存管理未就绪

};



//复制内存

//*des:目的地址

//*src:源地址

//n:需要复制的内存长度(字节为单位)

void mymemcpy(void *des,void *src,u32 n)  

{  

    u8 *xdes=des;

        u8 *xsrc=src; 

    while(n--)*xdes++=*xsrc++;  

}  

//设置内存

//*s:内存首地址

//c :要设置的值

//count:需要设置的内存大小(字节为单位)

void mymemset(void *s,u8 c,u32 count)  

{  

    u8 *xs = s;  

    while(count--)*xs++=c;  

}           

//内存管理初始化  

//memx:所属内存块

void my_mem_init(u8 memx)  

{  

    mymemset(mallco_dev.memmap[memx], 0,memtblsize[memx]*2);//内存状态表数据清零  

        mymemset(mallco_dev.membase[memx], 0,memsize[memx]);        //内存池所有数据清零  

        mallco_dev.memrdy[memx]=1;                                                                //内存管理初始化OK  

}  

//获取内存使用率

//memx:所属内存块

//返回值:使用率(0~100)

u8 my_mem_perused(u8 memx)  

{  

    u32 used=0;  

    u32 i;  

    for(i=0;i<memtblsize[memx];i++)  

    {  

        if(mallco_dev.memmap[memx][i])used++; 

    } 

    return (used*100)/(memtblsize[memx]);  

}  

//内存分配(内部调用)

//memx:所属内存块

//size:要分配的内存大小(字节)

//返回值:0XFFFFFFFF,代表错误;其他,内存偏移地址 

u32 my_mem_malloc(u8 memx,u32 size)  

{  

    signed long offset=0;  

    u16 nmemb;        //需要的内存块数  

        u16 cmemb=0;//连续空内存块数

    u32 i;  

    if(!mallco_dev.memrdy[memx])mallco_dev.init(memx);//未初始化,先执行初始化 

    if(size==0)return 0XFFFFFFFF;//不需要分配



    nmemb=size/memblksize[memx];          //获取需要分配的连续内存块数

    if(size%memblksize[memx])nmemb++;  

    for(offset=memtblsize[memx]-1;offset>=0;offset--)//搜索整个内存控制区  

    {     

                if(!mallco_dev.memmap[memx][offset])cmemb++;//连续空内存块数增加

                else cmemb=0;                                                                //连续内存块清零

                if(cmemb==nmemb)                                                        //找到了连续nmemb个空内存块

                {

            for(i=0;i<nmemb;i++)                                          //标注内存块非空 

            {  

                mallco_dev.memmap[memx][offset+i]=nmemb;  

            }  

            return (offset*memblksize[memx]);//返回偏移地址  

                }

    }  

    return 0XFFFFFFFF;//未找到符合分配条件的内存块  

}  

//释放内存(内部调用) 

//memx:所属内存块

//offset:内存地址偏移

//返回值:0,释放成功;1,释放失败;  

u8 my_mem_free(u8 memx,u32 offset)  

{  

    int i;  

    if(!mallco_dev.memrdy[memx])//未初始化,先执行初始化

        {

                mallco_dev.init(memx);    

        return 1;//未初始化  

    }  

    if(offset<memsize[memx])//偏移在内存池内. 

    {  

        int index=offset/memblksize[memx];                        //偏移所在内存块号码  

        int nmemb=mallco_dev.memmap[memx][index];        //内存块数量

        for(i=0;i<nmemb;i++)                                                  //内存块清零

        {  

            mallco_dev.memmap[memx][index+i]=0;  

        }  

        return 0;  

    }else return 2;//偏移超区了.  

}  

//释放内存(外部调用) 

//memx:所属内存块

//ptr:内存首地址 

void myfree(u8 memx,void *ptr)  

{  

        u32 offset;  

    if(ptr==NULL)return;//地址为0.  

         offset=(u32)ptr-(u32)mallco_dev.membase[memx];  

    my_mem_free(memx,offset);//释放内存     

}  

//分配内存(外部调用)

//memx:所属内存块

//size:内存大小(字节)

//返回值:分配到的内存首地址.

void *mymalloc(u8 memx,u32 size)  

{  

    u32 offset;                                                                                

        offset=my_mem_malloc(memx,size);                                                

    if(offset==0XFFFFFFFF)return NULL;  

    else return (void*)((u32)mallco_dev.membase[memx]+offset);  

}  

//重新分配内存(外部调用)

//memx:所属内存块

//*ptr:旧内存首地址

//size:要分配的内存大小(字节)

//返回值:新分配到的内存首地址.

void *myrealloc(u8 memx,void *ptr,u32 size)  

{  

    u32 offset;  

    offset=my_mem_malloc(memx,size);  

    if(offset==0XFFFFFFFF)return NULL;     

    else  

    {                                                                             

            mymemcpy((void*)((u32)mallco_dev.membase[memx]+offset),ptr,size);        //拷贝旧内存内容到新内存   

        myfree(memx,ptr);                                                                                                            //释放旧内存

        return (void*)((u32)mallco_dev.membase[memx]+offset);                                  //返回新内存首地址

    }  

} 

#ifndef __MALLOC_H

#define __MALLOC_H

#include "at32f425.h"

          

#ifndef NULL

#define NULL 0

#endif



#define SRAMIN        0        //内部内存池

#define SRAMEX  1        //外部内存池





//mem1内存参数设定.mem1完全处于内部SRAM里面

#define MEM1_BLOCK_SIZE                        32                                                            //内存块大小为32字节

#define MEM1_MAX_SIZE                        17*1024 

#define MEM1_ALLOC_TABLE_SIZE        MEM1_MAX_SIZE/MEM1_BLOCK_SIZE         //内存表大小



//mem2内存参数设定.mem2的内存池处于外部SRAM里面,其他的处于内部SRAM里面

#define MEM2_BLOCK_SIZE                        32 

#define MEM2_MAX_SIZE                        17*1024

#define MEM2_ALLOC_TABLE_SIZE        MEM2_MAX_SIZE/MEM2_BLOCK_SIZE         //内存表大小

                 

                 

//内存管理控制器

struct _m_mallco_dev

{

        void (*init)(u8);                                        //初始化

        u8 (*perused)(u8);                                      //内存使用率

        u8         *membase[2];                                        //内存池 管理2个区域的内存

        u16 *memmap[2];                                         //内存管理状态表

        u8  memrdy[2];                                                 //内存管理是否就绪

};

extern struct _m_mallco_dev mallco_dev;         //在mallco.c里面定义



void mymemset(void *s,u8 c,u32 count);         //设置内存

void mymemcpy(void *des,void *src,u32 n);//复制内存 



void my_mem_init(u8 memx);                                         //内存管理初始化函数(外/内部调用)

u32 my_mem_malloc(u8 memx,u32 size);                 //内存分配(内部调用)

u8 my_mem_free(u8 memx,u32 offset);                 //内存释放(内部调用)

u8 my_mem_perused(u8 memx);                                 //获得内存使用率(外/内部调用) 

////////////////////////////////////////////////////////////////////////////////

//用户调用函数

void myfree(u8 memx,void *ptr);                          //内存释放(外部调用)

void *mymalloc(u8 memx,u32 size);                        //内存分配(外部调用)

void *myrealloc(u8 memx,void *ptr,u32 size);//重新分配内存(外部调用)

#endif

#include "at32f425_board.h"

#include "at32f425_clock.h"

#include "timer.h"

#include "malloc.h"

#include "enc28j60.h"          

#include "lwip/netif.h"

#include "lwip_comm.h"

#include "lwipopts.h"



int main(void)

{



  system_clock_config();

  at32_board_init();

  TIM3_Int_Init(9999,95);

  my_mem_init(SRAMIN);        

  lwip_comm_init();

//        printf("the lwip return value is %d\r\n",lwip_comm_init());

        if(lwip_comm_init()==0)//等待DHCP获取成功/超时溢出

        {

                printf("lwip init success.....\r\n");

        }

        else

        {

                printf("lwip init fail.....\r\n");

        }

 #if LWIP_DHCP   //使用DHCP

        while((lwipdev.dhcpstatus!=2)&&(lwipdev.dhcpstatus!=0XFF))//等待DHCP获取成功/超时溢出

        {

                lwip_periodic_handle();        //LWIP内核需要定时处理的函数

        }

 #endif        

        delay_ms(500);

  while(1)

  {

          

     lwip_periodic_handle();        //LWIP内核需要定时处理的函数

         

  }

}

u8 lwip_comm_mem_malloc(void)

{

        u32 mempsize;

        u32 ramheapsize; 

        mempsize=memp_get_memorysize();                        //得到memp_memory数组大小

        printf(" mempsiz is  %d\r\n",mempsize);

        memp_memory=mymalloc(SRAMIN,mempsize);        //为memp_memory申请内存

        printf(" memp_memory is %d\r\n",sizeof(memp_memory));

        if(!memp_memory)

        {

                printf(" mempsiz 申请失败 \r\n");

        }

        ramheapsize=LWIP_MEM_ALIGN_SIZE(MEM_SIZE)+2*LWIP_MEM_ALIGN_SIZE(4*3)+MEM_ALIGNMENT;//得到ram heap大小

        printf(" ramheapsize is  %d\r\n",ramheapsize);

        ram_heap=mymalloc(SRAMIN,ramheapsize);        //为ram_heap申请内存 

        printf(" ram_heap is  %d\r\n",sizeof(ram_heap));

        if(!ram_heap)

        {

                printf(" ram_heap 申请失败 \r\n");

        }

        if(!memp_memory||!ram_heap)//有申请失败的

        {

                lwip_comm_mem_free();

                return 1;

        }

        return 0;        

}