河北水利局项目

This commit is contained in:
2025-12-15 16:07:49 +08:00
commit f11a7c2b95
1146 changed files with 452892 additions and 0 deletions

203
shuangjia/FRAM.c Normal file
View File

@@ -0,0 +1,203 @@
#include "stm32f10x_spi.h"
#include "FRAM.h"
u8 FRAMReadWriteByte(u8 data)
{
while(SPI_I2S_GetFlagStatus(SPI3,SPI_I2S_FLAG_TXE)==RESET);
SPI_I2S_SendData(SPI3, data);
while(SPI_I2S_GetFlagStatus(SPI3,SPI_I2S_FLAG_RXNE)==RESET);
return (u8)(SPI_I2S_ReceiveData(SPI3));
}
void FRAM_GPIO_config(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
// RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO | SPI_FLASH_GPIO_CLK | FRAM_SPI_SCK_GPIO_CLK | FRAM_SPI_MISO_GPIO_CLK | FRAM_SPI_MOSI_GPIO_CLK , ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO | RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB, ENABLE);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_15;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3 | GPIO_Pin_4 |GPIO_Pin_5;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOB, &GPIO_InitStructure);
GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable,ENABLE);
// DGFLASH_CS_HIGH();
FRAM_CS_HIGH();
}
void FRAM_sRF_SPI_Config(void)
{
SPI_InitTypeDef SPI_InitStructure;
// RCC_APB2PeriphClockCmd(FRAM_SPI_CLK, ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI3, ENABLE);
FRAM_CS_HIGH();
/* Disable sRF_SPI */
SPI_Cmd(SPI3, DISABLE);
/*!< SPI configuration */
SPI_I2S_DeInit(SPI3);
SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_8;
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
SPI_InitStructure.SPI_CRCPolynomial = 7;
SPI_Init(SPI3, &SPI_InitStructure);
/*!< Enable the sRF_SPI */
SPI_Cmd(SPI3, ENABLE);
}
void FRAM_init(void)
{
FRAM_GPIO_config();
FRAM_sRF_SPI_Config();
}
void spiFlash_FRAMFlash_init(void)
{
FRAM_init();
}
void set_write_enable_latch(void)
{
FRAM_CS_LOW();
FRAMReadWriteByte(0x06);
FRAM_CS_HIGH();
}
void reset_write_enable_latch(void)
{
FRAM_CS_LOW();
FRAMReadWriteByte(0x04);
FRAM_CS_HIGH();
}
u8 read_status_reg(void)
{
u8 retVal;
FRAM_CS_LOW();
FRAMReadWriteByte(0x05);
retVal = FRAMReadWriteByte(0xAA);
FRAM_CS_HIGH();
return retVal;
}
void write_status_reg(u8 val)
{
FRAM_CS_LOW();
FRAMReadWriteByte(0x01);
FRAMReadWriteByte(val);
FRAM_CS_HIGH();
}
void read_memory_code(u16 addr, u8 *buf, u16 length)
{
FRAM_CS_LOW();
FRAMReadWriteByte(0x03);
FRAMReadWriteByte((u8)(addr/256));
FRAMReadWriteByte((u8)(addr%256));
for (u16 i = 0; i < length; i++)
{
buf[i] = FRAMReadWriteByte(0xAA);
}
FRAM_CS_HIGH();
}
void write_memory_code(u16 addr, u8 *buf, u16 length)
{
if ((read_status_reg() & 0x02) == 0)
{
set_write_enable_latch();
}
FRAM_CS_LOW();
FRAMReadWriteByte(0x02);
FRAMReadWriteByte((u8)(addr/256));
FRAMReadWriteByte((u8)(addr%256));
for (u16 i = 0; i < length; i++)
{
FRAMReadWriteByte(buf[i]);
}
FRAM_CS_HIGH();
reset_write_enable_latch();
}
void fill_FRAM_area(u16 start, u8 value, u16 length)
{
if ((read_status_reg() & 0x02) == 0)
{
set_write_enable_latch();
}
FRAM_CS_LOW();
FRAMReadWriteByte(0x02);
FRAMReadWriteByte((u8)(start/256));
FRAMReadWriteByte((u8)(start%256));
for (u16 i = 0; i < length; i++)
{
FRAMReadWriteByte(value);
}
FRAM_CS_HIGH();
reset_write_enable_latch();
}
void read_device_ID(u8 *buf)
{
FRAM_CS_LOW();
FRAMReadWriteByte(0x9F);
buf[0] = FRAMReadWriteByte(0xAA);
buf[1] = FRAMReadWriteByte(0xAA);
buf[2] = FRAMReadWriteByte(0xAA);
buf[3] = FRAMReadWriteByte(0xAA);
FRAM_CS_HIGH();
}
void fast_read_memory_code(u16 addr, u8 *buf, u16 length)//fast to 33M
{
FRAM_CS_LOW();
FRAMReadWriteByte(0x0B);
FRAMReadWriteByte((u8)(addr/256));
FRAMReadWriteByte((u8)(addr%256));
FRAMReadWriteByte(0xAA);
for (u16 i = 0; i < length; i++)
{
buf[i] = FRAMReadWriteByte(0xAA);
}
FRAM_CS_HIGH();
}
void FRAM_test(void)
{
u8 framTest[] = "I am a girl";
u8 ffff[15];
FRAM_init();
read_device_ID(framTest);
// GDflash_erase(0, 0);
//GDflash_128KByte_erase();
write_memory_code(0 , framTest, sizeof(framTest));
fast_read_memory_code(0, ffff, sizeof(framTest));
}

75
shuangjia/FRAM.h Normal file
View File

@@ -0,0 +1,75 @@
#ifndef _FRAM_H_
#define _FRAM_H_
#include "stm32f10x.h"
#include "stm32f10x_gpio.h"
//#define FRAM_SPI SPI3
//#define FRAM_SPI_CLK RCC_APB2Periph_SPI1
#define FRAM_SPI_SCK_PIN GPIO_Pin_3
#define FRAM_SPI_SCK_GPIO_PORT GPIOB
#define FRAM_SPI_SCK_GPIO_CLK RCC_APB2Periph_GPIOB
#define FRAM_SPI_MISO_PIN GPIO_Pin_4
#define FRAM_SPI_MISO_GPIO_PORT GPIOB
#define FRAM_SPI_MISO_GPIO_CLK RCC_APB2Periph_GPIOB
#define FRAM_SPI_MOSI_PIN GPIO_Pin_5
#define FRAM_SPI_MOSI_GPIO_PORT GPIOA
#define FRAM_SPI_MOSI_GPIO_CLK RCC_APB2Periph_GPIOB
#define SPI_FLASH_CS_PIN GPIO_Pin_15
#define SPI_FLASH_GPIO_PORT GPIOA
#define SPI_FLASH_GPIO_CLK RCC_APB2Periph_GPIOA
/*
#define FRAM_CS_PIN GPIO_Pin_0
#define FRAM_CS_GPIO_PORT GPIOB
#define FRAM_CS_GPIO_CLK RCC_APB2Periph_GPIOB
*/
#if 0
#define FRAM_CS_PIN GPIO_Pin_4
#define FRAM_CS_GPIO_PORT GPIOA
#define FRAM_CS_GPIO_CLK RCC_APB2Periph_GPIOA
#define SPI_FLASH_CS_PIN GPIO_Pin_0
#define SPI_FLASH_GPIO_PORT GPIOB
#define SPI_FLASH_GPIO_CLK RCC_APB2Periph_GPIOB
#endif
#define DGFLASH_CS_LOW() GPIO_ResetBits(SPI_FLASH_GPIO_PORT, GPIO_Pin_15)
#define DGFLASH_CS_HIGH() GPIO_SetBits(SPI_FLASH_GPIO_PORT, GPIO_Pin_15)
#define FRAM_CS_LOW() GPIO_ResetBits(SPI_FLASH_GPIO_PORT, GPIO_Pin_15)
#define FRAM_CS_HIGH() GPIO_SetBits(SPI_FLASH_GPIO_PORT, GPIO_Pin_15)
void FRAM_init(void);
void set_write_enable_latch(void);
void reset_write_enable_latch(void);
u8 read_status_reg(void);
void write_status_reg(u8 val);
void read_memory_code(u16 addr, u8 *buf, u16 length);
void write_memory_code(u16 addr, u8 *buf, u16 length);
void read_device_ID(u8 *buf);
void fast_read_memory_code(u16 addr, u8 *buf, u16 length);
uint8_t sFLASH_SendByte(uint8_t byte);
u8 FRAMReadWriteByte(u8 data);
void spiFlash_FRAMFlash_init(void);
void fill_FRAM_area(u16 start, u8 value, u16 length);
#endif

618
shuangjia/SPI_Flash.c Normal file
View File

