WebSVN – HomeAutomation – Diff – /trunk/EmbeddedSoftware/AVR/module/act_PIDv1/act_PIDv1.c

 x00,   //uint8_t TimeMsOrS;
 x0000, //uint16_t Time;
         CAN_MODULE_TYPE_ACT_SOFTPWM,    //ActuatorModuleType
 x00,   //ActuatorModuleId
 x00,   //ActuatorId
+x00000000, //uint32_t MAX; (float)
+x00000000, //uint32_t MIN; (float)
     },
   // crc, must be a correct value, but this will also be handled by the EEPROM module or make scripts
 };
 #endif
 #define PID_ON 1
       eeprom_write_byte_crc(EEDATA.sensorModuleId, PIDv1_TEMPERATURE_SENSOR_MODULE_ID, WITHOUT_CRC);
       eeprom_write_byte_crc(EEDATA.sensorId, PIDv1_TEMPERATURE_SENSOR, WITHOUT_CRC);
       eeprom_write_dword_crc(EEDATA32.K_P, 850.0f, WITHOUT_CRC);
       eeprom_write_dword_crc(EEDATA32.K_I, 0.5f, WITHOUT_CRC);
       eeprom_write_dword_crc(EEDATA32.K_D, 0.1f, WITHOUT_CRC);
+      eeprom_write_dword_crc(EEDATA32.MIN, 0, WITHOUT_CRC);
+      eeprom_write_dword_crc(EEDATA32.MAX, 0, WITHOUT_CRC);
       eeprom_write_byte_crc(EEDATA.TimeMsOrS, DEFAULT_PIDv1_CALC_PERIOD_UNIT, WITHOUT_CRC);
       eeprom_write_word_crc(EEDATA16.Time, DEFAULT_PIDv1_CALC_PERIOD, WITHOUT_CRC);
       eeprom_write_byte_crc(EEDATA.actuatorModuleType, PIDv1_PWM_ACTUATOR_MODULE_TYPE, WITHOUT_CRC);
       eeprom_write_byte_crc(EEDATA.actuatorModuleId, PIDv1_PWM_ACTUATOR_MODULE_ID, WITHOUT_CRC);
       eeprom_write_byte_crc(EEDATA.actuatorId, PIDv1_PWM_ACTUATOR, WITHOUT_CRC);
     sensorModuleId = eeprom_read_byte(EEDATA.sensorModuleId);
     sensorId = eeprom_read_byte(EEDATA.sensorId);
     uint32_t data_P = eeprom_read_dword(EEDATA32.K_P);
     uint32_t data_I = eeprom_read_dword(EEDATA32.K_I);
     uint32_t data_D = eeprom_read_dword(EEDATA32.K_D);
+    uint32_t Max_D = eeprom_read_dword(EEDATA32.MAX);
+    uint32_t Min_D = eeprom_read_dword(EEDATA32.MIN);
     float data_P_f;// = *((float*)((&data_P)));
     float data_I_f;// = *((float*)((&data_I)));
     float data_D_f;// = *((float*)(&data_D));
+    float Max_out_f;// = *((float*)((&data_I)));
+    float Min_out_f;// = *((float*)(&data_D));
     memcpy(&data_P_f, &data_P, sizeof(data_P));
     memcpy(&data_I_f, &data_I, sizeof(data_I));
     memcpy(&data_D_f, &data_D, sizeof(data_D));
+    memcpy(&Min_out_f, &Min_D, sizeof(Min_D));
+    memcpy(&Max_out_f, &Max_D, sizeof(Max_D));
     PID_init(&pid, &measurementValue, &outputValue, &referenceValue, data_P_f, data_I_f, data_D_f, PID_Direction_Direct);
     if (eeprom_read_byte(EEDATA.TimeMsOrS) == CAN_MODULE_ENUM_PID_CONFIG_PARAMETER_TIMEUNIT_S) {
         PID_SetSampleTime(&pid, (uint32_t)(eeprom_read_word(EEDATA16.Time))*1000);
     } else {
         PID_SetSampleTime(&pid, (uint32_t)(eeprom_read_word(EEDATA16.Time)));
+    }
+    PID_SetOutputLimits(&pid, Min_out_f, Max_out_f);
     outputValue = DEFAULT_PWM_VALUE;
     PID_SetMode(&pid, PID_Mode_Automatic);
