So, while playing around with the Animoog app, if you go into the setup menu there is a selection under ‘Refresh MIDI input(s)’ where  you can select ‘Off’ or ‘Network Session 1′.  This intrigued me!  Apparently you can use MIDI over the ‘Network’.  After some Googling I was still unclear on how to get this setup, so I thought I’d just tell everyone how I did it so you can get to making some cool tunes yourself.

I’m assuming your PC has iTunes installed and you have the Bonjour service that comes with it.  It should work without it but you lose the auto-discovery.  OK, so first thing you’re going to need is the Animoog app on your iPad.  Once that is installed, you’re going to need rtpMIDI which is available for free here.  (Download link on the top right).  I’m using Windows 7 64 bit for reference.  Once you download the rtpMIDI, unzip it and execute the .msi file to install it.  There is a better tutorial for installing rtpMIDI here so I won’t re-iterate everything.  The TL;DR version is Install, click Next, Next, Next, agree to anything that pops up, and done.

After the rtpMIDI is installed, run rtpMIDI from the start menu.  Click the + under ‘My Sessions’ and choose a new name or leave it as default.

Next highlight the (only) session and click the enable box on the right.  Now at this point Bonjour probably hasn’t caught up with you yet to display your iPad in the Directory box like mine.  If it does, click connect.  If it doesn’t click the + under Directory and type in the IP address of your iPad followed by :5004.  eg.  ’192.168.5.104:5004′ which is the case with mine.  You can get the WIFI IP address of your iPad by going to Settings ->General->Network->Wi-Fi->(Your Wi-Fi access point’s name) and you’ll see ‘IP Address’.  It’s usually something like 192.168.1.100 or so.

After adding an item in the Directory, highlight it and click connect.  If successfull it should show up in the ‘Participants window’.  Leave this application running.

OK, still with me?  Good.  Next, run Animoog, click on the top right where it says ‘Settings’, then on the left under ‘Refresh MIDI input(s)’ select ‘Network Session 1′.

At this point I’m going to presume that most software that uses MIDI output on  your PC will work, however I did not try them.  I’m going to use Fruity Loops Studio 9.

Once you fire up Fruity Loops, start with a fresh setup.  Goto Options->MIDI settings.  On the top you should see something similar to my screenshot.  The name of your ‘Session’ you used in rtpMIDI.  Highlight that MIDI Device, click Send Master Sync (so you can control BPM from FLStudio) and set the Port Number to 0.  Close this dialog.

Next, goto Channels->Add one->MIDI out.  On the channel settings, make sure you set the Channel to ’1′ and the Port to ’0′.

At this point you should be able to click the little virtual keyboard and hear it play on your iPad.

If this works, then you are all set up.  If not then either you missed a step or I forgot to mention the step (hah!).

You can start making your patterns with notes and hear them play back on the iPad.  You still have to setup your preset in Animoog on the iPad, and it doesn’t appear that all the functionality is supported.  Some notes don’t appear to work (things like pitch, etc.)  I presume if you had multiple iPads you could set them all up with different presets and make some really killer music.

And here is a quick little YouTube video showing it working.

Netduino

Over the last few weeks Harford Hackerspace has had the pleasure of beta testing the Netduino. The Netduino is a development board with a form factor similar to the Arduino. Care was taken when designing the Netduino to ensure compatibility with most of the existing Arduino shields. That’s about where the similarities of the two devices ends.

The Netduino uses Microsoft’s Open Source .net Micro Framework SDK along with Visual Studio C# (or VS C# Express) as the primary development environment. C# application developers will be able to quickly adapt to the .net Micro Framework and start programming microcontrollers in a matter of minutes. However, this does not let them off the hook for learning the basics of electronics.

After downloading and installing Visual Studio C# Express 2010, the .net Micro Framework 4.1 SDK , and the Secret Labs Netduino SDK we started with the “Hello World” of microcontrollers and blinked the on-board LED. That was easy…! You’ll be able to get details to do this yourself from the Netduino website.

