DIOGO SILVA

This work was the result of my dissertation done in a robotic soccer team, known as CAMBADA. Due to the continuous growth in the area of robotics, there is an increasing need for robots to communicate among them in order to create cooperation scenarios, as for example in robotic soccer. At CAMBADA, a robotic soccer team which actively participates in national and international competitions, there is an internal module responsible for ensuring that robots can easily access information shared between them in a simple and effective way.

This module is known as Real-Time Database (RtDB) and allows the replication of data sent by different robots, ensuring that each robot can easily access information that was read or interpreted by another robot. The model used by RtDB is based entirely on shared memory, with each robot containing the information generated and shared by the others replicated in its instance. This way, the access to the data of a remote robot is efficient. Updating the data stored in the RtDB is done in a transparent manner by an additional process.

The following image shows how the replication is done in the RtDB by using an additional process and replication areas inside each agent:

The objective of this dissertation was the conception, development, implementation and validation of a new version of the RtDB, called RtDB2, that would fill some limitations identified in the previous version, and that simultaneously could introduce some new functionalities. One important limitation eliminated by the RtDB2 was the existing imposition of previous knowledge of the memory space that an information item would occupy. This would force to previously define the size of the data structures to the most unfavorable cases, which would lead to a memory waste and an unnecessary bandwidth usage. Among the new features introduced, there is the potential of using different programming languages to produce and consume the same item of information, the possibility of dynamically introducing new items or the tolerance to small modifications in the definition of an item.

The new solution was duly tested and used in two of the annual competitions of RoboCup (Portuguese Robotics Open in Coimbra, Portugal and RoboCup 2017 in Nagoya, Japan), without any occurrences of problems.

Participated as Google Summer of Code Student by coding for an open-source organization, in this case, VideoLAN. I have not worked for Google during this project, Google is just responsible for “creating the bridge” between the organizations and the students.

Official Project Description: https://summerofcode.withgoogle.com/archive/2017/projects/6570146898378752/

This following description is the equal to the one submitted as the result from Google Summer of Code.

Description and Milestones Overview

The idea of this project was to add direct support inside VLC allowing the user to manipulate cloud storages (e.g. Google Drive). Several milestones had to be set up in order to achieve the final product:

1. Access and services discovery module
2. Add support for multiple users
3. Replace microhttpd from libcloudstorage with VLC internal httpd module
4. Replace libcurl from libcloudstorage with VLC internal http module
5. Add VLC functionality to spawn an external browser
6. Support the HTTP handle

The numbers from this enumeration are used through this document.

Repositories

The repositories below are the ones that I have been working on. You will notice that there will not be any commits from me in the branch master, because it is the branch that I always rebase from the original repository. All the others branches were managed by me.

• https://code.videolan.org/GSoC2017/dbtdsilva/vlc - The last version of my code is always maintained under the branch cloud-integration-master
• https://code.videolan.org/GSoC2017/dbtdsilva/libcloudstorage

Patches submitted

These patches were the ones sent to the VideoLan mailing list. It includes the majority of the work that was done until the last 2 weeks. After that, I have done more improvements based on the comments in the patches and also some problems that I have found (that latest work can be found at branch cloud-integration-master in my VLC clone).

1. keystore: add the possibility to delete credentials - was necessary in order to remove already logged in users;
2. http: resource is now able to invoke other methods rather than only GETs - the original VLC http module only allowed to perform GET operations and the others are also necessary to fulfil milestone 4;
3. http: the connection will now sent a payload if requested - this patch is the continuation from the previous one;
4. dialog: add new dialog that spawns a browser if the user allows it - this is the implementation of milestone 5 giving the possibility to spawn the default browser through VLC functions;
5. cloudstorage: add access module integrating libcloudstorage - implements milestone 1 and 2;
6. qt: add cloudstorage integration and improved sidebar sub-trees logic - allows to create sub-trees in the sidebar in a more cleaner way. It also has the modifications that spawns dialogs necessary for the integration;
7. cloudstorage: sd: add services discovery module - implements milestone 1;
8. cloudstorage: access: custom-made html pages to the http server responses - this patch is simply a question of aesthetics allowing to have more user-friendly responses from the http server;
9. cloudstorage: replaced microhttpd dependency by using vlc_httpd - implements milestone 3;
10. cloudstorage: replaced curl dependency by using functions from http module - completes the implementation for milestone 4.

