Common Program Level Scaling Problems and Solutions

From an integrator’s perspective, the challenges companies face when scaling their operations tend to repeat:

• Lack of investment early: Doing the bare minimum to get running might work for a pilot, but it creates real pain when scaling to full production.
• Lack of internal resources: Controls engineers are commonly stretched thin fighting fires, leaving little bandwidth for big-picture design.
• More voices, more complexity: Larger operations mean more voices in the room. Customers end up working with EPCs, OEMs, integrators, and other 3rd party contractors — the larger the scope, the harder it is to stay aligned.
• Limited vendor visibility: Even with strong internal controls standards, if you don’t have visibility into how OEMs are completing their projects, new machines can drop onto your plant floor that your internal team won’t be able to support.
• Geographic spread: New plants in different time zones introduce communication and localization challenges.

These problems are real — but they’re also solvable. We highlighted a few key strategies that help companies overcome these challenges and scale more effectively:

• Dedicated internal teams: Separating plant support from new plant development frees resources to focus on architecture-level design.
• Up-front expectation setting. Clear communication of controls standards and architectures early on ensures alignment across internal teams, integrators, and OEMs.
• Supplemental external resources: Partners like DMC can provide local support and scale up quickly, freeing internal engineers to focus on the higher-level problems only they can solve.

Companies that invest in these approaches early tend to scale smarter, faster, and with fewer surprises.

The Technical Backbone: MQTT + UDTs + Structured Data

While program-level issues matter, technical architecture is equally critical. Our presentation walked through how MQTT and standardized UDTs can form a flexible, resilient backbone:

1. Standardized UDTs: Define tags in a consistent hierarchy and structure so that all systems “speak the same language.”
2. MQTT as transport: Instead of point-to-point gateway connections, devices publish once to a central MQTT broker. Consumers subscribe as needed, making onboarding fast and keeping systems resilient.
3. Structured data backbone: Together, UDTs and MQTT enable a model where:
   • Data is published once, consumed many times.
   • Access is democratized — different systems, from cloud data lakes to custom trending software, are able to access the same data without friction.
   • Context is understood by all parties, because it is consistent across the site.
   • Data is real-time. Key parameters are live, not batched, enabling faster decisions.

Consistent User Experience

We also emphasized user experience as a critical piece of scale. With Ignition Edge and central Gateway deployment pipelines, companies can:

• Deploy shared screen libraries via global projects to ensure a consistent look and feel across OEM and internally developed tools.
• Use session properties so the same screens adapt whether running locally or remotely.
• Utilize Enterprise Administration Module to push entire projects to the edge to ensure consistency from control room to edge HMI

Operators and engineers benefit from a common interface across systems, which reduces training time and builds trust in the system.

Why This Matters

At DMC, one of our values is “Make Things Happen.” That means helping clients not only solve today’s challenges, but also laying the foundation for sustainable growth.

The strategies and architectures we presented at ICC — tackling scaling problems head-on, leveraging standardized UDTs, using MQTT as a flexible backbone, and delivering a consistent user experience — show that scaling doesn’t have to be chaotic.

When done right, scaling becomes predictable, consistent, and repeatable. The foundation built here supports not just this scale-out, but future expansions for years to come.

The post DMC Presents at ICC – Scaling Smart: Architecting for Industrial Growth appeared first on DMC, Inc..

Creating an Alarm

The first thing we need to do is create an alarm in WinCC. This is done through the “HMI Alarms” editor in TIA Portal. WinCC accesses all alarms by specifying a bit address in an HMI tag. This means you can group alarms in a couple of ways:

1. Add all alarms to an unoptimized data block as Booleans, then create a single HMI tag that is a word array with the same length as the block

Data block – Unoptimized 

HMI tag – this is an array of word with the appropriate size

Alarms – this is a link to the correct address of the relevant alarm

2. Group alarms into other data types, such as Word, DWord, Dint, etc.

DMC developed the Siemens Open Library, which has a function that automatically will combine 16 bits into a word

Move alarms into the bits of the alarm word

Each alarm corresponds to a bit in the word

Option one can be effective when you’re creating alarms for a large number of devices. The Siemens Open Library includes a windows application that will automatically generate a list of alarms from an unoptimized DB that can be directly imported into the alarm editor. This eliminates the hassle of having to create each of the alarms individually. Option two can be useful when you want to group alarms by device or subsystem. Each word can correspond to a specific device, which can be useful for checking device state on the PLC or displaying it on the HMI.

