wip

workspace/.metadata/.plugins/org.eclipse.cdt.core/.log

@@ -32,3 +32,5 @@
 *** SESSION mag 04, 2026 23:04:27.645 ------------------------------------------
 *** SESSION mag 05, 2026 22:49:18.92 -------------------------------------------
 *** SESSION mag 14, 2026 17:57:36.107 ------------------------------------------
+*** SESSION mag 15, 2026 18:08:46.927 ------------------------------------------
+*** SESSION mag 15, 2026 19:11:28.596 ------------------------------------------

workspace/.metadata/.plugins/org.eclipse.cdt.ui/AUTOM10.build.log

@@ -1,4 +1,4 @@
-19:42:02 **** Incremental Build of configuration Debug for project AUTOM10 ****
+19:11:41 **** Incremental Build of configuration Debug for project AUTOM10 ****
 make -j12 all 
 arm-none-eabi-size  AUTOM10.elf 
    text	   data	    bss	    dec	    hex	filename
@@ -6,5 +6,5 @@ arm-none-eabi-size  AUTOM10.elf
 Finished building: default.size.stdout
  
 
-19:42:02 Build Finished. 0 errors, 0 warnings. (took 187ms)
+19:11:42 Build Finished. 0 errors, 0 warnings. (took 655ms)
 

workspace/.metadata/.plugins/org.eclipse.cdt.ui/global-build.log

@@ -1,6 +1,6 @@
-19:41:57 **** Incremental Build of configuration Debug for project AUTOM10 ****
+19:03:59 **** Incremental Build of configuration Debug for project AUTOM10 ****
 make -j12 all 
-arm-none-eabi-gcc "../Core/Src/pwm.c" -mcpu=cortex-m3 -std=gnu11 -g3 -DDEBUG -DUSE_HAL_DRIVER -DSTM32F103xB -c -I../Core/Inc -I../Drivers/STM32F1xx_HAL_Driver/Inc/Legacy -I../Drivers/STM32F1xx_HAL_Driver/Inc -I../Drivers/CMSIS/Device/ST/STM32F1xx/Include -I../Drivers/CMSIS/Include -I../USB_DEVICE/App -I../USB_DEVICE/Target -I../Middlewares/ST/STM32_USB_Device_Library/Core/Inc -I../Middlewares/ST/STM32_USB_Device_Library/Class/CDC/Inc -O0 -ffunction-sections -fdata-sections -Wall -fstack-usage -fcyclomatic-complexity -MMD -MP -MF"Core/Src/pwm.d" -MT"Core/Src/pwm.o" --specs=nano.specs -mfloat-abi=soft -mthumb -o "Core/Src/pwm.o"
+arm-none-eabi-gcc "../Core/Src/eeprom.c" -mcpu=cortex-m3 -std=gnu11 -g3 -DDEBUG -DUSE_HAL_DRIVER -DSTM32F103xB -c -I../Core/Inc -I../Drivers/STM32F1xx_HAL_Driver/Inc/Legacy -I../Drivers/STM32F1xx_HAL_Driver/Inc -I../Drivers/CMSIS/Device/ST/STM32F1xx/Include -I../Drivers/CMSIS/Include -I../USB_DEVICE/App -I../USB_DEVICE/Target -I../Middlewares/ST/STM32_USB_Device_Library/Core/Inc -I../Middlewares/ST/STM32_USB_Device_Library/Class/CDC/Inc -O0 -ffunction-sections -fdata-sections -Wall -fstack-usage -fcyclomatic-complexity -MMD -MP -MF"Core/Src/eeprom.d" -MT"Core/Src/eeprom.o" --specs=nano.specs -mfloat-abi=soft -mthumb -o "Core/Src/eeprom.o"
 arm-none-eabi-gcc -o "AUTOM10.elf" @"objects.list"   -mcpu=cortex-m3 -T"C:\progetti\AUTOM\workspace\AUTOM10\STM32F103C8TX_FLASH.ld" --specs=nosys.specs -Wl,-Map="AUTOM10.map" -Wl,--gc-sections -static --specs=nano.specs -mfloat-abi=soft -mthumb -Wl,--start-group -lc -lm -Wl,--end-group
 Finished building target: AUTOM10.elf
  
@@ -12,7 +12,14 @@ Finished building: default.size.stdout
  
 Finished building: AUTOM10.list
  
-19:42:02 **** Incremental Build of configuration Debug for project AUTOM10 ****
+19:04:33 **** Incremental Build of configuration Debug for project AUTOM10 ****
+make -j12 all 
+arm-none-eabi-size  AUTOM10.elf 
+   text	   data	    bss	    dec	    hex	filename
+  60652	    476	   7360	  68488	  10b88	AUTOM10.elf
+Finished building: default.size.stdout
+ 
+19:11:41 **** Incremental Build of configuration Debug for project AUTOM10 ****
 make -j12 all 
 arm-none-eabi-size  AUTOM10.elf 
    text	   data	    bss	    dec	    hex	filename

workspace/.metadata/.plugins/org.eclipse.core.resources/.history/2/70351e9e7d50001117a8e64d4a083793

@@ -0,0 +1,396 @@
+/*
+ * mot.c
+ *
+ *  Created on: May 2, 2026
+ *      Author: user
+ */
+#include <stdio.h>
+#include <string.h>
+#include "main.h"
+#include "mot.h"
+#include "pwm.h"
+
+extern uint16_t apM1start;
+extern uint16_t apM1stop;
+extern uint16_t apM2start;
+extern uint16_t apM2stop;
+extern uint16_t apM3start;
+extern uint16_t apM3stop;
+extern uint16_t apM4start;
+extern uint16_t apM4stop;
+extern uint16_t chM1start;
+extern uint16_t chM1stop;
+extern uint16_t chM2start;
+extern uint16_t chM2stop;
+extern uint16_t chM3start;
+extern uint16_t chM3stop;
+extern uint16_t chM4start;
+extern uint16_t chM4stop;
+extern volatile uint16_t rtCiclo;
+extern uint16_t m1pwmap;
+extern uint16_t m1pwmch;
+extern uint16_t m2pwmap;
+extern uint16_t m2pwmch;
+extern uint16_t m3pwmap;
+extern uint16_t m3pwmch;
+extern uint16_t m4pwmap;
+extern uint16_t m4pwmch;
+extern uint16_t mrampstart[4];
+extern uint16_t tramp;
+
+extern UART_HandleTypeDef huart1;
+
+motMov_st m1ap(void){
+	static motMov_st m1st=motWaiting;
+	static motMov_st memm1st=motStop;
+	char s[100];
+	if(memm1st!=m1st){
+		memm1st=m1st;
+		sprintf(s,"\nm1ap=%d",m1st);
+		HAL_UART_Transmit(&huart1,(uint8_t*) s, strlen(s), HAL_MAX_DELAY);
+	}
+	if(rtCiclo<apM1start)m1st=motWaiting;
+	switch(m1st){
+		case motWaiting:
+			SetMotPerc(M1,FW,0);
+			SetMotPerc(M1,BW,0);
+			if(rtCiclo>=apM1start){
+				(void)ramp(M1,FW,mrampstart[M1-1],m1pwmap,tramp,RAMPINIT);
+				m1st=motStartRamp;
+			}
+			break;
+		case motStartRamp:
+			if(ramp(M1,FW,mrampstart[M1-1],m1pwmap,tramp,RAMPRUN)==DONE){
+				m1st=motWaitingTime;
+			}
+			break;
+		case motWaitingTime:
+			if(rtCiclo>=apM1stop){
+				(void)ramp(M1,FW,m1pwmap,0,tramp,RAMPINIT);
+				m1st=motStopRamp;
+			}
+			break;
+		case motStopRamp:
+			if(ramp(M1,FW,m1pwmap,0,tramp,RAMPRUN)==DONE){
+				m1st=motStop;
+			}
+			break;
+		case motStop:
+		default:
+			SetMotPerc(M1,FW,0);
+			SetMotPerc(M1,BW,0);
+		break;
+	}
+	return m1st;
+}
+
+motMov_st m2ap(void){
+	static motMov_st m2st;
+	static motMov_st memm2st=motStop;
+	char s[100];
+	if(memm2st!=m2st){
+		memm2st=m2st;
+		sprintf(s,"\nm2ap=%d",m2st);
+		HAL_UART_Transmit(&huart1,(uint8_t*) s, strlen(s), HAL_MAX_DELAY);
+	}
+	if(rtCiclo<apM2start)m2st=motWaiting;
+	switch(m2st){
+		case motWaiting:
+			SetMotPerc(M2,FW,0);
+			SetMotPerc(M2,BW,0);
+			if(rtCiclo>=apM2start){
+				(void)ramp(M2,BW,mrampstart[M2-1],m2pwmap,tramp,RAMPINIT);
+				m2st=motStartRamp;
+			}
+			break;
+		case motStartRamp:
+			if(ramp(M2,BW,mrampstart[M2-1],m2pwmap,tramp,RAMPRUN)==DONE){
+				m2st=motWaitingTime;
+			}
+			break;
+		case motWaitingTime:
+			if(rtCiclo>=apM2stop){
+				(void)ramp(M2,BW,m2pwmap,0,tramp,RAMPINIT);
+				m2st=motStopRamp;
+			}
+			break;
+		case motStopRamp:
+			if(ramp(M2,BW,m2pwmap,0,tramp,RAMPRUN)==DONE){
+				m2st=motStop;
+			}
+			break;
+		case motStop:
+		default:
+			SetMotPerc(M2,FW,0);
+			SetMotPerc(M2,BW,0);
+		break;
+	}
+	return m2st;
+}
+
+motMov_st m3ap(void){
+	static motMov_st m3st;
+	static motMov_st memm3st=motStop;
+	char s[100];
+	if(memm3st!=m3st){
+		memm3st=m3st;
+		sprintf(s,"\nm3ap=%d",m3st);
+		HAL_UART_Transmit(&huart1,(uint8_t*) s, strlen(s), HAL_MAX_DELAY);
+	}
+	if(rtCiclo<apM3start)m3st=motWaiting;
+	switch(m3st){
+		case motWaiting:
+			SetMotPerc(M3,FW,0);
+			SetMotPerc(M3,BW,0);
+			if(rtCiclo>=apM3start){
+				(void)ramp(M3,FW,mrampstart[M3-1],m2pwmap,tramp,RAMPINIT);
+				m3st=motStartRamp;
+			}
+			break;
+		case motStartRamp:
+			if(ramp(M3,FW,mrampstart[M3-1],m3pwmap,tramp,RAMPRUN)==DONE){
+				m3st=motWaitingTime;
+			}
+			break;
+		case motWaitingTime:
+			if(rtCiclo>=apM3stop){
+				(void)ramp(M3,FW,m3pwmap,0,tramp,RAMPINIT);
+				m3st=motStopRamp;
+			}
+			break;
+		case motStopRamp:
+			if(ramp(M3,FW,m3pwmap,0,tramp,RAMPRUN)==DONE){
+				m3st=motStop;
+			}
+			break;
+		case motStop:
+		default:
+			SetMotPerc(M3,FW,0);
+			SetMotPerc(M3,BW,0);
+		break;
+	}
+	return m3st;
+}
+
+motMov_st m4ap(void){
+	static motMov_st m4st;
+	static motMov_st memm4st=motStop;
+	char s[100];
+	if(memm4st!=m4st){
+		memm4st=m4st;
+		sprintf(s,"\nm4ap=%d",m4st);
+		HAL_UART_Transmit(&huart1,(uint8_t*) s, strlen(s), HAL_MAX_DELAY);
+	}
+	if(rtCiclo<apM4start)m4st=motWaiting;
+	switch(m4st){
+		case motWaiting:
+			SetMotPerc(M4,FW,0);
+			SetMotPerc(M4,BW,0);
+			if(rtCiclo>=apM4start){
+				(void)ramp(M4,BW,mrampstart[M4-1],m2pwmap,tramp,RAMPINIT);
+				m4st=motStartRamp;
+			}
+			break;
+		case motStartRamp:
+			if(ramp(M4,BW,mrampstart[M4-1],m4pwmap,tramp,RAMPRUN)==DONE){
+				m4st=motWaitingTime;
+			}
+			break;
+		case motWaitingTime:
+			if(rtCiclo>=apM4stop){
+				(void)ramp(M4,BW,m4pwmap,0,tramp,RAMPINIT);
+				m4st=motStopRamp;
+			}
+			break;
+		case motStopRamp:
+			if(ramp(M4,BW,m4pwmap,0,tramp,RAMPRUN)==DONE){
+				m4st=motStop;
+			}
+			break;
+		case motStop:
+		default:
+			SetMotPerc(M4,FW,0);
+			SetMotPerc(M4,BW,0);
+		break;
+	}
+	return m4st;
+}
+
+motMov_st m1ch(void){
+	static motMov_st m1st;
+	static motMov_st memm1st=motStop;
+	char s[100];
+	if(memm1st!=m1st){
+		memm1st=m1st;
+		sprintf(s,"\nm1ch=%d",m1st);
+		HAL_UART_Transmit(&huart1,(uint8_t*) s, strlen(s), HAL_MAX_DELAY);
+	}
+	if(rtCiclo<chM1start)m1st=motWaiting;
+	switch(m1st){
+		case motWaiting:
+			SetMotPerc(M1,FW,0);
+			SetMotPerc(M1,BW,0);
+			if(rtCiclo>=chM1start){
+				(void)ramp(M1,BW,mrampstart[M1-1],m1pwmch,tramp,RAMPINIT);
+				m1st=motStartRamp;
+			}
+			break;
+		case motStartRamp:
+			if(ramp(M1,BW,mrampstart[M1-1],m1pwmch,tramp,RAMPRUN)==DONE){
+				m1st=motWaitingTime;
+			}
+			break;
+		case motWaitingTime:
+			if(rtCiclo>=chM1stop){
+				(void)ramp(M1,BW,m1pwmch,0,tramp,RAMPINIT);
+				m1st=motStopRamp;
+			}
+			break;
+		case motStopRamp:
+			if(ramp(M1,BW,m1pwmch,0,tramp,RAMPRUN)==DONE){
+				m1st=motStop;
+			}
+			break;
+		case motStop:
+		default:
+			SetMotPerc(M1,FW,0);
+			SetMotPerc(M1,BW,0);
+		break;
+	}
+	return m1st;
+}
+
+motMov_st m2ch(void){
+	static motMov_st m2st;
+	static motMov_st memm2st=motStop;
+	char s[100];
+	if(memm2st!=m2st){
+		memm2st=m2st;
+		sprintf(s,"\nm2ch=%d",m2st);
+		HAL_UART_Transmit(&huart1,(uint8_t*) s, strlen(s), HAL_MAX_DELAY);
+	}
+
+	if(rtCiclo<chM2start)m2st=motWaiting;
+	switch(m2st){
+		case motWaiting:
+			SetMotPerc(M2,FW,0);
+			SetMotPerc(M2,BW,0);
+			if(rtCiclo>=chM2start){
+				(void)ramp(M2,FW,mrampstart[M2-1],m2pwmch,tramp,RAMPINIT);
+				m2st=motStartRamp;
+			}
+			break;
+		case motStartRamp:
+			if(ramp(M2,FW,mrampstart[M2-1],m2pwmch,tramp,RAMPRUN)==DONE){
+				m2st=motWaitingTime;
+			}
+			break;
+		case motWaitingTime:
+			if(rtCiclo>=chM2stop){
+				(void)ramp(M2,FW,m2pwmch,0,tramp,RAMPINIT);
+				m2st=motStopRamp;
+			}
+			break;
+		case motStopRamp:
+			if(ramp(M2,FW,m2pwmch,0,tramp,RAMPRUN)==DONE){
+				m2st=motStop;
+			}
+			break;
+		case motStop:
+		default:
+			SetMotPerc(M2,FW,0);
+			SetMotPerc(M2,BW,0);
+		break;
+	}
+	return m2st;
+}
+
+motMov_st m3ch(void){
+	static motMov_st m3st;
+	static motMov_st memm3st=motStop;
+	char s[100];
+	if(memm3st!=m3st){
+		memm3st=m3st;
+		sprintf(s,"\nm3ch=%d",m3st);
+		HAL_UART_Transmit(&huart1,(uint8_t*) s, strlen(s), HAL_MAX_DELAY);
+	}
+
+	if(rtCiclo<chM3start)m3st=motWaiting;
+	switch(m3st){
+		case motWaiting:
+			SetMotPerc(M3,FW,0);
+			SetMotPerc(M3,BW,0);
+			if(rtCiclo>=chM3start){
+				(void)ramp(M3,BW,mrampstart[M3-1],m2pwmch,tramp,RAMPINIT);
+				m3st=motStartRamp;
+			}
+			break;
+		case motStartRamp:
+			if(ramp(M3,BW,mrampstart[M3-1],m3pwmch,tramp,RAMPRUN)==DONE){
+				m3st=motWaitingTime;
+			}
+			break;
+		case motWaitingTime:
+			if(rtCiclo>=chM3stop){
+				(void)ramp(M3,BW,m3pwmch,0,tramp,RAMPINIT);
+				m3st=motStopRamp;
+			}
+			break;
+		case motStopRamp:
+			if(ramp(M3,BW,m3pwmch,0,tramp,RAMPRUN)==DONE){
+				m3st=motStop;
+			}
+			break;
+		case motStop:
+		default:
+			SetMotPerc(M3,FW,0);
+			SetMotPerc(M3,BW,0);
+		break;
+	}
+	return m3st;
+}
+
+motMov_st m4ch(void){
+	static motMov_st m4st;
+	static motMov_st memm4st=motStop;
+	char s[100];
+	if(memm4st!=m4st){
+		memm4st=m4st;
+		sprintf(s,"\nm4ch=%d",m4st);
+		HAL_UART_Transmit(&huart1,(uint8_t*) s, strlen(s), HAL_MAX_DELAY);
+	}
+
+	if(rtCiclo<chM4start)m4st=motWaiting;
+	switch(m4st){
+		case motWaiting:
+			SetMotPerc(M4,FW,0);
+			SetMotPerc(M4,BW,0);
+			if(rtCiclo>=chM4start){
+				(void)ramp(M4,FW,mrampstart[M4-1],m4pwmch,tramp,RAMPINIT);
+				m4st=motStartRamp;
+			}
+			break;
+		case motStartRamp:
+			if(ramp(M4,FW,mrampstart[M4-1],m4pwmch,tramp,RAMPRUN)==DONE){
+				m4st=motWaitingTime;
+			}
+			break;
+		case motWaitingTime:
+			if(rtCiclo>=chM4stop){
+				(void)ramp(M4,FW,m4pwmch,0,tramp,RAMPINIT);
+				m4st=motStopRamp;
+			}
+			break;
+		case motStopRamp:
+			if(ramp(M4,FW,m4pwmch,0,tramp,RAMPRUN)==DONE){
+				m4st=motStop;
+			}
+			break;
+		case motStop:
+		default:
+			SetMotPerc(M4,FW,0);
+			SetMotPerc(M4,BW,0);
+		break;
+	}
+	return m4st;
+}