@@ -0,0 +1,618 @@
/**********************************************************************
45DB011 Max 20MHz clock, using 8 MHz click, 512 Pages (264 Bytes/Page)
MX25l8006EM2C 台湾旺宏 8M字节 86/66/33MHZ 页256Byte 最大5ms 10万次擦写
**********************************************************************/
//#include "stm32f10x_lib.h"
#include "SPI_Flash.h"
#include "Flash.h"
#define FLASH_PAGE_SIZE 256
__no_init unsigned char spi_buf[FLASH_PAGE_SIZE]@0x20004000;//[256];;
//__no_init SPI_InitTypeDef SPI_InitStructure@0x20006000;//[256];;
//__no_init GPIO_InitTypeDef GPIO_InitStructure@0x20006100;//[256];;
//unsigned int Update_Len;
//unsigned int page;
//unsigned char* Update_Ptr;
//unsigned char Update_Data;
unsigned char m_ucFlashBuf[FLASH_PAGE_SIZE]={0};
//unsigned char m_ucFlashBuf[FLASH_PAGE_SIZE];
extern u16 FlashDataRAM[];
//0XC2 0X13
void FlashReadID(u8 *Data)@ "FLASHCODE"
{
u8 i;
Select_Flash();
SPI_Flash_SendByte(0x90);
SPI_Flash_SendByte(0x00);
SPI_Flash_SendByte(0x00);
SPI_Flash_SendByte(0x00);
for(i = 0; i < 2; i++)
{
Data[i] = SPI_Flash_ReadByte();
}
NotSelect_Flash();
}
/*******************************************************************************
* Function Name : SPI_FLASH_Init
* Description : Initializes the peripherals used by the SPI FLASH driver.
* Input : None
* Output : None
* Return : None
*******************************************************************************/
void SPI_Flash_Init(void)@ "FLASHCODE"
{
SPI_InitTypeDef SPI_InitStructure;
GPIO_InitTypeDef GPIO_InitStructure;
/* Enable SPI1 GPIOA and GPIOB clocks */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2,ENABLE);
/* Configure SPI1 pins: NSS, SCK, MISO and MOSI */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13 | GPIO_Pin_14| GPIO_Pin_15;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_Init(GPIOB, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_Init(GPIOB, &GPIO_InitStructure);
/* Deselect the FLASH: Chip Select high */
NotSelect_Flash();
/* SPI1 configuration */
SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;
SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;
SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_4; //divied by 2, SPI clock is (32M/2)/2=8MHz
//SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_4; // 4m
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
SPI_InitStructure.SPI_CRCPolynomial = 7;
SPI_Init(SPI2, &SPI_InitStructure);
/* Enable SPI1 */
SPI_Cmd(SPI2, ENABLE);
//flash_write_enable();
}
/*******************************************************************************
* Function Name : SPI_FLASH_ReadByte
* Description : Reads a byte from the SPI Flash.
* This function must be used only if the Start_Read_Sequence
* function has been previously called.
* Input : None
* Output : None
* Return : Byte Read from the SPI Flash.
*******************************************************************************/
//u8 SPI_Flash_ReadByte(void)@ "FLASHCODE"
//{
// return (SPI_Flash_SendByte(Dummy_Byte));
//}
unsigned char SPI_Flash_ReadByte(void)@ "FLASHCODE"
{
return (SPI_Flash_SendByte(Dummy_Byte));
}
/*******************************************************************************
* Function Name : SPI_FLASH_SendByte
* Description : Sends a byte through the SPI interface and return the byte
* received from the SPI bus.
* Input : byte : byte to send.
* Output : None
* Return : The value of the received byte.
*******************************************************************************/
u8 SPI_Flash_SendByte(u8 byte)@ "FLASHCODE"
{
/* Loop while DR register in not emplty */
while(SPI_GetFlagStatus(SPI2, SPI_FLAG_TXE) == RESET);
/* Send byte through the SPI1 peripheral */
SPI_SendData(SPI2, byte);
/* Wait to receive a byte */
while(SPI_GetFlagStatus(SPI2, SPI_FLAG_RXNE) == RESET);
/* Return the byte read from the SPI bus */
return SPI_ReceiveData(SPI2);
}
/*
void FlashPageEarse(u16 page)@ "FLASHCODE"
{
FlashWaitBusy();
Select_Flash();
SPI_Flash_SendByte(PAGE_ERASE);
SPI_Flash_SendByte((u8)(page >> 6));
SPI_Flash_SendByte((u8)(page << 2));
SPI_Flash_SendByte(Dummy_Byte);
//|-23-|-22-|21|20|19|18|17|16|15|14|13|12|11|10|9|8|7|6|5|4|3|2|1|0|
//|2个无关位|------------12位页地址-------------|----10个无关位-----|
NotSelect_Flash();
}
*/
void Delay_100us_1(void)
{
unsigned int j;
for(j=0; j<424; j++)
{
_NOP();
_NOP();
_NOP();
_NOP();
_NOP();
_NOP();
_NOP();
_NOP();
}
}
void FlashPageRead(unsigned int wPage,unsigned char *Update_Ptr)@ "FLASHCODE"
{
unsigned short i=0;
unsigned int uiAddr=0;
//256 8006E --> 4096 page
uiAddr = (unsigned int)(wPage*256);
FlashWaitBusy();
Select_Flash();
SPI_Flash_SendByte(0x03);
SPI_Flash_SendByte( (u8)((uiAddr>>16)&0xFF) );
SPI_Flash_SendByte( (u8)((uiAddr>>8)&0xFF) );
SPI_Flash_SendByte( (u8)((uiAddr)&0xFF) );
for (i = 0;i < 256; i++)
{
*Update_Ptr++=SPI_Flash_ReadByte();
}
NotSelect_Flash();
}
void flash_write_enable(void)
{
unsigned char state_reg=0x00;
while((state_reg&0x02) == 0x00)
{
Select_Flash();
SPI_Flash_SendByte(0x06);
NotSelect_Flash();
Delay_100us_1();
Select_Flash();
SPI_Flash_SendByte(FLASH_STATUS);
state_reg=SPI_Flash_ReadByte();
NotSelect_Flash();
if( (state_reg&0x02) == 0x01 )
{
break;
}
Delay_100us_1();
}
}
void FlashWaitBusy(void)@ "FLASHCODE"
{
unsigned char state_reg=0x00;
while( 1 )
{
Select_Flash();
SPI_Flash_SendByte(0x05);
state_reg=SPI_Flash_ReadByte();
NotSelect_Flash();
//ClearWatchdog();
{
//WDI_10;
//IWDG_WriteAccessCmd(IWDG_WriteAccess_Enable);
//IWDG_ReloadCounter();
}
if( (state_reg&0x01) == 0x00)
{
break;
}
}
}
void UClearWatchdog(void)@ "FLASHCODE"
{
unsigned char k;
// P6DIR_bit.P6DIR_1 = 1;
// P6OUT_bit.P6OUT_1 = 1;
WDI_1;
for (k=0;k<200;k++)//0
{
_NOP();
}
WDI_0;
// P6OUT_bit.P6OUT_1 = 0;
// WDTCTL = WDTPW + WDTSSEL + WDTCNTCL; //enable and clear watchdog, 2006-11-21
IWDG_ReloadCounter();
}
//read flash data within page
void D_spiReadFlashPage(unsigned int iadr,unsigned short ilen,unsigned char *pdin_data)//@ "FLASHCODE"
{
unsigned int i,tn;
tn=ilen+(iadr%FLASH_PAGE_SIZE);
FlashPageRead(iadr/FLASH_PAGE_SIZE,&spi_buf[0]);
for(i=(iadr%FLASH_PAGE_SIZE);i<tn;++i)
{
*pdin_data=spi_buf[i];
pdin_data++;
}
}
/**************************************************************************
read flash, not care iit's more than one page size or not, 2010-10-13
***************************************************************************/
void D_spiFlashRead(u32 iaddr,u16 length, u8 *pdin_data)//@ "FLASHCODE"
{
u16 i, page, tn, remain;
page=iaddr/FLASH_PAGE_SIZE;
remain=iaddr%FLASH_PAGE_SIZE;
if (remain!=0)
{
FlashPageRead(iaddr/FLASH_PAGE_SIZE,&spi_buf[0]);
tn=remain+length;
if (tn<FLASH_PAGE_SIZE)
{
for(i=remain;i<tn;++i)
{
*pdin_data=spi_buf[i];
pdin_data++;
}
return; //finished read all data
}
else
{
for(i=remain;i<FLASH_PAGE_SIZE;++i)
{
*pdin_data=spi_buf[i];
pdin_data++;
}
length = length-(FLASH_PAGE_SIZE-remain);
iaddr=iaddr+(FLASH_PAGE_SIZE-remain);
}
}
//keep reading the next page
while (length>FLASH_PAGE_SIZE)
{
FlashPageRead(page,&spi_buf[0]);
for(i=0;i<FLASH_PAGE_SIZE;++i)
{
*pdin_data++=spi_buf[i];
}
length-=FLASH_PAGE_SIZE;
page++;
}
if(0 == length%FLASH_PAGE_SIZE)
{
FlashPageRead(page,&spi_buf[0]);
for(i=0;i<FLASH_PAGE_SIZE;++i)
{
*pdin_data++=spi_buf[i];
}
}
else
{
//read the remained data from the last page
FlashPageRead(page,&spi_buf[0]);
for(i=0;i<(length%FLASH_PAGE_SIZE);++i)
{
*pdin_data++=spi_buf[i];
}
}
}
/////////////////////////////////////////////////////////////////////////////////
//void D_spiWriteIIC(unsigned int iadr, unsigned short nbyte, unsigned char* psrc_data)//@ "FLASHCODE"
void D_spiWriteFlash(unsigned int iadr, unsigned short nbyte, unsigned char* psrc_data)//@ "FLASHCODE"
{
unsigned int i,tn;
tn=nbyte+(iadr%FLASH_PAGE_SIZE);
for(i=(iadr%FLASH_PAGE_SIZE);i<tn;++i)
{
spi_buf[i]=*psrc_data;
psrc_data++;
}
FlashPageWrite(iadr/FLASH_PAGE_SIZE,spi_buf);
}
/****************************************************************************************************
Write flash, don't care length is more than one page or not
****************************************************************************************************/
void D_spiFlashWrite(u32 iadr, u16 length, u8 *psrc_data)//@ "FLASHCODE"
{
u16 i=0,page=0;
page=iadr/FLASH_PAGE_SIZE;
while (length>FLASH_PAGE_SIZE)
{
for(i=0;i<FLASH_PAGE_SIZE;++i)
{
spi_buf[i]=*psrc_data++;
}
FlashPageWrite(page,spi_buf);
length-=FLASH_PAGE_SIZE;
page++;
}
//read the last page of data from flash
flash_page_read(page, spi_buf);
for(i=0;i<length;++i)
{
spi_buf[i]=*psrc_data++;
}
FlashPageWrite(page,spi_buf);
}
void FlashPageWrite(u16 wPage,u8 *Data)//@ "FLASHCODE" //写一整页页范围0-4095
{
unsigned short i=0;
unsigned int uiAddr=0;
unsigned short wSector=0;
unsigned short wStartAddr=0;
unsigned char* m_flash_sector=0;
m_flash_sector=(unsigned char*)FlashDataRAM;
wStartAddr = (wPage%16)*256;
wSector = (unsigned short)(wPage/16);
uiAddr = wSector*4096;
flash_fast_read( uiAddr, 4096 );
flash_sector_erase(uiAddr);
for( i=0; i<256; i++ )
{
m_flash_sector[wStartAddr+i]=Data[i];
}
flash_sector_write(wSector*4096, 4096);
}
//256 8006E --> 4096 page
void flash_page_write(u16 wPage,u8 *Data)
{
unsigned short i=0;
unsigned int uiAddr=0;
uiAddr = (unsigned int)(wPage*256);
FlashWaitBusy();
flash_write_enable();
Select_Flash();
SPI_Flash_SendByte(0x02);
SPI_Flash_SendByte( (u8)((uiAddr>>16)&0xFF) );
SPI_Flash_SendByte( (u8)((uiAddr>>8)&0xFF) );
SPI_Flash_SendByte( (u8)((uiAddr)&0xFF) );
for (i = 0;i < 256; i++)
{
SPI_Flash_SendByte(Data[i]);
}
NotSelect_Flash();
}
//256 8006E --> 4096 page
void flash_page_read(unsigned short wPage, unsigned char* pData)
{
unsigned short i=0;
unsigned int uiAddr=0;
uiAddr = (unsigned int)(wPage*256);
FlashWaitBusy();
Select_Flash();
SPI_Flash_SendByte(0x03);
SPI_Flash_SendByte( (u8)((uiAddr>>16)&0xFF) );
SPI_Flash_SendByte( (u8)((uiAddr>>8)&0xFF) );
SPI_Flash_SendByte( (u8)((uiAddr)&0xFF) );
for (i = 0;i < 256; i++)
{
pData[i]=SPI_Flash_ReadByte();
}
NotSelect_Flash();
}
void flash_sector_erase(unsigned int uiAddr)
{
FlashWaitBusy();
flash_write_enable();
Select_Flash();
SPI_Flash_SendByte(0x20);
SPI_Flash_SendByte( (u8)((uiAddr>>16)&0xFF) );
SPI_Flash_SendByte( (u8)((uiAddr>>8)&0xFF) );
SPI_Flash_SendByte( (u8)((uiAddr)&0xFF) );
NotSelect_Flash();
}
void flash_sector_write(unsigned int uiAddr, unsigned short wLen)
{
unsigned short i=0;
unsigned short wPage=0;
unsigned char* m_flash_sector=0;
m_flash_sector=(unsigned char*)FlashDataRAM;
wPage = (unsigned short)(uiAddr/256);
for( i=0; i<16; i++ )
{
memcpy( &m_ucFlashBuf[0], &m_flash_sector[ 256*i ], 256 );
flash_page_write( wPage, &m_ucFlashBuf[0] );
wPage++;
}
SPI_Flash_SendByte(0x04); //dis write
}
void flash_fast_read( unsigned int uiAddr, unsigned short wLen )
{
unsigned short i=0;
unsigned char* m_flash_sector=0;
m_flash_sector=(unsigned char*)FlashDataRAM;
if(wLen>4096)
{
return;
}
FlashWaitBusy();
Select_Flash();
SPI_Flash_SendByte(0x0B);
SPI_Flash_SendByte( (u8)((uiAddr>>16)&0xFF) );
SPI_Flash_SendByte( (u8)((uiAddr>>8)&0xFF) );
SPI_Flash_SendByte( (u8)((uiAddr)&0xFF) );
SPI_Flash_SendByte( 0x00 );
for (i = 0;i < wLen; i++)
{
m_flash_sector[i]=SPI_Flash_ReadByte();
}
NotSelect_Flash();
}
void FlashWaidBusy(void)@ "FLASHCODE"
{
unsigned char state_reg=0x00;
while( 1 )
{
Select_Flash();
SPI_Flash_SendByte(0x05);
state_reg=SPI_Flash_ReadByte();
NotSelect_Flash();
UClearWatchdog();
if( (state_reg&0x01) == 0x00)
{
break;
}
}
}
void Flash_Page_Read(unsigned int wPage,unsigned char *Update_Ptr)@ "FLASHCODE"
{
unsigned short i=0;
unsigned int uiAddr=0;
//256 8006E --> 4096 page
uiAddr = (unsigned int)(wPage*256);
FlashWaidBusy();
Select_Flash();
SPI_Flash_SendByte(0x03);
SPI_Flash_SendByte( (u8)((uiAddr>>16)&0xFF) );
SPI_Flash_SendByte( (u8)((uiAddr>>8)&0xFF) );
SPI_Flash_SendByte( (u8)((uiAddr)&0xFF) );
for (i = 0;i < 256; i++)
{
*Update_Ptr++=SPI_Flash_ReadByte();
}
NotSelect_Flash();
}
/**
* @brief Write block of data to the SPI FLASH.
* @param WriteAddr: FLASH's internal address to write to.
* @param pBuffer: pointer to the buffer containing the data to be written to the FLASH.
* @param length: number of bytes to write to the FLASH.
* @retval None.
*/
void hal_sFLASH_WriteData(u32 WriteAddr, u8 *pBuffer, u16 length)
{
u16 pageLength = 0;
while (length > 0)
{
if ((WriteAddr & sFLASH_PAGE_MASK) == ((WriteAddr + length) & sFLASH_PAGE_MASK))
{
pageLength = length;
}
else
{
pageLength = ((WriteAddr + sFLASH_PAGE_SIZE) & sFLASH_PAGE_MASK) - WriteAddr;
}
FlashWaitBusy();
flash_write_enable();
Select_Flash();
SPI_Flash_SendByte(0x02);
SPI_Flash_SendByte((u8)((WriteAddr >> 16) & 0xFF));
SPI_Flash_SendByte((u8)((WriteAddr >> 8) & 0xFF));
SPI_Flash_SendByte((u8)((WriteAddr) & 0xFF));
for (u16 i = 0; i < pageLength; i++)
{
SPI_Flash_SendByte(pBuffer[i]);
}
NotSelect_Flash();
WriteAddr += pageLength;
pBuffer += pageLength;
length -= pageLength;
}
}
/**
* @brief Read block of data to the SPI FLASH.
* @param ReadAddr: FLASH's internal address to read from.
* @param pBuffer: pointer to the buffer containing the data to be read from the FLASH.
* @param length: number of bytes to read from the FLASH.
* @retval None.
*/
void hal_sFLASH_ReadData(u32 ReadAddr, u8 *pBuffer, u16 length)
{
FlashWaitBusy();
flash_write_enable();
Select_Flash();
SPI_Flash_SendByte(0x03);
SPI_Flash_SendByte((u8)((ReadAddr >> 16) & 0xFF));
SPI_Flash_SendByte((u8)((ReadAddr >> 8) & 0xFF));
SPI_Flash_SendByte((u8)((ReadAddr) & 0xFF));
for (u16 i = 0; i < length; i++)
{
pBuffer[i] = SPI_Flash_SendByte(Dummy_Byte);
}
NotSelect_Flash();
}

