Show Posts
Pages: [1] 2 3 ... 9
1  Community / Exhibition / Gallery / Re: Amiga MOD Player on Arduino Uno on: July 22, 2013, 01:54:41 am
Impressive!
You sent me back to 1994 for a minute smiley
2  Community / Exhibition / Gallery / Re: Voice Controlled Front Door Opener on: July 16, 2013, 09:33:49 am
Great presentation, does it work for Scottish accent?

3  Community / Exhibition / Gallery / Re: Small server/logger/gateway based on ATMEGA1284 on: July 05, 2013, 01:51:06 am
Great project,
I have done similar work, but using Atmga328+ENC28j60+RFM12B; I was always running short on resources, but then had no compatibility issues
4  Development / Other Hardware Development / Re: discussion on supporting the TI CC3000 WiFi module on: June 21, 2013, 02:11:35 am
There is a guy that published eagle design files for a CC3000 breakout

http://centerblack.com/

5  Development / Other Hardware Development / Re: discussion on supporting the TI CC3000 WiFi module on: June 17, 2013, 01:45:13 pm
I'd love to see this ported.

Some similar qustions being discussed here: http://e2e.ti.com/support/low_power_rf/f/851/p/260521/911920.aspx

Quote
void SpiPauseSpi(void)
{
   SPI_IRQ_PORT &= ~SPI_IRQ_PIN;
}
void SpiResumeSpi(void)
{
   SPI_IRQ_PORT |= SPI_IRQ_PIN;
}
As far I understand these functions enable or disabled the IRQ_SPI Line in your Microcontroller, and in case of CC3000 produce a falling edge in the IRQ Pin it would not be treated

I do the same using a Flag
void SpiPauseSpi(void)
{
  irq_flag=0;
}
void SpiResumeSpi(void)
{
  irq_flag=1;
}


6  Community / Exhibition / Gallery / Re: ATTiny85 4minute shower timer on: May 26, 2013, 01:09:03 pm
The 100K cycles is highly pessimistic (I know the datasheet), a guy tested hat out to find 1.2M erase/write cycles before it failed
http://hackaday.com/2011/05/16/destroying-an-arduinos-eeprom/

Another idea to save pins would be to use this way of wiring LEDs, it allows two per pin: http://www.josepino.com/?led_chaser2

Nice project anyway.
7  Community / Exhibition / Gallery / Re: 2*2 cm cut-off Arduino Leonardo with radio module on: April 23, 2013, 11:54:39 pm
Curious to why you ran the pin holes in a slalom configuration?

So that you can plug pin headers without soldering them.. for quick testing
8  Community / Exhibition / Gallery / 2*2 cm cut-down Arduino Leonardo with radio module on: April 20, 2013, 11:06:49 am
Hi guys,

I have been working on a miniature, low power wireless remote node based on the ATmega32U4 MCU (the same used in Leonardo Arduino). This is a Open Source Project, all design files and documentation is available here: http://harizanov.com/wiki/wiki-home/funky-sensor-v2/.
I wish to say that I am amateur, only started learning electronics on hobby level recently.

The highlights are:
  • 2*2 cm in size, only few mm thick
  • can be powered from a CR2032 coin cell
  • 0.04mA @ 3V in sleep mode
  • Programmed via the USB - just like Arduino Leonardo
  • Has a RFM12B radio module for wireless communication with other sensor nodes or another node acting as a gateway (logging the data or forwarding it to the Internet)
  • Option for on-board voltage step-up boost regulator

I build these by hand using hot air gun - a slow process, but the outcome is beautiful:



Comments are welcome smiley
9  Using Arduino / Programming Questions / Re: no matching function for call to 'SerialIPStack::use_device(Serial_&)' on: March 19, 2013, 10:14:18 am
It's the included example:
https://raw.github.com/beaucollins/arduino-projects/master/libraries/SerialIP/examples/HelloWorldServer/HelloWorldServer.pde