Local Acknowledgement on HMI

If you do no other configuration, the default acknowledgment setup is that all information about alarm state/acknowledgment is stored locally on the HMI. There are a few possible states for an alarm:

1. Incoming
   • An alarm condition is present; no acknowledgement has occurred
2. Incoming/Acknowledged
   • An alarm condition is present; acknowledgment has occurred
3. Incoming/Outgoing
   • Alarm condition was present, then went away before the alarm was acknowledged

Alarm display colors

Using the Alarms group tab of the editor, you can customize colors and display information for each of these acknowledgment states. Important note: you must enable colors in runtime settings or they will not be displayed.

Alarm Groups

By default, each alarm must be acknowledged individually. To change this, assign the alarms to groups in the alarm editor. Acknowledging one alarm in the group will acknowledge all the other alarms in that group as well.

Acknowledgment Button

There are two ways to acknowledge alarms. The first is using the button built into the alarm viewer. The other way is by configuring a custom button with the “AlarmViewAcknoweldgeAlarm” event.

HMI Acknowledgement Bit – Pass Acknowledgment Information from HMI to PLC

The HMI acknowledgment word is used to pass the acknowledgment status of an alarm from the HMI to the PLC. It must be a bit in a tag that is different than the alarm’s trigger tag. When acknowledgment of the alarm occurs on the HMI, the bit on the PLC is set to one. It will stay high until the alarm condition goes away, then occurs again. A diagram displays this below:

This bit is useful if you want to use the acknowledgment status as a pre-requisite for clearing the alarm condition on the PLC.

Multiple HMI Considerations

If multiple HMIs are part of the project, and each has a separate alarm viewer, any of the HMIs can acknowledge the alarm and set the HMI Acknowledgment bit. However, this information is stored locally on each HMI – the acknowledgement is not passed to the other HMIs. This disparity in information means that if one HMI acknowledges an alarm, it will still display as unacknowledged on a different HMI until this is also acknowledged there.

PLC Acknowledgment Bit – Pass Acknowledgement Information from PLC to HMI

The PLC acknowledgment bit is used to acknowledge alarms by passing down a bit from the PLC. When you set the bit on the PLC, the acknowledgement status of the associated alarm is updated on the HMI. This is useful as it allows multiple HMIs to keep their alarm acknowledgments in sync. A single PLC tag/bit is used as the PLC acknowledgement bit on all the HMIs, so each of them receives acknowledgements in sync.

One disadvantage of this approach is that it makes individual alarm acknowledgment, that is the ability to choose which alarm is going to be acknowledged by highlighting it in the alarm viewer, more difficult. When using the built-in acknowledgment in the alarm viewer (as you must with the HMI ack bit), a user can highlight/select a specific alarm to acknowledge.

However, there is no way to tell the PLC which alarm is currently highlighted, which prevents individual acknowledgement via PLC. Generally, when using this acknowledgment scheme, we have used a global alarm acknowledge button that automatically acknowledges all available alarms. Alternatively, we’ve grouped the alarms by system, and had a separate acknowledgement button for each system.

Important note: the acknowledgment bit must stay high long enough for the HMI to see it. We will normally pulse it on for a short duration (e.g. 1 second if the HMI tag update rate is 1s). This ensures each of the HMIs has time to see the tag’s value change.

The PLC acknowledgment bit is required to be in the same tag as the actual alarm bit. We have a couple of approaches to get around handle this:

Approach 1: Unoptimized db with Structs

The first way is to create an unoptimized DB with all alarm conditions at the top, and an identical structure at the bottom for alarm acknowledgment.

You can then access this DB as an array of words on the HMI, as discussed above. To configure the acknowledgment, use the bit in the first structure as the alarm bit, and the bit in the second structure as the plc acknowledgment bit. Then, set the plc acknowledgment bit high on the PLC to globally acknowledge the alarm on all HMIs.

Approach 2: Alarm Word

Another approach is to use Words for your alarms and keep them in a normal db. In this case, we generally group alarms by system or device, and use the first half of the word for the alarm conditions and the second half of the word for acknowledgments:

Overall, WinCC Comfort and Advanced give you several options for alarm acknowledgment. I hope this blog helps you implement it in your project!