SparkFun Color Sensor

ADJD-S371-Q999

The ADJD-S371 is a 4 channel RGB+Clear sensor and uses the 2-wire I2C protocol to communicate with the microcontroller.  It’s a complex little device that will test your puzzle solving skills. What I mean is that the device does not simply give you the correct color when you ask for it. You’ll have to play around with the Gain calibration algorithm and come up with something that works best for your application. However, for simple testing purposes you can use the code described in this tutorial. Here’s a quick video to demonstrate the project:

The code was originally created by Nathan Seidle for the PIC microcontroller and was ported and modified for the Arduino by Marcus from Interactive Matter. Paul King and I ported it once again to the C# Language for the .net Micro Framework.

Click to Enlarge

C# Code

Lines 1 through 6 define a namespace. This allows you to use classes or types without having to type out the full namespace where those types exist. For example, instead of typing:
SecretLabs.NETMF.Hardware.Netduino.Pins.ONBOARD_LED
We can simply type:
Pins.ONBOARD_LED

Lines 7 through 33 are constants defined in the Color Sensors documentation. Line 35 creates a new I²C device object named rtc. We use this object to actually send the data from the Netduino to the Color Sensor. I²C is a bus protocol which means that multiple devices can share the same wires. So the I2CDevice object requires us to give it a slave address. We defined this as the constant I2C_Address on line 11. The I2CDevice object also requires us to specify a rate in Kilohertz(Khz). 100Khz seemed to do that trick. We tried other speeds without much luck.

Line 37 creates a variable of type byte array. Note that we are only initializing the size of the array to 1. The color sensor does not actually need an array of bytes but the I2CDevice.CreateReadTransaction requires a byte array as one of its parameters and does not have an overloaded method for using just a byte.

Lines 38 is the main entry point for our program. On lines 40 through 42 we setup 3 pins which we are using to control an RGB LED. By adding the SecretLabs.NETMF.Hardware.Netduino.dll to our list of resources and declaring it with the using statement on line 6 we don’t have to remember the actual microcontrollers pin numbers. SecretLabs has already looked all this up for us and they allow us to use Pins.xxxxx. You notice that the intellisense aka code complete feature of Visual Studio automatically pops up a context menu allowing you to select from a list of available pins.