61
shuangjia/SPI_Flash.h Normal file
View File

@@ -0,0 +1,61 @@
#ifndef _SPI_FLASH_H_
#define _SPI_FLASH_H_ 1
#include "Flash.h"
//===========ATMEL 081D flash==================
#define FLASH_CHREAD 0x0B
#define FLASH_CLREAD 0x03
#define FLASH_PREAD 0xD2
#define FLASH_BUFWRITE1 0x84
#define FLASH_IDREAD 0x9F
//#define FLASH_STATUS 0xD7
#define PAGE_ERASE 0x81
//#define PAGE_READ 0xD2 //011D 264
#define PAGE_READ 0x52 //161D 528
#define MM_PAGE_TO_B1_XFER 0x53 // 将主存储器的指定页数据加载到第一缓冲区
#define BUFFER_2_WRITE 0x87 // 写入第二缓冲区
#define B2_TO_MM_PAGE_PROG_WITH_ERASE 0x86 // 将第二缓冲区的数据写入主存储器(擦除模式)
#define Dummy_Byte 0xA5
//===========MXIC 8006E flash==================
#define FLASH_STATUS 0x05
//#define PAGE_READ
/* Select SPI FLASH: ChipSelect pin low */
#define Select_Flash() GPIO_ResetBits(GPIOB, GPIO_Pin_12)
/* Deselect SPI FLASH: ChipSelect pin high */
#define NotSelect_Flash() GPIO_SetBits(GPIOB, GPIO_Pin_12)
#define sFLASH_PAGE_MASK 0xFFF00
#define sFLASH_PAGE_SIZE 0x100
#define DOWN_ONE_FRAME_LENGTH 200 //2013-03-19
void Delay_100us_1(void);
void SPI_Flash_Init(void); //SPI初始化
u8 SPI_Flash_ReadByte(void); //flash操作基本函数读一个字节
u8 SPI_Flash_SendByte(u8 byte);
//void SPI_Flash_SendByte(unsigned char Update_Data); // FLASH操作基本函数发送一个字节
//void FlashPageEarse(u16 page); //擦除指定的页,页范围0-4095
void FlashPageRead(unsigned int wPage,unsigned char *Update_Ptr); //读取整页页范围0-4095
void FlashPageWrite(u16 wPage,u8 *Data); //写一整页页范围0-4095
void flash_page_read(unsigned short wPage, unsigned char* pData);
void FlashWaidBusy(void);
void flash_write_enable(void);
void FlashWaitBusy(void); //Flash忙检测
void FlashReadID(u8 *ProdustID); //读取flashID四个字节
void D_spiWriteFlash(unsigned int iadr, unsigned short nbyte, unsigned char* psrc_data);
void D_spiReadFlashPage(unsigned int iadr,unsigned short ilen,unsigned char *pdin_data);
void D_spiFlashRead(u32 iaddr,u16 length, u8 *pdin_data);
void D_spiFlashWrite(u32 iadr, u16 length, u8 *psrc_data);
void UClearWatchdog(void);//@ "FLASHCODE"
void Flash_Page_Read(unsigned int wPage,unsigned char *Update_Ptr);
void flash_sector_erase(unsigned int uiAddr);
void flash_sector_write(unsigned int uiAddr, unsigned short wLen);
void flash_fast_read( unsigned int iAddr, unsigned short wLen );
#endif

34
shuangjia/addryw.c Normal file
View File

@@ -0,0 +1,34 @@
//#include "stdafx.h"
#include "addryw.h"
extern bool read_addr(u8 *addrbuf );
//static u8 address[ADDR_LEN] = {0x12,0x34,0x56,0x99,0x05};
//static u8 address2[ADDR_LEN] = {0x12,0x34,0x56,0x99,0x05};
void addr_set(u8 * addr)
{
// memmove(address,addr,ADDR_LEN);
//memmove(address2,address,ADDR_LEN);
// address[4] = address2[0];
// address[3] = address2[1];
// address[2] = address2[2];
// address[1] = address2[3];
// address[0] = address2[4];
// int kkk = 0;
}
void addr_write()
{
}
void addr_read()
{
// read_addr(address);
}

12
shuangjia/addryw.h Normal file
View File

@@ -0,0 +1,12 @@
#ifndef __ADDRYW__
#define __ADDRYW__
#include "global.h"
#include "Basedefine.h"
void addr_set(); //设置地址
u8 * addr_get(); //得到地址
void addr_write(); //地址写文件
void addr_read(); //地址读文件
#endif

52
shuangjia/amtdl.c Normal file
View File

@@ -0,0 +1,52 @@
#include "FreeRTOS.h"
#include "task.h"
#include "uart.h"
#include "sjframe.h"
//°¢ÃÀÌØÍ¸´«³ÌÐò¡£
//
extern bool amt_process(u8 * val,u8 len);
static u8 recv_buff[256];
static u8 recv_len = 0;
u8 smt_get_len()
{
return recv_len;
}
u8 * smt_get_val()
{
return recv_buff;
}
void smt_set_value(u8 * val,u8 len)
{
memmove(recv_buff,val,len);
recv_len = len;
}
void amt_task_1(u8 * val,u8 len)
{
memset(recv_buff,0,sizeof(recv_buff));
recv_len = 0;
amt_process(val,len);
}
void amt_task(u8 * val)
{
//0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
//68 13 00 XX XX 1A XX XX XX XX XX
amt_task_1(&val[12],val[11]);
}

12
shuangjia/file.c Normal file
View File

@@ -0,0 +1,12 @@
//#include "stdafx.h"
#include "file.h"
#include "metertable.h"
#include "rptime.h"
#include "doc.h"
void file_read()
{
addr_read();
ipport_read();
ipport_init();
}

9
shuangjia/file.h Normal file
View File

@@ -0,0 +1,9 @@
#ifndef __FILE1__
#define __FILE1__
#include "Basedefine.h"
#include "global.h"
void file_read();
#endif

55
shuangjia/filesave.c Normal file
View File