The milestone 6 was left out because it could be easily achieved by using LUA playlist scripts that already exist in VLC.

Work done under repositories

Under vlc repository [branches]

This repository contains several branches that were used during this project.
The branch cloud-integration-master is the main one, where the latest code is always located.

The code under this repository was already described under the patches submitted, since it contains all the work rebased. There is some work that is not considered in the patches, such as:

• fix in the keystore under the tag secret-sem-fix, that basically corrects a deadlock;
• some commits for the services discovery, because it was not user-friendly at the beggining;
• httpd interface modification to support MegaNz needs (this provider was discarded);
• the most recent changes in the branch cloud-integration-master that contain minor fixes to problems that I had been finding and some user-friendly improvements.

Under libcloudstorage repository [branches]

This repository has several branches: gsoc-master, gsoc-master2, gsoc-merged, gsoc-merged-2, gosc-merged-3.

The branch gsoc-master-2 should be the one used for testing purposes with VLC. It contains the commit that modify the keys for each API with the configurations used in VLC (redirect URIs mainly).

The branch gsoc-master was initially used to create an HTTPD interface in order to get rid of the microhttpd server and use httpd server from VLC (to be possible to implement the 3rd milestone). However it was later supported by libcloudstorage recent modifications.

The branches that start with gsoc-merged* were only used to create pull requests to the original libcloudstorage repository:

• Pull Request 7 - Added URL class, Auth can now have a prefix, improved JS responses and other fixes/improvements contains some modifications that make the HTTP interface independent from the URL class that encodes/decodes URLs. It also contains modifications that allow the specification of a path where the auth server will be listening and some minor improvements;
• Pull Request 8 contains the same modifications as the pull request 7, with consideration on the comments and rebase with the newest modifications on libcloudstorage;
• Pull Request 10 contains minor fixups for bugs or functionalities that I have found necessary (even though it was not merged, it was considered in several commits in the master branch).

Work left to be done

• Add VLC functionality to spawn the default browser under MacOS GUI (since I had no MacOS device to create such a functionality). Nevertheless, It was done for the QT interface.
  The only thing that is required is to fill a callback created to spawn the default browser using MacOS tools. The logic under the core is already done.

How to check the work done

1. Clone libcloudstorage repository and checkout to the branch gsoc-master-2;
2. Compile and install the library (advisable to use –prefix on “configure” to install it in a custom location);
3. Clone my VLC repository and checkout to the branch cloud-integration-master
4. Compile the code and run it. You may need to specify the location of libcloudstorage if the Cloud Storage does not appear on the sidebar. Use CXXFLAGS=”-I/usr/include/cloudstorage/” (with the prefix that you have specified) during the “configure”.
5. You will be able to see the Cloud Storage in the sidebar or even access it through a MRL **./vlc cloudstorage://[user_label@]/[path]** (user\_label and path are optional)

This project came across with the idea of developing a faster game to implement using real-time techniques and deploy it under a Xenomai system. So it was decided to implement Tower Defense as real-time system. The Tower Defense game is composed of a path, where monsters have to find their way to the end.

The objective of the game is to not allow the monsters to reach the end of the path. To do so a human player must place towers alongside the path, that will try to take out the monsters while they traverse it. The human player can place or remove towers, but it can’t interfere with the behaviour of the towers. To make the game more interesting, difficulty will increase when the player surpasses a level. This increase in the difficulty was implemented by introducing a stronger type of monster.

In my GitHub it is possible to find out a more detailed explanation about the existing tasks in the system and the respective report proving that the system is schedulable. Feel free to check at: https://github.com/dbtdsilva/tower-defense

