Обновление до версии 0.3.0

- обновлен elbear_fw_bootloader - добавлена проверка контрольной суммы каждой строки hex файла.
- в модуль работы с АЦП добавлена функция analogReadResolution(). Функция analogRead() теперь возвращает усредненное по 10 измерениям значение.
- общая функция обработки прерываний перенесена в память RAM. Обработчики прерываний модулей External Interrupts и Advanced I/O (функция tone()) так же перенесены в память RAM для увеличения скорости выполнения кода.
- в пакет добавлены библиотеки EEPROM, Servo, SoftSerial, NeoPixel, MFRC522 адаптированные для работы с платой Elbear Ace-Uno.
- добавлено описание особенностей работы с пакетом

cores/arduino/HardwareSerial.cpp

@@ -5,7 +5,7 @@
 #include "HardwareSerial.h"
 #include <uart_lib.h> 
 #include "mik32_hal_irq.h"
-
+#include "wiring_LL.h" 
 
 // HardwareSerial class objects for use in Arduino IDE
 HardwareSerial Serial(0);
@@ -127,9 +127,9 @@ void HardwareSerial::rx_complete_irq(void)
   unsigned char c;
   // while there is something to receive, put the data into the buffer 
   // and edit the buffer index
-  while (!UART_IsRxFifoEmpty(uart))
+  while(!UART_IS_RX_FIFO_EMPTY(uart))
   {
-    c = UART_ReadByte(uart);
+    c = UART_READ_BYTE(uart);
     if (i != _rx_buffer_tail) 
     {
       // write if there is space in the buffer
@@ -140,7 +140,7 @@ void HardwareSerial::rx_complete_irq(void)
 }
 
 // wrapper for use in С-files
-extern "C" void serial_handler_wrapper(uint8_t uartNumInt) 
+extern "C" void __attribute__((optimize("O3"))) serial_interrupt_handler(uint8_t uartNumInt) 
 {
   if (uartNumInt == 0)
   {

cores/arduino/HardwareSerial.h

@@ -100,7 +100,7 @@ class HardwareSerial : public Stream
     using Print::write; // pull in write(str)
     operator bool() { return isInited; }
 
-    void rx_complete_irq(void);
+    inline void rx_complete_irq(void) __attribute__((always_inline, optimize("O3")));
 };
 
 extern HardwareSerial Serial;

cores/arduino/Tone.cpp

@@ -3,6 +3,7 @@
 
 #include "mik32_hal_timer16.h"
 #include "mik32_hal_irq.h"
+#include "wiring_LL.h" 
 
 #define PRESCALERS_QTY    7
 typedef struct
@@ -100,7 +101,7 @@ void tone(uint8_t pin, unsigned int frequency, unsigned long duration)
     HAL_EPIC_MaskLevelSet(HAL_EPIC_TIMER16_1_MASK);
 
     pinMode(pin, OUTPUT);
-    timer_pin_port->CLEAR = timer_pin_mask;
+    GPIO_CLEAR_PIN((GPIO_TypeDef *)timer_pin_port, timer_pin_mask);
 
     HAL_Timer16_Counter_Start_IT(&htimer16_1, frequencyParams.period_ticks);
     timerIsOn = true;
@@ -124,9 +125,10 @@ void noTone(uint8_t pin)
 {
   if (timerIsOn)
   {
-    timer_pin_port->CLEAR = timer_pin_mask;           // pin to 0
-    htimer16_1.Instance->CR &= ~TIMER16_CR_ENABLE_M;  // disable timer
-    HAL_EPIC_MaskLevelClear(HAL_EPIC_TIMER16_1_MASK);
+    // pin to 0
+    GPIO_CLEAR_PIN((GPIO_TypeDef *)timer_pin_port, timer_pin_mask);
+    TIM16_DISABLE(htimer16_1);
+    EPIC_LEVEL_CLEAR_BY_MASK(HAL_EPIC_TIMER16_1_MASK);
     pinMode(pin, INPUT);                              // deinit pin
     timer_pin = -1;                                   // reset to default
     timerIsOn = false;
@@ -134,25 +136,26 @@ void noTone(uint8_t pin)
 }
 
 // irq handler
-extern "C" void tone_interrupt_handler(void)
+extern "C" void __attribute__((noinline, section(".ram_text"), optimize("O3"))) tone_interrupt_handler(void)
 {
-  if ((htimer16_1.Instance->ISR & htimer16_1.Instance->IER) & TIMER16_ISR_ARR_MATCH_M)
+  if (TIM16_GET_ARRM_INT_STATUS(htimer16_1))
   {
     // timer period has passed, change the pin state
     if (timer_toggle_count != 0)
     {
-      timer_pin_port->OUTPUT_ ^= timer_pin_mask;
-
+      GPIO_TOGGLE_PIN((GPIO_TypeDef*)timer_pin_port, timer_pin_mask);
       if (timer_toggle_count > 0)
         timer_toggle_count--;
     }
     else
     {
       // turn off if the specified duration has passed
-      timer_pin_port->CLEAR = timer_pin_mask;
-      noTone(timer_pin);
+      GPIO_CLEAR_PIN((GPIO_TypeDef *)timer_pin_port, timer_pin_mask);           
+      TIM16_DISABLE(htimer16_1);
+      EPIC_LEVEL_CLEAR_BY_MASK(HAL_EPIC_TIMER16_1_MASK);
+      timerIsOn = false;
     }
   }  
   // reset timer interrupt flags
-  htimer16_1.Instance->ICR = 0xFFFFFFFF; 
+  TIM16_CLEAR_INT_MASK(htimer16_1, 0xFFFFFFFF);
 }

cores/arduino/WInterrupts.c

@@ -4,8 +4,7 @@
 #include "pins_arduino.h"
 #include "wiring_digital.h"
 #include "WInterrupts.h"
-
-extern void ErrorMsgHandler(const char * msg);
+#include "wiring_LL.h" 
 
 typedef void (*voidFuncPtr)(void);
 
@@ -18,13 +17,13 @@ static void nothing(void)
 // enable global interrupts
 void interrupts(void)
 {
-  HAL_IRQ_EnableInterrupts();
+  GLOBAL_IRQ_ENABLE();
 }
 
 // disable global interrupts
 void noInterrupts(void)
 {
-  HAL_IRQ_DisableInterrupts();
+  GLOBAL_IRQ_DISABLE();
 }
 
 // we can provide no more than 8 interrupts on gpio at the same time
@@ -100,33 +99,26 @@ void detachInterrupt(uint8_t interruptNum)
 void disableInterrupt(uint8_t interruptNum)
 {
   if(interruptNum < EXTERNAL_NUM_INTERRUPTS) 
-  {
-    int irq_line_num = interruptToGpioIntLine(interruptNum) >> GPIO_IRQ_LINE_S;
     // disable gpio interrupt line
-    GPIO_IRQ->ENABLE_CLEAR = (1 << irq_line_num);
-  }
+    GPIO_IRQ_LINE_DISABLE(interruptToGpioIntLine(interruptNum));
 }
 
 // enable single interrupt
 void enableInterrupt(uint8_t interruptNum)
 {
   if(interruptNum < EXTERNAL_NUM_INTERRUPTS) 
-  {
-    int irq_line_num = interruptToGpioIntLine(interruptNum) >> GPIO_IRQ_LINE_S;
     // enable gpio interrupt line
-    GPIO_IRQ->ENABLE_SET = (1 << irq_line_num);
-  }
+    GPIO_IRQ_LINE_ENABLE(interruptToGpioIntLine(interruptNum));
 }
 
 // common gpio interrupt handler 
-void gpio_interrupts_handler(void)
+void __attribute__((noinline, section(".ram_text"), optimize("O3"))) gpio_interrupt_handler(void)
 {
   // go through all the interrupts and call the handler for the triggered line
   for (uint8_t i = 0; i < EXTERNAL_NUM_INTERRUPTS; i++)
   {
-    if (HAL_GPIO_LineInterruptState(interruptToGpioIntLine(i)))
+    if (GPIO_IRQ_LINE_STATE(interruptToGpioIntLine(i)))
       intFunc[i]();
   }
-  
-  HAL_GPIO_ClearInterrupts();
+  GPIO_IRQ_CLEAR_ALL();
 }

cores/arduino/WString.cpp

@@ -19,6 +19,8 @@
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
+#pragma GCC diagnostic ignored "-Wrestrict" // for GCC and Clang
+
 #include "WString.h"
 #include "itoa.h"
 

cores/arduino/board.cpp

@@ -1,11 +1,15 @@
 #include "board.h"
 #include "mik32_hal_pcc.h"
+#include "mik32_hal_irq.h"
 #include "Arduino.h"
 
 // --------------------- init --------------------- // 
 // called before setup()
 void pre_init(void)
 {
+    // set irq vector to ram region
+    write_csr(mtvec, 0x02000000);
+
     HAL_Init();
 
     // gpio clock
@@ -26,11 +30,15 @@ void post_init(void)
 }
 
 // --------------------- other --------------------- // 
-// print text if Serial is enabled
+volatile bool use_error_messages = true;
+// print error message to Serial
 extern "C" void ErrorMsgHandler(const char * msg)
 {
-    if(Serial)
-        Serial.println(msg);
+    // function works if Serial is used in sketch and user doesn't turn it off
+    #ifdef HardwareSerial_h         
+        if(use_error_messages&&Serial)
+            Serial.println(msg);
+    #endif
 }
 
 

cores/arduino/board.h

@@ -1,6 +1,10 @@
 #ifndef _BOARD_H_
 #define _BOARD_H_
 
+extern volatile bool use_error_messages;
+#define DISABLE_ERROR_MESSAGES()    (use_error_messages = false)
+#define ENABLE_ERROR_MESSAGES()     (use_error_messages = true)
+
 // functions for init called before and after setup()
 void pre_init(void) ;
 void post_init(void);

cores/arduino/mik32/hal/peripherals/Include/mik32_hal_eeprom.h

@@ -7,7 +7,7 @@ extern "C" {
 
 #include "mik32_hal_def.h"
 #include <mcu32_memory_map.h>
-#include <eeprom.h>
+#include <eeprom_def.h>
 #include <power_manager.h>
 
 #ifndef HAL_EEPROM_TIMEOUT

cores/arduino/mik32/hal/peripherals/Include/mik32_hal_gpio.h

@@ -375,14 +375,96 @@ typedef enum __HAL_GPIO_InterruptMode
 
 HAL_StatusTypeDef HAL_GPIO_Init(GPIO_TypeDef *GPIO_x, GPIO_InitTypeDef *GPIO_Init);
 HAL_StatusTypeDef HAL_GPIO_PinConfig(GPIO_TypeDef *GPIO_x, HAL_PinsTypeDef pin, HAL_GPIO_ModeTypeDef mode, HAL_GPIO_PullTypeDef pull, HAL_GPIO_DSTypeDef driveStrength);
-GPIO_PinState HAL_GPIO_ReadPin(GPIO_TypeDef *GPIO_x, HAL_PinsTypeDef pin);
-void HAL_GPIO_WritePin(GPIO_TypeDef *GPIO_x, HAL_PinsTypeDef pin, GPIO_PinState pinState);
-void HAL_GPIO_TogglePin(GPIO_TypeDef *GPIO_x, HAL_PinsTypeDef pin);
 HAL_StatusTypeDef HAL_GPIO_InitInterruptLine(HAL_GPIO_Line_Config mux, HAL_GPIO_InterruptMode mode);
 HAL_StatusTypeDef HAL_GPIO_DeInitInterruptLine(HAL_GPIO_Line irqLine);
-uint32_t HAL_GPIO_LineInterruptState(HAL_GPIO_Line irqLine);
-GPIO_PinState HAL_GPIO_LinePinState(HAL_GPIO_Line irqLine);
-void HAL_GPIO_ClearInterrupts();
+
+/**
+ * @brief Считать текущее состояние выводов порта GPIO_x.
+ * @param GPIO_x порт GPIO_x, где x может быть (0, 1, 2).
+ * @param pin маска выводов порта GPIO_x, с которых считывание значение.
+ * @return @ref GPIO_PIN_HIGH если с одного или больше выводов, указанных в pin, считалась 1. Иначе @ref GPIO_PIN_LOW.
+ */
+static inline __attribute__((always_inline)) GPIO_PinState HAL_GPIO_ReadPin(GPIO_TypeDef *GPIO_x, HAL_PinsTypeDef pin)
+{
+    if ((GPIO_x->SET & pin) != (uint32_t)GPIO_PIN_LOW)
+    	return GPIO_PIN_HIGH;
+    else
+        return GPIO_PIN_LOW;
+}
+
+/**
+ * @brief Задать логический уровень выходного сигнала для указанных выводов порта GPIO_x.
+ * @param GPIO_x порт GPIO_x, где x может быть (0, 1, 2).
+ * @param pin маска выводов порта GPIO_x, к которым применяются указанные настройки.
+ * @param pinState значение состояние вывода, в которое будут установлены указанные выводы.
+ *                  Этот параметр должен быть одним из значений:
+ * 		                - @ref GPIO_PIN_LOW низкий выходной уровень
+ * 		                - @ref GPIO_PIN_HIGH высокий выходной уровень
+ */
+static inline __attribute__((always_inline)) void HAL_GPIO_WritePin(GPIO_TypeDef *GPIO_x, HAL_PinsTypeDef pin, GPIO_PinState pinState)
+{
+    if (pinState == GPIO_PIN_LOW)
+        GPIO_x->CLEAR = pin;
+    else
+        GPIO_x->SET = pin;
+}
+
+/**
+ * @brief Переключить логический уровень выходного сигнала для указанных выводов порта GPIO_x.
+ * @param GPIO_x порт GPIO_x, где x может быть (0, 1, 2).
+ * @param pin маска выводов порта GPIO_x, к которым применяются указанные настройки.
+ */
+static inline __attribute__((always_inline)) void HAL_GPIO_TogglePin(GPIO_TypeDef *GPIO_x, HAL_PinsTypeDef pin)
+{
+	GPIO_x->OUTPUT_ ^= pin;
+}
+
+/**
+ * @brief Возвращает направление вывода при работе в режиме вход/выход
+ * @param GPIO_x порт GPIO_x, где x может быть (0, 1, 2).
+ * @param pin маска вывода порта GPIO_x, направление которого необходимо узнать.
+ * @return Возвращает направление вывода - input или output.
+ */
+static inline __attribute__((always_inline)) HAL_GPIO_ModeTypeDef HAL_GPIO_GetPinDirection(GPIO_TypeDef *GPIO_x, HAL_PinsTypeDef pin)
+{
+	return (GPIO_x->DIRECTION_IN & pin) == 0 ? HAL_GPIO_MODE_GPIO_OUTPUT : HAL_GPIO_MODE_GPIO_INPUT;
+}
+
+/** 
+ * @brief Получить состояние линии прерывания.
+ * @param irqLine номер линии прерывания.
+ * @return Возвращает 1 если сработало прерывание данной линии, иначе 0.
+ */
+static inline __attribute__((always_inline)) uint32_t HAL_GPIO_LineInterruptState(HAL_GPIO_Line irqLine)
+{
+    int irq_line_num = irqLine >> GPIO_IRQ_LINE_S;
+    return (GPIO_IRQ->INTERRUPT & (1 << (irq_line_num))) != 0;
+}
+
+/**
+ * @brief Функция чтения логического уровня вывода, подключенного к линии прерывания.
+ * @param irqLine номер линии прерывания.
+ * @return Логический уровень вывода.
+ */
+static inline __attribute__((always_inline)) GPIO_PinState HAL_GPIO_LinePinState(HAL_GPIO_Line irqLine)
+{
+    int irq_line_num = irqLine >> GPIO_IRQ_LINE_S;
+    return (GPIO_PinState)((GPIO_IRQ->STATE & (1 << (irq_line_num))) >> irq_line_num);
+}
+
+/** 
+ *  @brief Функция сброса регистра состояния прерываний.
+ *  @note Когда срабатывает прерывание на одной из линии, в регистре INTERRUPT
+ *  выставляется 1 в разряде, соответствующем линии прерывания.
+ *  После обработки прерывания необходимо сбросить данный регистр
+ *  в обработчике прерывания trap_handler().
+ *  Если после обработки прерывания регистр не был сброшен,
+ *  обработчик будет вызван снова, программа будет бесконечно вызывать обработчик.
+ */
+static inline __attribute__((always_inline)) void HAL_GPIO_ClearInterrupts()
+{
+    GPIO_IRQ->CLEAR = 0b11111111;
+}
 
 #ifdef __cplusplus
 }

cores/arduino/mik32/hal/peripherals/Include/mik32_hal_i2c.h

@@ -380,9 +380,6 @@ typedef struct
 
 
 void HAL_I2C_MspInit(I2C_HandleTypeDef* hi2c);
-void HAL_I2C_Disable(I2C_HandleTypeDef *hi2c);
-void HAL_I2C_Reset(I2C_HandleTypeDef *hi2c);
-void HAL_I2C_Enable(I2C_HandleTypeDef *hi2c);
 void HAL_I2C_AnalogFilterInit(I2C_HandleTypeDef *hi2c, HAL_I2C_AnalogFilterTypeDef AnalogFilter);
 void HAL_I2C_DigitalFilterInit(I2C_HandleTypeDef *hi2c, HAL_I2C_DigitalFilterTypeDef DigitalFilter);
 void HAL_I2C_SetClockSpeed(I2C_HandleTypeDef *hi2c);
@@ -394,6 +391,7 @@ void HAL_I2C_SBCMode(I2C_HandleTypeDef *hi2c, HAL_I2C_SBCModeTypeDef SBCMode);
 void HAL_I2C_SlaveInit(I2C_HandleTypeDef *hi2c);
 void HAL_I2C_MasterInit(I2C_HandleTypeDef *hi2c);
 HAL_StatusTypeDef HAL_I2C_Init(I2C_HandleTypeDef *hi2c);
+HAL_StatusTypeDef HAL_I2C_Deinit(I2C_HandleTypeDef *hi2c);
 void HAL_I2C_AutoEnd(I2C_HandleTypeDef *hi2c, HAL_I2C_AutoEndModeTypeDef AutoEnd);
 HAL_StatusTypeDef HAL_I2C_Master_WaitTXIS(I2C_HandleTypeDef *hi2c, uint32_t Timeout);
 HAL_StatusTypeDef HAL_I2C_Master_WaitRXNE(I2C_HandleTypeDef *hi2c, uint32_t Timeout);
@@ -427,6 +425,60 @@ HAL_StatusTypeDef HAL_I2C_Slave_Receive_IT(I2C_HandleTypeDef *hi2c, uint8_t *pDa
 HAL_StatusTypeDef HAL_I2C_Slave_Receive_NOSTRETCH_IT(I2C_HandleTypeDef *hi2c, uint8_t *pData, uint16_t DataSize);
 HAL_StatusTypeDef HAL_I2C_Slave_ReceiveSBC_IT(I2C_HandleTypeDef *hi2c, uint8_t *pData, uint16_t DataSize);
 
+
+static inline __attribute__((always_inline)) void HAL_I2C_Disable(I2C_HandleTypeDef *hi2c)
+{
+    hi2c->Instance->CR1 &= ~I2C_CR1_PE_M;
+}
+
+static inline __attribute__((always_inline)) void HAL_I2C_Reset(I2C_HandleTypeDef *hi2c)
+{
+    hi2c->ErrorCode = I2C_ERROR_NONE;
+    
+    hi2c->Instance->CR1 &= ~I2C_CR1_PE_M;
+    hi2c->Instance->CR1 |= I2C_CR1_PE_M;
+}
+
+static inline __attribute__((always_inline)) void HAL_I2C_Enable(I2C_HandleTypeDef *hi2c)
+{
+    hi2c->Instance->CR1 |= I2C_CR1_PE_M;
+}
+
+static inline __attribute__((always_inline)) void HAL_I2C_Reset_Interrupt_Flag(I2C_HandleTypeDef *hi2c, uint32_t mask)
+{
+	hi2c->Instance->ICR |= mask;
+}
+
+static inline __attribute__((always_inline)) void HAL_I2C_Reset_TXDR_Content(I2C_HandleTypeDef *hi2c)
+{
+	hi2c->Instance->ISR |= I2C_ISR_TXE_M;
+}
+
+static inline __attribute__((always_inline)) uint32_t HAL_I2C_Get_Interrupts_Status(I2C_HandleTypeDef *hi2c)
+{
+	return hi2c->Instance->ISR;
+}
+
+static inline __attribute__((always_inline)) uint32_t HAL_I2C_Get_CR1_Content(I2C_HandleTypeDef *hi2c)
+{
+	return hi2c->Instance->CR1;
+}
+
+static inline __attribute__((always_inline)) void HAL_I2C_Write_TXDR(I2C_HandleTypeDef *hi2c, uint8_t value)
+{
+    hi2c->Instance->TXDR = value;
+}
+
+static inline __attribute__((always_inline)) uint8_t HAL_I2C_Get_RXDR(I2C_HandleTypeDef *hi2c)
+{
+    return hi2c->Instance->RXDR;
+}
+
+static inline __attribute__((always_inline)) void HAL_I2C_Clear_Reload(I2C_HandleTypeDef *hi2c)
+{
+	hi2c->Instance->CR2 &= ~I2C_CR2_RELOAD_M;
+}
+
 static inline __attribute__((always_inline)) void HAL_I2C_ADDR_IRQ(I2C_HandleTypeDef *hi2c)
 {
     if (hi2c->Instance->CR1 & I2C_CR1_SBC_M)

cores/arduino/mik32/hal/peripherals/Include/mik32_hal_spi.h

@@ -253,7 +253,8 @@ void HAL_SPI_CS_Disable(SPI_HandleTypeDef *hspi);
 HAL_StatusTypeDef HAL_SPI_Exchange(SPI_HandleTypeDef *hspi, uint8_t TransmitBytes[], uint8_t ReceiveBytes[], uint32_t Size, uint32_t Timeout);
 HAL_StatusTypeDef HAL_SPI_ExchangeThreshold(SPI_HandleTypeDef *hspi, uint8_t TransmitBytes[], uint8_t ReceiveBytes[], uint32_t DataSize, uint32_t Timeout);
 HAL_StatusTypeDef HAL_SPI_Exchange_IT(SPI_HandleTypeDef *hspi, uint8_t TransmitBytes[], uint8_t ReceiveBytes[], uint32_t Size);
-
+void HAL_SPI_Set_Clock_Divider(SPI_HandleTypeDef *hspi);
+void HAL_SPI_Set_Clock_Mode(SPI_HandleTypeDef *hspi);
 
 /**
  * @brief Разрешить прерывания в соответствии с маской.

cores/arduino/mik32/hal/peripherals/Include/mik32_hal_timer16.h

@@ -230,8 +230,6 @@ typedef struct __Timer16_HandleTypeDef
 
 
 void HAL_TIMER16_MspInit(Timer16_HandleTypeDef* htimer16);
-void HAL_Timer16_Disable(Timer16_HandleTypeDef *htimer16);
-void HAL_Timer16_Enable(Timer16_HandleTypeDef *htimer16);
 void HAL_Timer16_SetActiveEdge(Timer16_HandleTypeDef *htimer16, uint8_t ActiveEdge);
 void HAL_Timer16_SetSourceClock(Timer16_HandleTypeDef *htimer16, uint8_t SourceClock);
 void HAL_Timer16_SetCountMode(Timer16_HandleTypeDef *htimer16, uint8_t CountMode);
@@ -278,6 +276,26 @@ void HAL_Timer16_SetInterruptARRM(Timer16_HandleTypeDef *htimer16);
 void HAL_Timer16_SetInterruptCMPM(Timer16_HandleTypeDef *htimer16);
 void HAL_Timer16_InterruptInit(Timer16_HandleTypeDef *htimer16);
 
+/**
+ * @brief Выключить таймер.
+ * Может использоваться для отключения таймера или при записи в регистр CFGR.
+ * 
+ * @param htimer16 Указатель на структуру с настройками Timer16.
+ */
+static inline void __attribute__((always_inline)) HAL_Timer16_Disable(Timer16_HandleTypeDef *htimer16)
+{
+    htimer16->Instance->CR &= ~TIMER16_CR_ENABLE_M;
+}
+
+/**
+ * @brief Включить таймер
+ * @param htimer16 Указатель на структуру с настройками Timer16.
+ */
+static inline void __attribute__((always_inline)) HAL_Timer16_Enable(Timer16_HandleTypeDef *htimer16)
+{
+    htimer16->Instance->CR |= TIMER16_CR_ENABLE_M;
+}
+
 /**
  * @brief Получить статус прерываний Timer16. 
  * Функция возвращает статус прерываний в соответствии с маской разрешенный прерываний.
@@ -291,6 +309,16 @@ static inline __attribute__((always_inline)) uint32_t HAL_Timer16_GetInterruptSt
     return interrupt_status;
 }
 
+/**
+ * @brief Получить статус прерывания по соответствию автозагрузке ARRM
+ * @param htimer16 Указатель на структуру с настройками Timer16
+ * @return Статус прерывания ARRM - true, если прерывание сработало
+ */
+static inline __attribute__((always_inline)) bool HAL_Timer16_GetInterruptStatus_ARRM(Timer16_HandleTypeDef *htimer16)
+{
+    return (bool)((htimer16->Instance->ISR & htimer16->Instance->IER) & TIMER16_ISR_ARR_MATCH_M);
+}
+
 /**
  * @brief Очистить флаг прерывания.
  * @param htimer16 Указатель на структуру с настройками Timer16.

cores/arduino/mik32/hal/peripherals/Include/mik32_hal_timer32.h

@@ -226,6 +226,7 @@ static inline __attribute__((always_inline)) HAL_StatusTypeDef HAL_Timer32_WaitF
 void HAL_TIMER32_MspInit(TIMER32_HandleTypeDef* htimer32);
 void HAL_TIMER32_Channel_MspInit(TIMER32_CHANNEL_HandleTypeDef* timerChannel);
 HAL_StatusTypeDef HAL_Timer32_Init(TIMER32_HandleTypeDef *timer);
+HAL_StatusTypeDef HAL_Timer32_Deinit(TIMER32_HandleTypeDef *timer);
 void HAL_Timer32_State_Set(TIMER32_HandleTypeDef *timer, HAL_TIMER32_StateTypeDef state);
 void HAL_Timer32_Top_Set(TIMER32_HandleTypeDef *timer, uint32_t top);
 void HAL_Timer32_Prescaler_Set(TIMER32_HandleTypeDef *timer, uint32_t prescaler);

cores/arduino/mik32/hal/peripherals/Source/mik32_hal_gpio.c

@@ -93,58 +93,6 @@ HAL_StatusTypeDef HAL_GPIO_PinConfig(GPIO_TypeDef *GPIO_x, HAL_PinsTypeDef pin,
     return HAL_GPIO_Init(GPIO_x, &GPIO_InitStruct);
 }
 
-/**
- * @brief Считать текущее состояние выводов порта GPIO_x.
- * @param GPIO_x порт GPIO_x, где x может быть (0, 1, 2).
- * @param pin маска выводов порта GPIO_x, с которых считывание значение.
- * @return @ref GPIO_PIN_HIGH если с одного или больше выводов, указанных в pin, считалась 1. Иначе @ref GPIO_PIN_LOW.
- */
-GPIO_PinState HAL_GPIO_ReadPin(GPIO_TypeDef *GPIO_x, HAL_PinsTypeDef pin)
-{
-    GPIO_PinState bitStatus;
-
-    if ((GPIO_x->SET & pin) != (uint32_t)GPIO_PIN_LOW)
-    {
-        bitStatus = GPIO_PIN_HIGH;
-    }
-    else
-    {
-        bitStatus = GPIO_PIN_LOW;
-    }
-    return bitStatus;
-}
-
-/**
- * @brief Задать логический уровень выходного сигнала для указанных выводов порта GPIO_x.
- * @param GPIO_x порт GPIO_x, где x может быть (0, 1, 2).
- * @param pin маска выводов порта GPIO_x, к которым применяются указанные настройки.
- * @param pinState значение состояние вывода, в которое будут установлены указанные выводы.
- *                  Этот параметр должен быть одним из значений:
- * 		                - @ref GPIO_PIN_LOW низкий выходной уровень
- * 		                - @ref GPIO_PIN_HIGH высокий выходной уровень
- */
-void HAL_GPIO_WritePin(GPIO_TypeDef *GPIO_x, HAL_PinsTypeDef pin, GPIO_PinState pinState)
-{
-    if (pinState == GPIO_PIN_LOW)
-    {
-        GPIO_x->CLEAR = pin;
-    }
-    else
-    {
-        GPIO_x->SET = pin;
-    }
-}
-
-/**
- * @brief Переключить логический уровень выходного сигнала для указанных выводов порта GPIO_x.
- * @param GPIO_x порт GPIO_x, где x может быть (0, 1, 2).
- * @param pin маска выводов порта GPIO_x, к которым применяются указанные настройки.
- */
-void HAL_GPIO_TogglePin(GPIO_TypeDef *GPIO_x, HAL_PinsTypeDef pin)
-{
-    GPIO_x->OUTPUT_ ^= pin;
-}
-
 /** 
  *  @brief Функция инициализации линии прерывания.
  * \param mux настройка мультиплексора линии прерывания.
@@ -222,39 +170,3 @@ HAL_StatusTypeDef HAL_GPIO_DeInitInterruptLine(HAL_GPIO_Line irqLine)
 
     return HAL_OK;
 }
-
-/** 
- * @brief Получить состояние линии прерывания.
- * @param irqLine номер линии прерывания.
- * @return Возвращает 1 если сработало прерывание данной линии, иначе 0.
- */
-uint32_t HAL_GPIO_LineInterruptState(HAL_GPIO_Line irqLine)
-{
-    int irq_line_num = irqLine >> GPIO_IRQ_LINE_S;
-    return (GPIO_IRQ->INTERRUPT & (1 << (irq_line_num))) != 0;
-}
-
-/**
- * @brief Функция чтения логического уровня вывода, подключенного к линии прерывания.
- * @param irqLine номер линии прерывания.
- * @return Логический уровень вывода.
- */
-GPIO_PinState HAL_GPIO_LinePinState(HAL_GPIO_Line irqLine)
-{
-    int irq_line_num = irqLine >> GPIO_IRQ_LINE_S;
-    return (GPIO_PinState)((GPIO_IRQ->STATE & (1 << (irq_line_num))) >> irq_line_num);
-}
-
-/** 
- *  @brief Функция сброса регистра состояния прерываний.
- *  @note Когда срабатывает прерывание на одной из линии, в регистре INTERRUPT
- *  выставляется 1 в разряде, соответствующем линии прерывания.
- *  После обработки прерывания необходимо сбросить данный регистр
- *  в обработчике прерывания trap_handler().
- *  Если после обработки прерывания регистр не был сброшен,
- *  обработчик будет вызван снова, программа будет бесконечно вызывать обработчик.
- */
-void HAL_GPIO_ClearInterrupts()
-{
-    GPIO_IRQ->CLEAR = 0b11111111;
-}

cores/arduino/mik32/hal/peripherals/Source/mik32_hal_i2c.c

@@ -26,24 +26,6 @@ __attribute__((weak)) void HAL_I2C_MspInit(I2C_HandleTypeDef* hi2c)
 
 }
 
-void HAL_I2C_Disable(I2C_HandleTypeDef *hi2c)
-{
-    hi2c->Instance->CR1 &= ~I2C_CR1_PE_M;
-}
-
-void HAL_I2C_Reset(I2C_HandleTypeDef *hi2c)
-{
-    hi2c->ErrorCode = I2C_ERROR_NONE;
-    
-    hi2c->Instance->CR1 &= ~I2C_CR1_PE_M;
-    hi2c->Instance->CR1 |= I2C_CR1_PE_M;
-}
-
-void HAL_I2C_Enable(I2C_HandleTypeDef *hi2c)
-{
-    hi2c->Instance->CR1 |= I2C_CR1_PE_M;
-}
-
 void HAL_I2C_AnalogFilterInit(I2C_HandleTypeDef *hi2c, HAL_I2C_AnalogFilterTypeDef AnalogFilter)
 {
     hi2c->Init.AnalogFilter = AnalogFilter;
@@ -244,6 +226,24 @@ HAL_StatusTypeDef HAL_I2C_Init(I2C_HandleTypeDef *hi2c)
     return HAL_OK;
 }
 
+HAL_StatusTypeDef HAL_I2C_Deinit(I2C_HandleTypeDef *hi2c)
+{
+    HAL_I2C_Disable(hi2c);
+
+    if (hi2c->Instance == I2C_0)
+    {
+        __HAL_PCC_I2C_0_CLK_DISABLE();
+        HAL_GPIO_PinConfig(GPIO_0, GPIO_PIN_9 | GPIO_PIN_10, HAL_GPIO_MODE_GPIO_INPUT, HAL_GPIO_PULL_NONE, HAL_GPIO_DS_2MA);
+    }
+    else if(hi2c->Instance == I2C_1)
+    {
+        __HAL_PCC_I2C_1_CLK_DISABLE();
+        HAL_GPIO_PinConfig(GPIO_1, GPIO_PIN_12 | GPIO_PIN_13, HAL_GPIO_MODE_GPIO_INPUT, HAL_GPIO_PULL_NONE, HAL_GPIO_DS_2MA);
+    }
+
+    return HAL_OK;
+}
+
 void HAL_I2C_AutoEnd(I2C_HandleTypeDef *hi2c, HAL_I2C_AutoEndModeTypeDef AutoEnd)
 {
     hi2c->Instance->CR2 &= ~I2C_CR2_AUTOEND_M;

cores/arduino/mik32/hal/peripherals/Source/mik32_hal_spi.c

@@ -282,6 +282,37 @@ HAL_StatusTypeDef HAL_SPI_Init(SPI_HandleTypeDef *hspi)
     return error_code;
 }
 
+/**
+ * @brief Установить новый делитель частоты
+ * 
+ * @param hspi указатель на структуру SPI_HandleTypeDef, которая содержит
+ *                  информацию о конфигурации для модуля SPI.
+ */
+void HAL_SPI_Set_Clock_Divider(SPI_HandleTypeDef *hspi)
+{
+    uint32_t config = hspi->Instance->CONFIG;
+    HAL_SPI_Disable(hspi);
+    config &= ~(0b111 << SPI_CONFIG_BAUD_RATE_DIV_S);                   // очистить
+    config |= (hspi->Init.BaudRateDiv << SPI_CONFIG_BAUD_RATE_DIV_S);   // установить новое
+    hspi->Instance->CONFIG = config;                                    // сохранить конфигурацию
+}
+
+/**
+ * @brief Установить новый режим работы
+ * 
+ * @param hspi указатель на структуру SPI_HandleTypeDef, которая содержит
+ *                  информацию о конфигурации для модуля SPI.
+ */
+void HAL_SPI_Set_Clock_Mode(SPI_HandleTypeDef *hspi)
+{
+  uint32_t config = hspi->Instance->CONFIG;
+  HAL_SPI_Disable(hspi);
+  config &= ~((1 << SPI_CONFIG_CLK_PH_S) | (1 << SPI_CONFIG_CLK_POL_S));    // очистить
+  config |= ((hspi->Init.CLKPhase << SPI_CONFIG_CLK_PH_S) |
+             (hspi->Init.CLKPolarity << SPI_CONFIG_CLK_POL_S));             // установить новые значения
+  hspi->Instance->CONFIG = config;                                          // сохранить конфигурацию
+}
+
 /**
  * @brief Очистить буфер TX_FIFO.
  * 

cores/arduino/mik32/hal/peripherals/Source/mik32_hal_timer16.c

@@ -99,26 +99,6 @@ __attribute__((weak)) void HAL_TIMER16_MspInit(Timer16_HandleTypeDef* htimer16)
     }
 }
 
-/**
- * @brief Выключить таймер.
- * Может использоваться для отключения таймера или при записи в регистр CFGR.
- * 
- * @param htimer16 Указатель на структуру с настройками Timer16.
- */
-void HAL_Timer16_Disable(Timer16_HandleTypeDef *htimer16)
-{
-    htimer16->Instance->CR &= ~TIMER16_CR_ENABLE_M;
-}
-
-/**
- * @brief Включить таймер
- * @param htimer16 Указатель на структуру с настройками Timer16.
- */
-void HAL_Timer16_Enable(Timer16_HandleTypeDef *htimer16)
-{
-    htimer16->Instance->CR |= TIMER16_CR_ENABLE_M;
-}
-
 /**
  * @brief Установить активный фронт для подсчёта или задать подрежим энкодера.
  * Используется при тактировании Timer16 от внешнего источника тактового сигнала на выводе Input1.

cores/arduino/mik32/hal/peripherals/Source/mik32_hal_timer32.c

@@ -78,6 +78,41 @@ HAL_StatusTypeDef HAL_Timer32_Init(TIMER32_HandleTypeDef *timer)
     return HAL_OK;
 }
 
+HAL_StatusTypeDef HAL_Timer32_Deinit(TIMER32_HandleTypeDef *timer)
+{
+    if ((timer->Instance != TIMER32_0) && (timer->Instance != TIMER32_1) && (timer->Instance != TIMER32_2))
+    {
+        return HAL_ERROR;
+    }
+
+    if (timer->Instance == TIMER32_0)
+    {
+        __HAL_PCC_TIMER32_0_CLK_DISABLE();
+    }
+
+    if (timer->Instance == TIMER32_1)
+    {
+        __HAL_PCC_TIMER32_1_CLK_DISABLE();
+        if (timer->Clock.Source == TIMER32_SOURCE_TX_PAD)
+            HAL_GPIO_PinConfig(GPIO_0, GPIO_PIN_4, HAL_GPIO_MODE_GPIO_INPUT, HAL_GPIO_PULL_NONE, HAL_GPIO_DS_2MA);
+    }
+
+    if (timer->Instance == TIMER32_2)
+    {
+        __HAL_PCC_TIMER32_2_CLK_DISABLE();
+        if (timer->Clock.Source == TIMER32_SOURCE_TX_PAD)
+            HAL_GPIO_PinConfig(GPIO_1, GPIO_PIN_4, HAL_GPIO_MODE_GPIO_INPUT, HAL_GPIO_PULL_NONE, HAL_GPIO_DS_2MA);
+    }
+
+    HAL_Timer32_InterruptMask_Clear(timer, 0xFFFFFFFF);
+    HAL_Timer32_Prescaler_Set(timer, 0); 
+    HAL_Timer32_InterruptFlags_ClearMask(timer, 0xFFFFFFFF);
+    HAL_Timer32_InterruptFlags_Clear(timer);
+
+    return HAL_OK;
+}
+
+
 void HAL_Timer32_State_Set(TIMER32_HandleTypeDef *timer, HAL_TIMER32_StateTypeDef state)
 {
     timer->State = state;
@@ -199,7 +234,7 @@ HAL_StatusTypeDef HAL_Timer32_Channel_Init(TIMER32_CHANNEL_HandleTypeDef *timerC
         return HAL_ERROR;
     }
 
-    HAL_TIMER32_Channel_MspInit(timerChannel);
+    // HAL_TIMER32_Channel_MspInit(timerChannel); // здесь инициализируются сразу все каналы выбранного таймера, а нам такого не надо
 
     timerChannel->Instance = (TIMER32_CHANNEL_TypeDef *)&(timerChannel->TimerInstance->CHANNELS[timerChannel->ChannelIndex]);
 
@@ -220,6 +255,8 @@ HAL_StatusTypeDef HAL_Timer32_Channel_DeInit(TIMER32_CHANNEL_HandleTypeDef *time
         return HAL_ERROR;
     }
 
+    timerChannel->Instance = (TIMER32_CHANNEL_TypeDef *)&(timerChannel->TimerInstance->CHANNELS[timerChannel->ChannelIndex]);
+    
     HAL_Timer32_Channel_Disable(timerChannel);
     HAL_Timer32_Channel_CaptureEdge_Set(timerChannel, 0);
     HAL_Timer32_Channel_ICR_Clear(timerChannel);

cores/arduino/mik32/shared/ldscripts/ram.ld

@@ -10,36 +10,52 @@ MEMORY {
 }
 
 STACK_SIZE = 1024;
+HEAP_SIZE = 1024;
 
 CL_SIZE = 16;
 
 SECTIONS {
     .text ORIGIN(ram) : {
         PROVIDE(__TEXT_START__ = .);
-        *crt0.o(.text .text.*)
+        *crt0.S.o(.text .text.*)
         *(.text.smallsysteminit)
         *(.text.SmallSystemInit)
         . = ORIGIN(ram) + 0xC0;
-        KEEP(*crt0.o(.trap_text))
+        KEEP(*crt0.S.o(.trap_text))
 
         *(.text)
         *(.text.*)
         *(.rodata)
         *(.rodata.*)      
         . = ALIGN(CL_SIZE);
-        PROVIDE(__TEXT_END__ = .);
     } >ram 
 
+    .init_array (READONLY) :
+	{
+	  PROVIDE_HIDDEN (__init_array_start = .);
+	  KEEP (*(SORT_BY_INIT_PRIORITY(.init_array.*) SORT_BY_INIT_PRIORITY(.ctors.*)))
+	  KEEP (*(.init_array EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o ) .ctors))
+	  PROVIDE_HIDDEN (__init_array_end = .);
+	  
+	  PROVIDE_HIDDEN (__fini_array_start = .);
+	  KEEP(*(SORT_BY_INIT_PRIORITY(.fini_array.*)))
+	  KEEP(*(.fini_array))
+	  PROVIDE_HIDDEN (__fini_array_end   = .); 
+		
+	  PROVIDE(__TEXT_END__ = .);
+	} >ram AT>ram 
+
     .data : 
     AT( __TEXT_END__ ) {
         PROVIDE(__DATA_START__ = .);
         _gp = .;
         *(.srodata.cst16) *(.srodata.cst8) *(.srodata.cst4) *(.srodata.cst2) *(.srodata*)
-        *(.sdata .sdata.* .gnu.linkonce.s.*)
+        *(.sdata .sdata.* .sdata* .sdata*.* .gnu.linkonce.s.*)
         *(.data .data.*)
+        *(.ramfunc) 
         . = ALIGN(CL_SIZE);
-    } >ram
-    
+    } >ram 
+
     __DATA_IMAGE_START__ = LOADADDR(.data);
     __DATA_IMAGE_END__ = LOADADDR(.data) + SIZEOF(.data);
     ASSERT(__DATA_IMAGE_END__ < ORIGIN(ram) + LENGTH(ram) - STACK_SIZE, "Data image overflows ram section")
@@ -72,12 +88,19 @@ SECTIONS {
         PROVIDE(__BSS_END__ = .);
     } >ram
 
+    .heap : {
+        PROVIDE(__heap_start = .);
+        . += HEAP_SIZE;
+        . = ALIGN(CL_SIZE);
+        PROVIDE(__heap_end = .);
+    } >ram
+
     _end = .;
     PROVIDE(__end = .);
 
     /* End of uninitalized data segement */
 
-    .stack ORIGIN(ram) + LENGTH(ram) - STACK_SIZE : {
+    .stack ORIGIN(ram) + LENGTH(ram) - STACK_SIZE: {
         FILL(0);
         PROVIDE(__STACK_START__ = .);
         . += STACK_SIZE;

cores/arduino/mik32/shared/ldscripts/spifi_cpp.ld

@@ -21,8 +21,8 @@ SECTIONS {
         *crt0.S.o(.text .text.*)
         *(.text.smallsysteminit)
         *(.text.SmallSystemInit)
-        . = ORIGIN(rom) + 0xC0;
-        KEEP(*crt0.S.o(.trap_text))
+        /*. = ORIGIN(rom) + 0xC0;*/
+        /*KEEP(*crt0.S.o(.trap_text))*/
 
         *(.text)
         *(.text.*)
@@ -50,15 +50,17 @@ SECTIONS {
     AT( __TEXT_END__ ) {
         PROVIDE(__DATA_START__ = .);
         _gp = .;
+        . = ORIGIN(ram) + 0xC0;
+        KEEP(*crt0.S.o(.trap_text))
         *(.srodata.cst16) *(.srodata.cst8) *(.srodata.cst4) *(.srodata.cst2) *(.srodata*)
         *(.sdata .sdata.* .sdata* .sdata*.* .gnu.linkonce.s.*)
         *(.data .data.*)
         . = ALIGN(CL_SIZE);
+        PROVIDE(__DATA_END__ = .);
     } >ram
     
     __DATA_IMAGE_START__ = LOADADDR(.data);
     __DATA_IMAGE_END__ = LOADADDR(.data) + SIZEOF(.data);
-    ASSERT(__DATA_IMAGE_END__ < ORIGIN(rom) + LENGTH(rom), "Data image overflows rom section")
 
     /* thread-local data segment */
     .tdata : {
@@ -84,10 +86,26 @@ SECTIONS {
 
     .bss : {
         *(.bss .bss.*)
+        *(COMMON)
         . = ALIGN(CL_SIZE);
         PROVIDE(__BSS_END__ = .);
     } >ram
 
+    /* Code intended to be copied to REGION_RAM before execution */
+    .ram_text : 
+    AT( ALIGN(__DATA_IMAGE_END__, CL_SIZE) ) {
+        PROVIDE(__RAM_TEXT_START__ = .);
+        *(.ram_text)
+        . = ALIGN(CL_SIZE);
+        PROVIDE(__RAM_TEXT_END__ = .);
+    } > ram
+
+    __RAM_TEXT_IMAGE_START__ = LOADADDR(.ram_text);
+    __RAM_TEXT_IMAGE_END__ = LOADADDR(.ram_text) + SIZEOF(.ram_text);
+    ASSERT(__RAM_TEXT_IMAGE_END__ < ORIGIN(rom) + LENGTH(rom), "rom segment overflows")
+
+    ASSERT(__RAM_TEXT_END__ < ORIGIN(ram) + LENGTH(ram) - STACK_SIZE - HEAP_SIZE, "REGION_RAM section overflows")
+
     .heap : {
         PROVIDE(__heap_start = .);
         . += HEAP_SIZE;

cores/arduino/mik32/shared/runtime/crt0.S

@@ -62,6 +62,11 @@ memset_2:
 
 _start:
     
+    li t0, 128000
+    start_loop_delay:
+    nop
+    addi t0, t0, -1
+    bnez t0, start_loop_delay
     # Init stack and global pointer
     #
     la_abs  sp, __C_STACK_TOP__
@@ -73,20 +78,19 @@ _start:
     la_abs  a2, __DATA_IMAGE_END__
     la_abs  a3, __DATA_START__
     memcpy  a1, a2, a3, t0
+
+    # Init ramfunc
+    #
+    la_abs  a1, __RAM_TEXT_IMAGE_START__
+    la_abs  a2, __RAM_TEXT_IMAGE_END__
+    la_abs  a3, __RAM_TEXT_START__
+    memcpy  a1, a2, a3, t0
     
     # Clear bss
     #
     la_abs  a1, __BSS_START__
     la_abs  a2, __BSS_END__
     memset a1, a2, zero
-
-    #ifdef MIK32V0
-    # Enable pad_config clocking
-    #
-    li t0, (1 << 3)
-    li t1, 0x50014
-    sw t0, (t1)
-    #endif
     
     jalr_abs ra, SmallSystemInit
     jalr_abs ra, SystemInit

cores/arduino/trap_handler.c

@@ -1,37 +1,46 @@
 #include "mik32_hal_irq.h" 
+#include "wiring_LL.h" 
 
 // isr functions
-extern void serial_handler_wrapper(uint8_t uartNumInt);
-extern void gpio_interrupts_handler(void);
+extern void serial_interrupt_handler(uint8_t uartNumInt);
+extern void gpio_interrupt_handler(void);
 extern void tone_interrupt_handler(void);
-void __attribute__((weak)) wire_handler_wrapper(void)
+void __attribute__((weak)) wire_interrupt_handler(void)
+{
+    // dummy function for case when wire library is not in use
+}
+void __attribute__((weak)) servo_interrupt_handler(void)
 {
     // dummy function for case when wire library is not in use
 }
 
 // ---------------------------------------------- //
-void trap_handler(void)
+void __attribute__((noinline, section(".ram_text"), optimize("O3"))) trap_handler (void)  
 {
+    // gpio interrupt
+    if (EPIC_CHECK_GPIO_IRQ())
+        gpio_interrupt_handler();
+
     // tone timer interrupt
     if (EPIC_CHECK_TIMER16_1())
         tone_interrupt_handler();
 
+    // servo timer interrupt
+    if (EPIC_CHECK_TIMER16_2())
+        servo_interrupt_handler();
+
     // uart0 interrupt
     if (EPIC_CHECK_UART_0())
-        serial_handler_wrapper(0);
+        serial_interrupt_handler(0);
 
     // uart1 interrupt
     if (EPIC_CHECK_UART_1())
-        serial_handler_wrapper(1);
-
-    // gpio interrupt
-    if (EPIC_CHECK_GPIO_IRQ())
-        gpio_interrupts_handler();
+        serial_interrupt_handler(1);
         
     // i2c interrupt
     if (EPIC_CHECK_I2C_1())
-        wire_handler_wrapper();
+        wire_interrupt_handler();
 
     // reset all interrupts
-    HAL_EPIC_Clear(0xFFFFFFFF);
+    EPIC_CLEAR_ALL();
 }

cores/arduino/util/delay.h

@@ -0,0 +1,6 @@
+#ifndef __DELAY_H_
+#define __DELAY_H_
+
+
+
+#endif // __DELAY_H_

cores/arduino/wiring_LL.h

@@ -0,0 +1,65 @@
+#ifndef _WIRING_LL_H_
+#define _WIRING_LL_H_
+
+#include "mik32_hal_irq.h" 
+#include "mik32_hal_gpio.h"
+#include "mik32_hal_scr1_timer.h"
+#include "mik32_hal_timer16.h"
+
+// ----------------- COMMON ----------------- //
+// convert pin mask from HAL_PinsTypeDef to pin number
+#define PIN_MASK_TO_PIN_NUMBER(mask)    \
+({                                      \
+  uint8_t pos;                          \
+  for (pos = 0; pos < 16; pos++)        \
+    if ((mask >> pos) & 1)              \
+      break;                            \
+  pos;                                  \
+})
+
+// ----------------- SYSTICK ----------------- //
+// get ticks from systick
+#define SYSTICK_GET_TICKS()                       ((uint64_t)(SCR1_TIMER->MTIMEH)<<32 | SCR1_TIMER->MTIME)
+
+// ----------------- UART ----------------- //
+#define UART_READ_BYTE(pUart)                     ((uint16_t)pUart->RXDATA)
+#define UART_IS_RX_FIFO_EMPTY(pUart)              ((pUart->FLAGS & UART_FLAGS_RXNE_M) == 0)
+
+// ----------------- TIMER16 ----------------- //
+#define TIM16_DISABLE(htim16)                     (htim16.Instance->CR &= ~TIMER16_CR_ENABLE_M)
+#define TIM16_CLEAR_INT_MASK(htim16, intMask)     (htim16.Instance->ICR = intMask)
+#define TIM16_GET_ARRM_INT_STATUS(htim16)         ((bool)((htim16.Instance->ISR & htim16.Instance->IER) & TIMER16_ISR_ARR_MATCH_M))
+#define TIM16_DISABLE_INT_BY_MASK(htim16,intMask) (htim16.Instance->IER &= ~(intMask))
+
+// ----------------- EPIC ----------------- //
+#define EPIC_LEVEL_CLEAR_BY_MASK(mask)            (EPIC->MASK_LEVEL_CLEAR |= mask)
+#define EPIC_CLEAR_ALL()                          (EPIC->CLEAR = 0xFFFFFFFF)
+
+// ----------------- IRQ ----------------- //
+#define GLOBAL_IRQ_DISABLE()                      (clear_csr(mie, MIE_MEIE))
+#define GLOBAL_IRQ_ENABLE()                       set_csr(mstatus, MSTATUS_MIE); \
+                                                  set_csr(mie, MIE_MEIE)
+
+// ----------------- GPIO ----------------- //
+#define GPIO_SET_PIN(GPIO_x, pinMask)             ((GPIO_x)->SET = (pinMask))
+#define GPIO_CLEAR_PIN(GPIO_x, pinMask)           ((GPIO_x)->CLEAR = (pinMask))
+#define GPIO_TOGGLE_PIN(GPIO_x, pinMask)          ((GPIO_x)->OUTPUT_ ^= pinMask)
+#define GPIO_READ_PIN(GPIO_x, pinMask)            (((GPIO_x)->SET & (pinMask)) != (uint32_t)GPIO_PIN_LOW ? GPIO_PIN_HIGH : GPIO_PIN_LOW)
+// get pin state by it's number
+#define GPIO_GET_PIN_STATE(GPIO_x, pinNumber)     (((GPIO_x)->OUTPUT_ >> pinNumber) & 0b1)
+
+// ----------------- GPIO IRQ ----------------- //
+#define GPIO_IRQ_LINE_ENABLE(lineMask)            ( GPIO_IRQ->ENABLE_SET = (1 << (lineMask >> GPIO_IRQ_LINE_S)) )
+#define GPIO_IRQ_LINE_DISABLE(lineMask)           ( GPIO_IRQ->ENABLE_CLEAR = (1 << (lineMask >> GPIO_IRQ_LINE_S)) )
+#define GPIO_IRQ_LINE_STATE(lineMask)             ((GPIO_IRQ->INTERRUPT & (1 << (lineMask >> GPIO_IRQ_LINE_S))) != 0)
+#define GPIO_IRQ_CLEAR_ALL()                      ( GPIO_IRQ->CLEAR = 0b11111111)
+
+// ----------------- PIN CONFIG ----------------- //
+// return config of pin with pinNumber(0...16) in portReg (config, pupd, ds for ports 0...2)
+#define PIN_GET_PAD_CONFIG(portReg, pinNumber)          ((PAD_CONFIG->portReg  >> (pinNumber<<1)) & 0b11)
+#define PIN_SET_PAD_CONFIG(portReg, pinNumber, value)   (PAD_CONFIG->portReg = (PAD_CONFIG->portReg & (~PAD_CONFIG_PIN_M(pinNumber))) \
+                                                        | PAD_CONFIG_PIN(pinNumber, value))
+
+  
+
+#endif /* _WIRING_LL_H_ */

cores/arduino/wiring_analog.c

@@ -8,9 +8,13 @@ extern "C" {
 #include "mik32_hal_gpio.h"
 #include "mik32_hal_timer32.h"
 
-extern void ErrorMsgHandler(const char * msg);
 
 // -------------------------- Analog read -------------------------- //
+#define ADC_SAMPLES_QTY           10  // samples quantity for averaging adc results
+#define ADC_DEFAULT_RESOLUTION    10  // resolution for arduino compatibility
+
+uint8_t currentResolution = ADC_DEFAULT_RESOLUTION; // resolution used for output results
+
 // structure for ADC channel initialization. Only the channel number 
 // changes, everything else is the same
 static ADC_HandleTypeDef hadc = 
@@ -21,6 +25,16 @@ static ADC_HandleTypeDef hadc =
   .Init.Sel    = 0
 };
 
+void analogReadResolution(uint8_t resolution)
+{
+  // resolution limits
+  if (resolution > 32) resolution = 32;
+  if (resolution < 1)  resolution = 1;
+
+  // save new resolution
+  currentResolution = resolution;
+}
+
 // initialize the channel, run a single measurement, wait for the result
 uint32_t analogRead(uint32_t PinNumber)
 {
@@ -44,11 +58,31 @@ uint32_t analogRead(uint32_t PinNumber)
     hadc.Init.Sel = adcChannel;
     HAL_ADC_Init(&hadc);
 
-    // start the conversion twice in case another channel was polled before
+    // start the dummy conversion in case another channel was polled before
     HAL_ADC_SINGLE_AND_SET_CH(hadc.Instance, adcChannel);
-    value = HAL_ADC_WaitAndGetValue(&hadc);
-    HAL_ADC_Single(&hadc);
-    value = HAL_ADC_WaitAndGetValue(&hadc);
+    HAL_ADC_WaitAndGetValue(&hadc);
+
+    // accumulate results
+    uint32_t acc = 0;
+    for (uint8_t i = 0; i<ADC_SAMPLES_QTY; i++)
+    {
+      HAL_ADC_Single(&hadc);
+      acc += HAL_ADC_WaitAndGetValue(&hadc);
+    }
+    // get value by averaging with MCU_ADC_RESOLUTION
+    value = acc/ADC_SAMPLES_QTY;
+
+    // map value to selected resolution
+    if (currentResolution > MCU_ADC_RESOLUTION)
+    {
+      // extra least significant bits are padded with zeros
+      value = (value << (currentResolution - MCU_ADC_RESOLUTION));
+    }
+    else
+    {
+      // extra least significant bits read from the ADC are discarded
+      value = (value >> (MCU_ADC_RESOLUTION - currentResolution));
+    }
   }
   else
     ErrorMsgHandler("analogRead(): invalid analog pin number");
@@ -68,25 +102,8 @@ static TIMER32_HandleTypeDef htimer32;
 static TIMER32_CHANNEL_HandleTypeDef htimer32_channel;
 static uint32_t WriteValMax = WRITE_VAL_MAX_DEFAULT;
 static uint32_t pwmTopVal = PWM_TOP_VAL_DEFAULT;
-static bool pwmIsInited = false;
+static uint8_t pwmIsInited = 0;
 
-HAL_StatusTypeDef Timer32_Channel_Init(TIMER32_CHANNEL_HandleTypeDef *timerChannel)
-{
-  if (timerChannel->TimerInstance == TIMER32_0)
-    return HAL_ERROR;
-
-  // gpio init removed from standard function
-
-  timerChannel->Instance = (TIMER32_CHANNEL_TypeDef *)&(timerChannel->TimerInstance->CHANNELS[timerChannel->ChannelIndex]);
-  HAL_Timer32_Channel_PWM_Invert_Set(timerChannel, timerChannel->PWM_Invert);
-  HAL_Timer32_Channel_Mode_Set(timerChannel, timerChannel->Mode);
-  HAL_Timer32_Channel_CaptureEdge_Set(timerChannel, timerChannel->CaptureEdge);
-  HAL_Timer32_Channel_OCR_Set(timerChannel, timerChannel->OCR);
-  HAL_Timer32_Channel_ICR_Clear(timerChannel);
-  HAL_Timer32_Channel_Noise_Set(timerChannel, timerChannel->Noise);
-
-  return HAL_OK;
-}
 
 /*
 It is recommended to enable the timer in the following order:
@@ -120,15 +137,15 @@ void analogWrite(uint32_t PinNumber, uint32_t writeVal)
     htimer32_channel.PWM_Invert     = TIMER32_CHANNEL_NON_INVERTED_PWM;
     htimer32_channel.Mode           = TIMER32_CHANNEL_MODE_PWM;
     htimer32_channel.CaptureEdge    = TIMER32_CHANNEL_CAPTUREEDGE_RISING;
-    // cast to uint64_t to avoid overflow when multiplying
     htimer32_channel.OCR            = (uint32_t) (((uint64_t)pwmTopVal * writeVal) / WriteValMax);
     htimer32_channel.Noise          = TIMER32_CHANNEL_FILTER_OFF;
-    Timer32_Channel_Init(&htimer32_channel);
+    HAL_Timer32_Channel_Init(&htimer32_channel);
+
     // start timer with initialized channel
     HAL_Timer32_Channel_Enable(&htimer32_channel);
     HAL_Timer32_Value_Clear(&htimer32);
     HAL_Timer32_Start(&htimer32);
-    pwmIsInited = true; // if at least one channel is working, say that the module is initialized
+    pwmIsInited++; // increase inited channels qty
   }
   else if(PinNumber == 10) // pin d10 has pwm, but you cannot use it while spi is running
     ErrorMsgHandler("analogWrite(): D10 cannot be used as PWM pin while SPI is running");
@@ -165,21 +182,26 @@ It is recommended to turn off the timer in the following order:
 */
 void analogWriteStop(uint32_t PinNumber)
 {
-  if (pwmIsInited)
+  if ((pwmIsInited > 0) && (digitalPinPwmIsOn(PinNumber)))
   {
     // load the timer address and channel number corresponding to the specified pin
     htimer32.Instance               = pwmPinToTimer(PinNumber);
     htimer32_channel.TimerInstance  = htimer32.Instance;
     htimer32_channel.ChannelIndex   = pwmPinToTimerChannel(PinNumber);
-    // in the initChannel function they do it inside, but in deinit they don't. We do it outside
-    htimer32_channel.Instance       = (TIMER32_CHANNEL_TypeDef *)&(htimer32_channel.TimerInstance->CHANNELS[htimer32_channel.ChannelIndex]);
-    // и все чистим/отключаем
-    HAL_Timer32_InterruptMask_Clear(&htimer32, 0xFFFFFFFF);
-    HAL_Timer32_Prescaler_Set(&htimer32, 0); 
-    HAL_Timer32_InterruptFlags_ClearMask(&htimer32, 0xFFFFFFFF);
+    // deinit channel
     HAL_Timer32_Channel_DeInit(&htimer32_channel);
-    HAL_Timer32_Stop(&htimer32);
-    pwmIsInited = false;
+    pwmIsInited--; // decrease inited channels qty
+
+    // stop timer if no inited channels left
+    if (pwmIsInited == 0)
+    {
+      HAL_Timer32_Stop(&htimer32);
+      HAL_Timer32_Deinit(&htimer32);
+    }
+
+    // config pin as input when timer channel off
+    HAL_GPIO_PinConfig(digitalPinToPort(PinNumber), digitalPinToBitMask(PinNumber), 
+                      HAL_GPIO_MODE_GPIO_INPUT, HAL_GPIO_PULL_NONE, HAL_GPIO_DS_2MA);
   }
 }
 

cores/arduino/wiring_analog.h

@@ -16,6 +16,13 @@ extern "C" {
  */
 uint32_t analogRead(uint32_t PinNumber);
 
+/*
+ * \brief Set the resolution of adc results. Default is 10 bits (range from 0 to 1023).
+ *
+ * \param resolution 1...32
+ */
+void analogReadResolution(uint8_t resolution);
+
 /*
  * \brief Writes an analog value (PWM wave) to a pin.
  *

cores/arduino/wiring_digital.c

@@ -24,8 +24,6 @@
 extern "C" {
 #endif
 
-extern void ErrorMsgHandler(const char * msg);
-
 // initialization
 void pinMode(uint32_t PinNumber, uint32_t PinMode)
 {

cores/arduino/wiring_time.c

@@ -39,6 +39,11 @@ void SysTick_Init(void)
     HAL_SCR1_Timer_Init(&hscr1_timer); // Ticks are 32 MHz
 }
 
+uint64_t SysTick_GetTicks(void)
+{
+  return TICKS_IN_SYSTIMER;
+}
+
 // number of microseconds since start of the program
 uint32_t micros(void)
 {

cores/arduino/wiring_time.h

@@ -24,12 +24,22 @@
 extern "C" {
 #endif
 
+#define clockCyclesPerMicrosecond()   (F_CPU / 1000000L)
+#define clockCyclesToMicroseconds(a)  ((a) / clockCyclesPerMicrosecond())
+#define microsecondsToClockCycles(a)  ((a) * clockCyclesPerMicrosecond())
+
 /**
  * \brief Initialize timer for creating delays
  *
  */
 void SysTick_Init(void);
 
+/**
+ * \brief Returns the number of ticks since the Arduino board began running the current program.
+
+ * \return Number of ticks since the program started
+ */
+uint64_t SysTick_GetTicks(void);
 
 /**
  * \brief Returns the number of milliseconds since the Arduino board began running the current program.