Learn more about DMC’s WinCC Expertise and contact us today to get started on your next project.

The post Alarm Acknowledgment in WinCC Comfort and Advanced appeared first on DMC, Inc..

An important note is that SQL access is not allowed through scripting from a Siemens Comfort Panel. One way to work around this is to have WinCC Advanced runtime running somewhere on your network to handle communication with the database. You can then access the database from WinCC Advanced, pass its values to the PLC, and then access them on the PLC from the comfort panel.

Database Settings

I will not go through the entire setup of an SQL database here. However, the user must update several essential settings for access from WinCC.

In SQL Server Management Studio

1. Open SQL Server Management Studio and connect to the server where the database you wish to access from WinCC resides. 

Right-click that server and open its properties. In the Security tab choose SQL Server and Windows Authentication Mode for Server Authentication. This allows access to the server with a username and password instead of a standard windows login.

 
2. In the connection explorer, open the Security folder and right click Logins. Then choose New Login.

This step adds a user to this server.

 
3. Add a user, choose SQL Server Authentication, and set the default database to the database you wish to access from WinCC.

In SQL Server Configuration Manager

1. Open SQL Server Configuration Manager. If you are having trouble finding it, try browsing to the locations seen on this site. Under SQL Server Network Configuration then Protocols for SQLEXPRESS, enable TCP/IP.

2. Under SQL Server Services, change the start mode of SQL Server Browser to Automatic and ensure it’s running.

3. Right click on SQL Server and SQL Server Browser and restart them.

In Windows Firewall with Advanced Features

1. Open Windows Firewall with Advanced Features. Choose Inbound Rules from the bar on the left, then New Rule… on the right.

2. Make the rule with the following features:

Rule type: Port
Protocol and Ports: UPD type, port number 1434
Action: Allow the connection
Profile: Choose all
Name: SQLExpressBrowser

3. Add another incoming rule. This time choose a custom type.

Rule Type: Custom
Program: Select Customize next to services and apply the rule to the service SQL Server (SQLEXPRESS).

Protocol and Ports: Protocol type Any
Scope: Any IP address local or remote
Action: Allow the connection
Profile: Apply to all
Name: SQL Server Database Engine Service

Script Setup

Now that we have the settings for the database nailed down it’s time to get into the fun part, the actual scripting!

Below, I will go through the lines of my code and explain what’s happening at each part. In this example, I’m calling a stored procedure from the database that takes inputs of integers and strings from the PLC and outputs to an array of UDTs on the PLC.

Sub SQLQuery()
'Keep running script if error occurs
On Error Resume Next

'Declare Variables
Dim i, index, test, row, iType, sFirstInput, iSecondInput, offset
Dim connection, recordset, record, connectionstring, query
Dim continue

continue = True

Sub SQLQuery()
'Keep running script if error occurs
On Error Resume Next

'Declare Variables
Dim i, index, test, row, iType, sFirstInput, iSecondInput, offset
Dim connection, recordset, record, connectionstring, query
Dim continue

continue = True

Line 3 ensures that if the script encounters an error, it keeps running. This line allows us to record the error we’re getting and set status tags for the script. Then declare all the variables being used and set the continue variable to true. This variable will do error handling.

If Not SmartTags("bCallScript") Then
	Exit Sub
End If

If Not SmartTags("bCallScript") Then
	Exit Sub
End If

Now, trigger the script on the PLC tag bCallScript. This tag has a continuous cyclic acquisition and calls  ExampleScript on a value change. Lines 12-14 ensure that we only run the SQL logic on a positive value change of bCallScript. 

'Create connection string and database object
connectionstring = "Provider=SQLOLEDB.1;Persist Security Info=True;"&_
					"User ID=ExampleUser;Password=ExamplePassword;"&_
					"Initial Catalog=ExampleDatabase;"&_
                    "Data Source=192.168.0.1\SQLEXPRESS;"
Set connection = CreateObject("ADODB.Connection")
'Open connection to database
connection.Open connectionstring

'Create connection string and database object
connectionstring = "Provider=SQLOLEDB.1;Persist Security Info=True;"&_
					"User ID=ExampleUser;Password=ExamplePassword;"&_
					"Initial Catalog=ExampleDatabase;"&_
                    "Data Source=192.168.0.1\SQLEXPRESS;"
