Coding Challenge - Ultimate LabVIEW Zone Coding Challenge

Challenge Description:

Ultimate LabVIEW Zone Coding Challenge

Beginner Challenge

Advanced Challenges

• VCR-Plus + and an advanced Disc navigator to simplify the recording process
• 10-bit/54MHz Video Digital to Analog converter
• PureCinema progressive scan output
• Integrated TV Tuner and Programming modes, in addition to VCR Plus
• On-screen menu shows thumbnails of each section of video to help locate the correct scene to play back
• Records on DVD-R discs
• Plays DVD, DVD-R, DVD-RW, CD media

LabVIEW Financial Planner Description

There are many websites publicly available which publish stock financial data. You select which website to utilize and the way in which you will retrieve financial information from it. However, the information you provide to the user must include at least:

• Last Trade
• Trade Time
• Current Day's Change
• P/E (ttm)
• Trailing P/E (ttm, intraday)
• Forward P/E (dates may vary)
• EPS (ttm)
• 52 week Range

Judging: First and foremost, your submission will be judged on usability. Is it user-friendly and intuitive to use? Does it behave as expected? Is the financial data presented in an understandable format? Secondly, it will also be judged on the speed with which your VI retrieves information from the web. Next, as you are free to add more statistics to your report, your submission will be judged on how much relevant material is provided to the user. Finally, all VIs will be judged on coding style according to the LabVIEW Development Guidelines

LabVIEW MP3 Player

In terms of functionality, your VI must offer a way for users to select which MP3 on their computer they wish to play. Once they have selected a song, your application should play that file through the computer and allow the users to pause, stop, rewind, and fast forward the song. After that, let your creative side do the work. Look to current media applications for inspiration: Windows Media Player, WINAMP, MusicMatch, iTunes, etc. These applications provide a hose of interactive features to improve the listening experience.

In this challenge, unlike all of the others, you are allowed to call external code (DLLs, exe, etc). This allows you to utilize the technology in other media software and focus most of your time on the user interface.

Judging: Your MP3 Player must obviously successfully play MP3 files. To narrow down the entries, we will first select three submissions that meet the above criteria, make efficient use of your computer resources (memory consumption, processor usage, etc), and adhere to the LabVIEW Development Guidelines. A panel of judges will select the winner from these three finalists. They will select the winner based upon quality of the user interface and coding style of the application.

 LabVIEW Bioinformatics Analysis Challenge

The sites listed below publish online databases. You must build a VI which acquires and stores, on your local machine, the data from these websites. Some of this may require CGI scripting. If you already have installed the LabVIEW Internet Toolkit, you are free to use the CGI VIs available in that toolkit. However, you will probably still need to develop more functionality on top of those for this particular application.

Yeast Data Retrieval

1. From the Stanford Microarray Database (SMD), retrieve yeast cell cycle time course expression data that was measured with Stanford spotted arrays by Spellman et al.
2. From the Gene Expression Omnibus (GEO), retrieve yeast Ume6 regulon expression data measured with Affymetrix arrays by Williams et al.
3. From the Rick Young's Lab at MIT, retrieve a tab-delimited text file of transcription factor DNA-binding data for transcription factors involved in mitosis and meiosis measured with Young Lab spotted arrays by Harbison et al.

Human Data Acquisition

1. From the Stanford Microarray Database (SMD), retrieve human cell cycle time course expression data measured with Stanford spotted arrays by Whitfield et al.
2. From the Stanford Microarray Database (SMD), create a tab-delimited text file with annotations of cell cycle-regulated human genes.
3. From the Stanford Microarray Database (SMD), retrieve human UV radiation expression data measured with Stanford spotted arrays by Murray et al.
4. From the Gene Expression Omnibus (GEO), retrieve human fibroblast DNA damage and UV radiation expression data measured with Affymetrix arrays by Gentile et al.

Your VI must retrieve all of this data and write it each table to a separate tab-delimited ASCII file which is determined by the user at run-time.

