SunRed/Marlin-Artillery-M600
Archived
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Cleanups for STM32F7

Browse source
This commit is contained in:
Scott Lahteine 2018-01-15 02:28:39 -06:00
parent a0246c5c96
commit 42933c804a
18 changed files with 988 additions and 1293 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
Marlin/src/HAL/HAL_STM32F1/fastio_Stm32f1.h
View file

@ -49,9 +49,9 @@
#define GET_TIMER(IO) (PIN_MAP[IO].timer_device != NULL) #define GET_TIMER(IO) (PIN_MAP[IO].timer_device != NULL)
#define OUT_WRITE(IO, v) { _SET_OUTPUT(IO); WRITE(IO, v); } #define OUT_WRITE(IO, v) { _SET_OUTPUT(IO); WRITE(IO, v); }
/* /**
* TODO: Write a macro to test if PIN is PWM or not. * TODO: Write a macro to test if PIN is PWM or not.
*/ */
#define PWM_PIN(p) true #define PWM_PIN(p) true
#endif /* _FASTIO_STM32F1_H */ #endif // _FASTIO_STM32F1_H

343
Marlin/src/HAL/HAL_STM32F7/EEPROM_Emul/eeprom_emul.cpp
View file

@ -78,8 +78,7 @@ static uint16_t EE_VerifyPageFullyErased(uint32_t Address);
* @retval - Flash error code: on write Flash error * @retval - Flash error code: on write Flash error
* - FLASH_COMPLETE: on success * - FLASH_COMPLETE: on success
*/ */
uint16_t EE_Initialise(void) uint16_t EE_Initialise(void) {
{
uint16_t PageStatus0 = 6, PageStatus1 = 6; uint16_t PageStatus0 = 6, PageStatus1 = 6;
uint16_t VarIdx = 0; uint16_t VarIdx = 0;
uint16_t EepromStatus = 0, ReadStatus = 0; uint16_t EepromStatus = 0, ReadStatus = 0;
@ -100,209 +99,141 @@ uint16_t EE_Initialise(void)
pEraseInit.VoltageRange = VOLTAGE_RANGE; pEraseInit.VoltageRange = VOLTAGE_RANGE;
/* Check for invalid header states and repair if necessary */ /* Check for invalid header states and repair if necessary */
switch (PageStatus0) switch (PageStatus0) {
{
case ERASED: case ERASED:
if (PageStatus1 == VALID_PAGE) /* Page0 erased, Page1 valid */ if (PageStatus1 == VALID_PAGE) { /* Page0 erased, Page1 valid */
{
/* Erase Page0 */ /* Erase Page0 */
if(!EE_VerifyPageFullyErased(PAGE0_BASE_ADDRESS)) if(!EE_VerifyPageFullyErased(PAGE0_BASE_ADDRESS)) {
{
FlashStatus = HAL_FLASHEx_Erase(&pEraseInit, &SectorError); FlashStatus = HAL_FLASHEx_Erase(&pEraseInit, &SectorError);
/* If erase operation was failed, a Flash error code is returned */ /* If erase operation was failed, a Flash error code is returned */
if (FlashStatus != HAL_OK) if (FlashStatus != HAL_OK) {
{
return FlashStatus; return FlashStatus;
} }
} }
} }
else if (PageStatus1 == RECEIVE_DATA) /* Page0 erased, Page1 receive */ else if (PageStatus1 == RECEIVE_DATA) { /* Page0 erased, Page1 receive */
{
/* Erase Page0 */ /* Erase Page0 */
if(!EE_VerifyPageFullyErased(PAGE0_BASE_ADDRESS)) if (!EE_VerifyPageFullyErased(PAGE0_BASE_ADDRESS)) {
{
FlashStatus = HAL_FLASHEx_Erase(&pEraseInit, &SectorError); FlashStatus = HAL_FLASHEx_Erase(&pEraseInit, &SectorError);
/* If erase operation was failed, a Flash error code is returned */ /* If erase operation was failed, a Flash error code is returned */
if (FlashStatus != HAL_OK) if (FlashStatus != HAL_OK) return FlashStatus;
{
return FlashStatus;
}
} }
/* Mark Page1 as valid */ /* Mark Page1 as valid */
FlashStatus = HAL_FLASH_Program(TYPEPROGRAM_HALFWORD, PAGE1_BASE_ADDRESS, VALID_PAGE); FlashStatus = HAL_FLASH_Program(TYPEPROGRAM_HALFWORD, PAGE1_BASE_ADDRESS, VALID_PAGE);
/* If program operation was failed, a Flash error code is returned */ /* If program operation was failed, a Flash error code is returned */
if (FlashStatus != HAL_OK) if (FlashStatus != HAL_OK) return FlashStatus;
{
return FlashStatus;
} }
} else { /* First EEPROM access (Page0&1 are erased) or invalid state -> format EEPROM */
else /* First EEPROM access (Page0&1 are erased) or invalid state -> format EEPROM */
{
/* Erase both Page0 and Page1 and set Page0 as valid page */ /* Erase both Page0 and Page1 and set Page0 as valid page */
FlashStatus = EE_Format(); FlashStatus = EE_Format();
/* If erase/program operation was failed, a Flash error code is returned */ /* If erase/program operation was failed, a Flash error code is returned */
if (FlashStatus != HAL_OK) if (FlashStatus != HAL_OK) return FlashStatus;
{
return FlashStatus;
}
} }
break; break;
case RECEIVE_DATA: case RECEIVE_DATA:
if (PageStatus1 == VALID_PAGE) /* Page0 receive, Page1 valid */ if (PageStatus1 == VALID_PAGE) { /* Page0 receive, Page1 valid */
{
/* Transfer data from Page1 to Page0 */ /* Transfer data from Page1 to Page0 */
for (VarIdx = 0; VarIdx < NB_OF_VAR; VarIdx++) for (VarIdx = 0; VarIdx < NB_OF_VAR; VarIdx++) {
{
if (( *(__IO uint16_t*)(PAGE0_BASE_ADDRESS + 6)) == VirtAddVarTab[VarIdx]) if (( *(__IO uint16_t*)(PAGE0_BASE_ADDRESS + 6)) == VirtAddVarTab[VarIdx])
{
x = VarIdx; x = VarIdx;
} if (VarIdx != x) {
if (VarIdx != x)
{
/* Read the last variables' updates */ /* Read the last variables' updates */
ReadStatus = EE_ReadVariable(VirtAddVarTab[VarIdx], &DataVar); ReadStatus = EE_ReadVariable(VirtAddVarTab[VarIdx], &DataVar);
/* In case variable corresponding to the virtual address was found */ /* In case variable corresponding to the virtual address was found */
if (ReadStatus != 0x1) if (ReadStatus != 0x1) {
{
/* Transfer the variable to the Page0 */ /* Transfer the variable to the Page0 */
EepromStatus = EE_VerifyPageFullWriteVariable(VirtAddVarTab[VarIdx], DataVar); EepromStatus = EE_VerifyPageFullWriteVariable(VirtAddVarTab[VarIdx], DataVar);
/* If program operation was failed, a Flash error code is returned */ /* If program operation was failed, a Flash error code is returned */
if (EepromStatus != HAL_OK) if (EepromStatus != HAL_OK) return EepromStatus;
{
return EepromStatus;
}
} }
} }
} }
/* Mark Page0 as valid */ /* Mark Page0 as valid */
FlashStatus = HAL_FLASH_Program(TYPEPROGRAM_HALFWORD, PAGE0_BASE_ADDRESS, VALID_PAGE); FlashStatus = HAL_FLASH_Program(TYPEPROGRAM_HALFWORD, PAGE0_BASE_ADDRESS, VALID_PAGE);
/* If program operation was failed, a Flash error code is returned */ /* If program operation was failed, a Flash error code is returned */
if (FlashStatus != HAL_OK) if (FlashStatus != HAL_OK) return FlashStatus;
{
return FlashStatus;
}
pEraseInit.Sector = PAGE1_ID; pEraseInit.Sector = PAGE1_ID;
pEraseInit.NbSectors = 1; pEraseInit.NbSectors = 1;
pEraseInit.VoltageRange = VOLTAGE_RANGE; pEraseInit.VoltageRange = VOLTAGE_RANGE;
/* Erase Page1 */ /* Erase Page1 */
if(!EE_VerifyPageFullyErased(PAGE1_BASE_ADDRESS)) if (!EE_VerifyPageFullyErased(PAGE1_BASE_ADDRESS)) {
{
FlashStatus = HAL_FLASHEx_Erase(&pEraseInit, &SectorError); FlashStatus = HAL_FLASHEx_Erase(&pEraseInit, &SectorError);
/* If erase operation was failed, a Flash error code is returned */ /* If erase operation was failed, a Flash error code is returned */
if (FlashStatus != HAL_OK) if (FlashStatus != HAL_OK) return FlashStatus;
{
return FlashStatus;
} }
} }
} else if (PageStatus1 == ERASED) { /* Page0 receive, Page1 erased */
else if (PageStatus1 == ERASED) /* Page0 receive, Page1 erased */
{
pEraseInit.Sector = PAGE1_ID; pEraseInit.Sector = PAGE1_ID;
pEraseInit.NbSectors = 1; pEraseInit.NbSectors = 1;
pEraseInit.VoltageRange = VOLTAGE_RANGE; pEraseInit.VoltageRange = VOLTAGE_RANGE;
/* Erase Page1 */ /* Erase Page1 */
if(!EE_VerifyPageFullyErased(PAGE1_BASE_ADDRESS)) if (!EE_VerifyPageFullyErased(PAGE1_BASE_ADDRESS)) {
{
FlashStatus = HAL_FLASHEx_Erase(&pEraseInit, &SectorError); FlashStatus = HAL_FLASHEx_Erase(&pEraseInit, &SectorError);
/* If erase operation was failed, a Flash error code is returned */ /* If erase operation was failed, a Flash error code is returned */
if (FlashStatus != HAL_OK) if (FlashStatus != HAL_OK) return FlashStatus;
{
return FlashStatus;
}
} }
/* Mark Page0 as valid */ /* Mark Page0 as valid */
FlashStatus = HAL_FLASH_Program(TYPEPROGRAM_HALFWORD, PAGE0_BASE_ADDRESS, VALID_PAGE); FlashStatus = HAL_FLASH_Program(TYPEPROGRAM_HALFWORD, PAGE0_BASE_ADDRESS, VALID_PAGE);
/* If program operation was failed, a Flash error code is returned */ /* If program operation was failed, a Flash error code is returned */
if (FlashStatus != HAL_OK) if (FlashStatus != HAL_OK) return FlashStatus;
{
return FlashStatus;
} }
} else { /* Invalid state -> format eeprom */
else /* Invalid state -> format eeprom */
{
/* Erase both Page0 and Page1 and set Page0 as valid page */ /* Erase both Page0 and Page1 and set Page0 as valid page */
FlashStatus = EE_Format(); FlashStatus = EE_Format();
/* If erase/program operation was failed, a Flash error code is returned */ /* If erase/program operation was failed, a Flash error code is returned */
if (FlashStatus != HAL_OK) if (FlashStatus != HAL_OK) return FlashStatus;
{
return FlashStatus;
}
} }
break; break;
case VALID_PAGE: case VALID_PAGE:
if (PageStatus1 == VALID_PAGE) /* Invalid state -> format eeprom */ if (PageStatus1 == VALID_PAGE) { /* Invalid state -> format eeprom */
{
/* Erase both Page0 and Page1 and set Page0 as valid page */ /* Erase both Page0 and Page1 and set Page0 as valid page */
FlashStatus = EE_Format(); FlashStatus = EE_Format();
/* If erase/program operation was failed, a Flash error code is returned */ /* If erase/program operation was failed, a Flash error code is returned */
if (FlashStatus != HAL_OK) if (FlashStatus != HAL_OK) return FlashStatus;
{
return FlashStatus;
} }
} else if (PageStatus1 == ERASED) { /* Page0 valid, Page1 erased */
else if (PageStatus1 == ERASED) /* Page0 valid, Page1 erased */
{
pEraseInit.Sector = PAGE1_ID; pEraseInit.Sector = PAGE1_ID;
pEraseInit.NbSectors = 1; pEraseInit.NbSectors = 1;
pEraseInit.VoltageRange = VOLTAGE_RANGE; pEraseInit.VoltageRange = VOLTAGE_RANGE;
/* Erase Page1 */ /* Erase Page1 */
if(!EE_VerifyPageFullyErased(PAGE1_BASE_ADDRESS)) if (!EE_VerifyPageFullyErased(PAGE1_BASE_ADDRESS)) {
{
FlashStatus = HAL_FLASHEx_Erase(&pEraseInit, &SectorError); FlashStatus = HAL_FLASHEx_Erase(&pEraseInit, &SectorError);
/* If erase operation was failed, a Flash error code is returned */ /* If erase operation was failed, a Flash error code is returned */
if (FlashStatus != HAL_OK) if (FlashStatus != HAL_OK) return FlashStatus;
{
return FlashStatus;
} }
} }
} else { /* Page0 valid, Page1 receive */
else /* Page0 valid, Page1 receive */
{
/* Transfer data from Page0 to Page1 */ /* Transfer data from Page0 to Page1 */
for (VarIdx = 0; VarIdx < NB_OF_VAR; VarIdx++) for (VarIdx = 0; VarIdx < NB_OF_VAR; VarIdx++) {
{
if ((*(__IO uint16_t*)(PAGE1_BASE_ADDRESS + 6)) == VirtAddVarTab[VarIdx]) if ((*(__IO uint16_t*)(PAGE1_BASE_ADDRESS + 6)) == VirtAddVarTab[VarIdx])
{
x = VarIdx; x = VarIdx;
}
if (VarIdx != x) if (VarIdx != x) {
{
/* Read the last variables' updates */ /* Read the last variables' updates */
ReadStatus = EE_ReadVariable(VirtAddVarTab[VarIdx], &DataVar); ReadStatus = EE_ReadVariable(VirtAddVarTab[VarIdx], &DataVar);
/* In case variable corresponding to the virtual address was found */ /* In case variable corresponding to the virtual address was found */
if (ReadStatus != 0x1) if (ReadStatus != 0x1) {
{
/* Transfer the variable to the Page1 */ /* Transfer the variable to the Page1 */
EepromStatus = EE_VerifyPageFullWriteVariable(VirtAddVarTab[VarIdx], DataVar); EepromStatus = EE_VerifyPageFullWriteVariable(VirtAddVarTab[VarIdx], DataVar);
/* If program operation was failed, a Flash error code is returned */ /* If program operation was failed, a Flash error code is returned */
if (EepromStatus != HAL_OK) if (EepromStatus != HAL_OK) return EepromStatus;
{
return EepromStatus;
}
} }
} }
} }
/* Mark Page1 as valid */ /* Mark Page1 as valid */
FlashStatus = HAL_FLASH_Program(TYPEPROGRAM_HALFWORD, PAGE1_BASE_ADDRESS, VALID_PAGE); FlashStatus = HAL_FLASH_Program(TYPEPROGRAM_HALFWORD, PAGE1_BASE_ADDRESS, VALID_PAGE);
/* If program operation was failed, a Flash error code is returned */ /* If program operation was failed, a Flash error code is returned */
if (FlashStatus != HAL_OK) if (FlashStatus != HAL_OK) return FlashStatus;
{
return FlashStatus;
}
pEraseInit.Sector = PAGE0_ID; pEraseInit.Sector = PAGE0_ID;
pEraseInit.NbSectors = 1; pEraseInit.NbSectors = 1;
pEraseInit.VoltageRange = VOLTAGE_RANGE; pEraseInit.VoltageRange = VOLTAGE_RANGE;
/* Erase Page0 */ /* Erase Page0 */
if(!EE_VerifyPageFullyErased(PAGE0_BASE_ADDRESS)) if (!EE_VerifyPageFullyErased(PAGE0_BASE_ADDRESS)) {
{
FlashStatus = HAL_FLASHEx_Erase(&pEraseInit, &SectorError); FlashStatus = HAL_FLASHEx_Erase(&pEraseInit, &SectorError);
/* If erase operation was failed, a Flash error code is returned */ /* If erase operation was failed, a Flash error code is returned */
if (FlashStatus != HAL_OK) if (FlashStatus != HAL_OK) return FlashStatus;
{
return FlashStatus;
}
} }
} }
break; break;
@ -311,10 +242,7 @@ uint16_t EE_Initialise(void)
/* Erase both Page0 and Page1 and set Page0 as valid page */ /* Erase both Page0 and Page1 and set Page0 as valid page */
FlashStatus = EE_Format(); FlashStatus = EE_Format();
/* If erase/program operation was failed, a Flash error code is returned */ /* If erase/program operation was failed, a Flash error code is returned */
if (FlashStatus != HAL_OK) if (FlashStatus != HAL_OK) return FlashStatus;
{
return FlashStatus;
}
break; break;
} }
@ -331,30 +259,22 @@ uint16_t EE_Initialise(void)
* - 0: if Page not erased * - 0: if Page not erased
* - 1: if Page erased * - 1: if Page erased
*/ */
uint16_t EE_VerifyPageFullyErased(uint32_t Address) uint16_t EE_VerifyPageFullyErased(uint32_t Address) {
{
uint32_t ReadStatus = 1; uint32_t ReadStatus = 1;
uint16_t AddressValue = 0x5555; uint16_t AddressValue = 0x5555;
/* Check each active page address starting from end */ /* Check each active page address starting from end */
while (Address <= PAGE0_END_ADDRESS) while (Address <= PAGE0_END_ADDRESS) {
{
/* Get the current location content to be compared with virtual address */ /* Get the current location content to be compared with virtual address */
AddressValue = (*(__IO uint16_t*)Address); AddressValue = (*(__IO uint16_t*)Address);
/* Compare the read address with the virtual address */ /* Compare the read address with the virtual address */
if (AddressValue != ERASED) if (AddressValue != ERASED) {
{
/* In case variable value is read, reset ReadStatus flag */ /* In case variable value is read, reset ReadStatus flag */
ReadStatus = 0; ReadStatus = 0;
break; break;
} }
/* Next address location */ /* Next address location */
Address = Address + 4; Address += 4;
} }
/* Return ReadStatus value: (0: Page not erased, 1: Sector erased) */ /* Return ReadStatus value: (0: Page not erased, 1: Sector erased) */
return ReadStatus; return ReadStatus;
} }
@ -369,8 +289,7 @@ uint16_t EE_VerifyPageFullyErased(uint32_t Address)
* - 1: if the variable was not found * - 1: if the variable was not found
* - NO_VALID_PAGE: if no valid page was found. * - NO_VALID_PAGE: if no valid page was found.
*/ */
uint16_t EE_ReadVariable(uint16_t VirtAddress, uint16_t* Data) uint16_t EE_ReadVariable(uint16_t VirtAddress, uint16_t* Data) {
{
uint16_t ValidPage = PAGE0; uint16_t ValidPage = PAGE0;
uint16_t AddressValue = 0x5555, ReadStatus = 1; uint16_t AddressValue = 0x5555, ReadStatus = 1;
uint32_t Address = EEPROM_START_ADDRESS, PageStartAddress = EEPROM_START_ADDRESS; uint32_t Address = EEPROM_START_ADDRESS, PageStartAddress = EEPROM_START_ADDRESS;
@ -379,10 +298,7 @@ uint16_t EE_ReadVariable(uint16_t VirtAddress, uint16_t* Data)
ValidPage = EE_FindValidPage(READ_FROM_VALID_PAGE); ValidPage = EE_FindValidPage(READ_FROM_VALID_PAGE);
/* Check if there is no valid page */ /* Check if there is no valid page */
if (ValidPage == NO_VALID_PAGE) if (ValidPage == NO_VALID_PAGE) return NO_VALID_PAGE;
{
return NO_VALID_PAGE;
}
/* Get the valid Page start Address */ /* Get the valid Page start Address */
PageStartAddress = (uint32_t)(EEPROM_START_ADDRESS + (uint32_t)(ValidPage * PAGE_SIZE)); PageStartAddress = (uint32_t)(EEPROM_START_ADDRESS + (uint32_t)(ValidPage * PAGE_SIZE));
@ -391,29 +307,21 @@ uint16_t EE_ReadVariable(uint16_t VirtAddress, uint16_t* Data)
Address = (uint32_t)((EEPROM_START_ADDRESS - 2) + (uint32_t)((1 + ValidPage) * PAGE_SIZE)); Address = (uint32_t)((EEPROM_START_ADDRESS - 2) + (uint32_t)((1 + ValidPage) * PAGE_SIZE));
/* Check each active page address starting from end */ /* Check each active page address starting from end */
while (Address > (PageStartAddress + 2)) while (Address > (PageStartAddress + 2)) {
{
/* Get the current location content to be compared with virtual address */ /* Get the current location content to be compared with virtual address */
AddressValue = (*(__IO uint16_t*)Address); AddressValue = (*(__IO uint16_t*)Address);
/* Compare the read address with the virtual address */ /* Compare the read address with the virtual address */
if (AddressValue == VirtAddress) if (AddressValue == VirtAddress) {
{
/* Get content of Address-2 which is variable value */ /* Get content of Address-2 which is variable value */
*Data = (*(__IO uint16_t*)(Address - 2)); *Data = (*(__IO uint16_t*)(Address - 2));
/* In case variable value is read, reset ReadStatus flag */ /* In case variable value is read, reset ReadStatus flag */
ReadStatus = 0; ReadStatus = 0;
break; break;
} }
else else /* Next address location */
{ Address -= 4;
/* Next address location */
Address = Address - 4;
} }
}
/* Return ReadStatus value: (0: variable exist, 1: variable doesn't exist) */ /* Return ReadStatus value: (0: variable exist, 1: variable doesn't exist) */
return ReadStatus; return ReadStatus;
} }
@ -428,19 +336,13 @@ uint16_t EE_ReadVariable(uint16_t VirtAddress, uint16_t* Data)
* - NO_VALID_PAGE: if no valid page was found * - NO_VALID_PAGE: if no valid page was found
* - Flash error code: on write Flash error * - Flash error code: on write Flash error
*/ */
uint16_t EE_WriteVariable(uint16_t VirtAddress, uint16_t Data) uint16_t EE_WriteVariable(uint16_t VirtAddress, uint16_t Data) {
{
uint16_t Status = 0;
/* Write the variable virtual address and value in the EEPROM */ /* Write the variable virtual address and value in the EEPROM */
Status = EE_VerifyPageFullWriteVariable(VirtAddress, Data); uint16_t Status = EE_VerifyPageFullWriteVariable(VirtAddress, Data);
/* In case the EEPROM active page is full */ /* In case the EEPROM active page is full */
if (Status == PAGE_FULL) if (Status == PAGE_FULL) /* Perform Page transfer */
{
/* Perform Page transfer */
Status = EE_PageTransfer(VirtAddress, Data); Status = EE_PageTransfer(VirtAddress, Data);
}
/* Return last operation status */ /* Return last operation status */
return Status; return Status;
@ -452,8 +354,7 @@ uint16_t EE_WriteVariable(uint16_t VirtAddress, uint16_t Data)
* @retval Status of the last operation (Flash write or erase) done during * @retval Status of the last operation (Flash write or erase) done during
* EEPROM formating * EEPROM formating
*/ */
static HAL_StatusTypeDef EE_Format(void) static HAL_StatusTypeDef EE_Format(void) {
{
HAL_StatusTypeDef FlashStatus = HAL_OK; HAL_StatusTypeDef FlashStatus = HAL_OK;
uint32_t SectorError = 0; uint32_t SectorError = 0;
FLASH_EraseInitTypeDef pEraseInit; FLASH_EraseInitTypeDef pEraseInit;
@ -463,33 +364,22 @@ static HAL_StatusTypeDef EE_Format(void)
pEraseInit.NbSectors = 1; pEraseInit.NbSectors = 1;
pEraseInit.VoltageRange = VOLTAGE_RANGE; pEraseInit.VoltageRange = VOLTAGE_RANGE;
/* Erase Page0 */ /* Erase Page0 */
if(!EE_VerifyPageFullyErased(PAGE0_BASE_ADDRESS)) if (!EE_VerifyPageFullyErased(PAGE0_BASE_ADDRESS)) {
{
FlashStatus = HAL_FLASHEx_Erase(&pEraseInit, &SectorError); FlashStatus = HAL_FLASHEx_Erase(&pEraseInit, &SectorError);
/* If erase operation was failed, a Flash error code is returned */ /* If erase operation was failed, a Flash error code is returned */
if (FlashStatus != HAL_OK) if (FlashStatus != HAL_OK) return FlashStatus;
{
return FlashStatus;
}
} }
/* Set Page0 as valid page: Write VALID_PAGE at Page0 base address */ /* Set Page0 as valid page: Write VALID_PAGE at Page0 base address */
FlashStatus = HAL_FLASH_Program(TYPEPROGRAM_HALFWORD, PAGE0_BASE_ADDRESS, VALID_PAGE); FlashStatus = HAL_FLASH_Program(TYPEPROGRAM_HALFWORD, PAGE0_BASE_ADDRESS, VALID_PAGE);
/* If program operation was failed, a Flash error code is returned */ /* If program operation was failed, a Flash error code is returned */
if (FlashStatus != HAL_OK) if (FlashStatus != HAL_OK) return FlashStatus;
{
return FlashStatus;
}
pEraseInit.Sector = PAGE1_ID; pEraseInit.Sector = PAGE1_ID;
/* Erase Page1 */ /* Erase Page1 */
if(!EE_VerifyPageFullyErased(PAGE1_BASE_ADDRESS)) if (!EE_VerifyPageFullyErased(PAGE1_BASE_ADDRESS)) {
{
FlashStatus = HAL_FLASHEx_Erase(&pEraseInit, &SectorError); FlashStatus = HAL_FLASHEx_Erase(&pEraseInit, &SectorError);
/* If erase operation was failed, a Flash error code is returned */ /* If erase operation was failed, a Flash error code is returned */
if (FlashStatus != HAL_OK) if (FlashStatus != HAL_OK) return FlashStatus;
{
return FlashStatus;
}
} }
return HAL_OK; return HAL_OK;
@ -504,8 +394,7 @@ static HAL_StatusTypeDef EE_Format(void)
* @retval Valid page number (PAGE or PAGE1) or NO_VALID_PAGE in case * @retval Valid page number (PAGE or PAGE1) or NO_VALID_PAGE in case
* of no valid page was found * of no valid page was found
*/ */
static uint16_t EE_FindValidPage(uint8_t Operation) static uint16_t EE_FindValidPage(uint8_t Operation) {
{
uint16_t PageStatus0 = 6, PageStatus1 = 6; uint16_t PageStatus0 = 6, PageStatus1 = 6;
/* Get Page0 actual status */ /* Get Page0 actual status */
@ -515,51 +404,28 @@ static uint16_t EE_FindValidPage(uint8_t Operation)
PageStatus1 = (*(__IO uint16_t*)PAGE1_BASE_ADDRESS); PageStatus1 = (*(__IO uint16_t*)PAGE1_BASE_ADDRESS);
/* Write or read operation */ /* Write or read operation */
switch (Operation) switch (Operation) {
{
case WRITE_IN_VALID_PAGE: /* ---- Write operation ---- */ case WRITE_IN_VALID_PAGE: /* ---- Write operation ---- */
if (PageStatus1 == VALID_PAGE) if (PageStatus1 == VALID_PAGE) {
{
/* Page0 receiving data */ /* Page0 receiving data */
if (PageStatus0 == RECEIVE_DATA) if (PageStatus0 == RECEIVE_DATA) return PAGE0; /* Page0 valid */
{ else return PAGE1; /* Page1 valid */
return PAGE0; /* Page0 valid */
} }
else else if (PageStatus0 == VALID_PAGE) {
{
return PAGE1; /* Page1 valid */
}
}
else if (PageStatus0 == VALID_PAGE)
{
/* Page1 receiving data */ /* Page1 receiving data */
if (PageStatus1 == RECEIVE_DATA) if (PageStatus1 == RECEIVE_DATA) return PAGE1; /* Page1 valid */
{ else return PAGE0; /* Page0 valid */
return PAGE1; /* Page1 valid */
} }
else else
{
return PAGE0; /* Page0 valid */
}
}
else
{
return NO_VALID_PAGE; /* No valid Page */ return NO_VALID_PAGE; /* No valid Page */
}
case READ_FROM_VALID_PAGE: /* ---- Read operation ---- */ case READ_FROM_VALID_PAGE: /* ---- Read operation ---- */
if (PageStatus0 == VALID_PAGE) if (PageStatus0 == VALID_PAGE)
{
return PAGE0; /* Page0 valid */ return PAGE0; /* Page0 valid */
}
else if (PageStatus1 == VALID_PAGE) else if (PageStatus1 == VALID_PAGE)
{
return PAGE1; /* Page1 valid */ return PAGE1; /* Page1 valid */
}
else else
{ return NO_VALID_PAGE; /* No valid Page */
return NO_VALID_PAGE ; /* No valid Page */
}
default: default:
return PAGE0; /* Page0 valid */ return PAGE0; /* Page0 valid */
@ -576,8 +442,7 @@ static uint16_t EE_FindValidPage(uint8_t Operation)
* - NO_VALID_PAGE: if no valid page was found * - NO_VALID_PAGE: if no valid page was found
* - Flash error code: on write Flash error * - Flash error code: on write Flash error
*/ */
static uint16_t EE_VerifyPageFullWriteVariable(uint16_t VirtAddress, uint16_t Data) static uint16_t EE_VerifyPageFullWriteVariable(uint16_t VirtAddress, uint16_t Data) {
{
HAL_StatusTypeDef FlashStatus = HAL_OK; HAL_StatusTypeDef FlashStatus = HAL_OK;
uint16_t ValidPage = PAGE0; uint16_t ValidPage = PAGE0;
uint32_t Address = EEPROM_START_ADDRESS, PageEndAddress = EEPROM_START_ADDRESS+PAGE_SIZE; uint32_t Address = EEPROM_START_ADDRESS, PageEndAddress = EEPROM_START_ADDRESS+PAGE_SIZE;
@ -586,10 +451,7 @@ static uint16_t EE_VerifyPageFullWriteVariable(uint16_t VirtAddress, uint16_t Da
ValidPage = EE_FindValidPage(WRITE_IN_VALID_PAGE); ValidPage = EE_FindValidPage(WRITE_IN_VALID_PAGE);
/* Check if there is no valid page */ /* Check if there is no valid page */
if (ValidPage == NO_VALID_PAGE) if (ValidPage == NO_VALID_PAGE) return NO_VALID_PAGE;
{
return NO_VALID_PAGE;
}
/* Get the valid Page start Address */ /* Get the valid Page start Address */
Address = (uint32_t)(EEPROM_START_ADDRESS + (uint32_t)(ValidPage * PAGE_SIZE)); Address = (uint32_t)(EEPROM_START_ADDRESS + (uint32_t)(ValidPage * PAGE_SIZE));
@ -598,28 +460,20 @@ static uint16_t EE_VerifyPageFullWriteVariable(uint16_t VirtAddress, uint16_t Da
PageEndAddress = (uint32_t)((EEPROM_START_ADDRESS - 1) + (uint32_t)((ValidPage + 1) * PAGE_SIZE)); PageEndAddress = (uint32_t)((EEPROM_START_ADDRESS - 1) + (uint32_t)((ValidPage + 1) * PAGE_SIZE));
/* Check each active page address starting from begining */ /* Check each active page address starting from begining */
while (Address < PageEndAddress) while (Address < PageEndAddress) {
{
/* Verify if Address and Address+2 contents are 0xFFFFFFFF */ /* Verify if Address and Address+2 contents are 0xFFFFFFFF */
if ((*(__IO uint32_t*)Address) == 0xFFFFFFFF) if ((*(__IO uint32_t*)Address) == 0xFFFFFFFF) {
{
/* Set variable data */ /* Set variable data */
FlashStatus = HAL_FLASH_Program(TYPEPROGRAM_HALFWORD, Address, Data); FlashStatus = HAL_FLASH_Program(TYPEPROGRAM_HALFWORD, Address, Data);
/* If program operation was failed, a Flash error code is returned */ /* If program operation was failed, a Flash error code is returned */
if (FlashStatus != HAL_OK) if (FlashStatus != HAL_OK) return FlashStatus;
{
return FlashStatus;
}
/* Set variable virtual address */ /* Set variable virtual address */
FlashStatus = HAL_FLASH_Program(TYPEPROGRAM_HALFWORD, Address + 2, VirtAddress); FlashStatus = HAL_FLASH_Program(TYPEPROGRAM_HALFWORD, Address + 2, VirtAddress);
/* Return program operation status */ /* Return program operation status */
return FlashStatus; return FlashStatus;
} }
else else /* Next address location */
{ Address += 4;
/* Next address location */
Address = Address + 4;
}
} }
/* Return PAGE_FULL in case the valid page is full */ /* Return PAGE_FULL in case the valid page is full */
@ -637,8 +491,7 @@ static uint16_t EE_VerifyPageFullWriteVariable(uint16_t VirtAddress, uint16_t Da
* - NO_VALID_PAGE: if no valid page was found * - NO_VALID_PAGE: if no valid page was found
* - Flash error code: on write Flash error * - Flash error code: on write Flash error
*/ */
static uint16_t EE_PageTransfer(uint16_t VirtAddress, uint16_t Data) static uint16_t EE_PageTransfer(uint16_t VirtAddress, uint16_t Data) {
{
HAL_StatusTypeDef FlashStatus = HAL_OK; HAL_StatusTypeDef FlashStatus = HAL_OK;
uint32_t NewPageAddress = EEPROM_START_ADDRESS; uint32_t NewPageAddress = EEPROM_START_ADDRESS;
uint16_t OldPageId=0; uint16_t OldPageId=0;
@ -650,60 +503,42 @@ static uint16_t EE_PageTransfer(uint16_t VirtAddress, uint16_t Data)
/* Get active Page for read operation */ /* Get active Page for read operation */
ValidPage = EE_FindValidPage(READ_FROM_VALID_PAGE); ValidPage = EE_FindValidPage(READ_FROM_VALID_PAGE);
if (ValidPage == PAGE1) /* Page1 valid */ if (ValidPage == PAGE1) { /* Page1 valid */
{
/* New page address where variable will be moved to */ /* New page address where variable will be moved to */
NewPageAddress = PAGE0_BASE_ADDRESS; NewPageAddress = PAGE0_BASE_ADDRESS;
/* Old page ID where variable will be taken from */ /* Old page ID where variable will be taken from */
OldPageId = PAGE1_ID; OldPageId = PAGE1_ID;
} }
else if (ValidPage == PAGE0) /* Page0 valid */ else if (ValidPage == PAGE0) { /* Page0 valid */
{
/* New page address where variable will be moved to */ /* New page address where variable will be moved to */
NewPageAddress = PAGE1_BASE_ADDRESS; NewPageAddress = PAGE1_BASE_ADDRESS;
/* Old page ID where variable will be taken from */ /* Old page ID where variable will be taken from */
OldPageId = PAGE0_ID; OldPageId = PAGE0_ID;
} }
else else
{
return NO_VALID_PAGE; /* No valid Page */ return NO_VALID_PAGE; /* No valid Page */
}
/* Set the new Page status to RECEIVE_DATA status */ /* Set the new Page status to RECEIVE_DATA status */
FlashStatus = HAL_FLASH_Program(TYPEPROGRAM_HALFWORD, NewPageAddress, RECEIVE_DATA); FlashStatus = HAL_FLASH_Program(TYPEPROGRAM_HALFWORD, NewPageAddress, RECEIVE_DATA);
/* If program operation was failed, a Flash error code is returned */ /* If program operation was failed, a Flash error code is returned */
if (FlashStatus != HAL_OK) if (FlashStatus != HAL_OK) return FlashStatus;
{
return FlashStatus;
}
/* Write the variable passed as parameter in the new active page */ /* Write the variable passed as parameter in the new active page */
EepromStatus = EE_VerifyPageFullWriteVariable(VirtAddress, Data); EepromStatus = EE_VerifyPageFullWriteVariable(VirtAddress, Data);
/* If program operation was failed, a Flash error code is returned */ /* If program operation was failed, a Flash error code is returned */
if (EepromStatus != HAL_OK) if (EepromStatus != HAL_OK) return EepromStatus;
{
return EepromStatus;
}
/* Transfer process: transfer variables from old to the new active page */ /* Transfer process: transfer variables from old to the new active page */
for (VarIdx = 0; VarIdx < NB_OF_VAR; VarIdx++) for (VarIdx = 0; VarIdx < NB_OF_VAR; VarIdx++) {
{ if (VirtAddVarTab[VarIdx] != VirtAddress) { /* Check each variable except the one passed as parameter */
if (VirtAddVarTab[VarIdx] != VirtAddress) /* Check each variable except the one passed as parameter */
{
/* Read the other last variable updates */ /* Read the other last variable updates */
ReadStatus = EE_ReadVariable(VirtAddVarTab[VarIdx], &DataVar); ReadStatus = EE_ReadVariable(VirtAddVarTab[VarIdx], &DataVar);
/* In case variable corresponding to the virtual address was found */ /* In case variable corresponding to the virtual address was found */
if (ReadStatus != 0x1) if (ReadStatus != 0x1) {
{
/* Transfer the variable to the new active page */ /* Transfer the variable to the new active page */
EepromStatus = EE_VerifyPageFullWriteVariable(VirtAddVarTab[VarIdx], DataVar); EepromStatus = EE_VerifyPageFullWriteVariable(VirtAddVarTab[VarIdx], DataVar);
/* If program operation was failed, a Flash error code is returned */ /* If program operation was failed, a Flash error code is returned */
if (EepromStatus != HAL_OK) if (EepromStatus != HAL_OK) return EepromStatus;
{
return EepromStatus;
}
} }
} }
} }
@ -716,18 +551,12 @@ static uint16_t EE_PageTransfer(uint16_t VirtAddress, uint16_t Data)
/* Erase the old Page: Set old Page status to ERASED status */ /* Erase the old Page: Set old Page status to ERASED status */
FlashStatus = HAL_FLASHEx_Erase(&pEraseInit, &SectorError); FlashStatus = HAL_FLASHEx_Erase(&pEraseInit, &SectorError);
/* If erase operation was failed, a Flash error code is returned */ /* If erase operation was failed, a Flash error code is returned */
if (FlashStatus != HAL_OK) if (FlashStatus != HAL_OK) return FlashStatus;
{
return FlashStatus;
}
/* Set new Page status to VALID_PAGE status */ /* Set new Page status to VALID_PAGE status */
FlashStatus = HAL_FLASH_Program(TYPEPROGRAM_HALFWORD, NewPageAddress, VALID_PAGE); FlashStatus = HAL_FLASH_Program(TYPEPROGRAM_HALFWORD, NewPageAddress, VALID_PAGE);
/* If program operation was failed, a Flash error code is returned */ /* If program operation was failed, a Flash error code is returned */
if (FlashStatus != HAL_OK) if (FlashStatus != HAL_OK) return FlashStatus;
{
return FlashStatus;
}
/* Return last operation flash status */ /* Return last operation flash status */
return FlashStatus; return FlashStatus;

11
Marlin/src/HAL/HAL_STM32F7/HAL_STM32F7.cpp
View file

@ -81,18 +81,17 @@ void sei(void) { interrupts(); }
void HAL_clear_reset_source(void) { __HAL_RCC_CLEAR_RESET_FLAGS(); } void HAL_clear_reset_source(void) { __HAL_RCC_CLEAR_RESET_FLAGS(); }
uint8_t HAL_get_reset_source (void) { uint8_t HAL_get_reset_source (void) {
if(__HAL_RCC_GET_FLAG(RCC_FLAG_IWDGRST) != RESET) if (__HAL_RCC_GET_FLAG(RCC_FLAG_IWDGRST) != RESET)
return RST_WATCHDOG; return RST_WATCHDOG;
if(__HAL_RCC_GET_FLAG(RCC_FLAG_SFTRST) != RESET) if (__HAL_RCC_GET_FLAG(RCC_FLAG_SFTRST) != RESET)
return RST_SOFTWARE; return RST_SOFTWARE;
if(__HAL_RCC_GET_FLAG(RCC_FLAG_PINRST) != RESET) if (__HAL_RCC_GET_FLAG(RCC_FLAG_PINRST) != RESET)
return RST_EXTERNAL; return RST_EXTERNAL;
if(__HAL_RCC_GET_FLAG(RCC_FLAG_PORRST) != RESET) if (__HAL_RCC_GET_FLAG(RCC_FLAG_PORRST) != RESET)
return RST_POWER_ON; return RST_POWER_ON;
return 0; return 0;
} }
@ -102,8 +101,6 @@ extern "C" {
extern unsigned int _ebss; // end of bss section extern unsigned int _ebss; // end of bss section
} }
// return free memory between end of heap (or end bss) and whatever is current // return free memory between end of heap (or end bss) and whatever is current
/* /*

13
Marlin/src/HAL/HAL_STM32F7/HAL_spi_STM32F7.cpp
View file

@ -85,17 +85,14 @@ void spiBegin(void) {
SET_OUTPUT(SS_PIN); SET_OUTPUT(SS_PIN);
WRITE(SS_PIN, HIGH); WRITE(SS_PIN, HIGH);
} }
/** Configure SPI for specified SPI speed */ /** Configure SPI for specified SPI speed */
void spiInit(uint8_t spiRate) { void spiInit(uint8_t spiRate) {
// Use datarates Marlin uses // Use datarates Marlin uses
uint32_t clock; uint32_t clock;
switch (spiRate) { switch (spiRate) {
case SPI_FULL_SPEED: clock = 20000000; break; //13.9mhz=20000000 6.75mhz=10000000 3.38mhz=5000000 .833mhz=1000000 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_HALF_SPEED: clock = 5000000; break;
case SPI_QUARTER_SPEED: clock = 2500000; break; case SPI_QUARTER_SPEED: clock = 2500000; break;
case SPI_EIGHTH_SPEED: clock = 1250000; break; case SPI_EIGHTH_SPEED: clock = 1250000; break;
@ -108,8 +105,6 @@ void spiInit(uint8_t spiRate) {
SPI.begin(); SPI.begin();
} }
/** /**
* @brief Receives a single byte from the SPI port. * @brief Receives a single byte from the SPI port.
* *
@ -133,8 +128,6 @@ uint8_t spiRec(void) {
* *
* @details Uses DMA * @details Uses DMA
*/ */
void spiRead(uint8_t* buf, uint16_t nbyte) { void spiRead(uint8_t* buf, uint16_t nbyte) {
SPI.beginTransaction(spiConfig); SPI.beginTransaction(spiConfig);
SPI.dmaTransfer(0, const_cast<uint8_t*>(buf), nbyte); SPI.dmaTransfer(0, const_cast<uint8_t*>(buf), nbyte);
@ -162,8 +155,6 @@ void spiSend(uint8_t b) {
* *
* @details Use DMA * @details Use DMA
*/ */
void spiSendBlock(uint8_t token, const uint8_t* buf) { void spiSendBlock(uint8_t token, const uint8_t* buf) {
SPI.beginTransaction(spiConfig); SPI.beginTransaction(spiConfig);
SPI.transfer(token); SPI.transfer(token);
@ -171,8 +162,6 @@ void spiSendBlock(uint8_t token, const uint8_t* buf) {
SPI.endTransaction(); SPI.endTransaction();
} }
#endif // SOFTWARE_SPI #endif // SOFTWARE_SPI
#endif // STM32F7 #endif // STM32F7

34
Marlin/src/HAL/HAL_STM32F7/HAL_timers_STM32F7.cpp
View file

@ -20,8 +20,8 @@
* *
*/ */
#ifdef STM32F7 #ifdef STM32F7
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// Includes // Includes
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@ -71,9 +71,9 @@ tTimerConfig timerConfig[NUM_HARDWARE_TIMERS];
bool timers_initialised[NUM_HARDWARE_TIMERS] = {false}; bool timers_initialised[NUM_HARDWARE_TIMERS] = {false};
void HAL_timer_start(uint8_t timer_num, uint32_t frequency) { void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
if(!timers_initialised[timer_num]) { if (!timers_initialised[timer_num]) {
switch (timer_num) { switch (timer_num) {
case STEP_TIMER_NUM: case STEP_TIMER_NUM:
//STEPPER TIMER TIM5 //use a 32bit timer //STEPPER TIMER TIM5 //use a 32bit timer
@ -103,52 +103,48 @@ void HAL_timer_start(uint8_t timer_num, uint32_t frequency) {
timers_initialised[timer_num] = true; timers_initialised[timer_num] = true;
} }
timerConfig[timer_num].timerdef.Init.Period = ((HAL_TIMER_RATE / timerConfig[timer_num].timerdef.Init.Prescaler) / (frequency)) - 1; timerConfig[timer_num].timerdef.Init.Period = (((HAL_TIMER_RATE) / timerConfig[timer_num].timerdef.Init.Prescaler) / frequency) - 1;
if(HAL_TIM_Base_Init(&timerConfig[timer_num].timerdef) == HAL_OK ){ if (HAL_TIM_Base_Init(&timerConfig[timer_num].timerdef) == HAL_OK)
HAL_TIM_Base_Start_IT(&timerConfig[timer_num].timerdef); HAL_TIM_Base_Start_IT(&timerConfig[timer_num].timerdef);
}
} }
//forward the interrupt //forward the interrupt
extern "C" void TIM5_IRQHandler() extern "C" void TIM5_IRQHandler() {
{
((void(*)(void))timerConfig[0].callback)(); ((void(*)(void))timerConfig[0].callback)();
} }
extern "C" void TIM7_IRQHandler() extern "C" void TIM7_IRQHandler() {
{
((void(*)(void))timerConfig[1].callback)(); ((void(*)(void))timerConfig[1].callback)();
} }
void HAL_timer_set_count (uint8_t timer_num, uint32_t count) { void HAL_timer_set_count(const uint8_t timer_num, const uint32_t count) {
__HAL_TIM_SetAutoreload(&timerConfig[timer_num].timerdef, count); __HAL_TIM_SetAutoreload(&timerConfig[timer_num].timerdef, count);
} }
void HAL_timer_set_current_count (uint8_t timer_num, uint32_t count) { void HAL_timer_set_current_count(const uint8_t timer_num, const uint32_t count) {
__HAL_TIM_SetAutoreload(&timerConfig[timer_num].timerdef, count); __HAL_TIM_SetAutoreload(&timerConfig[timer_num].timerdef, count);
} }
void HAL_timer_enable_interrupt (uint8_t timer_num) { void HAL_timer_enable_interrupt(const uint8_t timer_num) {
HAL_NVIC_EnableIRQ(timerConfig[timer_num].IRQ_Id); HAL_NVIC_EnableIRQ(timerConfig[timer_num].IRQ_Id);
} }
void HAL_timer_disable_interrupt (uint8_t timer_num) { void HAL_timer_disable_interrupt(const uint8_t timer_num) {
HAL_NVIC_DisableIRQ(timerConfig[timer_num].IRQ_Id); HAL_NVIC_DisableIRQ(timerConfig[timer_num].IRQ_Id);
} }
hal_timer_t HAL_timer_get_count (uint8_t timer_num) { hal_timer_t HAL_timer_get_count(const uint8_t timer_num) {
return __HAL_TIM_GetAutoreload(&timerConfig[timer_num].timerdef); return __HAL_TIM_GetAutoreload(&timerConfig[timer_num].timerdef);
} }
uint32_t HAL_timer_get_current_count(uint8_t timer_num) { uint32_t HAL_timer_get_current_count(const uint8_t timer_num) {
return __HAL_TIM_GetCounter(&timerConfig[timer_num].timerdef); return __HAL_TIM_GetCounter(&timerConfig[timer_num].timerdef);
} }
void HAL_timer_isr_prologue (uint8_t timer_num) { void HAL_timer_isr_prologue(const uint8_t timer_num) {
if (__HAL_TIM_GET_FLAG(&timerConfig[timer_num].timerdef, TIM_FLAG_UPDATE) == SET) { if (__HAL_TIM_GET_FLAG(&timerConfig[timer_num].timerdef, TIM_FLAG_UPDATE) == SET) {
__HAL_TIM_CLEAR_FLAG(&timerConfig[timer_num].timerdef, TIM_FLAG_UPDATE); __HAL_TIM_CLEAR_FLAG(&timerConfig[timer_num].timerdef, TIM_FLAG_UPDATE);
} }
} }
#endif #endif // STM32F7

35
Marlin/src/HAL/HAL_STM32F7/HAL_timers_STM32F7.h
View file

@ -20,8 +20,6 @@
* *
*/ */
#ifndef _HAL_TIMERS_STM32F7_H #ifndef _HAL_TIMERS_STM32F7_H
#define _HAL_TIMERS_STM32F7_H #define _HAL_TIMERS_STM32F7_H
@ -35,16 +33,15 @@
// Defines // Defines
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
#define FORCE_INLINE __attribute__((always_inline)) inline #define FORCE_INLINE __attribute__((always_inline)) inline
#define hal_timer_t uint32_t //hal_timer_t uint32_t //TODO: One is 16-bit, one 32-bit - does this need to be checked? #define hal_timer_t uint32_t // TODO: One is 16-bit, one 32-bit - does this need to be checked?
#define HAL_TIMER_TYPE_MAX 0xFFFF #define HAL_TIMER_TYPE_MAX 0xFFFF
#define STEP_TIMER_NUM 0 // index of timer to use for stepper #define STEP_TIMER_NUM 0 // index of timer to use for stepper
#define TEMP_TIMER_NUM 1 // index of timer to use for temperature #define TEMP_TIMER_NUM 1 // index of timer to use for temperature
#define HAL_TIMER_RATE (HAL_RCC_GetSysClockFreq()/2) // frequency of timer peripherals #define HAL_TIMER_RATE (HAL_RCC_GetSysClockFreq() / 2) // frequency of timer peripherals
#define STEPPER_TIMER_PRESCALE 54 // was 40,prescaler for setting stepper timer, 2Mhz #define STEPPER_TIMER_PRESCALE 54 // was 40,prescaler for setting stepper timer, 2Mhz
#define HAL_STEPPER_TIMER_RATE (HAL_TIMER_RATE / STEPPER_TIMER_PRESCALE) // frequency of stepper timer (HAL_TIMER_RATE / STEPPER_TIMER_PRESCALE) #define HAL_STEPPER_TIMER_RATE (HAL_TIMER_RATE / STEPPER_TIMER_PRESCALE) // frequency of stepper timer (HAL_TIMER_RATE / STEPPER_TIMER_PRESCALE)
#define HAL_TICKS_PER_US ((HAL_STEPPER_TIMER_RATE) / 1000000) // stepper timer ticks per us #define HAL_TICKS_PER_US ((HAL_STEPPER_TIMER_RATE) / 1000000) // stepper timer ticks per us
@ -55,11 +52,11 @@
#define TEMP_TIMER_PRESCALE 1000 // prescaler for setting Temp timer, 72Khz #define TEMP_TIMER_PRESCALE 1000 // prescaler for setting Temp timer, 72Khz
#define TEMP_TIMER_FREQUENCY 1000 // temperature interrupt frequency #define TEMP_TIMER_FREQUENCY 1000 // temperature interrupt frequency
#define ENABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_enable_interrupt (STEP_TIMER_NUM) #define ENABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_enable_interrupt(STEP_TIMER_NUM)
#define DISABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_disable_interrupt (STEP_TIMER_NUM) #define DISABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_disable_interrupt(STEP_TIMER_NUM)
#define ENABLE_TEMPERATURE_INTERRUPT() HAL_timer_enable_interrupt (TEMP_TIMER_NUM) #define ENABLE_TEMPERATURE_INTERRUPT() HAL_timer_enable_interrupt(TEMP_TIMER_NUM)
#define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt (TEMP_TIMER_NUM) #define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(TEMP_TIMER_NUM)
#define HAL_ENABLE_ISRs() do { if (thermalManager.in_temp_isr)DISABLE_TEMPERATURE_INTERRUPT(); else ENABLE_TEMPERATURE_INTERRUPT(); ENABLE_STEPPER_DRIVER_INTERRUPT(); } while(0) #define HAL_ENABLE_ISRs() do { if (thermalManager.in_temp_isr)DISABLE_TEMPERATURE_INTERRUPT(); else ENABLE_TEMPERATURE_INTERRUPT(); ENABLE_STEPPER_DRIVER_INTERRUPT(); } while(0)
// TODO change this // TODO change this
@ -86,27 +83,23 @@ typedef struct {
//extern const tTimerConfig timerConfig[]; //extern const tTimerConfig timerConfig[];
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// Public functions // Public functions
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
void HAL_timer_start (uint8_t timer_num, uint32_t frequency); void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency);
void HAL_timer_enable_interrupt(uint8_t timer_num); void HAL_timer_enable_interrupt(const uint8_t timer_num);
void HAL_timer_disable_interrupt(uint8_t timer_num); void HAL_timer_disable_interrupt(const uint8_t timer_num);
void HAL_timer_set_count(const uint8_t timer_num, const uint32_t count);
hal_timer_t HAL_timer_get_count(const uint8_t timer_num);
uint32_t HAL_timer_get_current_count(const uint8_t timer_num);
void HAL_timer_set_current_count(const uint8_t timer_num, const uint32_t count); // New
void HAL_timer_set_count (uint8_t timer_num, uint32_t count);
hal_timer_t HAL_timer_get_count (uint8_t timer_num);
uint32_t HAL_timer_get_current_count(uint8_t timer_num);
void HAL_timer_set_current_count (uint8_t timer_num, uint32_t count); //New
/*FORCE_INLINE static void HAL_timer_set_current_count(const uint8_t timer_num, const hal_timer_t count) { /*FORCE_INLINE static void HAL_timer_set_current_count(const uint8_t timer_num, const hal_timer_t count) {
// To do ?? // To do ??
}*/ }*/
void HAL_timer_isr_prologue (uint8_t timer_num); void HAL_timer_isr_prologue(const uint8_t timer_num);
#endif // _HAL_TIMERS_STM32F7_H #endif // _HAL_TIMERS_STM32F7_H

814
Marlin/src/HAL/HAL_STM32F7/TMC2660.cpp
View file

@ -1,28 +1,28 @@
/* /**
TMC26XStepper.cpp - - TMC26X Stepper library for Wiring/Arduino * TMC26XStepper.cpp - - TMC26X Stepper library for Wiring/Arduino
*
based on the stepper library by Tom Igoe, et. al. * based on the stepper library by Tom Igoe, et. al.
*
Copyright (c) 2011, Interactive Matter, Marcus Nowotny * Copyright (c) 2011, Interactive Matter, Marcus Nowotny
*
Permission is hereby granted, free of charge, to any person obtaining a copy * Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal * of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights * in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is * copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions: * furnished to do so, subject to the following conditions:
*
The above copyright notice and this permission notice shall be included in * The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software. * all copies or substantial portions of the Software.
*
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE. * THE SOFTWARE.
*
*/ */
//#include "Arduino.h" //#include "Arduino.h"
@ -120,72 +120,71 @@ SPIClass SPI_6(SPI6, SPI6_MOSI_PIN, SPI6_MISO_PIN, SPI6_SCK_PIN);
unsigned char current_scaling = 0; unsigned char current_scaling = 0;
/* /**
* Constructor * Constructor
* number_of_steps - the steps per rotation * number_of_steps - the steps per rotation
* cs_pin - the SPI client select pin * cs_pin - the SPI client select pin
* dir_pin - the pin where the direction pin is connected * dir_pin - the pin where the direction pin is connected
* step_pin - the pin where the step pin is connected * step_pin - the pin where the step pin is connected
*/ */
TMC26XStepper::TMC26XStepper(int number_of_steps, int cs_pin, int dir_pin, int step_pin, unsigned int current, unsigned int resistor) TMC26XStepper::TMC26XStepper(int number_of_steps, int cs_pin, int dir_pin, int step_pin, unsigned int current, unsigned int resistor) {
{ // We are not started yet
//we are not started yet started = false;
started=false;
//by default cool step is not enabled
cool_step_enabled=false;
//save the pins for later use // By default cool step is not enabled
this->cs_pin=cs_pin; cool_step_enabled = false;
this->dir_pin=dir_pin;
// Save the pins for later use
this->cs_pin = cs_pin;
this->dir_pin = dir_pin;
this->step_pin = step_pin; this->step_pin = step_pin;
//store the current sense resistor value for later use // Store the current sense resistor value for later use
this->resistor = resistor; this->resistor = resistor;
//initizalize our status values // Initizalize our status values
this->steps_left = 0; this->steps_left = 0;
this->direction = 0; this->direction = 0;
//initialize register values // Initialize register values
driver_control_register_value=DRIVER_CONTROL_REGISTER | INITIAL_MICROSTEPPING; driver_control_register_value = DRIVER_CONTROL_REGISTER | INITIAL_MICROSTEPPING;
chopper_config_register=CHOPPER_CONFIG_REGISTER; chopper_config_register = CHOPPER_CONFIG_REGISTER;
//setting the default register values // Setting the default register values
driver_control_register_value=DRIVER_CONTROL_REGISTER|INITIAL_MICROSTEPPING; driver_control_register_value = DRIVER_CONTROL_REGISTER|INITIAL_MICROSTEPPING;
microsteps = (1 << INITIAL_MICROSTEPPING); microsteps = _BV(INITIAL_MICROSTEPPING);
chopper_config_register=CHOPPER_CONFIG_REGISTER; chopper_config_register = CHOPPER_CONFIG_REGISTER;
cool_step_register_value=COOL_STEP_REGISTER; cool_step_register_value = COOL_STEP_REGISTER;
stall_guard2_current_register_value=STALL_GUARD2_LOAD_MEASURE_REGISTER; stall_guard2_current_register_value = STALL_GUARD2_LOAD_MEASURE_REGISTER;
driver_configuration_register_value = DRIVER_CONFIG_REGISTER | READ_STALL_GUARD_READING; driver_configuration_register_value = DRIVER_CONFIG_REGISTER | READ_STALL_GUARD_READING;
//set the current // Set the current
setCurrent(current); setCurrent(current);
//set to a conservative start value // Set to a conservative start value
setConstantOffTimeChopper(7, 54, 13,12,1); setConstantOffTimeChopper(7, 54, 13,12,1);
//set a nice microstepping value // Set a nice microstepping value
setMicrosteps(DEFAULT_MICROSTEPPING_VALUE); setMicrosteps(DEFAULT_MICROSTEPPING_VALUE);
//save the number of steps // Save the number of steps
this->number_of_steps = number_of_steps; this->number_of_steps = number_of_steps;
} }
/* /**
* start & configure the stepper driver * start & configure the stepper driver
* just must be called. * just must be called.
*/ */
void TMC26XStepper::start() { void TMC26XStepper::start() {
#ifdef TMC_DEBUG1 #ifdef TMC_DEBUG1
SERIAL_ECHOPGM("\n TMC26X stepper library \n"); SERIAL_ECHOPGM("\n TMC26X stepper library \n");
SERIAL_ECHOPAIR("\n CS pin: ",cs_pin); SERIAL_ECHOPAIR("\n CS pin: ", cs_pin);
SERIAL_ECHOPAIR("\n DIR pin: ",dir_pin); SERIAL_ECHOPAIR("\n DIR pin: ", dir_pin);
SERIAL_ECHOPAIR("\n STEP pin: ", step_pin); SERIAL_ECHOPAIR("\n STEP pin: ", step_pin);
SERIAL_PRINTF("\n current scaling: %d", current_scaling); SERIAL_PRINTF("\n current scaling: %d", current_scaling);
SERIAL_PRINTF("\n Resistor: %d", resistor); SERIAL_PRINTF("\n Resistor: %d", resistor);
//SERIAL_PRINTF("\n current: %d", current); //SERIAL_PRINTF("\n current: %d", current);
SERIAL_ECHOPAIR("\n Microstepping: ", microsteps); SERIAL_ECHOPAIR("\n Microstepping: ", microsteps);
#endif
#endif
//set the pins as output & its initial value //set the pins as output & its initial value
pinMode(step_pin, OUTPUT); pinMode(step_pin, OUTPUT);
@ -207,80 +206,69 @@ void TMC26XStepper::start() {
send262(driver_configuration_register_value); send262(driver_configuration_register_value);
//save that we are in running mode //save that we are in running mode
started=true; started = true;
} }
/* /**
Mark the driver as unstarted to be able to start it again * Mark the driver as unstarted to be able to start it again
*/ */
void TMC26XStepper::un_start() { void TMC26XStepper::un_start() { started = false; }
started=false;
}
/* /**
Sets the speed in revs per minute * Sets the speed in revs per minute
*/
*/ void TMC26XStepper::setSpeed(unsigned int whatSpeed) {
void TMC26XStepper::setSpeed(unsigned int whatSpeed)
{
this->speed = whatSpeed; this->speed = whatSpeed;
this->step_delay = (60UL * 1000UL * 1000UL) / ((unsigned long)this->number_of_steps * (unsigned long)whatSpeed * (unsigned long)this->microsteps); this->step_delay = 60UL * sq(1000UL) / ((unsigned long)this->number_of_steps * (unsigned long)whatSpeed * (unsigned long)this->microsteps);
#ifdef TMC_DEBUG0 //crashes #ifdef TMC_DEBUG0 // crashes
//SERIAL_PRINTF("Step delay in micros: "); //SERIAL_PRINTF("Step delay in micros: ");
SERIAL_ECHOPAIR("\nStep delay in micros: ",this->step_delay); SERIAL_ECHOPAIR("\nStep delay in micros: ", this->step_delay);
#endif #endif
//update the next step time // Update the next step time
this->next_step_time = this->last_step_time+this->step_delay; this->next_step_time = this->last_step_time + this->step_delay;
} }
unsigned int TMC26XStepper::getSpeed(void) { unsigned int TMC26XStepper::getSpeed(void) { return this->speed; }
return this->speed;
}
/* /**
Moves the motor steps_to_move steps. If the number is negative, * Moves the motor steps_to_move steps.
the motor moves in the reverse direction. * Negative indicates the reverse direction.
*/ */
char TMC26XStepper::step(int steps_to_move) char TMC26XStepper::step(int steps_to_move) {
{ if (this->steps_left == 0) {
if (this->steps_left==0) {
this->steps_left = abs(steps_to_move); // how many steps to take this->steps_left = abs(steps_to_move); // how many steps to take
// determine direction based on whether steps_to_mode is + or -: // determine direction based on whether steps_to_move is + or -:
if (steps_to_move > 0) { if (steps_to_move > 0)
this->direction = 1; this->direction = 1;
} else if (steps_to_move < 0) { else if (steps_to_move < 0)
this->direction = 0; this->direction = 0;
}
return 0; return 0;
} else {
return -1;
} }
return -1;
} }
char TMC26XStepper::move(void) { char TMC26XStepper::move(void) {
// decrement the number of steps, moving one step each time: // decrement the number of steps, moving one step each time:
if(this->steps_left>0) { if (this->steps_left > 0) {
unsigned long time = micros(); unsigned long time = micros();
// move only if the appropriate delay has passed: // move only if the appropriate delay has passed:
// rem if (time >= this->next_step_time) { // rem if (time >= this->next_step_time) {
if(abs(time - this->last_step_time) > this->step_delay) { if (abs(time - this->last_step_time) > this->step_delay) {
// increment or decrement the step number, // increment or decrement the step number,
// depending on direction: // depending on direction:
if (this->direction == 1) { if (this->direction == 1)
digitalWrite(step_pin, HIGH); digitalWrite(step_pin, HIGH);
} else { else {
digitalWrite(dir_pin, HIGH); digitalWrite(dir_pin, HIGH);
digitalWrite(step_pin, HIGH); digitalWrite(step_pin, HIGH);
} }
// get the timeStamp of when you stepped: // get the timeStamp of when you stepped:
this->last_step_time = time; this->last_step_time = time;
this->next_step_time = time+this->step_delay; this->next_step_time = time + this->step_delay;
// decrement the steps left: // decrement the steps left:
steps_left--; steps_left--;
//disable the step & dir pins //disable the step & dir pins
@ -292,13 +280,9 @@ char TMC26XStepper::move(void) {
return 0; return 0;
} }
char TMC26XStepper::isMoving(void) { char TMC26XStepper::isMoving(void) { return this->steps_left > 0; }
return (this->steps_left>0);
}
unsigned int TMC26XStepper::getStepsLeft(void) { unsigned int TMC26XStepper::getStepsLeft(void) { return this->steps_left; }
return this->steps_left;
}
char TMC26XStepper::stop(void) { char TMC26XStepper::stop(void) {
//note to self if the motor is currently moving //note to self if the motor is currently moving
@ -313,41 +297,40 @@ char TMC26XStepper::stop(void) {
void TMC26XStepper::setCurrent(unsigned int current) { void TMC26XStepper::setCurrent(unsigned int current) {
unsigned char current_scaling = 0; unsigned char current_scaling = 0;
//calculate the current scaling from the max current setting (in mA) //calculate the current scaling from the max current setting (in mA)
double mASetting = (double)current; double mASetting = (double)current,
double resistor_value = (double) this->resistor; resistor_value = (double)this->resistor;
// remove vesense flag // remove vsense flag
this->driver_configuration_register_value &= ~(VSENSE); this->driver_configuration_register_value &= ~(VSENSE);
//this is derrived from I=(cs+1)/32*(Vsense/Rsense) // Derived from I = (cs + 1) / 32 * (Vsense / Rsense)
//leading to cs = CS = 32*R*I/V (with V = 0,31V oder 0,165V and I = 1000*current) // leading to cs = 32 * R * I / V (with V = 0,31V oder 0,165V and I = 1000 * current)
//with Rsense=0,15 // with Rsense = 0,15
//for vsense = 0,310V (VSENSE not set) // for vsense = 0,310V (VSENSE not set)
//or vsense = 0,165V (VSENSE set) // or vsense = 0,165V (VSENSE set)
current_scaling = (byte)((resistor_value*mASetting*32.0/(0.31*1000.0*1000.0))-0.5); //theoretically - 1.0 for better rounding it is 0.5 current_scaling = (byte)((resistor_value * mASetting * 32.0 / (0.31 * sq(1000.0))) - 0.5); //theoretically - 1.0 for better rounding it is 0.5
//check if the current scalingis too low // Check if the current scalingis too low
if (current_scaling<16) { if (current_scaling < 16) {
//set the csense bit to get a use half the sense voltage (to support lower motor currents) // Set the csense bit to get a use half the sense voltage (to support lower motor currents)
this->driver_configuration_register_value |= VSENSE; this->driver_configuration_register_value |= VSENSE;
//and recalculate the current setting // and recalculate the current setting
current_scaling = (byte)((resistor_value*mASetting*32.0/(0.165*1000.0*1000.0))-0.5); //theoretically - 1.0 for better rounding it is 0.5 current_scaling = (byte)((resistor_value * mASetting * 32.0 / (0.165 * sq(1000.0))) - 0.5); //theoretically - 1.0 for better rounding it is 0.5
#ifdef TMC_DEBUG0 //crashes #ifdef TMC_DEBUG0 // crashes
//SERIAL_PRINTF("CS (Vsense=1): "); //SERIAL_PRINTF("CS (Vsense=1): ");
SERIAL_ECHOPAIR("\nCS (Vsense=1): ",current_scaling); SERIAL_ECHOPAIR("\nCS (Vsense=1): ",current_scaling);
} else { } else {
//SERIAL_PRINTF("CS: "); //SERIAL_PRINTF("CS: ");
SERIAL_ECHOPAIR("\nCS: ", current_scaling); SERIAL_ECHOPAIR("\nCS: ", current_scaling);
#endif #endif
} }
//do some sanity checks // do some sanity checks
if (current_scaling>31) { NOMORE(current_scaling, 31);
current_scaling=31;
} // delete the old value
//delete the old value
stall_guard2_current_register_value &= ~(CURRENT_SCALING_PATTERN); stall_guard2_current_register_value &= ~(CURRENT_SCALING_PATTERN);
//set the new current scaling // set the new current scaling
stall_guard2_current_register_value |= current_scaling; stall_guard2_current_register_value |= current_scaling;
//if started we directly send it to the motor // if started we directly send it to the motor
if (started) { if (started) {
send262(driver_configuration_register_value); send262(driver_configuration_register_value);
send262(stall_guard2_current_register_value); send262(stall_guard2_current_register_value);
@ -355,61 +338,52 @@ void TMC26XStepper::setCurrent(unsigned int current) {
} }
unsigned int TMC26XStepper::getCurrent(void) { unsigned int TMC26XStepper::getCurrent(void) {
//we calculate the current according to the datasheet to be on the safe side // Calculate the current according to the datasheet to be on the safe side.
//this is not the fastest but the most accurate and illustrative way // This is not the fastest but the most accurate and illustrative way.
double result = (double)(stall_guard2_current_register_value & CURRENT_SCALING_PATTERN); double result = (double)(stall_guard2_current_register_value & CURRENT_SCALING_PATTERN),
double resistor_value = (double)this->resistor; resistor_value = (double)this->resistor,
double voltage = (driver_configuration_register_value & VSENSE)? 0.165:0.31; voltage = (driver_configuration_register_value & VSENSE) ? 0.165 : 0.31;
result = (result+1.0)/32.0*voltage/resistor_value*1000.0*1000.0; result = (result + 1.0) / 32.0 * voltage / resistor_value * sq(1000.0);
return (unsigned int)result; return (unsigned int)result;
} }
void TMC26XStepper::setStallGuardThreshold(char stall_guard_threshold, char stall_guard_filter_enabled) { void TMC26XStepper::setStallGuardThreshold(char stall_guard_threshold, char stall_guard_filter_enabled) {
if (stall_guard_threshold<-64) { // We just have 5 bits
stall_guard_threshold = -64; LIMIT(stall_guard_threshold, -64, 63);
//We just have 5 bits
} else if (stall_guard_threshold > 63) { // Add trim down to 7 bits
stall_guard_threshold = 63; stall_guard_threshold &= 0x7F;
} // Delete old stall guard settings
//add trim down to 7 bits
stall_guard_threshold &=0x7f;
//delete old stall guard settings
stall_guard2_current_register_value &= ~(STALL_GUARD_CONFIG_PATTERN); stall_guard2_current_register_value &= ~(STALL_GUARD_CONFIG_PATTERN);
if (stall_guard_filter_enabled) { if (stall_guard_filter_enabled)
stall_guard2_current_register_value |= STALL_GUARD_FILTER_ENABLED; stall_guard2_current_register_value |= STALL_GUARD_FILTER_ENABLED;
}
//Set the new stall guard threshold // Set the new stall guard threshold
stall_guard2_current_register_value |= (((unsigned long)stall_guard_threshold << 8) & STALL_GUARD_CONFIG_PATTERN); stall_guard2_current_register_value |= (((unsigned long)stall_guard_threshold << 8) & STALL_GUARD_CONFIG_PATTERN);
//if started we directly send it to the motor // If started we directly send it to the motor
if (started) { if (started) send262(stall_guard2_current_register_value);
send262(stall_guard2_current_register_value);
}
} }
char TMC26XStepper::getStallGuardThreshold(void) { char TMC26XStepper::getStallGuardThreshold(void) {
unsigned long stall_guard_threshold = stall_guard2_current_register_value & STALL_GUARD_VALUE_PATTERN; unsigned long stall_guard_threshold = stall_guard2_current_register_value & STALL_GUARD_VALUE_PATTERN;
//shift it down to bit 0 //shift it down to bit 0
stall_guard_threshold >>=8; stall_guard_threshold >>= 8;
//convert the value to an int to correctly handle the negative numbers //convert the value to an int to correctly handle the negative numbers
char result = stall_guard_threshold; char result = stall_guard_threshold;
//check if it is negative and fill it up with leading 1 for proper negative number representation //check if it is negative and fill it up with leading 1 for proper negative number representation
//rem if (result & _BV(6)) { //rem if (result & _BV(6)) {
if (result & (1 << (6))) { if (TEST(result, 6)) result |= 0xC0;
result |= 0xC0;
}
return result; return result;
} }
char TMC26XStepper::getStallGuardFilter(void) { char TMC26XStepper::getStallGuardFilter(void) {
if (stall_guard2_current_register_value & STALL_GUARD_FILTER_ENABLED) { if (stall_guard2_current_register_value & STALL_GUARD_FILTER_ENABLED)
return -1; return -1;
} else {
return 0; return 0;
}
} }
/*
/**
* Set the number of microsteps per step. * Set the number of microsteps per step.
* 0,2,4,8,16,32,64,128,256 is supported * 0,2,4,8,16,32,64,128,256 is supported
* any value in between will be mapped to the next smaller value * any value in between will be mapped to the next smaller value
@ -418,60 +392,65 @@ char TMC26XStepper::getStallGuardFilter(void) {
void TMC26XStepper::setMicrosteps(int number_of_steps) { void TMC26XStepper::setMicrosteps(int number_of_steps) {
long setting_pattern; long setting_pattern;
//poor mans log //poor mans log
if (number_of_steps>=256) { if (number_of_steps >= 256) {
setting_pattern=0; setting_pattern = 0;
microsteps=256; microsteps = 256;
} else if (number_of_steps>=128) {
setting_pattern=1;
microsteps=128;
} else if (number_of_steps>=64) {
setting_pattern=2;
microsteps=64;
} else if (number_of_steps>=32) {
setting_pattern=3;
microsteps=32;
} else if (number_of_steps>=16) {
setting_pattern=4;
microsteps=16;
} else if (number_of_steps>=8) {
setting_pattern=5;
microsteps=8;
} else if (number_of_steps>=4) {
setting_pattern=6;
microsteps=4;
} else if (number_of_steps>=2) {
setting_pattern=7;
microsteps=2;
//1 and 0 lead to full step
} else if (number_of_steps<=1) {
setting_pattern=8;
microsteps=1;
} }
#ifdef TMC_DEBUG0 //crashes else if (number_of_steps >= 128) {
setting_pattern = 1;
microsteps = 128;
}
else if (number_of_steps >= 64) {
setting_pattern = 2;
microsteps = 64;
}
else if (number_of_steps >= 32) {
setting_pattern = 3;
microsteps = 32;
}
else if (number_of_steps >= 16) {
setting_pattern = 4;
microsteps = 16;
}
else if (number_of_steps >= 8) {
setting_pattern = 5;
microsteps = 8;
}
else if (number_of_steps >= 4) {
setting_pattern = 6;
microsteps = 4;
}
else if (number_of_steps >= 2) {
setting_pattern = 7;
microsteps = 2;
//1 and 0 lead to full step
}
else if (number_of_steps <= 1) {
setting_pattern = 8;
microsteps = 1;
}
#ifdef TMC_DEBUG0 // crashes
//SERIAL_PRINTF("Microstepping: "); //SERIAL_PRINTF("Microstepping: ");
SERIAL_ECHOPAIR("\n Microstepping: ", microsteps); SERIAL_ECHOPAIR("\n Microstepping: ", microsteps);
#endif #endif
//delete the old value // Delete the old value
this->driver_control_register_value &=0xFFFF0ul; this->driver_control_register_value &= 0xFFFF0UL;
//set the new value // Set the new value
this->driver_control_register_value |=setting_pattern; this->driver_control_register_value |= setting_pattern;
//if started we directly send it to the motor // If started we directly send it to the motor
if (started) { if (started) send262(driver_control_register_value);
send262(driver_control_register_value);
} // Recalculate the stepping delay by simply setting the speed again
//recalculate the stepping delay by simply setting the speed again
this->setSpeed(this->speed); this->setSpeed(this->speed);
} }
/* /**
* returns the effective number of microsteps at the moment * returns the effective number of microsteps at the moment
*/ */
int TMC26XStepper::getMicrosteps(void) { int TMC26XStepper::getMicrosteps(void) { return microsteps }
return microsteps;
}
/* /**
* constant_off_time: The off time setting controls the minimum chopper frequency. * constant_off_time: The off time setting controls the minimum chopper frequency.
* For most applications an off time within the range of 5μs to 20μs will fit. * For most applications an off time within the range of 5μs to 20μs will fit.
* 2...15: off time setting * 2...15: off time setting
@ -495,67 +474,51 @@ int TMC26XStepper::getMicrosteps(void) {
* 0: end by time only * 0: end by time only
*/ */
void TMC26XStepper::setConstantOffTimeChopper(char constant_off_time, char blank_time, char fast_decay_time_setting, char sine_wave_offset, unsigned char use_current_comparator) { void TMC26XStepper::setConstantOffTimeChopper(char constant_off_time, char blank_time, char fast_decay_time_setting, char sine_wave_offset, unsigned char use_current_comparator) {
//perform some sanity checks // Perform some sanity checks
if (constant_off_time<2) { LIMIT(constant_off_time, 2, 15);
constant_off_time=2;
} else if (constant_off_time>15) { // Save the constant off time
constant_off_time=15;
}
//save the constant off time
this->constant_off_time = constant_off_time; this->constant_off_time = constant_off_time;
char blank_value;
//calculate the value acc to the clock cycles
if (blank_time>=54) {
blank_value=3;
} else if (blank_time>=36) {
blank_value=2;
} else if (blank_time>=24) {
blank_value=1;
} else {
blank_value=0;
}
if (fast_decay_time_setting<0) {
fast_decay_time_setting=0;
} else if (fast_decay_time_setting>15) {
fast_decay_time_setting=15;
}
if (sine_wave_offset < -3) {
sine_wave_offset = -3;
} else if (sine_wave_offset>12) {
sine_wave_offset = 12;
}
//shift the sine_wave_offset
sine_wave_offset +=3;
//calculate the register setting // Calculate the value acc to the clock cycles
//first of all delete all the values for this const char blank_value = blank_time >= 54 ? 3 :
chopper_config_register &= ~((1<<12) | BLANK_TIMING_PATTERN | HYSTERESIS_DECREMENT_PATTERN | HYSTERESIS_LOW_VALUE_PATTERN | HYSTERESIS_START_VALUE_PATTERN | T_OFF_TIMING_PATERN); blank_time >= 36 ? 2 :
//set the constant off pattern blank_time >= 24 ? 1 : 0;
LIMIT(fast_decay_time_setting, 0, 15);
LIMIT(sine_wave_offset, -3, 12);
// Shift the sine_wave_offset
sine_wave_offset += 3;
// Calculate the register setting
// First of all delete all the values for this
chopper_config_register &= ~(_BV(12) | BLANK_TIMING_PATTERN | HYSTERESIS_DECREMENT_PATTERN | HYSTERESIS_LOW_VALUE_PATTERN | HYSTERESIS_START_VALUE_PATTERN | T_OFF_TIMING_PATERN);
// Set the constant off pattern
chopper_config_register |= CHOPPER_MODE_T_OFF_FAST_DECAY; chopper_config_register |= CHOPPER_MODE_T_OFF_FAST_DECAY;
//set the blank timing value // Set the blank timing value
chopper_config_register |= ((unsigned long)blank_value) << BLANK_TIMING_SHIFT; chopper_config_register |= ((unsigned long)blank_value) << BLANK_TIMING_SHIFT;
//setting the constant off time // Setting the constant off time
chopper_config_register |= constant_off_time; chopper_config_register |= constant_off_time;
//set the fast decay time // Set the fast decay time
//set msb // Set msb
chopper_config_register |= (((unsigned long)(fast_decay_time_setting & 0x8))<<HYSTERESIS_DECREMENT_SHIFT); chopper_config_register |= (((unsigned long)(fast_decay_time_setting & 0x8)) << HYSTERESIS_DECREMENT_SHIFT);
//other bits // Other bits
chopper_config_register |= (((unsigned long)(fast_decay_time_setting & 0x7))<<HYSTERESIS_START_VALUE_SHIFT); chopper_config_register |= (((unsigned long)(fast_decay_time_setting & 0x7)) << HYSTERESIS_START_VALUE_SHIFT);
//set the sine wave offset // Set the sine wave offset
chopper_config_register |= (unsigned long)sine_wave_offset << HYSTERESIS_LOW_SHIFT; chopper_config_register |= (unsigned long)sine_wave_offset << HYSTERESIS_LOW_SHIFT;
//using the current comparator? // Using the current comparator?
if (!use_current_comparator) { if (!use_current_comparator)
chopper_config_register |= (1<<12); chopper_config_register |= _BV(12);
}
//if started we directly send it to the motor
if (started) {
//rem send262(driver_control_register_value);
// If started we directly send it to the motor
if (started) {
// rem send262(driver_control_register_value);
send262(chopper_config_register); send262(chopper_config_register);
} }
} }
/* /**
* constant_off_time: The off time setting controls the minimum chopper frequency. * constant_off_time: The off time setting controls the minimum chopper frequency.
* For most applications an off time within the range of 5μs to 20μs will fit. * For most applications an off time within the range of 5μs to 20μs will fit.
* 2...15: off time setting * 2...15: off time setting
@ -576,45 +539,26 @@ void TMC26XStepper::setConstantOffTimeChopper(char constant_off_time, char blank
*/ */
void TMC26XStepper::setSpreadCycleChopper(char constant_off_time, char blank_time, char hysteresis_start, char hysteresis_end, char hysteresis_decrement) { void TMC26XStepper::setSpreadCycleChopper(char constant_off_time, char blank_time, char hysteresis_start, char hysteresis_end, char hysteresis_decrement) {
//perform some sanity checks // Perform some sanity checks
if (constant_off_time<2) { LIMIT(constant_off_time, 2, 15);
constant_off_time=2;
} else if (constant_off_time>15) { // Save the constant off time
constant_off_time=15;
}
//save the constant off time
this->constant_off_time = constant_off_time; this->constant_off_time = constant_off_time;
char blank_value;
//calculate the value acc to the clock cycles // Calculate the value acc to the clock cycles
if (blank_time>=54) { const char blank_value = blank_time >= 54 ? 3 :
blank_value=3; blank_time >= 36 ? 2 :
} else if (blank_time>=36) { blank_time >= 24 ? 1 : 0;
blank_value=2;
} else if (blank_time>=24) { LIMIT(hysteresis_start, 1, 8);
blank_value=1;
} else {
blank_value=0;
}
if (hysteresis_start<1) {
hysteresis_start=1;
} else if (hysteresis_start>8) {
hysteresis_start=8;
}
hysteresis_start--; hysteresis_start--;
if (hysteresis_end < -3) { LIMIT(hysteresis_start, -3, 12);
hysteresis_end = -3;
} else if (hysteresis_end>12) {
hysteresis_end = 12;
}
//shift the hysteresis_end
hysteresis_end +=3;
if (hysteresis_decrement<0) { // Shift the hysteresis_end
hysteresis_decrement=0; hysteresis_end += 3;
} else if (hysteresis_decrement>3) {
hysteresis_decrement=3; LIMIT(hysteresis_decrement, 0, 3);
}
//first of all delete all the values for this //first of all delete all the values for this
chopper_config_register &= ~(CHOPPER_MODE_T_OFF_FAST_DECAY | BLANK_TIMING_PATTERN | HYSTERESIS_DECREMENT_PATTERN | HYSTERESIS_LOW_VALUE_PATTERN | HYSTERESIS_START_VALUE_PATTERN | T_OFF_TIMING_PATERN); chopper_config_register &= ~(CHOPPER_MODE_T_OFF_FAST_DECAY | BLANK_TIMING_PATTERN | HYSTERESIS_DECREMENT_PATTERN | HYSTERESIS_LOW_VALUE_PATTERN | HYSTERESIS_START_VALUE_PATTERN | T_OFF_TIMING_PATERN);
@ -632,12 +576,11 @@ void TMC26XStepper::setSpreadCycleChopper(char constant_off_time, char blank_tim
//if started we directly send it to the motor //if started we directly send it to the motor
if (started) { if (started) {
//rem send262(driver_control_register_value); //rem send262(driver_control_register_value);
send262(chopper_config_register); send262(chopper_config_register);
} }
} }
/* /**
* In a constant off time chopper scheme both coil choppers run freely, i.e. are not synchronized. * In a constant off time chopper scheme both coil choppers run freely, i.e. are not synchronized.
* The frequency of each chopper mainly depends on the coil current and the position dependant motor coil inductivity, thus it depends on the microstep position. * The frequency of each chopper mainly depends on the coil current and the position dependant motor coil inductivity, thus it depends on the microstep position.
* With some motors a slightly audible beat can occur between the chopper frequencies, especially when they are near to each other. This typically occurs at a * With some motors a slightly audible beat can occur between the chopper frequencies, especially when they are near to each other. This typically occurs at a
@ -650,97 +593,85 @@ void TMC26XStepper::setSpreadCycleChopper(char constant_off_time, char blank_tim
* reducing electromagnetic emission on single frequencies. * reducing electromagnetic emission on single frequencies.
*/ */
void TMC26XStepper::setRandomOffTime(char value) { void TMC26XStepper::setRandomOffTime(char value) {
if (value) { if (value)
chopper_config_register |= RANDOM_TOFF_TIME; chopper_config_register |= RANDOM_TOFF_TIME;
} else { else
chopper_config_register &= ~(RANDOM_TOFF_TIME); chopper_config_register &= ~(RANDOM_TOFF_TIME);
}
//if started we directly send it to the motor //if started we directly send it to the motor
if (started) { if (started) {
//rem send262(driver_control_register_value); //rem send262(driver_control_register_value);
send262(chopper_config_register); send262(chopper_config_register);
} }
} }
void TMC26XStepper::setCoolStepConfiguration(unsigned int lower_SG_threshold, unsigned int SG_hysteresis, unsigned char current_decrement_step_size, void TMC26XStepper::setCoolStepConfiguration(
unsigned char current_increment_step_size, unsigned char lower_current_limit) { unsigned int lower_SG_threshold,
//sanitize the input values unsigned int SG_hysteresis,
if (lower_SG_threshold>480) { unsigned char current_decrement_step_size,
lower_SG_threshold = 480; unsigned char current_increment_step_size,
} unsigned char lower_current_limit)
//divide by 32 {
lower_SG_threshold >>=5; // Sanitize the input values
if (SG_hysteresis>480) { NOMORE(lower_SG_threshold, 480);
SG_hysteresis=480; // Divide by 32
} lower_SG_threshold >>= 5;
//divide by 32 NOMORE(SG_hysteresis, 480);
SG_hysteresis >>=5; // Divide by 32
if (current_decrement_step_size>3) { SG_hysteresis >>= 5;
current_decrement_step_size=3; NOMORE(current_decrement_step_size, 3);
} NOMORE(current_increment_step_size, 3);
if (current_increment_step_size>3) { NOMORE(lower_current_limit, 1);
current_increment_step_size=3;
} // Store the lower level in order to enable/disable the cool step
if (lower_current_limit>1) {
lower_current_limit=1;
}
//store the lower level in order to enable/disable the cool step
this->cool_step_lower_threshold=lower_SG_threshold; this->cool_step_lower_threshold=lower_SG_threshold;
//if cool step is not enabled we delete the lower value to keep it disabled // If cool step is not enabled we delete the lower value to keep it disabled
if (!this->cool_step_enabled) { if (!this->cool_step_enabled) lower_SG_threshold = 0;
lower_SG_threshold=0; // The good news is that we can start with a complete new cool step register value
} // And simply set the values in the register
//the good news is that we can start with a complete new cool step register value cool_step_register_value = ((unsigned long)lower_SG_threshold)
//and simply set the values in the register | (((unsigned long)SG_hysteresis) << 8)
cool_step_register_value = ((unsigned long)lower_SG_threshold) | (((unsigned long)SG_hysteresis)<<8) | (((unsigned long)current_decrement_step_size)<<5) | (((unsigned long)current_decrement_step_size) << 5)
| (((unsigned long)current_increment_step_size)<<13) | (((unsigned long)lower_current_limit)<<15) | (((unsigned long)current_increment_step_size) << 13)
//and of course we have to include the signature of the register | (((unsigned long)lower_current_limit) << 15)
| COOL_STEP_REGISTER; | COOL_STEP_REGISTER; // Register signature
//SERIAL_PRINTFln(cool_step_register_value,HEX); //SERIAL_PRINTFln(cool_step_register_value,HEX);
if (started) { if (started) send262(cool_step_register_value);
send262(cool_step_register_value);
}
} }
void TMC26XStepper::setCoolStepEnabled(boolean enabled) { void TMC26XStepper::setCoolStepEnabled(boolean enabled) {
//simply delete the lower limit to disable the cool step // Simply delete the lower limit to disable the cool step
cool_step_register_value &= ~SE_MIN_PATTERN; cool_step_register_value &= ~SE_MIN_PATTERN;
//and set it to the proper value if cool step is to be enabled // And set it to the proper value if cool step is to be enabled
if (enabled) { if (enabled)
cool_step_register_value |=this->cool_step_lower_threshold; cool_step_register_value |= this->cool_step_lower_threshold;
} // And save the enabled status
//and save the enabled status
this->cool_step_enabled = enabled; this->cool_step_enabled = enabled;
//save the register value // Save the register value
if (started) { if (started) send262(cool_step_register_value);
send262(cool_step_register_value);
}
} }
boolean TMC26XStepper::isCoolStepEnabled(void) { boolean TMC26XStepper::isCoolStepEnabled(void) { return this->cool_step_enabled; }
return this->cool_step_enabled;
}
unsigned int TMC26XStepper::getCoolStepLowerSgThreshold() { unsigned int TMC26XStepper::getCoolStepLowerSgThreshold() {
//we return our internally stored value - in order to provide the correct setting even if cool step is not enabled // We return our internally stored value - in order to provide the correct setting even if cool step is not enabled
return this->cool_step_lower_threshold<<5; return this->cool_step_lower_threshold<<5;
} }
unsigned int TMC26XStepper::getCoolStepUpperSgThreshold() { unsigned int TMC26XStepper::getCoolStepUpperSgThreshold() {
return (unsigned char)((cool_step_register_value & SE_MAX_PATTERN)>>8)<<5; return (unsigned char)((cool_step_register_value & SE_MAX_PATTERN) >> 8) << 5;
} }
unsigned char TMC26XStepper::getCoolStepCurrentIncrementSize() { unsigned char TMC26XStepper::getCoolStepCurrentIncrementSize() {
return (unsigned char)((cool_step_register_value & CURRENT_DOWN_STEP_SPEED_PATTERN)>>13); return (unsigned char)((cool_step_register_value & CURRENT_DOWN_STEP_SPEED_PATTERN) >> 13);
} }
unsigned char TMC26XStepper::getCoolStepNumberOfSGReadings() { unsigned char TMC26XStepper::getCoolStepNumberOfSGReadings() {
return (unsigned char)((cool_step_register_value & SE_CURRENT_STEP_WIDTH_PATTERN)>>5); return (unsigned char)((cool_step_register_value & SE_CURRENT_STEP_WIDTH_PATTERN) >> 5);
} }
unsigned char TMC26XStepper::getCoolStepLowerCurrentLimit() { unsigned char TMC26XStepper::getCoolStepLowerCurrentLimit() {
return (unsigned char)((cool_step_register_value & MINIMUM_CURRENT_FOURTH)>>15); return (unsigned char)((cool_step_register_value & MINIMUM_CURRENT_FOURTH) >> 15);
} }
void TMC26XStepper::setEnabled(boolean enabled) { void TMC26XStepper::setEnabled(boolean enabled) {
@ -751,20 +682,12 @@ void TMC26XStepper::setEnabled(boolean enabled) {
chopper_config_register |= this->constant_off_time; chopper_config_register |= this->constant_off_time;
} }
//if not enabled we don't have to do anything since we already delete t_off from the register //if not enabled we don't have to do anything since we already delete t_off from the register
if (started) { if (started) send262(chopper_config_register);
send262(chopper_config_register);
}
} }
boolean TMC26XStepper::isEnabled() { boolean TMC26XStepper::isEnabled() { return !!(chopper_config_register & T_OFF_PATTERN); }
if (chopper_config_register & T_OFF_PATTERN) {
return true;
} else {
return false;
}
}
/* /**
* reads a value from the TMC26X status register. The value is not obtained directly but can then * reads a value from the TMC26X status register. The value is not obtained directly but can then
* be read by the various status routines. * be read by the various status routines.
* *
@ -774,14 +697,14 @@ void TMC26XStepper::readStatus(char read_value) {
//reset the readout configuration //reset the readout configuration
driver_configuration_register_value &= ~(READ_SELECTION_PATTERN); driver_configuration_register_value &= ~(READ_SELECTION_PATTERN);
//this now equals TMC26X_READOUT_POSITION - so we just have to check the other two options //this now equals TMC26X_READOUT_POSITION - so we just have to check the other two options
if (read_value == TMC26X_READOUT_STALLGUARD) { if (read_value == TMC26X_READOUT_STALLGUARD)
driver_configuration_register_value |= READ_STALL_GUARD_READING; driver_configuration_register_value |= READ_STALL_GUARD_READING;
} else if (read_value == TMC26X_READOUT_CURRENT) { else if (read_value == TMC26X_READOUT_CURRENT)
driver_configuration_register_value |= READ_STALL_GUARD_AND_COOL_STEP; driver_configuration_register_value |= READ_STALL_GUARD_AND_COOL_STEP;
}
//all other cases are ignored to prevent funny values //all other cases are ignored to prevent funny values
//check if the readout is configured for the value we are interested in //check if the readout is configured for the value we are interested in
if (driver_configuration_register_value!=old_driver_configuration_register_value) { if (driver_configuration_register_value != old_driver_configuration_register_value) {
//because then we need to write the value twice - one time for configuring, second time to get the value, see below //because then we need to write the value twice - one time for configuring, second time to get the value, see below
send262(driver_configuration_register_value); send262(driver_configuration_register_value);
} }
@ -799,9 +722,7 @@ int TMC26XStepper::getMotorPosition(void) {
//returns -1 if stallguard information is not present //returns -1 if stallguard information is not present
int TMC26XStepper::getCurrentStallGuardReading(void) { int TMC26XStepper::getCurrentStallGuardReading(void) {
//if we don't yet started there cannot be a stall guard value //if we don't yet started there cannot be a stall guard value
if (!started) { if (!started) return -1;
return -1;
}
//not time optimal, but solution optiomal: //not time optimal, but solution optiomal:
//first read out the stall guard value //first read out the stall guard value
readStatus(TMC26X_READOUT_STALLGUARD); readStatus(TMC26X_READOUT_STALLGUARD);
@ -810,97 +731,80 @@ int TMC26XStepper::getCurrentStallGuardReading(void) {
unsigned char TMC26XStepper::getCurrentCSReading(void) { unsigned char TMC26XStepper::getCurrentCSReading(void) {
//if we don't yet started there cannot be a stall guard value //if we don't yet started there cannot be a stall guard value
if (!started) { if (!started) return 0;
return 0;
}
//not time optimal, but solution optiomal: //not time optimal, but solution optiomal:
//first read out the stall guard value //first read out the stall guard value
readStatus(TMC26X_READOUT_CURRENT); readStatus(TMC26X_READOUT_CURRENT);
return (getReadoutValue() & 0x1f); return (getReadoutValue() & 0x1F);
} }
unsigned int TMC26XStepper::getCurrentCurrent(void) { unsigned int TMC26XStepper::getCurrentCurrent(void) {
double result = (double)getCurrentCSReading(); double result = (double)getCurrentCSReading(),
double resistor_value = (double)this->resistor; resistor_value = (double)this->resistor,
double voltage = (driver_configuration_register_value & VSENSE)? 0.165:0.31; voltage = (driver_configuration_register_value & VSENSE)? 0.165 : 0.31;
result = (result+1.0)/32.0*voltage/resistor_value*1000.0*1000.0; result = (result + 1.0) / 32.0 * voltage / resistor_value * sq(1000.0);
return (unsigned int)result; return (unsigned int)result;
} }
/* /**
return true if the stallguard threshold has been reached * Return true if the stallguard threshold has been reached
*/ */
boolean TMC26XStepper::isStallGuardOverThreshold(void) { boolean TMC26XStepper::isStallGuardOverThreshold(void) {
if (!this->started) { if (!this->started) return false;
return false;
}
return (driver_status_result & STATUS_STALL_GUARD_STATUS); return (driver_status_result & STATUS_STALL_GUARD_STATUS);
} }
/* /**
returns if there is any over temperature condition: * returns if there is any over temperature condition:
OVER_TEMPERATURE_PREWARING if pre warning level has been reached * OVER_TEMPERATURE_PREWARING if pre warning level has been reached
OVER_TEMPERATURE_SHUTDOWN if the temperature is so hot that the driver is shut down * OVER_TEMPERATURE_SHUTDOWN if the temperature is so hot that the driver is shut down
Any of those levels are not too good. * Any of those levels are not too good.
*/ */
char TMC26XStepper::getOverTemperature(void) { char TMC26XStepper::getOverTemperature(void) {
if (!this->started) { if (!this->started) return 0;
return 0;
} if (driver_status_result & STATUS_OVER_TEMPERATURE_SHUTDOWN)
if (driver_status_result & STATUS_OVER_TEMPERATURE_SHUTDOWN) {
return TMC26X_OVERTEMPERATURE_SHUTDOWN; return TMC26X_OVERTEMPERATURE_SHUTDOWN;
}
if (driver_status_result & STATUS_OVER_TEMPERATURE_WARNING) { if (driver_status_result & STATUS_OVER_TEMPERATURE_WARNING)
return TMC26X_OVERTEMPERATURE_PREWARING; return TMC26X_OVERTEMPERATURE_PREWARING;
}
return 0; return 0;
} }
//is motor channel A shorted to ground // Is motor channel A shorted to ground
boolean TMC26XStepper::isShortToGroundA(void) { boolean TMC26XStepper::isShortToGroundA(void) {
if (!this->started) { if (!this->started) return false;
return false;
}
return (driver_status_result & STATUS_SHORT_TO_GROUND_A); return (driver_status_result & STATUS_SHORT_TO_GROUND_A);
} }
//is motor channel B shorted to ground // Is motor channel B shorted to ground
boolean TMC26XStepper::isShortToGroundB(void) { boolean TMC26XStepper::isShortToGroundB(void) {
if (!this->started) { if (!this->started) return false;
return false;
}
return (driver_status_result & STATUS_SHORT_TO_GROUND_B); return (driver_status_result & STATUS_SHORT_TO_GROUND_B);
} }
//is motor channel A connected // Is motor channel A connected
boolean TMC26XStepper::isOpenLoadA(void) { boolean TMC26XStepper::isOpenLoadA(void) {
if (!this->started) { if (!this->started) return false;
return false;
}
return (driver_status_result & STATUS_OPEN_LOAD_A); return (driver_status_result & STATUS_OPEN_LOAD_A);
} }
//is motor channel B connected // Is motor channel B connected
boolean TMC26XStepper::isOpenLoadB(void) { boolean TMC26XStepper::isOpenLoadB(void) {
if (!this->started) { if (!this->started) return false;
return false;
}
return (driver_status_result & STATUS_OPEN_LOAD_B); return (driver_status_result & STATUS_OPEN_LOAD_B);
} }
//is chopper inactive since 2^20 clock cycles - defaults to ~0,08s // Is chopper inactive since 2^20 clock cycles - defaults to ~0,08s
boolean TMC26XStepper::isStandStill(void) { boolean TMC26XStepper::isStandStill(void) {
if (!this->started) { if (!this->started) return false;
return false;
}
return (driver_status_result & STATUS_STAND_STILL); return (driver_status_result & STATUS_STAND_STILL);
} }
//is chopper inactive since 2^20 clock cycles - defaults to ~0,08s //is chopper inactive since 2^20 clock cycles - defaults to ~0,08s
boolean TMC26XStepper::isStallGuardReached(void) { boolean TMC26XStepper::isStallGuardReached(void) {
if (!this->started) { if (!this->started) return false;
return false;
}
return (driver_status_result & STATUS_STALL_GUARD_STATUS); return (driver_status_result & STATUS_STALL_GUARD_STATUS);
} }
@ -910,72 +814,64 @@ int TMC26XStepper::getReadoutValue(void) {
return (int)(driver_status_result >> 10); return (int)(driver_status_result >> 10);
} }
int TMC26XStepper::getResistor() { int TMC26XStepper::getResistor() { return this->resistor; }
return this->resistor;
}
boolean TMC26XStepper::isCurrentScalingHalfed() { boolean TMC26XStepper::isCurrentScalingHalfed() {
if (this->driver_configuration_register_value & VSENSE) { return !!(this->driver_configuration_register_value & VSENSE);
return true;
} else {
return false;
}
} }
/* /**
version() returns the version of the library: * version() returns the version of the library:
*/ */
int TMC26XStepper::version(void) int TMC26XStepper::version(void) { return 1; }
{
return 1;
}
void TMC26XStepper::debugLastStatus() { void TMC26XStepper::debugLastStatus() {
#ifdef TMC_DEBUG1 #ifdef TMC_DEBUG1
if (this->started) { if (this->started) {
if (this->getOverTemperature()&TMC26X_OVERTEMPERATURE_PREWARING) { if (this->getOverTemperature()&TMC26X_OVERTEMPERATURE_PREWARING)
SERIAL_ECHOLNPGM("\n WARNING: Overtemperature Prewarning!"); SERIAL_ECHOLNPGM("\n WARNING: Overtemperature Prewarning!");
} else if (this->getOverTemperature()&TMC26X_OVERTEMPERATURE_SHUTDOWN) { else if (this->getOverTemperature()&TMC26X_OVERTEMPERATURE_SHUTDOWN)
SERIAL_ECHOLNPGM("\n ERROR: Overtemperature Shutdown!"); SERIAL_ECHOLNPGM("\n ERROR: Overtemperature Shutdown!");
}
if (this->isShortToGroundA()) { if (this->isShortToGroundA())
SERIAL_ECHOLNPGM("\n ERROR: SHORT to ground on channel A!"); SERIAL_ECHOLNPGM("\n ERROR: SHORT to ground on channel A!");
}
if (this->isShortToGroundB()) { if (this->isShortToGroundB())
SERIAL_ECHOLNPGM("\n ERROR: SHORT to ground on channel B!"); SERIAL_ECHOLNPGM("\n ERROR: SHORT to ground on channel B!");
}
if (this->isOpenLoadA()) { if (this->isOpenLoadA())
SERIAL_ECHOLNPGM("\n ERROR: Channel A seems to be unconnected!"); SERIAL_ECHOLNPGM("\n ERROR: Channel A seems to be unconnected!");
}
if (this->isOpenLoadB()) { if (this->isOpenLoadB())
SERIAL_ECHOLNPGM("\n ERROR: Channel B seems to be unconnected!"); SERIAL_ECHOLNPGM("\n ERROR: Channel B seems to be unconnected!");
}
if (this->isStallGuardReached()) { if (this->isStallGuardReached())
SERIAL_ECHOLNPGM("\n INFO: Stall Guard level reached!"); SERIAL_ECHOLNPGM("\n INFO: Stall Guard level reached!");
}
if (this->isStandStill()) { if (this->isStandStill())
SERIAL_ECHOLNPGM("\n INFO: Motor is standing still."); SERIAL_ECHOLNPGM("\n INFO: Motor is standing still.");
}
unsigned long readout_config = driver_configuration_register_value & READ_SELECTION_PATTERN; unsigned long readout_config = driver_configuration_register_value & READ_SELECTION_PATTERN;
int value = getReadoutValue(); const int value = getReadoutValue();
if (readout_config == READ_MICROSTEP_POSTION) { if (readout_config == READ_MICROSTEP_POSTION) {
//SERIAL_PRINTF("Microstep postion phase A: "); //SERIAL_PRINTF("Microstep postion phase A: ");
SERIAL_ECHOPAIR("\n Microstep postion phase A: ", value); SERIAL_ECHOPAIR("\n Microstep postion phase A: ", value);
} else if (readout_config == READ_STALL_GUARD_READING) { }
else if (readout_config == READ_STALL_GUARD_READING) {
//SERIAL_PRINTF("Stall Guard value:"); //SERIAL_PRINTF("Stall Guard value:");
SERIAL_ECHOPAIR("\n Stall Guard value:", value); SERIAL_ECHOPAIR("\n Stall Guard value:", value);
} else if (readout_config == READ_STALL_GUARD_AND_COOL_STEP) { }
int stallGuard = value & 0xf; else if (readout_config == READ_STALL_GUARD_AND_COOL_STEP) {
int current = value & 0x1F0; int stallGuard = value & 0xF, current = value & 0x1F0;
//SERIAL_PRINTF("Approx Stall Guard: "); //SERIAL_PRINTF("Approx Stall Guard: ");
SERIAL_ECHOPAIR("\n Approx Stall Guard: ", stallGuard); SERIAL_ECHOPAIR("\n Approx Stall Guard: ", stallGuard);
//SERIAL_PRINTF("Current level"); //SERIAL_PRINTF("Current level");
SERIAL_ECHOPAIR("\n Current level", current); SERIAL_ECHOPAIR("\n Current level", current);
} }
} }
#endif #endif
} }
/* /**
* send register settings to the stepper driver via SPI * send register settings to the stepper driver via SPI
* returns the current status * returns the current status
*/ */
@ -996,28 +892,29 @@ inline void TMC26XStepper::send262(unsigned long datagram) {
//ensure that only valid bist are set (0-19) //ensure that only valid bist are set (0-19)
//datagram &=REGISTER_BIT_PATTERN; //datagram &=REGISTER_BIT_PATTERN;
#ifdef TMC_DEBUG1 #ifdef TMC_DEBUG1
//SERIAL_PRINTF("Sending "); //SERIAL_PRINTF("Sending ");
//SERIAL_PRINTF("Sending ", datagram,HEX); //SERIAL_PRINTF("Sending ", datagram,HEX);
//SERIAL_ECHOPAIR("\n\nSending \n", print_hex_long(datagram)); //SERIAL_ECHOPAIR("\n\nSending \n", print_hex_long(datagram));
SERIAL_PRINTF("\n\nSending %x", datagram); SERIAL_PRINTF("\n\nSending %x", datagram);
#endif #endif
//write/read the values //write/read the values
i_datagram = STEPPER_SPI.transfer((datagram >> 16) & 0xff); i_datagram = STEPPER_SPI.transfer((datagram >> 16) & 0xFF);
i_datagram <<= 8; i_datagram <<= 8;
i_datagram |= STEPPER_SPI.transfer((datagram >> 8) & 0xff); i_datagram |= STEPPER_SPI.transfer((datagram >> 8) & 0xFF);
i_datagram <<= 8; i_datagram <<= 8;
i_datagram |= STEPPER_SPI.transfer((datagram) & 0xff); i_datagram |= STEPPER_SPI.transfer((datagram) & 0xFF);
i_datagram >>= 4; i_datagram >>= 4;
#ifdef TMC_DEBUG1 #ifdef TMC_DEBUG1
//SERIAL_PRINTF("Received "); //SERIAL_PRINTF("Received ");
//SERIAL_PRINTF("Received ", i_datagram,HEX); //SERIAL_PRINTF("Received ", i_datagram,HEX);
//SERIAL_ECHOPAIR("\n\nReceived \n", i_datagram); //SERIAL_ECHOPAIR("\n\nReceived \n", i_datagram);
SERIAL_PRINTF("\n\nReceived %x", i_datagram); SERIAL_PRINTF("\n\nReceived %x", i_datagram);
debugLastStatus(); debugLastStatus();
#endif #endif
//deselect the TMC chip //deselect the TMC chip
digitalWrite(cs_pin,HIGH); digitalWrite(cs_pin,HIGH);
@ -1027,7 +924,6 @@ inline void TMC26XStepper::send262(unsigned long datagram) {
// SPI.setDataMode(oldMode); // SPI.setDataMode(oldMode);
//} //}
//store the datagram as status result //store the datagram as status result
driver_status_result = i_datagram; driver_status_result = i_datagram;
} }

93
Marlin/src/HAL/HAL_STM32F7/TMC2660.h
View file

@ -1,37 +1,35 @@
/* /**
TMC26XStepper.cpp - - TMC26X Stepper library for Wiring/Arduino * TMC26XStepper.h - - TMC26X Stepper library for Wiring/Arduino
*
based on the stepper library by Tom Igoe, et. al. * based on the stepper library by Tom Igoe, et. al.
*
Copyright (c) 2011, Interactive Matter, Marcus Nowotny * Copyright (c) 2011, Interactive Matter, Marcus Nowotny
*
Permission is hereby granted, free of charge, to any person obtaining a copy * Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal * of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights * in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is * copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions: * furnished to do so, subject to the following conditions:
*
The above copyright notice and this permission notice shall be included in * The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software. * all copies or substantial portions of the Software.
*
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE. * THE SOFTWARE.
*
*/ */
#include "../../inc/MarlinConfig.h" #include "../../inc/MarlinConfig.h"
// ensure this library description is only included once // ensure this library description is only included once
#ifndef TMC26XStepper_h #ifndef _TMC26XSTEPPER_H_
#define TMC26XStepper_h #define _TMC26XSTEPPER_H_
//! return value for TMC26XStepper.getOverTemperature() if there is a overtemperature situation in the TMC chip //! return value for TMC26XStepper.getOverTemperature() if there is a overtemperature situation in the TMC chip
/*! /*!
@ -568,43 +566,42 @@ class TMC26XStepper {
int version(void); int version(void);
private: private:
unsigned int steps_left; //the steps the motor has to do to complete the movement unsigned int steps_left; // The steps the motor has to do to complete the movement
int direction; // Direction of rotation int direction; // Direction of rotation
unsigned long step_delay; // delay between steps, in ms, based on speed unsigned long step_delay; // Delay between steps, in ms, based on speed
int number_of_steps; // total number of steps this motor can take int number_of_steps; // Total number of steps this motor can take
unsigned int speed; // we need to store the current speed in order to change the speed after changing microstepping unsigned int speed; // Store the current speed in order to change the speed after changing microstepping
unsigned int resistor; //current sense resitor value in milliohm unsigned int resistor; // Current sense resitor value in milliohm
unsigned long last_step_time; // time stamp in ms of when the last step was taken unsigned long last_step_time; // Time stamp in ms of when the last step was taken
unsigned long next_step_time; // time stamp in ms of when the last step was taken unsigned long next_step_time; // Time stamp in ms of when the last step was taken
//driver control register copies to easily set & modify the registers // Driver control register copies to easily set & modify the registers
unsigned long driver_control_register_value; unsigned long driver_control_register_value;
unsigned long chopper_config_register; unsigned long chopper_config_register;
unsigned long cool_step_register_value; unsigned long cool_step_register_value;
unsigned long stall_guard2_current_register_value; unsigned long stall_guard2_current_register_value;
unsigned long driver_configuration_register_value; unsigned long driver_configuration_register_value;
//the driver status result // The driver status result
unsigned long driver_status_result; unsigned long driver_status_result;
//helper routione to get the top 10 bit of the readout // Helper routione to get the top 10 bit of the readout
inline int getReadoutValue(); inline int getReadoutValue();
//the pins for the stepper driver // The pins for the stepper driver
unsigned char cs_pin; unsigned char cs_pin;
unsigned char step_pin; unsigned char step_pin;
unsigned char dir_pin; unsigned char dir_pin;
//status values // Status values
boolean started; //if the stepper has been started yet boolean started; // If the stepper has been started yet
int microsteps; //the current number of micro steps int microsteps; // The current number of micro steps
char constant_off_time; //we need to remember this value in order to enable and disable the motor char constant_off_time; // We need to remember this value in order to enable and disable the motor
unsigned char cool_step_lower_threshold; // we need to remember the threshold to enable and disable the CoolStep feature unsigned char cool_step_lower_threshold; // we need to remember the threshold to enable and disable the CoolStep feature
boolean cool_step_enabled; //we need to remember this to configure the coolstep if it si enabled boolean cool_step_enabled; // We need to remember this to configure the coolstep if it si enabled
//SPI sender // SPI sender
inline void send262(unsigned long datagram); inline void send262(unsigned long datagram);
}; };
#endif #endif // _TMC26XSTEPPER_H_

2
Marlin/src/HAL/HAL_STM32F7/fastio_STM32F7.h
View file

@ -51,4 +51,4 @@
#define OUT_WRITE(IO, v) { _SET_OUTPUT(IO); WRITE(IO, v); } #define OUT_WRITE(IO, v) { _SET_OUTPUT(IO); WRITE(IO, v); }
#endif /* _FASTIO_STM32F7_H */ #endif // _FASTIO_STM32F7_H

47
Marlin/src/HAL/HAL_STM32F7/watchdog_STM32F7.cpp
View file

@ -1,24 +1,24 @@
/** /**
* Marlin 3D Printer Firmware * Marlin 3D Printer Firmware
* Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin] * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
* *
* Based on Sprinter and grbl. * Based on Sprinter and grbl.
* Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
* *
* This program is free software: you can redistribute it and/or modify * 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 * it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or * the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version. * (at your option) any later version.
* *
* This program is distributed in the hope that it will be useful, * This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
* *
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>. * along with this program. If not, see <http://www.gnu.org/licenses/>.
* *
*/ */
#ifdef STM32F7 #ifdef STM32F7
@ -34,22 +34,19 @@
hiwdg.Instance = IWDG; hiwdg.Instance = IWDG;
hiwdg.Init.Prescaler = IWDG_PRESCALER_32; //32kHz LSI clock and 32x prescalar = 1024Hz IWDG clock 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 hiwdg.Init.Reload = 4095; //4095 counts = 4 seconds at 1024Hz
if (HAL_IWDG_Init(&hiwdg) != HAL_OK) if (HAL_IWDG_Init(&hiwdg) != HAL_OK) {
{
//Error_Handler(); //Error_Handler();
} }
} }
void watchdog_reset() { void watchdog_reset() {
/* Refresh IWDG: reload counter */ /* Refresh IWDG: reload counter */
if (HAL_IWDG_Refresh(&hiwdg) != HAL_OK) if (HAL_IWDG_Refresh(&hiwdg) != HAL_OK) {
{
/* Refresh Error */ /* Refresh Error */
//Error_Handler(); //Error_Handler();
} }
} }
#endif // USE_WATCHDOG #endif // USE_WATCHDOG
#endif // STM32F7 #endif // STM32F7

2
Marlin/src/HAL/HAL_SanityCheck.h
View file

@ -40,7 +40,7 @@
#elif defined(STM32F7) #elif defined(STM32F7)
#include "HAL_STM32F7/SanityCheck_STM32F7.h" #include "HAL_STM32F7/SanityCheck_STM32F7.h"
#else #else
#error Unsupported Platform! #error Unsupported Platform!
#endif #endif

2
Marlin/src/HAL/HAL_spi_pins.h
View file

@ -41,7 +41,7 @@
#elif defined(STM32F7) #elif defined(STM32F7)
#include "HAL_STM32F7/spi_pins.h" #include "HAL_STM32F7/spi_pins.h"
#else #else
#error "Unsupported Platform!" #error "Unsupported Platform!"
#endif #endif

1
Marlin/src/core/macros.h
View file

@ -120,6 +120,7 @@
// Macros to contrain values // Macros to contrain values
#define NOLESS(v,n) do{ if (v < n) v = n; }while(0) #define NOLESS(v,n) do{ if (v < n) v = n; }while(0)
#define NOMORE(v,n) do{ if (v > n) v = n; }while(0) #define NOMORE(v,n) do{ if (v > n) v = n; }while(0)
#define LIMIT(v,n1,n2) do{ if (v < n1) v = n1; else if (v > n2) v = n2; }while(0)
// Macros to support option testing // Macros to support option testing
#define _CAT(a, ...) a ## __VA_ARGS__ #define _CAT(a, ...) a ## __VA_ARGS__

2
Marlin/src/module/stepper_indirection.cpp
View file

@ -42,7 +42,7 @@
#include <SPI.h> #include <SPI.h>
#if defined(STM32F7) #ifdef STM32F7
#include "../HAL/HAL_STM32F7/TMC2660.h" #include "../HAL/HAL_STM32F7/TMC2660.h"
#else #else
#include <TMC26XStepper.h> #include <TMC26XStepper.h>

2
Marlin/src/module/stepper_indirection.h
View file

@ -49,7 +49,7 @@
// TMC26X drivers have STEP/DIR on normal pins, but ENABLE via SPI // TMC26X drivers have STEP/DIR on normal pins, but ENABLE via SPI
#if ENABLED(HAVE_TMCDRIVER) #if ENABLED(HAVE_TMCDRIVER)
#include <SPI.h> #include <SPI.h>
#if defined(STM32F7) #ifdef STM32F7
#include "../HAL/HAL_STM32F7/TMC2660.h" #include "../HAL/HAL_STM32F7/TMC2660.h"
#else #else
#include <TMC26XStepper.h> #include <TMC26XStepper.h>