Set connection = CreateObject("ADODB.Connection")
'Open connection to database
connection.Open connectionstring

Make a connection string for the database using the password and User ID created earlier. The data source is the IP address of the computer that hosts the database.

Line 24 creates a database object and line 27 tries to connect to the database. The connection string will vary based on the type of database you’re using, the username and ID created, and other factors.

If Err.Number <> 0 Then
    SmartTags("ErrorTag") = "Opening Connection: " & Err.Description
    Err.Clear
    connection.close
    Set connection = Nothing
    continue = False
End If

If Err.Number <> 0 Then
    SmartTags("ErrorTag") = "Opening Connection: " & Err.Description
    Err.Clear
    connection.close
    Set connection = Nothing
    continue = False
End If

Put in the first error handling block. If an error has occurred trying to connect to the database, write Opening Connection: actual text of error to the tag dbSQL_sError.

Then, close the connection to the database and set the continue variable to false. This is useful in troubleshooting, as you can check the tag dbSQL_sError to help diagnose connection problems.

If continue = True Then
    'Convert inputs to strings
    sFirstInput = CStr(SmartTags("dbPLC_sFirstInput"))
    iSecondInput = Cstr(SmartTags("dbPLC_iSecondInput"))
    
    'Create query text
    query = "EXECUTE dbo.ExampleStoredProcedure" & sFirstInput & "," & iSecondInput
    
    'Execcute query and create recordset object
    Set recordset = connection.Execute(query)

    'Error routine
    If Err.Number <> 0 Then SmartTags("ErrorTag") = "Database query: " & Err.Description
        Err.Clear
        connection.close
        Set connection = Nothing
        Set recordset = Nothing
        continue = False
    End If
End If

If continue = True Then
    'Convert inputs to strings
    sFirstInput = CStr(SmartTags("dbPLC_sFirstInput"))
    iSecondInput = Cstr(SmartTags("dbPLC_iSecondInput"))
    
    'Create query text
    query = "EXECUTE dbo.ExampleStoredProcedure" & sFirstInput & "," & iSecondInput
    
    'Execcute query and create recordset object
    Set recordset = connection.Execute(query)

    'Error routine
    If Err.Number <> 0 Then SmartTags("ErrorTag") = "Database query: " & Err.Description
        Err.Clear
        connection.close
        Set connection = Nothing
        Set recordset = Nothing
        continue = False
    End If
End If

Now that the database connection is open, run the first query. First, check whether the continue variable is true. There is no use trying to run this logic if we had an error connecting to the database earlier.

For this example, I am running a query that calls a stored procedure in our database dbo.ExampleStoredProcedure. This procedure takes two inputs. The first is a string, the second is an integer and returns a table of results.

I take two PLC tags, convert/ensure they are strings, and combine them with another string to create the SQL query EXECUTE dbo.ExampleStoreProcedure sFirstInput, iSecondInput that is passed to the database.

The query can be any valid SQL query. However, I found that it’s easier to create stored procedures in the database than to write long queries in the VBA editor in TIA Portal. This makes the scripting in portal simpler and easier to troubleshoot.

We store the result of the query as the variable recordset, which is a recordset object.  This makes it easy to manipulate the data later.

Once again, there is an error routine here that sets the continue variable to false, records the error text, and closes the database connections in the case of an error.

If continue = True Then
    'Make sure we're at the start of the record
    recordset.MoveFirst
    
    'Determine how many rows to offset
    offset = (SmartTags("dbPLC_iPageNumber")-1)*10

    'Move to desired row
    recordset.Move(offset)

    'Error routine
    If Err.Number <> 0 Then SmartTags("ErrorTag") = "Page offset: " & Err.Description
        Err.Clear
        connection.close
        Set connection = Nothing
        Set recordset = Nothing
        continue = False
    End If
End If

If continue = True Then
    'Make sure we're at the start of the record
    recordset.MoveFirst
    
    'Determine how many rows to offset
    offset = (SmartTags("dbPLC_iPageNumber")-1)*10

    'Move to desired row
    recordset.Move(offset)

    'Error routine
    If Err.Number <> 0 Then SmartTags("ErrorTag") = "Page offset: " & Err.Description
        Err.Clear
        connection.close
        Set connection = Nothing
        Set recordset = Nothing
        continue = False
    End If