[*UPDATE: If you use the SecretLabs SDK Installer you can start a new "Netduino Application" which removes the need for manually adding the dll's to your resource list and also removes the need to manually add the SecretLabs using statements.]

On line 56 we create an infinite loop so that our program never ends. Without this our program would only run once and then terminate.

Lines 58 through 64 is where you could get creative. The color sensors datasheet and application note are a little fuzzy on explaining the proper way to calibrate and set the gain of your sensor. However, you MUST set the gain for each color before you request the color. If you fail to set the gain then you will get low results. We learned this the hard way. We just could not figure out why we only got numbers from 0 to 3!

Lines 65 through 78 is where we sample the colors through the use of a few helper methods which you’ll read about below. The key thing to note here is that the more samples you take the more stable your numbers will appear. We are taking 10 samples and adding the results together and dividing by 10 to get the average value.

Lines 80 through 93 is where we set the color of our RGB LED. We are using a very simple algorithm to determine the most dominate color and turning on just that leg of the RGB LED. We experimented with mixing colors but our LED was not diffused enough to mix the colors together. We were able to see the individual colors which did not have a good effect.

On Line 95 we call Debug.Print and output the values to Visual Studios output window. The clear value indicates an overall light intensity which the Red, Green, and Blue values are the intensity as seen through a light filter.

Now we start getting deep into the color sensors protocol. To tell the color sensor to take a sample we set the register 0×00 to the value of 0×01. The color sensor then takes a sample and stores it.

The color sensor stores its color values in two 8 bit registers. So. on lines 103 through 106, get_readout() takes the first register as a parameter and assumes the next register is just 1 more address above that register. So we read the value of the first register and then read the value of the second register and then shift the value of the second register 8 bits to the left leaving us with the full 16 bit integer. However, only 10 bits are actually put into the integer because the High registers only return the two least significant bits and the Low register returns 7 Bits.

Each color has two of its own gain registers. We defined these in our constants in the first few lines. Here we again assume that since we know the register address of the lower register, we can just add 1 to that address to get the higher register address. Then we assign the gain values through the help of set_register().

set_register is where the magic happens. Here we create a new byte array which contains two values. The first is r for register and the second is v for value. We pass this byte array to a new I2CDevice.CreateWriteTransaction object and then pass that object to the rtc.Execute method. You should recall that rtc is our I2CDevice object which knows about the slave address of our color sensor. So, in a nutshell our set_register function is where we package everything up and send it on its way.

On Lines 127 through 136 we are sending a request for our color values. We pass it ‘r’ which is the color we want to read. Remember that this happens twice for each color in order to get the full value. We wait 5000 milliseconds or 5 seconds for the return before we timeout.

Lines 137 to 174 is where you can again play around to perfect your results. You’ll need to derive a way to obtain a gain value which compensates for the ambient light and all the other environmental factors which may change the sensitivity. I’ll be honest. I’m not too sure what is going on here. You should check out Interactive Matter for more information about this method.

Finally, lines 175 to 220 tries to establish a suitable gain for each color. This will be called 3 times because each color has a different sensitivity. You can get creative here and come up with your own algorithm which suits your specific application. If you had a controlled environment then in theory this would be very simple. Make sure you post back here and let us know if you stumble across a better way to determine the gain values.

PicKit2 Debug Express

Around the space, we have been using the PICkit 2 Debug Express quite a bit lately.  This has allowed us to get pretty cozy with the functions of this handy little programmer and I thought I would share some of these features with you.

I’m sure you’ve read the previous tutorial ‘Programming PIC Microcontrollers in C‘, if you haven’t, you should go familiarize yourself with it now.  Continuing on from there, after we have a successful build of a led blinking we can use the PICkit 2 to program our chip via the ICSP header.

Our Debug Express Kit’s came with a Demo Board which has a 44 pin PIC16F887 microchip. The microcontroller is connected to a 6 Pin Male header called the ICSP (In-Circuit Serial Programmer) header.  All PIC microcontrollers with the letter “F” in their name can be programmed this way, even if you are using a breadboard and wires to make the connections. The “F” stands for Flash.  Maybe in a future article we will show you how to construct the ICSP header from the data sheet, but we will just assume you are using the 44 Pin Demo Board for now.

You should already have the PICkit 2 connected to your PC via the USB port, so after a successful build of our program, we can program the chip by selecting the ‘Programmer’ menu from within MPLAB, and then selecting ‘Select Programmer’, then ‘PICkit 2′.

At that point below in the debug window you should see a message such as ‘Found PICkit 2 – Operating System Version 2.32.0 …’ If you do not, select ‘Programmer’ then ‘Connect’ from MPLAB.

Finally we select ‘Programmer’ then ‘Program’, and it should start erasing and programming the chip.

Lastly, one tip that speeds up the programming process is to go to the ‘Programmer’ menu and then click ‘settings’. Then check the boxes ‘Program after a successful build’ and ‘Run after a successful program’.  Once you do that you can just hit F10 to compile and flash the pic over and over as you make small adjustments to your code.

In the end, this simple task is actually quite convenient. Being able to program a chip in-circuit, instead of taking the chip out of the socket, putting it in a programmer, programming it, taking it out, putting it back into the other socket, turning on, etc.

Finally, an often overlooked feature is that the PICkit 2 will power your chip if it doesn’t detect any voltage, which for me personally is the case before I have a power supply set up.  I wouldn’t overdue it, you can power small things, led’s, tiny motors but don’t try to draw too much current from it.  The maximum power draw is 200-300mA less than the USB port puts out, which in most cases is around 500mA leaving you with 200-300mA.  So don’t try to overdue it, if you’ve got a lot of power draw in your circuit, set up your own power source and the PICkit 2 will detect the voltage during program and wont try to power it.

Happy Hacking!

In this tutorial we will teach you what we learned. You can then take this new knowledge to your local hackerspace and put it to good use. Let’s get started!

What will you need?

PicKit2 Debug Express

• PicKit2 or PicKit3 Debug Express- The PicKits come with software, an in-circuit programmer (ICP) and a demo board. On the demo board is a PIC Microcontroller, 8 LEDs, 1 Potentiometer (variable resistor), and 1 momentary push button switch. You’ll want the Debug Express version.
• MPLAB IDE – The PicKits come with MPLAB IDE (Integrated Development Environment) software on a CD. However, you should download and install the latest version, as with any software, to avoid running into bugs. MPLAB is where you will do your C Programming.
• CCS Compiler- There is a free demo version of the CCS Compiler. However it’s limited in features. If you plan to do a lot of programming you may want to fork out the money for a full version. CCS comes with its own IDE but you won’t be using that.
• Debug Express Examples – The PicKit 2 comes with a second CD which includes mostly assembly (.asm) examples but does include a couple Hi-Tech C examples. Hi-Tech is an alternative compiler to CCS and chances are these C examples will not work. However, they contain enough information that they are worth looking at.

PicKit2 44Pin Demo Board

Software Installation

Installing the software is fairly straight forward. Start by installing MPLAB and the Debug Express Examples. Then install the CCS Compiler.  You can post a comment here if you have trouble but I don’t think you will.

Start a new Project

1. Start MPLAB
2. From the Project Menu select Project Wizard
3. Click Next – This is just a splash screen telling you about the wizard
4. Select your PIC device – Our PicKit2s came with PIC16F887 chips. Yours may be different so make sure you select the correct chip.
5. Click Next – This takes you to the second step which is the Compiler Setup.
6. From the Active Toolsuite drop down box select CCS C Compiler…
7. Under Toolsuite Contents,  CCS C Compiler (ccsc.exe) should be selected.
8. Browse to the location of ccsc.exe which by default is C:\Program files\Picc\CCSC.exe
9. Click Next – This takes you to the third step which is naming your project.
10. Click browse and create a new project folder and create a new file called Blink. You can use any name but for this tutorial we will be blinking an LED so we call it Blink. It’s a good idea to put projects in their own folder because a bunch of files will be created and associated with the project.
11. Click Next – This takes you to the fourth step which is adding files to your project. We won’t be adding any existing files here so you can just Click Next.
12. Click Finish – It may look like nothing happened or there are no windows open. In this case select View -> Project and this should show the Project Tree.
13. Select File -> New
14. Type the following code:

#include <16f887.h>

void main()
{

}

15. Select File -> Save and save the file as main.c in your Blink project folder.
16. Right Click on the Source Files folder in your Project Tree and select Add Files… Then select the main.c file you just created.
17. Select Project -> Build All and notice that several new files have been created for you. If you get an error check your code.

Project Tree

After you select build all you should notice several new files in your Project Tree. The most important to note is the 16F887.h file under the Header Files folder. Depending on your chip it may be named something different.

Sample Code

So, did you pick up on what just happened here? We created a Source File which we called main.c. It could have been named anything. By using the code #include <16F887.h> and selecting build all the compiler found a compatible header file for our PIC chip and automatically inserted it into our project.

Now you have a complete skeleton project ready for you to fill in the blanks. We’ll give you your first program and examine it line by line. We will also tell you how we learned which functions would work for the compiler and chip combination we are using.

First, we need to get some reading material or resources. You will need to open the help file for the CCS Compiler. They are nice and give you an executable in Windows Start -> Programs -> Pic-C ->Pic C Help. This was installed with the CCS Compiler. Then, we need to get the Datasheet for our chip.

PIC16F887 Datasheet

Here is our sample Blink code:

#include <16f887.h>
#fuses NOMCLR, INTRC_IO, NOBROWNOUT
#use delay(clock=8M)

void main()
{
    while(true)
    {
      output_high(PIN_D1);
      delay_ms(50);
      output_low(PIN_D1);
      delay_ms(50);
    }
}

Line 1:
We already know that this file is what tells the compiler to load the header file in our Project Tree. This line also tells the preprocessor to treat the contents of the 16F887.h file as if those contents had appeared in the source program starting from this line. Keywords that start with the character # are called a preprocessor directive. Some examples are #include, #use, #define, and #fuses which are used most often. This code is used to setup the compiler before it starts compiling your code.

#fuses NOMCLR, INTRC_IO, NOBROWNOUT

Line 2:
The #fuses directive tells the compiler how we want to setup our chip. The available #fuses can be found by looking at the top of the 16f887.h header file. Just double click on it in the Project Tree to open it. At the very top there will be a several-line comment which tells you what fuses can be set. This is one of the murky areas for us still but we can explain what we know so far.

We are setting 3 fuses in our example code. The first NOMCLR stands for No Master Clear. Master Clear is a pin on most chips which can be used to reset the chip. Usually this pin doubles as a Input/Output (I/O) pin. In order to use it as an I/O you must set the fuse NOMCLR to disable it as a Master Clear pin. You’ll always want to do this if you are not using it as a Master Clear because leaving it float will cause your chip to randomly reboot itself.

The second fuse is INTRC_IO which tells the compiler we want to use the Internal RC (Resistor Capacitor) Oscillator and that we want Pins (9) OSC1/CLKIN and (10) OSC2/CLKOUT set as outputs. In our chips datasheet this is cryptically explained on page 61. You might be tempted to use INTRC instead of INTRC_IO. INTRC outputs a clock on Pin 10 which is 4 times slower than our internal oscillator. This is usually written as Fosc/4. Pin 9 is an I/O when using INTRC.

The third fuse we set in NOBROWNOUT. Brownout is a circuit protection feature. If voltage to our chip drops below a certain threshold the chip will shutdown or reset. On page 216 this is described as Vbor for Voltage Brown Out Reset. In our particular chip the brown out voltage can be set at 4Volts or 2.1volts. In our case we don’t want the chip to ever reset no matter what the voltage is. So we set NOBROWNOUT.

#use delay(clock=8M)

Line 3:
The #use directive is followed by another keyword delay. This must be set to the speed at which are oscillator is actually running. Since we are using the INTRC_IO oscillator we know we are using the internal oscillator of this chip. Therefore you need to look in the datasheet of the chip and find out what the normal operating speed of the internal oscillator is. Some chips, including this one, can have their clocks divided to slow them down or they can be clocked faster using an external oscillator such as a crystal. On page 3 of our chip’s datasheet we can see that our chip actually has two internal oscillators. 8Mhz and 31Khz. We are using the 8Mhz here.

The reason #use delay needs to be defined is actually because we are using the delay_ms() function on line 10. delay_ms() uses the #use delay to know how fast the oscillator is running so that it can correctly delay the execution of our code. If you set #use delay to an incorrect value your delay_ms() will function but it will be at the wrong speed. We’ll touch on this again in a minute.

void main()
{

Line 5:
Every program needs a starting point. void main() is the starting point for our program. This is simply how the C language works. Our chip needs to know where to start executing code and it will start in the void main() function. Why void? Void is simply saying that we do not expect our function to return any value. It could be int main but then we would have to return an integer at the end of our program. This is sometimes done to indicate a successful run of the program, but what’s the point? So we just use void and then we don’t have to return anything.

void main()
{
    while(true)
    {
      output_high(PIN_D1);
      delay_ms(50);
      output_low(PIN_D1);
      delay_ms(50);
    }
}

Line 6 and 14, 8 and 13:
Sets of brackets are called blocks. Line 6 starts a block of code and line 14 ends that block of code. Lines 8 and 13 are another pair of brackets and are nested inside of the void main(){} code block. A common syntax error is having too many or two few brackets. For each open bracket you need a matching close bracket.

    while(true)
    {
      output_high(PIN_D1);
      delay_ms(50);
      output_low(PIN_D1);
      delay_ms(50);
    }

Line 7:
We use a while(true) loop so our code keeps restarting. If we did not use a while(true) loop our LED would turn on and off only one time. We want the LED to keep blinking.

CCS Help Program

Line 9:
output_high() is a compiler function. This is unique to the CCS Compiler. Remember that Help File I told you to get ready? It’s located under Windows Start -> Programs -> Pic-C -> Pic C Help. If you select the index tab and type ‘output’ you will see a long list of output options. output_A would control an entire bank, or PORT, of outputs. In our case we only want to toggle one output and we want to set it to High (on). The parameter PIN_D1 is defined in the 16f887.h header file.

See…That header file is coming in handy after all. Instead of you having to look in the datasheet and try to figure out what the hex value of PIN_D1 is, the CCS Compiler has given you a header file which defines a constant name for the value. All you need to know is where to look for the name (in the header file). If you look at the pinout diagram in your datasheet you might notice there is no pin labeled D1. It’s actually labeled RD1. ‘D’ is the Bank and 1 is the Port. Honestly, I don’t know what the R means but who cares. Let’s try another one. What do you think output_high(PIN_A0) will do? You’ve got it. It will turn the pin labeled RA0 in your datasheet to high. See…It’s not that hard once you know where to look.

delay_ms(50);

Line 10 and Line 12:
We already touched on delay_ms(50) when we were talking about the #use directive. Just a refresher here: In order for delay_ms to work you must set #use delay to the proper clock speed. A wrong clock speed will cause delay_ms to not work properly. delay_ms stands for Delay Milliseconds. Where do you think you would look if you wanted to delay micro seconds? You look in the CCS Help program and simply type delay. You would then notice you can delay for Microseconds(_us) or Cycles(_cycles). Clicking on those entries gives you examples of their use.

Line 11:
This one I am going to leave for your homework. If output_high(PIN_D1) turns the LED on then what do you think output_low(PIN_D1) does? Here’s a tip. Look in the CCS Help file.

Conclusion

So, you flashed an LED and now you are bored again. Use the CCS Help file and look up ADC for Analog to Digital Converter. Your Potentiometer is connected to an ADC pin and you should be able to read the help file and learn how to read the position of the potentiometer. You can also search the 44 Pin Demo Board User guide and learn what port the pushbutton is connected to. Then search the CCS Help for Input_State and learn how to use an input to control the LED. So don’t stop with this tutorial. There is lots to learn.

This is where I’m supposed to tell you to come join our hackerspace. But if you don’t live near Baltimore, check out www.hackerspaces.org and find a hackerspace near you. They are all over the world and are a ton of fun.

We are taking the knowledge we learned about flashing LEDs and applying it to hacking Toy RC Cars to make them autonomous (drive themselves). Check out our wiki.harfordhackerspace.org projects page for details on that project. It’s actually a very simple yet rewarding project.

Overview of TortoiseSVN

TortoiseSVN is a shell application. That means it’s an application that it interacts with the operating system. In this case it interacts with the file system. This will become visible in just a few moments. The other thing to know about TortoiseSVN is that you won’t find an icon in your start menu to run some elaborate  GUI (Graphical User Interface). Instead, you will notice a new menu whenever you Right-Click on your Desktop, a File Folder, or a File.  The Windows file system esentially becomes your GUI for working with Files.

The subversion process works by creating a local copy of the existing files. You will be able to distinguish these files from others because they will have additonal icons overlayed on top of your files and folders to show you the status. Once you are finished editing existing files and adding new files you then commit the changes to the remote file server (i.e.  Sourceforge.)

About Those Icons:

A fresh checked out working copy has a green checkmark as overlay. That means the Subversion status is Normal.
As soon as you start editing a file, the status changes to Modified and the icon overlay then changes to a red exclamation mark. That way you can easily see which files were changed since you last updated your working copy and need to be committed.

If during an update a conflict occurs then the icon changes to a yellow exclamation mark.
If you have set the

property on a file, Subversion makes that file ReadOnly until you get a lock on that file. Read-only files have this overlay to indicate that you have to get a lock first before you can edit that file.

If you hold a lock on a file, and the Subversion status is normal, this icon overlay reminds you that you should release the lock if you are not using it to allow others to commit their changes to the file.

This icon shows you that some files or folders inside the current folder have been scheduled to be deleted from version control or a file under version control is missing in a folder.

The plus sign tells you that a file or folder has been scheduled to be added to version control.

Installation

Download the latest  TortoiseSVN installer from http://tortoisesvn.net/downloads. It will have the .msi (Microsoft Installer) file extention. The  TortoiseSVN installer is very straight forward. Just follow the instructions.

Working with Sourceforge

Setting up a Sourceforge account is beyond the scope of this tutorial. We will be looking at this from a supporters or end users perspective. In order to make changes to a projects repository you will need permission from the projects administrator. Sign up for an account and notify the administrator providing them your username.

You will need the URL to the projects repository. This can be found by browsing to the projects homepage and clicking the Develop link on the top menu. Under the subversion access section you will find a URL that looks similar to this: https://hhscnc.svn.sourceforge.net/svnroot/hhscnc.

Putting it all Together

Now that you have installed TortoiseSVN and you found the URL to the repository you want to work with you’ll need to create a local copy of that repository on your machine.

 1. First, right click on your desktop or in a windows file explorer window where you want the folder to be created. Then click the SVN Checkout button.

 2. Enter the URL obtained earlier from the projects sourceforge page. Then enter the file path where you would like the folder to be created. We used “New Folder” as our example folder. Then click OK.

 3. If you have not already created the folder you will be asked if you would like TortoiseSVN to automatically create it.

 4. Watch as TortoiseSVN downloads the files from the remote server and saves them as a local copy in the folder you named above. Then press OK.

 5. You should now have a new folder on your desktop. You may or may not see the icon overlays on the root folder. If you don’t see an icon like ours don’t worry it’s still working properly and should show up after you work with the local copies and make a few changes to the files and folders.

Now that you have a local copy of the repository you can start making changes to those files. Don’t worry about messing anything up because the changes do not show up in the remote repository unless you commit them and even if you do mess something up the administrator of the project can revert back to a previous copy of the file. You should try to be careful when commiting changes because reverting (rolling back) to a previous version of a file is not always easy.

Here is an example of what your folder structures may look like locally. Note the icons as mentioned earlier. In our case all of our folders and files are unchanged. Under settings you can have TortoiseSVN check for updates automatically. This is setup by default as to check weekly but you may change it.

 Working with Folders and Files

Adding, Deleting, Renaming and Commiting changes to the files and folders is very simple. Just work with the folder as if it were any other folder on your file system. After all it actually is just like every other folder. When you create a new file or folder you need to right click on that file or folder and select Add from the TortoiseSVN menu. This does not actually commit the file to the repository. You will need to right click on the folder and select SVN Commit… from the menu to commit added, renamed, deleted or changed files.

One last thing to note is that there is a Delete option under the TortoiseSVN menu. Insteady of simply pressing Delete when working with your files and folders you may want to use this menu item as it will also delete the remote copy of the file the next time you commit the changes.

Final Thoughts

This tutorial is meant to get you up and running quickly. TortoiseSVN is well documented and you should read about any features not discussed here before using those features. Especially if you don’t own the project you are working on.