Problem with comparison.
/Designs/Spectrograph/SW/libraries/OneWire/OneWire.cpp |
---|
0,0 → 1,527 |
/* |
Copyright (c) 2007, Jim Studt (original old version - many contributors since) |
The latest version of this library may be found at: |
http://www.pjrc.com/teensy/td_libs_OneWire.html |
Version 2.1: |
Arduino 1.0 compatibility, Paul Stoffregen |
Improve temperature example, Paul Stoffregen |
DS250x_PROM example, Guillermo Lovato |
PIC32 (chipKit) compatibility, Jason Dangel, dangel.jason AT gmail.com |
Improvements from Glenn Trewitt: |
- crc16() now works |
- check_crc16() does all of calculation/checking work. |
- Added read_bytes() and write_bytes(), to reduce tedious loops. |
- Added ds2408 example. |
Delete very old, out-of-date readme file (info is here) |
Version 2.0: Modifications by Paul Stoffregen, January 2010: |
http://www.pjrc.com/teensy/td_libs_OneWire.html |
Search fix from Robin James |
http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1238032295/27#27 |
Use direct optimized I/O in all cases |
Disable interrupts during timing critical sections |
(this solves many random communication errors) |
Disable interrupts during read-modify-write I/O |
Reduce RAM consumption by eliminating unnecessary |
variables and trimming many to 8 bits |
Optimize both crc8 - table version moved to flash |
Modified to work with larger numbers of devices - avoids loop. |
Tested in Arduino 11 alpha with 12 sensors. |
26 Sept 2008 -- Robin James |
http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1238032295/27#27 |
Updated to work with arduino-0008 and to include skip() as of |
2007/07/06. --RJL20 |
Modified to calculate the 8-bit CRC directly, avoiding the need for |
the 256-byte lookup table to be loaded in RAM. Tested in arduino-0010 |
-- Tom Pollard, Jan 23, 2008 |
Jim Studt's original library was modified by Josh Larios. |
Tom Pollard, pollard@alum.mit.edu, contributed around May 20, 2008 |
Permission is hereby granted, free of charge, to any person obtaining |
a copy of this software and associated documentation files (the |
"Software"), to deal in the Software without restriction, including |
without limitation the rights to use, copy, modify, merge, publish, |
distribute, sublicense, and/or sell copies of the Software, and to |
permit persons to whom the Software is furnished to do so, subject to |
the following conditions: |
The above copyright notice and this permission notice shall be |
included in all copies or substantial portions of the Software. |
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE |
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION |
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
Much of the code was inspired by Derek Yerger's code, though I don't |
think much of that remains. In any event that was.. |
(copyleft) 2006 by Derek Yerger - Free to distribute freely. |
The CRC code was excerpted and inspired by the Dallas Semiconductor |
sample code bearing this copyright. |
//--------------------------------------------------------------------------- |
// Copyright (C) 2000 Dallas Semiconductor Corporation, All Rights Reserved. |
// |
// Permission is hereby granted, free of charge, to any person obtaining a |
// copy of this software and associated documentation files (the "Software"), |
// to deal in the Software without restriction, including without limitation |
// the rights to use, copy, modify, merge, publish, distribute, sublicense, |
// and/or sell copies of the Software, and to permit persons to whom the |
// Software is furnished to do so, subject to the following conditions: |
// |
// The above copyright notice and this permission notice shall be included |
// in all copies or substantial portions of the Software. |
// |
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. |
// IN NO EVENT SHALL DALLAS SEMICONDUCTOR BE LIABLE FOR ANY CLAIM, DAMAGES |
// OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, |
// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR |
// OTHER DEALINGS IN THE SOFTWARE. |
// |
// Except as contained in this notice, the name of Dallas Semiconductor |
// shall not be used except as stated in the Dallas Semiconductor |
// Branding Policy. |
//-------------------------------------------------------------------------- |
*/ |
#include "OneWire.h" |
OneWire::OneWire(uint8_t pin) |
{ |
pinMode(pin, INPUT); |
bitmask = PIN_TO_BITMASK(pin); |
baseReg = PIN_TO_BASEREG(pin); |
#if ONEWIRE_SEARCH |
reset_search(); |
#endif |
} |
// Perform the onewire reset function. We will wait up to 250uS for |
// the bus to come high, if it doesn't then it is broken or shorted |
// and we return a 0; |
// |
// Returns 1 if a device asserted a presence pulse, 0 otherwise. |
// |
uint8_t OneWire::reset(void) |
{ |
IO_REG_TYPE mask = bitmask; |
volatile IO_REG_TYPE *reg IO_REG_ASM = baseReg; |
uint8_t r; |
uint8_t retries = 125; |
noInterrupts(); |
DIRECT_MODE_INPUT(reg, mask); |
interrupts(); |
// wait until the wire is high... just in case |
do { |
if (--retries == 0) return 0; |
delayMicroseconds(2); |
} while ( !DIRECT_READ(reg, mask)); |
noInterrupts(); |
DIRECT_WRITE_LOW(reg, mask); |
DIRECT_MODE_OUTPUT(reg, mask); // drive output low |
interrupts(); |
delayMicroseconds(500); |
noInterrupts(); |
DIRECT_MODE_INPUT(reg, mask); // allow it to float |
delayMicroseconds(80); |
r = !DIRECT_READ(reg, mask); |
interrupts(); |
delayMicroseconds(420); |
return r; |
} |
// |
// Write a bit. Port and bit is used to cut lookup time and provide |
// more certain timing. |
// |
void OneWire::write_bit(uint8_t v) |
{ |
IO_REG_TYPE mask=bitmask; |
volatile IO_REG_TYPE *reg IO_REG_ASM = baseReg; |
if (v & 1) { |
noInterrupts(); |
DIRECT_WRITE_LOW(reg, mask); |
DIRECT_MODE_OUTPUT(reg, mask); // drive output low |
delayMicroseconds(10); |
DIRECT_WRITE_HIGH(reg, mask); // drive output high |
interrupts(); |
delayMicroseconds(55); |
} else { |
noInterrupts(); |
DIRECT_WRITE_LOW(reg, mask); |
DIRECT_MODE_OUTPUT(reg, mask); // drive output low |
delayMicroseconds(65); |
DIRECT_WRITE_HIGH(reg, mask); // drive output high |
interrupts(); |
delayMicroseconds(5); |
} |
} |
// |
// Read a bit. Port and bit is used to cut lookup time and provide |
// more certain timing. |
// |
uint8_t OneWire::read_bit(void) |
{ |
IO_REG_TYPE mask=bitmask; |
volatile IO_REG_TYPE *reg IO_REG_ASM = baseReg; |
uint8_t r; |
noInterrupts(); |
DIRECT_MODE_OUTPUT(reg, mask); |
DIRECT_WRITE_LOW(reg, mask); |
delayMicroseconds(3); |
DIRECT_MODE_INPUT(reg, mask); // let pin float, pull up will raise |
delayMicroseconds(10); |
r = DIRECT_READ(reg, mask); |
interrupts(); |
delayMicroseconds(53); |
return r; |
} |
// |
// Write a byte. The writing code uses the active drivers to raise the |
// pin high, if you need power after the write (e.g. DS18S20 in |
// parasite power mode) then set 'power' to 1, otherwise the pin will |
// go tri-state at the end of the write to avoid heating in a short or |
// other mishap. |
// |
void OneWire::write(uint8_t v, uint8_t power /* = 0 */) { |
uint8_t bitMask; |
for (bitMask = 0x01; bitMask; bitMask <<= 1) { |
OneWire::write_bit( (bitMask & v)?1:0); |
} |
if ( !power) { |
noInterrupts(); |
DIRECT_MODE_INPUT(baseReg, bitmask); |
DIRECT_WRITE_LOW(baseReg, bitmask); |
interrupts(); |
} |
} |
void OneWire::write_bytes(const uint8_t *buf, uint16_t count, bool power /* = 0 */) { |
for (uint16_t i = 0 ; i < count ; i++) |
write(buf[i]); |
if (!power) { |
noInterrupts(); |
DIRECT_MODE_INPUT(baseReg, bitmask); |
DIRECT_WRITE_LOW(baseReg, bitmask); |
interrupts(); |
} |
} |
// |
// Read a byte |
// |
uint8_t OneWire::read() { |
uint8_t bitMask; |
uint8_t r = 0; |
for (bitMask = 0x01; bitMask; bitMask <<= 1) { |
if ( OneWire::read_bit()) r |= bitMask; |
} |
return r; |
} |
void OneWire::read_bytes(uint8_t *buf, uint16_t count) { |
for (uint16_t i = 0 ; i < count ; i++) |
buf[i] = read(); |
} |
// |
// Do a ROM select |
// |
void OneWire::select( uint8_t rom[8]) |
{ |
int i; |
write(0x55); // Choose ROM |
for( i = 0; i < 8; i++) write(rom[i]); |
} |
// |
// Do a ROM skip |
// |
void OneWire::skip() |
{ |
write(0xCC); // Skip ROM |
} |
void OneWire::depower() |
{ |
noInterrupts(); |
DIRECT_MODE_INPUT(baseReg, bitmask); |
interrupts(); |
} |
#if ONEWIRE_SEARCH |
// |
// You need to use this function to start a search again from the beginning. |
// You do not need to do it for the first search, though you could. |
// |
void OneWire::reset_search() |
{ |
// reset the search state |
LastDiscrepancy = 0; |
LastDeviceFlag = FALSE; |
LastFamilyDiscrepancy = 0; |
for(int i = 7; ; i--) |
{ |
ROM_NO[i] = 0; |
if ( i == 0) break; |
} |
} |
// |
// Perform a search. If this function returns a '1' then it has |
// enumerated the next device and you may retrieve the ROM from the |
// OneWire::address variable. If there are no devices, no further |
// devices, or something horrible happens in the middle of the |
// enumeration then a 0 is returned. If a new device is found then |
// its address is copied to newAddr. Use OneWire::reset_search() to |
// start over. |
// |
// --- Replaced by the one from the Dallas Semiconductor web site --- |
//-------------------------------------------------------------------------- |
// Perform the 1-Wire Search Algorithm on the 1-Wire bus using the existing |
// search state. |
// Return TRUE : device found, ROM number in ROM_NO buffer |
// FALSE : device not found, end of search |
// |
uint8_t OneWire::search(uint8_t *newAddr) |
{ |
uint8_t id_bit_number; |
uint8_t last_zero, rom_byte_number, search_result; |
uint8_t id_bit, cmp_id_bit; |
unsigned char rom_byte_mask, search_direction; |
// initialize for search |
id_bit_number = 1; |
last_zero = 0; |
rom_byte_number = 0; |
rom_byte_mask = 1; |
search_result = 0; |
// if the last call was not the last one |
if (!LastDeviceFlag) |
{ |
// 1-Wire reset |
if (!reset()) |
{ |
// reset the search |
LastDiscrepancy = 0; |
LastDeviceFlag = FALSE; |
LastFamilyDiscrepancy = 0; |
return FALSE; |
} |
// issue the search command |
write(0xF0); |
// loop to do the search |
do |
{ |
// read a bit and its complement |
id_bit = read_bit(); |
cmp_id_bit = read_bit(); |
// check for no devices on 1-wire |
if ((id_bit == 1) && (cmp_id_bit == 1)) |
break; |
else |
{ |
// all devices coupled have 0 or 1 |
if (id_bit != cmp_id_bit) |
search_direction = id_bit; // bit write value for search |
else |
{ |
// if this discrepancy if before the Last Discrepancy |
// on a previous next then pick the same as last time |
if (id_bit_number < LastDiscrepancy) |
search_direction = ((ROM_NO[rom_byte_number] & rom_byte_mask) > 0); |
else |
// if equal to last pick 1, if not then pick 0 |
search_direction = (id_bit_number == LastDiscrepancy); |
// if 0 was picked then record its position in LastZero |
if (search_direction == 0) |
{ |
last_zero = id_bit_number; |
// check for Last discrepancy in family |
if (last_zero < 9) |
LastFamilyDiscrepancy = last_zero; |
} |
} |
// set or clear the bit in the ROM byte rom_byte_number |
// with mask rom_byte_mask |
if (search_direction == 1) |
ROM_NO[rom_byte_number] |= rom_byte_mask; |
else |
ROM_NO[rom_byte_number] &= ~rom_byte_mask; |
// serial number search direction write bit |
write_bit(search_direction); |
// increment the byte counter id_bit_number |
// and shift the mask rom_byte_mask |
id_bit_number++; |
rom_byte_mask <<= 1; |
// if the mask is 0 then go to new SerialNum byte rom_byte_number and reset mask |
if (rom_byte_mask == 0) |
{ |
rom_byte_number++; |
rom_byte_mask = 1; |
} |
} |
} |
while(rom_byte_number < 8); // loop until through all ROM bytes 0-7 |
// if the search was successful then |
if (!(id_bit_number < 65)) |
{ |
// search successful so set LastDiscrepancy,LastDeviceFlag,search_result |
LastDiscrepancy = last_zero; |
// check for last device |
if (LastDiscrepancy == 0) |
LastDeviceFlag = TRUE; |
search_result = TRUE; |
} |
} |
// if no device found then reset counters so next 'search' will be like a first |
if (!search_result || !ROM_NO[0]) |
{ |
LastDiscrepancy = 0; |
LastDeviceFlag = FALSE; |
LastFamilyDiscrepancy = 0; |
search_result = FALSE; |
} |
for (int i = 0; i < 8; i++) newAddr[i] = ROM_NO[i]; |
return search_result; |
} |
#endif |
#if ONEWIRE_CRC |
// The 1-Wire CRC scheme is described in Maxim Application Note 27: |
// "Understanding and Using Cyclic Redundancy Checks with Maxim iButton Products" |
// |
#if ONEWIRE_CRC8_TABLE |
// This table comes from Dallas sample code where it is freely reusable, |
// though Copyright (C) 2000 Dallas Semiconductor Corporation |
static const uint8_t PROGMEM dscrc_table[] = { |
0, 94,188,226, 97, 63,221,131,194,156,126, 32,163,253, 31, 65, |
157,195, 33,127,252,162, 64, 30, 95, 1,227,189, 62, 96,130,220, |
35,125,159,193, 66, 28,254,160,225,191, 93, 3,128,222, 60, 98, |
190,224, 2, 92,223,129, 99, 61,124, 34,192,158, 29, 67,161,255, |
70, 24,250,164, 39,121,155,197,132,218, 56,102,229,187, 89, 7, |
219,133,103, 57,186,228, 6, 88, 25, 71,165,251,120, 38,196,154, |
101, 59,217,135, 4, 90,184,230,167,249, 27, 69,198,152,122, 36, |
248,166, 68, 26,153,199, 37,123, 58,100,134,216, 91, 5,231,185, |
140,210, 48,110,237,179, 81, 15, 78, 16,242,172, 47,113,147,205, |
17, 79,173,243,112, 46,204,146,211,141,111, 49,178,236, 14, 80, |
175,241, 19, 77,206,144,114, 44,109, 51,209,143, 12, 82,176,238, |
50,108,142,208, 83, 13,239,177,240,174, 76, 18,145,207, 45,115, |
202,148,118, 40,171,245, 23, 73, 8, 86,180,234,105, 55,213,139, |
87, 9,235,181, 54,104,138,212,149,203, 41,119,244,170, 72, 22, |
233,183, 85, 11,136,214, 52,106, 43,117,151,201, 74, 20,246,168, |
116, 42,200,150, 21, 75,169,247,182,232, 10, 84,215,137,107, 53}; |
// |
// Compute a Dallas Semiconductor 8 bit CRC. These show up in the ROM |
// and the registers. (note: this might better be done without to |
// table, it would probably be smaller and certainly fast enough |
// compared to all those delayMicrosecond() calls. But I got |
// confused, so I use this table from the examples.) |
// |
uint8_t OneWire::crc8( uint8_t *addr, uint8_t len) |
{ |
uint8_t crc = 0; |
while (len--) { |
crc = pgm_read_byte(dscrc_table + (crc ^ *addr++)); |
} |
return crc; |
} |
#else |
// |
// Compute a Dallas Semiconductor 8 bit CRC directly. |
// this is much slower, but much smaller, than the lookup table. |
// |
uint8_t OneWire::crc8( uint8_t *addr, uint8_t len) |
{ |
uint8_t crc = 0; |
while (len--) { |
uint8_t inbyte = *addr++; |
for (uint8_t i = 8; i; i--) { |
uint8_t mix = (crc ^ inbyte) & 0x01; |
crc >>= 1; |
if (mix) crc ^= 0x8C; |
inbyte >>= 1; |
} |
} |
return crc; |
} |
#endif |
#if ONEWIRE_CRC16 |
bool OneWire::check_crc16(uint8_t* input, uint16_t len, uint8_t* inverted_crc) |
{ |
uint16_t crc = ~crc16(input, len); |
return (crc & 0xFF) == inverted_crc[0] && (crc >> 8) == inverted_crc[1]; |
} |
uint16_t OneWire::crc16(uint8_t* input, uint16_t len) |
{ |
static const uint8_t oddparity[16] = |
{ 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0 }; |
uint16_t crc = 0; // Starting seed is zero. |
for (uint16_t i = 0 ; i < len ; i++) { |
// Even though we're just copying a byte from the input, |
// we'll be doing 16-bit computation with it. |
uint16_t cdata = input[i]; |
cdata = (cdata ^ (crc & 0xff)) & 0xff; |
crc >>= 8; |
if (oddparity[cdata & 0x0F] ^ oddparity[cdata >> 4]) |
crc ^= 0xC001; |
cdata <<= 6; |
crc ^= cdata; |
cdata <<= 1; |
crc ^= cdata; |
} |
return crc; |
} |
#endif |
#endif |
/Designs/Spectrograph/SW/libraries/OneWire/OneWire.h |
---|
0,0 → 1,192 |
#ifndef OneWire_h |
#define OneWire_h |
#include <inttypes.h> |
#if ARDUINO >= 100 |
#include "Arduino.h" // for delayMicroseconds, digitalPinToBitMask, etc |
#else |
#include "WProgram.h" // for delayMicroseconds |
#include "pins_arduino.h" // for digitalPinToBitMask, etc |
#endif |
// You can exclude certain features from OneWire. In theory, this |
// might save some space. In practice, the compiler automatically |
// removes unused code (technically, the linker, using -fdata-sections |
// and -ffunction-sections when compiling, and Wl,--gc-sections |
// when linking), so most of these will not result in any code size |
// reduction. Well, unless you try to use the missing features |
// and redesign your program to not need them! ONEWIRE_CRC8_TABLE |
// is the exception, because it selects a fast but large algorithm |
// or a small but slow algorithm. |
// you can exclude onewire_search by defining that to 0 |
#ifndef ONEWIRE_SEARCH |
#define ONEWIRE_SEARCH 1 |
#endif |
// You can exclude CRC checks altogether by defining this to 0 |
#ifndef ONEWIRE_CRC |
#define ONEWIRE_CRC 1 |
#endif |
// Select the table-lookup method of computing the 8-bit CRC |
// by setting this to 1. The lookup table enlarges code size by |
// about 250 bytes. It does NOT consume RAM (but did in very |
// old versions of OneWire). If you disable this, a slower |
// but very compact algorithm is used. |
#ifndef ONEWIRE_CRC8_TABLE |
#define ONEWIRE_CRC8_TABLE 1 |
#endif |
// You can allow 16-bit CRC checks by defining this to 1 |
// (Note that ONEWIRE_CRC must also be 1.) |
#ifndef ONEWIRE_CRC16 |
#define ONEWIRE_CRC16 1 |
#endif |
#define FALSE 0 |
#define TRUE 1 |
// Platform specific I/O definitions |
#if defined(__AVR__) |
#define PIN_TO_BASEREG(pin) (portInputRegister(digitalPinToPort(pin))) |
#define PIN_TO_BITMASK(pin) (digitalPinToBitMask(pin)) |
#define IO_REG_TYPE uint8_t |
#define IO_REG_ASM asm("r30") |
#define DIRECT_READ(base, mask) (((*(base)) & (mask)) ? 1 : 0) |
#define DIRECT_MODE_INPUT(base, mask) ((*(base+1)) &= ~(mask)) |
#define DIRECT_MODE_OUTPUT(base, mask) ((*(base+1)) |= (mask)) |
#define DIRECT_WRITE_LOW(base, mask) ((*(base+2)) &= ~(mask)) |
#define DIRECT_WRITE_HIGH(base, mask) ((*(base+2)) |= (mask)) |
#elif defined(__PIC32MX__) |
#include <plib.h> // is this necessary? |
#define PIN_TO_BASEREG(pin) (portModeRegister(digitalPinToPort(pin))) |
#define PIN_TO_BITMASK(pin) (digitalPinToBitMask(pin)) |
#define IO_REG_TYPE uint32_t |
#define IO_REG_ASM |
#define DIRECT_READ(base, mask) (((*(base+4)) & (mask)) ? 1 : 0) //PORTX + 0x10 |
#define DIRECT_MODE_INPUT(base, mask) ((*(base+2)) = (mask)) //TRISXSET + 0x08 |
#define DIRECT_MODE_OUTPUT(base, mask) ((*(base+1)) = (mask)) //TRISXCLR + 0x04 |
#define DIRECT_WRITE_LOW(base, mask) ((*(base+8+1)) = (mask)) //LATXCLR + 0x24 |
#define DIRECT_WRITE_HIGH(base, mask) ((*(base+8+2)) = (mask)) //LATXSET + 0x28 |
#else |
#error "Please define I/O register types here" |
#endif |
class OneWire |
{ |
private: |
IO_REG_TYPE bitmask; |
volatile IO_REG_TYPE *baseReg; |
#if ONEWIRE_SEARCH |
// global search state |
unsigned char ROM_NO[8]; |
uint8_t LastDiscrepancy; |
uint8_t LastFamilyDiscrepancy; |
uint8_t LastDeviceFlag; |
#endif |
public: |
OneWire( uint8_t pin); |
// Perform a 1-Wire reset cycle. Returns 1 if a device responds |
// with a presence pulse. Returns 0 if there is no device or the |
// bus is shorted or otherwise held low for more than 250uS |
uint8_t reset(void); |
// Issue a 1-Wire rom select command, you do the reset first. |
void select( uint8_t rom[8]); |
// Issue a 1-Wire rom skip command, to address all on bus. |
void skip(void); |
// Write a byte. If 'power' is one then the wire is held high at |
// the end for parasitically powered devices. You are responsible |
// for eventually depowering it by calling depower() or doing |
// another read or write. |
void write(uint8_t v, uint8_t power = 0); |
void write_bytes(const uint8_t *buf, uint16_t count, bool power = 0); |
// Read a byte. |
uint8_t read(void); |
void read_bytes(uint8_t *buf, uint16_t count); |
// Write a bit. The bus is always left powered at the end, see |
// note in write() about that. |
void write_bit(uint8_t v); |
// Read a bit. |
uint8_t read_bit(void); |
// Stop forcing power onto the bus. You only need to do this if |
// you used the 'power' flag to write() or used a write_bit() call |
// and aren't about to do another read or write. You would rather |
// not leave this powered if you don't have to, just in case |
// someone shorts your bus. |
void depower(void); |
#if ONEWIRE_SEARCH |
// Clear the search state so that if will start from the beginning again. |
void reset_search(); |
// Look for the next device. Returns 1 if a new address has been |
// returned. A zero might mean that the bus is shorted, there are |
// no devices, or you have already retrieved all of them. It |
// might be a good idea to check the CRC to make sure you didn't |
// get garbage. The order is deterministic. You will always get |
// the same devices in the same order. |
uint8_t search(uint8_t *newAddr); |
#endif |
#if ONEWIRE_CRC |
// Compute a Dallas Semiconductor 8 bit CRC, these are used in the |
// ROM and scratchpad registers. |
static uint8_t crc8( uint8_t *addr, uint8_t len); |
#if ONEWIRE_CRC16 |
// Compute the 1-Wire CRC16 and compare it against the received CRC. |
// Example usage (reading a DS2408): |
// // Put everything in a buffer so we can compute the CRC easily. |
// uint8_t buf[13]; |
// buf[0] = 0xF0; // Read PIO Registers |
// buf[1] = 0x88; // LSB address |
// buf[2] = 0x00; // MSB address |
// WriteBytes(net, buf, 3); // Write 3 cmd bytes |
// ReadBytes(net, buf+3, 10); // Read 6 data bytes, 2 0xFF, 2 CRC16 |
// if (!CheckCRC16(buf, 11, &buf[11])) { |
// // Handle error. |
// } |
// |
// @param input - Array of bytes to checksum. |
// @param len - How many bytes to use. |
// @param inverted_crc - The two CRC16 bytes in the received data. |
// This should just point into the received data, |
// *not* at a 16-bit integer. |
// @return True, iff the CRC matches. |
static bool check_crc16(uint8_t* input, uint16_t len, uint8_t* inverted_crc); |
// Compute a Dallas Semiconductor 16 bit CRC. This is required to check |
// the integrity of data received from many 1-Wire devices. Note that the |
// CRC computed here is *not* what you'll get from the 1-Wire network, |
// for two reasons: |
// 1) The CRC is transmitted bitwise inverted. |
// 2) Depending on the endian-ness of your processor, the binary |
// representation of the two-byte return value may have a different |
// byte order than the two bytes you get from 1-Wire. |
// @param input - Array of bytes to checksum. |
// @param len - How many bytes to use. |
// @return The CRC16, as defined by Dallas Semiconductor. |
static uint16_t crc16(uint8_t* input, uint16_t len); |
#endif |
#endif |
}; |
#endif |
/Designs/Spectrograph/SW/libraries/OneWire/examples/DS18x20_Temperature/DS18x20_Temperature.pde |
---|
0,0 → 1,109 |
#include <OneWire.h> |
// OneWire DS18S20, DS18B20, DS1822 Temperature Example |
// |
// http://www.pjrc.com/teensy/td_libs_OneWire.html |
// |
// The DallasTemperature library can do all this work for you! |
// http://milesburton.com/Dallas_Temperature_Control_Library |
OneWire ds(10); // on pin 10 |
void setup(void) { |
Serial.begin(9600); |
} |
void loop(void) { |
byte i; |
byte present = 0; |
byte type_s; |
byte data[12]; |
byte addr[8]; |
float celsius, fahrenheit; |
if ( !ds.search(addr)) { |
Serial.println("No more addresses."); |
Serial.println(); |
ds.reset_search(); |
delay(250); |
return; |
} |
Serial.print("ROM ="); |
for( i = 0; i < 8; i++) { |
Serial.write(' '); |
Serial.print(addr[i], HEX); |
} |
if (OneWire::crc8(addr, 7) != addr[7]) { |
Serial.println("CRC is not valid!"); |
return; |
} |
Serial.println(); |
// the first ROM byte indicates which chip |
switch (addr[0]) { |
case 0x10: |
Serial.println(" Chip = DS18S20"); // or old DS1820 |
type_s = 1; |
break; |
case 0x28: |
Serial.println(" Chip = DS18B20"); |
type_s = 0; |
break; |
case 0x22: |
Serial.println(" Chip = DS1822"); |
type_s = 0; |
break; |
default: |
Serial.println("Device is not a DS18x20 family device."); |
return; |
} |
ds.reset(); |
ds.select(addr); |
ds.write(0x44,1); // start conversion, with parasite power on at the end |
delay(1000); // maybe 750ms is enough, maybe not |
// we might do a ds.depower() here, but the reset will take care of it. |
present = ds.reset(); |
ds.select(addr); |
ds.write(0xBE); // Read Scratchpad |
Serial.print(" Data = "); |
Serial.print(present,HEX); |
Serial.print(" "); |
for ( i = 0; i < 9; i++) { // we need 9 bytes |
data[i] = ds.read(); |
Serial.print(data[i], HEX); |
Serial.print(" "); |
} |
Serial.print(" CRC="); |
Serial.print(OneWire::crc8(data, 8), HEX); |
Serial.println(); |
// convert the data to actual temperature |
unsigned int raw = (data[1] << 8) | data[0]; |
if (type_s) { |
raw = raw << 3; // 9 bit resolution default |
if (data[7] == 0x10) { |
// count remain gives full 12 bit resolution |
raw = (raw & 0xFFF0) + 12 - data[6]; |
} |
} else { |
byte cfg = (data[4] & 0x60); |
if (cfg == 0x00) raw = raw << 3; // 9 bit resolution, 93.75 ms |
else if (cfg == 0x20) raw = raw << 2; // 10 bit res, 187.5 ms |
else if (cfg == 0x40) raw = raw << 1; // 11 bit res, 375 ms |
// default is 12 bit resolution, 750 ms conversion time |
} |
celsius = (float)raw / 16.0; |
fahrenheit = celsius * 1.8 + 32.0; |
Serial.print(" Temperature = "); |
Serial.print(celsius); |
Serial.print(" Celsius, "); |
Serial.print(fahrenheit); |
Serial.println(" Fahrenheit"); |
} |
/Designs/Spectrograph/SW/libraries/OneWire/examples/DS2408_Switch/DS2408_Switch.pde |
---|
0,0 → 1,77 |
#include <OneWire.h> |
/* |
* DS2408 8-Channel Addressable Switch |
* |
* Writte by Glenn Trewitt, glenn at trewitt dot org |
* |
* Some notes about the DS2408: |
* - Unlike most input/output ports, the DS2408 doesn't have mode bits to |
* set whether the pins are input or output. If you issue a read command, |
* they're inputs. If you write to them, they're outputs. |
* - For reading from a switch, you should use 10K pull-up resisters. |
*/ |
void PrintBytes(uint8_t* addr, uint8_t count, bool newline=0) { |
for (uint8_t i = 0; i < count; i++) { |
Serial.print(addr[i]>>4, HEX); |
Serial.print(addr[i]&0x0f, HEX); |
} |
if (newline) |
Serial.println(); |
} |
void ReadAndReport(OneWire* net, uint8_t* addr) { |
Serial.print(" Reading DS2408 "); |
PrintBytes(addr, 8); |
Serial.println(); |
uint8_t buf[13]; // Put everything in the buffer so we can compute CRC easily. |
buf[0] = 0xF0; // Read PIO Registers |
buf[1] = 0x88; // LSB address |
buf[2] = 0x00; // MSB address |
net->write_bytes(buf, 3); |
net->read_bytes(buf+3, 10); // 3 cmd bytes, 6 data bytes, 2 0xFF, 2 CRC16 |
net->reset(); |
if (!OneWire::check_crc16(buf, 11, &buf[11])) { |
Serial.print("CRC failure in DS2408 at "); |
PrintBytes(addr, 8, true); |
return; |
} |
Serial.print(" DS2408 data = "); |
// First 3 bytes contain command, register address. |
Serial.println(buf[3], BIN); |
} |
OneWire net(10); // on pin 10 |
void setup(void) { |
Serial.begin(9600); |
} |
void loop(void) { |
byte i; |
byte present = 0; |
byte addr[8]; |
if (!net.search(addr)) { |
Serial.print("No more addresses.\n"); |
net.reset_search(); |
delay(1000); |
return; |
} |
if (OneWire::crc8(addr, 7) != addr[7]) { |
Serial.print("CRC is not valid!\n"); |
return; |
} |
if (addr[0] != 0x29) { |
PrintBytes(addr, 8); |
Serial.print(" is not a DS2408.\n"); |
return; |
} |
ReadAndReport(&net, addr); |
} |
/Designs/Spectrograph/SW/libraries/OneWire/examples/DS250x_PROM/DS250x_PROM.pde |
---|
0,0 → 1,90 |
/* |
DS250x add-only programmable memory reader w/SKIP ROM. |
The DS250x is a 512/1024bit add-only PROM(you can add data but cannot change the old one) that's used mainly for device identification purposes |
like serial number, mfgr data, unique identifiers, etc. It uses the Maxim 1-wire bus. |
This sketch will use the SKIP ROM function that skips the 1-Wire search phase since we only have one device connected in the bus on digital pin 6. |
If more than one device is connected to the bus, it will fail. |
Sketch will not verify if device connected is from the DS250x family since the skip rom function effectively skips the family-id byte readout. |
thus it is possible to run this sketch with any Maxim OneWire device in which case the command CRC will most likely fail. |
Sketch will only read the first page of memory(32bits) starting from the lower address(0000h), if more than 1 device is present, then use the sketch with search functions. |
Remember to put a 4.7K pullup resistor between pin 6 and +Vcc |
To change the range or ammount of data to read, simply change the data array size, LSB/MSB addresses and for loop iterations |
This example code is in the public domain and is provided AS-IS. |
Built with Arduino 0022 and PJRC OneWire 2.0 library http://www.pjrc.com/teensy/td_libs_OneWire.html |
created by Guillermo Lovato <glovato@gmail.com> |
march/2011 |
*/ |
#include <OneWire.h> |
OneWire ds(6); // OneWire bus on digital pin 6 |
void setup() { |
Serial.begin (9600); |
} |
void loop() { |
byte i; // This is for the for loops |
boolean present; // device present var |
byte data[32]; // container for the data from device |
byte leemem[3] = { // array with the commands to initiate a read, DS250x devices expect 3 bytes to start a read: command,LSB&MSB adresses |
0xF0 , 0x00 , 0x00 }; // 0xF0 is the Read Data command, followed by 00h 00h as starting address(the beginning, 0000h) |
byte ccrc; // Variable to store the command CRC |
byte ccrc_calc; |
present = ds.reset(); // OneWire bus reset, always needed to start operation on the bus, returns a 1/TRUE if there's a device present. |
ds.skip(); // Skip ROM search |
if (present == TRUE){ // We only try to read the data if there's a device present |
Serial.println("DS250x device present"); |
ds.write(leemem[0],1); // Read data command, leave ghost power on |
ds.write(leemem[1],1); // LSB starting address, leave ghost power on |
ds.write(leemem[2],1); // MSB starting address, leave ghost power on |
ccrc = ds.read(); // DS250x generates a CRC for the command we sent, we assign a read slot and store it's value |
ccrc_calc = OneWire::crc8(leemem, 3); // We calculate the CRC of the commands we sent using the library function and store it |
if ( ccrc_calc != ccrc) { // Then we compare it to the value the ds250x calculated, if it fails, we print debug messages and abort |
Serial.println("Invalid command CRC!"); |
Serial.print("Calculated CRC:"); |
Serial.println(ccrc_calc,HEX); // HEX makes it easier to observe and compare |
Serial.print("DS250x readback CRC:"); |
Serial.println(ccrc,HEX); |
return; // Since CRC failed, we abort the rest of the loop and start over |
} |
Serial.println("Data is: "); // For the printout of the data |
for ( i = 0; i < 32; i++) { // Now it's time to read the PROM data itself, each page is 32 bytes so we need 32 read commands |
data[i] = ds.read(); // we store each read byte to a different position in the data array |
Serial.print(data[i]); // printout in ASCII |
Serial.print(" "); // blank space |
} |
Serial.println(); |
delay(5000); // Delay so we don't saturate the serial output |
} |
else { // Nothing is connected in the bus |
Serial.println("Nothing connected"); |
delay(3000); |
} |
} |
/Designs/Spectrograph/SW/libraries/OneWire/keywords.txt |
---|
0,0 → 1,38 |
####################################### |
# Syntax Coloring Map For OneWire |
####################################### |
####################################### |
# Datatypes (KEYWORD1) |
####################################### |
OneWire KEYWORD1 |
####################################### |
# Methods and Functions (KEYWORD2) |
####################################### |
reset KEYWORD2 |
write_bit KEYWORD2 |
read_bit KEYWORD2 |
write KEYWORD2 |
write_bytes KEYWORD2 |
read KEYWORD2 |
read_bytes KEYWORD2 |
select KEYWORD2 |
skip KEYWORD2 |
depower KEYWORD2 |
reset_search KEYWORD2 |
search KEYWORD2 |
crc8 KEYWORD2 |
crc16 KEYWORD2 |
check_crc16 KEYWORD2 |
####################################### |
# Instances (KEYWORD2) |
####################################### |
####################################### |
# Constants (LITERAL1) |
####################################### |
/Designs/Spectrograph/SW/colores/colores.ino |
---|
0,0 → 1,356 |
#include "OneWire.h" |
#include <Stepper.h> |
#include <Wire.h> |
/* |
protokol: |
M - motor na jednu stranu |
m - motor na druhou stranu |
-- |
a - vypni FW1 |
A - zapni FW1 |
-- |
b - vypni FW2 |
B - zapni FW2 |
-- |
c - vypni FW3 |
C - zapni FW3 |
-- |
i - inicializace: vypni vsechny FW, vytahni motor |
*/ |
#define light0 0x44 // A0 = L (I2C light0) |
#define light1 0x45 // A0 = H (I2C light1) |
int lights[] = {light0, light1}; |
//#define LAMP1 13 // Callibration Lamp 1 |
//#define LAMP2 6 // Callibration Lamp 2 |
#define FW1 7 // [PD7 - red] Slit Wheel 1-st from light |
#define FW2 8 // [PB0 - yellow] Grism Wheel 2-nd from light |
#define FW3 3 // [PD3 - blue] Filter Wheel 3-rd from light |
int filters[] = {FW1, FW2, FW3}; |
const int STEPS = 3500; // change this to fit the number of steps |
const int SSPEED = 8000; // max. 15 // stepper motor speed |
// initialize the stepper library on pins |
#define M1 9 |
#define M2 10 |
#define M3 11 |
#define M4 12 |
Stepper myStepper(200, M1,M2,M3,M4); |
// DS18S20 Temperature chip |
OneWire ds(5); // 1-Wire pin |
byte addr[2][8]; // 2x 1-Wire Address |
char deleni16[16]={'0','1','1','2','3','3','4','4','5','6','6','7','7','8','9','9'}; |
char serInString[100]; |
int serInIndx = 0; |
int in1, in2; |
void motor (word arg) |
{ |
word n; |
word s=SSPEED; |
/* |
for(n=0;n<2500000/SSPEED;n++) |
{ |
digitalWrite(M1, LOW); |
digitalWrite(M2, HIGH); |
digitalWrite(M1, LOW); |
digitalWrite(M2, HIGH); |
delayMicroseconds(SSPEED); |
digitalWrite(M1, HIGH); |
digitalWrite(M2, LOW); |
digitalWrite(M1, HIGH); |
digitalWrite(M2, LOW); |
delayMicroseconds(SSPEED); |
} |
*/ |
if(arg==-1) |
{ |
for(n=0;n<STEPS/4;n++) |
{ |
digitalWrite(M1, LOW); |
digitalWrite(M2, HIGH); |
// digitalWrite(M3, LOW); |
// digitalWrite(M4, HIGH); |
delayMicroseconds(s); |
// digitalWrite(M1, LOW); |
// digitalWrite(M2, HIGH); |
digitalWrite(M3, HIGH); |
digitalWrite(M4, LOW); |
delayMicroseconds(s); |
digitalWrite(M1, HIGH); |
digitalWrite(M2, LOW); |
// digitalWrite(M3, HIGH); |
// digitalWrite(M4, LOW); |
delayMicroseconds(s); |
// digitalWrite(M1, HIGH); |
// digitalWrite(M2, LOW); |
digitalWrite(M3, LOW); |
digitalWrite(M4, HIGH); |
delayMicroseconds(s); |
if(s>1500)s-=50; |
} |
} |
else |
{ |
for(n=0;n<STEPS/4;n++) |
{ |
// digitalWrite(M1, HIGH); |
// digitalWrite(M2, LOW); |
digitalWrite(M3, LOW); |
digitalWrite(M4, HIGH); |
delayMicroseconds(s); |
digitalWrite(M1, HIGH); |
digitalWrite(M2, LOW); |
// digitalWrite(M3, HIGH); |
// digitalWrite(M4, LOW); |
delayMicroseconds(s); |
// digitalWrite(M1, LOW); |
// digitalWrite(M2, HIGH); |
digitalWrite(M3, HIGH); |
digitalWrite(M4, LOW); |
delayMicroseconds(s); |
digitalWrite(M1, LOW); |
digitalWrite(M2, HIGH); |
// digitalWrite(M3, LOW); |
// digitalWrite(M4, HIGH); |
delayMicroseconds(s); |
if(s>1500)s-=50; |
} |
} |
/* |
myStepper.setSpeed(1); |
myStepper.step(arg * 10); |
myStepper.setSpeed(sspeed); |
myStepper.step(arg * steps); |
*/ |
digitalWrite(M1, LOW); |
digitalWrite(M2, LOW); |
digitalWrite(M3, LOW); |
digitalWrite(M4, LOW); |
} |
int light (int arg) |
{ |
int LSB = 0, MSB = 0; // data from light |
// Setup device |
Wire.beginTransmission(lights[arg]); |
Wire.write(byte(0x00)); // command register |
Wire.write(byte(0b11000001)); // setup (eye light sensing; measurement range 2 [4000 lx]) |
Wire.endTransmission(); // stop transmitting |
// Delay for measurement, maybe 100ms is enough, maybe not |
delay(110); |
// LSB |
Wire.beginTransmission(lights[arg]); |
Wire.write(byte(0x01)); // sends light0 |
Wire.endTransmission(); // stop transmitting |
// Connect to device and request one byte |
Wire.beginTransmission(lights[arg]); |
Wire.requestFrom(lights[arg], 1); |
LSB = Wire.read(); |
Wire.endTransmission(); |
// MSB |
Wire.beginTransmission(lights[arg]); |
Wire.write(byte(0x02)); // sends light0 |
Wire.endTransmission(); // stop transmitting |
// Connect to device and request one byte |
Wire.beginTransmission(lights[arg]); |
Wire.requestFrom(lights[arg], 1); |
MSB = Wire.read(); |
Wire.endTransmission(); // stop transmitting |
return ((MSB << 8) + LSB); |
} |
int temperature (int arg) |
{ |
int i, temp; |
byte data[12]; |
if (OneWire::crc8 (addr[arg], 7) != addr[arg][7]) |
{ |
Serial.print("CRC is not valid!\n"); |
return 0; |
} |
ds.reset(); |
ds.select(addr[arg]); |
ds.write(0x44, 1); // start conversion, with parasite power on at the end |
delay(800); // maybe 750ms is enough, maybe not |
ds.reset(); |
ds.select(addr[arg]); |
ds.write(0xBE); // Read Scratchpad |
for ( i = 0; i < 9; i++) // we need 9 bytes |
{ |
data[i] = ds.read(); |
} |
temp = (data[1] << 8) + data[0]; //take the two bytes from the response relating to temperature |
// temp = temp >> 4; //divide by 16 to get pure celcius readout |
return temp; |
} |
void inicializace () |
{ |
// vysune se motor |
motor (1); |
// vsechny vystupy off |
// digitalWrite(LAMP1, LOW); |
// digitalWrite(LAMP2, LOW); |
digitalWrite(FW1, LOW); |
digitalWrite(FW2, LOW); |
digitalWrite(FW3, LOW); |
} |
void setup() |
{ |
// pinMode(LAMP1, OUTPUT); |
// pinMode(LAMP2, OUTPUT); |
pinMode(FW1, OUTPUT); |
pinMode(FW2, OUTPUT); |
pinMode(FW3, OUTPUT); |
pinMode(6, OUTPUT); |
//analogWrite(6, 254); |
digitalWrite(6, HIGH); |
// initialize the serial port: |
Serial.begin(9600); |
Wire.begin(); // join i2c bus |
// OneWire |
ds.reset_search(); |
if (!ds.search(addr[0])) // search for next thermometer |
{ |
Serial.print ("1st thermometer error."); |
ds.reset_search(); |
delay(250); |
return; |
} |
if (!ds.search(addr[1])) // search for next thermometer |
{ |
Serial.print ("2nd thermometer error."); |
ds.reset_search(); |
delay(250); |
return; |
} |
inicializace (); |
} |
void telemetrie () |
{ |
int t; |
Serial.print ("FW1="); |
Serial.print (digitalRead (filters[0]) ? '1' : '0'); |
Serial.print (",FW2="); |
Serial.print (digitalRead (filters[1]) ? '1' : '0'); |
Serial.print (",FW3="); |
Serial.print (digitalRead (filters[2]) ? '1' : '0'); |
Serial.print (",T1="); |
t=temperature(0); |
Serial.print (t >> 4); |
Serial.print ("."); |
Serial.print (deleni16[t & 0xf]); |
Serial.print (",T2="); |
t=temperature(1); |
Serial.print (t >> 4); |
Serial.print ("."); |
Serial.print (deleni16[t & 0xf]); |
Serial.print (",L1="); |
Serial.print (light (0)); |
Serial.print (",L2="); |
Serial.print (light (1)); |
Serial.println (); |
} |
void readSerialString () |
{ |
serInIndx=0; |
do |
{ |
while(Serial.available()==0); |
serInString[serInIndx] = Serial.read(); |
Serial.print(serInString[serInIndx]); |
serInIndx++; |
} while ((serInString[serInIndx-1]!='\n')&&(serInString[serInIndx-1]!='.')); |
Serial.print("\r\n="); |
} |
void loop() |
{ |
// readSerialString(); |
if (Serial.available()) |
{ |
switch (Serial.read()) |
{ |
case 'i': // inicializace |
inicializace (); |
break; |
case 'm': |
motor (-1); |
break; |
case 'M': |
motor (1); // vysunuto |
break; |
case 'x': |
myStepper.setSpeed(100); |
myStepper.step(3000); |
break; |
case 'y': |
myStepper.setSpeed(10.0); |
myStepper.step(-3000); |
break; |
case 'A': |
digitalWrite(FW1, HIGH); |
break; |
case 'a': |
digitalWrite(FW1, LOW); |
break; |
case 'B': |
digitalWrite(FW2, HIGH); |
break; |
case 'b': |
digitalWrite(FW2, LOW); |
break; |
case 'C': |
digitalWrite(FW3, HIGH); |
break; |
case 'c': |
digitalWrite(FW3, LOW); |
break; |
} |
telemetrie (); |
Serial.flush (); |
// /for (serInIndx = 100; serInIndx > 0; serInIndx--) |
// serInString[serInIndx] = ' '; |
} |
// delay(100); |
} |
/Designs/Spectrograph/SW/test_hw/test_hw.pde |
---|
0,0 → 1,261 |
#include <OneWire.h> |
#include <Stepper.h> |
#include <Wire.h> |
#define light0 0x44 // A0 = L (I2C light0) |
#define light1 0x45 // A0 = H (I2C light1) |
#define LAMP1 13 // Callibration Lamp 1 |
#define LAMP2 6 // Callibration Lamp 2 |
#define FW1 7 // FilterWheel 1 |
#define FW2 8 // FilterWheel 2 |
#define FW3 3 // FilterWheel 3 |
const int steps = 3500; //3200; // change this to fit the number of steps |
const int sspeed = 15; // stepper motor speed |
// initialize the stepper library on pins |
#define M1 9 |
#define M2 10 |
#define M3 11 |
#define M4 12 |
Stepper myStepper(steps, M1,M2,M3,M4); |
// DS18S20 Temperature chip |
OneWire ds(5); // 1-Wire pin |
byte addr[8]; // 1-Wire Address |
boolean sense; // Sense of revolution |
void setup() |
{ |
sense=true; |
pinMode(LAMP1, OUTPUT); |
pinMode(LAMP2, OUTPUT); |
pinMode(FW1, OUTPUT); |
pinMode(FW2, OUTPUT); |
pinMode(FW3, OUTPUT); |
pinMode(6, OUTPUT); |
analogWrite(6, 128); |
// initialize the serial port: |
Serial.begin(9600); |
Wire.begin(); // join i2c bus |
} |
void loop() |
{ |
while(TRUE); |
byte i,n; // for fors |
byte present = 0; // for 1-Wire |
byte data[12]; // data from temperature |
byte inByte; // RS232 data |
int dd=0; // data from light |
digitalWrite(LAMP1, HIGH); // All outputs OFF |
digitalWrite(LAMP2, HIGH); |
digitalWrite(FW1, HIGH); |
digitalWrite(FW2, HIGH); |
digitalWrite(FW3, HIGH); |
delay(300); |
digitalWrite(LAMP1, LOW); // blik |
//--------------------------------------------------------- Serial Input |
// if we get a valid byte |
if (Serial.available() > 0) |
{ |
// get incoming byte: |
inByte = Serial.read(); |
Serial.print("Incoming char: "); |
Serial.print( inByte, HEX); |
Serial.println(); |
} |
//--------------------------------------------------------- Motor |
if (sense) |
{ |
// one revolution in one direction |
Serial.println("clockwise"); |
myStepper.setSpeed(sspeed); |
myStepper.step(steps); |
delay(50); |
digitalWrite(M1, LOW); |
digitalWrite(M2, LOW); |
digitalWrite(M3, LOW); |
digitalWrite(M4, LOW); |
} |
else |
{ |
// one revolution in the other direction: |
Serial.println("counterclockwise"); |
myStepper.setSpeed(sspeed/2); |
myStepper.step(-30); |
myStepper.setSpeed(sspeed); |
myStepper.step(-(steps-50)); |
myStepper.setSpeed(sspeed/2); |
myStepper.step(-20); |
delay(50); |
digitalWrite(M1, LOW); |
digitalWrite(M2, LOW); |
digitalWrite(M3, LOW); |
digitalWrite(M4, LOW); |
} |
sense=!sense; |
digitalWrite(LAMP2, LOW); // blik |
//--------------------------------------------------------- 1-Wire bus |
ds.reset_search(); |
for(n=0;n<2;n++) |
{ |
if ( !ds.search(addr)) // search for next thermometer |
{ |
continue; |
} |
Serial.print("R="); |
for( i = 0; i < 8; i++) |
{ |
Serial.print(addr[i], HEX); |
Serial.print(" "); |
} |
if ( OneWire::crc8( addr, 7) != addr[7]) |
{ |
Serial.print("CRC is not valid!\n"); |
} |
ds.reset(); |
ds.select(addr); |
ds.write(0x44,1); // start conversion, with parasite power on at the end |
delay(800); // maybe 750ms is enough, maybe not |
digitalWrite(FW1, LOW); // blik |
present = ds.reset(); |
ds.select(addr); |
ds.write(0xBE); // Read Scratchpad |
Serial.print("P="); |
Serial.print(present,HEX); |
Serial.print(" "); |
for ( i = 0; i < 9; i++) { // we need 9 bytes |
data[i] = ds.read(); |
Serial.print(data[i], HEX); |
Serial.print(" "); |
} |
Serial.print(" CRC="); |
Serial.print( OneWire::crc8( data, 8), HEX); |
Serial.println(); |
} |
//------------------------------------------------------- Light 0 |
Serial.print("Light0: COMMAND="); |
// Setup device |
Wire.beginTransmission(light0); |
Wire.send(0x00); // command register |
Wire.send(0b11000000); // setup (eye light sensing; measurement range 1 [1000 lx]) |
Wire.endTransmission(); // stop transmitting |
// Delay for measurement, maybe 100ms is enough, maybe not |
delay(110); |
digitalWrite(FW2, LOW); // blik |
// Connect to device and set register light0 |
Wire.beginTransmission(light0); |
Wire.send(0x00); // sends light0 |
Wire.endTransmission(); // stop transmitting |
// Connect to device and request one byte |
Wire.beginTransmission(light0); |
Wire.requestFrom(light0, 1); |
dd = Wire.receive(); |
Wire.endTransmission(); // stop transmitting |
Serial.print(dd, HEX); |
Serial.print(" LSB="); |
// Connect to device and set register light0 |
Wire.beginTransmission(light0); |
Wire.send(0x01); // sends light0 |
Wire.endTransmission(); // stop transmitting |
// Connect to device and request one byte |
Wire.beginTransmission(light0); |
Wire.requestFrom(light0, 1); |
dd = Wire.receive(); |
Wire.endTransmission(); // stop transmitting |
Serial.print(dd, HEX); |
Serial.print(" MSB="); |
// Connect to device and set register light0 |
Wire.beginTransmission(light0); |
Wire.send(0x02); // sends light0 |
Wire.endTransmission(); // stop transmitting |
// Connect to device and request one byte |
Wire.beginTransmission(light0); |
Wire.requestFrom(light0, 1); |
dd = Wire.receive(); |
Wire.endTransmission(); // stop transmitting |
Serial.println(dd, HEX); |
//------------------------------------------------------- Light 1 |
Serial.print("Light1: COMMAND="); |
// Setup device |
Wire.beginTransmission(light1); |
Wire.send(0x00); // command register |
Wire.send(0b11000001); // setup (eye light sensing; measurement range 2 [4000 lx]) |
Wire.endTransmission(); // stop transmitting |
// Delay for measurement, maybe 100ms is enough, maybe not |
delay(110); |
digitalWrite(FW3, LOW); // blik |
// Connect to device and set register light0 |
Wire.beginTransmission(light1); |
Wire.send(0x00); // sends light0 |
Wire.endTransmission(); // stop transmitting |
// Connect to device and request one byte |
Wire.beginTransmission(light1); |
Wire.requestFrom(light1, 1); |
dd = Wire.receive(); |
Wire.endTransmission(); // stop transmitting |
Serial.print(dd, HEX); |
Serial.print(" LSB="); |
// Connect to device and set register light0 |
Wire.beginTransmission(light1); |
Wire.send(0x01); // sends light0 |
Wire.endTransmission(); // stop transmitting |
// Connect to device and request one byte |
Wire.beginTransmission(light1); |
Wire.requestFrom(light1, 1); |
dd = Wire.receive(); |
Wire.endTransmission(); // stop transmitting |
Serial.print(dd, HEX); |
Serial.print(" MSB="); |
// Connect to device and set register light0 |
Wire.beginTransmission(light1); |
Wire.send(0x02); // sends light0 |
Wire.endTransmission(); // stop transmitting |
// Connect to device and request one byte |
Wire.beginTransmission(light1); |
Wire.requestFrom(light1, 1); |
dd = Wire.receive(); |
Wire.endTransmission(); // stop transmitting |
Serial.println(dd, HEX); |
//-------------------------------------------------- Accelerometer |
Serial.print("X="); |
Serial.print(analogRead(A0)-512, DEC); |
Serial.print(" Y="); |
Serial.print(analogRead(A1)-512, DEC); |
Serial.print(" Z="); |
Serial.println(analogRead(A2)-512, DEC); |
} |
/Designs/Spectrograph/SW/test_hw/i2c_light/i2c_light.pde |
---|
0,0 → 1,141 |
// I2C Light Sensor |
#include <Wire.h> |
#define address 0x44 // A0 = L |
void setup() |
{ |
Wire.begin(); // join i2c bus (address optional for master) |
pinMode(3, OUTPUT); // LED pro blikani, aby bylo videt, ze to neco dela |
pinMode(5, OUTPUT); // LED pro blikani, aby bylo videt, ze to neco dela |
Serial.begin(9600); // Zmerena intenzita osvetleni se bude vypisovat na seriovou linku |
} |
int data = 0; |
void loop() |
{ |
int lux=0; |
Serial.print("lux="); |
// Setup device |
digitalWrite(5, HIGH); |
Wire.beginTransmission(address); |
Wire.send(0x00); // sends address |
Wire.send(0b11000000); // setup (eye light sensing; one time measurement; measurement range 1) |
Wire.endTransmission(); // stop transmitting |
// Delay for measurement |
{ |
long n; |
for(n=0;n<66000;n++) |
{ |
digitalWrite(5, LOW); // set the LED off |
// delay(500); |
digitalWrite(5, HIGH); // set the LED on |
delayMicroseconds(100); |
// delay(500); |
} |
} |
// Connect to device and set register address |
Wire.beginTransmission(address); |
Wire.send(0x00); // sends address |
Wire.endTransmission(); // stop transmitting |
// Connect to device and request one byte |
Wire.beginTransmission(address); |
Wire.requestFrom(address, 1); |
data = Wire.receive(); |
Wire.endTransmission(); // stop transmitting |
// Serial.print(data, HEX); |
// Serial.print(" LSB="); |
// Connect to device and set register address |
Wire.beginTransmission(address); |
Wire.send(0x01); // sends address |
Wire.endTransmission(); // stop transmitting |
// Connect to device and request one byte |
Wire.beginTransmission(address); |
Wire.requestFrom(address, 1); |
data = Wire.receive(); |
Wire.endTransmission(); // stop transmitting |
// Serial.print(data, HEX); |
lux=data; |
// Serial.print(" MSB="); |
// Connect to device and set register address |
Wire.beginTransmission(address); |
Wire.send(0x02); // sends address |
Wire.endTransmission(); // stop transmitting |
// Connect to device and request one byte |
Wire.beginTransmission(address); |
Wire.requestFrom(address, 1); |
data = Wire.receive(); |
Wire.endTransmission(); // stop transmitting |
// Serial.print(data, HEX); |
lux+=data*256; |
/* |
Serial.print((unsigned)lux, DEC); |
Serial.print(" luxIR="); |
// Setup device |
Wire.beginTransmission(address); |
Wire.send(0x00); // sends address |
Wire.send(0b11100000); // setup (eye light sensing; measurement range 2 [4000 lx]) |
Wire.endTransmission(); // stop transmitting |
// Delay for measurement |
digitalWrite(3, HIGH); // set the LED on |
delay(500); |
digitalWrite(3, LOW); // set the LED off |
delay(500); |
// Connect to device and set register address |
Wire.beginTransmission(address); |
Wire.send(0x00); // sends address |
Wire.endTransmission(); // stop transmitting |
// Connect to device and request one byte |
Wire.beginTransmission(address); |
Wire.requestFrom(address, 1); |
data = Wire.receive(); |
Wire.endTransmission(); // stop transmitting |
// Serial.print(data, HEX); |
// Serial.print(" LSB="); |
// Connect to device and set register address |
Wire.beginTransmission(address); |
Wire.send(0x01); // sends address |
Wire.endTransmission(); // stop transmitting |
// Connect to device and request one byte |
Wire.beginTransmission(address); |
Wire.requestFrom(address, 1); |
data = Wire.receive(); |
Wire.endTransmission(); // stop transmitting |
// Serial.print(data, HEX); |
lux=data; |
// Serial.print(" MSB="); |
// Connect to device and set register address |
Wire.beginTransmission(address); |
Wire.send(0x02); // sends address |
Wire.endTransmission(); // stop transmitting |
// Connect to device and request one byte |
Wire.beginTransmission(address); |
Wire.requestFrom(address, 1); |
data = Wire.receive(); |
Wire.endTransmission(); // stop transmitting |
// Serial.print(data, HEX); |
lux+=data*256; |
*/ |
Serial.println((unsigned)lux, DEC); |
} |
/Designs/Spectrograph/SW/test_hw/motor/motor.pde |
---|
0,0 → 1,109 |
#include <OneWire.h> |
#include <Stepper.h> |
const int stepsPerRevolution = 3200; // change this to fit the number of steps per revolution |
// for your motor |
byte sense=0; |
// initialize the stepper library on pins |
Stepper myStepper(stepsPerRevolution, 9,10,11,12); |
// DS18S20 Temperature chip |
OneWire ds(1); // 1-Wire |
byte addr[8]; // Addres |
void setup() |
{ |
pinMode(13, OUTPUT); // LED |
digitalWrite(13, LOW); // LED ON |
// initialize the serial port: |
Serial.begin(9600); |
// set the speed |
myStepper.setSpeed(8); |
// search for DS |
if ( !ds.search(addr)) |
{ |
ds.reset_search(); |
delay(250); |
return; |
} |
if ( OneWire::crc8( addr, 7) != addr[7]) |
{ |
Serial.print("CRC is not valid!\n"); |
return; |
} |
} |
void loop() |
{ |
byte i; |
byte present = 0; |
byte data[12]; |
byte inByte; |
// if we get a valid byte |
//!!! if (Serial.available() > 0) |
{ |
// get incoming byte: |
//!!! inByte = Serial.read(); |
if(sense) |
{ |
digitalWrite(0, LOW); // blik |
// step one revolution in one direction: |
Serial.println("clockwise"); |
myStepper.step(stepsPerRevolution); |
delay(50); |
digitalWrite(9, LOW); |
digitalWrite(10, LOW); |
digitalWrite(11, LOW); |
digitalWrite(12, LOW); |
delay(500); |
sense=0; |
} |
else |
{ |
digitalWrite(0, HIGH); // blik |
// step one revolution in the other direction: |
Serial.println("counterclockwise"); |
myStepper.step(-stepsPerRevolution); |
delay(50); |
digitalWrite(9, LOW); |
digitalWrite(10, LOW); |
digitalWrite(11, LOW); |
digitalWrite(12, LOW); |
delay(500); |
sense=1; |
} |
// 1-Wire bus |
ds.reset(); |
ds.select(addr); |
ds.write(0x44,1); // start conversion |
delay(1000); // maybe 750ms is enough, maybe not |
present = ds.reset(); |
ds.select(addr); |
ds.write(0xBE); // Read Scratchpad |
Serial.print("P="); |
Serial.print(present,HEX); |
Serial.print(" "); |
for ( i = 0; i < 9; i++) // we need 9 bytes |
{ |
data[i] = ds.read(); |
Serial.print(data[i], HEX); |
Serial.print(" "); |
} |
Serial.print(" CRC="); |
Serial.print( OneWire::crc8( data, 8), HEX); |
Serial.println(); |
} |
} |