3DPrinting/MarlinFirmware
1
0
Fork 0
mirror of https://github.com/MarlinFirmware/Marlin.git synced 2024-11-26 13:25:54 +00:00
Code Issues Releases Wiki Activity

Bring STM32F4/F7 together

Browse Source
This commit is contained in:
Scott Lahteine 2019-07-09 23:54:34 -05:00
parent cf9ac4c847
commit ad1c061e7b
49 changed files with 197 additions and 1905 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
Marlin/src/HAL/HAL.h
View File

@ -33,10 +33,8 @@
#define HAL_PLATFORM HAL_LPC1768
#elif defined(__STM32F1__) || defined(TARGET_STM32F1)
#define HAL_PLATFORM HAL_STM32F1
#elif defined(STM32GENERIC) && defined(STM32F4)
#define HAL_PLATFORM HAL_STM32F4
#elif defined(STM32GENERIC) && defined(STM32F7)
#define HAL_PLATFORM HAL_STM32F7
#elif defined(STM32GENERIC) && (defined(STM32F4) || defined(STM32F7))
#define HAL_PLATFORM HAL_STM32_F4_F7
#elif defined(ARDUINO_ARCH_STM32)
#define HAL_PLATFORM HAL_STM32
#elif defined(ARDUINO_ARCH_ESP32)

2
Marlin/src/HAL/HAL_STM32/persistent_store_impl.cpp
View File

