therm Changeset - e1ff9c2d3789 · protofusion repositories

Changeset - e1ff9c2d3789

Parent rev.

Child rev.

[Not reviewed]

default

0 1 0

Ethan Zonca - 10 years ago 2014-09-25 21:17:44
ez@ethanzonca.com

Initial attempt of minimal eeprom lib, doesn't seem to save properly.

1 file changed with 105 insertions and 33 deletions:

main.c

105

0 comments (0 inline, 0 general)

main.c

➞

Show inline comments

@@ @@ -283,160 +283,232 @@ void process() @@
+}
 void draw_setpoint() {
     char tempstr[3];
     itoa_fp(temp, temp_frac, tempstr);
     //ssd1306_DrawString("        ", 3, 40);
     ssd1306_DrawString(tempstr, 3, 40);
     ssd1306_DrawString("-> ", 3, 80);
     itoa(setpoint, tempstr);
     ssd1306_DrawString("    ", 3, 95);
     ssd1306_DrawString(tempstr, 3, 95);
+}
 uint8_t goto_mode = 2;
 // State machine
 uint8_t sw_btn_last = 0;
 uint8_t sw_up_last = 0;
 uint8_t sw_down_last = 0;
 uint8_t sw_left_last = 0;
 uint8_t sw_right_last = 0;
 #define SW_BTN_PRESSED (sw_btn_last == 0 && sw_btn == 1) // rising edge on buttonpress
 #define SW_UP_PRESSED (sw_up_last == 0 && sw_up == 1)
 #define SW_DOWN_PRESSED (sw_down_last == 0 && sw_down == 1)
 #define SW_LEFT_PRESSED (sw_left_last == 0 && sw_left == 1)
 #define SW_RIGHT_PRESSED (sw_right_last == 0 && sw_right == 1)
 /*
  * uint8_t boottobrew = 0;
 #define WINDUP_GUARD_GAIN 100
 uint16_t windup_guard = WINDUP_GUARD_GAIN;
 uint16_t k_p = 1;
 uint16_t k_i = 1;
 uint16_t k_d = 1;*/
 #define EEPROM_ADDR_WINDUP_GUARD 	0x001C
 #define EEPROM_ADDR_BOOTTOBREW		0x0020
 #define EEPROM_ADDR_K_P			0x0024
 #define EEPROM_ADDR_K_I			0x0028
 #define EEPROM_ADDR_K_D			0x002C
 #define EEPROM_ADDR_BREWTEMP		0x0030
 #define EEPROM_ADDR_STEAMTEMP		0x0034
 #define EEPROM_BASE_ADDR    0x08080000
 #define EEPROM_BYTE_SIZE    0x0FFF
 /*
 uint32_t EEPROM_ReadWord(uint16_t Addr)
 void Minimal_EEPROM_Unlock(void)
+{
   if((FLASH->PECR & FLASH_PECR_PELOCK) != RESET)
+{
     uint32 *wAddr;
     wAddr=(uint32 *)(EEPROM_BASE_ADDR+Addr);
     /* Unlocking the Data memory and FLASH_PECR register access*/
     FLASH->PEKEYR = FLASH_PEKEY1;
     FLASH->PEKEYR = FLASH_PEKEY2;
+  }
+}
 void Minimal_EEPROM_Lock(void)
+{
   /* Set the PELOCK Bit to lock the data memory and FLASH_PECR register access */
   FLASH->PECR |= FLASH_PECR_PELOCK;
+}
 FLASH_Status Minimal_FLASH_GetStatus(void)
