/ - Diff - LCOM1920-T5G03 - FEUP Project Manager

     #include "font.h"
     /**
      * @brief Menu.
      */
     typedef struct menu menu_t;
     /**
      * @brief Construct menu.
      * @param   fnt Font to use when rendering menu options text
      * @return      Pointer to constructed menu, or NULL if failed.
      */
     menu_t* (menu_ctor)(const font_t *fnt);
     /**
      * @brief Destruct menu.
      * @param   p   Pointer to menu to destruct
      */
     void (menu_dtor)(menu_t *p);
     /**
      * @brief Add item to menu.
      * @param   menu    Pointer to menu
      * @param   s       String to be used as text for the new item
      * @return  SUCCESS if operation was successful, other value otherwise
      */
     int (menu_add_item)(menu_t *menu, const char *s);
     /**
      * @brief Update menu state.
+     *
      * This function allows to check if the mouse is hovering over an item, and knowing
      * if an item was clicked.
      * @param   menu    Pointer to menu
      * @param   click   0 if mouse right button is clicked, other value otherwise
      * @return  selected option if clicked, -1 otherwise
      */
     int (menu_update_state)(menu_t *menu, int click);
     /**
      * @brief Draw menu on screen buffer.
      * @param   menu    Pointer to menu to be drawn
      */
     void (menu_draw)(menu_t *menu);
     void (menu_dtor)(menu_t *p);
     /**
      * @}
      */

      * @{
      */
     /**
      * @brief Rectangle.
      */
     typedef struct rectangle rectangle_t;
     /**
      * @brief Construct rectangle.
      * @param   x   X-position of upper-left corner
      * @param   y   Y-position of upper-left corner
      * @param   w   Width
      * @param   h   Height
      * @return      Pointer to constructed rectangle, or NULL if failed
      */
     rectangle_t* (rectangle_ctor)(int16_t x, int16_t y, uint16_t w, uint16_t h);
     /**
      * @brief Destruct rectangle.
      * @param   p   Pointer to rectangle to be destructed
      */
     void         (rectangle_dtor)(rectangle_t *p);
     /**
      * @brief Set rectangle position.
      * @param   p   Pointer to rectangle
      * @param   x   X-position of the upper-left corner
      * @param   y   Y-position of the upper-left corner
      */
     void (rectangle_set_pos)          (rectangle_t *p,  int16_t x,  int16_t y);
     /**
      * @brief Set rectangle size.
      * @param   p   Pointer to rectangle
      * @param   w   Width
      * @param   h   Height
      */
     void (rectangle_set_size)         (rectangle_t *p, uint16_t w, uint16_t h);
     /**
      * @brief Set rectangle fill color.
      * @param   p       Pointer to rectangle
      * @param   color   Color to fill rectangle
      */
     void (rectangle_set_fill_color)   (rectangle_t *p, uint32_t color);
     /**
      * @brief Set rectangle fill transparency.
      * @param   p       Pointer to rectangle
      * @param   alpha   Value of the alpha-channel
      */
     void (rectangle_set_fill_trans)   (rectangle_t *p, uint8_t  alpha);
     /**
      * @brief Set rectangle outline color.
      * @param   p       Pointer to rectangle
      * @param   color   Color to outline rectangle
      */
     void (rectangle_set_outline_color)(rectangle_t *p, uint32_t color);
     /**
      * @brief Set rectangle outline width.
      * @param   p       Pointer to rectangle
      * @param   width   Width of the rectangle border/outline
      */
     void (rectangle_set_outline_width)(rectangle_t *p,  int16_t width);
     /**
      * @brief Get rectangle x-position.
      * @param   p   Pointer to rectangle
      * @return      Rectangle x-position
      */
     int16_t  (rectangle_get_x)(const rectangle_t *p);
     /**
      * @brief Get rectangle y-position.
      * @param   p   Pointer to rectangle
      * @return      Rectangle y-position
      */
     int16_t  (rectangle_get_y)(const rectangle_t *p);
     /**
      * @brief Get rectangle width.
      * @param   p   Pointer to rectangle
      * @return      Rectangle width
      */
     uint16_t (rectangle_get_w)(const rectangle_t *p);
     /**
      * @brief Get rectangle height.
      * @param   p   Pointer to rectangle
      * @return      Rectangle height
      */
     uint16_t (rectangle_get_h)(const rectangle_t *p);
     /**
      * @brief Know if point in screen coordinates lies inside rectangle.
      * @param   p   Pointer to rectangle
      * @param   x   X-position of the point
      * @param   y   Y-position of the point
      * @return      True if the point lies inside the rectangle, false otherwise.
      */
     int      (rectangle_collide_point)(const rectangle_t *p, int x, int y);
     /**
      * Draw rectangle in screen buffer.
      * @param   p   Pointer to rectangle to be drawn
      */
     void (rectangle_draw)(const rectangle_t *p);
     /**

     #ifndef KBC_H_INCLUDED
     #define KBC_H_INCLUDED
     /**
      * This file concerns everything related to the KBC (KeyBoard Controller, which
      * actually also manages the mouse)
      * @defgroup    kbc kbc
      * @brief   KBC module.
+     *
      * @{
      */
     #ifndef KBC_H_INCLUDED
     #define KBC_H_INCLUDED
     /* KBC IRQ Line */
     /** @brief KBC Controller IRQ Line */
     #define KBC_IRQ     1
     /** @brief Mouse IRQ Line */
     #define MOUSE_IRQ   12
     #define KBC_IRQ     1   /* @brief KBC Controller IRQ Line */
     #define MOUSE_IRQ   12  /* @brief Mouse IRQ Line */
     /* Delay for KBC */
     #define DELAY           20000 /* @brief KBC Response Delay */
     #define KBC_NUM_TRIES   20    /* @brief Number of tries to issue command before timeout */
     /** @brief KBC Response Delay */
     #define DELAY           20000
     /** @brief Number of tries to issue command before timeout */
     #define KBC_NUM_TRIES   20
     /* I/O Ports Addresses */
     /** @brief Address to send commands to KBC */
     #define KBC_CMD     0x64
     /** @brief Address to write KBC Command Arguments */
     #define KBC_CMD_ARG 0x60
     /** @brief KBC Status Register address */
     #define STATUS_REG  0x64
     /** @brief Address of Output Buffer of KBC */
     #define OUTPUT_BUF  0x60
     #define KBC_CMD     0x64 /* @brief Address to send commands to KBC */
     #define KBC_CMD_ARG 0x60 /* @brief Address to write KBC Command Arguments */
     #define STATUS_REG  0x64 /* @brief KBC Status Register address */
     #define OUTPUT_BUF  0x60 /* @brief Address of Output Buffer of KBC */
     /* KBC Commands */
     #define READ_KBC_CMD    0x20 /* @brief Read KBC Command Byte */
     #define WRITE_KBC_CMD   0x60 /* @brief Write KBC Command Byte */
     #define KBC_SELF_TEST   0xAA /* @brief KBC Diagnostic Tests */
     #define KBC_INT_TEST    0xAB /* @brief Tests Keyboard Clock and Data lines */
     #define KBC_INT_DISABLE 0xAD /* @brief Disable KBC Interface */
     #define KBC_INT_ENABLE  0xAE /* @brief Enable KBC Interface */
     #define MOUSE_DISABLE   0xA7 /* @brief Disable Mouse */
     #define MOUSE_ENABLE    0xA8 /* @brief Enable Mouse */
     #define MOUSE_INT_TEST  0xA9 /* @brief Tests Mouse data line */
     #define MOUSE_WRITE_B   0xD4 /* @brief Write a byte directly to the mouse */
     /** @brief Read KBC Command Byte */
     #define READ_KBC_CMD    0x20
     /** @brief Write KBC Command Byte */
     #define WRITE_KBC_CMD   0x60
     /** @brief KBC Diagnostic Tests */
     #define KBC_SELF_TEST   0xAA
     /** @brief Tests Keyboard Clock and Data lines */
     #define KBC_INT_TEST    0xAB
     /** @brief Disable KBC Interface */
     #define KBC_INT_DISABLE 0xAD
     /** @brief Enable KBC Interface */
     #define KBC_INT_ENABLE  0xAE
     /** @brief Disable Mouse */
     #define MOUSE_DISABLE   0xA7
     /** @brief Enable Mouse */
     #define MOUSE_ENABLE    0xA8
     /** @brief Tests Mouse data line */
     #define MOUSE_INT_TEST  0xA9
     /** @brief Write a byte directly to the mouse */
     #define MOUSE_WRITE_B   0xD4
     /* Status Byte Masking */
     /** @brief Output Buffer State */
     #define OUT_BUF_FUL     BIT(0)
     /** @brief Input Buffer State */
     #define IN_BUF_FULL     BIT(1)
     /** @brief System Flag */
     #define SYS_FLAG        BIT(2)
     /** @brief Identifier of type of byte in input buffer */
     #define DATA_CMD_WRITE  BIT(3)
     /** @brief Keyboard inihibited */
     #define INH_FLAG        BIT(4)
     /** @brief Mouse Data */
     #define AUX_MOUSE       BIT(5)
     /** @brief Time Out Error - Invalid Data */
     #define TIME_OUT_REC    BIT(6)
     /** @brief Parity Error - Invalid Data */
     #define PARITY_ERROR    BIT(7)
     #define OUT_BUF_FUL     BIT(0) /* @brief Output Buffer State */
     #define IN_BUF_FULL     BIT(1) /* @brief Input Buffer State */
     #define SYS_FLAG        BIT(2) /* @brief System Flag */
     #define DATA_CMD_WRITE  BIT(3) /* @brief Identifier of type of byte in input buffer */
     #define INH_FLAG        BIT(4) /* @brief Keyboard inihibited */
     #define AUX_MOUSE       BIT(5) /* @brief Mouse Data */
     #define TIME_OUT_REC    BIT(6) /* @brief Time Out Error - Invalid Data */
     #define PARITY_ERROR    BIT(7) /* @brief Parity Error - Invalid Data */
     /* Scancode Constants */
     /** @brief ESC Break Code */
     #define ESC_BREAK_CODE  0x81
     /** @brief First byte of a two byte Scancode */
     #define TWO_BYTE_CODE   0xE0
     /** @brief Bit to distinguish between Make code and Break code */
     #define BREAK_CODE_BIT  BIT(7)
     #define ESC_BREAK_CODE  0x81    /* @brief ESC Break Code */
     #define TWO_BYTE_CODE   0xE0    /* @brief First byte of a two byte Scancode */
     #define BREAK_CODE_BIT  BIT(7)  /* @brief Bit to distinguish between Make code and Break code */
     /* Command byte masks */
     #define INT_KBD         BIT(0)  /* @brief Enable Keyboard Interrupts */
     #define INT_MOU         BIT(1)  /* @brief Enable Mouse Interrupts */
     #define DIS_KBD         BIT(4)  /* @brief Disable Keyboard */
     #define DIS_MOU         BIT(5)  /* @brief Disable Mouse */
     /** @brief Enable Keyboard Interrupts */
     #define INT_KBD         BIT(0)
     /** @brief Enable Mouse Interrupts */
     #define INT_MOU         BIT(1)
     /** @brief Disable Keyboard */
     #define DIS_KBD         BIT(4)
     /** @brief Disable Mouse */
     #define DIS_MOU         BIT(5)
     /**
      * @brief High-level function that reads the command byte of the KBC
-...
     /**
      * @brief High-level function that restores KBC to normal state
+     *
      * High-level function that restores KBC to normal state, because lcf_start
      * changes the command byte of KBC. If this function is not used, there is a
      * chance that the keyboard and keyboard interrupts remain disabled.
-...
     /**
      * @brief Low-level function for reading byte from keyboard
+     *
      * Low-level function for reading byte from keyboard. Waits until output buffer
      * is full
      * @param byte Pointer to variable where byte read from keyboard will be stored
-...
      */
     int (kbc_read_byte)(uint8_t *byte);
     /**
      * @}
      */
     #endif //KBC_H_INCLUDED

     #ifndef KEYBOARD_H_INCLUDED
     #define KEYBOARD_H_INCLUDED
     /**
      * This file concerns everything related to the keyboard
      * @defgroup    keyboard    keyboard
      * @ingroup kbc
      * @brief Keyboard module.
+     *
      * @{
      */
     #ifndef KEYBOARD_H_INCLUDED
     #define KEYBOARD_H_INCLUDED
     #include "kbc.h"
     #define W_MAKE_CODE             0x11    /** @brief W Make Code */
     #define W_BREAK_CODE            0x91    /** @brief W Break Code */
     #define A_MAKE_CODE             0x1E    /** @brief A Make Code */
     #define A_BREAK_CODE            0x9E    /** @brief A Break Code */
     #define S_MAKE_CODE             0x1F    /** @brief S Make Code */
     #define S_BREAK_CODE            0x9F    /** @brief S Break Code */
     #define D_MAKE_CODE             0x20    /** @brief D Make Code */
     #define D_BREAK_CODE            0xA0    /** @brief D Break Code */
     #define CTRL_MAKE_CODE          0x1D    /** @brief CTRL Make Code */
     #define CTRL_BREAK_CODE         0x9D    /** @brief CTRL Break Code */
     #define PLUS_MAKE_CODE          0x1A    /** @brief Plus (+) Make Code */
     #define PLUS_BREAK_CODE         0x9A    /** @brief Plus (+) Break Code */
     #define MINUS_MAKE_CODE         0x35    /** @brief Minus (-) Make Code */
     #define MINUS_BREAK_CODE        0xB5    /** @brief Minus (-) Break Code */
     /** @brief W Make Code */
     #define W_MAKE_CODE             0x11
     /** @brief W Break Code */
     #define W_BREAK_CODE            0x91
     /** @brief A Make Code */
     #define A_MAKE_CODE             0x1E
     /** @brief A Break Code */
     #define A_BREAK_CODE            0x9E
     /** @brief S Make Code */
     #define S_MAKE_CODE             0x1F
     /** @brief S Break Code */
     #define S_BREAK_CODE            0x9F
     /** @brief D Make Code */
     #define D_MAKE_CODE             0x20
     /** @brief D Break Code */
     #define D_BREAK_CODE            0xA0
     /** @brief CTRL Make Code */
     #define CTRL_MAKE_CODE          0x1D
     /** @brief CTRL Break Code */
     #define CTRL_BREAK_CODE         0x9D
     /** @brief Plus (+) Make Code */
     #define PLUS_MAKE_CODE          0x1A
     /** @brief Plus (+) Break Code */
     #define PLUS_BREAK_CODE         0x9A
     /** @brief Minus (-) Make Code */
     #define MINUS_MAKE_CODE         0x35
     /** @brief Minus (-) Break Code */
     #define MINUS_BREAK_CODE        0xB5
     #define ENTER_MAKE_CODE         0x1C
     #define ENTER_BREAK_CODE        0x9C
     #define BACKSPACE_MAKE_CODE     0x0E
-...
     #define ESC_BREAK_CODE          0x81    /** @brief ESC Break Code */
     /**
      * @brief Subscribes Keyboard Interrupts and disables Minix Default IH
      * @brief Subscribes Keyboard Interrupts and disables Minix Default IH.
      * @param interrupt_bit Bit of Interrupt Vector that will be set when Keyboard Interrupt is pending
      * @param interrupt_id Keyboard Interrupt ID to specify the Keyboard Interrupt in other calls
      * @return ERROR_CODE code representing the result of the operation, SUCCESS code is returned if everything is OK
-...
      */
     int (subscribe_kbc_interrupt)(uint8_t interrupt_bit, int *interrupt_id);
     const uint8_t* keyboard_get_scancode(void);
     int keyboard_get_done(void);
     int keyboard_get_size(void);
-...
     int (keyboard_poll)(uint8_t bytes[], uint8_t *size);
     /**
      * @}
      */
     #endif //KEYBOARD_H_INCLUDED

     #define MOUSE_H_INCLUDED
     /**
      * @defgroup    mouse   mouse
      * @ingroup kbc
      * @brief   Mouse module.
+     *
      * @{
      */
     /**
      * @brief Subscribes Mouse Interrupts and disables Minix Default IH
      * @param interrupt_bit Bit of Interrupt Vector that will be set when Mouse Interrupt is pending
      * @param interrupt_id Mouse Interrupt ID to specify the Mouse Interrupt in other calls
-...
      */
     int16_t (sign_extend_byte)(uint8_t sign_bit, uint8_t byte);
     /**
      * @}
      */
     #endif //MOUSE_H_INCLUDED

     #ifndef RTC_H_INCLUDED
     #define RTC_H_INCLUDED
     /**
      * @defgroup    rtc rtc
      * @brief RTC (Real-Time Clock) module.
+     *
      * @{
      */
     #include <stdint.h>
     /**
-...
      */
     int (rtc_read_date)(uint8_t *date);
     /**
      * @}
      */
     #endif /* end of include guard: RTC_H_INCLUDED */

     #ifndef TIMER_H_INCLUDED
     #define TIMER_H_INCLUDED
     /**
      * This file concerns everything related to the timer
      * @defgroup    timer   timer
      * @brief   Timer module.
+     *
      * @{
      */
     #ifndef TIMER_H_INCLUDED
     #define TIMER_H_INCLUDED
     /** @brief Timer 0 IRQ line */
     #define TIMER0_IRQ     0
     #define TIMER0_IRQ     0                                                                /**< @brief Timer 0 IRQ line */
     int (subscribe_timer_interrupt)(uint8_t interrupt_bit, int *interrupt_id);
     void (timer_int_handler)(void);
     uint32_t (timer_get_no_interrupts)(void);
     /**
      * @}
      */
     #endif //TIMER_H_INCLUDED

     #ifndef HLTP_H_INCLUDED
     #define HLTP_H_INCLUDED
     /**
      * @defgroup    hltp    hltp
      * @ingroup nctp
      * @brief HLTP (High-Level Transfer Protocol) module.
+     *
      * @{
      */
     #include "uart.h"
     #include "proj_structures.h"
-...
         hltp_type_bullet  = 0x42
     } hltp_type;
     /**
      * @brief Send string.
      * @param   p   Pointer to string to be sent
      * @return  SUCCESS if operation was successful, other value otherwise
      */
     int hltp_send_string(const char *p);
     /**
      * @brief Send host_info.
      * @param   p   Pointer to host_info to be sent
      * @return  SUCCESS if operation was successful, other value otherwise
      */
     int hltp_send_host_info(const host_info_t *p);
     /**
      * @brief Send remote_info.
      * @param   p   Pointer to remote_info to be sent
      * @return  SUCCESS if operation was successful, other value otherwise
      */
     int hltp_send_remote_info(const remote_info_t *p);
     /**
      * @brief Send bullet_info.
      * @param   p   Pointer to bullet_info to be sent
      * @return  SUCCESS if operation was successful, other value otherwise
      */
     int hltp_send_bullet_info(const bullet_info_t *p);
     /**
      * @brief Interpret message received as one of the structs HLTP knows.
      * @param   p       Pointer to beginning of message
      * @param   sz      Size of message
      * @param   dest    Pointer to void*, to where the interpreted message will be saved
      * @return          Code of the interpreted message
      */
     hltp_type hltp_interpret(const uint8_t *p, const size_t sz, void **dest);
     /**
      * @}
      */
     #endif //HLTP_H_INCLUDED

     #ifndef UART_H_INCLUDED
     #define UART_H_INCLUDED
     /**
      * @defgroup uart uart
      * @brief UART module.
+     *
      * @{
      */
     #define COM1_ADDR           0x3F8
     #define COM2_ADDR           0x2F8
     #define COM1_IRQ            4
