Scott Lahteine
5 years ago
49 changed files with 198 additions and 1906 deletions
@ -1,111 +0,0 @@ |
|||
/**
|
|||
* Marlin 3D Printer Firmware |
|||
* Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
|
|||
* |
|||
* This program is free software: you can redistribute it and/or modify |
|||
* it under the terms of the GNU General Public License as published by |
|||
* the Free Software Foundation, either version 3 of the License, or |
|||
* (at your option) any later version. |
|||
* |
|||
* This program is distributed in the hope that it will be useful, |
|||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
* GNU General Public License for more details. |
|||
* |
|||
* You should have received a copy of the GNU General Public License |
|||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|||
* |
|||
*/ |
|||
|
|||
/**
|
|||
* Description: Functions for a Flash emulated EEPROM |
|||
* Not platform dependent. |
|||
*/ |
|||
|
|||
#if defined(STM32GENERIC) && defined(STM32F4) |
|||
|
|||
#include "../../inc/MarlinConfig.h" |
|||
|
|||
#if ENABLED(EEPROM_SETTINGS) && NONE(I2C_EEPROM, SPI_EEPROM) |
|||
|
|||
// ------------------------
|
|||
// Includes
|
|||
// ------------------------
|
|||
|
|||
#include "HAL.h" |
|||
#include "EEPROM_Emul/eeprom_emul.h" |
|||
|
|||
// ------------------------
|
|||
// Local defines
|
|||
// ------------------------
|
|||
|
|||
// FLASH_FLAG_PGSERR (Programming Sequence Error) was renamed to
|
|||
// FLASH_FLAG_ERSERR (Erasing Sequence Error) in STM32F4
|
|||
// #define FLASH_FLAG_PGSERR FLASH_FLAG_ERSERR
|
|||
|
|||
// ------------------------
|
|||
// Private Variables
|
|||
// ------------------------
|
|||
|
|||
static bool eeprom_initialized = false; |
|||
|
|||
// ------------------------
|
|||
// Public functions
|
|||
// ------------------------
|
|||
|
|||
void eeprom_init() { |
|||
if (!eeprom_initialized) { |
|||
HAL_FLASH_Unlock(); |
|||
|
|||
__HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR |FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR); |
|||
|
|||
/* EEPROM Init */ |
|||
if (EE_Initialize() != EE_OK) |
|||
for (;;) HAL_Delay(1); // Spin forever until watchdog reset
|
|||
|
|||
HAL_FLASH_Lock(); |
|||
eeprom_initialized = true; |
|||
} |
|||
} |
|||
|
|||
void eeprom_write_byte(uint8_t *pos, unsigned char value) { |
|||
uint16_t eeprom_address = unsigned(pos); |
|||
|
|||
eeprom_init(); |
|||
|
|||
HAL_FLASH_Unlock(); |
|||
__HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR |FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR); |
|||
|
|||
if (EE_WriteVariable(eeprom_address, uint16_t(value)) != EE_OK) |
|||
for (;;) HAL_Delay(1); // Spin forever until watchdog reset
|
|||
|
|||
HAL_FLASH_Lock(); |
|||
} |
|||
|
|||
uint8_t eeprom_read_byte(uint8_t *pos) { |
|||
eeprom_init(); |
|||
|
|||
uint16_t data = 0xFF; |
|||
uint16_t eeprom_address = unsigned(pos); |
|||
(void)EE_ReadVariable(eeprom_address, &data); // Data unchanged on error
|
|||
|
|||
return uint8_t(data); |
|||
} |
|||
|
|||
void eeprom_read_block(void *__dst, const void *__src, size_t __n) { |
|||
eeprom_init(); |
|||
|
|||
uint16_t data = 0xFF; |
|||
uint16_t eeprom_address = (unsigned)__src; |
|||
for (uint8_t c = 0; c < __n; c++) { |
|||
EE_ReadVariable(eeprom_address+c, &data); |
|||
*((uint8_t*)__dst + c) = data; |
|||
} |
|||
} |
|||
|
|||
void eeprom_update_block(const void *__src, void *__dst, size_t __n) { |
|||
|
|||
} |
|||
|
|||
#endif // EEPROM_SETTINGS && (!I2C_EEPROM && !SPI_EEPROM)
|
|||
#endif // STM32GENERIC && STM32F4
|
|||
@ -1,53 +0,0 @@ |
|||
/**
|
|||
* Marlin 3D Printer Firmware |
|||
* Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
|
|||
* |
|||
* Based on Sprinter and grbl. |
|||
* Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm |
|||
* Copyright (c) 2017 Victor Perez |
|||
* |
|||
* This program is free software: you can redistribute it and/or modify |
|||
* it under the terms of the GNU General Public License as published by |
|||
* the Free Software Foundation, either version 3 of the License, or |
|||
* (at your option) any later version. |
|||
* |
|||
* This program is distributed in the hope that it will be useful, |
|||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
* GNU General Public License for more details. |
|||
* |
|||
* You should have received a copy of the GNU General Public License |
|||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|||
* |
|||
*/ |
|||
|
|||
#if defined(STM32GENERIC) && defined(STM32F4) |
|||
|
|||
#include "../../inc/MarlinConfig.h" |
|||
|
|||
#if HAS_SERVOS |
|||
|
|||
#include "HAL_Servo_STM32F4.h" |
|||
|
|||
int8_t libServo::attach(const int pin) { |
|||
return Servo::attach(pin); |
|||
} |
|||
|
|||
int8_t libServo::attach(const int pin, const int min, const int max) { |
|||
return Servo::attach(pin, min, max); |
|||
} |
|||
|
|||
void libServo::move(const int value) { |
|||
constexpr uint16_t servo_delay[] = SERVO_DELAY; |
|||
static_assert(COUNT(servo_delay) == NUM_SERVOS, "SERVO_DELAY must be an array NUM_SERVOS long."); |
|||
if (this->attach(0) >= 0) { |
|||
this->write(value); |
|||
safe_delay(servo_delay[this->servoIndex]); |
|||
#if ENABLED(DEACTIVATE_SERVOS_AFTER_MOVE) |
|||
this->detach(); |
|||
#endif |
|||
} |
|||
} |
|||
#endif // HAS_SERVOS
|
|||
|
|||
#endif // STM32GENERIC && STM32F4
|
|||
@ -1,37 +0,0 @@ |
|||
/**
|
|||
* Marlin 3D Printer Firmware |
|||
* Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
|
|||
* |
|||
* Based on Sprinter and grbl. |
|||
* Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm |
|||
* |
|||
* This program is free software: you can redistribute it and/or modify |
|||
* it under the terms of the GNU General Public License as published by |
|||
* the Free Software Foundation, either version 3 of the License, or |
|||
* (at your option) any later version. |
|||
* |
|||
* This program is distributed in the hope that it will be useful, |
|||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
* GNU General Public License for more details. |
|||
* |
|||
* You should have received a copy of the GNU General Public License |
|||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|||
* |
|||
*/ |
|||
#pragma once |
|||
|
|||
/**
|
|||
* Test STM32F4-specific configuration values for errors at compile-time. |
|||
*/ |
|||
//#if ENABLED(SPINDLE_LASER_PWM) && !(SPINDLE_LASER_PWM_PIN == 4 || SPINDLE_LASER_PWM_PIN == 6 || SPINDLE_LASER_PWM_PIN == 11)
|
|||
// #error "SPINDLE_LASER_PWM_PIN must use SERVO0, SERVO1 or SERVO3 connector"
|
|||
//#endif
|
|||
|
|||
#if ENABLED(EMERGENCY_PARSER) |
|||
#error "EMERGENCY_PARSER is not yet implemented for STM32F4. Disable EMERGENCY_PARSER to continue." |
|||
#endif |
|||
|
|||
#if ENABLED(FAST_PWM_FAN) |
|||
#error "FAST_PWM_FAN is not yet implemented for this platform." |
|||
#endif |
|||
@ -1,153 +0,0 @@ |
|||
/**
|
|||
* Marlin 3D Printer Firmware |
|||
* Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
|
|||
* |
|||
* Based on Sprinter and grbl. |
|||
* Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm |
|||
* Copyright (c) 2017 Victor Perez |
|||
* |
|||
* This program is free software: you can redistribute it and/or modify |
|||
* it under the terms of the GNU General Public License as published by |
|||
* the Free Software Foundation, either version 3 of the License, or |
|||
* (at your option) any later version. |
|||
* |
|||
* This program is distributed in the hope that it will be useful, |
|||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
* GNU General Public License for more details. |
|||
* |
|||
* You should have received a copy of the GNU General Public License |
|||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|||
* |
|||
*/ |
|||
#pragma once |
|||
|
|||
/**
|
|||
* Fast I/O interfaces for STM32F4 |
|||
* These use GPIO functions instead of Direct Port Manipulation, as on AVR. |
|||
*/ |
|||
|
|||
#undef _BV |
|||
#define _BV(b) (1 << (b)) |
|||
|
|||
#define READ(IO) digitalRead(IO) |
|||
#define WRITE(IO,V) digitalWrite(IO,V) |
|||
|
|||
#define _GET_MODE(IO) |
|||
#define _SET_MODE(IO,M) pinMode(IO, M) |
|||
#define _SET_OUTPUT(IO) pinMode(IO, OUTPUT) /*!< Output Push Pull Mode & GPIO_NOPULL */ |
|||
|
|||
#define OUT_WRITE(IO,V) do{ _SET_OUTPUT(IO); WRITE(IO,V); }while(0) |
|||
|
|||
#define SET_INPUT(IO) _SET_MODE(IO, INPUT) /*!< Input Floating Mode */ |
|||
#define SET_INPUT_PULLUP(IO) _SET_MODE(IO, INPUT_PULLUP) /*!< Input with Pull-up activation */ |
|||
#define SET_INPUT_PULLDOWN(IO) _SET_MODE(IO, INPUT_PULLDOWN) /*!< Input with Pull-down activation */ |
|||
#define SET_OUTPUT(IO) OUT_WRITE(IO, LOW) |
|||
#define SET_PWM(IO) pinMode(IO, PWM) |
|||
|
|||
#define TOGGLE(IO) OUT_WRITE(IO, !READ(IO)) |
|||
|
|||
#define IS_INPUT(IO) |
|||
#define IS_OUTPUT(IO) |
|||
|
|||
#define PWM_PIN(P) true |
|||
|
|||
// digitalRead/Write wrappers
|
|||
#define extDigitalRead(IO) digitalRead(IO) |
|||
#define extDigitalWrite(IO,V) digitalWrite(IO,V) |
|||
|
|||
//
|
|||
// Pins Definitions
|
|||
//
|
|||
#define PORTA 0 |
|||
#define PORTB 1 |
|||
#define PORTC 2 |
|||
#define PORTD 3 |
|||
#define PORTE 4 |
|||
|
|||
#define _STM32_PIN(P,PN) ((PORT##P * 16) + PN) |
|||
|
|||
#define PA0 _STM32_PIN(A, 0) |
|||
#define PA1 _STM32_PIN(A, 1) |
|||
#define PA2 _STM32_PIN(A, 2) |
|||
#define PA3 _STM32_PIN(A, 3) |
|||
#define PA4 _STM32_PIN(A, 4) |
|||
#define PA5 _STM32_PIN(A, 5) |
|||
#define PA6 _STM32_PIN(A, 6) |
|||
#define PA7 _STM32_PIN(A, 7) |
|||
#define PA8 _STM32_PIN(A, 8) |
|||
#define PA9 _STM32_PIN(A, 9) |
|||
#define PA10 _STM32_PIN(A, 10) |
|||
#define PA11 _STM32_PIN(A, 11) |
|||
#define PA12 _STM32_PIN(A, 12) |
|||
#define PA13 _STM32_PIN(A, 13) |
|||
#define PA14 _STM32_PIN(A, 14) |
|||
#define PA15 _STM32_PIN(A, 15) |
|||
|
|||
#define PB0 _STM32_PIN(B, 0) |
|||
#define PB1 _STM32_PIN(B, 1) |
|||
#define PB2 _STM32_PIN(B, 2) |
|||
#define PB3 _STM32_PIN(B, 3) |
|||
#define PB4 _STM32_PIN(B, 4) |
|||
#define PB5 _STM32_PIN(B, 5) |
|||
#define PB6 _STM32_PIN(B, 6) |
|||
#define PB7 _STM32_PIN(B, 7) |
|||
#define PB8 _STM32_PIN(B, 8) |
|||
#define PB9 _STM32_PIN(B, 9) |
|||
#define PB10 _STM32_PIN(B, 10) |
|||
#define PB11 _STM32_PIN(B, 11) |
|||
#define PB12 _STM32_PIN(B, 12) |
|||
#define PB13 _STM32_PIN(B, 13) |
|||
#define PB14 _STM32_PIN(B, 14) |
|||
#define PB15 _STM32_PIN(B, 15) |
|||
|
|||
#define PC0 _STM32_PIN(C, 0) |
|||
#define PC1 _STM32_PIN(C, 1) |
|||
#define PC2 _STM32_PIN(C, 2) |
|||
#define PC3 _STM32_PIN(C, 3) |
|||
#define PC4 _STM32_PIN(C, 4) |
|||
#define PC5 _STM32_PIN(C, 5) |
|||
#define PC6 _STM32_PIN(C, 6) |
|||
#define PC7 _STM32_PIN(C, 7) |
|||
#define PC8 _STM32_PIN(C, 8) |
|||
#define PC9 _STM32_PIN(C, 9) |
|||
#define PC10 _STM32_PIN(C, 10) |
|||
#define PC11 _STM32_PIN(C, 11) |
|||
#define PC12 _STM32_PIN(C, 12) |
|||
#define PC13 _STM32_PIN(C, 13) |
|||
#define PC14 _STM32_PIN(C, 14) |
|||
#define PC15 _STM32_PIN(C, 15) |
|||
|
|||
#define PD0 _STM32_PIN(D, 0) |
|||
#define PD1 _STM32_PIN(D, 1) |
|||
#define PD2 _STM32_PIN(D, 2) |
|||
#define PD3 _STM32_PIN(D, 3) |
|||
#define PD4 _STM32_PIN(D, 4) |
|||
#define PD5 _STM32_PIN(D, 5) |
|||
#define PD6 _STM32_PIN(D, 6) |
|||
#define PD7 _STM32_PIN(D, 7) |
|||
#define PD8 _STM32_PIN(D, 8) |
|||
#define PD9 _STM32_PIN(D, 9) |
|||
#define PD10 _STM32_PIN(D, 10) |
|||
#define PD11 _STM32_PIN(D, 11) |
|||
#define PD12 _STM32_PIN(D, 12) |
|||
#define PD13 _STM32_PIN(D, 13) |
|||
#define PD14 _STM32_PIN(D, 14) |
|||
#define PD15 _STM32_PIN(D, 15) |
|||
|
|||
#define PE0 _STM32_PIN(E, 0) |
|||
#define PE1 _STM32_PIN(E, 1) |
|||
#define PE2 _STM32_PIN(E, 2) |
|||
#define PE3 _STM32_PIN(E, 3) |
|||
#define PE4 _STM32_PIN(E, 4) |
|||
#define PE5 _STM32_PIN(E, 5) |
|||
#define PE6 _STM32_PIN(E, 6) |
|||
#define PE7 _STM32_PIN(E, 7) |
|||
#define PE8 _STM32_PIN(E, 8) |
|||
#define PE9 _STM32_PIN(E, 9) |
|||
#define PE10 _STM32_PIN(E, 10) |
|||
#define PE11 _STM32_PIN(E, 11) |
|||
#define PE12 _STM32_PIN(E, 12) |
|||
#define PE13 _STM32_PIN(E, 13) |
|||
#define PE14 _STM32_PIN(E, 14) |
|||
#define PE15 _STM32_PIN(E, 15) |
|||
@ -1,69 +0,0 @@ |
|||
/**
|
|||
* Marlin 3D Printer Firmware |
|||
* |
|||
* Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
|
|||
* Copyright (c) 2016 Bob Cousins bobcousins42@googlemail.com |
|||
* Copyright (c) 2015-2016 Nico Tonnhofer wurstnase.reprap@gmail.com |
|||
* Copyright (c) 2016 Victor Perez victor_pv@hotmail.com |
|||
* |
|||
* This program is free software: you can redistribute it and/or modify |
|||
* it under the terms of the GNU General Public License as published by |
|||
* the Free Software Foundation, either version 3 of the License, or |
|||
* (at your option) any later version. |
|||
* |
|||
* This program is distributed in the hope that it will be useful, |
|||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
* GNU General Public License for more details. |
|||
* |
|||
* You should have received a copy of the GNU General Public License |
|||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|||
* |
|||
*/ |
|||
|
|||
#if defined(STM32GENERIC) && defined(STM32F4) |
|||
|
|||
#include "../shared/persistent_store_api.h" |
|||
|
|||
#include "../../inc/MarlinConfig.h" |
|||
|
|||
#if ENABLED(EEPROM_SETTINGS) |
|||
|
|||
bool PersistentStore::access_start() { return true; } |
|||
bool PersistentStore::access_finish() { return true; } |
|||
|
|||
bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, uint16_t *crc) { |
|||
while (size--) { |
|||
uint8_t * const p = (uint8_t * const)pos; |
|||
uint8_t v = *value; |
|||
// EEPROM has only ~100,000 write cycles,
|
|||
// so only write bytes that have changed!
|
|||
if (v != eeprom_read_byte(p)) { |
|||
eeprom_write_byte(p, v); |
|||
if (eeprom_read_byte(p) != v) { |
|||
SERIAL_ECHO_MSG(MSG_ERR_EEPROM_WRITE); |
|||
return true; |
|||
} |
|||
} |
|||
crc16(crc, &v, 1); |
|||
pos++; |
|||
value++; |
|||
}; |
|||
return false; |
|||
} |
|||
|
|||
bool PersistentStore::read_data(int &pos, uint8_t* value, size_t size, uint16_t *crc, const bool writing) { |
|||
do { |
|||
uint8_t c = eeprom_read_byte((uint8_t*)pos); |
|||
if (writing) *value = c; |
|||
crc16(crc, &c, 1); |
|||
pos++; |
|||
value++; |
|||
} while (--size); |
|||
return false; |
|||
} |
|||
|
|||
size_t PersistentStore::capacity() { return E2END + 1; } |
|||
|
|||
#endif // EEPROM_SETTINGS
|
|||
#endif // STM32GENERIC && STM32F4
|
|||
@ -1,27 +0,0 @@ |
|||
/**
|
|||
* Marlin 3D Printer Firmware |
|||
* Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
|
|||
* |
|||
* This program is free software: you can redistribute it and/or modify |
|||
* it under the terms of the GNU General Public License as published by |
|||
* the Free Software Foundation, either version 3 of the License, or |
|||
* (at your option) any later version. |
|||
* |
|||
* This program is distributed in the hope that it will be useful, |
|||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
* GNU General Public License for more details. |
|||
* |
|||
* You should have received a copy of the GNU General Public License |
|||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|||
* |
|||
*/ |
|||
#pragma once |
|||
|
|||
#ifdef NUM_DIGITAL_PINS // Only in ST's Arduino core (STM32duino, STM32Core)
|
|||
#include "../HAL_STM32/pinsDebug_STM32duino.h" |
|||
#elif defined(BOARD_NR_GPIO_PINS) // Only in STM32GENERIC (Maple)
|
|||
#include "../HAL_STM32/pinsDebug_STM32GENERIC.h" |
|||
#else |
|||
#error "M43 not supported for this board" |
|||
#endif |
|||
@ -1,525 +0,0 @@ |
|||
/**
|
|||
****************************************************************************** |
|||
* @file EEPROM/EEPROM_Emulation/src/eeprom.c |
|||
* @author MCD Application Team |
|||
* @version V1.2.6 |
|||
* @date 04-November-2016 |
|||
* @brief This file provides all the EEPROM emulation firmware functions. |
|||
****************************************************************************** |
|||
* @attention |
|||
* |
|||
* Copyright © 2016 STMicroelectronics International N.V. |
|||
* All rights reserved. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted, provided that the following conditions are met: |
|||
* |
|||
* 1. Redistribution of source code must retain the above copyright notice, |
|||
* this list of conditions and the following disclaimer. |
|||
* 2. Redistributions in binary form must reproduce the above copyright notice, |
|||
* this list of conditions and the following disclaimer in the documentation |
|||
* and/or other materials provided with the distribution. |
|||
* 3. Neither the name of STMicroelectronics nor the names of other |
|||
* contributors to this software may be used to endorse or promote products |
|||
* derived from this software without specific written permission. |
|||
* 4. This software, including modifications and/or derivative works of this |
|||
* software, must execute solely and exclusively on microcontroller or |
|||
* microprocessor devices manufactured by or for STMicroelectronics. |
|||
* 5. Redistribution and use of this software other than as permitted under |
|||
* this license is void and will automatically terminate your rights under |
|||
* this license. |
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY STMICROELECTRONICS AND CONTRIBUTORS "AS IS" |
|||
* AND ANY EXPRESS, IMPLIED OR STATUTORY WARRANTIES, INCLUDING, BUT NOT |
|||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A |
|||
* PARTICULAR PURPOSE AND NON-INFRINGEMENT OF THIRD PARTY INTELLECTUAL PROPERTY |
|||
* RIGHTS ARE DISCLAIMED TO THE FULLEST EXTENT PERMITTED BY LAW. IN NO EVENT |
|||
* SHALL STMICROELECTRONICS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, |
|||
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
|||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, |
|||
* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF |
|||
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING |
|||
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, |
|||
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
* |
|||
****************************************************************************** |
|||
*/ |
|||
/** @addtogroup EEPROM_Emulation
|
|||
* @{ |
|||
*/ |
|||
#ifdef STM32F7 |
|||
|
|||
/* Includes ------------------------------------------------------------------*/ |
|||
#include "eeprom_emul.h" |
|||
|
|||
/* Private variables ---------------------------------------------------------*/ |
|||
|
|||
/* Global variable used to store variable value in read sequence */ |
|||
uint16_t DataVar = 0; |
|||
|
|||
/* Virtual address defined by the user: 0xFFFF value is prohibited */ |
|||
uint16_t VirtAddVarTab[NB_OF_VAR]; |
|||
|
|||
/* Private function prototypes -----------------------------------------------*/ |
|||
/* Private functions ---------------------------------------------------------*/ |
|||
static HAL_StatusTypeDef EE_Format(void); |
|||
static uint16_t EE_FindValidPage(uint8_t Operation); |
|||
static uint16_t EE_VerifyPageFullWriteVariable(uint16_t VirtAddress, uint16_t Data); |
|||
static uint16_t EE_PageTransfer(uint16_t VirtAddress, uint16_t Data); |
|||
static uint16_t EE_VerifyPageFullyErased(uint32_t Address); |
|||
|
|||
/**
|
|||
* @brief Restore the pages to a known good state in case of page's status |
|||
* corruption after a power loss. |
|||
* @param None. |
|||
* @retval - Flash error code: on write Flash error |
|||
* - FLASH_COMPLETE: on success |
|||
*/ |
|||
uint16_t EE_Initialize(void) { |
|||
/* Get Page0 and Page1 status */ |
|||
uint16_t PageStatus0 = (*(__IO uint16_t*)PAGE0_BASE_ADDRESS), |
|||
PageStatus1 = (*(__IO uint16_t*)PAGE1_BASE_ADDRESS); |
|||
|
|||
FLASH_EraseInitTypeDef pEraseInit; |
|||
pEraseInit.TypeErase = TYPEERASE_SECTORS; |
|||
pEraseInit.Sector = PAGE0_ID; |
|||
pEraseInit.NbSectors = 1; |
|||
pEraseInit.VoltageRange = VOLTAGE_RANGE; |
|||
|
|||
/* Check for invalid header states and repair if necessary */ |
|||
uint32_t SectorError; |
|||
switch (PageStatus0) { |
|||
case ERASED: |
|||
if (PageStatus1 == VALID_PAGE) { /* Page0 erased, Page1 valid */ |
|||
/* Erase Page0 */ |
|||
if (!EE_VerifyPageFullyErased(PAGE0_BASE_ADDRESS)) { |
|||
/* As the last operation, simply return the result */ |
|||
return HAL_FLASHEx_Erase(&pEraseInit, &SectorError); |
|||
} |
|||
} |
|||
else if (PageStatus1 == RECEIVE_DATA) { /* Page0 erased, Page1 receive */ |
|||
/* Erase Page0 */ |
|||
if (!EE_VerifyPageFullyErased(PAGE0_BASE_ADDRESS)) { |
|||
HAL_StatusTypeDef fStat = HAL_FLASHEx_Erase(&pEraseInit, &SectorError); |
|||
/* If erase operation was failed, a Flash error code is returned */ |
|||
if (fStat != HAL_OK) return fStat; |
|||
} |
|||
/* Mark Page1 as valid */ |
|||
/* As the last operation, simply return the result */ |
|||
return HAL_FLASH_Program(TYPEPROGRAM_HALFWORD, PAGE1_BASE_ADDRESS, VALID_PAGE); |
|||
} |
|||
else { /* First EEPROM access (Page0&1 are erased) or invalid state -> format EEPROM */ |
|||
/* Erase both Page0 and Page1 and set Page0 as valid page */ |
|||
/* As the last operation, simply return the result */ |
|||
return EE_Format(); |
|||
} |
|||
break; |
|||
|
|||
case RECEIVE_DATA: |
|||
if (PageStatus1 == VALID_PAGE) { /* Page0 receive, Page1 valid */ |
|||
/* Transfer data from Page1 to Page0 */ |
|||
int16_t x = -1; |
|||
for (uint16_t VarIdx = 0; VarIdx < NB_OF_VAR; VarIdx++) { |
|||
if (( *(__IO uint16_t*)(PAGE0_BASE_ADDRESS + 6)) == VirtAddVarTab[VarIdx]) |
|||
x = VarIdx; |
|||
if (VarIdx != x) { |
|||
/* Read the last variables' updates */ |
|||
uint16_t ReadStatus = EE_ReadVariable(VirtAddVarTab[VarIdx], &DataVar); |
|||
/* In case variable corresponding to the virtual address was found */ |
|||
if (ReadStatus != 0x1) { |
|||
/* Transfer the variable to the Page0 */ |
|||
uint16_t EepromStatus = EE_VerifyPageFullWriteVariable(VirtAddVarTab[VarIdx], DataVar); |
|||
/* If program operation was failed, a Flash error code is returned */ |
|||
if (EepromStatus != HAL_OK) return EepromStatus; |
|||
} |
|||
} |
|||
} |
|||
/* Mark Page0 as valid */ |
|||
HAL_StatusTypeDef FlashStatus = HAL_FLASH_Program(TYPEPROGRAM_HALFWORD, PAGE0_BASE_ADDRESS, VALID_PAGE); |
|||
/* If program operation was failed, a Flash error code is returned */ |
|||
if (FlashStatus != HAL_OK) return FlashStatus; |
|||
pEraseInit.Sector = PAGE1_ID; |
|||
pEraseInit.NbSectors = 1; |
|||
pEraseInit.VoltageRange = VOLTAGE_RANGE; |
|||
/* Erase Page1 */ |
|||
if (!EE_VerifyPageFullyErased(PAGE1_BASE_ADDRESS)) { |
|||
/* As the last operation, simply return the result */ |
|||
return HAL_FLASHEx_Erase(&pEraseInit, &SectorError); |
|||
} |
|||
} |
|||
else if (PageStatus1 == ERASED) { /* Page0 receive, Page1 erased */ |
|||
pEraseInit.Sector = PAGE1_ID; |
|||
pEraseInit.NbSectors = 1; |
|||
pEraseInit.VoltageRange = VOLTAGE_RANGE; |
|||
/* Erase Page1 */ |
|||
if (!EE_VerifyPageFullyErased(PAGE1_BASE_ADDRESS)) { |
|||
HAL_StatusTypeDef fStat = HAL_FLASHEx_Erase(&pEraseInit, &SectorError); |
|||
/* If erase operation was failed, a Flash error code is returned */ |
|||
if (fStat != HAL_OK) return fStat; |
|||
} |
|||
/* Mark Page0 as valid */ |
|||
/* As the last operation, simply return the result */ |
|||
return HAL_FLASH_Program(TYPEPROGRAM_HALFWORD, PAGE0_BASE_ADDRESS, VALID_PAGE); |
|||
} |
|||
else { /* Invalid state -> format eeprom */ |
|||
/* Erase both Page0 and Page1 and set Page0 as valid page */ |
|||
/* As the last operation, simply return the result */ |
|||
return EE_Format(); |
|||
} |
|||
break; |
|||
|
|||
case VALID_PAGE: |
|||
if (PageStatus1 == VALID_PAGE) { /* Invalid state -> format eeprom */ |
|||
/* Erase both Page0 and Page1 and set Page0 as valid page */ |
|||
FlashStatus = EE_Format(); |
|||
/* If erase/program operation was failed, a Flash error code is returned */ |
|||
if (FlashStatus != HAL_OK) return FlashStatus; |
|||
} |
|||
else if (PageStatus1 == ERASED) { /* Page0 valid, Page1 erased */ |
|||
pEraseInit.Sector = PAGE1_ID; |
|||
pEraseInit.NbSectors = 1; |
|||
pEraseInit.VoltageRange = VOLTAGE_RANGE; |
|||
/* Erase Page1 */ |
|||
if (!EE_VerifyPageFullyErased(PAGE1_BASE_ADDRESS)) { |
|||
FlashStatus = HAL_FLASHEx_Erase(&pEraseInit, &SectorError); |
|||
/* If erase operation was failed, a Flash error code is returned */ |
|||
if (FlashStatus != HAL_OK) return FlashStatus; |
|||
} |
|||
} |
|||
else { /* Page0 valid, Page1 receive */ |
|||
/* Transfer data from Page0 to Page1 */ |
|||
int16_t x = -1; |
|||
for (uint16_t VarIdx = 0; VarIdx < NB_OF_VAR; VarIdx++) { |
|||
if ((*(__IO uint16_t*)(PAGE1_BASE_ADDRESS + 6)) == VirtAddVarTab[VarIdx]) |
|||
x = VarIdx; |
|||
|
|||
if (VarIdx != x) { |
|||
/* Read the last variables' updates */ |
|||
uint16_t ReadStatus = EE_ReadVariable(VirtAddVarTab[VarIdx], &DataVar); |
|||
/* In case variable corresponding to the virtual address was found */ |
|||
if (ReadStatus != 0x1) { |
|||
/* Transfer the variable to the Page1 */ |
|||
uint16_t EepromStatus = EE_VerifyPageFullWriteVariable(VirtAddVarTab[VarIdx], DataVar); |
|||
/* If program operation was failed, a Flash error code is returned */ |
|||
if (EepromStatus != HAL_OK) return EepromStatus; |
|||
} |
|||
} |
|||
} |
|||
/* Mark Page1 as valid */ |
|||
FlashStatus = HAL_FLASH_Program(TYPEPROGRAM_HALFWORD, PAGE1_BASE_ADDRESS, VALID_PAGE); |
|||
/* If program operation was failed, a Flash error code is returned */ |
|||
if (FlashStatus != HAL_OK) return FlashStatus; |
|||
pEraseInit.Sector = PAGE0_ID; |
|||
pEraseInit.NbSectors = 1; |
|||
pEraseInit.VoltageRange = VOLTAGE_RANGE; |
|||
/* Erase Page0 */ |
|||
if (!EE_VerifyPageFullyErased(PAGE0_BASE_ADDRESS)) { |
|||
/* As the last operation, simply return the result */ |
|||
return HAL_FLASHEx_Erase(&pEraseInit, &SectorError); |
|||
} |
|||
} |
|||
break; |
|||
|
|||
default: /* Any other state -> format eeprom */ |
|||
/* Erase both Page0 and Page1 and set Page0 as valid page */ |
|||
/* As the last operation, simply return the result */ |
|||
return EE_Format(); |
|||
} |
|||
|
|||
return HAL_OK; |
|||
} |
|||
|
|||
/**
|
|||
* @brief Verify if specified page is fully erased. |
|||
* @param Address: page address |
|||
* This parameter can be one of the following values: |
|||
* @arg PAGE0_BASE_ADDRESS: Page0 base address |
|||
* @arg PAGE1_BASE_ADDRESS: Page1 base address |
|||
* @retval page fully erased status: |
|||
* - 0: if Page not erased |
|||
* - 1: if Page erased |
|||
*/ |
|||
uint16_t EE_VerifyPageFullyErased(uint32_t Address) { |
|||
uint32_t ReadStatus = 1; |
|||
/* Check each active page address starting from end */ |
|||
while (Address <= PAGE0_END_ADDRESS) { |
|||
/* Get the current location content to be compared with virtual address */ |
|||
uint16_t AddressValue = (*(__IO uint16_t*)Address); |
|||
/* Compare the read address with the virtual address */ |
|||
if (AddressValue != ERASED) { |
|||
/* In case variable value is read, reset ReadStatus flag */ |
|||
ReadStatus = 0; |
|||
break; |
|||
} |
|||
/* Next address location */ |
|||
Address += 4; |
|||
} |
|||
/* Return ReadStatus value: (0: Page not erased, 1: Sector erased) */ |
|||
return ReadStatus; |
|||
} |
|||
|
|||
/**
|
|||
* @brief Returns the last stored variable data, if found, which correspond to |
|||
* the passed virtual address |
|||
* @param VirtAddress: Variable virtual address |
|||
* @param Data: Global variable contains the read variable value |
|||
* @retval Success or error status: |
|||
* - 0: if variable was found |
|||
* - 1: if the variable was not found |
|||
* - NO_VALID_PAGE: if no valid page was found. |
|||
*/ |
|||
uint16_t EE_ReadVariable(uint16_t VirtAddress, uint16_t* Data) { |
|||
uint16_t ReadStatus = 1; |
|||
|
|||
/* Get active Page for read operation */ |
|||
uint16_t ValidPage = EE_FindValidPage(READ_FROM_VALID_PAGE); |
|||
|
|||
/* Check if there is no valid page */ |
|||
if (ValidPage == NO_VALID_PAGE) return NO_VALID_PAGE; |
|||
|
|||
/* Get the valid Page start and end Addresses */ |
|||
uint32_t PageStartAddress = uint32_t(EEPROM_START_ADDRESS) + uint32_t(ValidPage * (PAGE_SIZE)), |
|||
Address = PageStartAddress + PAGE_SIZE - 2; |
|||
|
|||
/* Check each active page address starting from end */ |
|||
while (Address > PageStartAddress + 2) { |
|||
/* Get the current location content to be compared with virtual address */ |
|||
uint16_t AddressValue = (*(__IO uint16_t*)Address); |
|||
|
|||
/* Compare the read address with the virtual address */ |
|||
if (AddressValue == VirtAddress) { |
|||
/* Get content of Address-2 which is variable value */ |
|||
*Data = (*(__IO uint16_t*)(Address - 2)); |
|||
/* In case variable value is read, reset ReadStatus flag */ |
|||
ReadStatus = 0; |
|||
break; |
|||
} |
|||
else /* Next address location */ |
|||
Address -= 4; |
|||
} |
|||
/* Return ReadStatus value: (0: variable exist, 1: variable doesn't exist) */ |
|||
return ReadStatus; |
|||
} |
|||
|
|||
/**
|
|||
* @brief Writes/upadtes variable data in EEPROM. |
|||
* @param VirtAddress: Variable virtual address |
|||
* @param Data: 16 bit data to be written |
|||
* @retval Success or error status: |
|||
* - FLASH_COMPLETE: on success |
|||
* - PAGE_FULL: if valid page is full |
|||
* - NO_VALID_PAGE: if no valid page was found |
|||
* - Flash error code: on write Flash error |
|||
*/ |
|||
uint16_t EE_WriteVariable(uint16_t VirtAddress, uint16_t Data) { |
|||
/* Write the variable virtual address and value in the EEPROM */ |
|||
uint16_t Status = EE_VerifyPageFullWriteVariable(VirtAddress, Data); |
|||
|
|||
/* In case the EEPROM active page is full */ |
|||
if (Status == PAGE_FULL) /* Perform Page transfer */ |
|||
Status = EE_PageTransfer(VirtAddress, Data); |
|||
|
|||
/* Return last operation status */ |
|||
return Status; |
|||
} |
|||
|
|||
/**
|
|||
* @brief Erases PAGE and PAGE1 and writes VALID_PAGE header to PAGE |
|||
* @param None |
|||
* @retval Status of the last operation (Flash write or erase) done during |
|||
* EEPROM formating |
|||
*/ |
|||
static HAL_StatusTypeDef EE_Format(void) { |
|||
FLASH_EraseInitTypeDef pEraseInit; |
|||
pEraseInit.TypeErase = FLASH_TYPEERASE_SECTORS; |
|||
pEraseInit.Sector = PAGE0_ID; |
|||
pEraseInit.NbSectors = 1; |
|||
pEraseInit.VoltageRange = VOLTAGE_RANGE; |
|||
|
|||
HAL_StatusTypeDef FlashStatus; // = HAL_OK
|
|||
|
|||
/* Erase Page0 */ |
|||
if (!EE_VerifyPageFullyErased(PAGE0_BASE_ADDRESS)) { |
|||
uint32_t SectorError; |
|||
FlashStatus = HAL_FLASHEx_Erase(&pEraseInit, &SectorError); |
|||
/* If erase operation was failed, a Flash error code is returned */ |
|||
if (FlashStatus != HAL_OK) return FlashStatus; |
|||
} |
|||
/* Set Page0 as valid page: Write VALID_PAGE at Page0 base address */ |
|||
FlashStatus = HAL_FLASH_Program(TYPEPROGRAM_HALFWORD, PAGE0_BASE_ADDRESS, VALID_PAGE); |
|||
/* If program operation was failed, a Flash error code is returned */ |
|||
if (FlashStatus != HAL_OK) return FlashStatus; |
|||
|
|||
pEraseInit.Sector = PAGE1_ID; |
|||
/* Erase Page1 */ |
|||
if (!EE_VerifyPageFullyErased(PAGE1_BASE_ADDRESS)) { |
|||
/* As the last operation, just return the result code */ |
|||
uint32_t SectorError; |
|||
return HAL_FLASHEx_Erase(&pEraseInit, &SectorError); |
|||
} |
|||
|
|||
return HAL_OK; |
|||
} |
|||
|
|||
/**
|
|||
* @brief Find valid Page for write or read operation |
|||
* @param Operation: operation to achieve on the valid page. |
|||
* This parameter can be one of the following values: |
|||
* @arg READ_FROM_VALID_PAGE: read operation from valid page |
|||
* @arg WRITE_IN_VALID_PAGE: write operation from valid page |
|||
* @retval Valid page number (PAGE or PAGE1) or NO_VALID_PAGE in case |
|||
* of no valid page was found |
|||
*/ |
|||
static uint16_t EE_FindValidPage(uint8_t Operation) { |
|||
/* Get Page0 and Page1 actual status */ |
|||
uint16_t PageStatus0 = (*(__IO uint16_t*)PAGE0_BASE_ADDRESS), |
|||
PageStatus1 = (*(__IO uint16_t*)PAGE1_BASE_ADDRESS); |
|||
|
|||
/* Write or read operation */ |
|||
switch (Operation) { |
|||
case WRITE_IN_VALID_PAGE: /* ---- Write operation ---- */ |
|||
if (PageStatus1 == VALID_PAGE) { |
|||
/* Page0 receiving data */ |
|||
return (PageStatus0 == RECEIVE_DATA) ? PAGE0 : PAGE1; |
|||
} |
|||
else if (PageStatus0 == VALID_PAGE) { |
|||
/* Page1 receiving data */ |
|||
return (PageStatus1 == RECEIVE_DATA) ? PAGE1 : PAGE0; |
|||
} |
|||
else |
|||
return NO_VALID_PAGE; /* No valid Page */ |
|||
|
|||
case READ_FROM_VALID_PAGE: /* ---- Read operation ---- */ |
|||
if (PageStatus0 == VALID_PAGE) |
|||
return PAGE0; /* Page0 valid */ |
|||
else if (PageStatus1 == VALID_PAGE) |
|||
return PAGE1; /* Page1 valid */ |
|||
else |
|||
return NO_VALID_PAGE; /* No valid Page */ |
|||
|
|||
default: |
|||
return PAGE0; /* Page0 valid */ |
|||
} |
|||
} |
|||
|
|||
/**
|
|||
* @brief Verify if active page is full and Writes variable in EEPROM. |
|||
* @param VirtAddress: 16 bit virtual address of the variable |
|||
* @param Data: 16 bit data to be written as variable value |
|||
* @retval Success or error status: |
|||
* - FLASH_COMPLETE: on success |
|||
* - PAGE_FULL: if valid page is full |
|||
* - NO_VALID_PAGE: if no valid page was found |
|||
* - Flash error code: on write Flash error |
|||
*/ |
|||
static uint16_t EE_VerifyPageFullWriteVariable(uint16_t VirtAddress, uint16_t Data) { |
|||
/* Get valid Page for write operation */ |
|||
uint16_t ValidPage = EE_FindValidPage(WRITE_IN_VALID_PAGE); |
|||
|
|||
/* Check if there is no valid page */ |
|||
if (ValidPage == NO_VALID_PAGE) return NO_VALID_PAGE; |
|||
|
|||
/* Get the valid Page start and end Addresses */ |
|||
uint32_t Address = uint32_t(EEPROM_START_ADDRESS) + uint32_t(ValidPage * (PAGE_SIZE)), |
|||
PageEndAddress = Address + PAGE_SIZE - 1; |
|||
|
|||
/* Check each active page address starting from begining */ |
|||
while (Address < PageEndAddress) { |
|||
/* Verify if Address and Address+2 contents are 0xFFFFFFFF */ |
|||
if ((*(__IO uint32_t*)Address) == 0xFFFFFFFF) { |
|||
/* Set variable data */ |
|||
HAL_StatusTypeDef FlashStatus = HAL_FLASH_Program(TYPEPROGRAM_HALFWORD, Address, Data); |
|||
/* If program operation was failed, a Flash error code is returned */ |
|||
if (FlashStatus != HAL_OK) return FlashStatus; |
|||
/* Set variable virtual address, return status */ |
|||
return HAL_FLASH_Program(TYPEPROGRAM_HALFWORD, Address + 2, VirtAddress); |
|||
} |
|||
else /* Next address location */ |
|||
Address += 4; |
|||
} |
|||
|
|||
/* Return PAGE_FULL in case the valid page is full */ |
|||
return PAGE_FULL; |
|||
} |
|||
|
|||
/**
|
|||
* @brief Transfers last updated variables data from the full Page to |
|||
* an empty one. |
|||
* @param VirtAddress: 16 bit virtual address of the variable |
|||
* @param Data: 16 bit data to be written as variable value |
|||
* @retval Success or error status: |
|||
* - FLASH_COMPLETE: on success |
|||
* - PAGE_FULL: if valid page is full |
|||
* - NO_VALID_PAGE: if no valid page was found |
|||
* - Flash error code: on write Flash error |
|||
*/ |
|||
static uint16_t EE_PageTransfer(uint16_t VirtAddress, uint16_t Data) { |
|||
/* Get active Page for read operation */ |
|||
uint16_t ValidPage = EE_FindValidPage(READ_FROM_VALID_PAGE); |
|||
uint32_t NewPageAddress = EEPROM_START_ADDRESS; |
|||
uint16_t OldPageId = 0; |
|||
|
|||
if (ValidPage == PAGE1) { /* Page1 valid */ |
|||
/* New page address where variable will be moved to */ |
|||
NewPageAddress = PAGE0_BASE_ADDRESS; |
|||
/* Old page ID where variable will be taken from */ |
|||
OldPageId = PAGE1_ID; |
|||
} |
|||
else if (ValidPage == PAGE0) { /* Page0 valid */ |
|||
/* New page address where variable will be moved to */ |
|||
NewPageAddress = PAGE1_BASE_ADDRESS; |
|||
/* Old page ID where variable will be taken from */ |
|||
OldPageId = PAGE0_ID; |
|||
} |
|||
else |
|||
return NO_VALID_PAGE; /* No valid Page */ |
|||
|
|||
/* Set the new Page status to RECEIVE_DATA status */ |
|||
HAL_StatusTypeDef FlashStatus = HAL_FLASH_Program(TYPEPROGRAM_HALFWORD, NewPageAddress, RECEIVE_DATA); |
|||
/* If program operation was failed, a Flash error code is returned */ |
|||
if (FlashStatus != HAL_OK) return FlashStatus; |
|||
|
|||
/* Write the variable passed as parameter in the new active page */ |
|||
uint16_t EepromStatus = EE_VerifyPageFullWriteVariable(VirtAddress, Data); |
|||
/* If program operation was failed, a Flash error code is returned */ |
|||
if (EepromStatus != HAL_OK) return EepromStatus; |
|||
|
|||
/* Transfer process: transfer variables from old to the new active page */ |
|||
for (uint16_t VarIdx = 0; VarIdx < NB_OF_VAR; VarIdx++) { |
|||
if (VirtAddVarTab[VarIdx] != VirtAddress) { /* Check each variable except the one passed as parameter */ |
|||
/* Read the other last variable updates */ |
|||
uint16_t ReadStatus = EE_ReadVariable(VirtAddVarTab[VarIdx], &DataVar); |
|||
/* In case variable corresponding to the virtual address was found */ |
|||
if (ReadStatus != 0x1) { |
|||
/* Transfer the variable to the new active page */ |
|||
EepromStatus = EE_VerifyPageFullWriteVariable(VirtAddVarTab[VarIdx], DataVar); |
|||
/* If program operation was failed, a Flash error code is returned */ |
|||
if (EepromStatus != HAL_OK) return EepromStatus; |
|||
} |
|||
} |
|||
} |
|||
|
|||
FLASH_EraseInitTypeDef pEraseInit; |
|||
pEraseInit.TypeErase = TYPEERASE_SECTORS; |
|||
pEraseInit.Sector = OldPageId; |
|||
pEraseInit.NbSectors = 1; |
|||
pEraseInit.VoltageRange = VOLTAGE_RANGE; |
|||
|
|||
/* Erase the old Page: Set old Page status to ERASED status */ |
|||
uint32_t SectorError; |
|||
FlashStatus = HAL_FLASHEx_Erase(&pEraseInit, &SectorError); |
|||
/* If erase operation was failed, a Flash error code is returned */ |
|||
if (FlashStatus != HAL_OK) return FlashStatus; |
|||
|
|||
/* Set new Page status to VALID_PAGE status */ |
|||
/* As the last operation, just return the result code */ |
|||
return HAL_FLASH_Program(TYPEPROGRAM_HALFWORD, NewPageAddress, VALID_PAGE); |
|||
} |
|||
|
|||
#endif // STM32F7
|
|||
|
|||
/**
|
|||
* @} |
|||
*/ |
|||
|
|||
/******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/ |
|||
@ -1,109 +0,0 @@ |
|||
/******************************************************************************
|
|||
* @file eeprom_emul.h |
|||
* @author MCD Application Team |
|||
* @version V1.2.6 |
|||
* @date 04-November-2016 |
|||
* @brief This file contains all the functions prototypes for the EEPROM |
|||
* emulation firmware library. |
|||
****************************************************************************** |
|||
* @attention |
|||
* |
|||
* <h2><center>© Copyright © 2016 STMicroelectronics International N.V. |
|||
* All rights reserved.</center></h2> |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted, provided that the following conditions are met: |
|||
* |
|||
* 1. Redistribution of source code must retain the above copyright notice, |
|||
* this list of conditions and the following disclaimer. |
|||
* 2. Redistributions in binary form must reproduce the above copyright notice, |
|||
* this list of conditions and the following disclaimer in the documentation |
|||
* and/or other materials provided with the distribution. |
|||
* 3. Neither the name of STMicroelectronics nor the names of other |
|||
* contributors to this software may be used to endorse or promote products |
|||
* derived from this software without specific written permission. |
|||
* 4. This software, including modifications and/or derivative works of this |
|||
* software, must execute solely and exclusively on microcontroller or |
|||
* microprocessor devices manufactured by or for STMicroelectronics. |
|||
* 5. Redistribution and use of this software other than as permitted under |
|||
* this license is void and will automatically terminate your rights under |
|||
* this license. |
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY STMICROELECTRONICS AND CONTRIBUTORS "AS IS" |
|||
* AND ANY EXPRESS, IMPLIED OR STATUTORY WARRANTIES, INCLUDING, BUT NOT |
|||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A |
|||
* PARTICULAR PURPOSE AND NON-INFRINGEMENT OF THIRD PARTY INTELLECTUAL PROPERTY |
|||
* RIGHTS ARE DISCLAIMED TO THE FULLEST EXTENT PERMITTED BY LAW. IN NO EVENT |
|||
* SHALL STMICROELECTRONICS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, |
|||
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
|||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, |
|||
* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF |
|||
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING |
|||
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, |
|||
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
* |
|||
*****************************************************************************/ |
|||
#pragma once |
|||
|
|||
// ------------------------
|
|||
// Includes
|
|||
// ------------------------
|
|||
#include "../../../inc/MarlinConfig.h" |
|||
#include "../HAL.h" |
|||
|
|||
/* Exported constants --------------------------------------------------------*/ |
|||
/* EEPROM emulation firmware error codes */ |
|||
#define EE_OK uint32_t(HAL_OK) |
|||
#define EE_ERROR uint32_t(HAL_ERROR) |
|||
#define EE_BUSY uint32_t(HAL_BUSY) |
|||
#define EE_TIMEOUT uint32_t(HAL_TIMEOUT) |
|||
|
|||
/* Define the size of the sectors to be used */ |
|||
#define PAGE_SIZE uint32_t(0x4000) /* Page size = 16KByte */ |
|||
|
|||
/* Device voltage range supposed to be [2.7V to 3.6V], the operation will
|
|||
be done by word */ |
|||
#define VOLTAGE_RANGE uint8_t(VOLTAGE_RANGE_3) |
|||
|
|||
/* EEPROM start address in Flash */ |
|||
#define EEPROM_START_ADDRESS uint32_t(0x08100000) /* EEPROM emulation start address: |
|||
from sector2 : after 16KByte of used |
|||
Flash memory */ |
|||
|
|||
/* Pages 0 and 1 base and end addresses */ |
|||
#define PAGE0_BASE_ADDRESS uint32_t(EEPROM_START_ADDRESS + 0x0000) |
|||
#define PAGE0_END_ADDRESS uint32_t(EEPROM_START_ADDRESS + PAGE_SIZE - 1) |
|||
#define PAGE0_ID FLASH_SECTOR_1 |
|||
|
|||
#define PAGE1_BASE_ADDRESS uint32_t(EEPROM_START_ADDRESS + 0x4000) |
|||
#define PAGE1_END_ADDRESS uint32_t(EEPROM_START_ADDRESS + 2 * (PAGE_SIZE) - 1) |
|||
#define PAGE1_ID FLASH_SECTOR_2 |
|||
|
|||
/* Used Flash pages for EEPROM emulation */ |
|||
#define PAGE0 uint16_t(0x0000) |
|||
#define PAGE1 uint16_t(0x0001) /* Page nb between PAGE0_BASE_ADDRESS & PAGE1_BASE_ADDRESS*/ |
|||
|
|||
/* No valid page define */ |
|||
#define NO_VALID_PAGE uint16_t(0x00AB) |
|||
|
|||
/* Page status definitions */ |
|||
#define ERASED uint16_t(0xFFFF) /* Page is empty */ |
|||
#define RECEIVE_DATA uint16_t(0xEEEE) /* Page is marked to receive data */ |
|||
#define VALID_PAGE uint16_t(0x0000) /* Page containing valid data */ |
|||
|
|||
/* Valid pages in read and write defines */ |
|||
#define READ_FROM_VALID_PAGE uint8_t(0x00) |
|||
#define WRITE_IN_VALID_PAGE uint8_t(0x01) |
|||
|
|||
/* Page full define */ |
|||
#define PAGE_FULL uint8_t(0x80) |
|||
|
|||
/* Variables' number */ |
|||
#define NB_OF_VAR uint16_t(4096) |
|||
|
|||
/* Exported functions ------------------------------------------------------- */ |
|||
uint16_t EE_Initialize(void); |
|||
uint16_t EE_ReadVariable(uint16_t VirtAddress, uint16_t* Data); |
|||
uint16_t EE_WriteVariable(uint16_t VirtAddress, uint16_t Data); |
|||
|
|||
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ |
|||
@ -1,107 +0,0 @@ |
|||
/**
|
|||
* Marlin 3D Printer Firmware |
|||
* |
|||
* Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
|
|||
* Copyright (c) 2016 Bob Cousins bobcousins42@googlemail.com |
|||
* Copyright (c) 2015-2016 Nico Tonnhofer wurstnase.reprap@gmail.com |
|||
* Copyright (c) 2017 Victor Perez |
|||
* |
|||
* This program is free software: you can redistribute it and/or modify |
|||
* it under the terms of the GNU General Public License as published by |
|||
* the Free Software Foundation, either version 3 of the License, or |
|||
* (at your option) any later version. |
|||
* |
|||
* This program is distributed in the hope that it will be useful, |
|||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
* GNU General Public License for more details. |
|||
* |
|||
* You should have received a copy of the GNU General Public License |
|||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|||
* |
|||
*/ |
|||
|
|||
#ifdef STM32F7 |
|||
|
|||
#include "HAL.h" |
|||
|
|||
//#include <Wire.h>
|
|||
|
|||
// ------------------------
|
|||
// Public Variables
|
|||
// ------------------------
|
|||
|
|||
uint16_t HAL_adc_result; |
|||
|
|||
// ------------------------
|
|||
// Public functions
|
|||
// ------------------------
|
|||
|
|||
/* VGPV Done with defines
|
|||
// disable interrupts
|
|||
void cli(void) { noInterrupts(); } |
|||
|
|||
// enable interrupts
|
|||
void sei(void) { interrupts(); } |
|||
*/ |
|||
|
|||
void HAL_clear_reset_source(void) { __HAL_RCC_CLEAR_RESET_FLAGS(); } |
|||
|
|||
uint8_t HAL_get_reset_source(void) { |
|||
if (__HAL_RCC_GET_FLAG(RCC_FLAG_IWDGRST) != RESET) |
|||
return RST_WATCHDOG; |
|||
|
|||
if (__HAL_RCC_GET_FLAG(RCC_FLAG_SFTRST) != RESET) |
|||
return RST_SOFTWARE; |
|||
|
|||
if (__HAL_RCC_GET_FLAG(RCC_FLAG_PINRST) != RESET) |
|||
return RST_EXTERNAL; |
|||
|
|||
if (__HAL_RCC_GET_FLAG(RCC_FLAG_PORRST) != RESET) |
|||
return RST_POWER_ON; |
|||
return 0; |
|||
} |
|||
|
|||
void _delay_ms(const int delay_ms) { delay(delay_ms); } |
|||
|
|||
extern "C" { |
|||
extern unsigned int _ebss; // end of bss section
|
|||
} |
|||
|
|||
// return free memory between end of heap (or end bss) and whatever is current
|
|||
|
|||
/*
|
|||
#include "wirish/syscalls.c" |
|||
//extern caddr_t _sbrk(int incr);
|
|||
#ifndef CONFIG_HEAP_END |
|||
extern char _lm_heap_end; |
|||
#define CONFIG_HEAP_END ((caddr_t)&_lm_heap_end) |
|||
#endif |
|||
|
|||
extern "C" { |
|||
static int freeMemory() { |
|||
char top = 't'; |
|||
return &top - reinterpret_cast<char*>(sbrk(0)); |
|||
} |
|||
int freeMemory() { |
|||
int free_memory; |
|||
int heap_end = (int)_sbrk(0); |
|||
free_memory = ((int)&free_memory) - ((int)heap_end); |
|||
return free_memory; |
|||
} |
|||
} |
|||
*/ |
|||
|
|||
// ------------------------
|
|||
// ADC
|
|||
// ------------------------
|
|||
|
|||
void HAL_adc_start_conversion(const uint8_t adc_pin) { |
|||
HAL_adc_result = analogRead(adc_pin); |
|||
} |
|||
|
|||
uint16_t HAL_adc_get_result(void) { |
|||
return HAL_adc_result; |
|||
} |
|||
|
|||
#endif // STM32F7
|
|||
@ -1,208 +0,0 @@ |
|||
/**
|
|||
* Marlin 3D Printer Firmware |
|||
* |
|||
* Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
|
|||
* Copyright (c) 2016 Bob Cousins bobcousins42@googlemail.com |
|||
* Copyright (c) 2015-2016 Nico Tonnhofer wurstnase.reprap@gmail.com |
|||
* Copyright (c) 2017 Victor Perez |
|||
* |
|||
* This program is free software: you can redistribute it and/or modify |
|||
* it under the terms of the GNU General Public License as published by |
|||
* the Free Software Foundation, either version 3 of the License, or |
|||
* (at your option) any later version. |
|||
* |
|||
* This program is distributed in the hope that it will be useful, |
|||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
* GNU General Public License for more details. |
|||
* |
|||
* You should have received a copy of the GNU General Public License |
|||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|||
* |
|||
*/ |
|||
#pragma once |
|||
|
|||
#define CPU_32_BIT |
|||
|
|||
#ifndef vsnprintf_P |
|||
#define vsnprintf_P vsnprintf |
|||
#endif |
|||
|
|||
#include <stdint.h> |
|||
|
|||
#include "../shared/Marduino.h" |
|||
#include "../shared/math_32bit.h" |
|||
#include "../shared/HAL_SPI.h" |
|||
|
|||
#include "fastio_STM32F7.h" |
|||
#include "watchdog_STM32F7.h" |
|||
|
|||
#include "HAL_timers_STM32F7.h" |
|||
|
|||
#include "../../inc/MarlinConfigPre.h" |
|||
|
|||
// ------------------------
|
|||
// Defines
|
|||
// ------------------------
|
|||
|
|||
//Serial override
|
|||
//extern HalSerial usb_serial;
|
|||
|
|||
#if !WITHIN(SERIAL_PORT, -1, 6) |
|||
#error "SERIAL_PORT must be from -1 to 6" |
|||
#endif |
|||
#if SERIAL_PORT == -1 |
|||
#define MYSERIAL0 SerialUSB |
|||
#elif SERIAL_PORT == 1 |
|||
#define MYSERIAL0 SerialUART1 |
|||
#elif SERIAL_PORT == 2 |
|||
#define MYSERIAL0 SerialUART2 |
|||
#elif SERIAL_PORT == 3 |
|||
#define MYSERIAL0 SerialUART3 |
|||
#elif SERIAL_PORT == 4 |
|||
#define MYSERIAL0 SerialUART4 |
|||
#elif SERIAL_PORT == 5 |
|||
#define MYSERIAL0 SerialUART5 |
|||
#elif SERIAL_PORT == 6 |
|||
#define MYSERIAL0 SerialUART6 |
|||
#endif |
|||
|
|||
#ifdef SERIAL_PORT_2 |
|||
#if !WITHIN(SERIAL_PORT_2, -1, 6) |
|||
#error "SERIAL_PORT_2 must be from -1 to 6" |
|||
#elif SERIAL_PORT_2 == SERIAL_PORT |
|||
#error "SERIAL_PORT_2 must be different than SERIAL_PORT" |
|||
#endif |
|||
#define NUM_SERIAL 2 |
|||
#if SERIAL_PORT_2 == -1 |
|||
#define MYSERIAL1 SerialUSB |
|||
#elif SERIAL_PORT_2 == 1 |
|||
#define MYSERIAL1 SerialUART1 |
|||
#elif SERIAL_PORT_2 == 2 |
|||
#define MYSERIAL1 SerialUART2 |
|||
#elif SERIAL_PORT_2 == 3 |
|||
#define MYSERIAL1 SerialUART3 |
|||
#elif SERIAL_PORT_2 == 4 |
|||
#define MYSERIAL1 SerialUART4 |
|||
#elif SERIAL_PORT_2 == 5 |
|||
#define MYSERIAL1 SerialUART5 |
|||
#elif SERIAL_PORT_2 == 6 |
|||
#define MYSERIAL1 SerialUART6 |
|||
#endif |
|||
#else |
|||
#define NUM_SERIAL 1 |
|||
#endif |
|||
|
|||
#define _BV(b) (1 << (b)) |
|||
|
|||
/**
|
|||
* TODO: review this to return 1 for pins that are not analog input |
|||
*/ |
|||
#ifndef analogInputToDigitalPin |
|||
#define analogInputToDigitalPin(p) (p) |
|||
#endif |
|||
|
|||
#define CRITICAL_SECTION_START uint32_t primask = __get_PRIMASK(); __disable_irq() |
|||
#define CRITICAL_SECTION_END if (!primask) __enable_irq() |
|||
#define ISRS_ENABLED() (!__get_PRIMASK()) |
|||
#define ENABLE_ISRS() __enable_irq() |
|||
#define DISABLE_ISRS() __disable_irq() |
|||
#define cli() __disable_irq() |
|||
#define sei() __enable_irq() |
|||
|
|||
// On AVR this is in math.h?
|
|||
#define square(x) ((x)*(x)) |
|||
|
|||
#ifndef strncpy_P |
|||
#define strncpy_P(dest, src, num) strncpy((dest), (src), (num)) |
|||
#endif |
|||
|
|||
// Fix bug in pgm_read_ptr
|
|||
#undef pgm_read_ptr |
|||
#define pgm_read_ptr(addr) (*(addr)) |
|||
|
|||
// ------------------------
|
|||
// Types
|
|||
// ------------------------
|
|||
|
|||
typedef int8_t pin_t; |
|||
|
|||
// ------------------------
|
|||
// Public Variables
|
|||
// ------------------------
|
|||
|
|||
/** result of last ADC conversion */ |
|||
extern uint16_t HAL_adc_result; |
|||
|
|||
// ------------------------
|
|||
// Public functions
|
|||
// ------------------------
|
|||
|
|||
// Memory related
|
|||
#define __bss_end __bss_end__ |
|||
|
|||
inline void HAL_init(void) { } |
|||
|
|||
/** clear reset reason */ |
|||
void HAL_clear_reset_source (void); |
|||
|
|||
/** reset reason */ |
|||
uint8_t HAL_get_reset_source(void); |
|||
|
|||
void _delay_ms(const int delay); |
|||
|
|||
/*
|
|||
extern "C" { |
|||
int freeMemory(void); |
|||
} |
|||
*/ |
|||
|
|||
extern "C" char* _sbrk(int incr); |
|||
/*
|
|||
static int freeMemory() { |
|||
volatile int top; |
|||
top = (int)((char*)&top - reinterpret_cast<char*>(_sbrk(0))); |
|||
return top; |
|||
} |
|||
*/ |
|||
static int freeMemory() { |
|||
volatile char top; |
|||
return &top - reinterpret_cast<char*>(_sbrk(0)); |
|||
} |
|||
|
|||
// SPI: Extended functions which take a channel number (hardware SPI only)
|
|||
/** Write single byte to specified SPI channel */ |
|||
void spiSend(uint32_t chan, byte b); |
|||
/** Write buffer to specified SPI channel */ |
|||
void spiSend(uint32_t chan, const uint8_t* buf, size_t n); |
|||
/** Read single byte from specified SPI channel */ |
|||
uint8_t spiRec(uint32_t chan); |
|||
|
|||
|
|||
// EEPROM
|
|||
|
|||
/**
|
|||
* TODO: Write all this eeprom stuff. Can emulate eeprom in flash as last resort. |
|||
* Wire library should work for i2c eeproms. |
|||
*/ |
|||
void eeprom_write_byte(uint8_t *pos, unsigned char value); |
|||
uint8_t eeprom_read_byte(uint8_t *pos); |
|||
void eeprom_read_block (void *__dst, const void *__src, size_t __n); |
|||
void eeprom_update_block (const void *__src, void *__dst, size_t __n); |
|||
|
|||
// ADC
|
|||
|
|||
#define HAL_ANALOG_SELECT(pin) pinMode(pin, INPUT) |
|||
|
|||
inline void HAL_adc_init(void) {} |
|||
|
|||
#define HAL_START_ADC(pin) HAL_adc_start_conversion(pin) |
|||
#define HAL_READ_ADC() HAL_adc_result |
|||
#define HAL_ADC_READY() true |
|||
|
|||
void HAL_adc_start_conversion(const uint8_t adc_pin); |
|||
uint16_t HAL_adc_get_result(void); |
|||
|
|||
#define GET_PIN_MAP_PIN(index) index |
|||
#define GET_PIN_MAP_INDEX(pin) pin |
|||
#define PARSED_PIN_INDEX(code, dval) parser.intval(code, dval) |
|||
@ -1,37 +0,0 @@ |
|||
/**
|
|||
* Marlin 3D Printer Firmware |
|||
* Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
|
|||
* |
|||
* Based on Sprinter and grbl. |
|||
* Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm |
|||
* Copyright (c) 2017 Victor Perez |
|||
* |
|||
* This program is free software: you can redistribute it and/or modify |
|||
* it under the terms of the GNU General Public License as published by |
|||
* the Free Software Foundation, either version 3 of the License, or |
|||
* (at your option) any later version. |
|||
* |
|||
* This program is distributed in the hope that it will be useful, |
|||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
* GNU General Public License for more details. |
|||
* |
|||
* You should have received a copy of the GNU General Public License |
|||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|||
* |
|||
*/ |
|||
#pragma once |
|||
|
|||
#include <../../libraries/Servo/src/Servo.h> |
|||
|
|||
// Inherit and expand on the official library
|
|||
class libServo : public Servo { |
|||
public: |
|||
int8_t attach(const int pin); |
|||
int8_t attach(const int pin, const int min, const int max); |
|||
void move(const int value); |
|||
private: |
|||
uint16_t min_ticks; |
|||
uint16_t max_ticks; |
|||
uint8_t servoIndex; // index into the channel data for this servo
|
|||
}; |
|||
@ -1,160 +0,0 @@ |
|||
/**
|
|||
* Marlin 3D Printer Firmware |
|||
* Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
|
|||
* |
|||
* Based on Sprinter and grbl. |
|||
* Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm |
|||
* Copyright (c) 2017 Victor Perez |
|||
* |
|||
* This program is free software: you can redistribute it and/or modify |
|||
* it under the terms of the GNU General Public License as published by |
|||
* the Free Software Foundation, either version 3 of the License, or |
|||
* (at your option) any later version. |
|||
* |
|||
* This program is distributed in the hope that it will be useful, |
|||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
* GNU General Public License for more details. |
|||
* |
|||
* You should have received a copy of the GNU General Public License |
|||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|||
* |
|||
*/ |
|||
|
|||
/**
|
|||
* Software SPI functions originally from Arduino Sd2Card Library |
|||
* Copyright (c) 2009 by William Greiman |
|||
*/ |
|||
|
|||
/**
|
|||
* Adapted to the STM32F7 HAL |
|||
*/ |
|||
|
|||
#ifdef STM32F7 |
|||
|
|||
#include "HAL.h" |
|||
#include "../shared/HAL_SPI.h" |
|||
#include <pins_arduino.h> |
|||
#include "spi_pins.h" |
|||
#include "../../core/macros.h" |
|||
#include <SPI.h> |
|||
|
|||
// ------------------------
|
|||
// Public Variables
|
|||
// ------------------------
|
|||
|
|||
static SPISettings spiConfig; |
|||
|
|||
// ------------------------
|
|||
// Public functions
|
|||
// ------------------------
|
|||
|
|||
#if ENABLED(SOFTWARE_SPI) |
|||
// ------------------------
|
|||
// Software SPI
|
|||
// ------------------------
|
|||
#error "Software SPI not supported for STM32F7. Use hardware SPI." |
|||
|
|||
#else |
|||
|
|||
// ------------------------
|
|||
// Hardware SPI
|
|||
// ------------------------
|
|||
|
|||
/**
|
|||
* VGPV SPI speed start and F_CPU/2, by default 72/2 = 36Mhz |
|||
*/ |
|||
|
|||
/**
|
|||
* @brief Begin SPI port setup |
|||
* |
|||
* @return Nothing |
|||
* |
|||
* @details Only configures SS pin since libmaple creates and initialize the SPI object |
|||
*/ |
|||
void spiBegin(void) { |
|||
#if !PIN_EXISTS(SS) |
|||
#error SS_PIN not defined! |
|||
#endif |
|||
|
|||
OUT_WRITE(SS_PIN, HIGH); |
|||
} |
|||
|
|||
/** Configure SPI for specified SPI speed */ |
|||
void spiInit(uint8_t spiRate) { |
|||
// Use datarates Marlin uses
|
|||
uint32_t clock; |
|||
switch (spiRate) { |
|||
case SPI_FULL_SPEED: clock = 20000000; break; // 13.9mhz=20000000 6.75mhz=10000000 3.38mhz=5000000 .833mhz=1000000
|
|||
case SPI_HALF_SPEED: clock = 5000000; break; |
|||
case SPI_QUARTER_SPEED: clock = 2500000; break; |
|||
case SPI_EIGHTH_SPEED: clock = 1250000; break; |
|||
case SPI_SPEED_5: clock = 625000; break; |
|||
case SPI_SPEED_6: clock = 300000; break; |
|||
default: |
|||
clock = 4000000; // Default from the SPI libarary
|
|||
} |
|||
spiConfig = SPISettings(clock, MSBFIRST, SPI_MODE0); |
|||
SPI.begin(); |
|||
} |
|||
|
|||
/**
|
|||
* @brief Receives a single byte from the SPI port. |
|||
* |
|||
* @return Byte received |
|||
* |
|||
* @details |
|||
*/ |
|||
uint8_t spiRec(void) { |
|||
SPI.beginTransaction(spiConfig); |
|||
uint8_t returnByte = SPI.transfer(0xFF); |
|||
SPI.endTransaction(); |
|||
return returnByte; |
|||
} |
|||
|
|||
/**
|
|||
* @brief Receives a number of bytes from the SPI port to a buffer |
|||
* |
|||
* @param buf Pointer to starting address of buffer to write to. |
|||
* @param nbyte Number of bytes to receive. |
|||
* @return Nothing |
|||
* |
|||
* @details Uses DMA |
|||
*/ |
|||
void spiRead(uint8_t* buf, uint16_t nbyte) { |
|||
SPI.beginTransaction(spiConfig); |
|||
SPI.dmaTransfer(0, const_cast<uint8_t*>(buf), nbyte); |
|||
SPI.endTransaction(); |
|||
} |
|||
|
|||
/**
|
|||
* @brief Sends a single byte on SPI port |
|||
* |
|||
* @param b Byte to send |
|||
* |
|||
* @details |
|||
*/ |
|||
void spiSend(uint8_t b) { |
|||
SPI.beginTransaction(spiConfig); |
|||
SPI.transfer(b); |
|||
SPI.endTransaction(); |
|||
} |
|||
|
|||
/**
|
|||
* @brief Write token and then write from 512 byte buffer to SPI (for SD card) |
|||
* |
|||
* @param buf Pointer with buffer start address |
|||
* @return Nothing |
|||
* |
|||
* @details Use DMA |
|||
*/ |
|||
void spiSendBlock(uint8_t token, const uint8_t* buf) { |
|||
SPI.beginTransaction(spiConfig); |
|||
SPI.transfer(token); |
|||
SPI.dmaSend(const_cast<uint8_t*>(buf), 512); |
|||
SPI.endTransaction(); |
|||
} |
|||
|
|||
#endif // SOFTWARE_SPI
|
|||
|
|||
#endif // STM32F7
|
|||
@ -1,64 +0,0 @@ |
|||
/**
|
|||
* Marlin 3D Printer Firmware |
|||
* Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
|
|||
* |
|||
* Based on Sprinter and grbl. |
|||
* Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm |
|||
* Copyright (c) 2017 Victor Perez |
|||
* |
|||
* This program is free software: you can redistribute it and/or modify |
|||
* it under the terms of the GNU General Public License as published by |
|||
* the Free Software Foundation, either version 3 of the License, or |
|||
* (at your option) any later version. |
|||
* |
|||
* This program is distributed in the hope that it will be useful, |
|||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
* GNU General Public License for more details. |
|||
* |
|||
* You should have received a copy of the GNU General Public License |
|||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|||
* |
|||
*/ |
|||
#pragma once |
|||
|
|||
#include "../../module/endstops.h" |
|||
|
|||
// One ISR for all EXT-Interrupts
|
|||
void endstop_ISR(void) { endstops.update(); } |
|||
|
|||
void setup_endstop_interrupts(void) { |
|||
#if HAS_X_MAX |
|||
attachInterrupt(X_MAX_PIN, endstop_ISR, CHANGE); |
|||
#endif |
|||
#if HAS_X_MIN |
|||
attachInterrupt(X_MIN_PIN, endstop_ISR, CHANGE); |
|||
#endif |
|||
#if HAS_Y_MAX |
|||
attachInterrupt(Y_MAX_PIN, endstop_ISR, CHANGE); |
|||
#endif |
|||
#if HAS_Y_MIN |
|||
attachInterrupt(Y_MIN_PIN, endstop_ISR, CHANGE); |
|||
#endif |
|||
#if HAS_Z_MAX |
|||
attachInterrupt(Z_MAX_PIN, endstop_ISR, CHANGE); |
|||
#endif |
|||
#if HAS_Z_MIN |
|||
attachInterrupt(Z_MIN_PIN, endstop_ISR, CHANGE); |
|||
#endif |
|||
#if HAS_Z2_MAX |
|||
attachInterrupt(Z2_MAX_PIN, endstop_ISR, CHANGE); |
|||
#endif |
|||
#if HAS_Z2_MIN |
|||
attachInterrupt(Z2_MIN_PIN, endstop_ISR, CHANGE); |
|||
#endif |
|||
#if HAS_Z3_MAX |
|||
attachInterrupt(Z3_MAX_PIN, endstop_ISR, CHANGE); |
|||
#endif |
|||
#if HAS_Z3_MIN |
|||
attachInterrupt(Z3_MIN_PIN, endstop_ISR, CHANGE); |
|||
#endif |
|||
#if HAS_Z_MIN_PROBE_PIN |
|||
attachInterrupt(Z_MIN_PROBE_PIN, endstop_ISR, CHANGE); |
|||
#endif |
|||
} |
|||
@ -1,27 +0,0 @@ |
|||
/**
|
|||
* Marlin 3D Printer Firmware |
|||
* Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
|
|||
* |
|||
* This program is free software: you can redistribute it and/or modify |
|||
* it under the terms of the GNU General Public License as published by |
|||
* the Free Software Foundation, either version 3 of the License, or |
|||
* (at your option) any later version. |
|||
* |
|||
* This program is distributed in the hope that it will be useful, |
|||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
* GNU General Public License for more details. |
|||
* |
|||
* You should have received a copy of the GNU General Public License |
|||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|||
* |
|||
*/ |
|||
#pragma once |
|||
|
|||
/**
|
|||
* Define SPI Pins: SCK, MISO, MOSI, SS |
|||
*/ |
|||
#define SCK_PIN PA5 |
|||
#define MISO_PIN PA6 |
|||
#define MOSI_PIN PA7 |
|||
#define SS_PIN PA8 |
|||
@ -1,52 +0,0 @@ |
|||
/**
|
|||
* Marlin 3D Printer Firmware |
|||
* Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
|
|||
* |
|||
* Based on Sprinter and grbl. |
|||
* Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm |
|||
* |
|||
* This program is free software: you can redistribute it and/or modify |
|||
* it under the terms of the GNU General Public License as published by |
|||
* the Free Software Foundation, either version 3 of the License, or |
|||
* (at your option) any later version. |
|||
* |
|||
* This program is distributed in the hope that it will be useful, |
|||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
* GNU General Public License for more details. |
|||
* |
|||
* You should have received a copy of the GNU General Public License |
|||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|||
* |
|||
*/ |
|||
|
|||
#ifdef STM32F7 |
|||
|
|||
#include "../../inc/MarlinConfig.h" |
|||
|
|||
#if ENABLED(USE_WATCHDOG) |
|||
|
|||
#include "watchdog_STM32F7.h" |
|||
|
|||
IWDG_HandleTypeDef hiwdg; |
|||
|
|||
void watchdog_init() { |
|||
hiwdg.Instance = IWDG; |
|||
hiwdg.Init.Prescaler = IWDG_PRESCALER_32; //32kHz LSI clock and 32x prescalar = 1024Hz IWDG clock
|
|||
hiwdg.Init.Reload = 4095; //4095 counts = 4 seconds at 1024Hz
|
|||
if (HAL_IWDG_Init(&hiwdg) != HAL_OK) { |
|||
//Error_Handler();
|
|||
} |
|||
} |
|||
|
|||
void watchdog_reset() { |
|||
/* Refresh IWDG: reload counter */ |
|||
if (HAL_IWDG_Refresh(&hiwdg) != HAL_OK) { |
|||
/* Refresh Error */ |
|||
//Error_Handler();
|
|||
} |
|||
} |
|||
|
|||
#endif // USE_WATCHDOG
|
|||
|
|||
#endif // STM32F7
|
|||
@ -0,0 +1,6 @@ |
|||
# This HAL is for... |
|||
|
|||
- STM32F407 MCU with STM32Generic Arduino core by danieleff. |
|||
- STM32F765 board "The Borg" with STM32Generic. |
|||
|
|||
See the `README.md` files in HAL_STM32F4 and HAL_STM32F7 for the specifics of those hals. |
|||
Loading…
Reference in new issue