Code:
/*
 * SerialIP Hello World example.
 *
 * SerialIP is a TCP/IP stack that can be used over a serial port (a bit
 * like a dial-up Internet connection, but without the modem.)  It works with
 * stock Arduinos (no shields required.)  When attached to a PC supporting
 * SLIP, the Arduino can host network servers and access the Internet (if the
 * PC is configured to share its Internet connection of course!)
 *
 * SerialIP uses the fine uIP stack by Adam Dunkels <adam@sics.se>
 *
 * For more information see the SerialIP page on the Arduino wiki:
 *   <http://www.arduino.cc/playground/Code/SerialIP>
 *
 *      -----------------
 *
 * This Hello World example sets up a server at 192.168.5.2 on port 1000.
 * Telnet here to access the service.  The uIP stack will also respond to
 * pings to test if you have successfully established a SLIP connection to
 * the Arduino.
 *
 * SLIP connection set up under Linux:
 *
 *  # modprobe slip
 *  # slattach -L -s 115200 -p slip /dev/ttyUSB0     (see note below)
 *  # ifconfig sl0 192.168.5.1 dstaddr 192.168.5.2
 *
 *  # ping 192.168.5.2
 *  # telnet 192.168.5.2 1000
 *
 * Here 192.168.5.1 is the address you will give to your PC, and it must be
 * unique on your LAN.  192.168.5.2 is the IP you will give the Arduino.  It
 * must also be unique, and must match the address the Arduino is expecting
 * as set by the "myIP" variable below.
 *
 * Note that slattach won't return so you'll need to run ifconfig from
 * another terminal.  You can press Ctrl+C to kill slattach and release the
 * serial port, e.g. to upload another sketch.
 *
 * This example was based upon uIP hello-world by Adam Dunkels <adam@sics.se>
 * Ported to the Arduino IDE by Adam Nielsen <malvineous@shikadi.net>
 */

#include <SerialIP.h>

// The connection_data struct needs to be defined in an external file.
#include "HelloWorldData.h"

void setup() {

  // Set up the speed of our serial link.
  Serial.begin(115200);

  // Tell SerialIP which serial port to use (some boards have more than one.)
  // Currently this is limited to HardwareSerial ports, until both it and
  // SoftwareSerial inherit from a common base class.
  SerialIP.use_device(Serial);

  // We're going to be handling uIP events ourselves.  Perhaps one day a simpler
  // interface will be implemented for the Arduino IDE, but until then... 
  SerialIP.set_uip_callback(uip_callback);

  // Set the IP address we'll be using.  Make sure this doesn't conflict with
  // any IP addresses or subnets on your LAN or you won't be able to connect to
  // either the Arduino or your LAN...
  IP_ADDR myIP = {192,168,5,2};
  IP_ADDR subnet = {255,255,255,0};
  SerialIP.begin(myIP, subnet);

  // If you'll be making outgoing connections from the Arduino to the rest of
  // the world, you'll need a gateway set up.
  //IP_ADDR gwIP = {192,168,5,1};
  //SerialIP.set_gateway(gwIP);

  // Listen for incoming connections on TCP port 1000.  Each incoming
  // connection will result in the uip_callback() function being called.
  SerialIP.listen(1000);
}

void loop() {
  // Check the serial port and process any incoming data.
  SerialIP.tick();

  // We can do other things in the loop, but be aware that the loop will
  // briefly pause while IP data is being processed.
}

void uip_callback(uip_tcp_appstate_t *s)
{
  if (uip_connected()) {

    // We want to store some data in our connections, so allocate some space
    // for it.  The connection_data struct is defined in a separate .h file,
    // due to the way the Arduino IDE works.  (typedefs come after function
    // definitions.)
    connection_data *d = (connection_data *)malloc(sizeof(connection_data));

    // Save it as SerialIP user data so we can get to it later.
    s->user = d;

    // The protosocket's read functions need a per-connection buffer to store
    // data they read.  We've got some space for this in our connection_data
    // structure, so we'll tell uIP to use that.
    PSOCK_INIT(&s->p, d->input_buffer, sizeof(d->input_buffer));

  }

  // Call/resume our protosocket handler.
  handle_connection(s, (connection_data *)s->user);

  // If the connection has been closed, release the data we allocated earlier.
  if (uip_closed()) {
    if (s->user) free(s->user);
    s->user = NULL;
  }
}