The following image shows a scenario with a total of 7 tasks (1 cannon, 4 minions, 1 god task and 1 user interaction):

This project consisted of detecting and tracking cars from a digital camera placed on the car’s front. The main objective of this project was to study what has been used so far in this kind of situations and even try some of them.

Said that the project was divided into 4 parts:

• Data pre-processing
• Detection
• False positives removal
• Tracking

The detailed report can be found in https://github.com/dbtdsilva/onroad-car-detection-tracking/blob/master/docs/onroad-vehicle-report.pdf.

The first phase, pre-processing, consisted into equalizing the histogram to intensify the contrast between frames.

The second and one of the most important, car detection, was done using Haar Cascades. This method required to obtain data that wanted to be detected and some false data in order to train the classifier.

The false positive removal was done in two steps:

• Cutting the detection in the horizontal and vertical. The vertical cut divided the car into the left and right side. Then we flipped on to the sides and it should have a similar correspondence since the cars are typically symmetrical when comparing their left side with the right one.
• Considering the average of the road color in the last N frames and applying segmentation with that color, it is possible to extract false positives that appear in the air, since the car should appear partially in the road (bottom part of the car).

The project can be found on Github: https://github.com/dbtdsilva/onroad-car-detection-tracking.

This work describes an agent that is able to play the game known as TORCS developed for Intelligent and Mobile Robotics at the University of Aveiro. The main objective of the robot is to control a race car in an unknown track. The agent will try to minimize the time that it takes to complete the race. It was considered that the agent always runs alone in the track.

This work covered several factors like gear selection, pressure on the accelerator or the brakes and direction of the steer. Besides that, it is also taken into account the path that the agent takes to minimize the time to complete the race. The main strategy to output the values according to the give environment input is based on Fuzzy Logic using a library known as fuzzylite. There are also other strategies that were applied in order to decide where the car should stay in the road or how it should unstuck when it happens (e.g., stuck agaisnt a wall).

The following image shows how the server handles several clients playing in the same race. Besides that, it also has an example of the car vision sensors (bottom right) and a picture of the actually gameplay (top right)

Feel free to check source code at https://github.com/dbtdsilva/robot-naga/tree/master/maze_pathfinder

This project consisted in developing an autonomous agent, which is a system that tries to understand the environment using sensors and acts according with it using actuators. In this case, after it senses the world, it will plan and only then actuate over the motors; it is a deliberative agent.

It is possible to check in more detail what was done for this project in this report.

This agent will have to find its way to the final target through a maze. This maze contains walls that might be vertical or horizontal. After the robot finds the final target, it must return to the initial position in the less possible time.

The following image shows one of the possible mazes:

Besides the description of the problem, the strategies adopted to fulfil every challenge are described. For example, when exploring the agent uses a flood fill algorithm to discover the next unexplored zone. After it finds the target area, it also checks if it has the best path to return. To discover if it has the best path, it compares the size of the path of an A* algorithm of explored and unexplored nodes to the size of a path of an A* algorithm with explored nodes only.

In the following image it is possible to verify that the agent is able to create a mapping and plans his next action. The orange path is the best path discovered and purple path might be a better path than the discovered one.

This agent is simulated using a specific platform and was never implemented in a non-simulated environment. The agent described is able to find its way to the target and it is also able to return to the initial position after finding the shortest path, without any collisions.

The following image shows the robot’s sensors and actuators, in this case, it has 3 obstacles sensors, compass, and motors.

Robot did not have any kind of encoders associated with the wheels or GPS, the project had to use a movement model that is associated with the motors.

Source code is available at: https://github.com/dbtdsilva/robot-naga/tree/master/line_follower

This project was developed an agent for a robot with the objective of following a black line, that robot runs using a PIC32 which runs with low resources.

Moreover, it consisted in developing an autonomous agent, which is a system that tries to understand the environment using sensors and acts according with it using actuators. This agent will have to follow a line and pass several challenges, such as, deal with tight curves, interrupted track, obstacles, etc.