+}
+        {
         case CAN_MODULE_CMD_PHYSICAL_TEMPERATURE_CELSIUS:
             if (rxMsg->Data[0]==0)  //sensor id shall be zero
+            {
                 //printf("New setpoint with: %X %X\n",rxMsg->Data[1],rxMsg->Data[2]);
                 if (rxMsg->Length == 3)
                 {
                     if (0x80 == rxMsg->Data[1] && 0x00 == rxMsg->Data[2]) //512 degrees
                     {
                         //pid_Reset_Integrator(&pidData);
                         PID_Status = PID_AUTO;
+                    }
                     else
+                    {
                         eeprom_write_dword_crc(EEDATA32.referenceValue, referenceValue, WITH_CRC);
+                    }
+                }
                 rxMsg->Data[1] = (uint8_t)0x00ff & (((uint32_t)(referenceValue*64))>>8);
                 rxMsg->Data[2] = (uint8_t)0x00ff & ((uint32_t)referenceValue*64);
                 StdCan_Set_direction(rxMsg->Header, DIRECTIONFLAG_FROM_OWNER);
                 rxMsg->Length = 3;
                 while (StdCan_Put(rxMsg) != StdCan_Ret_OK);
             }
         break;
         case CAN_MODULE_CMD_PID_CONFIG_SENSOR:
+            //printf("New sensor with: %X %X %X len: %d\n",rxMsg->Data[1],rxMsg->Data[2] ,rxMsg->Data[2],rxMsg->Length);
             if (rxMsg->Length == 3)
+            {
                 eeprom_write_byte_crc(EEDATA.sensorModuleType, rxMsg->Data[0] , WITHOUT_CRC);
                 eeprom_write_byte_crc(EEDATA.sensorModuleId, rxMsg->Data[1] , WITHOUT_CRC);
                 eeprom_write_byte_crc(EEDATA.sensorId, rxMsg->Data[2] , WITH_CRC);
                 sensorModuleType = eeprom_read_byte(EEDATA.sensorModuleType);
                 sensorModuleId = eeprom_read_byte(EEDATA.sensorModuleId);
                 sensorId = eeprom_read_byte(EEDATA.sensorId);
+                //printf("Stored\n");
+            }
             rxMsg->Data[0] = eeprom_read_byte(EEDATA.sensorModuleType);
             rxMsg->Data[1] = eeprom_read_byte(EEDATA.sensorModuleId);
             rxMsg->Data[2] = eeprom_read_byte(EEDATA.sensorId);
             StdCan_Set_direction(rxMsg->Header, DIRECTIONFLAG_FROM_OWNER);
                 //data = (float*)&rxMsg->Data[4];
                 float* data1 = (float*)&rxMsg->Data[4];
                 data_32 = (uint32_t*)data1;
                 eeprom_write_dword_crc(EEDATA32.K_I, *data_32, WITH_CRC);
                 PID_SetTunings(&pid, *data, *data1, PID_GetKd(&pid));
                 PID_Status = PID_ON;
                 pwmValue = DEFAULT_PWM_VALUE;
+            }
+            data2 = PID_GetKp(&pid);
+            ptr = (uint8_t*)&data2;
+            rxMsg->Data[0] = ptr[0];
+            rxMsg->Data[1] = ptr[1];
+            rxMsg->Data[2] = ptr[2];
+            rxMsg->Data[3] = ptr[3];
+            data2 = PID_GetKi(&pid);
+            ptr = (uint8_t*)&data2;
+            rxMsg->Data[4] = ptr[0];
+            rxMsg->Data[5] = ptr[1];
+            rxMsg->Data[6] = ptr[2];
+            rxMsg->Data[7] = ptr[3];
+            StdCan_Set_direction(rxMsg->Header, DIRECTIONFLAG_FROM_OWNER);
+            rxMsg->Length = 8;
+            while (StdCan_Put(rxMsg) != StdCan_Ret_OK);
+        break;
+        case CAN_MODULE_CMD_PID_OUTMINMAX:
+            if (rxMsg->Length > 1)
+            {
+                uint32_t* data_32;
+                float* data = (float*)&rxMsg->Data[0];
+                data_32 = (uint32_t*)data;
+                eeprom_write_dword_crc(EEDATA32.MIN, *data_32, WITHOUT_CRC);
+                //data = (float*)&rxMsg->Data[4];
+                float* data1 = (float*)&rxMsg->Data[4];
+                data_32 = (uint32_t*)data1;
+                eeprom_write_dword_crc(EEDATA32.MAX, *data_32, WITH_CRC);
+                PID_SetOutputLimits(&pid, *data, *data1);
+            }
-            data2 = PID_GetKp(&pid);
+            data2 = PID_GetMin(&pid);
             ptr = (uint8_t*)&data2;
             rxMsg->Data[0] = ptr[0];
             rxMsg->Data[1] = ptr[1];
             rxMsg->Data[2] = ptr[2];
             rxMsg->Data[3] = ptr[3];
-            data2 = PID_GetKi(&pid);
+            data2 = PID_GetMax(&pid);
             ptr = (uint8_t*)&data2;
             rxMsg->Data[4] = ptr[0];
             rxMsg->Data[5] = ptr[1];
             rxMsg->Data[6] = ptr[2];
             rxMsg->Data[7] = ptr[3];
             StdCan_Set_direction(rxMsg->Header, DIRECTIONFLAG_FROM_OWNER);
             rxMsg->Length = 8;
             while (StdCan_Put(rxMsg) != StdCan_Ret_OK);
         break;
+        }
+    }
     if (    StdCan_Ret_class(rxMsg->Header) == CAN_MODULE_CLASS_SNS &&

Subversion Repositories HomeAutomation

(root)/trunk/EmbeddedSoftware/AVR/module/act_PIDv1/act_PIDv1.c – Rev 2273 → 2278