@@ -0,0 +1,55 @@
//#include "stdafx.h"
#include "filesave.h"
//#include "Flash.h"
extern void flash_onepage_write(u32 addr,u8 * val,u16 len);
extern void flash_onepage_read(u32 addr,u8 * val,u16 len);
extern void flash_doc_write(u32 addr,u8 * val,u16 len);
extern void flash_doc_read(u32 addr,u8 * val,u16 len);
#define FLASH_CONCENTADDR_ADDR (0*4096) //集中器地址 //1
#define FLASH_IPPORT_ADDR (5*4096) //集中器网络参数 //4
//16 * 4096
#define FLASH_CONCENTDLRESULT_ADDR (6*4096) //集中器数据 // 200页
extern void GDflash_read_datas(u32 startAddr, u8 *buf, u32 length, bool fastRead);
extern void GDflash_page_program(u32 startAddr, u8 *buf, u16 length, bool fastWrite);
void update_write(u32 index,u8 * val,u8 len)
{
GDflash_page_program(FLASH_CONCENTDLRESULT_ADDR+index*256 , val, len,TRUE);
}
void update_read(u32 index,u8 * val,u8 len)
{
GDflash_read_datas(FLASH_CONCENTDLRESULT_ADDR+index*256 , val, len,TRUE);
}
//集中器地址
void addr_writefile(u8 * val,u8 len)
{
flash_onepage_write(FLASH_CONCENTADDR_ADDR,val,len);
}
//ip和端口
void ipport_writefile(u8 * val,u8 len)
{
flash_onepage_write(FLASH_IPPORT_ADDR,val,len);
}
void ipport_readfile(u8 * val,u8 len)
{
flash_onepage_read(FLASH_IPPORT_ADDR,val,len);
}

38
shuangjia/filesave.h Normal file
View File

@@ -0,0 +1,38 @@
#ifndef __FILESAVE__
#define __FILESAVE__
#include "Basedefine.h"
#include "global.h"
void addr_writefile(u8 * val,u8 len);
void addr_readfile(u8 * val,u8 len);
void heart_writefile(u8 * val,u8 len);
void heart_readfile(u8 * val,u8 len);
void isrp_writefile(u8 * val,u8 len);
void isrp_readfile(u8 * val,u8 len);
void netpara_writefile(u8 * val,u8 len);
void netpara_readfile(u8 * val,u8 len);
void rptime_writefile(u8 * val,u8 len);
void rptime_readfile(u8 * val,u8 len);
void doc_writefile(u8 * val,u16 len);
void doc_readfile(u8 * val,u16 len);
void dldata_writefile(u16 id,u8 * val,u16 len);
void dldata_readfile(u16 id,u8 * val,u16 len);
void ipport_writefile(u8 * val,u8 len);
void ipport_readfile(u8 * val,u8 len);
/*
void file_meter_write(u8 * val,u16 len);
void file_meter_read(u8 * val,u16 len);
void file_metertablenum_write(u8 * val,u16 len);
void file_metertablenum_read(u8 * val,u16 len);
*/
#endif

30
shuangjia/global.h Normal file
View File

@@ -0,0 +1,30 @@
#ifndef __GLOBAL1__
#define __GLOBAL1__
//#define WINDOW_STATE
#define ADDR_LEN (5)
#include "Basedefine.h"
#include <intrinsics.h>
#include <stdio.h>
#include <string.h>
//#include <intrins.h>
#include <ctype.h>
#include <stdlib.h>
//typedef unsigned short u16;
//typedef unsigned char u8;
//typedef unsigned int u32;
#include "addryw.h"
#include "file.h"
//#include "localtime.h"
#include "load.h"
#include "filesave.h"
#include "poweroffon.h"
#include "gprs.h"
#include "sjframe.h"
#endif

2642
shuangjia/gprs.c Normal file

File diff suppressed because it is too large Load Diff

213
shuangjia/gprs.h Normal file
View File

@@ -0,0 +1,213 @@
/*************************************************************
* SOON WRITING *
* Copyright (c) Robulink, 2014-2024 *
*************************************************************/
/* Create Date: 2014/08/20
*
* Modify Record:
* <date> <author> <version> <desc>
* -------------------------------------------------------------------
* 2014/08/20 SOON 1.0 Create the file.
*/
/**
******************************************************************************
* @file gprs.h
* @author SOON
* @version V1.0.0
* @date 2014-08-20
* @brief GPRS 通信处理任务头文件
*
******************************************************************************
* @attention
*
* <h2><center>&copy; COPYRIGHT 2014 Robulink </center></h2>
******************************************************************************
*/
#ifndef __GPRS_H__
#define __GPRS_H__
#include "Basedefine.h"
#include "global.h"
// 宏定义
//#define GPRS_DEBUG_SWITCH 0
#define CPU_INT08U u8
#define CPU_INT16U u16
#define CPU_INT32U u32
#define CPU_INT16S int
#define NULLP NULL
#define CPU_CHAR char
#define OS_SEM int
#define CPU_INT08S char
#define CPU_TS int
#define OS_ERR int
#define OS_MSG_SIZE int
/* 模块返回值类型*/
typedef enum gprs_cmd_ack_e
{
GPRS_CMD_ACK_OK = (0x00000000)
, GPRS_CMD_ACK_ERR
, GPRS_CMD_ACK_PBREADY
, GPRS_CMD_ACK_MYCCID
, GPRS_CMD_ACK_CPIN_READY
, GPRS_CMD_ACK_CSQ
, GPRS_CMD_ACK_CREG
, GPRS_CMD_ACK_MYTYPE
, GPRS_CMD_ACK_MYURCACT
, GPRS_CMD_ACK_MYNETOPEN
, GPRS_CMD_ACK_MYURCREAD
, GPRS_CMD_ACK_MYNETREAD
, GPRS_CMD_ACK_MYNETWRITE
, GPRS_CMD_ACK_MYNETACK
, GPRS_CMD_ACK_MYNETCLOSE
, GPRS_CMD_ACK_MAX
} gprs_cmd_ack_t ;
// 数据结构
#define GPRS_CMD_LEN 256
#define GPRS_MAX_FLAG 255
#define MIN_MYURC_LEN 2
#define GPRS_CCID_LEN 20
#define GPRS_GMR_LEN 44
#define NET_STATE_DISCONNECT 0
#define NET_STATE_CONNECT 1
//#define MAX_GPRSSEND_TABLE 2
#define PORT_STATUS_IDLE 0
#define PORT_STATUS_CONNECTED 1
#define GPRS_AT_STATUS_IDLE 0
#define GPRS_AT_STATUS_SEND 1
#define GPRS_AT_STATUS_ACKERR 2
#define GPRS_AT_STATUS_ACKOK 3
//-----STATE2/STATE1/STATE0
#define MODULE_STATE_NOMODULE 7 //无模块
#define MODULE_STATE_AT 6 //有模块响应AT
#define MODULE_STATE_NOTAT 4 //有模块不响应AT
#define MODULE_STATE_RESERVE 0 //预留
typedef struct{
CPU_INT08U *cmd_snd; //发送命令
CPU_INT08U *good_rcv; //期待正确应答,可以为空
CPU_INT08U status; //00没有发送01已发送02收到错误应答03收到正确应答
}gprs_at_cmd;
typedef struct{
CPU_INT08U send_port;
CPU_INT16U len;
}gprs_msg_head;
#define MAX_NET_LEN 1500
#define MAX_GPRSSEND_BUF 2000
#define TYPE_TCP_CLIENT 0
#define TYPE_TCP_SERVER 1
#define TYPE_UDP 2
/*
typedef struct {
//CPU_INT08U used; // 是否有效
CPU_INT16U len; // 长度信息
CPU_INT08U data[MAX_GPRSSEND_BUF]; // 数据缓存字节数
}gprs_send_entry;
typedef struct{
gprs_send_entry databuff[MAX_GPRSSEND_TABLE]; // 支持表项
CPU_INT08U count; // 几包有效数据
CPU_INT08U head; // 数据缓存队列头指针位置
CPU_INT08U tail; // 数据缓存队列尾指针位置
OS_SEM* buf_sem;
OS_SEM* nstored;
}gprssend_ctrl;
*/
typedef struct{
CPU_INT08U databuff[MAX_GPRSSEND_BUF]; // 支持表项
CPU_INT16U count; // 几包有效数据
CPU_INT16U head;
CPU_INT16U tail;
CPU_INT16U used_len;
// OS_SEM buf_sem;
}gprssend_ctrl;
/****************************函数对外声明******************************/
extern void task_gprs(void *pParam);//
//extern INT16S gprs_handle_urc(void* pst_ctrl, CPU_INT16U used_len);
//extern INT16S gprs_sendbuf_send(CPU_INT08U *pmsg, CPU_INT08U * data, CPU_INT16U len);
/****************************变量对外声明******************************/
extern gprssend_ctrl gprs_send_ctrl;
//extern OS_SEM gprs_count_sem;
extern CPU_INT08U gprs_init_flag;
extern CPU_INT08U gprs_connect_flag;
extern CPU_INT08U gprs_socket_flag;
//extern OS_SEM* gprs_read0_sem;
//extern gprs_byte_count gbc;
extern CPU_INT08U config_server_flag;
extern CPU_INT08U server_ip_main[16];
extern CPU_INT08U server_ip_bak[16];
extern CPU_INT16U server_port_main;
extern CPU_INT16U server_port_bak;
//extern void gprs_online_off();
//extern void gprs_online_on();
//extern void gprs_remote_revled_on();
//extern void gprs_remote_revled_off();
//extern void gprs_remote_sendled_on();
//extern void gprs_remote_sendled_off();
CPU_INT16S gprs_sendbuf_send(CPU_INT08U *pmsg, CPU_INT08U * data, CPU_INT16U len);
void gprs_get_CCID(CPU_INT08U* buf);
bool gprs_connect_status();
void gprs_send_flag();
/* AFN04_F3结构体 */
typedef struct
{
CPU_INT08U ip1;
CPU_INT08U ip2;
CPU_INT08U ip3;
CPU_INT08U ip4;
CPU_INT16U port;
}ip_and_port;
typedef struct
{
ip_and_port primary;
ip_and_port reserve;
CPU_INT08U APN[16];
CPU_INT08U user[30];
CPU_INT08U password[30];
}afn04_F3_st;
void gprs_send_flag();
void gprs_send_proc_direct(u8 * val,u16 len);
void ipport_read();
void ipport_write();
void ipport_init();
#endif

369
shuangjia/hal_GDflash.c Normal file
View File