The follow image shows an example of what the robot has to deal with.

It is possible to verify in more detail what was done for this project in this report.

This program was created in the University of Aveiro (UA) to promote academic and personal success of new students. Aiming to meet this purpose, the UA has working in this program since 2010, a Mentoring Program (in portuguese, Programa de Tutoria).

In this program there is 3 entities, the new students that have recently joined the university, older students (tutors) helping these new students with problems they might have and mentors that are in charge of supervising the tutors. This helps to create an easier and more relaxed interaction with the new students.

I have been working in 2016 as tutor, helping the newcomers.

Feel free to visit program homepage.

This project consists in creating a DRM (Digital rights management) that controls the user access in order to restrict the usage of copyrighted works. In this case, piracy of digital content. This project is made of two main components: the player and the server.

The server is in charge of controlling the user access to the protected files. The player requests and plays the files from the server.

In order for the user to have access to the titles he/she wants, we also have a web application where the user can buy the titles to play later. To reach the goal of this project, we also needed a database that helped manage the user and file related information.

Feel free to check the source code at https://github.com/dbtdsilva/security-iecds-drm

There is available a report which describes what was done for this project: https://github.com/dbtdsilva/security-iecds-drm/blob/master/Report60337_60340_Final.pdf

The following image shows an example of what the report contains. In this case, this represents a login diagram with a citizen card verifying a challenge signed with the private key that is stored in that card.

This project consisted in simulating a implementation of an ISP using GNS3.

Feel free to check router configurations at https://github.com/dbtdsilva/isp-network-sim_gns3

Thus it requires the implementation of more ISP than just one ISP to be able to simulate all mechanisms and understand them, like external BGP. Otherwise it would be impossible to test external BGP without connections for another ISP.

This project includes the implementations of several mechanisms:

1. Implementation of local VLANs for different types of access and some VLANs end-to-end for security cameras and;
2. External BGP;
3. Private AS;
4. Routing Constraints (such as, traffic routed over a specific ISP or configure the ISP as non-transit);
5. MPLS tunnel for SIP Traffic and VPNs;
6. VoIP SIP configurations (PSTN and forward calls).

In the following image it is possible to visualize 3 different ISP: ISP L, ISP S, ISP X (the one that the project were supposed to manage).

CiberRato is a competition that happens every year organized by the Universidade of Aveiro with the objective of simulating a real environment for robots.

This project consisted in a web platform used to make the competition CiberRato easier for both the organizer as well as the participants. Besides this, it is possible to create multiple online competitions with the same environment and conditions as the competition day, instead of it being only one day a year. It was developed by 6 members.

The objective was to support the user with the possibility of compete using the platform, it means that he will be have to upload or even edit his code on the platform and submit it for the competition.

This project was also used to support the CiberRato competition with several features like online competitions, hall of fame, real-time competitions.

Feel free to check more details about this project at https://github.com/CiberRato/pei2015-ciberrato.

Moreover, in the following link it is possible to check a flyer that was done for a presentation: https://docs.google.com/document/d/1JS-qkOIQVkcGy5ht-Fr35iwlrt76aRygxGtcqtX0eTM/edit?usp=sharing

All the project documentation was stored in Google Docs: https://drive.google.com/drive/u/0/folders/0B7UaldalQCUiWGVuVmh3RjFuWUk

This project consisted in simulating a implementation of a new topology configuration for a company in their building without destroying their old connectivity using GNS3.

The idea is pretty simple, the company has an older part of the building that the administrator does not want to be modified or touched (that area includes a datacenter and some clients). The other main task is to provide connectivity along the new part of the building, this new part includes 2 floors, DMZ Area and an area where the core of the network will be installed.

This project includes the implementations of several mechanisms:

1. Organize the network with the proper addressing (guaranteeing connectivity with the old network) and preventing single points of failure;
2. Proper switching and routing according with the situation, communication between VLANs should using switching instead of routing in some situation, that is the reason why inter-switches are useful;
3. Implementation of local VLANs for different types of access and some VLANs end-to-end for security cameras and;
4. QoS implementation for the VoIP conferences;
5. SNMP to monitor some attempts of IP Spoofing;
6. Implementation of SNAT (Stateful NAT, the network receives connectivity from two different ISP).

In the following image it is possible to visualize the schema previously described.

This project was created to show everything that we have learnt in a university class related with databases.

This was developed using Microsoft SQL Server and Visual Studio without any intermediate to access the database such a ORM. The professor did not want us to use any kinda of ORM because he wanted us to understand deeply how this kind of system works.

At first an idea had to be selected, in this case, it was decided to create an Event Manager which allowed the user to create several events, such as conferences. Each conference has several programs associated with it and their schedule. It also should allow to assign speakers and participants to these programs.

The following image shows the followed step, the design of the DER schema:

After that, a relational schema was obtained from the DER (converted using specific steps to keep the consistency). At last, the implementation of that schema using several SQL scripts. SQL Server Management Studio was used to access the database and create SQL scripts to manipulate it. Those scripts include tables creation and respective indexes to optimize specific searches, the most used ones.

The idea of this project was to understand how distributed system works.

Feel free to check the source code at github.com/dbtdsilva/distributed-systems-sim.

The project consisted in simulating the crafting of several products, those products would go for several phases, collect the prime materials, craft the product and sell the product. In this problem there is 3 different type of entities: craftsmanship (that creates the products and collects the prime materials); entrepreneur (sells products); customers (buy products).

The system was created and modified several times:

1. Simple multi-threaded system that could solve the problem without any deadlocks;
2. Modify the first solution to support a distributed system, implementing specific messages and communicate those messages using TCP sockets.
3. Modify the first solution again but to support a distributed system using remote method invocation instead of creating specific messages. This process was solved by using Java RMI (marshalling and unmarshalling), a vector clock was also implemented for the final system produce a log properly ordered.

“Hash Code is a team-based programming competition organized by Google for students and industry professionals across Europe, the Middle East and Africa.” - from hashcode.withgoogle.com/

I have participated in this competition in 2016 and it was pretty fun. This competition forces the members of the group to use a strategy divide-and-conquer to fulfil the challenge in time.

This project, SOFS, is a simple and limited file system based on Linux’s ext2 file system.

“In general terms, the introduction of a new file system into the operating system implies two well-defined tasks. The first consists of integration code associated with the implementation of the data type file in the kernel of the operative system and the second is the instantiation on one or more mass memory devices of the computational system.

FUSE (File system in User SpacE) is a very ingenious alternative solution that aims to build file systems in the user space, as if they were mere applications, preventing any inconsistencies and errors that arise in its implementation. This means that those errors will not be transmitted directly to the kernel and lead to its inoperability.

The infrastructure offered is made up of two main parts:

1. File system interface module - acts as the communications mediator between the uniform interface of file operations provided by the Kernel and its implementation in user space;
2. Implementation library - provides the communication data structures and the prototype of operations that have to be developed to ensure compatibility User-defined data type with the underlying model; It also provides a set of functionalities designed to instantiate the type of Data on a mass storage device and its integration into the operating system.”

The idea of this project was to understand how a filesystem works and can be modified/created.

Several tasks were implemented in SOFS, such as, allocate/free i-nodes, read/write/clean i-nodes, write/read clusters, perform operations on those clusters, manipulate directory entries.

Besides the low level definition of the filesystem, it had been implemented some syscalls for the user to manipulate the system.

The concept of this project is pretty simple. The idea is to create a game based on the raw functions of OpenGL. I have decided to pick Chess because I enjoy to play it with some friends.

Feel free to check this project at https://github.com/dbtdsilva/chess-opengl

With this project it was possible to understand computer vision works, how it represents bigger models, light scenes, environments, etc.

This project implements models that represent the Chess pieces and the board (also the possible moves). There is also a conversion of the mouse click to the world, lights implementation on the board to create a more realistic scenario.