End If

In this example, the goal was to display ten rows of the table produced by our stored procedure on an HMI screen. 

This code is only run if our continue flag is true. The first line does the MoveFirst command on the recordset object we created earlier. Think of the recordset object like a big table with one row highlighted. The MoveFirst command ensures highlighting of the first row. Then calculate how many rows we need to offset to display entries 1-10 on page 1, 11-20 on page 2, 21-30 on page 3, etc. 

This offset will always be a 0 or some multiple of 10.  Use the recordset.Move(offset) command next to move our highlighted row down however many rows required. The move command moves down the table for positive numbers and up the table for negative numbers. 

For example, if we move to row 1 using the MoveFirst command, then offset 10 with the move command, we end up highlighting row 11. This would start the second page of entries.

There is now an error routine again. This command catches errors such as the stored procedure returning an empty table or trying to move to a second page when there are less than ten entries.

If continue = True Then
    For i = 0 to 9
        If Not recordset.EOF Then
            SmartTags("dbPLC_Data{"&CStr(i)&"}.iOutputOne") = CInt(recordset.Fields("OutputOne").Value)
            SmartTags("dbPLC_Data{"&CStr(i)&"}.sOutputTwo") = CInt(recordset.Fields("OutputTwo").Value)
            SmartTags("dbPLC_Data{"&CStr(i)&"}.bExists") = True
        Else
            SmartTags("dbPLC_Data{"&CStr(i)&"}.bExists") = False
        End If

        'Error routine
        If Err.Number <> 0 Then SmartTags("ErrorTag") = "Retrieve Data: " & Err.Description
            Err.Clear
            connection.close
            Set connection = Nothing
            Set recordset = Nothing
            continue = False
        End If
    Next
End If

If continue = True Then
    For i = 0 to 9
        If Not recordset.EOF Then
            SmartTags("dbPLC_Data{"&CStr(i)&"}.iOutputOne") = CInt(recordset.Fields("OutputOne").Value)
            SmartTags("dbPLC_Data{"&CStr(i)&"}.sOutputTwo") = CInt(recordset.Fields("OutputTwo").Value)
            SmartTags("dbPLC_Data{"&CStr(i)&"}.bExists") = True
        Else
            SmartTags("dbPLC_Data{"&CStr(i)&"}.bExists") = False
        End If

        'Error routine
        If Err.Number <> 0 Then SmartTags("ErrorTag") = "Retrieve Data: " & Err.Description
            Err.Clear
            connection.close
            Set connection = Nothing
            Set recordset = Nothing
            continue = False
        End If
    Next
End If

This block moves data into an array of UDTs on the PLC. The UDT has three elements: iOutputOne, sOutputTwo, and bExists. The array has ten elements and is called dbSQL_Data. Loop from 0 to 9 to fill each element of the array.

Within the for loop, there is an if statement that checks recordset.EOF. This is a property of the recordset object which tells whether you have moved past the last row of the table. In this case, use it to ensure that we don’t attempt to read data from an empty row.

If recordset.EOF is false, then read data from the recordset object using the .Field and .Value properties. Each field corresponds to the name of a column from the database table returned by the stored procedure. The .Value property returns the value in that column from the row that is currently selected.

Wrap the recordset.Fields.().Value commands in Cstr and Cint to ensure the correct data types are in the PLC. We write to the dbSQL_bExists bit if we are not at the end of the file, as this means we successfully populated this entry in the array with information. This is useful for deciding whether or not to display info on a screen or use it in the PLC.

After writing the data to the PLC, use the .MoveNext method to move down one row in the data table.

If at the end of the file (recordset.EOF  = true), do not read any data, and set the dbSQL_bExists bit to false.

Finish with another error routine for this part of the code.

If continue = False Then
    SmartTags("dbPLC_bErrorExists") = True
    For i = 0 to 9
        SmartTags("dbPLC_Data{"&CStr(i)&"}.bExists") = False
    Next
End If

SmartTags("dbPLC_bScriptComplete") = True
SmartTags("dbPLC_bCallSCript") = False

connection.close
connection = Nothing
recordset = Nothing
End Sub

If continue = False Then
    SmartTags("dbPLC_bErrorExists") = True
    For i = 0 to 9
        SmartTags("dbPLC_Data{"&CStr(i)&"}.bExists") = False
    Next