@@ -0,0 +1,369 @@
#include "hal_gdflash.h"
#include "stm32f10x.h"
#include "FRAM.h"
/*****************************************************************************
Prototype : hal_sRF_SPI_Config
Description : none
Input : void
Output : None
Return Value :
Date : 2014/3/15
Author : Barry
*****************************************************************************/
void GDflash_init(void)
{
spiFlash_FRAMFlash_init();
}
/*****************************************************************************
Prototype : spiReadWriteByte
Description : spi basic function
Input : u8 data
Output : None
Return Value :
Date : 2014/3/15
Author : Barry
*****************************************************************************/
u8 GDflash_ReadWriteByte(u8 data)
{
return FRAMReadWriteByte(data);
}
void GDflash_write_enable(bool enable)
{
DGFLASH_CS_LOW();
if (enable)
{
GDflash_ReadWriteByte(GDFLASH_WRITE_ENABLE);
}
else
{
GDflash_ReadWriteByte(GDFLASH_WRITE_DISABLE);
}
DGFLASH_CS_HIGH();
}
u8 GDflash_read_status_reg(void)
{
u8 status_value;
DGFLASH_CS_LOW();
GDflash_ReadWriteByte(GDFLASH_READ_STATUS_REG);
status_value = GDflash_ReadWriteByte(DGFLASH_DUMMY_BYTE);
DGFLASH_CS_HIGH();
return status_value;
}
void GDflash_write_status_reg(u8 value)
{
DGFLASH_CS_LOW();
GDflash_ReadWriteByte(GDFLASH_WRITE_STATUS_REG);
GDflash_ReadWriteByte(value);
DGFLASH_CS_HIGH();
}
void GDflash_read_datas(u32 startAddr, u8 *buf, u32 length, bool fastRead)
{
while ((GDflash_read_status_reg() & 0x01) == 1 );
DGFLASH_CS_LOW();
if (fastRead)
{
GDflash_ReadWriteByte(GDFLASH_FAST_READ);
}
else
{
GDflash_ReadWriteByte(GDFLASH_READ_DATA);
}
GDflash_ReadWriteByte( (u8)((startAddr>> 16) &0xFF));
GDflash_ReadWriteByte( (u8)((startAddr>> 8) &0xFF));
GDflash_ReadWriteByte( (u8)(startAddr &0xFF));
if (fastRead)
{
GDflash_ReadWriteByte(DGFLASH_DUMMY_BYTE);
}
for (u32 i = 0; i < length; i++)
{
buf[i] = GDflash_ReadWriteByte(DGFLASH_DUMMY_BYTE);
}
DGFLASH_CS_HIGH();
}
/*****************************************************************************
Prototype : spiReadWriteByte
Description : spi basic function
Input : u8 data
Output : None
Return Value :
Date : 2014/3/15
Author : Barry
当写入地址不是每页的开头时,若此页的剩余空间小于要写入的内容大小,那么数据将会重当前
地址开始填充完此页后,从此页的开始处,再继续填充,直到完成
写入内容不能超出每页的大小256字节超出的部分自能保证最后256字节的内容被写入flash
*****************************************************************************/
void GDflash_page_program(u32 startAddr, u8 *buf, u16 length, bool fastWrite)
{
while ((GDflash_read_status_reg() & 0x01) == 1 );
GDflash_write_enable(TRUE);
DGFLASH_CS_LOW();
if (fastWrite)
{
GDflash_ReadWriteByte(GDFLASH_PAGE_PROGRAM_F2);
}
else
{
GDflash_ReadWriteByte(GDFLASH_PAGE_PROGRAM_02);
}
GDflash_ReadWriteByte( (u8)((startAddr>> 16) &0xFF));
GDflash_ReadWriteByte( (u8)((startAddr>> 8) &0xFF));
GDflash_ReadWriteByte( (u8)(startAddr &0xFF));
for (u16 i = 0; i < length; i++)
{
GDflash_ReadWriteByte( buf[i]);
}
DGFLASH_CS_HIGH();
}
/*
Any address inside the sector is a valid
address for the Sector Erase (SE) command
*/
void GDflash_erase(u32 startAddr, GDFLASH_ERASE_TYPE erase_type)
{
while ((GDflash_read_status_reg() & 0x01) == 1 );
GDflash_write_enable(TRUE);
DGFLASH_CS_LOW();
switch (erase_type)
{
case SECTOR_ERASE:
GDflash_ReadWriteByte(GDFLASH_SECTOR_ERASE);
break;
case BLOCK_ERASE_32K:
GDflash_ReadWriteByte(GDFLASH_BLOCK_ERASE_32);
break;
case BLOCK_ERASE_64K:
GDflash_ReadWriteByte(GDFLASH_BLOCK_ERASE_64);
break;
case CHIP_ERASE:
GDflash_ReadWriteByte(GDFLASH_CHIP_ERASE);
break;
default:
break;
}
if (erase_type != CHIP_ERASE)
{
GDflash_ReadWriteByte( (u8)((startAddr>> 16) &0xFF));
GDflash_ReadWriteByte( (u8)((startAddr>> 8) &0xFF));
GDflash_ReadWriteByte( (u8)(startAddr &0xFF));
}
DGFLASH_CS_HIGH();
}
/*****************************************************************************
*
*
*
*
*
*
当写入地址不是每页的开头时,若此页的剩余空间小于要写入的内容大小,那么数据将会重当前
地址开始填充完此页后,从此页的开始处,再继续填充,直到完成
写入内容不能超出每页的大小256字节超出的部分自能保证最后256字节的内容被写入flash
这种写入方法,只管写,不管擦除,在第一个升级包的时候就全片擦除
*****************************************************************************/
#define GDFLASH_PAGE_SIZE 256
void GDflash_write(u32 startAddr, u8 *buf, u32 length)
{
u32 current_startAddr = startAddr;
u8 first_page_byte = GDFLASH_PAGE_SIZE - (startAddr % GDFLASH_PAGE_SIZE);
u8 * current_data_ptr = buf;
u32 left_length = length;
u16 integrated_Pages;
u16 end_page_byte;
if (length > first_page_byte)
{
GDflash_page_program( current_startAddr, current_data_ptr, first_page_byte, FALSE);
current_startAddr = current_startAddr + first_page_byte;
current_data_ptr += first_page_byte;
left_length = length - first_page_byte;
integrated_Pages = left_length / GDFLASH_PAGE_SIZE;
end_page_byte = left_length % GDFLASH_PAGE_SIZE;
for (u16 i = 0; i < integrated_Pages; i++)
{
GDflash_page_program( current_startAddr, current_data_ptr, GDFLASH_PAGE_SIZE, FALSE);
current_startAddr += GDFLASH_PAGE_SIZE;
current_data_ptr += GDFLASH_PAGE_SIZE;
}
if (end_page_byte > 0)
{
GDflash_page_program( current_startAddr, current_data_ptr, end_page_byte, FALSE);
}
}
else
{
GDflash_page_program( current_startAddr, current_data_ptr, length, FALSE);
}
}
void GDflash_read_next(u32 startAddr, u8 *buf, u32 length)
{
u32 current_startAddr = startAddr;
u8 first_page_byte = GDFLASH_PAGE_SIZE - (startAddr % GDFLASH_PAGE_SIZE);
u8 * current_data_ptr = buf;
u32 left_length = length;
u16 integrated_Pages;
u16 end_page_byte;
if (length > first_page_byte)
{
GDflash_read_datas( current_startAddr, current_data_ptr, first_page_byte, FALSE);
current_startAddr = current_startAddr + first_page_byte;
current_data_ptr += first_page_byte;
left_length = length - first_page_byte;
integrated_Pages = left_length / GDFLASH_PAGE_SIZE;
end_page_byte = left_length % GDFLASH_PAGE_SIZE;
for (u16 i = 0; i < integrated_Pages; i++)
{
GDflash_read_datas( current_startAddr, current_data_ptr, GDFLASH_PAGE_SIZE, FALSE);
current_startAddr += GDFLASH_PAGE_SIZE;
current_data_ptr += GDFLASH_PAGE_SIZE;
}
if (end_page_byte > 0)
{
GDflash_read_datas( current_startAddr, current_data_ptr, end_page_byte, FALSE);
}
}
else
{
GDflash_read_datas( current_startAddr, current_data_ptr, length, FALSE);
}
}
void GDfalsh_read_identification(u8 *buf)
{
DGFLASH_CS_LOW();
GDflash_ReadWriteByte(0x9F);
buf[0] = GDflash_ReadWriteByte(0xAA);
buf[1] = GDflash_ReadWriteByte(0xAA);
buf[2] = GDflash_ReadWriteByte(0xAA);
DGFLASH_CS_HIGH();
}
void GDflash_128KByte_erase(void)
{
GDflash_erase(0, BLOCK_ERASE_64K);
GDflash_erase(65536, BLOCK_ERASE_64K);
}
void GDflash_read(u32 startAddr, u8 *buf, u32 length)
{
GDflash_read_datas(startAddr, buf, length, FALSE);
}
void GDflash_test(void)
{
u8 buf[] = "hello,world!";
u8 buf1[20];
u8 buf2[20];
GDflash_init();
GDflash_erase(0,BLOCK_ERASE_64K);
GDflash_read_datas(0 , buf1, sizeof(buf), FALSE);
GDflash_page_program(0 , buf, sizeof(buf),TRUE);
GDflash_read_datas(0 , buf2, sizeof(buf), FALSE);
}
void flash_onepage_write(u32 addr,u8 * val,u16 len)
{
GDflash_erase(addr,SECTOR_ERASE);
GDflash_page_program(addr , val, len,TRUE);
}
void flash_onepage_read(u32 addr,u8 * val,u16 len)
{
GDflash_read_datas(addr , val, len, FALSE);
}
void flash_doc_write(u32 addr,u8 * val,u16 len)
{
GDflash_erase(addr,SECTOR_ERASE);
GDflash_erase(addr+4096,SECTOR_ERASE);
GDflash_erase(addr+4096*2,SECTOR_ERASE);
GDflash_erase(addr+4096*3,SECTOR_ERASE);
GDflash_erase(addr+4096*4,SECTOR_ERASE);
// GDflash_page_program(addr , val, len,TRUE);
GDflash_write(addr , val, len);
}
void flash_doc_read(u32 addr,u8 * val,u16 len)
{
GDflash_read_next(addr , val, len);
}
void update_clear()
{
for(u16 i = 26;i<200;i++)
{
GDflash_erase(i*4096 ,SECTOR_ERASE);
}
}

108
shuangjia/hal_gdflash.h Normal file
View File