The following image shows the final result of this project.

Moreover, a skybox was also implemented instead of having a static color to represent the sky. It is possible to verify that in the following image, the player is unable to zoom out from the skybox, otherwise he would notice that the world is represented inside a big cube.

“The MicroRato Competition is open to all those who wish to compete and, in particular, to the students of the terminal years and post-graduate courses in Electronic Engineering and similar. The number and type of disciplines involved in building a MicroRato robot make the technical challenge appealing and educational to any enthusiast in electronics and computers.

Knowledge is needed from digital and analog electronics, microprocessors (software and hardware), power electronics, control, etc. These characteristics make the competition particularly attractive and motivating for most young people and in particular for students of Areas.

The teams consisting mainly of students enrolled in the courses under the responsibility of the Electronics and Telecommunications Department of the University of Aveiro may apply for the use of a robotic kit with sensors and actuators compatible with the proposed challenge.” - MicroRato webpage

I have participated in this competition in 2014 and I got to admit, it is a great challenge. My teammates and I have learnt a lot while working for the robot, it requires knowledge in several different areas.

Feel free to visit the homepage of the competition at http://microrato.ua.pt/

This figure shows the robot used and a small portion of the maze.

“IEEEXtreme is a global challenge in which teams of IEEE Student members—advised and proctored by an IEEE member, and often supported by an IEEE Student Branch—compete in a 24-hour time span against each other to solve a set of programming problems.” - from http://www.ieee.org/xtreme

It is a 24-hour competition that involves a lot of knowledge. This competition brings maths and programming completely together, most of the challenges that appear during these 24 hours are required to be efficient, otherwise they will not pass all the tests. In my opinion, this is one of the best characteristics in the competition.

I have been participating on it since 2013 and I do not regret once.

“Bison and Flex” project consists into using Bison and Flex to convert from a robot maze described in JSON to URDF files that could be played in a 3D Viewer in order to visualize the maze and the robots on the map 3D.

This project was created because there is a simulator implemented in 2D that outputs those kinds of details about the maze, but the objective is to be possible to represent in 3 dimensions.

The following image contains an example of what is possible to describe in the JSON. Such as, walls with thickness, target areas, beacons, overlapping was taken into account, robot’s pose, maze dimensions and even challenge parameters.

The following example was the input received by converter for the previous image (output):

{
    "challenge name" : "Final, 2005",
    "challenge type" : "competitive",
    "cycle time" : 50,
    "duration" : 2400,
    "scenario description" : {
        "name" : "TOS challenge",
        "dimensions" : [28, 14],
        "beacons" : [
            { "position" : [14, 7], "radius" : 1, "height" : 2 },
            { "position" : [3.5, 6.5], "radius" : 1, "height" : 4 },
            { "position" : [24, 1] }
        ],
        "target areas" : [
            { "position" : [14, 7], "radius" : 1},
            { "position" : [9, 5], "radius" : 1}
        ],
        "models" : [
            { "id": 1, "height" : 1, "corner list" : [ [0, 0], [0, 5], [5, 5] ] },
            { "id": 2, "use model": 1, "translation": [5, 5] },
            { "id": 3, "height" : 1, "corner list" : [ [5, 5], [10, 5], [5, 10], [10, 10] ], "thickness" : 1 },
            { "id": 4, "height" : 1, "corner list" : [ [5, 5], [10, 5], [15, 5]], "thickness" : 1 }
        ],
        "walls" : [
            { "use model": 1, "height": 2, "translation": [15, 5], "rotate": 90 },
            { "use model": 3, "rotate": 45 },
            { "height" : 2, "corner list" : [ [15, 7] ], "thickness" : 1 },
            { "use model": 4 },
            { "corner list" : [ [24, 9], [24, 7], [28, 7] ], "thickness" : 1 },
            { "corner list" : [ [24, 13], [28, 13], [22, 11] ], "thickness" : 0.5 }
        ],         
        "grid" : [ 
            [2, 12.5, -15],
            [2, 12.5, -15], 
            [1.75, 1.5, 15], 
            [26.25, 12.5, 90],
            [24.25, 12.5, 180],
            [22.25, 12.5, 270]
        ]
    },
    "robot modelling parameters" : {  
        "motors noise" : 1.5,
        "beacon sensor noise": 2,
        "beacon sensor aperture" : "PI",
        "requests per cycle" : 10
    },
    "scoring parameters" : {
        "robot-robot collision penalty" : 1,
        "robot-wall collision penalty" : 1,
        "key time" : 1800,
        "arrival time penalty" : 100,
        "home reward" : 100,
        "return time penalty" : 2000,
        "target reward" : 100
    },
    "debugging parameters" : {
    }
}

