The buildings look old and rundown compared to what people in the west are used to, but I’m told they all have Internet connections. Seeing people selling things in the street is a common sight.

My friend’s mom spoke of how she used to get taken to school on these buggies.

My friend reminisced about the times he and his cousins used to play around this well as children. He spoke about it with a light smile on his face, so one could tell how he missed those simpler times.

I got a lot of strange looks from people in the village – it was obvious to them I wasn’t from around there. How often do they ever see a foreigner around town? Probably never. On one occasion, the workers on my friend’s family’s farm asked his cousin what I was doing there. For the entire time I was on the farm, I constantly felt their gaze. They even made a comment saying how they had never seen a guy with a man-bun before.

Their family is quite hospitable and prepared a meal for us – according to my friend, his aunt is quite known within the family for being a fantastic cook. The dishes themselves were the typical ones like paneer, chickpeas, and lentils, but she really knew how to control the spices. She was so happy that we all enjoyed her cooking and for my friend, it was a taste of nostalgia.

Check out this link for more photos of this village

The first stop is a food market not far from where we stayed. The curry dish isn’t as spicy as it looks and is very flavourful. The beef noodles is pretty similar to pho, but with their Thai spin on it with the herbs that they use. I’d say it had a bit more umami than the typical pho. The Pad Thai I thought wasn’t as flavourful as I liked, and was actually kind of plain. The other two dishes are highly recommended though!

As far as fruit smoothies go, the fruit seemed to be so much more flavourful. I know that with bananas they are harvested before they’re riped so they can last for a few weeks as they are transported, so it’s possible the same thing is happening with these fruits. But since these fruits are local, they get to fully ripen on the tree.

I also saw them add a little bit of salt to enhance the existing sweetness and acidity of the smoothies. It made it perfectly sweet, without being overpowering.

Next is probably the most famous dish in northern Thailand: Khao Soi. It’s a noodle dish with soft noodles in the soup and deep fried noodles on top. The soup itself can vary in spiciness, but is made of a curry-like sauce with meat, chilis, lime, and coconut milk.

The main attraction about this dish for me is the spiciness of the soup. It isn’t just a big spicy attack on the senses, but rather it’s nuanced because it’s balanced by the coconut milk.

Last but not least, we had some tom yum, yellow curry, and morning glory. This place is an actual restaurant with western style ambience, so naturally there was a price premium to that.

It’s kind of difficult to comment on how the yellow curry and tom yum tasted because it was way too spicy for our senses. I definitely tasted the spiciness and sourness of the soup, but the spiciness overpowered me quickly. The best by far as the morning glory. I just really like leafy greens with crunchy stems. The chilis added gave it a slight zing.

As usual, Mike has made a video!

The food I miss most is definitely the fruit smoothies. When I came back home, I had constant cravings for those smoothies for weeks. To see the other parts of my trip in Chiang Mai, click here.

My computer specifications:

• Intel Core i5-4570
• 16 GB Memory
• Radeon HD 5770

I followed the instructions here, with these changes:

• Using video driver “fglrx-updates” (the tutorial talks about NVIDIA cards)
• Did not install TuxLoL
• Did not do anything regarding the “Maestro error” since it only applies to Optimus Notebook users
• Did not follow step 6 because I did not run into the problem for big item icon text for the item shop
• EDIT: Thanks to Ingvar’s comment, the installation progress for the game can be viewed like so: open terminal (Ctrl+Alt+T) and execute:

tail -f ~/.PlayOnLinux/wineprefix/LeagueOfLegends/drive_c/Riot\ Games/League\ of\ Legends/Logs/Patcher\ Logs/*.log

There are also other steps that I had to do, which I read from here:

• Click configure for the “League of Legends” entry in “PlayOnLinux” and find the “Display” tab and then choose the following options:
  • Direct Draw Renderer – gdi
  • Video memory size – 4096 (or something else depending on graphics card)
  • Offscreen rendering mode – fbo\0
  • Everything else on default
• Create a file called “game.cfg” in the directory “/home/your-username-here/PlayOnLinux’s virtual drives/LeagueOfLegends/drive_c/Riot Games/League of Legends/Config”. Below is what I have in my “game.cfg”:

[General]
EnableAudio=1
GameMouseSpeed=10
UserSetResolution=1
BindSysKeys=0
SnapCameraOnRespawn=0
OSXMouseAcceleration=1
AutoAcquireTarget=0
EnableLightFx=0
WindowMode=0
ShowTurretRangeIndicators=0
PredictMovement=0
WaitForVerticalSync=0
Colors=32
Height=1080
Width=1920
SystemMouseSpeed=0
CfgVersion=5.3.296
x3d_platform=1

[HUD]
CameraLockMode=0
MiddleClickDragScrollEnabled=0
KeyboardScrollSpeed=0.5000
ChatScale=50
ObjectTooltips=0
AutoDisplayTarget=0
ShowAllChannelChat=1
ShowTimestamps=1
ItemShopPrevY=39
ItemShopPrevX=106
NameTagDisplay=1
ShowChampionIndicator=0
ShowSummonerNames=1
ScrollSmoothingEnabled=0
MiddleMouseScrollSpeed=0.5000
MapScrollSpeed=0.5000
ShowAttackRadius=0
NumericCooldownFormat=1
SmartCastOnKeyRelease=0
EnableLineMissileVis=0
FlipMiniMap=1
ItemShopResizeHeight=0
ItemShopResizeWidth=164
ItemShopPrevResizeHeight=1080
ItemShopPrevResizeWidth=1920
ItemShopItemDisplayMode=1
ItemShopStartPane=1

[Performance]
CharacterInking=1
ShadowsEnabled=1
EnableHUDAnimations=0
PerPixelPointLighting=0
EnableParticleOptimizations=0
BudgetOverdrawAverage=0
BudgetSkinnedVertexCount=0
BudgetSkinnedDrawCallCount=0
BudgetTextureUsage=0
BudgetVertexCount=0
BudgetTriangleCount=0
BudgetDrawCallCount=0
EnableGrassSwaying=0
EnableFXAA=0
AdvancedShader=0
FrameCapType=6
GammaEnabled=0
Full3DModeEnabled=0
AutoPerformanceSettings=0
CharacterQuality=4
EffectsQuality=4
EnvironmentQuality=4
ShadowQuality=4
GraphicsSlider=6
paths=0

[FloatingText]
EnemyTrueDamageCritical_Enabled=1
EnemyMagicalDamageCritical_Enabled=1
EnemyPhysicalDamageCritical_Enabled=1
TrueDamageCritical_Enabled=1
MagicalDamageCritical_Enabled=1
PhysicalDamageCritical_Enabled=1
Countdown_Enabled=0
EnemyTrueDamage_Enabled=0
EnemyMagicalDamage_Enabled=0
EnemyPhysicalDamage_Enabled=0
TrueDamage_Enabled=0
MagicalDamage_Enabled=0
PhysicalDamage_Enabled=0
Score_Enabled=0
QuestComplete_Enabled=0
QuestReceived_Enabled=0
Disable_Enabled=0
Level_Enabled=0
Dodge_Enabled=0
Heal_Enabled=0
Special_Enabled=0
Invulnerable_Enabled=0
Debug_Enabled=0
Absorbed_Enabled=0
OMW_Enabled=0
EnemyCritical_Enabled=0
MagicCritical_Enabled=0
Critical_Enabled=0

[Volume]
SfxVolume=0.5
MasterVolume=0.5

In a computer, there are various methods of storing information.  Information can be stored in the processor cache, RAM, hard disk, etc.  It can be faster to request information from a storage medium that is smaller.  However, this smaller storage medium cannot fit all the possible information that can be requested.  So the idea is to insert a portion of the data into the faster, smaller medium (the cache) and the rest into the slower, larger medium (main memory).

If a request is made and the data is not available in the faster, smaller medium first, then the data will be read from the slower, larger medium – this is what is known as a cache miss.

Given that all the data cannot possibly live in the cache, there must be a way to minimize the amount of times that the data must be read from the main memory.

Optimal Caching – Farthest-in-Future

The Algorithm

The idea is that there is an algorithm that minimizes the amount of cache misses that occur for a set of requests.  The Farthest-in-Future Algorithm evicts the item in the cache that is not requested until the farthest in the future.  For example, given the following cache with items “a” through “f”.

It is clear that “g” does not exist in the set of cache items and so when “g” is requested, a cache miss will result. An item will be evicted because “g” is not in the cache.  According to the Farthest-in-Future Algorithm, element “f” will be evicted since it is the one that will be used furthest in the future.

Definitions

Cache Miss – Occurs when it is necessary to bring in an item from the main memory into the cache

Schedule – A list that contains, for each, request, which item is brought into the cache, and which item is evicted

Reduced Schedule – a schedule that only brings in an item when there is a request for that item – so a non-reduced schedule would bring an item into the cache outside of a request for that item

Theorem

To be shown:

Farthest-in-Future is the optimal algorithm that minimizes the number of cache misses.

To prove this, let’s say there is a schedule SFF that follows the Farthest-in-Future Algorithm and that there is a schedule optimal S that has a minimum number of cache misses. It can be shown that it is possible to transform S into SFF by performing a series of evictions without increasing the number of cache misses.  Since S^* is already optimal, and the number of cache misses did not increase, then SFF must be optimal.

To perform one transformation, the statement below can be used.  Right now, it isn’t all that clear why this is necessary, but it should become clearer further on.

Let S be a reduced schedule that is the same as SFF for the first j requests, then there is a reduced schedule S’ that is the same as SFF for the first j+1 requests, and incurs no more misses than S

Proof

Let’s say the cache at the start looks like this.  S and SFF have the exact same contents (this is what was defined in the previous section).

Given a schedule S, it can be shown that any request can be made, and the resulting schedule would be equal to the ideal algorithm and does not increase the number of cache misses.  Essentially, we want S = S’ = SFF after a request is made and that the number of cache misses have not increased.  If this can be shown for all different scenarios that items are requested, then Farthest-in-Future is the ideal algorithm.

Case 1: Item Is Already in the Cache

Now let’s say the next item to be requested is item “d”.  It is clear that this item exists in both caches and no evictions are necessary.  Since no evictions are necessary, SFF does not change.  It was specified in a prior section that there is a schedule S’ that equals SFF, which incurs no more misses than S.

Here, S = S’ because no changes had to be made to the cache and there were no cache misses.  After the request for item “d”, S = S’, each with zero cache misses, which is a valid outcome.

Case 2: Item Is Not in the Cache, S and SFF Evict the Same Item

Let’s say the next item to be requested is item “e”.  Neither cache has this item, so an eviction will have to be made.  Let’s also say SFF and S both choose to evict item “a” to make room for “e”.  It was specified in a prior section that there is a schedule S’ that equals SFF, which incurs no more misses than S.

Here S = S’ because S and SFF both evicted the same item.  Both S and S’ each have one cache miss (no increase relative to one another), which is a valid outcome.

Case 3: Item Is Not in the Cache, S and SFF Each Evict A Different Item

This is where the proof can become more confusing (as if it isn’t already).  Let’s say the next item to be requested is “e”.  Let’s also say that the ideal algorithm, SFF, evicts “a” and S evicts “b”. It was specified in a prior section that there is a schedule S’ that equals SFF, which incurs no more misses than S. This means that in order to get S’ = SFF, S’ should evict “a” in order to match with SFF.

Here, S does not agree with S’ = SFF.  Essentially, these two schedules behave the same, so long as future requests do not request items “a” or “b”.  This shows that there is a schedule S’ that equals SFF, but it is not known whether or not S’ has no more cache misses than S, since “a” or “b” can be requested in the future, which can determine whether S or S’ has more cache misses.  From this point onward, S and S’ behave the same until one of the following happens:

Case 3a: Item Is in SFF, But Not S; S Evicts “a”

Let’s say eventually item “b” gets requested.  In this case, S’ and SFF do not need to change.  All S has to do is evict “a” to make room for “b”.  In this case, S has two total cache misses (from request “e” and “b”), while SFF and S’ each have only one cache miss, thus fulfilling the cache miss requirement.

Case 3b: Item Is Neither in SFF Nor S

Let’s say eventually item “f” gets requested.  S’, SFF, and S all need to make an eviction. S’ and SFF can evict “b” to make room for “f”, and S can evict “a” to make room for “f”.  In this case, each schedule as two cache misses, thus fulfilling the cache miss requirement.

Case 3c: Item Is in SFF, But Not S; S Evicts Item Not Equal to “a”

Let’s say eventually item “b” gets requested and S evicts an item that isn’t “a”, say “c”.  Now, SFF and S’ both already have “b” in the cache.  In order to synchronize S and S’ to make them comparable to see how many cache misses each have, S’ and SFF will evict “c” to make room for “a”.

Since “a” is being brought into the cache without a request for “a”, this makes S’ and SFF no longer a reduced schedule.  However, the proof calls for S’ and SFF being a reduced schedule.  Fortunately, it is possible to transform an unreduced schedule into a reduced one.  In this case, each schedule has two cache misses, thus fulfilling the cache miss requirement.

Case 3d: Item Is Not in SFF, But in S

The only item that is in S and not SFF is item “a”.  SFF had evicted it initially at the beginning of Case 3.  Since SFF had evicted it, it must have been the item that would be requested furthest into the future.  Therefore, it is not possible for item “a” to be requested before other items.

After going through all possible eviction decisions that the schedules can do, it was shown that for each scenario, there was indeed a schedule S’ = SFF, where the cache misses incurred in S’ no more than S.

Paragraph Spacing

setlength{parskip}{7pt}

This goes in the preamble of the document (after the document class stuff, but before the begin document line).

Removing Page Numbers

thispagestyle{empty}

This gets rid of page numbers for that particular page, but the numbering sequence continues on the next page.

Adding Unnumbered Sections into the TOC

section*{Introduction}
addcontentsline{toc}{section}{Introduction}

By default, unnumbered sections do not appear in the table of contents and therefore they must be added manually.

Defining a New Style with fancyhdr

fancypagestyle{plain}{%
fancyhf{}}% clear all header and footer fields

New style definitions should go before the very last curly brace.

Unnumbered Sections Not Working with leftmark and rightmark

section*{Introductionmarkboth{Introduction}{}}

For some reason, unnumbered sections don’t play nice with fancyhdr and don’t get treated as real sections when the leftmark and rightmark commands are used.  By using markboth, it fixes the problem.  Now my headers show the correct section name.

Bulleted List

begin{itemize}
item Here is a bullet.
item Here is another bullet.
end{itemize}

Numbered List

begin{enumerate}
item Here is item one.
item Here is item two.
end{enumerate}

Referencing Sections by Name

section{MyFirstSection} label{marker}
section{MySecondSection}
In section~nameref{marker} we defined...

Requires the hyperref package!  Put the line below in the preamble.

usepackage{hyperref}

Linking to a Website

href{http://www.example.com}{Link}

Umlauts

"{o}

That gives an o with an umlaut.  Just replace the letter to get an umlaut on a different character.

Flight to Barcelona

I woke up at around 3:30am to get ready for the flight to Barcelona.  I had slept at around 10:30pm the night before in order to not feel absolutely terrible in the morning.  We took the first train out to the airport at 4:40am and got there about an hour before our departure at 6:45am.  While going through security, I forgot to take of my belt and because of that, the security personnel checked me with the metal detector wand all over the place.  For some reason, he seemed to also have a huge suspicion that I was hiding something in my pants.  Once he let me go, we were on our way.  On the plane ride there, I tried by my best to take a nap, but this little kid cried for the whole duration.

Sagrada Familia

After dropping off our stuff at the hostel, w went to the Sagrada Familia, an unfinished church that began construction in 1882.  When I saw it, I thought it was really weird that the construction crew used modern cranes to build architecture of the old style.  We tried to go inside, but there was a huge line up.

After wandering around town a little bit, we came across this market that sold all sorts of things.  Apart from pretty normal items like clothing, vendors there sold N64’s, used power tools and even military regalia.  A lot of that stuff was probably stolen.  We walked around some more and then headed down to the beach.

Barceloneta

The area we were in, the Barceloneta, was a stretch of beach coastline looking into the Mediterranean Sea.  It had the nicest beach water and sand – even better than what I saw in Volos.  Looking around the beach, I learned that it was legal for women to sunbathe topless. It was actually quite prominent.  The weather was really hot too – perfect beach weather I suppose. 

I lay down under an umbrella on a beach towel while the others went for a swim.  I ended up falling asleep.  I suppose that made up for not having a good sleep on the plane.  After spending about an hour and a half at the beach, we went on a walking tour.

The Walking Tour

The first destination in the tour was in the Gothic Quarter.  We reached the memorial for Eulalia of Barcelona, a 13 year old girl that was brutally subjected to torture from the Romans for refusing to give up Christianity.  She died from the 13th and final torture that involved her being put inside a barrel with blades shoved inside it and then having that barrel rolled down in incline.  It is said that a dove flew out of her dead body as she ascended to Heaven.

The next destination was the oldest synagogue in Europe (as opposed to the one in Prague, which is the oldest active synagogue).  From the outside, it doesn’t look anything like a synagogue.  It just blends in perfectly with the buildings around it and the building itself doesn’t have any valuable looking ornaments or decorations either.  The only things that separate it from the other buildings is sign in Hebrew on the doorway and some signs for tourists to know that it’s there.  In this Jewish district, the tour guide mentioned the expulsion of Jews during the Spanish Inquisition.  I thought it was kind of amusing when I was caught by surprise at the mention of it – kind of like that quote from Monty Python.

Afterward, we went to Plaza de Sant Felip Neri.  The significance of this place was that the plaza was the site of a air attack from Italian bombers during the Spanish Civil War.  Shrapnel damage from the bombs still scar the walls of the plaza.  On another side of the plaza, the bomb damaged was repaired but one can still see the slight difference in colour between the bricks which shows how much of the wall had been destroyed.

One thing about the streets in the Gothic Quarter of Barcelona is that a lot of them are really narrow – probably only about 10 feet wide.  We walked through these streets for most of the tour.  In one of those streets, we came across a mosaic of Space Invaders.  Apparently, there is an artist who goes all over the world putting them up.

The next destination was the Placa Nova, which used to be the location of the city gates back when the Romans lived in Barcelona.  The remnants of the gate and the aqueduct still exists.  Across from the gate is the City Architecture School, which has a joke drawing by Picasso splattered over it.

After walking some more we saw the Barcelona Cathedral which housed the tomb of Eulalia of Barcelona and also the Placa del Rei, the historical location where Christopher Columbus reported his discovery of the Americas to the Spanish royalty.  We also saw some Roman ruins after climbing a mountain with a height of 16.9 meters (that’s what a plaque actually said) as well as the Placa de San Jaume, the political center of Cataluña (the area of Spain that Barcelona belongs to).

The tour guide also talked about the origins of the flag of Catalonia (Cataluña is the name in Catalan).  It is said that a great warrior Wilfred the Hairy, after being wounded in battle, drew stripes along a copper shield with his blood-stained fingers, hence the four prominent red stripes on the Catalan flag.

We also walked along La Rambla, a popular tourist street in the city.  The tour guide also showed us a city square that featured some of buildings designed by an architect named Gaudi.  Apparently, his designs are all over the city.

Next was the Placa George Orwell.  As a memorial to him (he was involved during the Spanish Civil War), the city named a city square after him.  Ironically enough, this plaza used to be under 24 hour surveillance kind of like Big Brother in his book “1984”.

We finished the tour at a bar and socialized with other people in the tour group for a little bit and drank Sangria.  I got to talk to these people who used to work at the same hostel we stayed at in Hamburg.  It was such a coincidence.

Barcelona’s Skateboarding Fame

After that, we walked around the city to look for the skateboarding spots that Barcelona was so famous for among skateboarders.  I’m not a fan, so I could not recognize the place from skateboarding videos, but it was cool to see a lot of skateboarders in one place showing off their tricks.

Tapas

For dinner, we tried Tapas, a Spanish delicacy.  Tapas are basically a small appetizer dish, but patrons generally order a few of them for a full meal.  Along with Tapas, Paellas are another Spanish delicacy that’s also really delicious.

Sangria is Evil

That night, we spent a little bit of time at the hostel bar.  We all drank Sangria and the thing about that drink is that it tastes a lot like juice, which means it is really easy to drink too much.  And that’s what I did.  I puked a bunch and got a pretty bad hangover the next morning.  I never intended to drink that much in the first place.

While we were drinking, we talked with this black dude and he always had racist jokes to say.  He went on about how white people could never get away with saying racist comments, which was so true. 

Park Güell

I spent the next morning puking too which sucked a lot.  We went to the beach again that morning, but I felt so bad at that time that I decided to go back to the hostel to rest up a bit before doing anything.  I felt a lot better in the evening and so we all continued sightseeing and went to Park Güell.

Park Güell was basically a park that featured a lot of Gaudi’s architectural exploits.  Since he hated the use of right angles in his work, much of the design had curvy edges.  Spanish architecture here was so different from the architecture I’d seen everywhere else.  It was really distinct and unique.

A Less Intense Night (at Least for Me)

After visiting the park, we went to the hostel bar like the night before.  Except this time, I didn’t do any crazy drinking.  We met the same black dude from the night before again and this time he went on about how much he loved eating fried chicken, which just made me crack up so hard.  He perpetuated that stereotype.  Once the hostel bar quieted down, my friends went out for clubbing while I stayed at the hostel and went to sleep.

Mini-Sandwiches

I found out later that they returned at around 6 am.  Two of them were really high on weed apparently when they came back too (weed is legal in Barcelona so long as one possesses less than 50g).  They missed the hostel breakfast that morning and slept in until 12pm.  Once we all got ready, we went out for lunch at a mini-sandwich restaurant. 

The place had so many varieties of mini sandwiches and they all looked and tasted delicious.  I wanted to try all of them, but I was pretty certain that I couldn’t eat that much since I wasn’t hungry for lunch yet.

Montjuïc

After eating, we went up to Montjuïc.  The mountain had a lot of really nice architecture, just like a lot of places in the city.  Also on the mountain was the site of the 1992 Summer Olympics in Barcelona.  We walked around the Olympic stadium and got a really good view of the city.

We walked further up the mountain and reached the fortress at the top.  At the time, we didn’t know there was a gondola that took us up there, so we walked the whole way, which was super tiring in the intense heat that day.  Fortunately, seeing the fortress was worth it.  From there, we got a really good view of the entire city, all the way around. 

After walking around so much, we all got really hungry and took the gondola back down and looked for a place to eat.

Paellas

After trying Tapas on the first day, we decided to try Paellas this time around.  Paellas are basically a rice dish and consists of either vegetables, seafood, or different varieties of meat depending on the type.  We ordered one with seafood and chicken in it. 

Being able to pick meat off bones and peeling the shell off of shrimp was so satisfying.  It was totally unlike the German dishes that involve none of that peeling whatsoever.

Writing at the Beach

We spent the rest of the night at the beach to get one last look at it before leaving the next morning.  When we got there, the sun was already setting so it was quite comfortable at the beach without the sun constantly cooking us. 

As the sun set, it actually got really cold.  While sitting at the beach, I started writing bits of this blog entry in my notebook.  Writing on the beach was really satisfying.

My Joint-Rolling Experience

When we got back to the hostel, two of the people I went with wanted to use up the rest of the weed that they bought.  I refused to do any weed when they offered it to me – even if it was legal here, but I did want to try rolling a joint.  They passed me some of the weed and rolling paper and then taught me how to do it.  In the end, I rolled a better joint than both of them and it was only my first try too.  They called me a “stoner prodigy” and said how I’d be a really good stoner if I ever did weed.  No way I’m going to smoke it for real though even if rolling a joint was an interesting experience.  When the others started smoking the rest of the weed, I returned to the hostel and went to bed.

Flying Back

The next morning we all woke up at 6 am to get to the airport for our flight back to Stuttgart.  For pretty much the entire trip home, our whole group barely talked.  We all had this zombie look on our faces from waking up way too early and not sleeping enough.  It took a few hours for us to return back to our normal state.  We all felt it was a good trip – except for the part where I had too much Sangria.

More photos here

As one of the largest port cities in Europe, we got a chance to go to Hamburg to see its beauty.  We went there by car and saw much of the historical part of the city as well as took a ferry ride along the coast of the Elbe River and walked along the city’s canals.  The weather was pretty much raining for the whole time we were there.  As my friend put it, “when you go to Hamburg, plan for rain”.

The Drive

We left work at around noon to pick up our rental car.  It took us a bit longer than we expected because we had to go grocery shopping so we could have lunch and dinner in the car on the way there for our 6 hour drive (or so we thought).  The drive ended up taking 8 hours because of a stau (traffic jam).

The car we got from the rental company was a Mercedes-Benz C220.  When we got into the car, it smelled like new and being in such a new car for a road trip was undoubtedly awesome. We only got this car because it was the cheapest car with automatic transmission available.  I guess the Renault that we got last time was booked for today.  I wish that I got the chance to drive it though.

On the way there, we got to see a lot of the German countryside (as anyone typically does when going from one major city to another).  On the grass plains and knolls, we saw countless villages, farms, vineyards, and the like.  We even saw farms of wind turbines and solar panels.

After a few hours of driving, we stopped a few times.  We stopped at a rest area and at this middle-of-nowhere village.  The GPS guided us off the highway and into this village just to avoid the traffic jam.  For the first third of the trip, I sat in the front while three of my friends had to squish together in the back.  When it was my turn to sit in the back, I didn’t really feel the discomfort while I was reading on my friend’s Kindle.  I ended up going through about 90 pages of Band of Brothers.  Maybe the book was so interesting that I just completely zoned out of the real world for a little bit.

We reached our hostel at around 9 at night and parked the car.  After moving our stuff into our room, we began our sightseeing tour of Hamburg.

Reeperbahn

Our first destination was the Reeperbahn street.  Similar to Amsterdam, this area is one of the most famous red light districts in the world.  The whole area was full of sex shops, strip clubs, and brothels.  On the street corner, many women wearing fanny packs kept trying to approach tourists and we figured that these women were all prostitutes (that stuff is legal in Germany).

One of the more peculiar things was that there was a church that stood pretty much in the core of the whole area.  Really convenient for people to go to confess their sins I guess.

We meant to find a bar here for a drink, but pretty much all of the places reeked with pungent cigarette smoke or was way too loud.  Two of my biggest pet peeves in one place.  We ended up just going back to the hostel instead.

In order to keep up my “try-as-much-kinds-of-beer-as-possible mentality”, I tried a type of beer called Astra Urtyp.  It tasted horrible – too much of hops flavour.  Some of the others drank a few more beers and got tequila shots before heading out again.  As usual, I went to sleep.  The next morning, I found that they returned at around 5:30 in the morning.

The Rathaus

At around 11, on a cloudy day with a large and persistent ocean breeze (it was super cold even with my jacket on), we showed up at the meeting point for the walking tour – a Starbucks.  This tour company receives some sort of sponsorship from them.  Our tour guide, didn’t look like a German, and when he spoke, a clear Northern USA accent came about – apparently, he had been living in Germany for some time.  He led us to the first destination of the tour – the Rathaus (city hall).

Located by the Alster River, this rathaus replaced the old one that was destroyed in the fire of 1842.  This building looked quite similar in form to other city halls, like the one in Munich and Vienna, with a clock tower-like structure that extended directly above the main entrance.  Right above the gate of the main entrance, the Hamburgers proudly displayed their coat of arms that depicted the old fortress of Hammaburg (where the city got its name) that used to exist in the area before its destruction by the Vikings.  Once more this coat of arms was displayed on the clock tower of the rathaus, just beneath a large antiquated mechanical clock.  Statues of German Kaisers decorated the side of the building as each one stood in a line just beneath the rooftop.

In front of the building was a giant courtyard and during World War II, a bomb landed here, but didn’t explode.  If it had, the rathaus would have been badly damaged.  The bomb was defused and the timing mechanism removed from the bomb is now on display in the rathaus.  In the courtyard, the Hamburgers held the Stuttgart Wine Festival, which apparently coincided with the Hamburg Fish Market in Stuttgart.  Here, people set up tents selling South German cuisine – the kind of German food that I’m always used to eating. 

Along the Alster River stood a giant stone plaque engraved with a message saying that 40000 sons of the city gave their life for us all.  Everyday, people going to the rathaus are reminded of the tragedy that befell the country.  Beside it, swans, ducks and other birds frolicked about and went on with their day to day lives.

Buildings on the other side of the river formed a canal much like in Amsterdam.  Canals could be seen throughout much of the city and in fact, the city holds the world record for having the most amount of bridges.  At first I thought Amsterdam’s 900 bridges was a lot, but apparently Hamburg has around 2300.

St. Peter’s Church

Although, not so significant as a work of architecture, many believe this place to be the site of where the old Hammaburg fortress once existed.  When we stood at the entrance of this church, the tour guide said, “welcome to the highest point of Hamburg!”  I looked around and just saw a gentle slope and nothing more.  I guess Hamburg must not have any mountains! 

Besides being a church, this building once served as a stables for Napoleon’s forces.  Not long after the Napoleonic Wars, the church was destroyed in the fire of 1842.  Despite the fire, much of the art in the building was saved including the lion shaped door knocker – the oldest artifact in the city.  At the back of the church, vegetation grew along the brick walls over the years and not far beside it, a wooden sign stood with directions to various places for pilgrimages.

Expressionist Architecture

During the height of Hamburg’s power in sea trade, many firms set up offices in the city.  Many of these firms had buildings resembling the architecture style of the expressionists – elements of the building’s exterior would reflect the purpose of the building.  For example, in one of the accounting houses for sea trade, one could see elements of the building protruding from its side in the shape of a caravel or an anchor.

In another building, known as the Chilehaus, held the shape of a ship and above the front entrance, there were various objects representing the country of Chile.  Similarly, in the Afrikahaus, there was a giant statue of a tribesman wielding a spear and behind the statue on the gate, was a sculpture of a plant indigenous to Africa.

We also visited the Patriotische Gesellschaft (no idea what that is in English), but this building too had examples of the expressionist art.  Statues of caravels and Poseidon stood on the roof.

World War II Stuff

While on the tour, the guide pointed out a plaque on the side of a building and on it was information saying that the building was once the location of the firm that manufactured the Zyklon B gas that killed millions of people in the death camps.  This plaque used to be located at the main entrance of the building, but the building owners and people working there did not want a daily reminder of those atrocities.  To counteract this, they used a different entrance as the main one instead.

Another destination, the Church of Saint Nicholas was one of the many buildings destroyed during the instead bombing raids on Hamburg.  The church did not get a complete repair after the war, but instead it now stands as a memorial – another reminder of the devastation of World War II.

Deichstrasse

Located near a large network of canals, this area of the city is the oldest part of Hamburg.  Undoubtedly, this area was filled with old architecture and complete with the cobblestone roads that are so prevalent in Europe.  The building style also resembled a lot of 18th and 19th century architecture. 

There would have been more buildings in this area, but through several fires and bombings, much of it was destroyed.  In fact, one of the buildings here was where the fire of 1842 started.  It must have been reconstructed since then.

Speicherstadt

Literally translated, the title means a “city of warehouses”, which indeed is what the area was for – storing cargo.  Back in the day, this area used to be where the Hamburgers traded without having to deal with customs tariffs.

As the size of cargo ships got larger, these buildings began to be obsoleted as many of these cargo ships could not fit in the narrow city canals.

HafenCity

Probably the most modern part of the city, this district serves as a playground for architects.  Much of the buildings here don’t follow any sort of mainstream design ideas – lots of buildings here looked really bizarre.

One building to note though, is the concert house under construction.  It has the shape of ocean waves to represent the city’s rich history of sea trade.  Originally budgeted for 100 million euros, due to construction delays and other unfortunate events, the cost of the building is now nearing 500 million euros.

Before this area became popular, the city had trouble getting people to move here, so they rented out flats here for as low as 500 euros a month, but now people can’t rent a flat here for anything less than 3000 euros a month.

Shopping and Food

After our tour, some of my friends couldn’t stand the freezing ocean wind anymore and decided they had to go buy a hoodie.  The wind was so strong that the clouds weren’t just floating across anymore.  There was like a wind speed of about 20 km/h.  We walked around the old town and found an H&M.  I looked around inside and to my surprise, I found that the prices at this H&M seemed to be a lot higher than Stuttgart.  Otherwise, I most probably would have bought something there.

Later on, we went back to the old part of Hamburg for traditional Hamburg cuisine.  We entered a restaurant that had a theme of sailing.  The wall had on display some schematics and black and white photos of various types of ships.  The color scheme of the place even coincided with the stereotypical blue and white colour combination of sailors. We went to eat at around 3, so it was kind of empty at the time.

The food I tried here was Labskaus – a dish typically served in Northern Germany and according to Wiki, “the main ingredients are salted meat or corned beef, potatoes, and onion. Some – non-traditional – recipes put beetroot, pickled gherkin, or even herring into it.”  Mine was served with beetroot and pickled herring, which was typical of the Hamburg style.

Hamburg Hafen

After our meal, we went to the harbour for a ferry ride along the Elbe River.  The ferry drove along the coastline and gave us a really good view of the city.  We rode the ferry from HafenCity all the way to the beach near the Elbtunnel.  In addition to the city scape, we even saw a docked submarine and a cruise ship about to begin its journey.  The travellers on the ship happened to be doing their lifeboat safety drill as we passed by so the people on the two ships happily waved to each other.

The ocean wind we felt on the ship was so strong that I probably needed a winter coat to keep warm.  The wind even caused the waves to be strong enough such that water splashed onto the deck of the boat and onto everyone standing on it.

On the other side of the river, miles of cranes lined up the shore, ready to unload any cargo on ships that docked.  What we were seeing was the second largest port in Europe, the largest being the one in Rotterdam.

Bar District

Supposedly, this area is known as the bar district (at least that’s what we called it).  Despite its name though, there was a really tight concentration of bars here, but the cost of beer was even more than Stuttgart.

At the bar/restaurant, I ordered an apple strudel to help combat my hunger from walking around all day instead of going for beer like everyone else did (although I did have a little bit).  The apple strudel I got wasn’t that expensive and it looked and tasted amazing.

Fish Market

The next morning, we went to the fish market – Hamburg is famous for it.  However, we got there a little late, so by the time we got there, a lot of the places were closing down.  As a last ditch attempt to sell more stuff, a lot of shops there started giving people really good deals on food like selling a whole box of fruit for only 1 euro.  I would have bought it if I could eat all of that.  A pile of garbage behind all these people went to show how much food they sold that day.

Although the market by named says “fish”, people sold all sorts of things in addition to fish.  Many sold bread, cheese, and various types of meat.  I wondered if I’d see something similar to the wurst man I saw a while back, but I didn’t.

The market even had an indoor beer garden with a live band playing.  It was quite a nice place.  If only we were there early enough.

Driving Home

As I probably should have known, I could not resist the urge to drive.  I ended up taking the wheel for about half an hour and managed to get the Benz up to 200 km/h.  While driving at that speed though, the steering wheel was really shaky.  I felt that if the car ran over a pebble or something like that, the car would just plunge into the side of the road.  If it wasn’t for that, I would have reached the car’s top speed.

Before I started driving though, we stopped at a rest area.  When we took a good look at the back seat of the car and noticed a giant mess of crumbs from all our snacking during the trip.  I don’t think I had any to do with that since I never considered myself to be a messy eater.  Just as we finished commenting about the messiness of the car, one of my friends had apparently stepped on dog poop and got it in the car.  It smelled horrible.  He even got it onto another friend’s pants.  He cleaned it up right away, but a faint smell of the poop lingered in the car for the rest of the journey.  It’s a shame that the car rental company gave us a car smelling like new just so we’d give it back with a bad smell.

In another rest area near Frankfurt, we stopped for a bite to eat and went up to the observation tower there to look at the Frankfurt skyline.  That was a nice sight except for the giant high voltage line that blocked part of the view.  By then we were already pretty much 3/4 of the way home.  I continued reading Band of Brothers on the Kindle and managed to get through about 65% of the book in total.  We got back into Stuttgart at around 7:30 in the evening, returned the car, and went home.

More photos here

Link: http://www.heerengandhi.com/2009/07/29/firefox-icon-went-missing-in-windows-7-heres-a-fix/comment-page-1/

The Blog-Health-o-Meter reads This blog is on fire!.

Crunchy numbers

A Boeing 747-400 passenger jet can hold 416 passengers. This blog was viewed about 6,600 times in 2010. That’s about 16 full 747s.

In 2010, there were 85 new posts, growing the total archive of this blog to 120 posts. There were 48 pictures uploaded, taking up a total of 3mb. That’s about 4 pictures per month.

The busiest day of the year was November 23rd with 83 views. The most popular post that day was South Korea: Yet Again Swallowing the Bitter Pill.

Where did they come from?

The top referring sites in 2010 were zamunda.net, facebook.com, dailyblogged.com, google.com, and en.wordpress.com.

Some visitors came searching, mostly for p1i windows 7, p1_usb_signed_drivers, p1_usb_signed_drivers.rar, p1_usb_signed_drivers package, and failed to load resource sony ericsson.

Attractions in 2010

These are the posts and pages that got the most views in 2010.

South Korea: Yet Again Swallowing the Bitter Pill November 2010
1 comment

Connecting a Sony Ericsson P1i to a Windows 7 x64 Computer in Phone Mode December 2009
1 comment

Snow Leopard on a Dell Inspiron 1520 June 2010
17 comments

How to Install Solidworks 2008 on a x64 Operating System November 2009

SolidWorks 2010 Side-By-Side Configuration Error Fix August 2010
5 comments

Generally, communication with serial ports involves these steps (in no particular order):

• Searching for serial ports
• Connecting to the serial port
• Starting the input output streams
• Adding an event listener to listen for incoming data
• Disconnecting from the serial port
• Sending Data
• Receiving Data

I wrote an example program that includes all of those steps in it and are each in their own separate method within the class, but first I will go through my hardware set up.

Hardware Setup

My current hardware setup is as follows:

• PC connected to an XBee
• Arduino connected to an XBee

User input is given from the PC through the a Java GUI that contains code for serial communication, which is the code presented here.

The Arduino is responsible for reading this data.  This set up is pretty much using my computer as a remote control for whatever device is on the Arduino end.  It could be a motor control, on-off switch, etc.

Existing Code

The purpose of this post is to discuss serial programming in Java, and not GUI’s.  However, I did create a GUI for testing purposes.  See the Code Downloads section for the actual files.

Above is the picture of the GUI complete with the buttons that I use to interact with the program.  I also added key bindings which I can use to control the throttle.

When the program is first started, none of the GUI elements will work except for the combo box and the connect button.  Once a successful connection is made the controls are enabled.  This is done through the use of the setConnected(true) and the toggleControls() methods shown in the example code that follows.

Imports

The imports i used for this program were as follows:

import gnu.io.*;
import java.awt.Color;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.TooManyListenersException;

Depending on the Java IDE it might already know to tell you to use these imports except for the first one.  That first import is specific to RXTX, and all its library methods/classes are in there.

Class Declaration

The code here reads:

public class Communicator implements SerialPortEventListener

I named my class Communicator, but the name is really up to the programmer.  The name pretty much reflects its intended use.

The class should also implement the SerialPortEventListener class.  This is a class in RXTX and is required in order to receive incoming data.

On some IDE’s this may generate a public void method called serialEvent().  This method will be defined later.

Class Variables and Constants

Below are the variables and constants that I defined in my class.  What the variables are for is in the comments but a more detailed explanation will follow.

    //passed from main GUI
    GUI window = null;

    //for containing the ports that will be found
    private Enumeration ports = null;
    //map the port names to CommPortIdentifiers
    private HashMap portMap = new HashMap();

    //this is the object that contains the opened port
    private CommPortIdentifier selectedPortIdentifier = null;

I could have easily put the variable definitions in the constructor but it wouldn’t change anything.

The GUI object is another class that I wrote separate from this one that contains all the GUI elements.  The GUI class extends javax.swing.JFrame.

The HashMap is for mapping each of the ports’ names to the actual object. What that means is that I can associate (put() method) the name of a serial port, say a string that says COM1, to an object in the code.  Later, I can access the name COM1 from the HashMap by using the get() method and it will return the object that it was associated with previously.

The CommPortIdentifiers object is needed to gather the list of ports that are available for connection. by using its getPortIdentifiers() method.

The SerialPort object is for storing the data for the port once a successful connection is made.

The InputStream and OutputStream is the object that is required for sending and receiving data.

The Boolean variable bConnected is just a flag that I use for enabling and disabling elements on the GUI.

The constant TIMEOUT is a number required when opening the port so that it knows how long to try for before stopping.

The constants for the ASCII values are some values that I use to send through the output stream that act as delimiters for data.

The string logText is basically what the comment says.  When stuff happens in the program, the program stores a string in this variable and it will be appended to a text area in the GUI.

Searching for Available Serial Ports

The method below is for searching for available serial ports on the computer.  Code adapted from Discovering Available Comm Ports from the Reference Material.

    //search for all the serial ports
    //pre style="font-size: 11px;": none
    //post: adds all the found ports to a combo box on the GUI
    void searchForPorts()
    {
        ports = CommPortIdentifier.getPortIdentifiers();

        <span style="color: blue;">while (ports.hasMoreElements())
        {
            CommPortIdentifier curPort = (CommPortIdentifier)ports.nextElement();

            //get only serial ports
            <span style="color: blue;">if (curPort.getPortType() == CommPortIdentifier.PORT_SERIAL)
            {
                window.cboxPorts.addItem(curPort.getName());
                portMap.put(curPort.getName(), curPort);
            }
        }
    }

The method getPortIdentifiers() returns an Enumeration of all the comm ports on the computer.  The code can iterate through each element inside the Enumeration and determine whether or not it is a serial port.  The method getPortType() can identify what kind of port it is.  If it is a serial port, then the code will add its name to a combo box in the GUI (so that users can pick what port to connect to).  The serial port that is found should also be mapped to the HashMap so we can identify the object later.  This is helpful because the names listed in the combo box are the actual names of the object (COM1, COM2, etc), and so we can use these names to identify the actual object they are tied to.

Connecting to the Serial Port

The method below is for connecting to the serial port once they have been found (see previous section).  See How to Open A Serial Port in the Reference Material for more information.

    //connect to the selected port in the combo box
    //ports are already found by using the searchForPorts
    //method
    //post: the connected comm port is stored in commPort, otherwise,
    //an exception is generated
    public void connect()
    {
        String selectedPort = (String)window.cboxPorts.getSelectedItem();
        selectedPortIdentifier = (CommPortIdentifier)portMap.get(selectedPort);

        CommPort commPort = null;

        try
        {
            //the method below returns an object of type CommPort
            commPort = selectedPortIdentifier.open("TigerControlPanel", TIMEOUT);
            //the CommPort object can be casted to a SerialPort object
            serialPort = (SerialPort)commPort;

            //for controlling GUI elements
            setConnected(true);

            //logging
            logText = selectedPort + " opened successfully.";
            window.txtLog.setForeground(Color.black);
            window.txtLog.append(logText + "n");

            //CODE ON SETTING BAUD RATE ETC OMITTED
            //XBEE PAIR ASSUMED TO HAVE SAME SETTINGS ALREADY

            //enables the controls on the GUI if a successful connection is made
            window.keybindingController.toggleControls();
        }
        catch (PortInUseException e)
        {
            logText = selectedPort + " is in use. (" + e.toString() + ")";

            window.txtLog.setForeground(Color.RED);
            window.txtLog.append(logText + "n");
        }
        catch (Exception e)
        {
            logText = "Failed to open " + selectedPort + "(" + e.toString() + ")";
            window.txtLog.append(logText + "n");
            window.txtLog.setForeground(Color.RED);
        }
    }

Using the HashMap we can retrieve the CommPortIdentifier object from the string that was mapped earlier.  This is achieved through the HashMap’s get() method.  The object must also be casted as a CommPortIdentifier because the get() method has a return type of Object.

The setConnected method just changes a boolean flag so that the program can store whether or not it is connected to a serial port or not.

The CommPort must also be initialized because the port object will be stored here once a successful connection is made.

The main method of interest here is the open() method.  This instructs the program to open the port, and this method will return the object for the opened port, which I store in in the previously initialized CommPort object.  I then cast this object as a SerialPort and store it as well.  This is helpful for accessing the methods and variables specific to the SerialPort class.

It should also be noted that the open() method requires the use of a try-catch block.  So applying that, I catch two different exceptions.  The PortInUseException is what the name says.  If the port is in use, then this exception is thrown.  The next catch block is just for the generic exceptions that occur.  I never came across that during testing, nor do I know how to replicate that.

I neglected to include any code for setting the baud rate and other settings on the XBee’s (see Hardware Configuration), because I already set those parameters previously using X-CTU (more on setting up XBee’s here).

Initializing the Input and Output Streams

This method is pretty short and is pretty straightforward to read.

    //open the input and output streams
    //pre style="font-size: 11px;": an open port
    //post: initialized input and output streams for use to communicate data
    public boolean initIOStream()
    {
        //return value for whether opening the streams is successful or not
        boolean successful = false;

        try {
            //
            input = serialPort.getInputStream();
            output = serialPort.getOutputStream();
            writeData(0, 0);

            successful = true;
            return successful;
        }
        catch (IOException e) {
            logText = "I/O Streams failed to open. (" + e.toString() + ")";
            window.txtLog.setForeground(Color.red);
            window.txtLog.append(logText + "n");
            return successful;
        }
    }

The streams are initialized by returning the input and output streams of the open serial port.  In order for the serial port object to not be null, it must store the object for the open serial port.

The getInputStream() and getOutputStream() methods both require a try-catch block.  The important exception to catch here is the IOException to signify whether the streams failed to open or not.  For more information see How to Open A Serial Port in the Reference Material.

I also call a method called writeData(0, 0).  This is the method that encapsulates the code required to write serial data.  More on that later.  Right now it is just used to set variables on the microcontroller side to zero.

Setting Up Event Listeners to Read Data

Once the port is open, the serial port must know whenever there is data to be read.  This approach is event driven rather than by polling.  When the event is hit, a special block of code will run.  This is advantageous to polling because polling requires constantly asking if data is available.  The code for the event driven approach is below.  See Event Based Two Way Communication for more information.

    //starts the event listener that knows whenever data is available to be read
    //pre style="font-size: 11px;": an open serial port
    //post: an event listener for the serial port that knows when data is received
    public void initListener()
    {
        try
        {
            serialPort.addEventListener(this);
            serialPort.notifyOnDataAvailable(true);
        }
        catch (TooManyListenersException e)
        {
            logText = "Too many listeners. (" + e.toString() + ")";
            window.txtLog.setForeground(Color.red);
            window.txtLog.append(logText + "n");
        }
    }

The code here is pretty much the whole reason why this class implements SerialPortEventListener.  The parameter for adding the event listener is just the object itself.  The base class has a method called serialEvent(event) that should be overridden before the event code will work.  Overriding that method defines what happens when the event is hit.

The method addEventListener(this) is the event that is always checking for SerialEvents.  It isn’t really important to know what the events actually are, just that the one we’re interested in is the one that tells us whenever data is received.  Adding the event listener is complemented by the method notifyOnDataAvailable(true), which definitely helps us achieve what I mentioned previously.

This code requires a try-catch box.  The exception here is that there may be too many event listeners.  I only use one in the code, so this exception should never be hit.

Disconnecting from the Serial Port

Once all the communication is completed, the serial port must be disconnected.  In some instances, some ports stay stuck open, which isn’t exactly a good thing.

    //disconnect the serial port
    //pre style="font-size: 11px;": an open serial port
    //post: closed serial port
    public void disconnect()
    {
        //close the serial port
        try
        {
            writeData(0, 0);

            serialPort.removeEventListener();
            serialPort.close();
            input.close();
            output.close();
            setConnected(false);
            window.keybindingController.toggleControls();

            logText = "Disconnected.";
            window.txtLog.setForeground(Color.red);
            window.txtLog.append(logText + "n");
        }
        catch (Exception e)
        {
            logText = "Failed to close " + serialPort.getName()
                              + "(" + e.toString() + ")";
            window.txtLog.setForeground(Color.red);
            window.txtLog.append(logText + "n");
        }
    }

The code here requires a try-catch block so there it is.  The exception to catch here is pretty generic.

Before closing the port, I reset the data on the microcontroller.  That step is optional depending on the application.  For example, if the value sent to the microcontroller is controlling the speed of a motor, I’d want the motor to turn off if I turn off the remote control.

The event listener should be removed as it is no longer needed.

The method to close the port is the close() method.

The input and output streams should also be closed via the same method as above.

See How to Close A Serial Port in the Reference section for more information.

Reading Data – The serialEvent Method

This is a follow-up to the section on preparing to Read Data.  It has information on how to process the data that the program reads.

    //what happens when data is received
    //pre style="font-size: 11px;": serial event is triggered
    //post: processing on the data it reads
    public void serialEvent(SerialPortEvent evt) {
        if (evt.getEventType() == SerialPortEvent.DATA_AVAILABLE)
        {
            try
            {
                byte singleData = (byte)input.read();

                if (singleData != NEW_LINE_ASCII)
                {
                    logText = new String(new byte[] {singleData});
                    window.txtLog.append(logText);
                }
                else
                {
                    window.txtLog.append("n");
                }
            }
            catch (Exception e)
            {
                logText = "Failed to read data. (" + e.toString() + ")";
                window.txtLog.setForeground(Color.red);
                window.txtLog.append(logText + "n");
            }
        }
    }

Since we only want to read data if it exists, we test the condition in the if statement above.  This could be redundant because we wouldn’t be in this method if the event never got triggered.

Reading the data requires a try-catch block.  The read() method returns an integer, but the value in it is actually a byte value so this is casted to a byte, in which I store in a variable called singleData.  When I was testing this code before, I noticed that the data being read would always have random new line characters in it, and I never knew why this happened.  I never wrote any new line characters.  Since I don’t want these, I add an if condition saying that if it encounters that, don’t display that data on the screen.

Java also has a nice way of converting bytes to a string.  A byte array can be used as a parameter when initializing a string, which is what I’ve done when I assign a value to logText.

The exception here is just the usual generic one.

Writing Data

Here is the method for writing data.  In my application, I am writing two integers sequentially to my microcontroller.  Data that is sent to the MCU can be used for such things such as controlling motor speeds, which is what I am trying to do here.  I hope to use the data sent do control the PWM duty cycle of the motor for speed control.

    //method that can be called to send data
    //pre style="font-size: 11px;": open serial port
    //post: data sent to the other device
    public void writeData(int leftThrottle, int rightThrottle)
    {
        try
        {
            output.write(leftThrottle);
            output.flush();
            //this is a delimiter for the data
            output.write(DASH_ASCII);
            output.flush();

            output.write(rightThrottle);
            output.flush();
            //will be read as a byte so it is a space key
            output.write(SPACE_ASCII);
            output.flush();
        }
        catch (Exception e)
        {
            logText = "Failed to write data. (" + e.toString() + ")";
            window.txtLog.setForeground(Color.red);
            window.txtLog.append(logText + "n");
        }
    }

The write() method here requires a try-catch block just like many of the other methods used for serial communication.  Using the output stream, I call that method to write an integer value.  I also write a dash and a space to separate the actual data being read.  See the ASCII Table for the values of what these characters should be.  This helps me differentiate the sets of data that is sent back and forth.  The dash separates the two integers being sent and the space separates the entire set.  On the Arduino end, four called to read() can separate the data without mixing things up.  Example of that later.

Putting All the Java Code Together

Once all these methods are setup, they need to be called somewhere in the program so we can put them to use.  When the program starts, the code for searching for serial ports will run so that it can populate the combo box on the GUI.  The GUI buttons also need to be disabled to reflect the fact they should be disabled when there is no connection to a port.  When the connect button is pressed, the input and output streams are started and the event listener is added.  The code for that is shown below.

        private void btnConnectActionPerformed(java.awt.event.ActionEvent evt) {
            communicator.connect();
            if (communicator.getConnected() == true)
            {
                if (communicator.initIOStream() == true)
                {
                    communicator.initListener();
                }
            }
        }

The if statement is needed such that the code will not run if a successful connection was not made.  This is the precondition for the initIOStream() and the initLIstener() methods.

When the user decides to disconnect from the serial port, the user only needs to call the disconnect() method when the disconnect button is pressed.

The up/down arrows on my GUI are set to write data to the serial port when they are pressed.  When data is written to the Arduino, the MCU will send the data back to the Java program, which will signal the event listener to display that data back to the screen.

Arduino Code

The Arduino code is pretty straight forward.  There are just a few calls to the read() method.

Update 6 May 2012: the syntax for the Arduino code has updated since the writing of this article.  Apparently, the lines

Serial.print(separator, BYTE);
Serial.print(space, BYTE);

are no longer valid and have since been replaced by the following:

Serial.write(byte(separator));
Serial.write(byte(space));

The code below hasn’t been edited with this change, but basically the code required for writing a byte value through serial communication has changed.

// this is where we will put our data
int left = 0;
int right = 0;
byte space = 0;
byte separator = 0;

void setup(){
  // Start up our serial port, we configured our XBEE devices for 38400 bps. 
  Serial.begin(9200);
}

void loop(){
  // handle serial data, if any
  if (Serial.available() >= 4){
    left = Serial.read();
    separator = Serial.read();
    right = Serial.read();
    space = Serial.read();
    Serial.flush();

    Serial.print(left);
    Serial.print(separator, BYTE);
    Serial.print(right);
    Serial.print(space, BYTE);
    Serial.print("n");
  }
}

I first declare four variables to reflect the fact that I’m writing four different variables to the serial port.

In the loop method, I added a condition which will check whether there are four pieces of data available before reading them.  This again reflects the fact I’m writing four values.

The four variables initially declared store the values in the order that they are written, and then are just printed to the screen.

The print() method is able to convert the byte value to an actual character by adding a second parameter called BYTE.  The left and right variables don’t need it because the values written were integers to begin with, however, the dash and space characters were written as ASCII values.

For more information about Arduino and Java, and Arduino’s Serial library, please refer to those in the Reference Section.

Code Downloads

Here are the code downloads for the GUI, key bindings and the serial communication.  WordPress doesn’t allow uploads of zip or java files so I uploaded it all to Megaupload.

Link to download: http://www.mediafire.com/?z2l26ncypmzn20z

Other Examples

There are also other sites I looked at which had example code for serial port communication in Java.  The sites are Programming Serial and Parallel Ports and Serial Port Access Using RXTX in Java, which are both in the Reference section.

Reference Material

Below are a bunch of links to reference sites that I used to find some of the information written here.  I mostly referred to bits and pieces of each article to understand the serial code and to come up with the example I present here.  The list is in the order that I referenced them.

Discovering Available Comm Ports

http://rxtx.qbang.org/wiki/index.php/Discovering_available_comm_ports

The code on this page is pretty specific to the title of this heading, and the code is pretty easy to follow.

How to Open A Serial Port

http://embeddedfreak.wordpress.com/2008/08/08/how-to-open-serial-port-using-rxtx/

This page provides a very concise and detailed explanation on what each line of code does in order to get a serial port open.  Definitely work a look if you’re trying to understand the code.

Event Based Two Way Communication

http://rxtx.qbang.org/wiki/index.php/Event_Based_Two_Way_Communication

This page has example code on how to connect to a serial port and how to interact with it.  The code here uses events, rather than polling, to send data back and forth, which means that whenever data is received, the event code is triggered.

How to Close A Serial Port

http://embeddedfreak.wordpress.com/2008/08/08/how-to-close-serial-port-in-rxtx/

This article is written by the same author who wrote the article on how to open serial ports.  Good example code here.

ASCII Table

http://www.asciitable.com/

Having the ASCII Table is quite handy for serial data because data being sent and written are bytes, so being able to know what byte values correspond to what character really helps.

Arduino and Java

http://www.arduino.cc/playground/Interfacing/Java

This article discusses how to use the serial port communication with Java and Arduino, which is exactly what I am after.  It has example code on pretty much the entire process of serial port communication, but it may be too much to read since there is little explanation about the code.

Arduino Serial Class

http://arduino.cc/en/Reference/Serial

A good reference for Arduino’s Serial class methods.  Also has example code to look at.

Programming Serial and Parallel Ports

This article provides a brief introduction to programming serial ports and has information on the steps required to talk to the serial port.  However, the code examples in there may be hard to follow for someone new to serial programming.

Serial Port Access Using RXTX in Java

http://gomultidomain.blogspot.com/2008/06/serial-port-access-using-rxtx-in-java.html

This page also has complete code for serial communication in Java, but what I was looking for here was how to use the write method to send serial data from Java.