就是将IO的底层封装一下嘛，给你看看下我的项目上的做法

头文件
[mw_shl_code=c,true]
#ifndef HW_H_
#define HW_H_


#include "main.h"
#include "message_queue.h"

typedef enum
{
    HW_Level_Low = Bit_RESET,
    HW_Level_High = Bit_SET
}HW_Level_t;

typedef enum
{
    HW_Status_Inactive = DISABLE,
    HW_Status_Active =  ENABLE
}HW_Status_t;

typedef enum
{
    HW_In_S1,
    HW_In_S2,
    HW_In_S3,
    HW_In_S4,
    HW_In_S5,
    HW_In_1FB,
    HW_In_2FB,
    HW_In_3FB,
    HW_In_4FB,
    HW_In_5FB,
    HW_In_6FB,
    HW_In_7FB,
    HW_In_ALM1,
    HW_In_ALM3,
    HW_In_Arrival1,
    HW_In_Arrival3,
    HW_In_None,
}HW_In_t;

typedef enum
{
    HW_Out_Led,
    HW_Out_Rs485De1,
    HW_Out_EN1,
    HW_Out_EN2,
    HW_Out_EN3,
    HW_Out_DIR1,
    HW_Out_DIR2,
    HW_Out_DIR3,
    HW_Out_Brak1,
    HW_Out_Brak3,
    HW_Out_Magnet,
    HW_Out_1_2D,
    HW_Out_3_4D,
    HW_Out_5_6D,
    HW_Out_7D,
    HW_Out_None,
}HW_Out_t;

typedef enum
{
    HW_Exti_1,
    HW_Exti_2,
    HW_Exti_3,
    HW_Exti_4,
    HW_Exti_5,
    HW_Exti_6,
    HW_Exti_7,
    HW_Exti_8,

    HW_Exti_Max = HW_Exti_8
}HW_Exti_t;

typedef void (*HW_ExtiCallback_t)(int data);

void HW_Init(void);
void HW_SetExtiCallback(HW_Exti_t exti, HW_ExtiCallback_t cb, int data);

void HW_Set(HW_Out_t out, HW_Level_t level);
HW_Level_t HW_GetSetted(HW_Out_t out);
void HW_Config(HW_Out_t out, HW_Status_t status);
HW_Status_t HW_IsConfigedActive(HW_Out_t out);
void HW_Trigger(HW_Out_t out);

HW_Level_t HW_Get(HW_In_t in);
int HW_IsActive(HW_In_t in);
int HW_IsExtiActive(HW_Exti_t exti);

unsigned int HW_ReadBoardAddres(void);
int HW_IoInCmd(int argc, char *argv[]);
int HW_IoOutCmd(int argc, char *argv[]);
void HW_OnExtiMsg(MsgQueue_Msg_t *msg);

#endif /* HW_H_ */[/mw_shl_code]

源文件
[mw_shl_code=c,true]#include "hw.h"

#include <stdlib.h>
#include <string.h>
#include <ctype.h>

static const struct
{
    GPIO_TypeDef *port;
    uint16_t pin;
    HW_Level_t activeLevel;
} _ins[] =
{
        {GPIOB, GPIO_Pin_3,  HW_Level_Low},  // HW_In_S1,
        {GPIOD, GPIO_Pin_2,  HW_Level_Low},  // HW_In_S2,
        {GPIOC, GPIO_Pin_12, HW_Level_Low},  // HW_In_S3,
        {GPIOC, GPIO_Pin_11, HW_Level_Low},  // HW_In_S4,
        {GPIOC, GPIO_Pin_10, HW_Level_Low},  // HW_In_S5,
        {GPIOB, GPIO_Pin_9,  HW_Level_Low},  // HW_In_1FB,
        {GPIOB, GPIO_Pin_8,  HW_Level_Low},  // HW_In_2FB,
        {GPIOA, GPIO_Pin_0,  HW_Level_Low},  // HW_In_3FB,
        {GPIOB, GPIO_Pin_4,  HW_Level_Low},  // HW_In_4FB,
        {GPIOB, GPIO_Pin_5,  HW_Level_Low},  // HW_In_5FB,
        {GPIOB, GPIO_Pin_6,  HW_Level_Low},  // HW_In_6FB,
        {GPIOB, GPIO_Pin_7,  HW_Level_Low},  // HW_In_7FB,
        {GPIOB, GPIO_Pin_13, HW_Level_Low},  // HW_In_ALM1,
        {GPIOB, GPIO_Pin_15, HW_Level_Low},  // HW_In_ALM3,
        {GPIOB, GPIO_Pin_14, HW_Level_High}, // HW_In_Arrival1,
        {GPIOC, GPIO_Pin_8,  HW_Level_High}, // HW_In_Arrival3,
        {GPIOD, GPIO_Pin_1,  HW_Level_High}, // HW_In_None,
};