// This function is going to use uIP's protosockets to handle the connection.
// This means it must return int, because of the way the protosockets work.
// In a nutshell, when a PSOCK_* macro needs to wait for something, it will
// return from handle_connection so that other work can take place.  When the
// event is triggered, uip_callback() will call this function again and the
// switch() statement (see below) will take care of resuming execution where
// it left off.  It *looks* like this function runs from start to finish, but
// that's just an illusion to make it easier to code :-)
int handle_connection(uip_tcp_appstate_t *s, connection_data *d)
{
  // All protosockets must start with this macro.  Its internal implementation
  // is that of a switch() statement, so all code between PSOCK_BEGIN and
  // PSOCK_END is actually inside a switch block.  (This means for example,
  // that you can't declare variables in the middle of it!)
  PSOCK_BEGIN(&s->p);

  // Send some text over the connection.
  PSOCK_SEND_STR(&s->p, "Hello. What is your name?\n");

  // Read some returned text into the input buffer we set in PSOCK_INIT.  Data
  // is read until a newline (\n) is received, or the input buffer gets filled
  // up.  (Which, at 16 chars by default, isn't hard!)
  PSOCK_READTO(&s->p, '\n');

  // Since any subsequent PSOCK_* functions would overwrite the buffer, we
  // need to make a copy of it first.  We can't use a local variable for this,
  // because any PSOCK_* macro may make the function return and resume later,
  // thus losing the data in any local variables.  This is why uip_callback
  // has allocated the connection_data structure for us to use instead.  (You
  // can add/remove other variables in this struct to store different data.
  // See the other file in this sketch, serialip_conn.h)
  strncpy(d->name, d->input_buffer, sizeof(d->name));
  // Note that this will misbehave when the input buffer overflows (i.e.
  // more than 16 characters are typed in) but hey, this is supposed to be
  // a simple example.  Fixing this problem will be left as an exercise for
  // the reader :-)

  // Send some more data over the connection.
  PSOCK_SEND_STR(&s->p, "Hello ");
  PSOCK_SEND_STR(&s->p, d->name);

  // Disconnect.
  PSOCK_CLOSE(&s->p);

  // All protosockets must end with this macro.  It closes the switch().
  PSOCK_END(&s->p);
}

10  Using Arduino / Programming Questions / no matching function for call to 'SerialIPStack::use_device(Serial_&)' on: March 19, 2013, 10:02:48 am
Hi,