workspace/.metadata/.plugins/org.eclipse.core.resources/.history/27/403cb7177b50001117a8e64d4a083793

@@ -0,0 +1,396 @@
+/*
+ * mot.c
+ *
+ *  Created on: May 2, 2026
+ *      Author: user
+ */
+#include <stdio.h>
+#include <string.h>
+#include "main.h"
+#include "mot.h"
+#include "pwm.h"
+
+extern uint16_t apM1start;
+extern uint16_t apM1stop;
+extern uint16_t apM2start;
+extern uint16_t apM2stop;
+extern uint16_t apM3start;
+extern uint16_t apM3stop;
+extern uint16_t apM4start;
+extern uint16_t apM4stop;
+extern uint16_t chM1start;
+extern uint16_t chM1stop;
+extern uint16_t chM2start;
+extern uint16_t chM2stop;
+extern uint16_t chM3start;
+extern uint16_t chM3stop;
+extern uint16_t chM4start;
+extern uint16_t chM4stop;
+extern volatile uint16_t rtCiclo;
+extern uint16_t m1pwmap;
+extern uint16_t m1pwmch;
+extern uint16_t m2pwmap;
+extern uint16_t m2pwmch;
+extern uint16_t m3pwmap;
+extern uint16_t m3pwmch;
+extern uint16_t m4pwmap;
+extern uint16_t m4pwmch;
+extern uint16_t mrampstart[4];
+extern uint16_t tramp;
+
+extern UART_HandleTypeDef huart1;
+
+motMov_st m1ap(void){
+	static motMov_st m1st=motWaiting;
+	static motMov_st memm1st=motStop;
+	char s[100];
+	if(memm1st!=m1st){
+		memm1st=m1st;
+		sprintf(s,"\nm1ap=%d",m1st);
+		HAL_UART_Transmit(&huart1,(uint8_t*) s, strlen(s), HAL_MAX_DELAY);
+	}
+	if(rtCiclo<apM1start)m1st=motWaiting;
+	switch(m1st){
+		case motWaiting:
+			SetMotPerc(M1,FW,0);
+			SetMotPerc(M1,BW,0);
+			if(rtCiclo>=apM1start){
+				(void)ramp(M1,BW,mrampstart[M1-1],m1pwmap,tramp,RAMPINIT);
+				m1st=motStartRamp;
+			}
+			break;
+		case motStartRamp:
+			if(ramp(M1,BW,mrampstart[M1-1],m1pwmap,tramp,RAMPRUN)==DONE){
+				m1st=motWaitingTime;
+			}
+			break;
+		case motWaitingTime:
+			if(rtCiclo>=apM1stop){
+				(void)ramp(M1,BW,m1pwmap,0,tramp,RAMPINIT);
+				m1st=motStopRamp;
+			}
+			break;
+		case motStopRamp:
+			if(ramp(M1,BW,m1pwmap,0,tramp,RAMPRUN)==DONE){
+				m1st=motStop;
+			}
+			break;
+		case motStop:
+		default:
+			SetMotPerc(M1,FW,0);
+			SetMotPerc(M1,BW,0);
+		break;
+	}
+	return m1st;
+}
+
+motMov_st m2ap(void){
+	static motMov_st m2st;
+	static motMov_st memm2st=motStop;
+	char s[100];
+	if(memm2st!=m2st){
+		memm2st=m2st;
+		sprintf(s,"\nm2ap=%d",m2st);
+		HAL_UART_Transmit(&huart1,(uint8_t*) s, strlen(s), HAL_MAX_DELAY);
+	}
+	if(rtCiclo<apM2start)m2st=motWaiting;
+	switch(m2st){
+		case motWaiting:
+			SetMotPerc(M2,FW,0);
+			SetMotPerc(M2,BW,0);
+			if(rtCiclo>=apM2start){
+				(void)ramp(M2,BW,mrampstart[M2-1],m2pwmap,tramp,RAMPINIT);
+				m2st=motStartRamp;
+			}
+			break;
+		case motStartRamp:
+			if(ramp(M2,BW,mrampstart[M2-1],m2pwmap,tramp,RAMPRUN)==DONE){
+				m2st=motWaitingTime;
+			}
+			break;
+		case motWaitingTime:
+			if(rtCiclo>=apM2stop){
+				(void)ramp(M2,BW,m2pwmap,0,tramp,RAMPINIT);
+				m2st=motStopRamp;
+			}
+			break;
+		case motStopRamp:
+			if(ramp(M2,BW,m2pwmap,0,tramp,RAMPRUN)==DONE){
+				m2st=motStop;
+			}
+			break;
+		case motStop:
+		default:
+			SetMotPerc(M2,FW,0);
+			SetMotPerc(M2,BW,0);
+		break;
+	}
+	return m2st;
+}
+
+motMov_st m3ap(void){
+	static motMov_st m3st;
+	static motMov_st memm3st=motStop;
+	char s[100];
+	if(memm3st!=m3st){
+		memm3st=m3st;
+		sprintf(s,"\nm3ap=%d",m3st);
+		HAL_UART_Transmit(&huart1,(uint8_t*) s, strlen(s), HAL_MAX_DELAY);
+	}
+	if(rtCiclo<apM3start)m3st=motWaiting;
+	switch(m3st){
+		case motWaiting:
+			SetMotPerc(M3,FW,0);
+			SetMotPerc(M3,BW,0);
+			if(rtCiclo>=apM3start){
+				(void)ramp(M3,BW,mrampstart[M3-1],m2pwmap,tramp,RAMPINIT);
+				m3st=motStartRamp;
+			}
+			break;
+		case motStartRamp:
+			if(ramp(M3,BW,mrampstart[M3-1],m3pwmap,tramp,RAMPRUN)==DONE){
+				m3st=motWaitingTime;
+			}
+			break;
+		case motWaitingTime:
+			if(rtCiclo>=apM3stop){
+				(void)ramp(M3,BW,m3pwmap,0,tramp,RAMPINIT);
+				m3st=motStopRamp;
+			}
+			break;
+		case motStopRamp:
+			if(ramp(M3,BW,m3pwmap,0,tramp,RAMPRUN)==DONE){
+				m3st=motStop;
+			}
+			break;
+		case motStop:
+		default:
+			SetMotPerc(M3,FW,0);
+			SetMotPerc(M3,BW,0);
+		break;
+	}
+	return m3st;
+}
+
+motMov_st m4ap(void){
+	static motMov_st m4st;
+	static motMov_st memm4st=motStop;
+	char s[100];
+	if(memm4st!=m4st){
+		memm4st=m4st;
+		sprintf(s,"\nm4ap=%d",m4st);
+		HAL_UART_Transmit(&huart1,(uint8_t*) s, strlen(s), HAL_MAX_DELAY);
+	}
+	if(rtCiclo<apM4start)m4st=motWaiting;
+	switch(m4st){
+		case motWaiting:
+			SetMotPerc(M4,FW,0);
+			SetMotPerc(M4,BW,0);
+			if(rtCiclo>=apM4start){
+				(void)ramp(M4,BW,mrampstart[M4-1],m2pwmap,tramp,RAMPINIT);
+				m4st=motStartRamp;
+			}
+			break;
+		case motStartRamp:
+			if(ramp(M4,BW,mrampstart[M4-1],m4pwmap,tramp,RAMPRUN)==DONE){
+				m4st=motWaitingTime;
+			}
+			break;
+		case motWaitingTime:
+			if(rtCiclo>=apM4stop){
+				(void)ramp(M4,BW,m4pwmap,0,tramp,RAMPINIT);
+				m4st=motStopRamp;
+			}
+			break;
+		case motStopRamp:
+			if(ramp(M4,BW,m4pwmap,0,tramp,RAMPRUN)==DONE){
+				m4st=motStop;
+			}
+			break;
+		case motStop:
+		default:
+			SetMotPerc(M4,FW,0);
+			SetMotPerc(M4,BW,0);
+		break;
+	}
+	return m4st;
+}
+
+motMov_st m1ch(void){
+	static motMov_st m1st;
+	static motMov_st memm1st=motStop;
+	char s[100];
+	if(memm1st!=m1st){
+		memm1st=m1st;
+		sprintf(s,"\nm1ch=%d",m1st);
+		HAL_UART_Transmit(&huart1,(uint8_t*) s, strlen(s), HAL_MAX_DELAY);
+	}
+	if(rtCiclo<chM1start)m1st=motWaiting;
+	switch(m1st){
+		case motWaiting:
+			SetMotPerc(M1,FW,0);
+			SetMotPerc(M1,BW,0);
+			if(rtCiclo>=chM1start){
+				(void)ramp(M1,FW,mrampstart[M1-1],m1pwmch,tramp,RAMPINIT);
+				m1st=motStartRamp;
+			}
+			break;
+		case motStartRamp:
+			if(ramp(M1,FW,mrampstart[M1-1],m1pwmch,tramp,RAMPRUN)==DONE){
+				m1st=motWaitingTime;
+			}
+			break;
+		case motWaitingTime:
+			if(rtCiclo>=chM1stop){
+				(void)ramp(M1,FW,m1pwmch,0,tramp,RAMPINIT);
+				m1st=motStopRamp;
+			}
+			break;
+		case motStopRamp:
+			if(ramp(M1,FW,m1pwmch,0,tramp,RAMPRUN)==DONE){
+				m1st=motStop;
+			}
+			break;
+		case motStop:
+		default:
+			SetMotPerc(M1,FW,0);
+			SetMotPerc(M1,BW,0);
+		break;
+	}
+	return m1st;
+}
+
+motMov_st m2ch(void){
+	static motMov_st m2st;
+	static motMov_st memm2st=motStop;
+	char s[100];
+	if(memm2st!=m2st){
+		memm2st=m2st;
+		sprintf(s,"\nm2ch=%d",m2st);
+		HAL_UART_Transmit(&huart1,(uint8_t*) s, strlen(s), HAL_MAX_DELAY);
+	}
+
+	if(rtCiclo<chM2start)m2st=motWaiting;
+	switch(m2st){
+		case motWaiting:
+			SetMotPerc(M2,FW,0);
+			SetMotPerc(M2,BW,0);
+			if(rtCiclo>=chM2start){
+				(void)ramp(M2,FW,mrampstart[M2-1],m2pwmch,tramp,RAMPINIT);
+				m2st=motStartRamp;
+			}
+			break;
+		case motStartRamp:
+			if(ramp(M2,FW,mrampstart[M2-1],m2pwmch,tramp,RAMPRUN)==DONE){
+				m2st=motWaitingTime;
+			}
+			break;
+		case motWaitingTime:
+			if(rtCiclo>=chM2stop){
+				(void)ramp(M2,FW,m2pwmch,0,tramp,RAMPINIT);
+				m2st=motStopRamp;
+			}
+			break;
+		case motStopRamp:
+			if(ramp(M2,FW,m2pwmch,0,tramp,RAMPRUN)==DONE){
+				m2st=motStop;
+			}
+			break;
+		case motStop:
+		default:
+			SetMotPerc(M2,FW,0);
+			SetMotPerc(M2,BW,0);
+		break;
+	}
+	return m2st;
+}
+
+motMov_st m3ch(void){
+	static motMov_st m3st;
+	static motMov_st memm3st=motStop;
+	char s[100];
+	if(memm3st!=m3st){
+		memm3st=m3st;
+		sprintf(s,"\nm3ch=%d",m3st);
+		HAL_UART_Transmit(&huart1,(uint8_t*) s, strlen(s), HAL_MAX_DELAY);
+	}
+
+	if(rtCiclo<chM3start)m3st=motWaiting;
+	switch(m3st){
+		case motWaiting:
+			SetMotPerc(M3,FW,0);
+			SetMotPerc(M3,BW,0);
+			if(rtCiclo>=chM3start){
+				(void)ramp(M3,FW,mrampstart[M3-1],m2pwmch,tramp,RAMPINIT);
+				m3st=motStartRamp;
+			}
+			break;
+		case motStartRamp:
+			if(ramp(M3,FW,mrampstart[M3-1],m3pwmch,tramp,RAMPRUN)==DONE){
+				m3st=motWaitingTime;
+			}
+			break;
+		case motWaitingTime:
+			if(rtCiclo>=chM3stop){
+				(void)ramp(M3,FW,m3pwmch,0,tramp,RAMPINIT);
+				m3st=motStopRamp;
+			}
+			break;
+		case motStopRamp:
+			if(ramp(M3,FW,m3pwmch,0,tramp,RAMPRUN)==DONE){
+				m3st=motStop;
+			}
+			break;
+		case motStop:
+		default:
+			SetMotPerc(M3,FW,0);
+			SetMotPerc(M3,BW,0);
+		break;
+	}
+	return m3st;
+}
+
+motMov_st m4ch(void){
+	static motMov_st m4st;
+	static motMov_st memm4st=motStop;
+	char s[100];
+	if(memm4st!=m4st){
+		memm4st=m4st;
+		sprintf(s,"\nm4ch=%d",m4st);
+		HAL_UART_Transmit(&huart1,(uint8_t*) s, strlen(s), HAL_MAX_DELAY);
+	}
+
+	if(rtCiclo<chM4start)m4st=motWaiting;
+	switch(m4st){
+		case motWaiting:
+			SetMotPerc(M4,FW,0);
+			SetMotPerc(M4,BW,0);
+			if(rtCiclo>=chM4start){
+				(void)ramp(M4,FW,mrampstart[M4-1],m4pwmch,tramp,RAMPINIT);
+				m4st=motStartRamp;
+			}
+			break;
+		case motStartRamp:
+			if(ramp(M4,FW,mrampstart[M4-1],m4pwmch,tramp,RAMPRUN)==DONE){
+				m4st=motWaitingTime;
+			}
+			break;
+		case motWaitingTime:
+			if(rtCiclo>=chM4stop){
+				(void)ramp(M4,FW,m4pwmch,0,tramp,RAMPINIT);
+				m4st=motStopRamp;
+			}
+			break;
+		case motStopRamp:
+			if(ramp(M4,FW,m4pwmch,0,tramp,RAMPRUN)==DONE){
+				m4st=motStop;
+			}
+			break;
+		case motStop:
+		default:
+			SetMotPerc(M4,FW,0);
+			SetMotPerc(M4,BW,0);
+		break;
+	}
+	return m4st;
+}

