Mailing List

We now have a mailing list that is through http://www.freelists.org. The Freelists service does not required any special account, just an email address. Also, Freelists maintains a searchable web archive of the mailing list, that archives attachments, so this can be a nice way for people to share code.

The main page for the mailing list is: http://www.freelists.org/list/panels The archive is located here: http://www.freelists.org/archives/panels/

Please sign up for the mailing list by sending email to panels-request@freelists.org with 'subscribe' in the Subject field OR by using the web interface (http://www.freelists.org/list/panels).

Users can unsubscribe from the list by sending email to panels-request@freelists.org with 'unsubscribe' in the Subject field OR by logging into the web interface. To post to the list, simply send email to panels@freelists.org.

System Overview

The system has been designed to allow for rapid development of behavioral (visual) stimuli. Here are some pictures. There are three components to the system:

• The panels - the actual display. These are 8x8 dot matrix displays of LEDs with some electronics to drive the display.
• The controller - a custom designed microprocessor circuit that communicates with a PC via the serial port and to the panels using a rapid serial interface (TWI). Note that TWI is Atmel's name for their own implementation of the I2C bus, a standard developed by Phillips.
• PC software - written in Matlab, there are tools for generating patterns and sending commands to the controller.

In all the documentation that follows, we will try to use this terminology consistently:

• The system - refers to all of the components: controllers, panels, etc.
• Setup - refers to your particular configuration. This is mostly used in the context of the particular way in which you have the panels connected to the controller.
• The Controller - refers to the controller circuit board that is described in Section controller. This can be somewhat confusing, because the panels and controller boards both have microcontrollers on them, which both act as controllers. Furthermore, the Matlab program is also controlling the controller. However, the controller will always refer to the controller circuit.
• A Panel - refers to the module that is composed of both the circuit board and the LED display.
• PControl - is the name of the Matlab gui.

Installation and Prerequisites

There are some basic tools needed to use the system:

• A PC running a recent version of Windows. The PC must have at least 1 serial port, although 2 (or even 3) would be useful. To easily add serial ports to your computer, consider a USB to Serial converter. Here are some.
• Matlab on above PC - the code used to work on all Matlab releases, but is currently only tested and supported on release 14 (Service Pack 1 or 2).
• A Programming device for the Atmel microcontrollers. Either the AVR ISP or the AVR STK500. The AVR ISP (Digikey p/n ATAVRISP-ND) is a stand alone programmer - it connects to a PC with the serial port on one end, and has the 6 pin programming interface which is used to program the controller and the panels. The AVR STK500 (Digikey p/n ATSTK500-ND) has the programming interface, but is also a starter kit and development system for Atmel microcontrollers. There is also an Atmel USB programmer that should work, but we have not tested this.
• AVR studio or other set of AVR tools - this is useful if you plan to make any modifications to the software running on either the controller or the panels. The AVR studio has a nice GUI for programming Atmel microcontrollers through either the AVR ISP or AVR STK500. More information at www.atmel.com and www.avrfreaks.net.
• Power supplies - see section Controller Hardware for details.
• Compact Flash (CF) card and reader. Any USB-based CF (or multi-format) reader will work. Even large patterns only require space measured in kilobytes, so any available CF card will be large enough, but it is advisable to get a high speed card. The fastest card we measured was a 128 MB Dane-Elec 45X card. Note: currently the system seems not to work with cards that are larger than 128 MB. This is certainly a solvable problem, but buying 128 MB cards is the best option currently.
• Many experiments can be made simpler by generating signals from Matlab that can be used to encode some information about the current trial (this signal is then acquired along with any other experimental data). An inexpensive and reliable product for doing this is one of the USB DAQ modules from Measurement Computing. We have been using the USB-1208LS (specs and pin out), which has 2 analog out signals and is supported by the Matlab DAQ toolbox.

Download Code & PCB files

All code is maintained by MR. The code is distributed “as is”; it works for me and I hope it works for you. Michael Reiser, the Dickinson Lab, and Caltech are not liable for any damage caused by using (or misusing) this code. Remember, programming microcontrollers is not as safe as PC programming, extreme caution must be taken to ensure that all connections are correct, and that the circuit boards are functioning – if anything smells like it is burning or gets hot – turn off immediately and recheck everything.

• Panel Files Release 2
• The older version is still available: Panel Files

There are many changes that are included in the second release:

• New control modes, numeric position control. This uses the function generator to numerically specify the current position. Implemented as a (signed) offset to the position specified by Panel_com(‘set_position’, [X,Y]).
• System can now support much larger patterns – previously a frame was limited to one block of the CF memory – 512 bytes. Now multi-block frames are supported. Tested with 48 panel gscale patterns (1152 bytes per frame).
• CF reading is slightly faster, no longer reads entire block, but stops once the number of bytes in the frame have been read.
• Row compression: for patterns that consist of identical data for all rows of the pattern. RC is enabled by setting pattern.row_compression = 1; in the pattern-making script. An RC pattern will just consist of one row instead of 8, resulting is a speedup factor of at least 5. This feature required modification to the code on the main and CF controllers, the panel code, and a few of the MATLAB pattern making and displaying routines.
• Identity compression: For patterns that contain large swaths of pixels that are simply on or off. The controller can check to see if this is the case, and then just send the row-compressed version of the panel data for a panel that corresponds to a pattern piece that is all one value (works for grayscale too!). This feature is not used at pattern making time, but rather while the pattern is running. Identity compression can be enabled by invoking: Panel_com('ident_compress_on') from MATLAB.
• New (simpler) serial port interface from Matlab. Fixes previous problem sending certain values (byte values above 127) over the serial port.
• Two new digital outputs: pulse to trigger a laser depending on pattern position, and an adjustable clock signal to trigger a camera. These are supported by commands in the panel_com function.
• Most of the C code (controller programs and the G3 panel code) is now compatible with newest version of GCC compiler. This required including a legacy.h file.
• Now releasing code for 3 generations of panels. The code in the previous release is now considered G2 code. G3 code is only slightly modified from G2 to support a new chip – the Atmega168 (slightly faster, bigger flash), using the same panel PCB. G1 code is included for the convenience of Dickinson Lab members who are still using the original design. All controller code is compatible with all 3 generations of panels.
• The distribution includes PCB files for a 12 panel ring, the typical configuration of a flight arena.

All files are being distributed in a single .zip file. This file contains 3 folders:

• c code - code for the panels and the controller board. Each subfolder also contains the .hex file needed to program the individual microcontrollers. If no modification will be made to the c code, then the compiled .hex files are sufficient to build the system. To edit and compile the AVR c code, you will need to install a GCC compiler for the Atmel AVRs. We recommend the WinAVR package, but there are others out there. Some of the modules used in the AVR c code, are taken from the Procyon AVRlib package written by Pascal Stang. The code from the AVRlib is included in the distributed .zip file above, so you will not need to download this package, but you are encouraged to do so if you plan to do any serious Atmel programming.
• schematics –schematic and PCB files for the panels and the controller. These files were created in Protel 99 SE. Each folder also contains a subfolder with all of the CAD files that are needed to order the PCBs.
• Matlab panels code – contains a folder called MatlabRoot that contains a series of subfolders. To set this up on a new system, the folder should be copied to the C:\ drive (you want the subfolders to reside under c:\matlabroot). It is important to add these new folders and all subfolders to the Matlab path. There is a file called panel_control_paths.m that should be updated with the appropriate paths for the specified files, so that the installation will function on your PC. You will also need to the file dd.exe, but this is included in the folder of other files. This file is necessary to burn images onto the CompactFlash cards (from Windows). In MatlabRoot\Panels\IO_tools\ there is a file called get_CF_drive.m, this file contains a hard-coded drive letter for the CF drive - you should update this letter to reflect your system.

Panels

The panels are the display devices in the system. They are individually addressed and communicated with over the TWI bus. Each panel runs a small program which receives updated pattern information and refreshes the display.

Controller

The Controller reads in pattern data from the CF card memory, accepts commands from the PC control program, and sends pattern data to the panels over the TWI bus.

To-dos & Wish List

As presented the system is fully functional and has been in regular use for more than a two years. However, there are many features that will improve the system. Here is a list of suggested projects. Some of these will be completed by MBR (many will certainly not be), but if anyone is interested in tackling these or suggesting other projects, please send email to the ‘mailing list`_.

• programming of the panels from the Matlab GUI, maybe even address them during programming. This would be done using the command line interface to the AVR Studio, or similar.
• A small box that converts ±5 V to two distinct 0-5 V lines, mapping positive voltage to one and negative to the other. This would really simplify using certain signals with controller. Ideally, put 2 of these in one box (will need independent power).
• program panels when they are plugged in, so they don’t need to be programmed independently. Apparently this is possible, especially since the panels are set up to communicate with the TWI interface. Look at Boot Loader Support section in the AVR documentation.
• re-mapable greenscales – the idea here is to be able to use binary, 2 level, patters and then be able to arbitrarily map the 0 and 1 values to any of the 8 greenscale levels. This scheme has basically been worked out (is in the distributed panels code, but commented out). This system needs to be tested, etc.
• more efficient CF reading – that would start moving the bytes from the FIFO before the pattern is completely dumped – this should provide at least 10% faster frame rates.
• more user-friendly installation that checks the CF card location, makes a temp folder if necessary, etc.
• Some buttons on the PControl gui for quickly linking to experiment scripts.
• Move storage of internal function generator functions onto the CF card, maybe increase the temporal resolution (100 Hz seems reasonable), and allow the function buffer length to vary.

Parts Lists

Prices given are approximate, are for 1 item of each, and apply to small quantity orders.