/**
|
******************************************************************************
|
* @file : functions.c
|
* @brief : funcstions program body
|
******************************************************************************
|
*/
|
//#include "globaldef.h"
|
#include "functions.h"
|
#include "string.h"
|
#include "stm32f0xx_hal.h"
|
#if (BOARD_TYPE == 14)
|
#include "fp0.h"
|
#endif
|
extern __IO uint32_t uwTick;
|
|
unsigned char Uart3RxBuf[UART3RXBUFSIZE];
|
unsigned char Uart3TxBuf[UART3TXBUFSIZE];
|
stUartStat Uart3Stat={0};
|
unsigned int Uart3RecvBuf1DataLen =0;
|
unsigned int Uart3ToSendLen =0 ;
|
unsigned int Uart3SentLen = 0;
|
|
unsigned char Uart5RxBuf[UART5RXBUFSIZE];
|
unsigned char Uart5TxBuf[UART5TXBUFSIZE];
|
stUartStat Uart5Stat={0};
|
unsigned int Uart5RecvBuf1DataLen =0;
|
unsigned int Uart5ToSendLen =0 ;
|
unsigned int Uart5SentLen = 0;
|
|
unsigned char Uart6RxBuf[UART6RXBUFSIZE];
|
unsigned char Uart6TxBuf[UART6TXBUFSIZE];
|
stUartStat Uart6Stat={0};
|
unsigned int Uart6RecvBuf1DataLen =0;
|
unsigned int Uart6ToSendLen =0 ;
|
unsigned int Uart6SentLen = 0;
|
|
//#include "Myprotocol.h"
|
int TickFreq=10000;
|
int CoreClkMHz; //=SystemCoreClock/1000000;
|
int TickPriodClk; //=SystemCoreClock/TickFreq;
|
unsigned int TickPrioduS; //
|
volatile unsigned int nCurTick=0;
|
volatile unsigned int CurTickuS=0;
|
//volatile unsigned int ThisRunTime=0; //开机时间
|
//volatile unsigned int TotalRunTime=0; //总开机时间
|
//volatile unsigned int PwrCount=0; //开机次数
|
unsigned short ClkuS; //每个Clk的nS数，
|
|
int InituS(int TickFreq1)
|
{
|
TickPrioduS=1000000/TickFreq1; //每个SysTick的微秒数
|
CoreClkMHz=HAL_RCC_GetHCLKFreq()/1000000; //=SystemCoreClock/1000000;每uS的时钟数
|
TickPriodClk=SystemCoreClock/TickFreq1; //每个SysTick的时钟数
|
ClkuS=(1000000LL*65536)/SystemCoreClock;
|
CurTickuS=TickPrioduS+100u;
|
return 0;
|
}
|
|
inline unsigned int GetuS(void)
|
{
|
// unsigned short Clk1=SysTick->VAL;
|
|
int CurTickuS1=CurTickuS;
|
int Val1=SysTick->VAL;
|
if (CurTickuS1 != CurTickuS )
|
{
|
CurTickuS1=CurTickuS;
|
Val1=SysTick->VAL;
|
}
|
uint32_t us1=CurTickuS1-(((Val1)*1365)>>16);
|
return us1;
|
}
|
|
inline unsigned int GetTick(void)
|
{
|
// unsigned short Clk1=SysTick->VAL;
|
return nCurTick;
|
}
|
|
void logData(unsigned char d)
|
{
|
KMem.WDB[128+KMem.WDT[123]] = d;
|
KMem.WDT[123]++; if (KMem.WDT[123]>=100) {KMem.WDT[123]=81;}
|
}
|
|
const unsigned short crc16_table[256] = {
|
0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
|
0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
|
0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
|
0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
|
0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
|
0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
|
0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
|
0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
|
0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
|
0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
|
0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
|
0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
|
0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
|
0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
|
0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
|
0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
|
0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
|
0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
|
0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
|
0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
|
0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
|
0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
|
0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
|
0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
|
0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
|
0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
|
0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
|
0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
|
0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
|
0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
|
0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
|
0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
|
};
|
|
unsigned short crc_check(const unsigned char * data, unsigned int length)
|
{
|
unsigned short crc_reg = 0xFFFF;
|
while (length--)
|
{
|
crc_reg = (crc_reg >> 8) ^ crc16_table[(crc_reg ^ *data++) & 0xff];
|
}
|
return (~crc_reg) & 0xFFFF;
|
}
|
|
const uint16_t polynom = 0xA001;
|
|
unsigned short crc16bitbybit(const unsigned char *ptr, unsigned int len)
|
{
|
uint8_t i;
|
uint16_t crc = 0xffff;
|
|
if (len == 0) {
|
len = 1;
|
}
|
while (len--) {
|
crc ^= *ptr;
|
for (i = 0; i<8; i++)
|
{
|
if (crc & 1) {
|
crc >>= 1;
|
crc ^= polynom;
|
}
|
else {
|
crc >>= 1;
|
}
|
}
|
ptr++;
|
}
|
return(crc);
|
}
|
|
/* Table of CRC values for high-order byte */
|
const uint8_t crctablehi[] = {
|
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
|
0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
|
0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01,
|
0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
|
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81,
|
0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
|
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01,
|
0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
|
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
|
0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
|
0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01,
|
0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
|
0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
|
0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
|
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01,
|
0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
|
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
|
0x40
|
};
|
/* Table of CRC values for low-order byte */
|
const uint8_t crctablelo[] = {
|
0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06, 0x07, 0xC7, 0x05, 0xC5, 0xC4,
|
0x04, 0xCC, 0x0C, 0x0D, 0xCD, 0x0F, 0xCF, 0xCE, 0x0E, 0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09,
|
0x08, 0xC8, 0xD8, 0x18, 0x19, 0xD9, 0x1B, 0xDB, 0xDA, 0x1A, 0x1E, 0xDE, 0xDF, 0x1F, 0xDD,
|
0x1D, 0x1C, 0xDC, 0x14, 0xD4, 0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 0x12, 0x13, 0xD3,
|
0x11, 0xD1, 0xD0, 0x10, 0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3, 0xF2, 0x32, 0x36, 0xF6, 0xF7,
|
0x37, 0xF5, 0x35, 0x34, 0xF4, 0x3C, 0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A,
|
0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38, 0x28, 0xE8, 0xE9, 0x29, 0xEB, 0x2B, 0x2A, 0xEA, 0xEE,
|
0x2E, 0x2F, 0xEF, 0x2D, 0xED, 0xEC, 0x2C, 0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26,
|
0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0, 0xA0, 0x60, 0x61, 0xA1, 0x63, 0xA3, 0xA2,
|
0x62, 0x66, 0xA6, 0xA7, 0x67, 0xA5, 0x65, 0x64, 0xA4, 0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F,
|
0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 0x68, 0x78, 0xB8, 0xB9, 0x79, 0xBB,
|
0x7B, 0x7A, 0xBA, 0xBE, 0x7E, 0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C, 0xB4, 0x74, 0x75, 0xB5,
|
0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71, 0x70, 0xB0, 0x50, 0x90, 0x91,
|
0x51, 0x93, 0x53, 0x52, 0x92, 0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54, 0x9C, 0x5C,
|
0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E, 0x5A, 0x9A, 0x9B, 0x5B, 0x99, 0x59, 0x58, 0x98, 0x88,
|
0x48, 0x49, 0x89, 0x4B, 0x8B, 0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C,
|
0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42, 0x43, 0x83, 0x41, 0x81, 0x80,
|
0x40
|
};
|
|
uint16_t crc16table(const uint8_t *ptr, uint16_t len)
|
{
|
uint8_t crchi = 0xff;
|
uint8_t crclo = 0xff;
|
uint16_t index;
|
while (len--)
|
{
|
index = crclo ^ *ptr++;
|
crclo = crchi ^ crctablehi[index];
|
crchi = crctablelo[index];
|
}
|
return (crchi << 8 | crclo);
|
}
|
|
void modbuscrc16test()
|
{
|
printf("\n");
|
printf(" Modbus CRC16 tester\n");
|
printf("-----------------------------------------------------------------------\n");
|
uint8_t crc16_data[] = { 0x01, 0x04, 0x04, 0x43, 0x6b, 0x58, 0x0e }; // expected crc value 0xD825.
|
printf(" modbus crc16table test, expected value : 0xd825, calculate value : 0x%x\n", crc16table(crc16_data, sizeof(crc16_data)));
|
// printf(" modbus crc16tablefast test, expected value : 0xd825, calculate value : 0x%x\n", crc16tablefast(crc16_data, sizeof(crc16_data)));
|
printf(" modbus crc16bitbybit test, expected value : 0xd825, calculate value : 0x%x\n", crc16bitbybit(crc16_data, sizeof(crc16_data)));
|
}
|
|
int InitUartstat(stUartStat * pUartstat,void * pBufRx, int nSizeRx, void * pBufTx, int nSizeTx)
|
{
|
memset(pUartstat,sizeof(stUartStat),0);
|
initQueue(&pUartstat->QRx,pBufRx,nSizeRx);
|
initQueue(&pUartstat->QTx,pBufTx,nSizeTx);
|
return 0;
|
}
|
|
int Uart1SendDMA(void * pData, int nSize)
|
{
|
LL_DMA_DisableChannel(DMA1,LL_DMA_CHANNEL_2);
|
LL_DMA_ConfigAddresses(DMA1,LL_DMA_CHANNEL_2, (uint32_t)pData,
|
(uint32_t)&USART1->TDR, LL_DMA_DIRECTION_MEMORY_TO_PERIPH);
|
LL_DMA_SetDataLength(DMA1,LL_DMA_CHANNEL_2,nSize);
|
LL_DMA_EnableChannel(DMA1,LL_DMA_CHANNEL_2);
|
Uart1Stat.DMASendLen=nSize;
|
Uart1Stat.bSending=1;
|
LL_DMA_EnableIT_TC(DMA1,LL_DMA_CHANNEL_2);
|
LL_USART_EnableDMAReq_TX(USART1);
|
return nSize;
|
}
|
|
int Uart1TriggerSendDMA()
|
{
|
if (!Uart1Stat.bSending&&!IsEmpty(&Uart1Stat.QTx))
|
{
|
int len1=GetContinueData(&Uart1Stat.QTx);
|
Uart1SendDMA(GetReadBuffer(&Uart1Stat.QTx),len1);
|
}
|
return 0;
|
}
|
|
void Uart2SetDE(void)
|
{
|
LL_GPIO_ResetOutputPin(GPIOA,LL_GPIO_PIN_1);
|
}
|
void Uart2UnsetDE(void)
|
{
|
LL_GPIO_SetOutputPin(GPIOA,LL_GPIO_PIN_1);
|
}
|
void DelayUs(int nUs)
|
{
|
for (int i=0;i<nUs;i++)
|
for (volatile int j=0;j<24;j++)
|
{
|
__nop();
|
}
|
}
|
|
int Uart2RecvDMA(void * pBuf, int nSize)
|
{
|
LL_DMA_DisableChannel(DMA1,LL_DMA_CHANNEL_5);
|
LL_DMA_ConfigAddresses(DMA1,LL_DMA_CHANNEL_5, (uint32_t)&USART2->RDR,
|
(uint32_t)pBuf, LL_DMA_DIRECTION_PERIPH_TO_MEMORY);
|
LL_DMA_SetDataLength(DMA1,LL_DMA_CHANNEL_5,nSize);
|
LL_DMA_EnableChannel(DMA1,LL_DMA_CHANNEL_5);
|
Uart2Stat.DMARecvLen=nSize;
|
Uart2Stat.bRecving=1;
|
LL_DMA_EnableIT_TC(DMA1,LL_DMA_CHANNEL_5);
|
LL_USART_EnableDMAReq_RX(USART2);
|
return 0;
|
}
|
int Uart2SendDMA(void * pData, int nSize)
|
{
|
#if (USART2_USE_HARDWARE_DE == 1)
|
|
#else
|
Uart2SetDE();
|
DelayUs(USART2_DE_ASSERTION_TIME);
|
#endif
|
LL_DMA_DisableChannel(DMA1,LL_DMA_CHANNEL_4);
|
LL_DMA_ConfigAddresses(DMA1,LL_DMA_CHANNEL_4, (uint32_t)pData,
|
(uint32_t)&USART2->TDR, LL_DMA_DIRECTION_MEMORY_TO_PERIPH);
|
LL_DMA_SetDataLength(DMA1,LL_DMA_CHANNEL_4,nSize);
|
LL_DMA_EnableChannel(DMA1,LL_DMA_CHANNEL_4);
|
Uart2Stat.DMASendLen=nSize;
|
Uart2Stat.bSending=1;
|
LL_DMA_EnableIT_TC(DMA1,LL_DMA_CHANNEL_4);
|
LL_USART_EnableDMAReq_TX(USART2);
|
return nSize;
|
}
|
int Uart2TriggerSendDMA()
|
{
|
if (!Uart2Stat.bSending&&!IsEmpty(&Uart2Stat.QTx))
|
{
|
int len1=GetContinueData(&Uart2Stat.QTx);
|
Uart2SendDMA(GetReadBuffer(&Uart2Stat.QTx),len1);
|
}
|
return 0;
|
}
|
|
void TriggerPendSV()
|
{
|
SCB->ICSR=SCB_ICSR_PENDSVSET_Msk; //1<<SCB_ICSR_PENDSVSET_Pos;
|
}
|
|
|
void SPI1_IRQ_CallBack()
|
{
|
uint8_t value;
|
// LL_GPIO_TogglePin(GPIOB,LL_GPIO_PIN_7);
|
if (LL_SPI_IsActiveFlag_RXNE(SPI1))
|
{
|
value = LL_SPI_ReceiveData8( SPI1);
|
#if (BOARD_TYPE == 14)
|
KMem.WDD[62]++;
|
KMem.WDT[122]++;
|
if (!bSPI1Sending)
|
{
|
logData(value);
|
}
|
if (!bSPI1Sending && (1 || bSPI1Recving))
|
{
|
SPI1RecvBuf[nSPI1RecvPos]=value;
|
nSPI1RecvPos++;
|
|
if (value==0x0d)
|
{
|
logData(nSPI1RecvPos);
|
|
nSPI1RecvLenInBuf=nSPI1RecvPos;
|
bSPI1RecvDone=1;
|
nSPI1RecvPos=0;
|
bSPI1Recving=0;
|
|
TriggerPendSV();
|
}
|
}
|
if (bSPI1Sending)
|
{
|
nSPI1SentLen++;
|
KMem.SDD[63]++;
|
|
if (nSPI1SentLen >= nSPI1ToSendLen) {
|
SetACKPin_1();
|
bSPI1Sending=0;
|
bSPI1SendDone=1;
|
bSPI1Recving=1;
|
nSPI1RecvPos=0;
|
SetFP0DEPin_0();
|
}
|
else {
|
value = SPI1SendBuf[nSPI1SentLen];
|
LL_SPI_TransmitData8(SPI1,value);
|
logData(value);
|
}
|
}
|
#endif
|
}
|
}
|
|
void Uart1SendDone()
|
{
|
Uart1Stat.TcCount++;
|
return;
|
}
|
|
void Uart1RecvDone()
|
{
|
Uart1Stat.IdelCount++;
|
// NVIC_SetPendingIRQ(PendSV_IRQn);
|
// SCB->ICSR=SCB_ICSR_PENDSVSET_Msk; //1<<SCB_ICSR_PENDSVSET_Pos;
|
|
if (Uart1RecvBuf1DataLen >0)
|
{
|
Uart1Stat.bPacketRecved=1;
|
// SCB->ICSR=SCB_ICSR_PENDSVSET_Msk; //1<<SCB_ICSR_PENDSVSET_Pos;
|
// KLParsePacket(Uart1RecvBuf1,Uart1RecvBuf1DataLen);
|
// Uart1RecvBuf1DataLen=0;
|
}
|
}
|
|
void Uart2SendDone()
|
{
|
Uart2Stat.TcCount++;
|
#if (USART2_USE_HARDWARE_DE == 1)
|
#else
|
Uart2UnsetDE();
|
#endif
|
}
|
void Uart2RecvDone()
|
{
|
Uart2RecvBuf1DataLen=sizeof(Uart2RecvBuf1) - LL_DMA_GetDataLength(DMA1,LL_DMA_CHANNEL_5);
|
Uart2Stat.bPacketRecved=1;
|
Uart2Stat.IdelCount++;
|
if (Uart2RecvBuf1DataLen>0)
|
TriggerPendSV();
|
// ParsePacket((pKBPacket)Uart2RecvBuf1,Uart2RecvBuf1DataLen);
|
}
|
|
void Uart3SendDone()
|
{
|
// Uart1Stat.TcCount++;
|
return;
|
}
|
|
void Uart3RecvDone()
|
{
|
// Uart3Stat.IdelCount++;
|
// NVIC_SetPendingIRQ(PendSV_IRQn);
|
// SCB->ICSR=SCB_ICSR_PENDSVSET_Msk; //1<<SCB_ICSR_PENDSVSET_Pos;
|
|
if (Uart3RecvBuf1DataLen >0)
|
{
|
Uart3Stat.bPacketRecved=1;
|
// SCB->ICSR=SCB_ICSR_PENDSVSET_Msk; //1<<SCB_ICSR_PENDSVSET_Pos;
|
// KLParsePacket(Uart1RecvBuf1,Uart1RecvBuf1DataLen);
|
// Uart1RecvBuf1DataLen=0;
|
}
|
}
|
void Uart3SendPacket(char * str, int len)
|
{
|
memcpy(Uart3TxBuf,str,len);
|
Uart3ToSendLen = len;
|
LL_USART_EnableIT_TXE(USART3);
|
}
|
|
void Uart5SendDone()
|
{
|
// Uart1Stat.TcCount++;
|
return;
|
}
|
|
void Uart5RecvDone()
|
{
|
// Uart5Stat.IdelCount++;
|
// NVIC_SetPendingIRQ(PendSV_IRQn);
|
// SCB->ICSR=SCB_ICSR_PENDSVSET_Msk; //1<<SCB_ICSR_PENDSVSET_Pos;
|
|
if (Uart5RecvBuf1DataLen >0)
|
{
|
Uart5Stat.bPacketRecved=1;
|
// SCB->ICSR=SCB_ICSR_PENDSVSET_Msk; //1<<SCB_ICSR_PENDSVSET_Pos;
|
// KLParsePacket(Uart1RecvBuf1,Uart1RecvBuf1DataLen);
|
// Uart1RecvBuf1DataLen=0;
|
}
|
}
|
void Uart5SendPacket(char * str, int len)
|
{
|
memcpy(Uart5TxBuf,str,len);
|
Uart5ToSendLen = len;
|
|
LL_USART_EnableIT_TXE(USART5);
|
}
|
|
void Uart6SendDone()
|
{
|
// Uart1Stat.TcCount++;
|
return;
|
}
|
|
void Uart6RecvDone()
|
{
|
// Uart5Stat.IdelCount++;
|
// NVIC_SetPendingIRQ(PendSV_IRQn);
|
// SCB->ICSR=SCB_ICSR_PENDSVSET_Msk; //1<<SCB_ICSR_PENDSVSET_Pos;
|
|
if (Uart6RecvBuf1DataLen >0)
|
{
|
Uart6Stat.bPacketRecved=1;
|
// SCB->ICSR=SCB_ICSR_PENDSVSET_Msk; //1<<SCB_ICSR_PENDSVSET_Pos;
|
// KLParsePacket(Uart1RecvBuf1,Uart1RecvBuf1DataLen);
|
// Uart1RecvBuf1DataLen=0;
|
}
|
}
|
void Uart6SendPacket(void * str, int len)
|
{
|
memcpy(Uart6TxBuf,str,len);
|
Uart6ToSendLen = len;
|
|
LL_USART_EnableIT_TXE(USART6);
|
}
|
|
void SLPSendPacket(void * str, uchar len)
|
{
|
Uart6SendPacket(str,len);
|
}
|
|
|
int PutStr(char * str1, int len1)
|
{
|
// Uart1SendDMA(str1,len1);
|
PushIn(&Uart1Stat.QTx,str1,len1);
|
// LL_USART_EnableIT_TXE(USART1);
|
// LL_USART_EnableIT_TC(USART1);
|
Uart1TriggerSendDMA();
|
return len1;
|
}
|
int PutStr1(char * str1, int len1)
|
{
|
// Uart1SendDMA(str1,len1);
|
PushIn(&Uart1Stat.QTx,str1,len1);
|
// LL_USART_EnableIT_TXE(USART1);
|
// LL_USART_EnableIT_TC(USART1);
|
Uart1TriggerSendDMA();
|
return len1;
|
}
|
int PutStr2(char * str1, int len1)
|
{
|
Uart2SendDMA(str1,len1);
|
// PushIn(&Uart2Stat.QTx,str1,len1);
|
// LL_USART_EnableIT_TXE(USART1);
|
// LL_USART_EnableIT_TC(USART1);
|
// Uart2TriggerSendDMA();
|
return len1;
|
}
|
|
int SendPacket(int nChn, void * pBuf,int len1)
|
{
|
if (nChn==1) {
|
PutStr1((char *)pBuf,len1);
|
// PushIn(&Uart1Stat.QTx,p1,len1);
|
// Uart1TriggerSendDMA();
|
Uart1Stat.SentPacket++;
|
}else if (nChn==2){
|
PutStr2((char *)pBuf,len1);
|
// PushIn(&Uart2Stat.QTx,p1,len1);
|
// Uart2TriggerSendDMA();
|
Uart2Stat.SentPacket++;
|
}
|
return len1;
|
}
|
/*
|
int SendPacket1(void * pBuf,int len1)
|
{
|
PutStr1((char *)pBuf,len1);
|
// PushIn(&Uart1Stat.QTx,p1,len1);
|
// Uart1TriggerSendDMA();
|
Uart1Stat.SentPacket++;
|
return len1;
|
}
|
int SendPacket2(pKBPacket p1,int len1)
|
{
|
PutStr2((char *)p1,len1);
|
// PushIn(&Uart2Stat.QTx,p1,len1);
|
// Uart2TriggerSendDMA();
|
Uart2Stat.SentPacket++;
|
return len1;
|
}
|
*/
|
void ToggleRunLed() { LL_GPIO_TogglePin(GPIOC,LL_GPIO_PIN_13);}
|
void ToggleErrLed() { LL_GPIO_TogglePin(GPIOC,LL_GPIO_PIN_14);}
|
void ToggleErr2Led() { LL_GPIO_TogglePin(GPIOC,LL_GPIO_PIN_15);}
|
|
#if (BOARD_TYPE == 14)
|
void ToggleOutStat() { LL_GPIO_TogglePin(GPIOC,LL_GPIO_PIN_15);}
|
|
void SetOutStat(uchar bOn)
|
{
|
if (bOn) {LL_GPIO_SetOutputPin(GPIOC,LL_GPIO_PIN_15);}
|
else {LL_GPIO_ResetOutputPin(GPIOC,LL_GPIO_PIN_15);}
|
}
|
#else
|
void ToggleOutStat() { LL_GPIO_TogglePin(GPIOA,LL_GPIO_PIN_11);}
|
|
void SetOutStat(uchar bOn)
|
{
|
if (bOn) {LL_GPIO_SetOutputPin(GPIOA,LL_GPIO_PIN_11);}
|
else {LL_GPIO_ResetOutputPin(GPIOA,LL_GPIO_PIN_11);}
|
}
|
#endif
|
|
void SetRunLed(uchar bOn)
|
{
|
if (bOn) {LL_GPIO_ResetOutputPin(GPIOC,LL_GPIO_PIN_13);}
|
else {LL_GPIO_SetOutputPin(GPIOC,LL_GPIO_PIN_13);}
|
}
|
void SetErrLed(uchar bOn)
|
{
|
if (bOn) {LL_GPIO_ResetOutputPin(GPIOC,LL_GPIO_PIN_14);}
|
else {LL_GPIO_SetOutputPin(GPIOC,LL_GPIO_PIN_14);}
|
}
|
void SetErr2Led(uchar bOn)
|
{
|
if (bOn) {LL_GPIO_ResetOutputPin(GPIOC,LL_GPIO_PIN_15);}
|
else {LL_GPIO_SetOutputPin(GPIOC,LL_GPIO_PIN_15);}
|
}
|
/*
|
void SetLeds(uchar bRun, uchar bErr)
|
{
|
SetRunLed(bRun); SetErrLed (bErr);
|
}
|
*/
|
|
#define set165SL_0() LL_GPIO_ResetOutputPin(GPIOA,LL_GPIO_PIN_4)
|
#define set165SL_1() LL_GPIO_SetOutputPin(GPIOA,LL_GPIO_PIN_4)
|
#define set165CLK_0() LL_GPIO_ResetOutputPin(GPIOA,LL_GPIO_PIN_5)
|
#define set165CLK_1() LL_GPIO_SetOutputPin(GPIOA,LL_GPIO_PIN_5)
|
#define Get165SER() LL_GPIO_IsInputPinSet(GPIOA,LL_GPIO_PIN_6)
|
#define GetCfg165SER() LL_GPIO_IsInputPinSet(GPIOA,LL_GPIO_PIN_7)
|
|
unsigned int Input165_8()
|
{
|
int x1=0;
|
__disable_irq();
|
set165SL_0(); set165SL_1();
|
unsigned int mask1=0x0080;
|
volatile uint32_t * p1=&GPIOA->IDR;
|
for (uint32_t i=8;i;i--)
|
{
|
//if (Get165SER()) {}
|
//else x1|=mask1;
|
if (*p1&LL_GPIO_PIN_6) {}
|
else x1|=mask1;
|
//x1<<=1;
|
//x1|=!Get165SER();
|
set165CLK_0();
|
mask1>>=1;
|
set165CLK_1();
|
}
|
__enable_irq();
|
return x1;
|
}
|
|
unsigned int Input165(int nBit)
|
{
|
int x1=0;
|
__disable_irq();
|
set165SL_0(); set165SL_1();
|
unsigned int mask1=1<<(nBit-1);
|
volatile uint32_t * p1=&GPIOA->IDR;
|
for (uint32_t i=nBit;i;i--)
|
{
|
//if (Get165SER()) {}
|
//else x1|=mask1;
|
if (*p1&LL_GPIO_PIN_6) {}
|
else x1|=mask1;
|
//x1<<=1;
|
//x1|=!Get165SER();
|
set165CLK_0();
|
mask1>>=1;
|
set165CLK_1();
|
}
|
__enable_irq();
|
return x1;
|
}
|
unsigned int Input165_R(int nBit)
|
{
|
__disable_irq();
|
set165SL_0(); set165SL_1();
|
int nBytes = nBit /8;
|
volatile uint32_t * p1=&GPIOA->IDR;
|
union stdata
|
{
|
int intvalue;
|
unsigned char Bytes[4];
|
}rdata;
|
rdata.intvalue=0;
|
for (int i=0;i<nBytes;i++)
|
{
|
int x1=0;
|
unsigned int mask1=1<<(7);
|
for (uint32_t i=8;i;i--)
|
{
|
//if (Get165SER()) {}
|
//else x1|=mask1;
|
if (*p1&LL_GPIO_PIN_6) {}
|
else x1|=mask1;
|
//x1<<=1;
|
//x1|=!Get165SER();
|
set165CLK_0();
|
mask1>>=1;
|
set165CLK_1();
|
}
|
rdata.Bytes[i]=x1;
|
}
|
__enable_irq();
|
return rdata.intvalue;
|
}
|
|
#define set165SL_C0() LL_GPIO_ResetOutputPin(GPIOA,LL_GPIO_PIN_12)
|
#define set165SL_C1() LL_GPIO_SetOutputPin(GPIOA,LL_GPIO_PIN_12)
|
#define set165CLK_C0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_13)
|
#define set165CLK_C1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_13)
|
#define Get165SER_C() LL_GPIO_IsInputPinSet(GPIOB,LL_GPIO_PIN_14)
|
|
|
unsigned int Input165_C(int nBit)
|
{
|
__disable_irq();
|
set165SL_C0();
|
__nop();
|
__nop();
|
__nop();
|
__nop();
|
|
set165SL_C1();
|
int nBytes = nBit /8;
|
volatile uint32_t * p1=&GPIOB->IDR;
|
union stdata
|
{
|
int intvalue;
|
unsigned char Bytes[4];
|
}rdata;
|
rdata.intvalue=0;
|
for (int i=0;i<nBytes;i++)
|
{
|
int x1=0;
|
unsigned int mask1=1<<(7);
|
for (uint32_t i=8;i;i--)
|
{
|
//if (Get165SER()) {}
|
//else x1|=mask1;
|
if (*p1&LL_GPIO_PIN_14) {x1|=mask1;}
|
else {};
|
//x1<<=1;
|
//x1|=!Get165SER();
|
set165CLK_C0();
|
mask1>>=1;
|
__nop();
|
__nop();
|
__nop();
|
__nop();
|
__nop();
|
|
set165CLK_C1();
|
}
|
/*
|
LL_SPI_TransmitData8(SPI2,0xff);
|
while (LL_SPI_IsActiveFlag_TXE(SPI2) == RESET)
|
{
|
}
|
while (LL_SPI_IsActiveFlag_BSY(SPI2) == SET)
|
{
|
}
|
x1 = LL_SPI_ReceiveData8(SPI2);
|
*/
|
rdata.Bytes[i]=~x1;
|
// rdata.Bytes[i]=0;
|
|
}
|
__enable_irq();
|
return rdata.intvalue;
|
}
|
|
unsigned int Input165Cfg(int nBit)
|
{
|
int x1=0;
|
__disable_irq();
|
set165SL_0(); set165SL_1();
|
unsigned int mask1=1<<(nBit-1);
|
volatile uint32_t * p1=&GPIOA->IDR;
|
for (uint32_t i=nBit;i;i--)
|
{
|
//if (Get165SER()) {}
|
//else x1|=mask1;
|
if (*p1&LL_GPIO_PIN_7) {}
|
else x1|=mask1;
|
//x1<<=1;
|
//x1|=!Get165SER();
|
set165CLK_0();
|
mask1>>=1;
|
set165CLK_1();
|
}
|
__enable_irq();
|
return x1;
|
}
|
|
unsigned int GetInput()
|
{
|
int BoradType=GetBoardType();
|
switch (BoradType)
|
{
|
|
case 1:
|
return Input165(8);
|
case 2:
|
return Input165(8);
|
case 3:
|
return Input165(16);
|
case 4:
|
return Input165(8);
|
case 5:
|
case 7:
|
return Input165(16);
|
case 6:
|
case 8:
|
return Input165(8);
|
case 9:
|
return Input165_R(16);
|
case 10:
|
return Input165_R(8);
|
case 11:
|
return Input165_R(8);
|
case 13:
|
return Input165_R(16);
|
case 14:
|
return 0; //FP0
|
case 15:
|
return Input165_R(16);
|
case 16:
|
return Input165_R(8);
|
|
case 17:
|
return Input165_C(8);
|
|
default:
|
break;
|
}
|
return 0;
|
|
}
|
int ReadConfig_0()
|
{
|
return 0;
|
}
|
|
int ReadConfig_1()
|
{
|
// uchar x = LL_GPIO_ReadInputPort(GPIOB);
|
// uchar x1 = LL_GPIO_IsInputPinSet(GPIOB,LL_GPIO_PIN_10);
|
// uchar x2=(x&0x7) | (x1 << 3 ) ;
|
uchar x2=0;
|
x2=(GPIOB->IDR&0x7) | ((GPIOB->IDR &0x400)>>7);
|
x2= (~x2)&0xf;
|
return x2;
|
}
|
|
int ReadConfig_2()
|
{
|
uchar x2=0;
|
x2=(GPIOB->IDR&0x7) | ((GPIOB->IDR &0x400)>>7);
|
x2= (~x2)&0xf;
|
return x2;
|
}
|
|
int ReadConfig_3()
|
{
|
uchar x2=0;
|
x2 = Input165(24)&0xff;
|
return x2;
|
|
}
|
int ReadConfig_4()
|
{
|
|
uchar x2=0;
|
x2 = Input165(16)&0xff;
|
return x2;
|
}
|
|
int ReadConfig_5()
|
{
|
uchar x2=0;
|
x2 = Input165Cfg(8)&0xff;
|
return x2;
|
}
|
|
int ReadConfig_11()
|
{
|
uchar x2=0;
|
x2=((GPIOB->IDR&0x6)<<4);
|
x2= ((~x2)&0x30)|1;
|
return x2;
|
}
|
|
int ReadConfig_17()
|
{
|
shortbits v1;
|
v1.value=0;
|
shortbits x2;
|
x2.value=GPIOA->IDR;
|
v1.bit8 = ~x2.bit6;
|
v1.bit9 = ~x2.bit7;
|
v1.bit10 = ~x2.bit15;
|
x2.value=GPIOB->IDR;
|
v1.bit11 = ~x2.bit1;
|
v1.bit12 = ~x2.bit2;
|
|
v1.bit0 = ~x2.bit5;
|
v1.bit1 = ~x2.bit6;
|
v1.bit2 = ~x2.bit7;
|
v1.bit3 = ~x2.bit8;
|
v1.bit4 = ~x2.bit9;
|
x2.value=GPIOC->IDR;
|
v1.bit13 = ~x2.bit15;
|
|
return v1.value;
|
}
|
|
int ReadJumperSW()
|
{
|
int BoradType=GetBoardType();
|
switch (BoradType)
|
{
|
case 0:
|
return ReadConfig_0();
|
case 1:
|
return ReadConfig_1(); //old board 4 in 4 o
|
case 2:
|
return ReadConfig_2(); //old board 8 in 8 o
|
case 3:
|
return ReadConfig_3(); //Master 16 in16 o
|
case 4:
|
return ReadConfig_4(); //Slave 8 in 8 o
|
case 5:
|
case 7:
|
return ReadConfig_5(); // New Master 16 in16 o
|
case 6:
|
case 8:
|
return ReadConfig_5(); //New Slave 8 in 8 o
|
case 9:
|
case 10:
|
return ReadConfig_5(); //New Master Slave 8 in 8 o
|
case 11:
|
return ReadConfig_11(); //Mini Board
|
case 13:
|
return ReadConfig_5();
|
case 14:
|
return (~(LL_GPIO_ReadInputPort(GPIOA)>>4))&0x0f; //FP0
|
case 15:
|
case 16:
|
return ReadConfig_5(); //Wireless Master Slave 8 in 8 o
|
case 17:
|
return ReadConfig_17(); //Wireless Master Slave 8 in 8 o
|
default:
|
|
return 0;
|
}
|
}
|
|
#define SRCLK2_0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_13)
|
#define SRCLK2_1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_13)
|
#define STRCLK2_0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_12)
|
#define STRCLK2_1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_12)
|
#define SER2_0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_15)
|
#define SER2_1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_15)
|
|
void Enable595(uchar bEnable)
|
{
|
if (bEnable) {LL_GPIO_ResetOutputPin(GPIOA,LL_GPIO_PIN_8);}
|
else {LL_GPIO_SetOutputPin(GPIOA,LL_GPIO_PIN_8);}
|
}
|
|
void Output595_8(unsigned int cc)
|
{
|
//unsigned char i;
|
;// 74HC595输出程序，输出8位
|
// cc=~0x3f;
|
__disable_irq();
|
STRCLK2_1();
|
unsigned int mask1=0x0080;
|
//volatile uint32_t * p1 = &GPIOB->BRR;
|
//volatile uint32_t * p2 = &GPIOB->BSRR;
|
for (;mask1;)
|
{
|
SRCLK2_0();
|
//*p1=LL_GPIO_PIN_13;
|
if (cc&mask1) {SER2_1();}
|
else {SER2_0();}
|
mask1>>=1;
|
SRCLK2_1();
|
// __nop();
|
//*p2=LL_GPIO_PIN_13;
|
}
|
STRCLK2_0();
|
STRCLK2_1();
|
__enable_irq();
|
}
|
|
void Output595_16(unsigned int cc)
|
{
|
//unsigned char i;
|
;// 74HC595输出程序，输出16位
|
// cc=~0x3f;
|
__disable_irq();
|
STRCLK2_1();
|
unsigned int mask1=0x8000;
|
//volatile uint32_t * p1 = &GPIOB->BRR;
|
//volatile uint32_t * p2 = &GPIOB->BSRR;
|
for (;mask1;)
|
{
|
SRCLK2_0();
|
//*p1=LL_GPIO_PIN_13;
|
if (cc&mask1) {SER2_1();}
|
else {SER2_0();}
|
mask1>>=1;
|
SRCLK2_1();
|
// __nop();
|
//*p2=LL_GPIO_PIN_13;
|
}
|
STRCLK2_0();
|
STRCLK2_1();
|
__enable_irq();
|
}
|
|
/*
|
#define STRCLK12_0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_7)
|
#define STRCLK12_1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_7)
|
|
void PutOutputSPI1(unsigned int Y)
|
{
|
__disable_irq();
|
STRCLK12_1();
|
LL_SPI_TransmitData8(SPI1,Y>>8);
|
int i=0;
|
while (LL_SPI_IsActiveFlag_TXE(SPI1) == RESET)
|
{
|
}
|
KMem.SDD[28]=i;
|
i=0;
|
while (LL_SPI_IsActiveFlag_BSY(SPI1) == SET)
|
{
|
i++;
|
}
|
LL_SPI_TransmitData8(SPI1,Y);
|
while (LL_SPI_IsActiveFlag_TXE(SPI1) == RESET)
|
{
|
}
|
KMem.SDD[28]=i;
|
i=0;
|
while (LL_SPI_IsActiveFlag_BSY(SPI1) == SET)
|
{
|
i++;
|
}
|
KMem.SDD[30]=i;
|
STRCLK12_0();
|
__nop();
|
STRCLK12_1();
|
__enable_irq();
|
}
|
*/
|
|
void PutOutputSPI2(unsigned int Y)
|
{
|
__disable_irq();
|
STRCLK2_1();
|
LL_SPI_TransmitData8(SPI2,Y>>8);
|
int i=0;
|
while (LL_SPI_IsActiveFlag_TXE(SPI2) == RESET)
|
{
|
}
|
KMem.SDD[28]=i;
|
i=0;
|
while (LL_SPI_IsActiveFlag_BSY(SPI2) == SET)
|
{
|
i++;
|
}
|
LL_SPI_TransmitData8(SPI2,Y);
|
while (LL_SPI_IsActiveFlag_TXE(SPI2) == RESET)
|
{
|
}
|
KMem.SDD[28]=i;
|
i=0;
|
while (LL_SPI_IsActiveFlag_BSY(SPI2) == SET)
|
{
|
i++;
|
}
|
KMem.SDD[30]=i;
|
STRCLK2_0();
|
STRCLK2_1();
|
__enable_irq();
|
}
|
|
void PutOutput(unsigned int Y)
|
{
|
#if (BOARD_TYPE == 14)
|
return ;
|
#else
|
// PutOutputSPI2(Y);
|
Output595_8(Y);
|
#endif
|
}
|
|
#if (BOARD_TYPE == 9 || BOARD_TYPE == 10 || BOARD_TYPE == 15 || BOARD_TYPE == 16)
|
//#pragma message("9,10")
|
// V4.2 管脚排列向右移动了一位。
|
#define SRCLK1_0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_1)
|
#define SRCLK1_1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_1)
|
#define STRCLK1_0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_2)
|
#define STRCLK1_1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_2)
|
#define OE1_0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_10)
|
#define OE1_1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_10)
|
#define SER1_0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_11)
|
#define SER1_1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_11)
|
#else //按照原来的管脚排列
|
#define SRCLK1_0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_0)
|
#define SRCLK1_1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_0)
|
#define STRCLK1_0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_1)
|
#define STRCLK1_1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_1)
|
#define OE1_0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_2)
|
#define OE1_1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_2)
|
#define SER1_0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_10)
|
#define SER1_1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_10)
|
#endif
|
|
|
void EnableDisIn(uchar bEnable)
|
{
|
if (bEnable) {OE1_0();}
|
else {OE1_1();}
|
}
|
/*
|
void displayInput(unsigned int cc)
|
{
|
//unsigned char i;
|
;// 74HC595输出程序，输出8位
|
// cc=~0x3f;
|
__disable_irq();
|
STRCLK1_1();
|
unsigned int mask1=0x8000;
|
//volatile uint32_t * p1 = &GPIOB->BRR;
|
//volatile uint32_t * p2 = &GPIOB->BSRR;`````
|
for (;mask1;)
|
{
|
SRCLK1_0();
|
// *p1=LL_GPIO_PIN_13;
|
if (cc&mask1) {SER1_1();}
|
else {SER1_0();}
|
mask1>>=1;
|
SRCLK1_1();
|
// __nop();
|
// *p2=LL_GPIO_PIN_13;
|
}
|
STRCLK1_0();
|
STRCLK1_1();
|
__enable_irq();
|
}
|
*/
|