@ -83,7 +83,7 @@ bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, ui
return false;
}
bool PersistentStore::read_data(int &pos, uint8_t* value, size_t size, uint16_t *crc, const bool writing) {
bool PersistentStore::read_data(int &pos, uint8_t* value, size_t size, uint16_t *crc, const bool writing/*=true*/) {
do {
// Read from either external EEPROM, program flash or Backup SRAM
const uint8_t c = (

6
Marlin/src/HAL/HAL_STM32/pinsDebug_STM32GENERIC.h
View File

@ -30,10 +30,8 @@
#ifdef __STM32F1__
#include "../HAL_STM32F1/fastio_STM32F1.h"
#elif defined(STM32F4)
#include "../HAL_STM32F4/fastio_STM32F4.h"
#elif defined(STM32F7)
#include "../HAL_STM32F7/fastio_STM32F7.h"
#elif defined(STM32F4) || defined(STM32F7)
#include "../HAL_STM32_F4_F7/fastio_STM32_F4_F7.h"
#endif
extern const stm32_pin_info PIN_MAP[BOARD_NR_GPIO_PINS];

4
Marlin/src/HAL/HAL_STM32F1/persistent_store_eeprom.cpp
View File

@ -49,10 +49,10 @@ bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, ui
return false;
}
bool PersistentStore::read_data(int &pos, uint8_t* value, size_t size, uint16_t *crc, const bool set/*=true*/) {
bool PersistentStore::read_data(int &pos, uint8_t* value, size_t size, uint16_t *crc, const bool writing/*=true*/) {
do {
uint8_t c = eeprom_read_byte((uint8_t*)pos);
if (set && value) *value = c;
if (writing && value) *value = c;
crc16(crc, &c, 1);
pos++;
value++;

111
Marlin/src/HAL/HAL_STM32F4/EmulatedEeprom.cpp
View File

@ -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

53
Marlin/src/HAL/HAL_STM32F4/HAL_Servo_STM32F4.cpp
View File

@ -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

153
Marlin/src/HAL/HAL_STM32F4/fastio_STM32F4.h
View File

@ -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)

69
Marlin/src/HAL/HAL_STM32F4/persistent_store_eeprom.cpp
View File

@ -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

27
Marlin/src/HAL/HAL_STM32F4/pinsDebug.h
View File

@ -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

525
Marlin/src/HAL/HAL_STM32F7/EEPROM_Emul/eeprom_emul.cpp
View File

@ -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****/

109
Marlin/src/HAL/HAL_STM32F7/EEPROM_Emul/eeprom_emul.h
View 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>&copy; 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****/

107
Marlin/src/HAL/HAL_STM32F7/HAL.cpp
View 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

208
Marlin/src/HAL/HAL_STM32F7/HAL.h
View File

@ -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)

37
Marlin/src/HAL/HAL_STM32F7/HAL_Servo_STM32F7.h
View File

@ -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
};

160
Marlin/src/HAL/HAL_STM32F7/HAL_spi_STM32F7.cpp
View File

@ -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

37
Marlin/src/HAL/HAL_STM32F7/SanityCheck.h
View File

@ -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 STM32F7-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 STM32F7. Disable EMERGENCY_PARSER to continue."
#endif
#if ENABLED(FAST_PWM_FAN)
#error "FAST_PWM_FAN is not yet implemented for this platform."
#endif

64
Marlin/src/HAL/HAL_STM32F7/endstop_interrupts.h
View File

@ -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
}

27
Marlin/src/HAL/HAL_STM32F7/spi_pins.h
View File

@ -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

52
Marlin/src/HAL/HAL_STM32F7/watchdog_STM32F7.cpp
View File

@ -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

33
Marlin/src/HAL/HAL_STM32F7/EmulatedEeprom.cpp → Marlin/src/HAL/HAL_STM32_F4_F7/EmulatedEeprom.cpp
View File

@ -17,29 +17,43 @@
*
*/
#ifdef STM32F7
#if defined(STM32GENERIC) && (defined(STM32F4) || defined(STM32F7))
/**
* Description: Functions for a Flash emulated EEPROM
* Not platform dependent.
*/
// Include configs and pins to get all EEPROM flags
#include "../../inc/MarlinConfig.h"
#ifdef STM32F7
#define HAS_EMULATED_EEPROM 1
#else
#define HAS_EMULATED_EEPROM NONE(I2C_EEPROM, SPI_EEPROM)
#endif
#if HAS_EMULATED_EEPROM && ENABLED(EEPROM_SETTINGS)
// ------------------------
// Includes
// ------------------------
#include "HAL.h"
#include "EEPROM_Emul/eeprom_emul.h"
#include "eeprom_emul.h"
// ------------------------
// Local defines
// ------------------------
// FLASH_FLAG_PGSERR (Programming Sequence Error) was renamed to
// FLASH_FLAG_ERSERR (Erasing Sequence Error) in STM32F7
#define FLASH_FLAG_PGSERR FLASH_FLAG_ERSERR
// FLASH_FLAG_ERSERR (Erasing Sequence Error) in STM32F4/7
#ifdef STM32F7
#define FLASH_FLAG_PGSERR FLASH_FLAG_ERSERR
#else
//#define FLASH_FLAG_PGSERR FLASH_FLAG_ERSERR
#endif
// ------------------------
// Private Variables
@ -67,13 +81,12 @@ void eeprom_init() {
}
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);
uint16_t eeprom_address = unsigned(pos);
if (EE_WriteVariable(eeprom_address, uint16_t(value)) != EE_OK)
for (;;) HAL_Delay(1); // Spin forever until watchdog reset
@ -91,11 +104,10 @@ uint8_t eeprom_read_byte(uint8_t *pos) {
}
void eeprom_read_block(void *__dst, const void *__src, size_t __n) {
uint16_t data = 0xFF;
uint16_t eeprom_address = unsigned(__src);
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;
@ -106,4 +118,5 @@ void eeprom_update_block(const void *__src, void *__dst, size_t __n) {
}
#endif // STM32F7
#endif // EEPROM_SETTINGS
#endif // STM32GENERIC && (STM32F4 || STM32F7)

19
Marlin/src/HAL/HAL_STM32F4/HAL.cpp → Marlin/src/HAL/HAL_STM32_F4_F7/HAL.cpp
View File

@ -21,7 +21,7 @@
*
*/
#if defined(STM32GENERIC) && defined(STM32F4)
#if defined(STM32GENERIC) && (defined(STM32F4) || defined(STM32F7))
#include "HAL.h"
@ -49,10 +49,9 @@ 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;
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;
}
@ -90,12 +89,8 @@ extern "C" {
// ADC
// ------------------------
void HAL_adc_start_conversion(const uint8_t adc_pin) {
HAL_adc_result = analogRead(adc_pin);
}
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;
}
uint16_t HAL_adc_get_result(void) { return HAL_adc_result; }
#endif // // STM32GENERIC && STM32F4
#endif // STM32GENERIC && (STM32F4 || STM32F7)

26
Marlin/src/HAL/HAL_STM32F4/HAL.h → Marlin/src/HAL/HAL_STM32_F4_F7/HAL.h
View File

@ -27,15 +27,17 @@
#include "../shared/Marduino.h"
#include "../shared/math_32bit.h"
#include "../shared/HAL_SPI.h"
#include "fastio_STM32F4.h"
#include "watchdog_STM32F4.h"
#include "HAL_timers_STM32F4.h"
#include "fastio_STM32_F4_F7.h"
#include "watchdog_STM32_F4_F7.h"
#include "HAL_timers_STM32_F4_F7.h"
#include "../../inc/MarlinConfigPre.h"
#include <stdint.h>
#ifdef USBCON
#ifdef defined(STM32F4) && USBCON
#include <USBSerial.h>
#endif
@ -46,7 +48,7 @@
//Serial override
//extern HalSerial usb_serial;
#if SERIAL_PORT == 0
#if defined(STM32F4) && SERIAL_PORT == 0
#error "Serial port 0 does not exist"
#endif
@ -70,10 +72,9 @@
#endif
#ifdef SERIAL_PORT_2
#if SERIAL_PORT_2 == 0
#if defined(STM32F4) && SERIAL_PORT_2 == 0
#error "Serial port 0 does not exist"
#endif
#if !WITHIN(SERIAL_PORT_2, -1, 6)
#error "SERIAL_PORT_2 must be from -1 to 6"
#elif SERIAL_PORT_2 == SERIAL_PORT
@ -99,7 +100,6 @@
#define NUM_SERIAL 1
#endif
#undef _BV
#define _BV(b) (1 << (b))
/**
@ -134,7 +134,9 @@
typedef int8_t pin_t;
#define HAL_SERVO_LIB libServo
#ifdef STM32F4
#define HAL_SERVO_LIB libServo
#endif
// ------------------------
// Public Variables
@ -224,5 +226,7 @@ uint16_t HAL_adc_get_result(void);
#define GET_PIN_MAP_INDEX(pin) pin
#define PARSED_PIN_INDEX(code, dval) parser.intval(code, dval)
#define JTAG_DISABLE() afio_cfg_debug_ports(AFIO_DEBUG_SW_ONLY)
#define JTAGSWD_DISABLE() afio_cfg_debug_ports(AFIO_DEBUG_NONE)
#ifdef STM32F4
#define JTAG_DISABLE() afio_cfg_debug_ports(AFIO_DEBUG_SW_ONLY)
#define JTAGSWD_DISABLE() afio_cfg_debug_ports(AFIO_DEBUG_NONE)
#endif

8
Marlin/src/HAL/HAL_STM32F7/HAL_Servo_STM32F7.cpp → Marlin/src/HAL/HAL_STM32_F4_F7/HAL_Servo_STM32_F4_F7.cpp
View File

@ -21,13 +21,13 @@
*
*/
#ifdef STM32F7
#if defined(STM32GENERIC) && (defined(STM32F4) || defined(STM32F7))
#include "../../inc/MarlinConfig.h"
#if HAS_SERVOS
#include "HAL_Servo_STM32F7.h"
#include "HAL_Servo_STM32_F4_F7.h"
int8_t libServo::attach(const int pin) {
if (this->servoIndex >= MAX_SERVOS) return -1;
@ -49,6 +49,6 @@ void libServo::move(const int value) {
#endif
}
}
#endif // HAS_SERVOS
#endif // STM32F7
#endif // HAS_SERVOS
#endif // STM32GENERIC && (STM32F4 || STM32F7)

9
Marlin/src/HAL/HAL_STM32F4/HAL_Servo_STM32F4.h → Marlin/src/HAL/HAL_STM32_F4_F7/HAL_Servo_STM32_F4_F7.h
View File

@ -22,7 +22,11 @@
*/
#pragma once
#include <Servo.h>
//#ifdef STM32F7
// #include <../../libraries/Servo/src/Servo.h>
//#else
#include <Servo.h>
//#endif
// Inherit and expand on the official library
class libServo : public Servo {
@ -31,7 +35,6 @@ class libServo : public Servo {
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;
uint16_t min_ticks, max_ticks;
uint8_t servoIndex; // index into the channel data for this servo
};

15
Marlin/src/HAL/HAL_STM32F4/HAL_spi_STM32F4.cpp → Marlin/src/HAL/HAL_STM32_F4_F7/HAL_spi_STM32_F4_F7.cpp
View File

@ -27,10 +27,10 @@
*/
/**
* Adapted to the STM32F4 HAL
* Adapted to the Marlin STM32F4/7 HAL
*/
#if defined(STM32GENERIC) && defined(STM32F4)
#if defined(STM32GENERIC) && (defined(STM32F4) || defined(STM32F7))
#include "HAL.h"
#include "../shared/HAL_SPI.h"
@ -50,12 +50,10 @@ static SPISettings spiConfig;
// ------------------------
#if ENABLED(SOFTWARE_SPI)
// ------------------------
// Software SPI
// ------------------------
#error "Software SPI not supported for STM32F4. Use hardware SPI."
#error "Software SPI not supported for STM32F4/7. Use Hardware SPI."
#else
// ------------------------
@ -123,13 +121,11 @@ uint8_t spiRec(void) {
*/
void spiRead(uint8_t* buf, uint16_t nbyte) {
SPI.beginTransaction(spiConfig);
#ifdef STM32GENERIC
SPI.dmaTransfer(0, const_cast<uint8_t*>(buf), nbyte);
#else
SPI.transfer((uint8_t*)buf, nbyte);
#endif
SPI.endTransaction();
}
@ -157,16 +153,13 @@ void spiSend(uint8_t b) {
void spiSendBlock(uint8_t token, const uint8_t* buf) {
SPI.beginTransaction(spiConfig);
SPI.transfer(token);
#ifdef STM32GENERIC
SPI.dmaSend(const_cast<uint8_t*>(buf), 512);
#else
SPI.transfer((uint8_t*)buf, nullptr, 512);
#endif
SPI.endTransaction();
}
#endif // SOFTWARE_SPI
#endif // STM32GENERIC && STM32F4
#endif // STM32GENERIC && (STM32F4 || STM32F7)

15
Marlin/src/HAL/HAL_STM32F7/watchdog_STM32F7.h → Marlin/src/HAL/HAL_STM32_F4_F7/HAL_timers_STM32_F4_F7.h
View File

@ -1,9 +1,9 @@
/**
* 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) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
* Copyright (c) 2016 Bob Cousins bobcousins42@googlemail.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
@ -21,7 +21,8 @@
*/
#pragma once
extern IWDG_HandleTypeDef hiwdg;
void watchdog_init();
void watchdog_reset();
#ifdef STM32F4
#include "STM32F4/HAL_timers_STM32F4.h"
#else
#include "STM32F7/HAL_timers_STM32F7.h"
#endif

6
Marlin/src/HAL/HAL_STM32_F4_F7/README.md Normal file
View File

@ -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.

4
Marlin/src/HAL/HAL_STM32F4/HAL_timers_STM32F4.cpp → Marlin/src/HAL/HAL_STM32_F4_F7/STM32F4/HAL_timers_STM32F4.cpp
View File

@ -22,8 +22,7 @@
#if defined(STM32GENERIC) && defined(STM32F4)
#include "HAL.h"
#include "../HAL.h"
#include "HAL_timers_STM32F4.h"
// ------------------------
@ -35,6 +34,7 @@
#define TEMP_TIMER_IRQ_ID TIM7_IRQn
//#define PRESCALER 1
// ------------------------
// Private Variables
// ------------------------

0
Marlin/src/HAL/HAL_STM32F4/HAL_timers_STM32F4.h → Marlin/src/HAL/HAL_STM32_F4_F7/STM32F4/HAL_timers_STM32F4.h
View File

0
Marlin/src/HAL/HAL_STM32F4/README.md → Marlin/src/HAL/HAL_STM32_F4_F7/STM32F4/README.md
View File

11
Marlin/src/HAL/HAL_STM32F7/HAL_timers_STM32F7.cpp → Marlin/src/HAL/HAL_STM32_F4_F7/STM32F7/HAL_timers_STM32F7.cpp
View File

@ -20,10 +20,9 @@
*
*/
#ifdef STM32F7
#include "HAL.h"
#if defined(STM32GENERIC) && defined(STM32F7)
#include "../HAL.h"
#include "HAL_timers_STM32F7.h"
// ------------------------
@ -33,6 +32,7 @@
#define NUM_HARDWARE_TIMERS 2
//#define PRESCALER 1
// ------------------------
// Private Variables
// ------------------------
@ -43,8 +43,7 @@ tTimerConfig timerConfig[NUM_HARDWARE_TIMERS];
// Public functions
// ------------------------
bool timers_initialized[NUM_HARDWARE_TIMERS] = {false};
bool timers_initialized[NUM_HARDWARE_TIMERS] = { false };
void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
@ -128,4 +127,4 @@ bool HAL_timer_interrupt_enabled(const uint8_t timer_num) {
return NVIC->ISER[IRQ_Id >> 5] & _BV32(IRQ_Id & 0x1F);
}
#endif // STM32F7
#endif // STM32GENERIC && STM32F7

2
Marlin/src/HAL/HAL_STM32F7/HAL_timers_STM32F7.h → Marlin/src/HAL/HAL_STM32_F4_F7/STM32F7/HAL_timers_STM32F7.h
View File

@ -57,8 +57,8 @@
#define STEPPER_ISR_ENABLED() HAL_timer_interrupt_enabled(STEP_TIMER_NUM)
#define TEMP_ISR_ENABLED() HAL_timer_interrupt_enabled(TEMP_TIMER_NUM)
// TODO change this
// TODO change this
extern void TC5_Handler();
extern void TC7_Handler();

7
Marlin/src/HAL/HAL_STM32F7/README.md → Marlin/src/HAL/HAL_STM32_F4_F7/STM32F7/README.md
View File

@ -4,7 +4,7 @@
https://github.com/danieleff/STM32GENERIC
but i have not committed the changes needed for the Borg there yet, so please use:
but I haven't committed the changes needed for the Borg there yet, so please use:
https://github.com/Spawn32/STM32GENERIC
@ -15,9 +15,9 @@ Download the latest GNU ARM Embedded Toolchain:
https://developer.arm.com/open-source/gnu-toolchain/gnu-rm/downloads
(The one in Arduino dosen't support STM32F7).
(The one in Arduino doesn't support STM32F7).
Change compiler.path in platform.txt to point to that you downloaded.
Change compiler.path in platform.txt to point to the one you downloaded.
# This HAL is in development.
# Currently only tested on "The Borg".
@ -25,4 +25,3 @@ Change compiler.path in platform.txt to point to that you downloaded.
You will also need the latest Arduino 1.9.0-beta or newer.
This HAL is a modified version of Chris Barr's Picoprint STM32F4 HAL, so shouldn't be to hard to get it to work on a F4.

30
Marlin/src/HAL/HAL_STM32F7/TMC2660.cpp → Marlin/src/HAL/HAL_STM32_F4_F7/STM32F7/TMC2660.cpp
View File

@ -25,22 +25,22 @@
*
*/
//#include <Arduino.h>
#if defined(STM32GENERIC) && defined(STM32F7)
#ifdef STM32F7
#include "../../../inc/MarlinConfigPre.h"
#if HAS_DRIVER(TMC2660)
#include <stdbool.h>
#include <SPI.h>
#include "TMC2660.h"
#include "HAL.h"
#include "../../core/serial.h"
#include "../../inc/MarlinConfig.h"
#include "../../Marlin.h"
#include "../../module/stepper_indirection.h"
#include "../../module/printcounter.h"
#include "../../libs/duration_t.h"
#include "../../libs/hex_print_routines.h"
#include "../../../inc/MarlinConfig.h"
#include "../../../Marlin.h"
#include "../../../module/stepper_indirection.h"
#include "../../../module/printcounter.h"
#include "../../../libs/duration_t.h"
#include "../../../libs/hex_print_routines.h"
//some default values used in initialization
#define DEFAULT_MICROSTEPPING_VALUE 32
@ -630,19 +630,19 @@ uint16_t TMC26XStepper::getCoolStepLowerSgThreshold() {
}
uint16_t TMC26XStepper::getCoolStepUpperSgThreshold() {
return (uint8_t)((cool_step_register_value & SE_MAX_PATTERN) >> 8) << 5;
return uint8_t((cool_step_register_value & SE_MAX_PATTERN) >> 8) << 5;
}
uint8_t TMC26XStepper::getCoolStepCurrentIncrementSize() {
return (uint8_t)((cool_step_register_value & CURRENT_DOWN_STEP_SPEED_PATTERN) >> 13);
return uint8_t((cool_step_register_value & CURRENT_DOWN_STEP_SPEED_PATTERN) >> 13);
}
uint8_t TMC26XStepper::getCoolStepNumberOfSGReadings() {
return (uint8_t)((cool_step_register_value & SE_CURRENT_STEP_WIDTH_PATTERN) >> 5);
return uint8_t((cool_step_register_value & SE_CURRENT_STEP_WIDTH_PATTERN) >> 5);
}
uint8_t TMC26XStepper::getCoolStepLowerCurrentLimit() {
return (uint8_t)((cool_step_register_value & MINIMUM_CURRENT_FOURTH) >> 15);
return uint8_t((cool_step_register_value & MINIMUM_CURRENT_FOURTH) >> 15);
}
void TMC26XStepper::setEnabled(boolean enabled) {
@ -895,4 +895,4 @@ inline void TMC26XStepper::send262(uint32_t datagram) {
driver_status_result = i_datagram;
}
#endif // STM32F7
#endif // STM32GENERIC && STM32F7

1
Marlin/src/HAL/HAL_STM32F7/TMC2660.h → Marlin/src/HAL/HAL_STM32_F4_F7/STM32F7/TMC2660.h
View File

@ -140,7 +140,6 @@ class TMC26XStepper {
*/
void un_start();
/*!
* \brief Set the rotation speed in RPM.
* \param whatSpeed the desired speed in RPM.

4
Marlin/src/HAL/HAL_STM32F4/SanityCheck.h → Marlin/src/HAL/HAL_STM32_F4_F7/SanityCheck.h
View File

@ -22,14 +22,14 @@
#pragma once
/**
* Test STM32F4-specific configuration values for errors at compile-time.
* Test STM32F4/7-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."
#error "EMERGENCY_PARSER is not yet implemented for STM32F4/7. Disable EMERGENCY_PARSER to continue."
#endif
#if ENABLED(FAST_PWM_FAN)

4
Marlin/src/HAL/HAL_STM32F4/EEPROM_Emul/eeprom_emul.cpp → Marlin/src/HAL/HAL_STM32_F4_F7/eeprom_emul.cpp
View File

@ -47,7 +47,7 @@
/** @addtogroup EEPROM_Emulation
* @{
*/
#if defined(STM32GENERIC) && defined(STM32F4)
#if defined(STM32GENERIC) && (defined(STM32F4) || defined(STM32F7))
/* Includes ------------------------------------------------------------------*/
#include "eeprom_emul.h"
@ -516,7 +516,7 @@ static uint16_t EE_PageTransfer(uint16_t VirtAddress, uint16_t Data) {
return HAL_FLASH_Program(TYPEPROGRAM_HALFWORD, NewPageAddress, VALID_PAGE);
}
#endif // STM32GENERIC && STM32F4
#endif // STM32GENERIC && (STM32F4 || STM32F7)
/**
* @}

17
Marlin/src/HAL/HAL_STM32F4/EEPROM_Emul/eeprom_emul.h → Marlin/src/HAL/HAL_STM32_F4_F7/eeprom_emul.h
View File

@ -8,7 +8,7 @@
******************************************************************************
* @attention
*
* <h2><center>&copy; Copyright <EFBFBD> 2016 STMicroelectronics International N.V.
* Copyright © 2016 STMicroelectronics International N.V.
* All rights reserved.</center></h2>
*
* Redistribution and use in source and binary forms, with or without
@ -48,8 +48,9 @@
// ------------------------
// Includes
// ------------------------
#include "../../../inc/MarlinConfig.h"
#include "../HAL.h"
#include "../../inc/MarlinConfig.h"
#include "HAL.h"
/* Exported constants --------------------------------------------------------*/
/* EEPROM emulation firmware error codes */
@ -66,8 +67,14 @@
#define VOLTAGE_RANGE uint8_t(VOLTAGE_RANGE_3)
/* EEPROM start address in Flash */
#define EEPROM_START_ADDRESS uint32_t(0x08078000) /* EEPROM emulation start address:
after 480KByte of used Flash memory */
#ifdef STM32F7
#define EEPROM_START_ADDRESS uint32_t(0x08100000) /* EEPROM emulation start address:
from sector2 : after 16KByte of used
Flash memory */
#else
#define EEPROM_START_ADDRESS uint32_t(0x08078000) /* EEPROM emulation start address:
after 480KByte of used Flash memory */
#endif
/* Pages 0 and 1 base and end addresses */
#define PAGE0_BASE_ADDRESS uint32_t(EEPROM_START_ADDRESS + 0x0000)

0
Marlin/src/HAL/HAL_STM32F4/endstop_interrupts.h → Marlin/src/HAL/HAL_STM32_F4_F7/endstop_interrupts.h
View File

76
Marlin/src/HAL/HAL_STM32F7/fastio_STM32F7.h → Marlin/src/HAL/HAL_STM32_F4_F7/fastio_STM32_F4_F7.h
View File

@ -23,7 +23,7 @@
#pragma once
/**
* Fast I/O interfaces for STM32F7
* Fast I/O interfaces for STM32F4/7
* These use GPIO functions instead of Direct Port Manipulation, as on AVR.
*/
@ -63,10 +63,8 @@
#define PORTC 2
#define PORTD 3
#define PORTE 4
#define PORTF 5
#define PORTG 6
#define _STM32_PIN(_PORT,_PIN) ((PORT##_PORT * 16) + _PIN)
#define _STM32_PIN(P,PN) ((PORT##P * 16) + PN)
#define PA0 _STM32_PIN(A, 0)
#define PA1 _STM32_PIN(A, 1)
@ -153,36 +151,42 @@
#define PE14 _STM32_PIN(E, 14)
#define PE15 _STM32_PIN(E, 15)
#define PF0 _STM32_PIN(F, 0)
#define PF1 _STM32_PIN(F, 1)
#define PF2 _STM32_PIN(F, 2)
#define PF3 _STM32_PIN(F, 3)
#define PF4 _STM32_PIN(F, 4)
#define PF5 _STM32_PIN(F, 5)
#define PF6 _STM32_PIN(F, 6)
#define PF7 _STM32_PIN(F, 7)
#define PF8 _STM32_PIN(F, 8)
#define PF9 _STM32_PIN(F, 9)
#define PF10 _STM32_PIN(F, 10)
#define PF11 _STM32_PIN(F, 11)
#define PF12 _STM32_PIN(F, 12)
#define PF13 _STM32_PIN(F, 13)
#define PF14 _STM32_PIN(F, 14)
#define PF15 _STM32_PIN(F, 15)
#ifdef STM32F7
#define PORTF 5
#define PORTG 6
#define PG0 _STM32_PIN(G, 0)
#define PG1 _STM32_PIN(G, 1)
#define PG2 _STM32_PIN(G, 2)
#define PG3 _STM32_PIN(G, 3)
#define PG4 _STM32_PIN(G, 4)
#define PG5 _STM32_PIN(G, 5)
#define PG6 _STM32_PIN(G, 6)
#define PG7 _STM32_PIN(G, 7)
#define PG8 _STM32_PIN(G, 8)
#define PG9 _STM32_PIN(G, 9)
#define PG10 _STM32_PIN(G, 10)
#define PG11 _STM32_PIN(G, 11)
#define PG12 _STM32_PIN(G, 12)
#define PG13 _STM32_PIN(G, 13)
#define PG14 _STM32_PIN(G, 14)
#define PG15 _STM32_PIN(G, 15)
#define PF0 _STM32_PIN(F, 0)
#define PF1 _STM32_PIN(F, 1)
#define PF2 _STM32_PIN(F, 2)
#define PF3 _STM32_PIN(F, 3)
#define PF4 _STM32_PIN(F, 4)
#define PF5 _STM32_PIN(F, 5)
#define PF6 _STM32_PIN(F, 6)
#define PF7 _STM32_PIN(F, 7)
#define PF8 _STM32_PIN(F, 8)
#define PF9 _STM32_PIN(F, 9)
#define PF10 _STM32_PIN(F, 10)
#define PF11 _STM32_PIN(F, 11)
#define PF12 _STM32_PIN(F, 12)
#define PF13 _STM32_PIN(F, 13)
#define PF14 _STM32_PIN(F, 14)
#define PF15 _STM32_PIN(F, 15)
#define PG0 _STM32_PIN(G, 0)
#define PG1 _STM32_PIN(G, 1)
#define PG2 _STM32_PIN(G, 2)
#define PG3 _STM32_PIN(G, 3)
#define PG4 _STM32_PIN(G, 4)
#define PG5 _STM32_PIN(G, 5)
#define PG6 _STM32_PIN(G, 6)
#define PG7 _STM32_PIN(G, 7)
#define PG8 _STM32_PIN(G, 8)
#define PG9 _STM32_PIN(G, 9)
#define PG10 _STM32_PIN(G, 10)
#define PG11 _STM32_PIN(G, 11)
#define PG12 _STM32_PIN(G, 12)
#define PG13 _STM32_PIN(G, 13)
#define PG14 _STM32_PIN(G, 14)
#define PG15 _STM32_PIN(G, 15)
#endif // STM32GENERIC && STM32F7

8
Marlin/src/HAL/HAL_STM32F7/persistent_store_eeprom.cpp → Marlin/src/HAL/HAL_STM32_F4_F7/persistent_store_eeprom.cpp
View File

@ -21,7 +21,7 @@
*
*/
#ifdef STM32F7
#if defined(STM32GENERIC) && (defined(STM32F4) || defined(STM32F7))
#include "../../inc/MarlinConfigPre.h"
@ -52,10 +52,10 @@ bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, ui
return false;
}
bool PersistentStore::read_data(int &pos, uint8_t* value, size_t size, uint16_t *crc) {
bool PersistentStore::read_data(int &pos, uint8_t* value, size_t size, uint16_t *crc, const bool writing/*=true*/) {
do {
uint8_t c = eeprom_read_byte((uint8_t*)pos);
*value = c;
if (writing) *value = c;
crc16(crc, &c, 1);
pos++;
value++;
@ -66,4 +66,4 @@ bool PersistentStore::read_data(int &pos, uint8_t* value, size_t size, uint16_t
size_t PersistentStore::capacity() { return E2END + 1; }
#endif // EEPROM_SETTINGS
#endif // STM32F7
#endif // STM32GENERIC && (STM32F4 || STM32F7)

2
Marlin/src/HAL/HAL_STM32F7/pinsDebug.h → Marlin/src/HAL/HAL_STM32_F4_F7/pinsDebug.h
View File

@ -23,5 +23,5 @@
#elif defined(BOARD_NR_GPIO_PINS) // Only in STM32GENERIC (Maple)
#include "../HAL_STM32/pinsDebug_STM32GENERIC.h"
#else
#error "M43 not supported for this board"
#error "M43 Pins Debugging not supported for this board."
#endif

0
Marlin/src/HAL/HAL_STM32F4/spi_pins.h → Marlin/src/HAL/HAL_STM32_F4_F7/spi_pins.h
View File

17
Marlin/src/HAL/HAL_STM32F4/watchdog_STM32F4.cpp → Marlin/src/HAL/HAL_STM32_F4_F7/watchdog_STM32_F4_F7.cpp
View File

@ -20,13 +20,13 @@
*
*/
#if defined(STM32GENERIC) && defined(STM32F4)
#if defined(STM32GENERIC) && (defined(STM32F4) || defined(STM32F7))
#include "../../inc/MarlinConfig.h"
#if ENABLED(USE_WATCHDOG)
#include "watchdog_STM32F4.h"
#include "watchdog_STM32_F4_F7.h"
IWDG_HandleTypeDef hiwdg;
@ -37,6 +37,11 @@
if (HAL_IWDG_Init(&hiwdg) != HAL_OK) {
//Error_Handler();
}
else {
#if PIN_EXISTS(LED) && !ENABLED(PINS_DEBUGGING)
TOGGLE(LED_PIN); // heartbeat indicator
#endif
}
}
void watchdog_reset() {
@ -45,13 +50,7 @@
/* Refresh Error */
//Error_Handler();
}
else {
#if PIN_EXISTS(LED)
TOGGLE(LED_PIN); // heartbeat indicator
#endif
}
}
#endif // USE_WATCHDOG
#endif // STM32GENERIC && STM32F4
#endif // STM32GENERIC && (STM32F4 || STM32F7)

0
Marlin/src/HAL/HAL_STM32F4/watchdog_STM32F4.h → Marlin/src/HAL/HAL_STM32_F4_F7/watchdog_STM32_F4_F7.h
View File

4
Marlin/src/HAL/HAL_TEENSY31_32/HAL_timers_Teensy.h
View File

@ -44,8 +44,8 @@ typedef uint32_t hal_timer_t;
#define FTM0_TIMER_PRESCALE_BITS 0b011
#define FTM1_TIMER_PRESCALE_BITS 0b010
#define FTM0_TIMER_RATE (F_BUS / FTM0_TIMER_PRESCALE) // 60MHz / 8 = 7500kHz
#define FTM1_TIMER_RATE (F_BUS / FTM1_TIMER_PRESCALE) // 60MHz / 4 = 15MHz
#define FTM0_TIMER_RATE (F_BUS / (FTM0_TIMER_PRESCALE)) // 60MHz / 8 = 7500kHz
#define FTM1_TIMER_RATE (F_BUS / (FTM1_TIMER_PRESCALE)) // 60MHz / 4 = 15MHz
#define HAL_TIMER_RATE (FTM0_TIMER_RATE)

4
Marlin/src/module/stepper_indirection.cpp
View File

@ -45,8 +45,8 @@
#if HAS_DRIVER(TMC26X)
#include <SPI.h>
#ifdef STM32F7
#include "../HAL/HAL_STM32F7/TMC2660.h"
#if defined(STM32GENERIC) && defined(STM32F7)
#include "../HAL/HAL_STM32_F4_F7/STM32F7/TMC2660.h"
#else
#include <TMC26XStepper.h>
#endif

4
Marlin/src/module/stepper_indirection.h
View File

@ -35,8 +35,8 @@
// TMC26X drivers have STEP/DIR on normal pins, but ENABLE via SPI
#if HAS_DRIVER(TMC26X)
#include <SPI.h>
#ifdef STM32F7
#include "../HAL/HAL_STM32F7/TMC2660.h"
#if defined(STM32GENERIC) && defined(STM32F7)
#include "../HAL/HAL_STM32_F4_F7/STM32F7/TMC2660.h"
#else
#include <TMC26XStepper.h>
#endif

19
platformio.ini
View File

@ -329,7 +329,7 @@ upload_protocol = stlink
debug_tool = stlink
#
# STM32F4
# STM32F4 with STM32GENERIC
#
[env:STM32F4]
platform = ststm32
@ -338,7 +338,20 @@ board = disco_f407vg
build_flags = ${common.build_flags} -DUSE_STM32GENERIC -DSTM32GENERIC -DMENU_USB_SERIAL -DMENU_SERIAL=SerialUSB
lib_deps = ${common.lib_deps}
lib_ignore = Adafruit NeoPixel, c1921b4, TMCStepper
src_filter = ${common.default_src_filter} +<src/HAL/HAL_STM32F4>
src_filter = ${common.default_src_filter} +<src/HAL/HAL_STM32_F4_F7> -<src/HAL/HAL_STM32_F4_F7/*> +<src/HAL/HAL_STM32_F4_F7/STM32F4>
monitor_speed = 250000
#
# STM32F7 with STM32GENERIC
#
[env:STM32F7]
platform = ststm32
framework = arduino
board = disco_f765vg
build_flags = ${common.build_flags} -DUSE_STM32GENERIC -DSTM32GENERIC -DMENU_USB_SERIAL -DMENU_SERIAL=SerialUSB
lib_deps = ${common.lib_deps}
lib_ignore = Adafruit NeoPixel, c1921b4, TMCStepper
src_filter = ${common.default_src_filter} +<src/HAL/HAL_STM32_F4_F7> -<src/HAL/HAL_STM32_F4_F7/*> +<src/HAL/HAL_STM32_F4_F7/STM32F7>
monitor_speed = 250000
#
@ -467,7 +480,7 @@ board = BigTree_SKR_Pro
extra_scripts = pre:buildroot/share/PlatformIO/scripts/generic_create_variant.py
build_flags = ${common.build_flags}
-DUSBCON -DUSBD_USE_CDC -DUSBD_VID=0x0483 -DUSB_PRODUCT=\"STM32F407ZG\"
-DTARGET_STM32F4 -DSTM32F407_5ZX -DVECT_TAB_OFFSET=0x8000
-DTARGET_STM32F4 -DSTM32F407_5ZX -DVECT_TAB_OFFSET=0x8000
lib_deps = ${common.lib_deps}
lib_ignore = Adafruit NeoPixel, c1921b4, TMC26XStepper, SailfishLCD, SailfishRGB_LED, SlowSoftI2CMaster
src_filter = ${common.default_src_filter} +<src/HAL/HAL_STM32>