I am trying to set the SerialIP example ( http://playground.arduino.cc/Code/SerialIP ) working on an Arduino Leonardo, but I am getting
Code:
no matching function for call to 'SerialIPStack::use_device(Serial_&)'

on this line:  SerialIP.use_device(Serial);

If I replace "Serial" with "Serial1" (the hardware serial) all compiles, but I don't want the Serial1, but the CDC virtual Serial port so I can plug the Arduino to a Linux box.

The comment to the above line states
Quote
  // Tell SerialIP which serial port to use (some boards have more than one.)
  // Currently this is limited to HardwareSerial ports, until both it and
  // SoftwareSerial inherit from a common base class.

but I am sure there has to be a way to pass the serial as argument. Please help  smiley-red
11  Using Arduino / Microcontrollers / Re: Custom atmega32u4+RFM12b board: high current draw in sleep mode on: March 13, 2013, 03:04:53 pm
OK I think I found the issue, I was powering the board from a quite noisy 3.3V source therefore mu multimer was going crazy. Powering from couple AA batteries gives me now 0.13mA, which is still high, but much better. I will see how I can get that even lower
12  Using Arduino / Microcontrollers / Custom atmega32u4+RFM12b board: high current draw in sleep mode on: March 13, 2013, 07:17:03 am
Guys,

I am trying go get a FOSS project going, namely a miniature, battery operated atmega32u4 node with a RFM12B module on it, called it 'Funky'.
I am very unexperienced, just recently started hobby level learning electronics, so please be forgiving.

Wiki page http://harizanov.com/wiki/wiki-home/funky-sensor-v2/

Schematic:

http://harizanov.com/wp-content/uploads/2013/03/IMG_2007-1024x768.jpg





So my trouble is that I can't get decent sleep currents, the lowest I get is 3mA using this Arduino code:



Code:

#include <avr/power.h>
#include <avr/sleep.h>

#include <JeeLib.h> // https://github.com/jcw/jeelib
#include "pins_arduino.h"

ISR(WDT_vect) { Sleepy::watchdogEvent(); } // interrupt handler for JeeLabs Sleepy power saving

#define myNodeID 27      // RF12 node ID in the range 1-30
#define network 210      // RF12 Network group
#define freq RF12_868MHZ // Frequency of RFM12B module

#define LEDpin 1


void setup() {

  pinMode(LEDpin,OUTPUT);
  digitalWrite(LEDpin,HIGH);

  rf12_initialize(myNodeID,freq,network); // Initialize RFM12 with settings defined above
  // Adjust low battery voltage to 2.2V
  rf12_control(0xC040);
  rf12_sleep(0);                          // Put the RFM12 to sleep
 
  digitalWrite(LEDpin,LOW);
     
  power_adc_disable();
  power_usart0_disable();
  //power_spi_disable();
  power_twi_disable();
  //Leave timer 0 going for delay() function
  power_timer1_disable();
  power_timer2_disable();
  power_timer3_disable();
  power_usart1_disable();

   // Datasheet says that to power off the USB interface we have to do 'some' of:
   //       Detach USB interface
   //      Disable USB interface
   //      Disable PLL
   //      Disable USB pad regulator

   // Disable the USB interface
   USBCON &= ~(1 << USBE);
   
   // Disable the VBUS transition enable bit
   USBCON &= ~(1 << VBUSTE);
   
   // Disable the VUSB pad
   USBCON &= ~(1 << OTGPADE);
   
   // Freeze the USB clock
   USBCON &= ~(1 << FRZCLK);
   
   // Disable USB pad regulator
   UHWCON &= ~(1 << UVREGE);
   
   // Clear the IVBUS Transition Interrupt flag
   USBINT &= ~(1 << VBUSTI);
   
   // Physically detact USB (by disconnecting internal pull-ups on D+ and D-)
   UDCON |= (1 << DETACH);

   digitalWrite(LEDpin,LOW);

   cli();
 
  SMCR |=(1<<SM1);//Power down
  SMCR |=(1<<SE); //Enable sleep mode
  __asm__ __volatile__ ("sleep" "\n\t" :: );


// I expect uA readings here, but get 3mA...
   
}

void loop() {
 
}



Any tips are welcome, is it a hardware design issue, or software consideration?

[edit] I realize I didn't mention it, but I power the board from a 3.3V source directly at the VCC pin.
I don't have the  LTC3525 boost regulator circuitry poplated for this board build, jut the MCP1703. I tried completely unsoldering it after I programmed the board with the test sketch, but no improvement happened. I also experimented with fuses, disabling BOD, switching clock source from the external crystal to internal one.
13  Community / Exhibition / Gallery / Re: Arduino and MLX90620 16X4 pixel IR thermal array on: October 09, 2012, 03:51:45 am
Thanks for sharing,
I tried to order from there some time ago, but shipping cost to Europe was ridiculous, almost the price of the sensor itself.
Does anyone know an EU source of this?

14  Using Arduino / Microcontrollers / Re: Bootloader for Tiny chips? on: August 26, 2012, 08:37:50 am
Tom, this is great news. I have quite a few projects on Attiny84 and have been looking for a bootloading solution for quite some time now..

Do you plan to document this and release your modifications? edit: got too excited and didn't read carefully smiley
15  Using Arduino / Microcontrollers / Re: New optiboot; beta testers welcome... on: August 02, 2012, 08:55:11 am
Apologies first, if this doesn't belong here.

I have started a separate thread on my issues trying to get optiboot run on Attiny84. http://arduino.cc/forum/index.php?topic=108989.0
I have come to a dead end, although Luminet (Attiny84 based) is said to work, I couldn't get results. If someone has walked that path, please advice on any tricks that need to be pulled down the sleeve.

Thanks
Pages: [1] 2 3 ... 9