static const struct
{
    GPIO_TypeDef *port;
    uint16_t pin;
    HW_Level_t activeLevel;
    HW_Status_t defaultStatus;
}_outs[] =
{
#ifdef BOARD_WAR_SHIP
        {GPIOB, GPIO_Pin_5,  HW_Level_Low,  HW_Status_Active},  // HW_Out_Led
#else
        {GPIOD, GPIO_Pin_0, HW_Level_Low,  HW_Status_Active},  // HW_Out_Led
#endif
        {GPIOA, GPIO_Pin_1,  HW_Level_High, HW_Status_Inactive}, // HW_Out_Rs485ReDe1,
        {GPIOB, GPIO_Pin_12, HW_Level_High, HW_Status_Inactive}, // HW_Out_EN1,
        {GPIOA, GPIO_Pin_11, HW_Level_High, HW_Status_Inactive}, // HW_Out_EN2,
        {GPIOC, GPIO_Pin_6,  HW_Level_High, HW_Status_Inactive}, // HW_Out_EN3,
        {GPIOB, GPIO_Pin_2,  HW_Level_High, HW_Status_Inactive}, // HW_Out_DIR1,
        {GPIOA, GPIO_Pin_12, HW_Level_High, HW_Status_Inactive}, // HW_Out_DIR2,
        {GPIOC, GPIO_Pin_7,  HW_Level_High, HW_Status_Inactive}, // HW_Out_DIR3,
        {GPIOA, GPIO_Pin_5,  HW_Level_High, HW_Status_Inactive}, // HW_Out_Brak1,
        {GPIOA, GPIO_Pin_4,  HW_Level_High, HW_Status_Inactive}, // HW_Out_Brak3,
        {GPIOC, GPIO_Pin_1,  HW_Level_High, HW_Status_Inactive}, // HW_Out_Magnet,
        {GPIOC, GPIO_Pin_15, HW_Level_High, HW_Status_Inactive}, // HW_Out_1_2D,
        {GPIOC, GPIO_Pin_14, HW_Level_High, HW_Status_Inactive}, // HW_Out_3_4D,
        {GPIOC, GPIO_Pin_13, HW_Level_High, HW_Status_Inactive}, // HW_Out_5_6D,
        {GPIOC, GPIO_Pin_0,  HW_Level_High, HW_Status_Inactive}, // HW_Out_7D,
        {GPIOD, GPIO_Pin_0,  HW_Level_High, HW_Status_Inactive}, // HW_Out_None
};

