ATY_LIB/INCLUDE_ATY.h

/**
* @file INCLUDE_ATY.h
*
* @param Project DEVICE_GENERAL_ATY_LIB
*
* @author ATY
*
* @copyright
*       - Copyright 2017 - 2025 MZ-ATY
*       - This code follows:
*           - MZ-ATY Various Contents Joint Statement -
*               <a href="https://mengze.top/MZ-ATY_VCJS">
*                        https://mengze.top/MZ-ATY_VCJS</a>
*           - CC 4.0 BY-NC-SA -
*               <a href="https://creativecommons.org/licenses/by-nc-sa/4.0/">
*                        https://creativecommons.org/licenses/by-nc-sa/4.0/</a>
*       - Your use will be deemed to have accepted the terms of this statement.
*
* @brief Headers include or defines for all embedded code
*       - MCU main changes at GPIO/TIMER/PWM
*
* @version
*       - 1_01_220605 > ATY
*           -# Preliminary version, first Release
* @todo
*       - HW port file set independent
*       - Not support 64 platfrom, todo or never(and double)
********************************************************************************
*/


// fromelf.exe --bin -o  ./DIPM_ATY_ST_V3/DIPM_ATY_ST_V3.bin ./DIPM_ATY_ST_V3/DIPM_ATY_ST_V3.axf
/* Keyword ********************************************************************
ANSI C:
auto
break
case
char
const
continue
default
do
double
else
enum
extern
float
for
goto
if
int
long
register
return
short
signed
sizeof
static
struct
switch
typedef
union
unsigned
void
volatile
while

C99:
inline
restrict
_Bool
_Complex
_Imaginary

C11:
_Alignas
_Alignof
_Atomic
_Static_assert
_Noreturn
_Thread_local
_Generic

C51:
_at_
_priority_
_task_
alien
bdata
bit
code
compact
data
idata
interrupt
large
pdata
reentrant
sbit
sfr
sfr16
small
using
xdata
********************************************************************************
*/

#ifndef __INCLUDE_ATY_H
#define __INCLUDE_ATY_H

/******************************* Data Type ************************************/
// #define __UNUSED(x) ((void)(x))
#define __UNUSED(x) (x = x) // not suit for const, used for function formal parameter uaually

#ifndef __stdint_h
#define __stdint_h

#ifndef bit
#define bit uint8_t
#endif /* bit */

#ifndef _UINT8_T
#define _UINT8_T
typedef unsigned char uint8_t;
#endif /* _UINT8_T */

#ifndef _UINT16_T
#define _UINT16_T
typedef unsigned short int uint16_t;
#endif /* _UINT16_T */

#ifndef _UINT32_T
#define _UINT32_T
typedef unsigned long uint32_t;
#endif /* _UINT32_T */

#ifndef _UINT64_T
#define _UINT64_T
#if defined (SDCC) || defined(__SDCC) || defined(__CX51__) || defined(__C51__)
typedef unsigned long int uint64_t;  // uint64_t at 64 bit platform with ulong
#else
typedef unsigned long long int uint64_t;
#endif /* uint64_t */
#endif /* _UINT64_T */

typedef signed char int8_t;
typedef signed short int int16_t;
typedef signed int int32_t;
#if defined (SDCC) || defined(__SDCC) || defined(__CX51__) || defined(__C51__)
typedef signed long int int64_t;
#else
typedef signed long long int int64_t;
#endif /* int64_t */
#endif /* __stdint_h */

/******************************* Platform *************************************/
#if defined (__SDCC_SYNTAX_FIX)
#include <stdbool.h>
#include <lint.h>
# warning unrecognized compiler
#define __BIT                   bool
#define __DATA
#define __IDATA
#define __PDATA
#define __XDATA
#define __CODE
#define __REENTRANT
#define SBIT(name, addr, bit)   volatile bool name
#define SFR(name, addr)         volatile unsigned char name
#define SFRX(addr)              (*(unsigned char volatile *)(addr))
#define SFR16X(addr)            (*(unsigned char volatile *)(addr))
#define INTERRUPT(name, vector) void name (void)
#define INTERRUPT_USING(name, vector, regnum) void name (void)
#define __NOP_ATY
#define __WEAK_ATY

#elif defined(SDCC) || defined(__SDCC)
#define __BIT                   __bit
#define __DATA                  __data
#define __IDATA                 __idata
#define __PDATA                 __pdata
#define __XDATA                 __xdata
#define __CODE                  __code
#define __REENTRANT             __reentrant
#define SBIT(name, addr, bit)   __sbit __at(addr+bit) name
#define SFR(name, addr)         __sfr __at(addr) name
#define SFRX(addr)              (*(unsigned char volatile __xdata *)(addr))
#define SFR16X(addr)            (*(unsigned int  volatile __xdata *)(addr))

// #define INTERRUPT(name, vector) void name (void) __interrupt (vector)
// #define INTERRUPT_USING(name, vector, regnum) void name (void) __interrupt (vector) __using (regnum)
#define INTERRUPT(vector) __interrupt (vector)
#define INTERRUPT_USING(vector, regnum) __interrupt (vector) __using (regnum)
#define __NOP_ATY __asm NOP __endasm
#define __WEAK_ATY

#elif defined(__CX51__) || defined(__C51__)
// #warning Use C51
#define __BIT                   bit
#define __DATA                  data
#define __IDATA                 idata
#define __PDATA                 pdata
#define __XDATA                 xdata
#define __CODE                  code
#define __REENTRANT             reentrant
#define SBIT(name, addr, bit)   sbit name = addr^bit
#define SFR(name, addr)         sfr name = addr
#define SFRX(addr)              (*(unsigned char volatile xdata *)(addr))
#define SFR16X(addr)            (*(unsigned int  volatile xdata *)(addr))