Description

This was one of the last projects that I have participated while I was in the electronics course, the group was composed of 7 elements.

We were required to address a particular problem which consisted of developing a temperature controller for domestic devices. This particular device would turn the device on or off according to room temperature and should function for both domestic heaters and coolers.

This device would have another functionality, common to this type of product, which would allow it to also turn on or off based on a chosen time set by the user.

It was necessary that the device be easy to carry and to work with since it’s destined for a domestic user with poor knowledge of electronic appliances. Considering it’s destined for commercialization, maintaining a competitive price is instrumental.

Approaches taken to the solution

During an early stage of the project we did some market research to determine which devices that already exist in the market are able to solve our problem and identified their main features. Based on this research, we established the main goals of our project: to design a small device (≈0.1x0.05x0.05m), plug-in, with temperature, time and random control and low-priced (under 40€) in order to gain some competitiveness in the national market. We also considered the possibility of exporting the product.

The development of the solution was implemented progressively, with two initial prototypes being developed before the final product. The first prototype was based on and Arduino development board and the second on PCB-THT with PDIP components.

The following image represents the second solution that was implemented in a breadboard. At first it had an Arduino but it has unnecessary costs because we could only use the Atmega328p which is a lot cheaper.

The final product was implemented on PCB-SMT with SMD components. Due to lack of time the final solution was only designed and not implemented as you can see in the following image.

We performed a techno-economic analysis of the product and its market implementation and concluded that we were able to meet all proposed goals and that the project is technologically and economically viable.

Campus4US is an event that happens once a year at the University of Aveiro. This event has the objective of showing the university to the newcomers, such as, places to eat or to study. At the start of the day, it is created several groups of newcomers (randomly selected) where they have the opportunity to know each other. During the day they will explore the university that they just joined with the group.

I have participated in 2011, since then I haven’t participated again, but it is worth to try at least once. It is always great to help with the integration of the students in the university.

There is a page with a small description of this program at http://www.ua.pt/ensino/page/21562. Sadly it is only available in portuguese.

Brief Description

Source code is available at: https://github.com/dbtdsilva/tetris-kinect

This project was created to show a possible use for a Kinect (in this case, we have used the first version).

To represent a possible use for the Kinect, we have decided to pick up a game that could be played using only one hand. Tetris includes only 4 different movements.

Movements simulated with the Kinect

The screen where the player plays is divided in 6 areas. These areas allow the player to choose the direction in which he wants the piece to go, or just move fast downwards with the hand and the piece will instantly drop to the bottom of the board. The possibility to pause wasn’t left behind, so the top right area it includes the possibility to pause the game by pushing towards the Kinect with the hand.

The possible movements are moving right or left, moving down, instantly put the piece to the bottom and rotate in the respective areas when needed.

Additional features

This tetris version was implemented as a “Time-Attack” style, which means that the player as a fixed time of 2 minutes to make the maximum score.

It also includes an high score board which was used to create some competition.

Programming language used: C#

This is a national event, as the name says, national competitions of science. This event occurs once in a year during 3 days.

This event includes 12 competitions in several areas, such as, maths, biology, physics, chemistry, portuguese, etc.

Those competitions targets students that are in the elementary or high school.

I have been helping those students to manage with technical problems found during the competitions.

Feel free to visit CNC Homepage.