Here's an example of what I think you want, more or less.

Sheet1

Sheet2

Col 01 | Col 02 | Col 03 | Col 04 | Col 05 |

1 | 3 | 5 | 7 | 9 |

<tbody>

</tbody>

Lets add sheets 1 and 2, that is, AAA will be 2, BBB will be 5, CCC will be 9, etc., etc.

Create a new workbook that looks like the above. Then press F11 to enter VBA. Insert a module (should be Module 1), insert this code into the module, and press F8 to start stepping through.

Code:

```
Option Explicit
Private Sub UpdateSheet()
Const NumCols = 5
Dim SRow As Integer
Dim DRow As Integer
SRow = ThisWorkbook.Sheets("Sheet2").Cells(ThisWorkbook.Sheets("Sheet2").Rows.Count, 1).End(xlUp).Row
DRow = ThisWorkbook.Sheets("Sheet1").Cells(ThisWorkbook.Sheets("Sheet1").Rows.Count, 1).End(xlUp).Row
Dim SourceRange As Range
Dim DestRange As Range
Set SourceRange = ThisWorkbook.Sheets("Sheet2").Range(ThisWorkbook.Sheets("Sheet2").Cells(SRow, 1), ThisWorkbook.Sheets("Sheet2").Cells(SRow, NumCols))
Set DestRange = ThisWorkbook.Sheets("Sheet1").Range(ThisWorkbook.Sheets("Sheet1").Cells(DRow, 1), ThisWorkbook.Sheets("Sheet1").Cells(DRow, NumCols))
Dim ndx As Byte
For ndx = 1 To NumCols
DestRange.Cells(ndx).Value = DestRange.Cells(ndx).Value + SourceRange.Cells(ndx).Value
Next ndx
End Sub
```

This is a Subroutine. The other option would have been to make it a Function. The difference is that you use a sub like you use a command. You don't expect a return value. You just expect the computer to do whatever. A function, however, returns a value. If you made this code into a function, you would probably want it to return True or False to indicate whether the function had succeeded or not.

The first line defines a constant, a value that cannot change. The number of your columns may or may not be fixed, but in my example, it is. A benefit of using constants is that a well-named constant tells you want it's for. In this case, you go, "oh, it's the number of columns," whereas if there had just been a 5, you might have wondered, "Five what? What does this number indicate?"

Then we define a couple of Integer variables, SRow for Source Row and DRow for Destination Row. In other words, SRow is the row number that has the values that will be added to Sheet 1, and DRow is the row number where the values from the Source Row will be added to. SRow and DRow are not the best names because they are too abbreviated. What's an SRow? What's a DRow? Unless you know, you can't figure it out.

Having defined those two variables, we now actually put a value in them. That's the next two lines, and now it starts getting complicated.

SRow = ThisWorkbook.Sheets("Sheet2").Cells(ThisWorkbook.Sheets("Sheet2").Rows.Count, 1).End(xlUp).Row

ThisWorkbook.Sheets("Sheet2") -- this refers to sheet 2 in the workbook

Cells(

*ThisWorkbook.Sheets("Sheet2").Rows.Count*,

**1**) -- the Cells collections contains all the cells and lets us specify which cell we mean. The syntax is Cells(Row Number, Column Number). Here, we use ThisWorkbook.Sheets("Sheet2").Rows.Count to find the number of rows on the sheet. In VBA, collections like Rows, Columns, Cells, Workbooks, Sheets, etc., have a Count property that tells you how many there are, so Rows.Count returns the total number of rows in the sheet (65,536 in older versions, and 1048576 in newer ones). The Column Number is 1, which corresponds to Column A on the sheet, so the expression so far points to cell A1048576 (or A65536 if you have an older Excel version). But we're not done yet because that's the last row on the sheet, not the last row where our number are, so what follows is End(xlUp). This is just like pressing the End key and then the Up Arrow key from the bottom row. You are moved automatically to the last used cell in that column. Finally, we end the line with Row, which returns the current Row number.

We can read the entire line as "In Sheet2 of this workbook, find the last row by moving to the very bottom and then moving up to the first non-empty cell. Then take the row number of that first non-empty cell and put it in SRow. This is our Source Row number.

The next line does the same, except for the other sheet, the Destination.

Now we have two ranges. Think of them like windows into your spreadsheet. One window points to where the data is coming from, and the other window points to where the data is going.

Now let's define a small variable, just a byte, which can count up to 255. Pick the smallest variable type that accommodates your needs. You don't have more than 255 columns, so a byte will do just fine. Otherwise, you'd have to use an Integer, Long, Double, or something else.

Then we have the loop that does the actual work. The For-Next structure is one way that VBA does loops, doing the same steps over and over, making some small controlled change each time. Here's the full syntax. The variables you provide are in italics.

Rich (BB code):

`For `**counter** = **first** To *last* Step **n**
'steps to be done over and over
Next **counter**

In this case, we go from 1 to 5, and we don't use a Step because it counts one by one by default. The variable ndx first contains a 1, then a 2, all the way through 5. When it adds one more, it becomes 6, and that's over the To limit, so it exits the loop.

We only have one step, add one value to the other value. Note how defining the ranges saves a lot of typings later on, not to mention making things much more clearer. Instead of having to say

**ThisWorkbook.Sheets("Sheet1").Range(ThisWorkbook.Sheets("Sheet1").Cells(DRow, 1), ThisWorkbook.Sheets("Sheet1").Cells(DRow, NumCols))** all we had to do was say

**DestRange.**
So now the step.

**DestRange.Cells(ndx).Value = DestRange.Cells(ndx).Value + SourceRange.Cells(ndx).Value**
This is almost plain English. "Make the value of the (ndx)th cell in DestRange equal to the sum of itself plus the value in the (ndx)th cell in SourceRange."

You can download this example spreadsheet from

http://www.clicketyhome.com/example.xlsm
I hope this helps. We're all still learning.