@@ -0,0 +1,108 @@
#ifndef __HAL_GDFLASH_H__
#define __HAL_GDFLASH_H__
#include "Basedefine.h"
# if 0
#define GDFLASH_SPI SPI1
#define DGFLASH_SPI_PORT GPIOA
#define GDFLASH_GPIO_CLK RCC_AHBPeriph_GPIOA
#define GDFLASH_CS_PIN GPIO_Pin_4
#define GDFLASH_SCK_PIN GPIO_Pin_5
#define DGFLASH_SPI_SCK_SOURCE GPIO_PinSource5
#define DGFLASH_SPI_SCK_AF GPIO_AF_0
#define GDFLASH_MISO_PIN GPIO_Pin_6
#define DGFLASH_SPI_MISO_SOURCE GPIO_PinSource6
#define DGFLASH_SPI_MISO_AF GPIO_AF_0
#define GDFLASH_MOSI_PIN GPIO_Pin_7
#define DGFLASH_SPI_MOSI_SOURCE GPIO_PinSource7
#define DGFLASH_SPI_MOSI_AF GPIO_AF_0
/* Select sRF: Chip Select pin low */
#define DGFLASH_CS_LOW() GPIO_ResetBits(DGFLASH_SPI_PORT, GDFLASH_CS_PIN)
/* Deselect sRF: Chip Select pin high */
#define DGFLASH_CS_HIGH() GPIO_SetBits(DGFLASH_SPI_PORT, GDFLASH_CS_PIN)
#endif
#define GDFLASH_SPI SPI1
#define DGFLASH_SPI_SCK RCC_APB2Periph_SPI1
#define GDFLASH_CS_PIN GPIO_Pin_15
#define GDFLASH_CS_PORT GPIOA
#define GDFLASH_CS_SCK RCC_APB2Periph_GPIOA
#define GDFLASH_SCK_PIN GPIO_Pin_3
#define DGFLASH_SCK_PORT GPIOB
#define DGFLASH_SCK_SCK RCC_APB2Periph_GPIOB
#define GDFLASH_MISO_PIN GPIO_Pin_4
#define DGFLASH_MISO_PORT GPIOB
#define DGFLASH_MISO_SCK RCC_APB2Periph_GPIOB
#define GDFLASH_MOSI_PIN GPIO_Pin_5
#define DGFLASH_MOSI_PORT GPIOB
#define DGFLASH_MOSI_SCK RCC_APB2Periph_GPIOB
#if 0
/* Select sRF: Chip Select pin low */
#define DGFLASH_CS_LOW() GPIO_ResetBits(GDFLASH_CS_PORT, GDFLASH_CS_PIN)
/* Deselect sRF: Chip Select pin high */
#define DGFLASH_CS_HIGH() GPIO_SetBits(GDFLASH_CS_PORT, GDFLASH_CS_PIN)
#endif
#define DGFLASH_DUMMY_BYTE 0xAA
#define GDFLASH_WRITE_ENABLE 0x06
#define GDFLASH_WRITE_DISABLE 0x04
#define GDFLASH_READ_STATUS_REG 0x05
#define GDFLASH_WRITE_STATUS_REG 0x01
#define GDFLASH_READ_DATA 0x03
#define GDFLASH_FAST_READ 0x0b
#define GDFLASH_DUAL_OUTPUT_FAST_READ 0x3b
#define GDFLASH_PAGE_PROGRAM_02 0x02
#define GDFLASH_PAGE_PROGRAM_F2 0xF2
#define GDFLASH_SECTOR_ERASE 0x20
#define GDFLASH_BLOCK_ERASE_32 0x52
#define GDFLASH_BLOCK_ERASE_64 0xD8
#define GDFLASH_CHIP_ERASE 0x60
#define GDFLASH_DEEP_POWER_DOWN 0xB9
#define GDFLASH_RELEASE_FROM_DPD_AND_READ_DEVICE_ID 0xAB //两个靠参数的不同来实现不同的功能
#define GDFLASH_RELEASE_FROM_DPD 0xAB //
#define GDFLASH_DEVICE_ID 0x90
#define GDFLASH_READ_IDENTIFICATION 0x9F
typedef enum
{
SECTOR_ERASE = 0,
BLOCK_ERASE_32K = 1,
BLOCK_ERASE_64K = 2,
CHIP_ERASE = 3,
}GDFLASH_ERASE_TYPE;
void GDflash_init(void);
u8 GDflash_read_status_reg(void);
void GDflash_write_enable(bool enable);
void GDflash_test(void);
void GDflash_128KByte_erase(void);
void GDflash_read(u32 startAddr, u8 *buf, u32 length);
void GDflash_write(u32 startAddr, u8 *buf, u32 length);
void GDflash_erase(u32 startAddr, GDFLASH_ERASE_TYPE erase_type);
#endif

146
shuangjia/load.c Normal file
View File

@@ -0,0 +1,146 @@
//#include "stdafx.h"
#include "load.h"
#include "gprs.h"
#include "Cmd.h"
#include <math.h>
#include "include.h"
#include "debug_printf.h"
#include "Rtc.h"
#include "addr.h"
#include "uart.h"
#include "storage.h"
#include "apl.h"
#include "PHY.h"
#include "rtc_ext.h"
#include "update.h"
#include "gprs.h"
#include "hearttime.h"
/*gprs相关*/
#define HEART_NO_REV_NUM 3 /*未收到n次主站心跳报文后通知gprs模块重新连接主站*/
#define FIRST_HEART_SPACE 6 //第一次认为是10秒后心跳
extern CPU_INT08U gprs_loading_flag;
extern void concent_load(u8 * val,u16 * len);
extern void gprs_send_flag();
extern void concent_heart(u8 * val,u16 * len);
extern void gprs_close_all();
extern u8 * get_uart_send();
extern u16 * get_uart_send_plen();
extern CPU_INT08U bak_ip_flag;
extern u32 time_cur;
extern CPU_INT08U port_0_status;
extern void sj_frame_load(u8 * val,u16 * len);
extern void sj_frame_heart(u8 * val,u16 * len);
extern void COM_led_off(u8 led);
extern void COM_led_on(u8 led);
//extern void net_para_save();
extern void hb_heart_rp_pro(u8 * val,u16 * len);
#define HEART_SPACE_TIME (220)
typedef struct
{
CPU_INT08U gprs0_land :1;
CPU_INT08U gprs0_heart :1;
CPU_INT08U gprs0_recv :1;
CPU_INT08U uip_land :1;
CPU_INT08U uip_heart :1;
CPU_INT08U uip_recv :1;
CPU_INT08U reserved :2;
}land_heart_state;
typedef struct
{
CPU_INT32U gprs0_rev_time;
CPU_INT32U gprs0_heart_time;
CPU_INT32U uip_rev_time;
CPU_INT32U uip_heart_time;
}heart_time_tp;
static u32 heart_timespace = 0;
static u8 heart_flag = 0;
//
//time_cur //在task_gprs中被赋值
void gprs_setload()
{
//循环心跳间隔时间赋值为0
heart_flag = 0;
//循环心跳间隔时间赋值为0
heart_flag = 1;
heart_timespace = time_cur;
}
extern u32 m3761_recv_time;
void gprs_recv_judge_timeset()
{
//判断是否超过3个心跳时间
//gprs0_time_socket =time_cur;
//心跳时间
heart_timespace = time_cur;
m3761_recv_time = time_cur;
//点灯 在线状态
//led_online_status |= LED_GPRSONLINE_YES;
//led_run_status |= LED_RUN_GPRSONLINE;
COM_led_on(3);
}
u32 time_save = 0;
bool is_set_save = false;
void set_time_save()
{
is_set_save = true;
time_save = time_cur;
}
void gprs_load()
{
if(PORT_STATUS_CONNECTED == port_0_status)
{
if(1 == gprs_loading_flag)
{
printf("GPRS 连接成功 !!!\r\n");
gprs_loading_flag = 0;
gprs_setload();
}
if(1 == heart_flag)
{
if((time_cur - heart_timespace) >= HEART_SPACE_TIME)
{
hb_heart_rp_pro(get_uart_send(),get_uart_send_plen());
gprs_send_flag();
heart_timespace = time_cur;
printf("\r\n循环心跳\r\n");
}
}
}
}
void heart_send()
{
concent_heart(get_uart_send(),get_uart_send_plen());
gprs_send_flag();
heart_timespace = time_cur;
}

10
shuangjia/load.h Normal file
View File

@@ -0,0 +1,10 @@
#ifndef __LOAD__
#define __LOAD__
//#include "global.h"
#include "Basedefine.h"
u8 make_heart(void);
void gprs_recv_judge_timeset();
#endif

137
shuangjia/poweroffon.c Normal file
View File

@@ -0,0 +1,137 @@
//#include "stdafx.h"
#include "poweroffon.h"
#include "include.h"
void gprs_device_poweroff();
void gprs_device_poweron();
//pc7 ---> pa1
void gprs_device_init()
{
// return;
GPIO_InitTypeDef GPIO_InitStructure;
// RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO | SPI_FLASH_GPIO_CLK | FRAM_SPI_SCK_GPIO_CLK | FRAM_SPI_MISO_GPIO_CLK | FRAM_SPI_MOSI_GPIO_CLK , ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA |RCC_APB2Periph_GPIOB||RCC_APB2Periph_GPIOC , ENABLE);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_Init(GPIOB, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_Init(GPIOC, &GPIO_InitStructure);
// GPIO_SetBits(GPIOA, GPIO_Pin_1);
// GPIO_ReetBits(GPIOA, GPIO_Pin_1);
// GPIO_ResetBits(GPIOA, GPIO_Pin_1);
gprs_device_poweron();
}
void gprs_device_poweroff()
{
#if 0
printf("gprs 윗됴왠齡신 700봐취\r\n");
//GPIO_SetBits(GPIOA, GPIO_Pin_1);
GPIO_SetBits(GPIOC, GPIO_Pin_7);
vTaskDelay(700/portTICK_RATE_MS);
printf("gprs 윗멕왠齡신 50봐취\r\n");
//GPIO_ResetBits(GPIOA, GPIO_Pin_1);
GPIO_ResetBits(GPIOC, GPIO_Pin_7);
vTaskDelay(50/portTICK_RATE_MS);
#endif
printf("gprs 윗됴든都신뙤든1000봐취\r\n");
//든都신
GPIO_SetBits(GPIOB, GPIO_Pin_0);
vTaskDelay(1000/portTICK_RATE_MS);
}
void gprs_device_ctl_h()
{
//printf("윗멕왠齡신PWRKEY = 1\r\n\r\n");
//GPIO_SetBits(GPIOC, GPIO_Pin_7);
//vTaskDelay(10/portTICK_RATE_MS);
}
void gprs_device_poweron()
{
#if 0
printf("gprs 윗멕든都신,묩든\r\n");
//든都신
GPIO_ResetBits(GPIOB, GPIO_Pin_0);
vTaskDelay(1000/portTICK_RATE_MS);
printf("gprs 왠齡신윗멕 1000봐취\r\n");
//GPIO_SetBits(GPIOA, GPIO_Pin_1);
GPIO_SetBits(GPIOC, GPIO_Pin_7);
vTaskDelay(1000/portTICK_RATE_MS);
printf("gprs 윗됴왠齡신\r\n");
//왠齡신
//GPIO_ResetBits(GPIOA, GPIO_Pin_1);
GPIO_ResetBits(GPIOC, GPIO_Pin_7);
vTaskDelay(1000/portTICK_RATE_MS);
printf("gprs 된덤5취 랙箇AT츱즈\r\n");
vTaskDelay(5000/portTICK_RATE_MS);
#endif
printf("gprs 윗멕든都신,묩든\r\n");
//든都신
GPIO_ResetBits(GPIOB, GPIO_Pin_0);
vTaskDelay(1000/portTICK_RATE_MS);
printf("gprs 왠齡신윗됴 200봐취\r\n");
GPIO_ResetBits(GPIOC, GPIO_Pin_7);
vTaskDelay(200/portTICK_RATE_MS);
printf("gprs 왠齡신윗멕 100봐취\r\n");
GPIO_SetBits(GPIOC, GPIO_Pin_7);
vTaskDelay(100/portTICK_RATE_MS);
// STM_GPRS_PCTRL_ON();
// OSTimeDlyHMSM(0,0,0,200,OS_OPT_TIME_HMSM_NON_STRICT,&err);
// STM_GPRS_ONOFF_L();
// OSTimeDlyHMSM(0,0,1,0,OS_OPT_TIME_HMSM_NON_STRICT,&err);
// STM_GPRS_ONOFF_H();
// OSTimeDlyHMSM(0,0,10,0,OS_OPT_TIME_HMSM_NON_STRICT,&err);
// dbug_printf(MSG_GPRS_INFO,"gprs_power_on finish\r\n");
}