+{
   FLASH_Status FLASHstatus = FLASH_COMPLETE;
     uint32 res;
     res = *wAddr++;
     while(Length--){
         *Buffer++=*wAddr++;
   if((FLASH->SR & FLASH_FLAG_BSY) == FLASH_FLAG_BSY)
+  {
     FLASHstatus = FLASH_BUSY;
+  }
   else
+  {
     if((FLASH->SR & (uint32_t)FLASH_FLAG_WRPERR)!= (uint32_t)0x00)
+    {
       FLASHstatus = FLASH_ERROR_WRP;
+    }
     else
+    {
       if((FLASH->SR & (uint32_t)0x1E00) != (uint32_t)0x00)
+      {
         FLASHstatus = FLASH_ERROR_PROGRAM;
+      }
       else
+      {
         FLASHstatus = FLASH_COMPLETE;
+      }
+    }
+}
 */
   /* Return the FLASH Status */
   return FLASHstatus;
+}
 FLASH_Status Minimal_FLASH_WaitForLastOperation(uint32_t Timeout)
+{
   __IO FLASH_Status status = FLASH_COMPLETE;
   /* Check for the FLASH Status */
   status = Minimal_FLASH_GetStatus();
   /* Wait for a FLASH operation to complete or a TIMEOUT to occur */
   while((status == FLASH_BUSY) && (Timeout != 0x00))
+  {
     status = Minimal_FLASH_GetStatus();
     Timeout--;
+  }
   if(Timeout == 0x00 )
+  {
     status = FLASH_TIMEOUT;
+  }
   /* Return the operation status */
   return status;
+}
 void Minimal_EEPROM_ProgramWord(uint32_t Address, uint32_t Data)
+{
   // Wait for last operation to be completed
   FLASH_Status status = FLASH_COMPLETE;
   status = Minimal_FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT);
   if(status == FLASH_COMPLETE)
+  {
     *(__IO uint32_t *)Address = Data;
     // Wait for last operation to be completed
     status = Minimal_FLASH_WaitForLastOperation(FLASH_ER_PRG_TIMEOUT);
+  }
   // Return the Write Status
   return status;
+}
 void save_settings()
+{
-    DATA_EEPROM_Unlock();
+   Minimal_EEPROM_Unlock();
     // Try programming a word at an address divisible by 4
     DATA_EEPROM_ProgramWord(EEPROM_BASE_ADDR + EEPROM_ADDR_BOOTTOBREW, boottobrew);
     DATA_EEPROM_ProgramWord(EEPROM_BASE_ADDR + EEPROM_ADDR_WINDUP_GUARD, windup_guard);
     DATA_EEPROM_ProgramWord(EEPROM_BASE_ADDR + EEPROM_ADDR_K_P, k_p);
     DATA_EEPROM_ProgramWord(EEPROM_BASE_ADDR + EEPROM_ADDR_K_I, k_i);
     DATA_EEPROM_ProgramWord(EEPROM_BASE_ADDR + EEPROM_ADDR_K_D, k_d);
     DATA_EEPROM_Lock();
     Minimal_EEPROM_ProgramWord(EEPROM_BASE_ADDR + EEPROM_ADDR_BOOTTOBREW, boottobrew);
     Minimal_EEPROM_ProgramWord(EEPROM_BASE_ADDR + EEPROM_ADDR_WINDUP_GUARD, windup_guard);
     Minimal_EEPROM_ProgramWord(EEPROM_BASE_ADDR + EEPROM_ADDR_K_P, k_p);
     Minimal_EEPROM_ProgramWord(EEPROM_BASE_ADDR + EEPROM_ADDR_K_I, k_i);
     Minimal_EEPROM_ProgramWord(EEPROM_BASE_ADDR + EEPROM_ADDR_K_D, k_d);
     Minimal_EEPROM_Lock();
+}
+}
 void save_setpoints()
+{
     DATA_EEPROM_Unlock();
     DATA_EEPROM_ProgramWord(EEPROM_BASE_ADDR + EEPROM_ADDR_BREWTEMP, setpoint_brew);
     DATA_EEPROM_ProgramWord(EEPROM_BASE_ADDR + EEPROM_ADDR_STEAMTEMP, setpoint_steam);
     DATA_EEPROM_Lock();
     Minimal_EEPROM_Unlock();
     Minimal_EEPROM_ProgramWord(EEPROM_BASE_ADDR + EEPROM_ADDR_BREWTEMP, setpoint_brew);
     Minimal_EEPROM_ProgramWord(EEPROM_BASE_ADDR + EEPROM_ADDR_STEAMTEMP, setpoint_steam);
     Minimal_EEPROM_Lock();
+}
 // TODO: Save/restore temperature setpoint settings
 void restore_settings()