workspace/.metadata/.plugins/org.eclipse.core.resources/.history/4b/b071a5108050001117a8e64d4a083793

@@ -0,0 +1,493 @@
+#include <stdio.h>
+#include <string.h>
+#include "eeprom.h"
+#include "pwm.h"
+extern UART_HandleTypeDef huart1;
+/*
+ * Record format (4 bytes):
+ *  [0] VirtAddress (uint16_t)
+ *  [2] Data        (uint16_t)
+ *
+ * Page layout:
+ *  [0]  PageStatus (uint16_t)
+ *  [2..] Records...
+ */
+
+extern uint16_t m1pwmap;
+extern uint16_t m1pwmch;
+extern uint16_t m2pwmap;
+extern uint16_t m2pwmch;
+extern uint16_t m3pwmap;
+extern uint16_t m3pwmch;
+extern uint16_t m4pwmap;
+extern uint16_t m4pwmch;
+extern uint16_t m1TimeoutMan;
+extern uint16_t m2TimeoutMan;
+extern uint16_t m3TimeoutMan;
+extern uint16_t m4TimeoutMan;
+extern uint16_t twap;
+extern uint16_t tramp;
+extern uint16_t t1ch;
+extern uint16_t t2ch;
+extern uint16_t t3ch;
+extern uint16_t t4ch;
+extern uint16_t twch;
+extern uint16_t tramp1;
+extern uint16_t trampman;
+extern uint16_t m1pwmMan;
+extern uint16_t m2pwmMan;
+extern uint16_t m3pwmMan;
+extern uint16_t m4pwmMan;
+extern uint16_t mrampstart[];
+
+
+extern uint16_t apM1start;
+extern uint16_t apM1stop;
+extern uint16_t apM2start;
+extern uint16_t apM2stop;
+extern uint16_t apM3start;
+extern uint16_t apM3stop;
+extern uint16_t apM4start;
+extern uint16_t apM4stop;
+extern uint16_t chM1start;
+extern uint16_t chM1stop;
+extern uint16_t chM2start;
+extern uint16_t chM2stop;
+extern uint16_t chM3start;
+extern uint16_t chM3stop;
+extern uint16_t chM4start;
+extern uint16_t chM4stop;
+
+const uint16_t deftab[EE_NUM_VIRTUAL_ADDR]={
+	40,	//m1pwmap
+	60, //m1pwmch
+	70, //m2pwmap
+	70, //m2pwmch
+	35, //m3pwmap
+	40, //m3pwmch
+	40, //m4pwmap
+	40,	//m4pwmch
+	20, //m1rampstart
+	20, //m2rampstart
+	20, //m3rampstart
+	20, //m4rampstart
+	230,//m1timeoutman
+	100,//m2timeoutman
+	130,//m3timeoutman
+	300,//m4timeoutman
+	1,  //twap
+	27,  //t1ch
+	10,  //t2ch
+	30,  //t3ch
+	1,  //t4ch
+	1,  //twch
+	0,
+	0,
+	0,
+	100, //tramp1
+	60,  //m1pwmMan
+	70,  //m2pwmMan
+	40,	 //m3pwmMan
+	40,	 //m4pwmMan
+	50,  //trampman
+	10,  //tramp
+	310,   //apM1start;
+	450,   //apM1stop;
+	30,   //apM2start;
+	310,  //apM2stop;
+	340,   //apM3start;
+	420,   //apM3stop;
+	30,   //apM4start;
+	430,   //apM4stop;
+	10,   //chM1start;
+	320,   //chM1stop;
+	140,   //chM2start;
+	440,   //chM2stop;
+	20,   //chM3start;
+	280,   //chM3stop;
+	40,   //chM4start;
+	440,   //chM4stop;
+	1,
+	27,
+	10,
+	30,
+	1,
+	1,
+	0,
+	0,
+	0,
+	100,
+	60,
+	70,
+	40,
+	40,
+	50,
+	10,
+};
+
+typedef struct
+{
+    uint16_t VirtAddress;
+    uint16_t Data;
+} EE_Record_t;
+
+/* Active page base address (runtime selected in EE_Init) */
+static uint32_t EE_ActivePageBase = EE_PAGE0_BASE;
+
+/* 32 sequential virtual addresses */
+const uint16_t EE_VirtAddrs[EE_NUM_VIRTUAL_ADDR] =
+{
+	    0x0001, 0x0002, 0x0003, 0x0004,
+	    0x0005, 0x0006, 0x0007, 0x0008,
+	    0x0009, 0x000A, 0x000B, 0x000C,
+	    0x000D, 0x000E, 0x000F, 0x0010,
+	    0x0011, 0x0012, 0x0013, 0x0014,
+	    0x0015, 0x0016, 0x0017, 0x0018,
+	    0x0019, 0x001A, 0x001B, 0x001C,
+	    0x001D, 0x001E, 0x001F, 0x0020,
+
+	    0x0021, 0x0022, 0x0023, 0x0024,
+	    0x0025, 0x0026, 0x0027, 0x0028,
+	    0x0029, 0x002A, 0x002B, 0x002C,
+	    0x002D, 0x002E, 0x002F, 0x0030,
+	    0x0031, 0x0032, 0x0033, 0x0034,
+	    0x0035, 0x0036, 0x0037, 0x0038,
+	    0x0039, 0x003A, 0x003B, 0x003C,
+	    0x003D, 0x003E, 0x003F, 0x0040
+};
+/* ========================================================================= */
+
+/* --- Internal helpers ---------------------------------------------------- */
+
+static uint16_t EE_GetPageStatus(uint32_t pageBase)
+{
+    return *(__IO uint16_t *)pageBase;
+}
+
+static HAL_StatusTypeDef EE_FlashProgramHalfWord(uint32_t Address, uint16_t Data)
+{
+    HAL_StatusTypeDef status;
+
+    HAL_FLASH_Unlock();
+    status = HAL_FLASH_Program(FLASH_TYPEPROGRAM_HALFWORD, Address, Data);
+    HAL_FLASH_Lock();
+
+    return status;
+}
+
+static HAL_StatusTypeDef EE_FlashErasePage(uint32_t PageAddress)
+{
+    HAL_StatusTypeDef status;
+    FLASH_EraseInitTypeDef EraseInit;
+    uint32_t PageError = 0;
+
+    HAL_FLASH_Unlock();
+
+    EraseInit.TypeErase   = FLASH_TYPEERASE_PAGES;
+    EraseInit.PageAddress = PageAddress;
+    EraseInit.NbPages     = 1;
+
+    status = HAL_FLASHEx_Erase(&EraseInit, &PageError);
+
+    HAL_FLASH_Lock();
+    return status;
+}
+
+/* Find first free record address in given page (returns 0 if full) */
+static uint32_t EE_FindFreeAddress(uint32_t pageBase)
+{
+    uint32_t addr = pageBase + 2U;                /* Skip status word */
+    uint32_t pageEnd = pageBase + EE_PAGE_SIZE;
+
+    while (addr < (pageEnd - sizeof(EE_Record_t) + 1U))
+    {
+        uint16_t vaddr = *(__IO uint16_t *)addr;
+
+        if (vaddr == 0xFFFFU)
+        {
+            /* Empty slot */
+            return addr;
+        }
+        addr += sizeof(EE_Record_t);
+    }
+
+    return 0U; /* No space */
+}
+
+/* Find latest value of VirtAddress in a specific page (internal, uses EE_Status) */
+/* Find latest value of VirtAddress in a specific page (scan forward) */
+static EE_Status EE_FindInPage(uint32_t pageBase, uint16_t VirtAddress, uint16_t *Data)
+{
+    uint32_t addr     = pageBase + 2U;            // skip status halfword
+    uint32_t pageEnd  = pageBase + EE_PAGE_SIZE;
+    EE_Status result  = EE_NOT_FOUND;
+    uint16_t lastVal  = 0;
+
+    if (Data == NULL)
+        return EE_ERROR;
+
+    while (addr <= (pageEnd - sizeof(EE_Record_t)))
+    {
+        uint16_t vaddr = *(__IO uint16_t *)addr;
+
+        if (vaddr == 0xFFFFU)
+        {
+            // First empty slot => no more records in this page
+            break;
+        }
+
+        uint16_t value = *(__IO uint16_t *)(addr + 2U);
+
+        if (vaddr == VirtAddress)
+        {
+            lastVal = value;    // keep most recent
+            result  = EE_OK;
+        }
+
+        addr += sizeof(EE_Record_t);  // move 4 bytes forward
+    }
+
+    if (result == EE_OK)
+        *Data = lastVal;
+
+    return result;
+}
+
+
+
+/* Format both pages: erase and set PAGE0 as VALID */
+static EE_Status EE_Format(void)
+{
+    if (EE_FlashErasePage(EE_PAGE0_BASE) != HAL_OK)
+        return EE_STATUS_ERROR;
+
+    if (EE_FlashErasePage(EE_PAGE1_BASE) != HAL_OK)
+        return EE_STATUS_ERROR;
+
+    if (EE_FlashProgramHalfWord(EE_PAGE0_BASE, EE_PAGE_STATUS_VALID) != HAL_OK)
+        return EE_STATUS_ERROR;
+
+    /* PAGE1 will remain erased (status = 0xFFFF) */
+    EE_ActivePageBase = EE_PAGE0_BASE;
+
+    return EE_STATUS_OK;
+}
+
+/* Get the base of the other page */
+static uint32_t EE_GetOtherPageBase(uint32_t pageBase)
+{
+    return (pageBase == EE_PAGE0_BASE) ? EE_PAGE1_BASE : EE_PAGE0_BASE;
+}
+
+/* Page transfer (garbage collection + new write) */
+static EE_Status EE_PageTransfer(uint16_t VirtAddress, uint16_t Data)
+{
+    uint32_t oldBase = EE_ActivePageBase;
+    uint32_t newBase = EE_GetOtherPageBase(oldBase);
+    uint32_t addr;
+    uint16_t value;
+    EE_Status st;
+
+    /* Erase new page */
+    if (EE_FlashErasePage(newBase) != HAL_OK)
+        return EE_STATUS_ERROR;
+
+    /* Mark new page as RECEIVE */
+    if (EE_FlashProgramHalfWord(newBase, EE_PAGE_STATUS_RECEIVE) != HAL_OK)
+        return EE_STATUS_ERROR;
+
+    /* Start writing records just after status */
+    addr = newBase + 2U;
+
+    /* For each known virtual variable */
+    for (uint16_t i = 0; i < EE_NUM_VIRTUAL_ADDR; i++)
+    {
+        uint16_t vaddr = EE_VirtAddrs[i];
+
+        if (vaddr == VirtAddress)
+        {
+            /* Use the new data passed into PageTransfer */
+            value = Data;
+        }
+        else
+        {
+            /* Read latest value from old active page */
+            st = EE_FindInPage(oldBase, vaddr, &value);
+            if (st != EE_STATUS_OK)
+            {
+                /* Variable never written -> skip */
+                continue;
+            }
+        }
+
+        /* Write record to new page */
+        if (EE_FlashProgramHalfWord(addr, vaddr) != HAL_OK)
+            return EE_STATUS_ERROR;
+        if (EE_FlashProgramHalfWord(addr + 2U, value) != HAL_OK)
+            return EE_STATUS_ERROR;
+
+        addr += sizeof(EE_Record_t);
+        if (addr >= (newBase + EE_PAGE_SIZE))
+            return EE_STATUS_NO_SPACE;
+    }
+
+    /* Erase old page */
+    if (EE_FlashErasePage(oldBase) != HAL_OK)
+        return EE_STATUS_ERROR;
+
+    /* Mark new page as VALID */
+    if (EE_FlashProgramHalfWord(newBase, EE_PAGE_STATUS_VALID) != HAL_OK)
+        return EE_STATUS_ERROR;
+
+    /* Update active page */
+    EE_ActivePageBase = newBase;
+
+    return EE_STATUS_OK;
+}
+
+/* --- Public API ----------------------------------------------------------- */
+
+/*
+ * Initialize the EEPROM emulation.
+ * - Checks page statuses and chooses the active page.
+ * - If inconsistent or blank, formats pages.
+ * PUBLIC RETURN TYPE: uint16_t (EE_OK / EE_ERROR / ...)
+ */
+uint16_t EE_Init(void)
+{
+    uint16_t status0 = EE_GetPageStatus(EE_PAGE0_BASE);
+    uint16_t status1 = EE_GetPageStatus(EE_PAGE1_BASE);
+
+    if ((status0 == EE_PAGE_STATUS_ERASED) && (status1 == EE_PAGE_STATUS_ERASED))
+    {
+        /* Fresh device -> format */
+        return (uint16_t)EE_Format();
+    }
+    else if ((status0 == EE_PAGE_STATUS_VALID) && (status1 == EE_PAGE_STATUS_ERASED))
+    {
+        EE_ActivePageBase = EE_PAGE0_BASE;
+        return EE_OK;
+    }
+    else if ((status1 == EE_PAGE_STATUS_VALID) && (status0 == EE_PAGE_STATUS_ERASED))
+    {
+        EE_ActivePageBase = EE_PAGE1_BASE;
+        return EE_OK;
+    }
+    else
+    {
+        /* Any weird or inconsistent state -> reformat */
+        return (uint16_t)EE_Format();
+    }
+}
+
+/*
+ * Read a 16-bit variable by its virtual address.
+ * PUBLIC RETURN: EE_OK / EE_NOT_FOUND / EE_ERROR (as uint16_t)
+ */
+uint16_t EE_ReadVariable(uint16_t VirtAddress, uint16_t *Data)
+{
+    EE_Status st;
+
+    if (Data == NULL)
+        return EE_ERROR;
+
+    st = EE_FindInPage(EE_ActivePageBase, VirtAddress, Data);
+    return (uint16_t)st;
+}
+
+/*
+ * Write (append) a 16-bit variable.
+ * - Writes a new record in the active page.
+ * - If the page is full, triggers a page transfer (GC).
+ * PUBLIC RETURN: EE_OK / EE_ERROR / EE_NO_SPACE (as uint16_t)
+ */
+uint16_t EE_WriteVariable(uint16_t VirtAddress, uint16_t Data)
+{
+    uint32_t freeAddr;
+    EE_Status st;
+
+    /* Find free space in active page */
+    freeAddr = EE_FindFreeAddress(EE_ActivePageBase);
+    if (freeAddr != 0U)
+    {
+        /* Write new record */
+        if (EE_FlashProgramHalfWord(freeAddr, VirtAddress) != HAL_OK)
+            return EE_ERROR;
+        if (EE_FlashProgramHalfWord(freeAddr + 2U, Data) != HAL_OK)
+            return EE_ERROR;
+
+        return EE_OK;
+    }
+
+    /* No space -> page transfer */
+    st = EE_PageTransfer(VirtAddress, Data);
+    return (uint16_t)st;
+}
+
+void loadEE(void){
+	char s [200];
+	EEW_Read(M1PWMAP, &m1pwmap);
+	EEW_Read(M1PWMCH, &m1pwmch);
+	EEW_Read(M2PWMAP, &m2pwmap);
+	EEW_Read(M2PWMCH, &m2pwmch);
+	EEW_Read(M3PWMAP, &m3pwmap);
+	EEW_Read(M3PWMCH, &m3pwmch);
+	EEW_Read(M4PWMAP, &m4pwmap);
+	EEW_Read(M4PWMCH, &m4pwmch);
+
+	EEW_Read(M1RAMPSTART, &mrampstart[M1-1]);
+	EEW_Read(M2RAMPSTART, &mrampstart[M2-1]);
+	EEW_Read(M3RAMPSTART, &mrampstart[M3-1]);
+	EEW_Read(M4RAMPSTART, &mrampstart[M4-1]);
+
+
+	EEW_Read(M1TIMEOUTMAN, &m1TimeoutMan);
+	EEW_Read(M2TIMEOUTMAN, &m2TimeoutMan);
+	EEW_Read(M3TIMEOUTMAN, &m3TimeoutMan);
+	EEW_Read(M4TIMEOUTMAN, &m4TimeoutMan);
+
+	EEW_Read(TRAMP1, &tramp1);
+	EEW_Read(M1PWMMAN, &m1pwmMan);
+	EEW_Read(M2PWMMAN, &m2pwmMan);
+	EEW_Read(M3PWMMAN, &m3pwmMan);
+	EEW_Read(M4PWMMAN, &m4pwmMan);
+	EEW_Read(TRAMPMAN, &trampman);
+	EEW_Read(TRAMP, &tramp);
+
+	EEW_Read(APM1START,&apM1start);
+	EEW_Read(APM1STOP ,&apM1stop);
+	EEW_Read(APM2START,&apM2start);
+	EEW_Read(APM2STOP ,&apM2stop);
+	EEW_Read(APM3START,&apM3start);
+	EEW_Read(APM3STOP ,&apM3stop);
+	EEW_Read(APM4START,&apM4start);
+	EEW_Read(APM4STOP ,&apM4stop);
+	EEW_Read(CHM1START,&chM1start);
+	EEW_Read(CHM1STOP ,&chM1stop);
+	EEW_Read(CHM2START,&chM2start);
+	EEW_Read(CHM2STOP ,&chM2stop);
+	EEW_Read(CHM3START,&chM3start);
+	EEW_Read(CHM3STOP ,&chM3stop);
+	EEW_Read(CHM4START,&chM4start);
+	EEW_Read(CHM4STOP ,&chM4stop);
+
+	sprintf((char*)s,"LoadEE\n");
+	HAL_UART_Transmit(&huart1,(uint8_t*) s, strlen(s), HAL_MAX_DELAY);
+	sprintf((char*)s,"\nm1pwmap=%d m1pwmch=%d m2pwmap=%d m2pwmch=%d m3pwmap=%d m3pwmch=%d m4pwmap=%d m4pwmch=%d",m1pwmap,m1pwmch,m2pwmap,m2pwmch,m3pwmap,m3pwmch,m4pwmap, m4pwmch);
+	HAL_UART_Transmit(&huart1,(uint8_t*) s, strlen(s), HAL_MAX_DELAY);
+	sprintf((char*)s,"\nm1TimeoutMan=%d m2TimeoutMan=%d m3TimeoutMan=%d m4TimeoutMan=%d ",m1TimeoutMan,m2TimeoutMan,m3TimeoutMan,m4TimeoutMan);
+	HAL_UART_Transmit(&huart1,(uint8_t*) s, strlen(s), HAL_MAX_DELAY);
+	sprintf((char*)s,"\ntramp=%d trampman=%d",tramp,trampman);
+	HAL_UART_Transmit(&huart1,(uint8_t*) s, strlen(s), HAL_MAX_DELAY);
+	sprintf((char*)s,"\nm1pwmMan=%d m2pwmMan=%d m3pwmMan=%d m4pwmMan=%d",m1pwmMan,m2pwmMan,m3pwmMan,m4pwmMan);
+	HAL_UART_Transmit(&huart1,(uint8_t*) s, strlen(s), HAL_MAX_DELAY);
+	sprintf((char*)s,"\napM1start=%d apM1stop=%d chM1start=%d chM1stop=%d",apM1start,apM1stop,chM1start,chM1stop);
+	HAL_UART_Transmit(&huart1,(uint8_t*) s, strlen(s), HAL_MAX_DELAY);
+	sprintf((char*)s,"\napM2start=%d apM2stop=%d chM2start=%d chM2stop=%d",apM2start,apM2stop,chM2start,chM2stop);
+	HAL_UART_Transmit(&huart1,(uint8_t*) s, strlen(s), HAL_MAX_DELAY);
+	sprintf((char*)s,"\napM3start=%d apM3stop=%d chM3start=%d chM3stop=%d",apM3start,apM3stop,chM3start,chM3stop);
+	HAL_UART_Transmit(&huart1,(uint8_t*) s, strlen(s), HAL_MAX_DELAY);
+	sprintf((char*)s,"\napM4start=%d apM4stop=%d chM4start=%d chM4stop=%d",apM4start,apM4stop,chM4start,chM4stop);
+	HAL_UART_Transmit(&huart1,(uint8_t*) s, strlen(s), HAL_MAX_DELAY);
+
+}

