Troubleshooting Negative Weight Display Issue in PLC Programming

The user "muusic_man" inquired about the communication method being used, suggesting it may not be the traditional 4-20mA and instead could be Ethernet TCP/IP. In this case, it is recommended to review the settings in the scale head for byte swapping and consider big endian or little endian configurations. This adjustment can be made by utilizing Ethernet for improved connectivity.

• 31-07-2024
• Hareeshmarpuri

IO_Rack confirmed that the number in question was indeed 32767.

• 01-08-2024
• Hareeshmarpuri

What is the specified data type of the tag in the programmable logic controller (PLC) that initially receives data from the scale?

• 02-08-2024
• joseph_e2

To maximize compatibility and precision in your code, consider converting the unsigned integer from the load cell controller to a double integer or even better, converting it to a real number. By utilizing real numbers, your code can achieve more accurate calculations. While not familiar with Logix 5000 specifically, there are likely conversion or scaling functions available to assist with this process.

• 02-08-2024
• JesperMP

Inquiring about the data type in a programmable logic controller (PLC) that initially receives data from a scale. The data type is INT[9].

• 02-08-2024
• Hareeshmarpuri

In a discussion, Hareeshmarpuri suggested replacing INT[9] with UINT[9] to ensure compatibility with other elements in the array that may have negative values. By copying the bits from the INT[x] weight to a UINT weight using the command COP INT_array[x] weight_UINT 1, the program can determine the current weight being written by the ethernet connection. The offset of the array element may vary, sometimes being 0. The new tag variable, weight_UINT, will always maintain a value within the range of 0 to 65535. It is advised not to exceed 32767kg on the scale. If this Studio 5000 program was derived from an RSLogix 500 program (e.g. SLC5/xx or MicroLogix), printing the entire program to a PDF and sharing it would be helpful for further analysis.

• 02-08-2024
• drbitboy

