neingeist/arduinisten
Archived
1
0
Fork 0
Code Releases Activity

arduino-0017-linux-x64

Browse source
This commit is contained in:
Eve Entropia 2010-03-30 20:10:36 +02:00
parent ed785c5798
commit ddf58ffb08
436 changed files with 62981 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

229
arduino-0017-linux-x64/hardware/libraries/Matrix/Matrix.cpp Executable file
View file

@ -0,0 +1,229 @@
/*
Matrix.cpp - Max7219 LED Matrix library for Arduino & Wiring
Copyright (c) 2006 Nicholas Zambetti. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
// TODO: Support segment displays in api?
// TODO: Support varying vendor layouts?
/******************************************************************************
* Includes
******************************************************************************/
extern "C" {
// AVR LibC Includes
#include <inttypes.h>
#include <stdlib.h>
// Wiring Core Includes
#undef abs
#include "WConstants.h"
// Wiring Core Prototypes
//void pinMode(uint8_t, uint8_t);
//void digitalWrite(int, uint8_t);
}
#include "Sprite.h"
#include "Matrix.h"
/******************************************************************************
* Definitions
******************************************************************************/
// Matrix registers
#define REG_NOOP 0x00
#define REG_DIGIT0 0x01
#define REG_DIGIT1 0x02
#define REG_DIGIT2 0x03
#define REG_DIGIT3 0x04
#define REG_DIGIT4 0x05
#define REG_DIGIT5 0x06
#define REG_DIGIT6 0x07
#define REG_DIGIT7 0x08
#define REG_DECODEMODE 0x09
#define REG_INTENSITY 0x0A
#define REG_SCANLIMIT 0x0B
#define REG_SHUTDOWN 0x0C
#define REG_DISPLAYTEST 0x0F
/******************************************************************************
* Constructors
******************************************************************************/
Matrix::Matrix(uint8_t data, uint8_t clock, uint8_t load, uint8_t screens /* = 1 */)
{
// record pins for sw spi
_pinData = data;
_pinClock = clock;
_pinLoad = load;
// set ddr for sw spi pins
pinMode(_pinClock, OUTPUT);
pinMode(_pinData, OUTPUT);
pinMode(_pinLoad, OUTPUT);
// allocate screenbuffers
_screens = screens;
_buffer = (uint8_t*)calloc(_screens, 64);
_maximumX = (_screens * 8);
// initialize registers
clear(); // clear display
setScanLimit(0x07); // use all rows/digits
setBrightness(0x0F); // maximum brightness
setRegister(REG_SHUTDOWN, 0x01); // normal operation
setRegister(REG_DECODEMODE, 0x00); // pixels not integers
setRegister(REG_DISPLAYTEST, 0x00); // not in test mode
}
/******************************************************************************
* MAX7219 SPI
******************************************************************************/
// sends a single byte by sw spi (no latching)
void Matrix::putByte(uint8_t data)
{
uint8_t i = 8;
uint8_t mask;
while(i > 0) {
mask = 0x01 << (i - 1); // get bitmask
digitalWrite(_pinClock, LOW); // tick
if (data & mask){ // choose bit
digitalWrite(_pinData, HIGH); // set 1
}else{
digitalWrite(_pinData, LOW); // set 0
}
digitalWrite(_pinClock, HIGH); // tock
--i; // move to lesser bit
}
}
// sets register to a byte value for all screens
void Matrix::setRegister(uint8_t reg, uint8_t data)
{
digitalWrite(_pinLoad, LOW); // begin
for(uint8_t i = 0; i < _screens; ++i){
putByte(reg); // specify register
putByte(data); // send data
}
digitalWrite(_pinLoad, HIGH); // latch in data
digitalWrite(_pinLoad, LOW); // end
}
// syncs row of display with buffer
void Matrix::syncRow(uint8_t row)
{
if (!_buffer) return;
// uint8_t's can't be negative, so don't test for negative row
if (row >= 8) return;
digitalWrite(_pinLoad, LOW); // begin
for(uint8_t i = 0; i < _screens; ++i){
putByte(8 - row); // specify register
putByte(_buffer[row + (8 * i)]); // send data
}
digitalWrite(_pinLoad, HIGH); // latch in data
digitalWrite(_pinLoad, LOW); // end
}
/******************************************************************************
* MAX7219 Configuration
******************************************************************************/
// sets how many digits are displayed
void Matrix::setScanLimit(uint8_t value)
{
setRegister(REG_SCANLIMIT, value & 0x07);
}
// sets brightness of the display
void Matrix::setBrightness(uint8_t value)
{
setRegister(REG_INTENSITY, value & 0x0F);
}
/******************************************************************************
* Helper Functions
******************************************************************************/
void Matrix::buffer(uint8_t x, uint8_t y, uint8_t value)
{
if (!_buffer) return;
// uint8_t's can't be negative, so don't test for negative x and y.
if (x >= _maximumX || y >= 8) return;
uint8_t offset = x; // record x
x %= 8; // make x relative to a single matrix
offset -= x; // calculate buffer offset
// wrap shift relative x for nexus module layout
if (x == 0){
x = 8;
}
--x;
// record value in buffer
if(value){
_buffer[y + offset] |= 0x01 << x;
}else{
_buffer[y + offset] &= ~(0x01 << x);
}
}
/******************************************************************************
* User API
******************************************************************************/
// buffers and writes to screen
void Matrix::write(uint8_t x, uint8_t y, uint8_t value)
{
buffer(x, y, value);
// update affected row
syncRow(y);
}
void Matrix::write(uint8_t x, uint8_t y, Sprite sprite)
{
for (uint8_t i = 0; i < sprite.height(); i++){
for (uint8_t j = 0; j < sprite.width(); j++)
buffer(x + j, y + i, sprite.read(j, i));
syncRow(y + i);
}
}
// clears screens and buffers
void Matrix::clear(void)
{
if (!_buffer) return;
// clear buffer
for(uint8_t i = 0; i < 8; ++i){
for(uint8_t j = 0; j < _screens; ++j){
_buffer[i + (8 * j)] = 0x00;
}
}
// clear registers
for(uint8_t i = 0; i < 8; ++i){
syncRow(i);
}
}