workspace/.metadata/.plugins/org.eclipse.core.resources/.history/f1/e0a6e3c87e50001117a8e64d4a083793

@@ -0,0 +1,493 @@
+#include <stdio.h>
+#include <string.h>
+#include "eeprom.h"
+#include "pwm.h"
+extern UART_HandleTypeDef huart1;
+/*
+ * Record format (4 bytes):
+ *  [0] VirtAddress (uint16_t)
+ *  [2] Data        (uint16_t)
+ *
+ * Page layout:
+ *  [0]  PageStatus (uint16_t)
+ *  [2..] Records...
+ */
+
+extern uint16_t m1pwmap;
+extern uint16_t m1pwmch;
+extern uint16_t m2pwmap;
+extern uint16_t m2pwmch;
+extern uint16_t m3pwmap;
+extern uint16_t m3pwmch;
+extern uint16_t m4pwmap;
+extern uint16_t m4pwmch;
+extern uint16_t m1TimeoutMan;
+extern uint16_t m2TimeoutMan;
+extern uint16_t m3TimeoutMan;
+extern uint16_t m4TimeoutMan;
+extern uint16_t twap;
+extern uint16_t tramp;
+extern uint16_t t1ch;
+extern uint16_t t2ch;
+extern uint16_t t3ch;
+extern uint16_t t4ch;
+extern uint16_t twch;
+extern uint16_t tramp1;
+extern uint16_t trampman;
+extern uint16_t m1pwmMan;
+extern uint16_t m2pwmMan;
+extern uint16_t m3pwmMan;
+extern uint16_t m4pwmMan;
+extern uint16_t mrampstart[];
+
+
+extern uint16_t apM1start;
+extern uint16_t apM1stop;
+extern uint16_t apM2start;
+extern uint16_t apM2stop;
+extern uint16_t apM3start;
+extern uint16_t apM3stop;
+extern uint16_t apM4start;
+extern uint16_t apM4stop;
+extern uint16_t chM1start;
+extern uint16_t chM1stop;
+extern uint16_t chM2start;
+extern uint16_t chM2stop;
+extern uint16_t chM3start;
+extern uint16_t chM3stop;
+extern uint16_t chM4start;
+extern uint16_t chM4stop;
+
+const uint16_t deftab[EE_NUM_VIRTUAL_ADDR]={
+	40,	//m1pwmap
+	60, //m1pwmch
+	70, //m2pwmap
+	70, //m2pwmch
+	35, //m3pwmap
+	40, //m3pwmch
+	40, //m4pwmap
+	40,	//m4pwmch
+	20, //m1rampstart
+	20, //m2rampstart
+	20, //m3rampstart
+	20, //m4rampstart
+	230,//m1timeoutman
+	100,//m2timeoutman
+	130,//m3timeoutman
+	300,//m4timeoutman
+	1,  //twap
+	27,  //t1ch
+	10,  //t2ch
+	30,  //t3ch
+	1,  //t4ch
+	1,  //twch
+	0,
+	0,
+	0,
+	100, //tramp1
+	60,  //m1pwmMan
+	70,  //m2pwmMan
+	40,	 //m3pwmMan
+	40,	 //m4pwmMan
+	50,  //trampman
+	10,  //tramp
+	310,   //apM1start;
+	450,   //apM1stop;
+	30,   //apM2start;
+	310,  //apM2stop;
+	350,   //apM3start;
+	450,   //apM3stop;
+	450,   //apM4start;
+	850,   //apM4stop;
+	10,   //chM1start;
+	280,   //chM1stop;
+	280,   //chM2start;
+	580,   //chM2stop;
+	20,   //chM3start;
+	280,   //chM3stop;
+	280,   //chM4start;
+	680,   //chM4stop;
+	1,
+	27,
+	10,
+	30,
+	1,
+	1,
+	0,
+	0,
+	0,
+	100,
+	60,
+	70,
+	40,
+	40,
+	50,
+	10,
+};
+
+typedef struct
+{
+    uint16_t VirtAddress;
+    uint16_t Data;
+} EE_Record_t;
+
+/* Active page base address (runtime selected in EE_Init) */
+static uint32_t EE_ActivePageBase = EE_PAGE0_BASE;
+
+/* 32 sequential virtual addresses */
+const uint16_t EE_VirtAddrs[EE_NUM_VIRTUAL_ADDR] =
+{
+	    0x0001, 0x0002, 0x0003, 0x0004,
+	    0x0005, 0x0006, 0x0007, 0x0008,
+	    0x0009, 0x000A, 0x000B, 0x000C,
+	    0x000D, 0x000E, 0x000F, 0x0010,
+	    0x0011, 0x0012, 0x0013, 0x0014,
+	    0x0015, 0x0016, 0x0017, 0x0018,
+	    0x0019, 0x001A, 0x001B, 0x001C,
+	    0x001D, 0x001E, 0x001F, 0x0020,
+
+	    0x0021, 0x0022, 0x0023, 0x0024,
+	    0x0025, 0x0026, 0x0027, 0x0028,
+	    0x0029, 0x002A, 0x002B, 0x002C,
+	    0x002D, 0x002E, 0x002F, 0x0030,
+	    0x0031, 0x0032, 0x0033, 0x0034,
+	    0x0035, 0x0036, 0x0037, 0x0038,
+	    0x0039, 0x003A, 0x003B, 0x003C,
+	    0x003D, 0x003E, 0x003F, 0x0040
+};
+/* ========================================================================= */
+
+/* --- Internal helpers ---------------------------------------------------- */
+
+static uint16_t EE_GetPageStatus(uint32_t pageBase)
+{
+    return *(__IO uint16_t *)pageBase;
+}
+
+static HAL_StatusTypeDef EE_FlashProgramHalfWord(uint32_t Address, uint16_t Data)
+{
+    HAL_StatusTypeDef status;
+
+    HAL_FLASH_Unlock();
+    status = HAL_FLASH_Program(FLASH_TYPEPROGRAM_HALFWORD, Address, Data);
+    HAL_FLASH_Lock();
+
+    return status;
+}
+
+static HAL_StatusTypeDef EE_FlashErasePage(uint32_t PageAddress)
+{
+    HAL_StatusTypeDef status;
+    FLASH_EraseInitTypeDef EraseInit;
+    uint32_t PageError = 0;
+
+    HAL_FLASH_Unlock();
+
+    EraseInit.TypeErase   = FLASH_TYPEERASE_PAGES;
+    EraseInit.PageAddress = PageAddress;
+    EraseInit.NbPages     = 1;
+
+    status = HAL_FLASHEx_Erase(&EraseInit, &PageError);
+
+    HAL_FLASH_Lock();
+    return status;
+}
+
+/* Find first free record address in given page (returns 0 if full) */
+static uint32_t EE_FindFreeAddress(uint32_t pageBase)
+{
+    uint32_t addr = pageBase + 2U;                /* Skip status word */
+    uint32_t pageEnd = pageBase + EE_PAGE_SIZE;
+
+    while (addr < (pageEnd - sizeof(EE_Record_t) + 1U))
+    {
+        uint16_t vaddr = *(__IO uint16_t *)addr;
+
+        if (vaddr == 0xFFFFU)
+        {
+            /* Empty slot */
+            return addr;
+        }
+        addr += sizeof(EE_Record_t);
+    }
+
+    return 0U; /* No space */
+}
+
+/* Find latest value of VirtAddress in a specific page (internal, uses EE_Status) */
+/* Find latest value of VirtAddress in a specific page (scan forward) */
+static EE_Status EE_FindInPage(uint32_t pageBase, uint16_t VirtAddress, uint16_t *Data)
+{
+    uint32_t addr     = pageBase + 2U;            // skip status halfword
+    uint32_t pageEnd  = pageBase + EE_PAGE_SIZE;
+    EE_Status result  = EE_NOT_FOUND;
+    uint16_t lastVal  = 0;
+
+    if (Data == NULL)
+        return EE_ERROR;
+
+    while (addr <= (pageEnd - sizeof(EE_Record_t)))
+    {
+        uint16_t vaddr = *(__IO uint16_t *)addr;
+
+        if (vaddr == 0xFFFFU)
+        {
+            // First empty slot => no more records in this page
+            break;
+        }
+
+        uint16_t value = *(__IO uint16_t *)(addr + 2U);
+
+        if (vaddr == VirtAddress)
+        {
+            lastVal = value;    // keep most recent
+            result  = EE_OK;
+        }
+
+        addr += sizeof(EE_Record_t);  // move 4 bytes forward
+    }
+
+    if (result == EE_OK)
+        *Data = lastVal;
+
+    return result;
+}
+
+
+
+/* Format both pages: erase and set PAGE0 as VALID */
+static EE_Status EE_Format(void)
+{
+    if (EE_FlashErasePage(EE_PAGE0_BASE) != HAL_OK)
+        return EE_STATUS_ERROR;
+
+    if (EE_FlashErasePage(EE_PAGE1_BASE) != HAL_OK)
+        return EE_STATUS_ERROR;
+
+    if (EE_FlashProgramHalfWord(EE_PAGE0_BASE, EE_PAGE_STATUS_VALID) != HAL_OK)
+        return EE_STATUS_ERROR;
+
+    /* PAGE1 will remain erased (status = 0xFFFF) */
+    EE_ActivePageBase = EE_PAGE0_BASE;
+
+    return EE_STATUS_OK;
+}
+
+/* Get the base of the other page */
+static uint32_t EE_GetOtherPageBase(uint32_t pageBase)
+{
+    return (pageBase == EE_PAGE0_BASE) ? EE_PAGE1_BASE : EE_PAGE0_BASE;
+}
+
+/* Page transfer (garbage collection + new write) */
+static EE_Status EE_PageTransfer(uint16_t VirtAddress, uint16_t Data)
+{
+    uint32_t oldBase = EE_ActivePageBase;
+    uint32_t newBase = EE_GetOtherPageBase(oldBase);
+    uint32_t addr;
+    uint16_t value;
+    EE_Status st;
+
+    /* Erase new page */
+    if (EE_FlashErasePage(newBase) != HAL_OK)
+        return EE_STATUS_ERROR;
+
+    /* Mark new page as RECEIVE */
+    if (EE_FlashProgramHalfWord(newBase, EE_PAGE_STATUS_RECEIVE) != HAL_OK)
+        return EE_STATUS_ERROR;
+
+    /* Start writing records just after status */
+    addr = newBase + 2U;
+
+    /* For each known virtual variable */
+    for (uint16_t i = 0; i < EE_NUM_VIRTUAL_ADDR; i++)
+    {
+        uint16_t vaddr = EE_VirtAddrs[i];
+
+        if (vaddr == VirtAddress)
+        {
+            /* Use the new data passed into PageTransfer */
+            value = Data;
+        }
+        else
+        {
+            /* Read latest value from old active page */
+            st = EE_FindInPage(oldBase, vaddr, &value);
+            if (st != EE_STATUS_OK)
+            {
+                /* Variable never written -> skip */
+                continue;
+            }
+        }
+
+        /* Write record to new page */
+        if (EE_FlashProgramHalfWord(addr, vaddr) != HAL_OK)
+            return EE_STATUS_ERROR;
+        if (EE_FlashProgramHalfWord(addr + 2U, value) != HAL_OK)
+            return EE_STATUS_ERROR;
+
+        addr += sizeof(EE_Record_t);
+        if (addr >= (newBase + EE_PAGE_SIZE))
+            return EE_STATUS_NO_SPACE;
+    }
+
+    /* Erase old page */
+    if (EE_FlashErasePage(oldBase) != HAL_OK)
+        return EE_STATUS_ERROR;
+
+    /* Mark new page as VALID */
+    if (EE_FlashProgramHalfWord(newBase, EE_PAGE_STATUS_VALID) != HAL_OK)
+        return EE_STATUS_ERROR;
+
+    /* Update active page */
+    EE_ActivePageBase = newBase;
+
+    return EE_STATUS_OK;
+}
+
+/* --- Public API ----------------------------------------------------------- */
+
+/*
+ * Initialize the EEPROM emulation.
+ * - Checks page statuses and chooses the active page.
+ * - If inconsistent or blank, formats pages.
+ * PUBLIC RETURN TYPE: uint16_t (EE_OK / EE_ERROR / ...)
+ */
+uint16_t EE_Init(void)
+{
+    uint16_t status0 = EE_GetPageStatus(EE_PAGE0_BASE);
+    uint16_t status1 = EE_GetPageStatus(EE_PAGE1_BASE);
+
+    if ((status0 == EE_PAGE_STATUS_ERASED) && (status1 == EE_PAGE_STATUS_ERASED))
+    {
+        /* Fresh device -> format */
+        return (uint16_t)EE_Format();
+    }
+    else if ((status0 == EE_PAGE_STATUS_VALID) && (status1 == EE_PAGE_STATUS_ERASED))
+    {
+        EE_ActivePageBase = EE_PAGE0_BASE;
+        return EE_OK;
+    }
+    else if ((status1 == EE_PAGE_STATUS_VALID) && (status0 == EE_PAGE_STATUS_ERASED))
+    {
+        EE_ActivePageBase = EE_PAGE1_BASE;
+        return EE_OK;
+    }
+    else
+    {
+        /* Any weird or inconsistent state -> reformat */
+        return (uint16_t)EE_Format();
+    }
+}
+
+/*
+ * Read a 16-bit variable by its virtual address.
+ * PUBLIC RETURN: EE_OK / EE_NOT_FOUND / EE_ERROR (as uint16_t)
+ */
+uint16_t EE_ReadVariable(uint16_t VirtAddress, uint16_t *Data)
+{
+    EE_Status st;
+
+    if (Data == NULL)
+        return EE_ERROR;
+
+    st = EE_FindInPage(EE_ActivePageBase, VirtAddress, Data);
+    return (uint16_t)st;
+}
+
+/*
+ * Write (append) a 16-bit variable.
+ * - Writes a new record in the active page.
+ * - If the page is full, triggers a page transfer (GC).
+ * PUBLIC RETURN: EE_OK / EE_ERROR / EE_NO_SPACE (as uint16_t)
+ */
+uint16_t EE_WriteVariable(uint16_t VirtAddress, uint16_t Data)
+{
+    uint32_t freeAddr;
+    EE_Status st;
+
+    /* Find free space in active page */
+    freeAddr = EE_FindFreeAddress(EE_ActivePageBase);
+    if (freeAddr != 0U)
+    {
+        /* Write new record */
+        if (EE_FlashProgramHalfWord(freeAddr, VirtAddress) != HAL_OK)
+            return EE_ERROR;
+        if (EE_FlashProgramHalfWord(freeAddr + 2U, Data) != HAL_OK)
+            return EE_ERROR;
+
+        return EE_OK;
+    }
+
+    /* No space -> page transfer */
+    st = EE_PageTransfer(VirtAddress, Data);
+    return (uint16_t)st;
+}
+
+void loadEE(void){
+	char s [200];
+	EEW_Read(M1PWMAP, &m1pwmap);
+	EEW_Read(M1PWMCH, &m1pwmch);
+	EEW_Read(M2PWMAP, &m2pwmap);
+	EEW_Read(M2PWMCH, &m2pwmch);
+	EEW_Read(M3PWMAP, &m3pwmap);
+	EEW_Read(M3PWMCH, &m3pwmch);
+	EEW_Read(M4PWMAP, &m4pwmap);
+	EEW_Read(M4PWMCH, &m4pwmch);
+
+	EEW_Read(M1RAMPSTART, &mrampstart[M1-1]);
+	EEW_Read(M2RAMPSTART, &mrampstart[M2-1]);
+	EEW_Read(M3RAMPSTART, &mrampstart[M3-1]);
+	EEW_Read(M4RAMPSTART, &mrampstart[M4-1]);
+
+
+	EEW_Read(M1TIMEOUTMAN, &m1TimeoutMan);
+	EEW_Read(M2TIMEOUTMAN, &m2TimeoutMan);
+	EEW_Read(M3TIMEOUTMAN, &m3TimeoutMan);
+	EEW_Read(M4TIMEOUTMAN, &m4TimeoutMan);
+
+	EEW_Read(TRAMP1, &tramp1);
+	EEW_Read(M1PWMMAN, &m1pwmMan);
+	EEW_Read(M2PWMMAN, &m2pwmMan);
+	EEW_Read(M3PWMMAN, &m3pwmMan);
+	EEW_Read(M4PWMMAN, &m4pwmMan);
+	EEW_Read(TRAMPMAN, &trampman);
+	EEW_Read(TRAMP, &tramp);
+
+	EEW_Read(APM1START,&apM1start);
+	EEW_Read(APM1STOP ,&apM1stop);
+	EEW_Read(APM2START,&apM2start);
+	EEW_Read(APM2STOP ,&apM2stop);
+	EEW_Read(APM3START,&apM3start);
+	EEW_Read(APM3STOP ,&apM3stop);
+	EEW_Read(APM4START,&apM4start);
+	EEW_Read(APM4STOP ,&apM4stop);
+	EEW_Read(CHM1START,&chM1start);
+	EEW_Read(CHM1STOP ,&chM1stop);
+	EEW_Read(CHM2START,&chM2start);
+	EEW_Read(CHM2STOP ,&chM2stop);
+	EEW_Read(CHM3START,&chM3start);
+	EEW_Read(CHM3STOP ,&chM3stop);
+	EEW_Read(CHM4START,&chM4start);
+	EEW_Read(CHM4STOP ,&chM4stop);
+
+	sprintf((char*)s,"LoadEE\n");
+	HAL_UART_Transmit(&huart1,(uint8_t*) s, strlen(s), HAL_MAX_DELAY);
+	sprintf((char*)s,"\nm1pwmap=%d m1pwmch=%d m2pwmap=%d m2pwmch=%d m3pwmap=%d m3pwmch=%d m4pwmap=%d m4pwmch=%d",m1pwmap,m1pwmch,m2pwmap,m2pwmch,m3pwmap,m3pwmch,m4pwmap, m4pwmch);
+	HAL_UART_Transmit(&huart1,(uint8_t*) s, strlen(s), HAL_MAX_DELAY);
+	sprintf((char*)s,"\nm1TimeoutMan=%d m2TimeoutMan=%d m3TimeoutMan=%d m4TimeoutMan=%d ",m1TimeoutMan,m2TimeoutMan,m3TimeoutMan,m4TimeoutMan);
+	HAL_UART_Transmit(&huart1,(uint8_t*) s, strlen(s), HAL_MAX_DELAY);
+	sprintf((char*)s,"\ntramp=%d trampman=%d",tramp,trampman);
+	HAL_UART_Transmit(&huart1,(uint8_t*) s, strlen(s), HAL_MAX_DELAY);
+	sprintf((char*)s,"\nm1pwmMan=%d m2pwmMan=%d m3pwmMan=%d m4pwmMan=%d",m1pwmMan,m2pwmMan,m3pwmMan,m4pwmMan);
+	HAL_UART_Transmit(&huart1,(uint8_t*) s, strlen(s), HAL_MAX_DELAY);
+	sprintf((char*)s,"\napM1start=%d apM1stop=%d chM1start=%d chM1stop=%d",apM1start,apM1stop,chM1start,chM1stop);
+	HAL_UART_Transmit(&huart1,(uint8_t*) s, strlen(s), HAL_MAX_DELAY);
+	sprintf((char*)s,"\napM2start=%d apM2stop=%d chM2start=%d chM2stop=%d",apM2start,apM2stop,chM2start,chM2stop);
+	HAL_UART_Transmit(&huart1,(uint8_t*) s, strlen(s), HAL_MAX_DELAY);
+	sprintf((char*)s,"\napM3start=%d apM3stop=%d chM3start=%d chM3stop=%d",apM3start,apM3stop,chM3start,chM3stop);
+	HAL_UART_Transmit(&huart1,(uint8_t*) s, strlen(s), HAL_MAX_DELAY);
+	sprintf((char*)s,"\napM4start=%d apM4stop=%d chM4start=%d chM4stop=%d",apM4start,apM4stop,chM4start,chM4stop);
+	HAL_UART_Transmit(&huart1,(uint8_t*) s, strlen(s), HAL_MAX_DELAY);
+
+}