// #define INTERRUPT(name, vector) void name (void) interrupt vector
// #define INTERRUPT_USING(name, vector, regnum) void name (void) interrupt vector using regnum
#define INTERRUPT(vector) interrupt vector
#define INTERRUPT_USING(vector, regnum) interrupt vector using regnum
#include <intrins.h>    // _nop_()
extern void _nop_(void);
#define __NOP_ATY _nop_()
#define __WEAK_ATY

#elif defined(__ICCARM__) || defined(__CC_ARM)
// #include <stdint.h>
#define __BIT                   bit
#define __DATA
#define __IDATA
#define __PDATA
#define __XDATA

#define __CODE
#define __NOP_ATY __nop()

#if defined (__ICCARM__)
#define __WEAK_ATY __WEAK __ATTRIBUTES
#elif defined(__CC_ARM)
#define __WEAK_ATY __weak
#endif

#else
#warning Unsupported compiler!

#endif /* PLATFORM */



/******************************* For user *************************************/
// #define DBG_ATY(DBG_CODE, code)
// do{
// #ifdef DBG_CODE
//     code
// #endif
// }while(0)


#include "main.h"

// #if defined (__HC32_ATY) || \
//     defined(__STM32_SPL_ATY) || \
//     defined(__STM32_HAL_ATY) || \
//     defined(__STM32_LL_ATY)
// // shield warnings
// #pragma diag_suppress 550   // variable ""  was set but never used
// #pragma diag_suppress 177   // function ""  was declared but never referenced
// #pragma diag_suppress 186   // pointless comparison of unsigned integer with zero
// #pragma diag_suppress 1035  // single-precision operand implicitly converted to double-precision
// // #pragma diag_suppress 223
// #endif

// #ifdef __STC51_ATY
// #define BIG_ENDIAN                                      // chip in big endian mode, like 51
// #endif

// #if defined (__STC51_ATY)
// #define LOG_ATY(__STRING) UartSendStr(__STRING)
// #elif defined(__HC32_ATY) || \
//     defined(__STM32_SPL_ATY) || \
//     defined(__STM32_HAL_ATY) || \
//     defined(__STM32_LL_ATY)
// #include "HW_UART_ATY.h"
// #include "stdarg.h"
// #define LOG_ATY(__STRING) printf(__STRING)   // C99
// #define LOG_ATY__(__STRING, ...) printf(__STRING,##__VA_ARGS__)   // C99
// #else
// #define LOG_ATY(__STRING)
// #endif



// #if !defined(__PRINTF_ATY) && !defined(__stdio_h) && !defined(__STM32_HAL_ATY)
// #include "stdarg.h"
// __WEAK_ATY void printf(uint8_t*, ...);
// #endif /* __PRINTF_ATY */

/*
// todo, not tested and need to be adjust
// #include <stdio.h>      // printf(only for debug)
#if defined (__HC32_ATY) || \
    defined(__STM32_SPL_ATY) || \
    defined(__STM32_HAL_ATY) || \
    defined(__STM32_LL_ATY)
#include "STM32_HAL_PRINTF_ATY.h"
#include "stdarg.h"
#define LOG_ATY(__STRING, ...) printf(__STRING,##__VA_ARGS__)   // C99
#else
#include "HW_UART_ATY.h"
#include "stdarg.h"
#define LOG_ATY(...) UartSendStr(__VA_ARGS__)
#endif
*/

// Define device symbol to main header
// #define __STC51_ATY
// #define __STC8G_ATY
// #define __STC8H_ATY
// #define __HC32_ATY
// #define __STM32_SPL_ATY
// #define __STM32_LL_ATY
// #define __STM32_HAL_ATY
// #define __ESP8266_RTOS_ATY
// #define __ESP32_IDF_ATY

// #define __TIMER_CYCLE_ATY
// #define TIMERC_N htim4
// #define TIMERC_N 0

// #define __I2C_HARDWARE_ATY
// #define I2CH_N hi2c1
// #define I2CH_N 0
// #define I2CH_N I2C_NUM_0

// #define __SPI_HARDWARE_ATY
// #define SPIH_N hspi2
// #define SPIH_N 0

// #define __PWM_HARDWARE_ATY
// #define PWMH_N htim1
// #define PWMH_N TIM1
// #define PWMH_N 1

// #define DEBUG_PRINTF_RECEIVE
// #define PRINTF_UART huart3
// #define PRINTF_DMA hdma_usart3_rx
// extern DMA_HandleTypeDef PRINTF_DMA;


/******************************************************************************/
#define _ATY_IO_O 0
#define _ATY_IO_I 1
#define _ATY_HL_L 0
#define _ATY_HL_H 1
#define _ATY_RW_W 0
#define _ATY_RW_R 1
#define _ATY_RW_RW 2

#define _ATY_BUSY 99
#define _ATY_LOCKED 101
#define _ATY_UNLOCKED 102
#if (USE_RTOS == 1U)
#define __ATY_LOCK(__HANDLE__)
#define __ATY_UNLOCK(__HANDLE__)
#else
#define __ATY_LOCK(__HANDLE__)                  \
    do{                                         \
        if((__HANDLE__)->lock == _ATY_LOCKED) {  \
            return _ATY_BUSY;                    \
        }                                       \
        else {                                  \
            (__HANDLE__)->lock = _ATY_LOCKED;    \
        }                                       \
    }while (0U)

#define __ATY_UNLOCK(__HANDLE__)                \
    do{                                         \
        (__HANDLE__)->lock = _ATY_UNLOCKED;      \
    }while (0U)
#endif /* USE_RTOS */

#endif /* __INCLUDE_ATY_H */

/************************************ etc *************************************/
/* init */

/* use */

/******************************************************************************/



/******************************** End Of File *********************************/