To optimize reading data from a scale, it is recommended to ensure that the maximum reading does not exceed 65535. In this case, you can use the bitwise AND operation between INT[0] and 65535 (16#FFFF) to convert it to a DINT for weight calculation. If the maximum reading exceeds 65535, it is likely that INT[1] contains the other half of the weight data. In this scenario, copying INT[0] to DINT with a length of 1 is the suggested approach. Additionally, if dealing with negative weights, further clarification on the scale's data output is necessary for accurate processing.

• 02-08-2024
• 5618

The TLM8 unit provides the Gross Weight data in the first 4 bytes of Input Assembly Instance 101. The data type is defined as GROSS WEIGHT, NET WEIGHT, with weight values represented as positive integer numbers, including decimal figures but without a decimal point. To check the sign and possible errors related to the weight, refer to the Status Register. The weight range is from -999,999 to 999,999. If you are encountering issues similar to those described by Steve Bailey, you may need to combine Intermediate_Silo_Weight:I.Data[0] and Intermediate_Silo_Weight:I.Data[1] to access the full 4 bytes of positive integers without a decimal point. Utilizing DINT as a 4-byte signed Integer will ensure that you fall within the specified weight range. Following the COP instruction, as suggested by 5618, will enable you to obtain the accurate weight reading without decimal points.

• 02-08-2024
• IO_Rack

In a forum discussion, user drbitboy suggested two possible options: 1. Convert the data type to UINT[9]. 2. Copy the bits from the INT[x] weight to a UINT weight: COP INT_array[x] weight_UINT 1. It is important to note that changing the data type to UINT[9] may affect other elements in the array with negative values. The offset 'is' indicates the array element to which the Ethernet connection writes the current weight, which can be zero at times. The newly introduced variable, weight_UINT, will always have a value ranging from 0 to 65535. It is advised not to exceed 32767kg on the scale. Questions raised include whether the Studio 5000 program was converted from an RSLogix 500 program (e.g., SLC5/xx or MicroLogix), and a request to share the entire program as a PDF file. Click to expand for more information and locate the PDF.

• 02-08-2024
• Hareeshmarpuri

If you're working with weight data that ranges up to 65535, you can use the AND operation on INT[0] with 65535 (or 16#FFFF) to convert it to a DINT. If the weight data exceeds this limit, you can consider INT[1] as the second half of the weight and then use the COP instruction to copy INT[0] to a DINT. For negative weights, additional information about the scale's data output is required. Here is an example to clarify: Suppose the weight data is 50000, you would first AND INT[0] with 65535 to get the exact weight value.

• 02-08-2024
• Hareeshmarpuri

Hareeshmarpuri inquired about creating a DINT tag or variable and sought an explanation with an example on how to write instructions to obtain the precise value.

• 02-08-2024
• drbitboy

Are you retrieving data through Ethernet communication? Is it Ethernet TCP/IP, Ethernet/IP, Modbus TCP using a ProSoft card, or another method altogether? If you're unsure of what I'm inquiring about, please let me know.

• 02-08-2024
• drbitboy

Give this a try: Create a DINT tag named NewWeight. Use a CPS instruction with the following parameters: Source = Intermediate_Silo_Weight:I.Data[0], Dest = NewWeight, Length = 1. This action will transfer the bits from Data[0] and Data[1] into the NewWeight tag. If you receive a valid value, that's great. There may be a need to use the SWPB instruction to rearrange the bits, but it's unlikely in this scenario. Utilize CPS to prevent any potential issues that may arise if the data updates while performing a COP instruction, which could lead to inaccurate results. This precaution ensures the source data remains unchanged during the copying process. The word "intermediate" might be misspelled, but it could be the correct spelling in other languages.

• 02-08-2024
• 5618

5618 suggested trying the following method for creating a DINT tag named NewWeight: use a CPS instruction with Source as Intermidiate_Silo_Weight:I.Data[0] and Dest as NewWeight, with a Length of 1. This will transfer the bits from Data[0] and Data[1] into the NewWeight tag. Consider using the SWPB instruction for reordering the bits if necessary. Using CPS is recommended to prevent data updating issues that may occur with a plain old COP instruction. It is important to note that the spelling of "intermidiate" may vary depending on language settings. After implementing this method, creating a second rung with MOV instructions can provide easy access to display and edit the values as needed.

• 02-08-2024
• OkiePC

We greatly appreciate everyone's valuable input. Based on your feedback, I implemented a solution that yielded positive results. I incorporated the LES instruction with Intermediate Silo Weight: I.Data[0] as Source A and 0 as Source B. Additionally, I included an ADD instruction with Source A set at 65536 and Source B as Intermediate Silo Weight: I.Data[0] in the same rung. This configuration allows for the addition of a negative value to 65536, resulting in the desired outcome. For example, with Source A at -31116 and Source B at 0 for the LES instruction, and Source A at 65536 and Source B at -31116 for the ADD instruction, the final result is 34420.

• 02-08-2024
• Hareeshmarpuri

As mentioned by @IO_Rack, the acceptable range is from -999999 to 999999. However, if the weights exceed 65535, adding them will be ineffective and can lead to errors, resulting in the conversion of small negative values into large positive values.

• 02-08-2024
• 5618

Hareeshmarpuri expressed gratitude for the valuable inputs provided. By incorporating these suggestions, positive results were achieved. The challenge lies in attempting to fit 4 pounds of data into a 2-pound container, as discussed by @5618. The data destination for the ADD instruction should ideally be UINT, DINT, UDINT, or a similar data type, and not REAL. It is important to note that exceeding 65535 will result in inaccurate values, as will negative values in fields like Intermediate_Silo_Weight:I.Data[2] and [3] for Net Weight. To address these issues, consider implementing the solution proposed by @OkiePC in Post #20. In summary, the root problem persists as solutions are provided without the original poster fully grasping the underlying issue, as outlined in point (i) of my .signature.

• 02-08-2024
• drbitboy

Hareeshmarpuri expressed gratitude for the valuable inputs provided. By implementing suggestions received, he successfully tested a new approach. This involved using the LES instruction with Intermediate_Silo_Weight:I.Data[0] as Source-A and 0 as Source-B, along with an ADD instruction using 65536 as Source A and Intermediate_Silo_Weight:I.Data[0] as Source B in the same rung. This method helps handle negative values effectively, resulting in the desired outcomes. For instance, when the weight is -1, the result will be 65000 instead of a perfect 0. Seeking advice from experienced individuals is essential, as it can prevent potential setbacks later on. It's crucial to listen to suggestions and avoid actions that may not address the underlying issue at hand. Appreciating constructive feedback is key to improving problem-solving skills for future challenges.

• 02-08-2024
• robertmee