#if 0
static const uint8_t _bitMap[] = {
        0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
#endif

static const char* _inNames[] =
{
        "S1",
        "S2",
        "S3",
        "S4",
        "S5",
        "1FB",
        "2FB",
        "3FB",
        "4FB",
        "5FB",
        "6FB",
        "7FB",
        "ALM1",
        "ALM3",
        "ARR1",
        "ARR3",
};

static const char* _outNames[] =
{
        "LED",
        "RS485DE",
        "EN1",
        "EN2",
        "EN3",
        "DIR1",
        "DIR2",
        "DIR3",
        "BRAKE1",
        "BRAkE3",
        "MAGNET",
        "1_2D",
        "3_4D",
        "5_6D",
        "7D",
};

static const struct
{
    uint16_t pin;
    uint8_t pinSource;
    uint32_t extiLine;
    IRQn_Type IRQn;
}_pinAttribs[] =
{
        {GPIO_Pin_0,  GPIO_PinSource0,  EXTI_Line0,  EXTI0_IRQn},
        {GPIO_Pin_1,  GPIO_PinSource1,  EXTI_Line1,  EXTI1_IRQn},
        {GPIO_Pin_2,  GPIO_PinSource2,  EXTI_Line2,  EXTI2_IRQn},
        {GPIO_Pin_3,  GPIO_PinSource3,  EXTI_Line3,  EXTI3_IRQn},
        {GPIO_Pin_4,  GPIO_PinSource4,  EXTI_Line4,  EXTI4_IRQn},
        {GPIO_Pin_5,  GPIO_PinSource5,  EXTI_Line5,  EXTI9_5_IRQn},
        {GPIO_Pin_6,  GPIO_PinSource6,  EXTI_Line6,  EXTI9_5_IRQn},
        {GPIO_Pin_7,  GPIO_PinSource7,  EXTI_Line7,  EXTI9_5_IRQn},
        {GPIO_Pin_8,  GPIO_PinSource8,  EXTI_Line8,  EXTI9_5_IRQn},
        {GPIO_Pin_9,  GPIO_PinSource9,  EXTI_Line9,  EXTI9_5_IRQn},
        {GPIO_Pin_10, GPIO_PinSource10, EXTI_Line10, EXTI15_10_IRQn},
        {GPIO_Pin_11, GPIO_PinSource11, EXTI_Line11, EXTI15_10_IRQn},
        {GPIO_Pin_12, GPIO_PinSource12, EXTI_Line12, EXTI15_10_IRQn},
        {GPIO_Pin_13, GPIO_PinSource13, EXTI_Line13, EXTI15_10_IRQn},
        {GPIO_Pin_14, GPIO_PinSource14, EXTI_Line14, EXTI15_10_IRQn},
        {GPIO_Pin_15, GPIO_PinSource15, EXTI_Line15, EXTI15_10_IRQn},
};

enum _Port
{
    _PortA,
    _PortB,
    _PortC,
    _PortD,
    _PortE,
};

static GPIO_TypeDef * const _ports[] =
{
        GPIOA,
        GPIOB,
        GPIOC,
        GPIOD,
        GPIOE,
};

static const struct
{
    GPIO_TypeDef *port;
    uint8_t portSource;
}_portSources[] =
{
        {GPIOA, GPIO_PortSourceGPIOA},
        {GPIOB, GPIO_PortSourceGPIOB},
        {GPIOC, GPIO_PortSourceGPIOC},
        {GPIOD, GPIO_PortSourceGPIOD},
        {GPIOE, GPIO_PortSourceGPIOE},
};

static const struct _Exti
{
    enum _Port portIndex;
    int pinIndex;
    HW_Level_t activeLevel;
    EXTITrigger_TypeDef trigger;
}_extis[] =
{
        {_PortC, 3, HW_Level_Low, EXTI_Trigger_Rising_Falling}, // HW_Exti_1,
        {_PortC, 2, HW_Level_Low, EXTI_Trigger_Rising_Falling}, // HW_Exti_2,
        {_PortA, 6, HW_Level_Low, EXTI_Trigger_Rising_Falling}, // HW_Exti_3,
        {_PortA, 7, HW_Level_Low, EXTI_Trigger_Rising_Falling}, // HW_Exti_4,
        {_PortC, 4, HW_Level_Low, EXTI_Trigger_Rising_Falling}, // HW_Exti_5,
        {_PortC, 5, HW_Level_Low, EXTI_Trigger_Rising_Falling}, // HW_Exti_6,
        {_PortB, 0, HW_Level_Low, EXTI_Trigger_Rising_Falling}, // HW_Exti_7,
        {_PortB, 1, HW_Level_Low, EXTI_Trigger_Rising_Falling}, // HW_Exti_8,
};

static struct
{
    HW_ExtiCallback_t cb;
    int data;
}_extiCbProfiles[ARRAY_SIZE(_extis)];

static void _ExtiInit(const struct _Exti *exti);
static void _ExtiDefaultHandler(int data);

void HW_Init(void)
{
    unsigned int i;
    GPIO_InitTypeDef GPIO_InitStructure;

    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB | RCC_APB2Periph_GPIOC |
            RCC_APB2Periph_GPIOD | RCC_APB2Periph_GPIOE, ENABLE);

    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
    for(i = 0; i < ARRAY_SIZE(_ins); i++)
    {
        GPIO_InitStructure.GPIO_Pin = _ins.pin;
        GPIO_Init(_ins.port, & GPIO_InitStructure);
    }

    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    for(i = 0; i < ARRAY_SIZE(_outs); i++)
    {
        GPIO_InitStructure.GPIO_Pin = _outs.pin;
        GPIO_Init(_outs.port, & GPIO_InitStructure);
        HW_Config(i, _outs.defaultStatus);
    }

    /* Enable AFIO clock */
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
    for(i = 0; i < ARRAY_SIZE(_extis); i++)
    {
        _ExtiInit(& _extis);
        HW_SetExtiCallback((HW_Exti_t)i, _ExtiDefaultHandler, _extis.pinIndex);
    }

#if defined(__DEBUG__)
//    HW_SetLight(HW_Light_Stop, HW_Status_Flash);
#endif
}