workspace/.metadata/version.ini

@@ -1,3 +1,3 @@
-#Thu May 14 17:57:33 CEST 2026
+#Fri May 15 19:11:24 CEST 2026
 org.eclipse.core.runtime=2
 org.eclipse.platform=4.33.0.v20240903-0240

workspace/AUTOM10/Core/Src/eeprom.c

@@ -95,18 +95,18 @@ const uint16_t deftab[EE_NUM_VIRTUAL_ADDR]={
 	450,   //apM1stop;
 	30,   //apM2start;
 	310,  //apM2stop;
-	350,   //apM3start;
+	340,   //apM3start;
-	450,   //apM3stop;
+	430,   //apM3stop;
-	450,   //apM4start;
+	30,   //apM4start;
-	850,   //apM4stop;
+	430,   //apM4stop;
 	10,   //chM1start;
-	280,   //chM1stop;
+	320,   //chM1stop;
-	280,   //chM2start;
+	140,   //chM2start;
-	580,   //chM2stop;
+	440,   //chM2stop;
 	20,   //chM3start;
 	280,   //chM3stop;
-	280,   //chM4start;
+	40,   //chM4start;
-	680,   //chM4stop;
+	440,   //chM4stop;
 	1,
 	27,
 	10,

workspace/AUTOM10/Core/Src/mot.c

@@ -55,23 +55,23 @@ motMov_st m1ap(void){
 			SetMotPerc(M1,FW,0);
 			SetMotPerc(M1,BW,0);
 			if(rtCiclo>=apM1start){
-				(void)ramp(M1,BW,mrampstart[M1-1],m1pwmap,tramp,RAMPINIT);
+				(void)ramp(M1,FW,mrampstart[M1-1],m1pwmap,tramp,RAMPINIT);
 				m1st=motStartRamp;
 			}
 			break;
 		case motStartRamp:
-			if(ramp(M1,BW,mrampstart[M1-1],m1pwmap,tramp,RAMPRUN)==DONE){
+			if(ramp(M1,FW,mrampstart[M1-1],m1pwmap,tramp,RAMPRUN)==DONE){
 				m1st=motWaitingTime;
 			}
 			break;
 		case motWaitingTime:
 			if(rtCiclo>=apM1stop){
-				(void)ramp(M1,BW,m1pwmap,0,tramp,RAMPINIT);
+				(void)ramp(M1,FW,m1pwmap,0,tramp,RAMPINIT);
 				m1st=motStopRamp;
 			}
 			break;
 		case motStopRamp:
-			if(ramp(M1,BW,m1pwmap,0,tramp,RAMPRUN)==DONE){
+			if(ramp(M1,FW,m1pwmap,0,tramp,RAMPRUN)==DONE){
 				m1st=motStop;
 			}
 			break;
@@ -143,23 +143,23 @@ motMov_st m3ap(void){
 			SetMotPerc(M3,FW,0);
 			SetMotPerc(M3,BW,0);
 			if(rtCiclo>=apM3start){
-				(void)ramp(M3,BW,mrampstart[M3-1],m2pwmap,tramp,RAMPINIT);
+				(void)ramp(M3,FW,mrampstart[M3-1],m2pwmap,tramp,RAMPINIT);
 				m3st=motStartRamp;
 			}
 			break;
 		case motStartRamp:
-			if(ramp(M3,BW,mrampstart[M3-1],m3pwmap,tramp,RAMPRUN)==DONE){
+			if(ramp(M3,FW,mrampstart[M3-1],m3pwmap,tramp,RAMPRUN)==DONE){
 				m3st=motWaitingTime;
 			}
 			break;
 		case motWaitingTime:
 			if(rtCiclo>=apM3stop){
-				(void)ramp(M3,BW,m3pwmap,0,tramp,RAMPINIT);
+				(void)ramp(M3,FW,m3pwmap,0,tramp,RAMPINIT);
 				m3st=motStopRamp;
 			}
 			break;
 		case motStopRamp:
-			if(ramp(M3,BW,m3pwmap,0,tramp,RAMPRUN)==DONE){
+			if(ramp(M3,FW,m3pwmap,0,tramp,RAMPRUN)==DONE){
 				m3st=motStop;
 			}
 			break;
@@ -187,23 +187,23 @@ motMov_st m4ap(void){
 			SetMotPerc(M4,FW,0);
 			SetMotPerc(M4,BW,0);
 			if(rtCiclo>=apM4start){
-				(void)ramp(M4,BW,mrampstart[M4-1],m2pwmap,tramp,RAMPINIT);
+				(void)ramp(M4,FW,mrampstart[M4-1],m2pwmap,tramp,RAMPINIT);
 				m4st=motStartRamp;
 			}
 			break;
 		case motStartRamp:
-			if(ramp(M4,BW,mrampstart[M4-1],m4pwmap,tramp,RAMPRUN)==DONE){
+			if(ramp(M4,FW,mrampstart[M4-1],m4pwmap,tramp,RAMPRUN)==DONE){
 				m4st=motWaitingTime;
 			}
 			break;
 		case motWaitingTime:
 			if(rtCiclo>=apM4stop){
-				(void)ramp(M4,BW,m4pwmap,0,tramp,RAMPINIT);
+				(void)ramp(M4,FW,m4pwmap,0,tramp,RAMPINIT);
 				m4st=motStopRamp;
 			}
 			break;
 		case motStopRamp:
-			if(ramp(M4,BW,m4pwmap,0,tramp,RAMPRUN)==DONE){
+			if(ramp(M4,FW,m4pwmap,0,tramp,RAMPRUN)==DONE){
 				m4st=motStop;
 			}
 			break;
@@ -231,23 +231,23 @@ motMov_st m1ch(void){
 			SetMotPerc(M1,FW,0);
 			SetMotPerc(M1,BW,0);
 			if(rtCiclo>=chM1start){
-				(void)ramp(M1,FW,mrampstart[M1-1],m1pwmch,tramp,RAMPINIT);
+				(void)ramp(M1,BW,mrampstart[M1-1],m1pwmch,tramp,RAMPINIT);
 				m1st=motStartRamp;
 			}
 			break;
 		case motStartRamp:
-			if(ramp(M1,FW,mrampstart[M1-1],m1pwmch,tramp,RAMPRUN)==DONE){
+			if(ramp(M1,BW,mrampstart[M1-1],m1pwmch,tramp,RAMPRUN)==DONE){
 				m1st=motWaitingTime;
 			}
 			break;
 		case motWaitingTime:
 			if(rtCiclo>=chM1stop){
-				(void)ramp(M1,FW,m1pwmch,0,tramp,RAMPINIT);
+				(void)ramp(M1,BW,m1pwmch,0,tramp,RAMPINIT);
 				m1st=motStopRamp;
 			}
 			break;
 		case motStopRamp:
-			if(ramp(M1,FW,m1pwmch,0,tramp,RAMPRUN)==DONE){
+			if(ramp(M1,BW,m1pwmch,0,tramp,RAMPRUN)==DONE){
 				m1st=motStop;
 			}
 			break;
@@ -321,23 +321,23 @@ motMov_st m3ch(void){
 			SetMotPerc(M3,FW,0);
 			SetMotPerc(M3,BW,0);
 			if(rtCiclo>=chM3start){
-				(void)ramp(M3,FW,mrampstart[M3-1],m2pwmch,tramp,RAMPINIT);
+				(void)ramp(M3,BW,mrampstart[M3-1],m2pwmch,tramp,RAMPINIT);
 				m3st=motStartRamp;
 			}
 			break;
 		case motStartRamp:
-			if(ramp(M3,FW,mrampstart[M3-1],m3pwmch,tramp,RAMPRUN)==DONE){
+			if(ramp(M3,BW,mrampstart[M3-1],m3pwmch,tramp,RAMPRUN)==DONE){
 				m3st=motWaitingTime;
 			}
 			break;
 		case motWaitingTime:
 			if(rtCiclo>=chM3stop){
-				(void)ramp(M3,FW,m3pwmch,0,tramp,RAMPINIT);
+				(void)ramp(M3,BW,m3pwmch,0,tramp,RAMPINIT);
 				m3st=motStopRamp;
 			}
 			break;
 		case motStopRamp:
-			if(ramp(M3,FW,m3pwmch,0,tramp,RAMPRUN)==DONE){
+			if(ramp(M3,BW,m3pwmch,0,tramp,RAMPRUN)==DONE){
 				m3st=motStop;
 			}
 			break;
@@ -366,23 +366,23 @@ motMov_st m4ch(void){
 			SetMotPerc(M4,FW,0);
 			SetMotPerc(M4,BW,0);
 			if(rtCiclo>=chM4start){
-				(void)ramp(M4,FW,mrampstart[M4-1],m4pwmch,tramp,RAMPINIT);
+				(void)ramp(M4,BW,mrampstart[M4-1],m4pwmch,tramp,RAMPINIT);
 				m4st=motStartRamp;
 			}
 			break;
 		case motStartRamp:
-			if(ramp(M4,FW,mrampstart[M4-1],m4pwmch,tramp,RAMPRUN)==DONE){
+			if(ramp(M4,BW,mrampstart[M4-1],m4pwmch,tramp,RAMPRUN)==DONE){
 				m4st=motWaitingTime;
 			}
 			break;
 		case motWaitingTime:
 			if(rtCiclo>=chM4stop){
-				(void)ramp(M4,FW,m4pwmch,0,tramp,RAMPINIT);
+				(void)ramp(M4,BW,m4pwmch,0,tramp,RAMPINIT);
 				m4st=motStopRamp;
 			}
 			break;
 		case motStopRamp:
-			if(ramp(M4,FW,m4pwmch,0,tramp,RAMPRUN)==DONE){
+			if(ramp(M4,BW,m4pwmch,0,tramp,RAMPRUN)==DONE){
 				m4st=motStop;
 			}
 			break;

workspace/AUTOM10/Debug/AUTOM10.list

@@ -6643,7 +6643,7 @@ motMov_st m1ap(void){
  80030ac:	881b      	ldrh	r3, [r3, #0]
  80030ae:	429a      	cmp	r2, r3
  80030b0:	d365      	bcc.n	800317e <m1ap+0x162>
-				(void)ramp(M1,BW,mrampstart[M1-1],m1pwmap,tramp,RAMPINIT);
+				(void)ramp(M1,FW,mrampstart[M1-1],m1pwmap,tramp,RAMPINIT);
  80030b2:	4b3f      	ldr	r3, [pc, #252]	@ (80031b0 <m1ap+0x194>)
  80030b4:	881b      	ldrh	r3, [r3, #0]
  80030b6:	b2da      	uxtb	r2, r3
@@ -6657,7 +6657,7 @@ motMov_st m1ap(void){
  80030c6:	9001      	str	r0, [sp, #4]
  80030c8:	9300      	str	r3, [sp, #0]
  80030ca:	460b      	mov	r3, r1
- 80030cc:	2101      	movs	r1, #1
+ 80030cc:	2100      	movs	r1, #0
  80030ce:	2001      	movs	r0, #1
  80030d0:	f001 f9a2 	bl	8004418 <ramp>
 				m1st=motStartRamp;
@@ -6668,7 +6668,7 @@ motMov_st m1ap(void){
 			break;
  80030da:	e050      	b.n	800317e <m1ap+0x162>
 		case motStartRamp:
-			if(ramp(M1,BW,mrampstart[M1-1],m1pwmap,tramp,RAMPRUN)==DONE){
+			if(ramp(M1,FW,mrampstart[M1-1],m1pwmap,tramp,RAMPRUN)==DONE){
  80030dc:	4b34      	ldr	r3, [pc, #208]	@ (80031b0 <m1ap+0x194>)
  80030de:	881b      	ldrh	r3, [r3, #0]
  80030e0:	b2da      	uxtb	r2, r3
@@ -6682,7 +6682,7 @@ motMov_st m1ap(void){
  80030f0:	9001      	str	r0, [sp, #4]
  80030f2:	9300      	str	r3, [sp, #0]
  80030f4:	460b      	mov	r3, r1
- 80030f6:	2101      	movs	r1, #1
+ 80030f6:	2100      	movs	r1, #0
  80030f8:	2001      	movs	r0, #1
  80030fa:	f001 f98d 	bl	8004418 <ramp>
  80030fe:	4603      	mov	r3, r0
@@ -6704,7 +6704,7 @@ motMov_st m1ap(void){
  8003114:	881b      	ldrh	r3, [r3, #0]
  8003116:	429a      	cmp	r2, r3
  8003118:	d335      	bcc.n	8003186 <m1ap+0x16a>
-				(void)ramp(M1,BW,m1pwmap,0,tramp,RAMPINIT);
+				(void)ramp(M1,FW,m1pwmap,0,tramp,RAMPINIT);
  800311a:	4b26      	ldr	r3, [pc, #152]	@ (80031b4 <m1ap+0x198>)
  800311c:	881b      	ldrh	r3, [r3, #0]
  800311e:	b2da      	uxtb	r2, r3
@@ -6715,7 +6715,7 @@ motMov_st m1ap(void){
  8003128:	9101      	str	r1, [sp, #4]
  800312a:	9300      	str	r3, [sp, #0]
  800312c:	2300      	movs	r3, #0
- 800312e:	2101      	movs	r1, #1
+ 800312e:	2100      	movs	r1, #0
  8003130:	2001      	movs	r0, #1
  8003132:	f001 f971 	bl	8004418 <ramp>
 				m1st=motStopRamp;
@@ -6726,7 +6726,7 @@ motMov_st m1ap(void){
 			break;
  800313c:	e023      	b.n	8003186 <m1ap+0x16a>
 		case motStopRamp:
-			if(ramp(M1,BW,m1pwmap,0,tramp,RAMPRUN)==DONE){
+			if(ramp(M1,FW,m1pwmap,0,tramp,RAMPRUN)==DONE){
  800313e:	4b1d      	ldr	r3, [pc, #116]	@ (80031b4 <m1ap+0x198>)
  8003140:	881b      	ldrh	r3, [r3, #0]
  8003142:	b2da      	uxtb	r2, r3
@@ -6737,7 +6737,7 @@ motMov_st m1ap(void){
  800314c:	9101      	str	r1, [sp, #4]
  800314e:	9300      	str	r3, [sp, #0]
  8003150:	2300      	movs	r3, #0
- 8003152:	2101      	movs	r1, #1
+ 8003152:	2100      	movs	r1, #0
  8003154:	2001      	movs	r0, #1
  8003156:	f001 f95f 	bl	8004418 <ramp>
  800315a:	4603      	mov	r3, r0
@@ -7109,7 +7109,7 @@ motMov_st m3ap(void){
  80033f4:	881b      	ldrh	r3, [r3, #0]
  80033f6:	429a      	cmp	r2, r3
  80033f8:	d365      	bcc.n	80034c6 <m3ap+0x162>
-				(void)ramp(M3,BW,mrampstart[M3-1],m2pwmap,tramp,RAMPINIT);
+				(void)ramp(M3,FW,mrampstart[M3-1],m2pwmap,tramp,RAMPINIT);
  80033fa:	4b3f      	ldr	r3, [pc, #252]	@ (80034f8 <m3ap+0x194>)
  80033fc:	889b      	ldrh	r3, [r3, #4]
  80033fe:	b2da      	uxtb	r2, r3
@@ -7123,7 +7123,7 @@ motMov_st m3ap(void){
  800340e:	9001      	str	r0, [sp, #4]
  8003410:	9300      	str	r3, [sp, #0]
  8003412:	460b      	mov	r3, r1
- 8003414:	2101      	movs	r1, #1
+ 8003414:	2100      	movs	r1, #0
  8003416:	2003      	movs	r0, #3
  8003418:	f000 fffe 	bl	8004418 <ramp>
 				m3st=motStartRamp;
@@ -7134,7 +7134,7 @@ motMov_st m3ap(void){
 			break;
  8003422:	e050      	b.n	80034c6 <m3ap+0x162>
 		case motStartRamp:
-			if(ramp(M3,BW,mrampstart[M3-1],m3pwmap,tramp,RAMPRUN)==DONE){
+			if(ramp(M3,FW,mrampstart[M3-1],m3pwmap,tramp,RAMPRUN)==DONE){
  8003424:	4b34      	ldr	r3, [pc, #208]	@ (80034f8 <m3ap+0x194>)
  8003426:	889b      	ldrh	r3, [r3, #4]
  8003428:	b2da      	uxtb	r2, r3
@@ -7148,7 +7148,7 @@ motMov_st m3ap(void){
  8003438:	9001      	str	r0, [sp, #4]
  800343a:	9300      	str	r3, [sp, #0]
  800343c:	460b      	mov	r3, r1
- 800343e:	2101      	movs	r1, #1
+ 800343e:	2100      	movs	r1, #0
  8003440:	2003      	movs	r0, #3
  8003442:	f000 ffe9 	bl	8004418 <ramp>
  8003446:	4603      	mov	r3, r0
@@ -7170,7 +7170,7 @@ motMov_st m3ap(void){
  800345c:	881b      	ldrh	r3, [r3, #0]
  800345e:	429a      	cmp	r2, r3
  8003460:	d335      	bcc.n	80034ce <m3ap+0x16a>
-				(void)ramp(M3,BW,m3pwmap,0,tramp,RAMPINIT);
+				(void)ramp(M3,FW,m3pwmap,0,tramp,RAMPINIT);
  8003462:	4b28      	ldr	r3, [pc, #160]	@ (8003504 <m3ap+0x1a0>)
  8003464:	881b      	ldrh	r3, [r3, #0]
  8003466:	b2da      	uxtb	r2, r3
@@ -7181,7 +7181,7 @@ motMov_st m3ap(void){
  8003470:	9101      	str	r1, [sp, #4]
  8003472:	9300      	str	r3, [sp, #0]
  8003474:	2300      	movs	r3, #0
- 8003476:	2101      	movs	r1, #1
+ 8003476:	2100      	movs	r1, #0
  8003478:	2003      	movs	r0, #3
  800347a:	f000 ffcd 	bl	8004418 <ramp>
 				m3st=motStopRamp;
@@ -7192,7 +7192,7 @@ motMov_st m3ap(void){
 			break;
  8003484:	e023      	b.n	80034ce <m3ap+0x16a>
 		case motStopRamp:
-			if(ramp(M3,BW,m3pwmap,0,tramp,RAMPRUN)==DONE){
+			if(ramp(M3,FW,m3pwmap,0,tramp,RAMPRUN)==DONE){
  8003486:	4b1f      	ldr	r3, [pc, #124]	@ (8003504 <m3ap+0x1a0>)
  8003488:	881b      	ldrh	r3, [r3, #0]
  800348a:	b2da      	uxtb	r2, r3
@@ -7203,7 +7203,7 @@ motMov_st m3ap(void){
  8003494:	9101      	str	r1, [sp, #4]
  8003496:	9300      	str	r3, [sp, #0]
  8003498:	2300      	movs	r3, #0
- 800349a:	2101      	movs	r1, #1
+ 800349a:	2100      	movs	r1, #0
  800349c:	2003      	movs	r0, #3
  800349e:	f000 ffbb 	bl	8004418 <ramp>
  80034a2:	4603      	mov	r3, r0
@@ -7343,7 +7343,7 @@ motMov_st m4ap(void){
  800359c:	881b      	ldrh	r3, [r3, #0]
  800359e:	429a      	cmp	r2, r3
  80035a0:	d365      	bcc.n	800366e <m4ap+0x162>
-				(void)ramp(M4,BW,mrampstart[M4-1],m2pwmap,tramp,RAMPINIT);
+				(void)ramp(M4,FW,mrampstart[M4-1],m2pwmap,tramp,RAMPINIT);
  80035a2:	4b3f      	ldr	r3, [pc, #252]	@ (80036a0 <m4ap+0x194>)
  80035a4:	88db      	ldrh	r3, [r3, #6]
  80035a6:	b2da      	uxtb	r2, r3
@@ -7357,7 +7357,7 @@ motMov_st m4ap(void){
  80035b6:	9001      	str	r0, [sp, #4]
  80035b8:	9300      	str	r3, [sp, #0]
  80035ba:	460b      	mov	r3, r1
- 80035bc:	2101      	movs	r1, #1
+ 80035bc:	2100      	movs	r1, #0
  80035be:	2004      	movs	r0, #4
  80035c0:	f000 ff2a 	bl	8004418 <ramp>
 				m4st=motStartRamp;
@@ -7368,7 +7368,7 @@ motMov_st m4ap(void){
 			break;
  80035ca:	e050      	b.n	800366e <m4ap+0x162>
 		case motStartRamp:
-			if(ramp(M4,BW,mrampstart[M4-1],m4pwmap,tramp,RAMPRUN)==DONE){
+			if(ramp(M4,FW,mrampstart[M4-1],m4pwmap,tramp,RAMPRUN)==DONE){
  80035cc:	4b34      	ldr	r3, [pc, #208]	@ (80036a0 <m4ap+0x194>)
  80035ce:	88db      	ldrh	r3, [r3, #6]
  80035d0:	b2da      	uxtb	r2, r3
@@ -7382,7 +7382,7 @@ motMov_st m4ap(void){
  80035e0:	9001      	str	r0, [sp, #4]
  80035e2:	9300      	str	r3, [sp, #0]
  80035e4:	460b      	mov	r3, r1
- 80035e6:	2101      	movs	r1, #1
+ 80035e6:	2100      	movs	r1, #0
  80035e8:	2004      	movs	r0, #4
  80035ea:	f000 ff15 	bl	8004418 <ramp>
  80035ee:	4603      	mov	r3, r0
@@ -7404,7 +7404,7 @@ motMov_st m4ap(void){
  8003604:	881b      	ldrh	r3, [r3, #0]
  8003606:	429a      	cmp	r2, r3
  8003608:	d335      	bcc.n	8003676 <m4ap+0x16a>
-				(void)ramp(M4,BW,m4pwmap,0,tramp,RAMPINIT);
+				(void)ramp(M4,FW,m4pwmap,0,tramp,RAMPINIT);
  800360a:	4b28      	ldr	r3, [pc, #160]	@ (80036ac <m4ap+0x1a0>)
  800360c:	881b      	ldrh	r3, [r3, #0]
  800360e:	b2da      	uxtb	r2, r3
@@ -7415,7 +7415,7 @@ motMov_st m4ap(void){
  8003618:	9101      	str	r1, [sp, #4]
  800361a:	9300      	str	r3, [sp, #0]
  800361c:	2300      	movs	r3, #0
- 800361e:	2101      	movs	r1, #1
+ 800361e:	2100      	movs	r1, #0
  8003620:	2004      	movs	r0, #4
  8003622:	f000 fef9 	bl	8004418 <ramp>
 				m4st=motStopRamp;
@@ -7426,7 +7426,7 @@ motMov_st m4ap(void){
 			break;
  800362c:	e023      	b.n	8003676 <m4ap+0x16a>
 		case motStopRamp:
-			if(ramp(M4,BW,m4pwmap,0,tramp,RAMPRUN)==DONE){
+			if(ramp(M4,FW,m4pwmap,0,tramp,RAMPRUN)==DONE){
  800362e:	4b1f      	ldr	r3, [pc, #124]	@ (80036ac <m4ap+0x1a0>)
  8003630:	881b      	ldrh	r3, [r3, #0]
  8003632:	b2da      	uxtb	r2, r3
@@ -7437,7 +7437,7 @@ motMov_st m4ap(void){
  800363c:	9101      	str	r1, [sp, #4]
  800363e:	9300      	str	r3, [sp, #0]
  8003640:	2300      	movs	r3, #0
- 8003642:	2101      	movs	r1, #1
+ 8003642:	2100      	movs	r1, #0
  8003644:	2004      	movs	r0, #4
  8003646:	f000 fee7 	bl	8004418 <ramp>
  800364a:	4603      	mov	r3, r0
@@ -7577,7 +7577,7 @@ motMov_st m1ch(void){
  8003744:	881b      	ldrh	r3, [r3, #0]
  8003746:	429a      	cmp	r2, r3
  8003748:	d365      	bcc.n	8003816 <m1ch+0x162>
-				(void)ramp(M1,FW,mrampstart[M1-1],m1pwmch,tramp,RAMPINIT);
+				(void)ramp(M1,BW,mrampstart[M1-1],m1pwmch,tramp,RAMPINIT);
  800374a:	4b3f      	ldr	r3, [pc, #252]	@ (8003848 <m1ch+0x194>)
  800374c:	881b      	ldrh	r3, [r3, #0]
  800374e:	b2da      	uxtb	r2, r3
@@ -7591,7 +7591,7 @@ motMov_st m1ch(void){
  800375e:	9001      	str	r0, [sp, #4]
  8003760:	9300      	str	r3, [sp, #0]
  8003762:	460b      	mov	r3, r1
- 8003764:	2100      	movs	r1, #0
+ 8003764:	2101      	movs	r1, #1
  8003766:	2001      	movs	r0, #1
  8003768:	f000 fe56 	bl	8004418 <ramp>
 				m1st=motStartRamp;
@@ -7602,7 +7602,7 @@ motMov_st m1ch(void){
 			break;
  8003772:	e050      	b.n	8003816 <m1ch+0x162>
 		case motStartRamp:
-			if(ramp(M1,FW,mrampstart[M1-1],m1pwmch,tramp,RAMPRUN)==DONE){
+			if(ramp(M1,BW,mrampstart[M1-1],m1pwmch,tramp,RAMPRUN)==DONE){
  8003774:	4b34      	ldr	r3, [pc, #208]	@ (8003848 <m1ch+0x194>)
  8003776:	881b      	ldrh	r3, [r3, #0]
  8003778:	b2da      	uxtb	r2, r3
@@ -7616,7 +7616,7 @@ motMov_st m1ch(void){
  8003788:	9001      	str	r0, [sp, #4]
  800378a:	9300      	str	r3, [sp, #0]
  800378c:	460b      	mov	r3, r1
- 800378e:	2100      	movs	r1, #0
+ 800378e:	2101      	movs	r1, #1
  8003790:	2001      	movs	r0, #1
  8003792:	f000 fe41 	bl	8004418 <ramp>
  8003796:	4603      	mov	r3, r0
@@ -7638,7 +7638,7 @@ motMov_st m1ch(void){
  80037ac:	881b      	ldrh	r3, [r3, #0]
  80037ae:	429a      	cmp	r2, r3
  80037b0:	d335      	bcc.n	800381e <m1ch+0x16a>
-				(void)ramp(M1,FW,m1pwmch,0,tramp,RAMPINIT);
+				(void)ramp(M1,BW,m1pwmch,0,tramp,RAMPINIT);
  80037b2:	4b26      	ldr	r3, [pc, #152]	@ (800384c <m1ch+0x198>)
  80037b4:	881b      	ldrh	r3, [r3, #0]
  80037b6:	b2da      	uxtb	r2, r3
@@ -7649,7 +7649,7 @@ motMov_st m1ch(void){
  80037c0:	9101      	str	r1, [sp, #4]
  80037c2:	9300      	str	r3, [sp, #0]
  80037c4:	2300      	movs	r3, #0
- 80037c6:	2100      	movs	r1, #0
+ 80037c6:	2101      	movs	r1, #1
  80037c8:	2001      	movs	r0, #1
  80037ca:	f000 fe25 	bl	8004418 <ramp>
 				m1st=motStopRamp;
@@ -7660,7 +7660,7 @@ motMov_st m1ch(void){
 			break;
  80037d4:	e023      	b.n	800381e <m1ch+0x16a>
 		case motStopRamp:
-			if(ramp(M1,FW,m1pwmch,0,tramp,RAMPRUN)==DONE){
+			if(ramp(M1,BW,m1pwmch,0,tramp,RAMPRUN)==DONE){
  80037d6:	4b1d      	ldr	r3, [pc, #116]	@ (800384c <m1ch+0x198>)
  80037d8:	881b      	ldrh	r3, [r3, #0]
  80037da:	b2da      	uxtb	r2, r3
@@ -7671,7 +7671,7 @@ motMov_st m1ch(void){
  80037e4:	9101      	str	r1, [sp, #4]
  80037e6:	9300      	str	r3, [sp, #0]
  80037e8:	2300      	movs	r3, #0
- 80037ea:	2100      	movs	r1, #0
+ 80037ea:	2101      	movs	r1, #1
  80037ec:	2001      	movs	r0, #1
  80037ee:	f000 fe13 	bl	8004418 <ramp>
  80037f2:	4603      	mov	r3, r0
@@ -8045,7 +8045,7 @@ motMov_st m3ch(void){
  8003a8c:	881b      	ldrh	r3, [r3, #0]
  8003a8e:	429a      	cmp	r2, r3
  8003a90:	d365      	bcc.n	8003b5e <m3ch+0x162>
-				(void)ramp(M3,FW,mrampstart[M3-1],m2pwmch,tramp,RAMPINIT);
+				(void)ramp(M3,BW,mrampstart[M3-1],m2pwmch,tramp,RAMPINIT);
  8003a92:	4b3f      	ldr	r3, [pc, #252]	@ (8003b90 <m3ch+0x194>)
  8003a94:	889b      	ldrh	r3, [r3, #4]
  8003a96:	b2da      	uxtb	r2, r3
@@ -8059,7 +8059,7 @@ motMov_st m3ch(void){
  8003aa6:	9001      	str	r0, [sp, #4]
  8003aa8:	9300      	str	r3, [sp, #0]
  8003aaa:	460b      	mov	r3, r1
- 8003aac:	2100      	movs	r1, #0
+ 8003aac:	2101      	movs	r1, #1
  8003aae:	2003      	movs	r0, #3
  8003ab0:	f000 fcb2 	bl	8004418 <ramp>
 				m3st=motStartRamp;
@@ -8070,7 +8070,7 @@ motMov_st m3ch(void){
 			break;
  8003aba:	e050      	b.n	8003b5e <m3ch+0x162>
 		case motStartRamp:
-			if(ramp(M3,FW,mrampstart[M3-1],m3pwmch,tramp,RAMPRUN)==DONE){
+			if(ramp(M3,BW,mrampstart[M3-1],m3pwmch,tramp,RAMPRUN)==DONE){
  8003abc:	4b34      	ldr	r3, [pc, #208]	@ (8003b90 <m3ch+0x194>)
  8003abe:	889b      	ldrh	r3, [r3, #4]
  8003ac0:	b2da      	uxtb	r2, r3
@@ -8084,7 +8084,7 @@ motMov_st m3ch(void){
  8003ad0:	9001      	str	r0, [sp, #4]
  8003ad2:	9300      	str	r3, [sp, #0]
  8003ad4:	460b      	mov	r3, r1
- 8003ad6:	2100      	movs	r1, #0
+ 8003ad6:	2101      	movs	r1, #1
  8003ad8:	2003      	movs	r0, #3
  8003ada:	f000 fc9d 	bl	8004418 <ramp>
  8003ade:	4603      	mov	r3, r0
@@ -8106,7 +8106,7 @@ motMov_st m3ch(void){
  8003af4:	881b      	ldrh	r3, [r3, #0]
  8003af6:	429a      	cmp	r2, r3
  8003af8:	d335      	bcc.n	8003b66 <m3ch+0x16a>
-				(void)ramp(M3,FW,m3pwmch,0,tramp,RAMPINIT);
+				(void)ramp(M3,BW,m3pwmch,0,tramp,RAMPINIT);
  8003afa:	4b28      	ldr	r3, [pc, #160]	@ (8003b9c <m3ch+0x1a0>)
  8003afc:	881b      	ldrh	r3, [r3, #0]
  8003afe:	b2da      	uxtb	r2, r3
@@ -8117,7 +8117,7 @@ motMov_st m3ch(void){
  8003b08:	9101      	str	r1, [sp, #4]
  8003b0a:	9300      	str	r3, [sp, #0]
  8003b0c:	2300      	movs	r3, #0
- 8003b0e:	2100      	movs	r1, #0
+ 8003b0e:	2101      	movs	r1, #1
  8003b10:	2003      	movs	r0, #3
  8003b12:	f000 fc81 	bl	8004418 <ramp>
 				m3st=motStopRamp;
@@ -8128,7 +8128,7 @@ motMov_st m3ch(void){
 			break;
  8003b1c:	e023      	b.n	8003b66 <m3ch+0x16a>
 		case motStopRamp:
-			if(ramp(M3,FW,m3pwmch,0,tramp,RAMPRUN)==DONE){
+			if(ramp(M3,BW,m3pwmch,0,tramp,RAMPRUN)==DONE){
  8003b1e:	4b1f      	ldr	r3, [pc, #124]	@ (8003b9c <m3ch+0x1a0>)
  8003b20:	881b      	ldrh	r3, [r3, #0]
  8003b22:	b2da      	uxtb	r2, r3
@@ -8139,7 +8139,7 @@ motMov_st m3ch(void){
  8003b2c:	9101      	str	r1, [sp, #4]
  8003b2e:	9300      	str	r3, [sp, #0]
  8003b30:	2300      	movs	r3, #0
- 8003b32:	2100      	movs	r1, #0
+ 8003b32:	2101      	movs	r1, #1
  8003b34:	2003      	movs	r0, #3
  8003b36:	f000 fc6f 	bl	8004418 <ramp>
  8003b3a:	4603      	mov	r3, r0
@@ -8280,7 +8280,7 @@ motMov_st m4ch(void){
  8003c34:	881b      	ldrh	r3, [r3, #0]
  8003c36:	429a      	cmp	r2, r3
  8003c38:	d365      	bcc.n	8003d06 <m4ch+0x162>
-				(void)ramp(M4,FW,mrampstart[M4-1],m4pwmch,tramp,RAMPINIT);
+				(void)ramp(M4,BW,mrampstart[M4-1],m4pwmch,tramp,RAMPINIT);
  8003c3a:	4b3f      	ldr	r3, [pc, #252]	@ (8003d38 <m4ch+0x194>)
  8003c3c:	88db      	ldrh	r3, [r3, #6]
  8003c3e:	b2da      	uxtb	r2, r3
@@ -8294,7 +8294,7 @@ motMov_st m4ch(void){
  8003c4e:	9001      	str	r0, [sp, #4]
  8003c50:	9300      	str	r3, [sp, #0]
  8003c52:	460b      	mov	r3, r1
- 8003c54:	2100      	movs	r1, #0
+ 8003c54:	2101      	movs	r1, #1
  8003c56:	2004      	movs	r0, #4
  8003c58:	f000 fbde 	bl	8004418 <ramp>
 				m4st=motStartRamp;
@@ -8305,7 +8305,7 @@ motMov_st m4ch(void){
 			break;
  8003c62:	e050      	b.n	8003d06 <m4ch+0x162>
 		case motStartRamp:
-			if(ramp(M4,FW,mrampstart[M4-1],m4pwmch,tramp,RAMPRUN)==DONE){
+			if(ramp(M4,BW,mrampstart[M4-1],m4pwmch,tramp,RAMPRUN)==DONE){
  8003c64:	4b34      	ldr	r3, [pc, #208]	@ (8003d38 <m4ch+0x194>)
  8003c66:	88db      	ldrh	r3, [r3, #6]
  8003c68:	b2da      	uxtb	r2, r3
@@ -8319,7 +8319,7 @@ motMov_st m4ch(void){
  8003c78:	9001      	str	r0, [sp, #4]
  8003c7a:	9300      	str	r3, [sp, #0]
  8003c7c:	460b      	mov	r3, r1
- 8003c7e:	2100      	movs	r1, #0
+ 8003c7e:	2101      	movs	r1, #1
  8003c80:	2004      	movs	r0, #4
  8003c82:	f000 fbc9 	bl	8004418 <ramp>
  8003c86:	4603      	mov	r3, r0
@@ -8341,7 +8341,7 @@ motMov_st m4ch(void){
  8003c9c:	881b      	ldrh	r3, [r3, #0]
  8003c9e:	429a      	cmp	r2, r3
  8003ca0:	d335      	bcc.n	8003d0e <m4ch+0x16a>
-				(void)ramp(M4,FW,m4pwmch,0,tramp,RAMPINIT);
+				(void)ramp(M4,BW,m4pwmch,0,tramp,RAMPINIT);
  8003ca2:	4b26      	ldr	r3, [pc, #152]	@ (8003d3c <m4ch+0x198>)
  8003ca4:	881b      	ldrh	r3, [r3, #0]
  8003ca6:	b2da      	uxtb	r2, r3
@@ -8352,7 +8352,7 @@ motMov_st m4ch(void){
  8003cb0:	9101      	str	r1, [sp, #4]
  8003cb2:	9300      	str	r3, [sp, #0]
  8003cb4:	2300      	movs	r3, #0
- 8003cb6:	2100      	movs	r1, #0
+ 8003cb6:	2101      	movs	r1, #1
  8003cb8:	2004      	movs	r0, #4
  8003cba:	f000 fbad 	bl	8004418 <ramp>
 				m4st=motStopRamp;
@@ -8363,7 +8363,7 @@ motMov_st m4ch(void){
 			break;
  8003cc4:	e023      	b.n	8003d0e <m4ch+0x16a>
 		case motStopRamp:
-			if(ramp(M4,FW,m4pwmch,0,tramp,RAMPRUN)==DONE){
+			if(ramp(M4,BW,m4pwmch,0,tramp,RAMPRUN)==DONE){
  8003cc6:	4b1d      	ldr	r3, [pc, #116]	@ (8003d3c <m4ch+0x198>)
  8003cc8:	881b      	ldrh	r3, [r3, #0]
  8003cca:	b2da      	uxtb	r2, r3
@@ -8374,7 +8374,7 @@ motMov_st m4ch(void){
  8003cd4:	9101      	str	r1, [sp, #4]
  8003cd6:	9300      	str	r3, [sp, #0]
  8003cd8:	2300      	movs	r3, #0
- 8003cda:	2100      	movs	r1, #0
+ 8003cda:	2101      	movs	r1, #1
  8003cdc:	2004      	movs	r0, #4
  8003cde:	f000 fb9b 	bl	8004418 <ramp>
  8003ce2:	4603      	mov	r3, r0