End If

SmartTags("dbPLC_bScriptComplete") = True
SmartTags("dbPLC_bCallSCript") = False

connection.close
connection = Nothing
recordset = Nothing
End Sub

This is the end of the script. At this point, if the continue flag is false, write to a dbSQL_ErrorExists status bit on the PLC. Furthermore, set the “bSQL_bExists bit to false for all Data array elements to make it clear something went wrong while trying to access the database.

Line 122 sets a PLC tag indicating that the script has completed running to True, signaling to the PLC it can continue with other logic. Reset the dbSQL¬_CallScript tag here so that the script can be called again.

Conclusion

This is a relatively simple implementation of SQL access, but it shows some of the key features and methods you need to read data successfully to your PLC. I hope it can be of use to you in future projects.

Learn more about DMC’s WinCC programming expertise.

The post SQL Express Scripting from WinCC Advanced appeared first on DMC, Inc..

After a catered dinner at the office, we carpooled over to the stadium. I will watch almost any basketball game alone and enjoy myself, but being at the game with the DMC Houston team made it even more fun. It allowed us to hang out and bond outside the office, as well as meet some of each other’s friends, family, and roommates.

DMC makes a point of allowing you a plus one to every party. It’s an excellent way to feel more comfortable going to events when you're a new employee, and a great way to get to know new people!

I was even lucky enough to be selected to be part of a shooting competition on the court!

The promotion was a wheel of fortune inspired shooting game. I shot free throws for 20 seconds. For each basket I made, an assistant revealed one letter in a Southwest Airlines destination. At the end of the 20 seconds of shooting, I had to guess the location. A correct guess would net me 15,000 Southwest Rapid Rewards!

I have shot a fair number of free throws in my life, but none in front of this many people. I was unquestionably nervous!

Near the end of the 2nd quarter, it was my time to compete. I missed the first shot, but then made a few in a row. After 20 seconds I turned around to the letters “N-A-S-H-V-I.” I correctly guessed “Nashville,” and that was that! 15,000 Southwest miles anywhere I wanted, thanks, Ceci!

The game was incredibly exciting, with the now first place Rockets beating the Pelicans 130-123. James Harden recorded 14 assists in the first half, tying a Houston record.

All in all, it was a great time, and I can’t wait for our five future new hires to have their welcome parties later this summer!

DMC's offices are always expanding, so if you wish you were with us, check out our careers page.

The post Houston Rockets Basketball Welcome Party appeared first on DMC, Inc..

I started at DMC's Houston office in early September, so I arrived at the right time to enjoy the finished product. 

DMC Houston's Expansion

We have been thoroughly enjoying each of the new areas.

• Kitchen – Board and card games are a daily staple in the expanded kitchen during lunch.
• Conference Room – All Houston teammates can comfortably fit in the new conference room for status meetings.
• Quads – A fierce rivalry has erupted between those who work in the front workspace (known as “Power Quad”) and those who work in the back (name TBD).
• Collaboration Room – A second collaboration room allows for more flexibility when scheduling meetings with other DMC offices or clients.

On the Inside 

My time at DMC has been a blast so far! Our fridge and pantry are always stocked with lunch fare and snacks, which I take full advantage of.

One of the biggest learning curves I have faced is mastering the card game Bears vs. Babies. There is fierce competition almost daily at lunch, but I think I’m beginning to hold my own.

I’ve befriended our office dog, Travie. She’s a massive Irish Wolfhound who is simultaneously bigger and gentler than any other dog I have ever met.

Expansion Photos

DMC Houston's newly expanded kitchen has plenty of storage for snacks and space for playing shuffle board or card games. 

We've added more quads to accommodate the growing Houston team. You can see Peter hard at work in the corner!

Our new conference room is more spacious than ever.

Let's Keep Growing

DMC Houston's next move is joining a corporate basketball league that starts in January for some competition outside of the office. I hope this means the next addition to the office will be a championship banner hanging from the rafters.

We are always looking to hire more engineers to fill the rest of our space. Wish you were with us? Check out our opportunities.

If you’re in the area feel free to stop by and say hello, we’d love to give you a tour and play a game of shuffleboard!

See what else is going on at DMC Houston.

The post DMC Houston Is Bigger Than Ever appeared first on DMC, Inc..