-...
         uint8_t modem_stat_int        :1;
     } uart_config;
     /**
      * @brief Subscribes UART interrupts and disables Minix Default IH.
      * @param interrupt_bit Bit of interrupt vector that will be set when UART interrupt is pending
      * @param interrupt_id UART interrupt ID to specify the UART interrupt in other calls
      * @return ERROR_CODE code representing the result of the operation, SUCCESS code is returned if everything is OK
      * @see {_ERRORS_H_::errors}
      */
     int (subscribe_uart_interrupt)(uint8_t interrupt_bit, int *interrupt_id);
     /**
      * @brief Get UART configuration.
      * @param   base_addr   Base address of the serial port whose configuration we want
      * @param   config      Pointer to uart_config where the read configuration will be stored
      * @return SUCCESS if operation is successful, other value otherwise
      */
     int uart_get_config(int base_addr, uart_config *config);
     /**
      * @brief Print to stdout a UART configuration in a human-friendly way.
      * @param   config  UART configuration to be printed
      */
     void uart_print_config(uart_config config);
     /**
      * @brief Set number of bits per character.
+     *
      * Valid numbers of bits per char go from 5 to 8.
      * @param   base_addr       Base address of serial port
      * @param   bits_per_char   Number of bits per char
      * @return                  SUCCESS if operation is successful, other value otherwise
      */
     int uart_set_bits_per_character(int base_addr, uint8_t     bits_per_char);
     /**
      * @brief Set number of stop bits.
+     *
      * Valid numbers of stop bits are 1 and 2.
      * @param   base_addr   Base address of serial port
      * @param   stop        Number of stop bits
      * @return              SUCCESS if operation is successful, other value otherwise
      */
     int uart_set_stop_bits         (int base_addr, uint8_t     stop         );
     /**
      * @brief Set parity scheme to be used.
      * @param   base_addr   Base address of serial port
      * @param   par         Parity scheme
      * @return              SUCCESS if operation is successful, other value otherwise
      */
     int uart_set_parity            (int base_addr, uart_parity par          );
     /**
      * @brief Set bit rate.
+     *
      * Valid numbers of bit rates go up to 115200 bps.
      * @param   base_addr       Base address of serial port
      * @param   bit_rate        Number of bits per second
      * @return                  SUCCESS if operation is successful, other value otherwise
      */
     int uart_set_bit_rate          (int base_addr, uint32_t    bit_rate     );
     /**
      * @brief Enable Receiver Register Ready interrupts
      * @param   base_addr   Base address of serial port
      * @return              SUCCESS if operation is successful, other value otherwise
      */
     int uart_enable_int_rx (int base_addr);
     /**
      * @brief Disable Receiver Register Ready interrupts
      * @param   base_addr   Base address of serial port
      * @return              SUCCESS if operation is successful, other value otherwise
      */
     int uart_disable_int_rx(int base_addr);
     /**
      * @brief Enable Transmitter Register Empty interrupts
      * @param   base_addr   Base address of serial port
      * @return              SUCCESS if operation is successful, other value otherwise
      */
     int uart_enable_int_tx (int base_addr);
     /**
      * @brief Disable Transmitter Register Empty interrupts
      * @param   base_addr   Base address of serial port
      * @return              SUCCESS if operation is successful, other value otherwise
      */
     int uart_disable_int_tx(int base_addr);
     /// NCTP - Non-critical transmission protocol
     /**
      * @}
      */
     /**
     * @defgroup nctp    nctp
     * @ingroup uart
     * @brief NCTP (Non-Critical Transfer Protocol) module.
     * @{
     */
     /**
      * @brief Initialize NCTP structures.
      * @return SUCCESS if operation is successful, other value otherwise
      */
     int nctp_init(void);
     /**
      * @brief Dump all the content of the NCTP in/out queues.
      * @return SUCCESS if operation is successful, other value otherwise
      */
     int nctp_dump(void);
     /**
      * @brief Set function to be called when a full message is received.
      * @return SUCCESS if operation is successful, other value otherwise
      */
     int nctp_set_processor(void (*proc_func)(const uint8_t*, const size_t));
     /**
      * @brief Free resources taken on NCTP initialization.
      * @return SUCCESS if operation is successful, other value otherwise
      */
     int nctp_free(void);
     /**
      * @brief Send a message throught serial port COM1
      * @param   num     Number of different blocks to send in the message
      * @param   ptr     Array of length num, with pointers to blocks that should be sent
      * @param   sz      Size of each block that should be sent, in bytes
      * @return SUCCESS if operation is successful, other value otherwise
      */
     int nctp_send(size_t num, const uint8_t *const *ptr, const size_t *const sz);
     /**
      * @brief Get NCTP interrupt handler error code.
      * @return  SUCCESS if previous interrupt handler call was successful, other value otherwise
      */
     int (nctp_get_ih_error)(void);
     /**
      * @brief NCTP interrupt handler.
+     *
      * @note Must be called on all interrupt cycles. Even if not necessary, it must be
      * called so the NCTP is allowed to dump any messages it might receive, even
      * if those messages are unexpected.
      */
     void nctp_ih(void);
     /**
      * @}
      */
     #endif //UART_H_INCLUDED

     #ifndef ERRORS_H_INCLUDED
     #define ERRORS_H_INCLUDED
     /**
      * @defgroup    errors  errors
      * @brief Error codes.
+     *
      * @{
      */
     /** @brief Error Codes */
     enum errors {
         SUCCESS = 0,        /** @brief Sucessful */
-...
         OTHER_ERROR         /** @brief Unspecified error */
     };
     /**
      * @}
      */
     #endif //ERRORS_H_INCLUDED

     #ifndef FAST_MATH_H_INCLUDED
     #define FAST_MATH_H_INCLUDED
     /**
      * @defgroup fast_math  fast_math
      * @ingroup utils
      * @brief   Fast math module.
+     *
      * Essentially, this module provides almost-constant time for mathematical operations
      * that do not require extreme precision.
+     *
      * @{
      */
     /**
      * @brief Fast sine function.
      * @param   x   Argument
      * @return      Sine of x
      */
     double fm_sin(double x);
     /**
      * @brief Fast cosine function.
      * @param   x   Argument
      * @return      Cosine of x
      */
     double fm_cos(double x);
     /**
      * @}
      */
     #endif //FAST_MATH_H_INCLUDED

     #ifndef UTILS_H_INCLUDED
     #define UTILS_H_INCLUDED
     #define BCD_FIRST(n)     (n >> 4)       /** @brief Get first digit (leftmost digit) of 8-bit BCD */
     #define BCD_SECOND(n)    (n & 0x0F)     /** @brief Get second digit (rightmost digit) of 8-bit BCD */
     /**
      * @defgroup utils utils
      * @brief Utilities module.
+     *
      * @{
      */
     /** @brief Get first digit (leftmost digit) of 8-bit BCD */
     #define BCD_FIRST(n)     (n >> 4)
     /** @brief Get second digit (rightmost digit) of 8-bit BCD */
     #define BCD_SECOND(n)    (n & 0x0F)
     /**
      * @brief Gets the least significant byte of a 16-bit variable
      * @param val 16-bit variable
-...
     int32_t max32(int32_t a, int32_t b);
     double  dmax (double  a, double  b);
     /**
      * @brief Get the absolute value of a double.
      * @param   a   Argument
      * @return      Absolute value of a
      */
     double dabs(double a);
     /**
      * @brief Compare if two doubles are approximately equal (within 1e-10).
      * @param   a   First value
      * @param   b   Second value
      * @return      true if the two numbers are approximately equal, false otherwise
      */
     int deq(double a, double b);
     /**
      * @}
      */
     #endif //UTILS_H_INCLUDED

     #ifndef XMP_UTILS_H_INCLUDED
     #define XMP_UTILS_H_INCLUDED
     /**
      * @defgroup xpm_utils xpm_utils
      * @ingroup utils
      * @brief XPM utilities module.
+     *
      * @{
      */
     /**
      * @brief Save XPM array of strings as a XPM2 text file.
      * @param   p   XPM to be saved
      * @param   s   Path to save the XPM as XPM2 file
      */
     void xpm_save_as_xpm2(const char* const* p, const char *s);
     /**
      * @brief Load XPM2 file as a XPM array of strings.
      * @param   s   Path to XPM2 file to be loaded
      * @return      Array of strings representing the loaded XPM
      */
     char** xpm_load_xpm2(const char *s);
     /**
      * @}
      */
     #endif //XMP_UTILS_H_INCLUDED

Project

General

Profile

LCOM1920-T5G03

Revision 334