static void _ExtiInit(const struct _Exti *exti)
{
    EXTI_InitTypeDef   EXTI_InitStructure;
    GPIO_InitTypeDef   GPIO_InitStructure;
    NVIC_InitTypeDef   NVIC_InitStructure;

    /* Configure PG.08 pin as input floating */
    GPIO_InitStructure.GPIO_Pin = _pinAttribs[exti->pinIndex].pin;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_Init(_portSources[exti->portIndex].port, &GPIO_InitStructure);

    /* Connect EXTI Line to  pin */
    GPIO_EXTILineConfig(_portSources[exti->portIndex].portSource,
            _pinAttribs[exti->pinIndex].pinSource);

    /* Configure EXTI line */
    EXTI_InitStructure.EXTI_Line = _pinAttribs[exti->pinIndex].extiLine;
    EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
    EXTI_InitStructure.EXTI_Trigger = exti->trigger;
    EXTI_InitStructure.EXTI_LineCmd = ENABLE;
    EXTI_Init(&EXTI_InitStructure);

    /* Enable and set EXTI Interrupt priority */
    NVIC_InitStructure.NVIC_IRQChannel = _pinAttribs[exti->pinIndex].IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x00;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x01;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;

    NVIC_Init(&NVIC_InitStructure);
}

static void _ExtiDefaultHandler(int data)
{
    HW_Exti_t exti;

    exti = (HW_Exti_t)data;
    MsgQueue_Send(MsgQueue_Id_ExtiTest, & exti, sizeof(exti));
}

void HW_OnExtiMsg(MsgQueue_Msg_t *msg)
{
    HW_Exti_t exti;

    exti = *((HW_Exti_t *)msg->data);
    printf("EXTI%d Trigger ", (int) exti);
}

void HW_Set(HW_Out_t out, HW_Level_t level)
{
    if(level == HW_Level_Low)
    {
        _outs[out].port->BRR = _outs[out].pin;
    }
    else
    {
        _outs[out].port->BSRR = _outs[out].pin;
    }
}

HW_Level_t HW_GetSetted(HW_Out_t out)
{
    return ((_outs[out].port->ODR & _outs[out].pin) == 0) ? HW_Level_Low : HW_Level_High;
}

HW_Level_t HW_Get(HW_In_t in)
{
    return ((_ins[in].port->IDR & _ins[in].pin) == 0) ? HW_Level_Low : HW_Level_High;
}

void HW_Trigger(HW_Out_t out)
{
    _outs[out].port->ODR ^= _outs[out].pin;
}

void HW_Config(HW_Out_t out, HW_Status_t status)
{
    HW_Level_t level;

    level = status ? _outs[out].activeLevel : ! _outs[out].activeLevel;
    HW_Set(out, level);
}

HW_Status_t HW_IsConfigedActive(HW_Out_t out)
{
    HW_Level_t level;

    level = HW_GetSetted(out);
    return (level == _outs[out].activeLevel) ? HW_Status_Active : HW_Status_Inactive;
}

int HW_IsActive(HW_In_t in)
{
    HW_Level_t level;

    level = HW_Get(in);
    return level == _ins[in].activeLevel;
}

int HW_IsExtiActive(HW_Exti_t exti)
{
    GPIO_TypeDef *port;
    uint16_t pin;
    HW_Level_t level;

    port = _ports[_extis[exti].portIndex];
    pin = _pinAttribs[_extis[exti].pinIndex].pin;
    level = ((port->IDR & pin) == 0) ? HW_Level_Low : HW_Level_High;
    return (level == _extis[exti].activeLevel) ? HW_Status_Active : HW_Status_Inactive;
}

unsigned int HW_ReadBoardAddres(void)
{
    HW_In_t sn;
    unsigned int addr, d;

    addr = 0;
    d = 0x01;
    for(sn = HW_In_S2; sn <= HW_In_S3; sn++)
    {
        if(HW_IsActive(sn))
        {
            addr |= d;
        }

        d <<= 1;
    }

    return addr;
}