54
arduino-0017-linux-x64/hardware/libraries/Matrix/Matrix.h Executable file
View file

@ -0,0 +1,54 @@
/*
Matrix.h - Max7219 LED Matrix library for Arduino & Wiring
Copyright (c) 2006 Nicholas Zambetti. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef Matrix_h
#define Matrix_h
#include <inttypes.h>
class Sprite;
class Matrix
{
private:
uint8_t _pinData;
uint8_t _pinClock;
uint8_t _pinLoad;
uint8_t* _buffer;
uint8_t _screens;
uint8_t _maximumX;
void putByte(uint8_t);
void setRegister(uint8_t, uint8_t);
void syncRow(uint8_t);
void setScanLimit(uint8_t);
void buffer(uint8_t, uint8_t, uint8_t);
public:
Matrix(uint8_t, uint8_t, uint8_t, uint8_t = 1);
void setBrightness(uint8_t);
void write(uint8_t, uint8_t, uint8_t);
void write(uint8_t, uint8_t, Sprite);
void clear(void);
};
#endif

42
arduino-0017-linux-x64/hardware/libraries/Matrix/examples/hello_matrix/hello_matrix.pde Normal file
View file

@ -0,0 +1,42 @@
#include <Sprite.h>
#include <Matrix.h>
// Hello Matrix
// by Nicholas Zambetti <http://www.zambetti.com>
// Demonstrates the use of the Matrix library
// For MAX7219 LED Matrix Controllers
// Blinks welcoming face on screen
// Created 13 February 2006
/* create a new Matrix instance
pin 0: data (din)
pin 1: load (load)
pin 2: clock (clk)
*/
Matrix myMatrix = Matrix(0, 2, 1);
void setup()
{
}
void loop()
{
myMatrix.clear(); // clear display
delay(1000);
// turn some pixels on
myMatrix.write(1, 5, HIGH);
myMatrix.write(2, 2, HIGH);
myMatrix.write(2, 6, HIGH);
myMatrix.write(3, 6, HIGH);
myMatrix.write(4, 6, HIGH);
myMatrix.write(5, 2, HIGH);
myMatrix.write(5, 6, HIGH);
myMatrix.write(6, 5, HIGH);
delay(1000);
}

48
arduino-0017-linux-x64/hardware/libraries/Matrix/examples/sprite_animation/sprite_animation.pde Normal file
View file

@ -0,0 +1,48 @@
#include <Sprite.h>
#include <Matrix.h>
// Sprite Animation
// by Nicholas Zambetti <http://www.zambetti.com>
// Demonstrates the use of the Matrix & Sprite libraries
// Displays animated waveform graphic on screen
// Created 29 March 2006
/* create a new Matrix instance
pin 0: data (din)
pin 1: load (load)
pin 2: clock (clk)
*/
Matrix myMatrix = Matrix(0, 2, 1);
/* create a new Sprite instance
8 pixels wide, 4 pixels tall
*/
Sprite wave = Sprite(
8, 4,
B00011000,
B00100100,
B01000010,
B10000001
);
void setup()
{
}
int x = 0;
void loop()
{
myMatrix.write(x, 2, wave); // place sprite on screen
myMatrix.write(x - 8, 2, wave); // place sprite again, elsewhere on screen
delay(75); // wait a little bit
myMatrix.clear(); // clear the screen for next animation frame
if(x == 8) // if reached end of animation sequence
{
x = 0; // start from beginning
}
x++; // advance x coordinate to the right
}

22
arduino-0017-linux-x64/hardware/libraries/Matrix/keywords.txt Normal file
View file

@ -0,0 +1,22 @@
#######################################
# Syntax Coloring Map For Matrix
#######################################
#######################################
# Datatypes (KEYWORD1)
#######################################
Matrix KEYWORD1
#######################################
# Methods and Functions (KEYWORD2)
#######################################
setBrightness KEYWORD2
write KEYWORD2
clear KEYWORD2
#######################################
# Constants (LITERAL1)
#######################################