Judging: For any submission to be considered, it must correctly return all the data as described above. Once this is insured, we will measure how long each submission takes to retrieve and store all of this data (large amount of data). In the event of a tie, we will also take into account the amount of memory used. Whichever submission uses the least amount of memory and completes the data retrieval the quickest will win. As an additional test, we will judge how well the code conforms to the LabVIEW Development Guidelines.

LabVIEW Channel Coding Challenge

There are different ways to provide FEC. In the digital telecommunications world, channel coding is one commonly utilized technique. It is a pre-transmission process applied to a digital signal or data file intended to provide error-correcting in data transmission. The general concept is that you add bits of data (parity bits) to a data stream before it is transmitted to the receiver. These parity bits enable the receiver to determine if any of the data has been corrupted once it arrives. Learn more about the history of error-correction here. There are numerous different types of channel codes, each providing certain benefits such as speed, level of data integrity, etc. For this Coding Challenge, your goal is to develop a channel coding algorithm in LabVIEW to encode and decode digital transmissions.

You may implement any type of channel coding you wish, using one (or more) of the well-known FEC codes or implementing something entirely new.

You can find descriptions of many channel codes on the internet. While you are free to implement any of these, keep in mind that some are more efficient than others, and some are easier to build then others. Once you select the channel code you wish to use, you will create two VIs:

1. The Encoder: Your first VI will receive one input, an array of I8 values containing 1's and 0's that represent bits. It will encode this data using FEC and then output the corresponding data as an array of I8 values containing 1's and 0's that represent bits.
2. The Decoder: Your second VI will also receive an array of I8 values (containing 1's and 0's that represent bits) as input and have an array of I8 values containing 1's and 0's that represent bits. However, in this case, it must decode the data. This will determine if there were any errors in the received data. You may not use VIs from the Encode / Decode palettes of the Modulation Toolkit Ver 3.0 for this challenge.

Judging: To judge your submission, we will perform several tests:

Test 1: Verify functionality without noise

• Use your encoder to encode a message data set (a pseudo random bit stream-PRBS)
• Use your decoder to attempt to decode the encoded data set
• Verify that the decoded data set matches the message data set

Test 2: Verify functionality with noise

• Use your encoder to encode a message data set (a pseudo random bit stream-PRBS)
• Simulate the effect of channel noise by flipping some of the bits in your encoded data.
• Use your decoder to attempt to decode the degraded, encoded data set
• Measure the bit error rate of the decoded data set

We'll run Test 2 several times using different levels of noise (numbers of bits flipped) to gauge the performance (error correcting capacity) of your code.

Submissions will also be judged based on code efficiency (best use of memory, most optimal LabVIEW code (in terms of memory usage/speed), and how well the code adhered to and adhere to the LabVIEW Development Guidelines.

 LabVIEW Wavelet-based Denoising Challenge

For this challenge, we will provide a waveform, represented by a 1D array of DBL numeric values, which has had non-stationary noise introduced into it. Your task is to develop a signal processing algorithm that will input this noisy signal and output a denoised signal that closely approximates the original signal.

The tools from the Wavelet component of the Advanced Signal Processing Toolkit can prove especially useful for this challenge.

To participate in this challenge, download this VI. This VI contains the signals we will test the submissions with. You can select which signal to read and then your VI should perform wavelets based denoising on that signal. However, your final submission should work with as many of the signals as possible.

Judging: To judge the submission, we will run your application with all of the signals in the attached VI. For each signal, we will use least square fitting to determine which submission best approximates the original signal. The submission that performs efficient denoising on the greatest number of these signals will win. We will also take into account:

• Speed - Time required for your VI to complete the analysis.
• Memory - How little memory is required for your VI to run.
• Programming Style - How readable / clean / well commented your front panels and block diagrams appear. We will judge this according to the LabVIEW Development Guidelines

Additional Rules for All Challenges

1. All coding must be done in LabVIEW.
2. No external code, DLLs, CINs, exes, etc (Except for LabVIEW MP3 Player which may call external audio applications)
3. Have fun!

Good luck, wireworkers!

Discuss this challenge on the Discussion Forums

Submission Deadline: Friday, August 5, 2005

  Discussion

 Other Info