+{
     DATA_EEPROM_Unlock();
     while(FLASH_GetStatus()==FLASH_BUSY);
     Minimal_EEPROM_Unlock();
     while(Minimal_FLASH_GetStatus()==FLASH_BUSY);
     boottobrew = (*(__IO uint32_t*)EEPROM_BASE_ADDR + EEPROM_ADDR_BOOTTOBREW);
-    while(FLASH_GetStatus()==FLASH_BUSY);
+    while(Minimal_FLASH_GetStatus()==FLASH_BUSY);
     windup_guard = (*(__IO uint32_t*)EEPROM_BASE_ADDR + EEPROM_ADDR_WINDUP_GUARD);
-    while(FLASH_GetStatus()==FLASH_BUSY);
+    while(Minimal_FLASH_GetStatus()==FLASH_BUSY);
     k_p = (*(__IO uint32_t*)EEPROM_BASE_ADDR + EEPROM_ADDR_K_P);
-    while(FLASH_GetStatus()==FLASH_BUSY);
+    while(Minimal_FLASH_GetStatus()==FLASH_BUSY);
     k_i = (*(__IO uint32_t*)EEPROM_BASE_ADDR + EEPROM_ADDR_K_I);
-    while(FLASH_GetStatus()==FLASH_BUSY);
+    while(Minimal_FLASH_GetStatus()==FLASH_BUSY);
     k_d = (*(__IO uint32_t*)EEPROM_BASE_ADDR + EEPROM_ADDR_K_D);
-    while(FLASH_GetStatus()==FLASH_BUSY);
+    while(Minimal_FLASH_GetStatus()==FLASH_BUSY);
     setpoint_brew = (*(__IO uint32_t*)EEPROM_BASE_ADDR + EEPROM_ADDR_BREWTEMP);
-    while(FLASH_GetStatus()==FLASH_BUSY);
+    while(Minimal_FLASH_GetStatus()==FLASH_BUSY);
     setpoint_steam = (*(__IO uint32_t*)EEPROM_BASE_ADDR + EEPROM_ADDR_STEAMTEMP);
     DATA_EEPROM_Lock();
     Minimal_EEPROM_Lock();
+}
 void user_input(uint16_t* to_modify)
+{
     if(CHANGE_ELAPSED) {
         // TODO: Make function that takes reference to a var and increase/decreases it based on buttonpress
         if(!GPIO_ReadInputDataBit(SW_UP) ) {
             CHANGE_RESET;
             (*to_modify)++;
+        }
         else if(!GPIO_ReadInputDataBit(SW_DOWN) && (*to_modify) > 0) {
             CHANGE_RESET;
             (*to_modify)--;
+        }
+    }
+}
 void machine()
+{
     uint8_t last_state = state;
     uint8_t sw_btn = !GPIO_ReadInputDataBit(SW_BTN);
     uint8_t sw_up = !GPIO_ReadInputDataBit(SW_UP);
     uint8_t sw_down = !GPIO_ReadInputDataBit(SW_DOWN);
     uint8_t sw_left = !GPIO_ReadInputDataBit(SW_LEFT);
     uint8_t sw_right = !GPIO_ReadInputDataBit(SW_RIGHT);
     switch(state)
+    {
         // Idle state
         case STATE_IDLE:
+        {
             // Write text to OLED
             // [ therm :: idle ]
             ssd1306_DrawString("therm :: idle ", 0, 40);
             pid_enabled = 0;
             char tempstr[6];
             itoa_fp(temp, temp_frac, tempstr);
             ssd1306_DrawString("Temp: ", 3, 40);
             ssd1306_DrawString("    ", 3, 72);
             ssd1306_DrawString(tempstr, 3, 72);
             ssd1306_drawlogo();

0 comments (0 inline, 0 general)