void HW_SetExtiCallback(HW_Exti_t exti, HW_ExtiCallback_t cb, int data)
{
    _extiCbProfiles[exti].cb = cb;
    _extiCbProfiles[exti].data = data;
}

static void _ExtiIRQHandler(int pinIndexFrom, int pinIndexTo)
{
    HW_Exti_t exti;
    int pinIndex;

    for(exti = 0; exti < ARRAY_SIZE(_extis); exti++)
    {
        pinIndex = _extis[exti].pinIndex;
        if((pinIndex >= pinIndexFrom) && (pinIndex <= pinIndexTo))
        {
            if(EXTI_GetITStatus(_pinAttribs[pinIndex].extiLine) != RESET)
            {
                _extiCbProfiles[exti].cb(exti);
                EXTI_ClearITPendingBit(_pinAttribs[pinIndex].extiLine);
                break;
            }
        }
    }
}

void EXTI0_IRQHandler(void)
{
    _ExtiIRQHandler(0, 0);
}

void EXTI1_IRQHandler(void)
{
    _ExtiIRQHandler(1, 1);
}

void EXTI2_IRQHandler(void)
{
    _ExtiIRQHandler(2, 2);
}

void EXTI3_IRQHandler(void)
{
    _ExtiIRQHandler(3, 3);
}

void EXTI4_IRQHandler(void)
{
    _ExtiIRQHandler(4, 4);
}

void EXTI9_5_IRQHandler(void)
{
    _ExtiIRQHandler(5, 9);
}

void EXTI15_10_IRQHandler(void)
{
    _ExtiIRQHandler(10, 15);
}

int HW_IoInCmd(int argc, char *argv[])
{
    HW_In_t in;
    char name[8];
    unsigned int len, i;
    bool isExist;

    if(argc == 1)
    {
        for(in = 0; in < ARRAY_SIZE(_inNames); in++)
        {
            printf("%s: %s ", _inNames[in], HW_Get(in) == HW_Level_High ? "1" : "0");
        }
    }
    else if(argc == 2)
    {
        len = strlen(argv[1]);
        if(len >= ARRAY_SIZE(name))
        {
            printf("Unknown IO name! ");
            return -1;
        }

        for(i = 0; i < len; i++)
        {
            name = toupper(argv[1]);
        }
        name = '';

        isExist = FALSE;
        for(in = 0; in < ARRAY_SIZE(_inNames); in++)
        {
            if(strcmp(name, _inNames[in]) == 0)
            {
                printf("%s: %s ", _inNames[in], HW_Get(in) == HW_Level_High ? "1" : "0");
                isExist = TRUE;
                break;
            }
        }

        if(! isExist)
        {
            printf("Unknown IO name! ");
        }
    }

    return 0;
}

int HW_IoOutCmd(int argc, char *argv[])
{
    HW_Out_t out;
    char name[8];
    unsigned int len, i;
    bool isExist;
    int l;

    if(argc == 1)
    {
        for(out = 0; out < ARRAY_SIZE(_outNames); out++)
        {
            printf("%s: %s ", _outNames[out],
                    HW_GetSetted(out) == HW_Level_High ? "1" : "0");
        }
    }
    else if(argc >= 2)
    {
        len = strlen(argv[1]);
        if(len >= ARRAY_SIZE(name))
        {
            printf("Unknown IO name! ");
            return -1;
        }

        for(i = 0; i < len; i++)
        {
            name = toupper(argv[1]);
        }
        name = '';

        isExist = FALSE;
        for(out = 0; out < ARRAY_SIZE(_outNames); out++)
        {
            if(strcmp(name, _outNames[out]) == 0)
            {
                isExist = TRUE;
                break;
            }
        }

        if(isExist)
        {
            if(argc == 2)
            {
                printf("%s: %s ", _outNames[out],
                        HW_GetSetted(out) == HW_Level_High ? "1" : "0");
            }
            else
            {
                l = atoi(argv[2]);
                HW_Set(out, l ? HW_Level_High : HW_Level_Low);
                printf("%s: Set to %s ", _outNames[out], l ? "1" : "0");
            }
        }
        else
        {
            printf("Unknown IO name! ");
        }
    }

    return 0;
}[/mw_shl_code]