10
shuangjia/poweroffon.h Normal file
View File

@@ -0,0 +1,10 @@
#ifndef __POWEROFFON__
#define __POWEROFFON__
//#include "global.h"
void gprs_device_init();
void gprs_pwoff();
void gprs_pwon();
#endif

123
shuangjia/sjack.c Normal file
View File

@@ -0,0 +1,123 @@
///#include "stdafx.h"
#include "sjframe.h"
//#include "frame3762task.h"
extern u8 * get_uart_send();
extern u8 * addr_get();
//static u8 send_serial = 0x70;
static u8 recvserial = 0;
void sj_set_recvser(u8 ser)
{
recvserial = ser;
}
u8 sj_get_recvser()
{
return recvserial;
}
//叫駱뵨
extern unsigned char GetCK(unsigned char * Val, unsigned char Len);
void sj_frame_ack(u8 * val,u16 * len,u8 afn)
{
u8 * p = val;
u8 * addr = addr_get();
p[0] = 0x68;
p[1] = 49;
p[2] = 0x00;
p[3] = 49;
p[4] = 0x00;
p[5] = 0x68;
p[6] = 0x80;
//addr
p[7] = addr[0];
p[8] = addr[1];
p[9] = addr[2];
p[10] = addr[3];
p[11] = 0;
//afn
p[12] = afn;//
//ser
p[13] = (6<<4)|(recvserial&0x0F);
//데禱깃街
p[14] = 0x00;
p[15] = 0x00;
p[16] = 0x01;
p[17] = 0x00;
p[18] = GetCK(&p[6],0x0C);
p[19] = 0x16;
* len = 20;
}
void amt_frame_data(u8 * val,u16 * len,u8 * amtval,u8 amtlen)
{
//0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
//68 20 00 20 00 68 88 03 13 01 00 00 96 60 00 00 01 00 03 00 00 87 21 66 27 38 35 00 62 99 00 F7 16
//68 20 00 20 00 68 88 03 13 01 00 00 96 60 00 00 01 00
//03 00
//00 87 21 66 27 38 35
//00 62 99 00
//F7 16
//2 + num * 11 + 12
u8 * p = val;
u16 datalen = (13 + amtlen) * 4 + 1;
u16 alllen = 1 + amtlen + 20;
u8 * addr = addr_get();
p[0] = 0x68;
p[1] = datalen&0xFF;
p[2] = (datalen>>8)&0xFF;
p[3] = datalen&0xFF;
p[4] = (datalen>>8)&0xFF;
p[5] = 0x68;
p[6] = 0x88;
//addr
p[7] = addr[0];
p[8] = addr[1];
p[9] = addr[2];
p[10] = addr[3];
p[11] = 0;
//afn
p[12] = 0x9E;
//ser
p[13] = sj_get_recvser();//0x60;//get_sendserial();
//데禱깃街
p[14] = 0x00;
p[15] = 0x00;
p[16] = 0x01;
p[17] = 0x00;
//
p[18] = amtlen;
memmove(&p[19],amtval,amtlen);
p[alllen-2] = GetCK(&p[6],13 + amtlen);
p[alllen-1] = 0x16;
* len = alllen;
}

63
shuangjia/sjdataack.c Normal file
View File

@@ -0,0 +1,63 @@
#include "sjframe.h"
extern u8 * get_uart_send();
extern u8 * addr_get();
//УÑéºÍ
extern unsigned char GetCK(unsigned char * Val, unsigned char Len);
void sj_frame_data_ack(u8 * val,u16 * len,u8 * meter,u8 * data)
{
u8 recvserial = sj_get_recvser();
u8 * p = val;
u8 * addr = addr_get();
p[0] = 0x68;
p[1] = 101;
p[2] = 0x00;
p[3] = 101;
p[4] = 0x00;
p[5] = 0x68;
p[6] = 0x88;
//addr
p[7] = addr[0];
p[8] = addr[1];
p[9] = addr[2];
p[10] = addr[3];
p[11] = 0;
//afn
p[12] = 0x84;
//ser
p[13] = (6<<4)|(recvserial&0x0F);
//µ¥Ôª±êʶ
p[14] = 0x00;
p[15] = 0x00;
p[16] = 0x01;
p[17] = 0x00;
p[18] = 0x01;
p[19] = 0x00;
//20 21 22 23 24 25 26
memmove(&p[20],meter,7);
//27 28 29 30
// data[0] = 0x12;
// data[1] = 0x34;
// data[2] = 0x12;
// data[3] = 0x34;
memmove(&p[27],data,4);
p[31] = GetCK(&p[6],25);
p[32] = 0x16;
* len = 33;
}

433
shuangjia/sjframe.c Normal file
View File

@@ -0,0 +1,433 @@
//#include "stdafx.h"
#include "sjframe.h"
#include "rtc_ext.h"
//#include "frame3762task.h"
//extern u8 send_buff[512];
//extern u16 send_buff_len;
//extern u8 recv_buff[512];
//extern u16 recv_buff_len;
extern u8 * get_uart_send();
extern u8 * addr_get();
extern bool sj_frame_recv(u8 * val,u16 vallen);
//static u8 send_serial = 0x70;
//舞?<3F>
unsigned char GetCK(unsigned char * Val, unsigned char Len)
{
unsigned char i = 0;
unsigned char ck = 0;
if(NULL == Val) return 0;
if(0 == Len) return 0;
for( i = 0; i < Len; i++)
{
ck += Val[i];
}
return ck;
}
//?u16?懋??圜 2?懋?。
void P2From16(unsigned char * P2,unsigned short Val)
{
P2[0] = (Val&0xFF);
P2[1] = ((Val)>>8)&0xFF;
}
//?2?懋???圜 u16?懋。
unsigned short U16From2(unsigned char * P2)
{
return (((P2[1]<<8) &0xFF00) + P2[0]);
}
/*
static u8 get_sendserial()
{
return (send_serial++);
}
*/
void sj_frame_rpdata(u8 * val,u16 * len,u16 num,u8 * sendval)
{
//0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
//68 20 00 20 00 68 88 03 13 01 00 00 96 60 00 00 01 00 03 00 00 87 21 66 27 38 35 00 62 99 00 F7 16
//68 20 00 20 00 68 88 03 13 01 00 00 96 60 00 00 01 00
//03 00
//00 87 21 66 27 38 35
//00 62 99 00
//F7 16
//2 + num * 11 + 12
u8 * p = val;
u16 datalen = (2 + num * 11 + 12) * 4 + 1;
u16 alllen = 2 + num * 11 + 20;
u8 * addr = addr_get();
p[0] = 0x68;
p[1] = datalen&0xFF;
p[2] = (datalen>>8)&0xFF;
p[3] = datalen&0xFF;
p[4] = (datalen>>8)&0xFF;
p[5] = 0x68;
p[6] = 0x88;
//addr
p[7] = addr[0];
p[8] = addr[1];
p[9] = addr[2];
p[10] = addr[3];
p[11] = 0;
//afn
p[12] = 0x96;
//ser
p[13] = 0x60;//get_sendserial();
//单元标识
p[14] = 0x00;
p[15] = 0x00;
p[16] = 0x01;
p[17] = 0x00;
//
p[18] = num&0xFF;
p[19] = (num>>8)&0xFF;
memmove(&p[20],sendval,num*11);
p[alllen-2] = GetCK(&p[6],2 + num * 11 + 12);
p[alllen-1] = 0x16;
* len = alllen;
}
void sj_frame_load(u8 * val,u16 * len)
{
//登陆
//0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
//68 0C 00 0C 00 68 C9 03 13 01 00 00 95 70 00 00 01 00 E6 16
u8 * p = val;
u8 * addr = addr_get();
p[0] = 0x68;
p[1] = 49;
p[2] = 0x00;
p[3] = 49;
p[4] = 0x00;
p[5] = 0x68;
p[6] = 0xC9;
//addr
p[7] = addr[0];
p[8] = addr[1];
p[9] = addr[2];
p[10] = addr[3];
p[11] = 0;
//afn
p[12] = 0x95;
//ser
p[13] = 0x70;//get_sendserial();
//单元标识
p[14] = 0x00;
p[15] = 0x00;
p[16] = 0x01;
p[17] = 0x00;
p[18] = GetCK(&p[6],0x0C);
p[19] = 0x16;
* len = 20;
}
void sj_frame_heart(u8 * val,u16 * len)
{
//登陆
//0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
//68 0C 00 0C 00 68 C9 03 13 01 00 00 95 70 00 00 01 00 E6 16
u8 * p = val;
u8 * addr = addr_get();
p[0] = 0x68;
p[1] = 0x12*4+1;
p[2] = 0x00;
p[3] = 0x12*4+1;
p[4] = 0x00;
p[5] = 0x68;
p[6] = 0xC9;
//addr
p[7] = addr[0];
p[8] = addr[1];
p[9] = addr[2];
p[10] = addr[3];
p[11] = 0;
//afn
p[12] = 0x94;
//ser
p[13] = 0x70;//get_sendserial();
//单元标识
p[14] = 0x00;
p[15] = 0x00;
p[16] = 0x01;
p[17] = 0x00;
//时间
p[18] = 0x00;
p[19] = 0x00;
p[20] = 0x00;
p[21] = 0x09;
p[22] = 0x10;
p[23] = 0x19;
p[24] = GetCK(&p[6],0x12);
p[25] = 0x16;
* len = 26;
}
u8 send_buff[512];
u16 send_buff_len = 0;
u8 recv_buff[512];
u16 recv_buff_len = 0;
u8 * get_uart_recv()
{
return recv_buff;
}
u16 get_uart_recv_len()
{
return recv_buff_len;
}
u8 * get_uart_send()
{
return send_buff;
}
void set_uart_recv(u8 * val,u16 len)
{
memmove(recv_buff,val,len);
recv_buff_len = len;
//?锶猊钴唔知?濂郫?嘴
// set_recvserial(U16From2(&val[3]));
}
u16 get_uart_send_len()
{
return send_buff_len;
}
u16 * get_uart_send_plen()
{
return (&send_buff_len);
}
void concent_send_uart(u8 * val,u16 len)
{
memmove(send_buff,val,len);
send_buff_len = len;
// gprs_send_proc_direct(get_uart_send(),get_uart_send_len());
gprs_send_flag();
}
void concent_send_gprs()
{
gprs_send_proc_direct(get_uart_send(),get_uart_send_len());
}
void frame_process(u8 * val,u16 len)
{
memmove(recv_buff,val,len);
recv_buff_len = len;
set_uart_recv(val,len);
u8 ck1 = 0;
u8 ck2 = 0;
for(int j = 0;j<recv_buff_len;j++)
{
//0 1 2 3 4 5
//68 71 00 71 00 68 40 12 34 56 78 00 93 71 00 00 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 59 16
u16 vallen = U16From2(&val[j+1]);
vallen = vallen>>2;
// vallen = vallen - 1;
vallen = vallen + 8;
if(0x68 == val[j] && 0x16 == val[j+vallen-1])
{
ck1 = val[j+vallen-2];
ck2 = GetCK(&val[j+6],vallen-8);
if(ck1 == ck2)
{
//妪妄<E5A6AA>??扉蛄?锶。
gprs_recv_judge_timeset();
if(0x94 == val[j+12] || 0x95 == val[j+12])
{
//0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
//68 51 00 51 00 68 40 07 55 00 08 00 94 60 00 00 01 00 94 00 16 11 15 25 10 19 b7 16
if(0x94 == val[j+12])
{
st_rtc_ext rtc_dat;
rtc_dat.sec = val[j+20];
rtc_dat.min = val[j+21];
rtc_dat.hour = val[j+22];
rtc_dat.day = val[j+23];
rtc_dat.month = val[j+24];
rtc_dat.year = val[j+25];
rtc_dat.week = 1;
set_rtc_time(rtc_dat);
}
//Time_Set();
}
else
{
sj_frame_recv(&val[j],vallen-j);
}
//break;
}
}
}
#if 0
return;
//??诉萋?
//??槟<>
u16 ck1 = 0;
u16 ck2 = 0;
u8 kkk = 0;
for(int j = 0;j<recv_buff_len;j++)
{
u16 vallen = U16From2(&val[j+1]);
if(0x68 == val[j] && 0x16 == val[j+vallen-1])
{
ck1 = get_crc(&val[j+1],vallen-4);
ck2 = U16From2(&val[j+vallen-3]);
if(ck1 == ck2)
{
if(kkk==0)
{
memmove(recv_buff1,&val[j],vallen);
recv_buff_len1 = vallen;
}
else if(kkk==1)
{
memmove(recv_buff2,&val[j],vallen);
recv_buff_len2 = vallen;
kkk++;
break;
}
kkk++;
}
}
}
if(kkk==1)
{
set_uart_recv(val,len);
if(frame_recv())
{
//妪妄<E5A6AA>??扉蛄?锶。
gprs_recv_judge_timeset();
}
}
if(kkk==2)
{
memmove(recv_buff,recv_buff1,recv_buff_len1);
recv_buff_len = recv_buff_len1;
if(!frame_recv_noack())
{
memmove(recv_buff,recv_buff1,recv_buff_len1);
recv_buff_len = recv_buff_len1;
}
else
{
memmove(recv_buff,recv_buff2,recv_buff_len2);
recv_buff_len = recv_buff_len2;
}
set_uart_recv(recv_buff,recv_buff_len);
if(frame_recv())
{
//妪妄<E5A6AA>??扉蛄?锶。
gprs_recv_judge_timeset();
}
}
#endif
}

20
shuangjia/sjframe.h Normal file
View File

@@ -0,0 +1,20 @@
#ifndef __FRAME__
#define __FRAME__
#include "Basedefine.h"
#include "global.h"
void sj_frame_load(u8 * val,u16 * len);
void sj_frame_heart(u8 * val,u16 * len);
u8 * get_uart_recv();
u16 get_uart_recv_len();
u8 * get_uart_send();
void set_uart_recv(u8 * val,u16 len);
u16 get_uart_send_len();
void concent_send_uart(u8 * val,u16 len);
void concent_send_gprs();
void frame_process(u8 * val,u16 len);
void sj_frame_ack(u8 * val,u16 * len,u8 afn);
void sj_set_recvser(u8 ser);
u8 sj_get_recvser();
#endif

289
shuangjia/sjrecv.c Normal file
View File

@@ -0,0 +1,289 @@
//#include "stdafx.h"
#include "sjframe.h"
#include "metertable.h"
#include "meterseltable.h"
#include "rptime.h"
extern void rp_recvack();
extern u8 * get_uart_send();
extern void sj_frame_data_ack(u8 * val,u16 * len,u8 * meter,u8 * data);
extern void controlkeyaddr(u8 *str1,u8 val);
extern void simul_plc_rx_addr(u8 *str1);
extern void metertable_add(const u8 * addr,const u8 type);
extern void metertable_write();
extern void ClearMeterInfo();
extern bool get_dl_task_state();
extern void dl_start();
extern void ClearMeterInfo_realdl( void );
extern void ctl_start(u8 flag);
extern afn04_F3_st comm_04F3_param;
extern void ctl_sel_start(u8 flag);
extern void dl_task_set_rp();
extern void mbus_master_tx_begin();
extern u8 smt_get_len();
extern u8 * smt_get_val();
extern void amt_task(u8 * val);
extern void concent_send_uart(u8 * val,u16 len);
extern void amt_frame_data(u8 * val,u16 * len,u8 * amtval,u8 amtlen);
extern u8 sj_get_recvser();
void control_key_ack(u8 key)
{
u16 len = 0;
u8 * q = get_uart_send();
sj_frame_ack(q,&len,key);
concent_send_uart(q,len);
}
void sj_data_ack(u8 * meter,u8 * data)
{
u16 len = 0;
u8 * q = get_uart_send();
sj_frame_data_ack(q,&len,meter,data);
concent_send_uart(q,len);
}
//////////////////////////////////////////////////
static bool is_ctl_flag = false;
static u16 is_ctl_count = 0;
u8 ctladdr[7];
u8 ctlflag = 0;
void sj_ctl_process()
{
if(is_ctl_flag)
{
is_ctl_count++;
if(is_ctl_count>6)
{
is_ctl_flag = false;
is_ctl_count = 0;
//
printf("等待多个点开关阀时间到\r\n");
ctl_sel_start(ctlflag);
}
}
}
bool sj_frame_recv(u8 * val,u16 vallen)
{
u8 * p = val;
//0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
//68 71 00 71 00 68 40 12 34 56 78 00 93 71 00 00 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 59 16
u8 fn = p[12];
u8 * q = get_uart_send();
u16 len = 0;
sj_set_recvser(p[13]);
switch(fn)
{
default:
break;
case 0x93: //1.集中器初始化
{
metertable_init();
metertable_write();
sj_frame_ack(q,&len,0x93);
concent_send_uart(q,len);
return true;
}
break;
case 0x8C: //2.上报时间
{
//0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
//68 8D 00 8D 00 68 40 07 55 00 08 00 8C 72 00 00 01 00 81 05 04 02 25 10 19 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 7D 16
//
rptime_set(&p[18]);
rptime_write();
sj_frame_ack(q,&len,0x8C);
concent_send_uart(q,len);
return true;
}
break;
case 0x81: //3.关阀
{
//0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
//68 99 00 99 00 68 40 12 34 56 78 00 81 71 00 00 01 00 00 00 00 96 25 10 08 19 00 00 00 00 00 00 00 AA 00 00 00 00 00 00 00 00 00 00 DD 16
control_key_ack(0x81);
ctlflag = METER_CLOSE;
is_ctl_flag = true;
is_ctl_count = 0;
meterseltable_add(&p[21],METER_CLOSE);
return true;
}
break;
case 0x82: //4.开阀
{
control_key_ack(0x82);
ctlflag = METER_OPEN;
is_ctl_flag = true;
is_ctl_count = 0;
meterseltable_add(&p[21],METER_OPEN);
return true;
}
break;
case 0x84: //5.单个抄表
{
//0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
//68 55 00 55 00 68 40 12 34 56 78 00 84 71 00 00 01 00 00 01 00 59 02 81 90 11 11 D9 16
//sj_frame_ack(q,&len,0x82);
//concent_send_uart(q,len);
//清除数据
ClearMeterInfo_realdl();
//因为涉及到延长30秒特地加这个。
mbus_master_tx_begin();
simul_plc_rx_addr(&p[21]);
return true;
}
break;
case 0x9D: //6.集抄
{
//0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
//68 31 00 31 00 68 40 12 34 56 78 00 9D 71 00 00 01 00 63 16
// 5秒后启动定时上报
sj_frame_ack(q,&len,0x9D);
concent_send_uart(q,len);
//不仅抄表还需要上报
dl_task_set_rp();
dl_start();
return true;
}
case 0x51: //7.批量关阀
{
//0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
//68 31 00 31 00 68 40 12 34 56 78 00 51 73 00 00 01 00 19 16
// 批量关阀
sj_frame_ack(q,&len,0x51);
concent_send_uart(q,len);
ctl_start(METER_CLOSE);
return true;
}
break;
case 0x52: //8.批量开阀
{
//0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
//68 31 00 31 00 68 40 12 34 56 78 00 52 74 00 00 01 00 1B 16
// 批量开阀
sj_frame_ack(q,&len,0x52);
concent_send_uart(q,len);
ctl_start(METER_OPEN);
return true;
}
break;
case 0x85: //9.下发档案
{
//0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
// 68 40 12 34 56 78 00 85 71 00 00 01 00 02 00
//01 00 48 20 10 08 19 00 00 01
//02 00 96 25 10 08 19 00 00 01
//00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 D7 16
// 批量开阀
sj_frame_ack(q,&len,0x85);
//
u8 num = p[18];
u8 * pp = &p[20];
for(u8 i = 0;i<num;i++)
{
metertable_add(&pp[2],0);
pp = pp + 10;
}
metertable_write();
concent_send_uart(q,len);
return true;
}
break;
case 0x96: //10.上报回应
{
rp_recvack();
return true;
}
break;
case 0x88: //10.修改ip
{
//0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
//68 55 01 55 01 68 40 07 55 00 08 00 88 73 00 00 01 00 00 78 4C E5 35 DC 20 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 43 4D 4E 45 54 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 F1 16
//comm_04F3_param.primary.ip1 = ip1[0];
//comm_04F3_param.primary.ip2 = ip1[1];
//comm_04F3_param.primary.ip3 = ip1[2];
//comm_04F3_param.primary.ip4 = ip1[3];
//comm_04F3_param.primary.port = port1;
comm_04F3_param.reserve.ip1 = p[19];
comm_04F3_param.reserve.ip2 = p[20];
comm_04F3_param.reserve.ip3 = p[21];
comm_04F3_param.reserve.ip4 = p[22];
comm_04F3_param.reserve.port = (p[24]<<8)|p[23];
ipport_write();
ipport_init();
sj_frame_ack(q,&len,0x88);
concent_send_uart(q,len);
//rp_recvack();
return true;
}
break;
case 0x9E: //11.透明传输
{
//0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
//68 31 00 31 00 68 40 12 34 56 78 00 9E 74 00 00 01 00 1B 16
amt_task(p);
amt_frame_data(q,&len, smt_get_val(),smt_get_len());
concent_send_uart(q,len);
return true;
}
break;
}
return false;
}