Read more on MAKE

[StrangeMeadowlark] decided one day to create this badass Arduino-based gaming controller. Not for any particular reason, other than, why the heck not?!

It looks like a tiny Lego spaceship that has flown in from a nearby planet, zooming directly into the hands of an eager Earthling gamer. With buttons of silver, this device can play Portal 1 and 2, Garry’s Mod, Minecraft, and VisualBoy Advance. Although more work is still needed, the controller does the job; especially when playing Pokemon. It feels like a Gameboy interface, with a customizable outer frame.

Sticky, blue-tack holds a few wires in place. And, most of the materials are items that were found around the house. Like the gamepad buttons on top; they are ordinary tactile switches that can be extracted from simple electronics. And the Legos, which provide an easy way to build out the body console, rather than having to track down a 3D printer and learning AutoCAD.

Communication between the PC and the Arduino inside is done by having the controller pretend to be a USB keyboard, allowing for in-game mapping of the keys. Key presses are sent to the Serial-to-USB chip in buffer specific to the firmware. Not to mention, it gives the option to browse Imgur if the urge arises.

For future iterations, Joysticks might be added. It will take some time to integrate them into the controller, but it will be worth the effort. Another implementation will be the utilization of gamepad firmware instead of emulating a keyboard, which doesn’t report analog values.

Other Lego projects similar to this include this two-axis panning time lapse rig, this custom electronic Lego microcontroller system called the LegoDuino, this obstacle avoiding LEGO rover with CD wheels, this Lego Drawing Machine, and this DIY Spectrophotometer.

Read more on MAKE

David Huerta is a technologist who recently published a provocative work to make everyone think a little bit more about privacy and what governments should be allowed to do or not:

I work outside the Pokemon business model of catching every user’s data or abusing it for state surveillance. I work instead surrounded by priceless art and in giving it a voice inside and outside the thick, Faraday cage walls of the museum it lives in.

He created an encrypted mixtape and sent it to NSA. The device runs on Arduino and other open hardware and for David is a:

machinery that can be trusted not to spy on you because of the disclosure of its design, schematics and bill of materials to anyone who wishes to inspect, build, or build upon the device. The device contains a soundtrack for the modern surveillance state. It’s designed to be enjoyed only by people I have consented it to be listened to. A second copy of this device will also be sent to the NSA’s headquarters in Maryland, but without the private key needed to decrypt it; a reminder that the rules of mathematics are more powerful than the rules of even the most powerful states.

We got in touch with him and was happy to answer a couple of questions for the blog:

Z: What makes you more uncomfortable about NSA actions which made you react and build this device?

D: The NSA’s mass surveillance encompasses a lot of programs which run counter to what I feel is a fundamental right to privacy. In the US Constitution there’s an expression of that in its fourth amendment.
What the NSA is doing goes against the spirit of that much like petting a cat backwards; It’s the wrong direction to go towards and a cat/society will swipe its paw at the offender.

Z: Arduino community is always interested in understanding how things are made. Where we can find source code and technical specs to build one? It would be great if we all could share more practical knowledge on these topics.

D: The mixtape device is basically just an Arduino and Adafruit wave shield. The code to play each wave file on the SD card on a loop (when unencrypted) is right off their list of examples.
I made one slight modification, which is to turn on a purple LED to indicate when it’s working. Purple is not an easy LED color to source, but it’s the global Pirate Party color and I wanted to give them subtle props for working towards a free and secure internet on the policy side of things.

I will at some point publish a way to do the encryption part of this using a Beaglebone Black and CryptoCape to make it a fully open hardware proof-of-concept, but in this case the SD card encryption was done off-device. I also plan on going through a full tutorial based on that at this year’s Open Hardware Summit in Rome.

Z: You said: “The NSA can read my stupid Facebook updates but without my consent it will never be able to listen to my kick-ass mix tape, even if it’s sitting right in front of them.” – What makes you believe that your encryption is strong enough?

D: The truth is that everyone sucks at information security, including myself, so no one can really make the claim something they’ve built is “NSA-proof.” Generally though, the less hardware and software you have, the less complexity and thus, opportunity for attack vectors or human errors there are. The playlist was kept offline, is not on the Arduino sketch, or anywhere in the hardware except encrypted in the SD card. The only place the audio existed aside from in the various sources I collected it from was on the hard drive of the PC I used to compose the mix tape, which has since been removed and stored offsite and offline. The encryption was also ran by a different machine, and one that I generally keep on my person. This goes beyond mass surveillance capabilities and into TAO/FBI “partyvan” surveillance; I can’t imagine an intelligence analyst is going to go to their very serious boss to explain that they need to expense a vehicle to go after some guy’s mix tape in a city where they won’t even be able to find a parking spot close enough to run a tempest attack from.

ZDo you have the pictures of the inside showing the components and the circuits?

D: They’re not too exciting since its just the Arduino + Wave Shield, but I attached a photo of the unencrypted version (clear acrylic instead of red clear acrylic), which I’ll also be bringing with me to the Open Hardware Summit.

Looking forward to meet him at Open Hadware Summit!

[Joakim] has built a clock that spells out the time in words. Wait a second – word clock, what is this, 2009? Word clocks are one of those projects that have become timeless. When we see a build that stands out, we make sure to write it up. [Joakim's] clock is special for a number of reasons. The time is spelled out in Norwegian, and since the clock is a birthday gift for [Daniel], [Joakim] added the his full name to the clock’s repertoire.

One of the hard parts of word clock design is controlling light spill. [Joakim] used a simple 3D printed frame to box each LED in. This keeps the spill under control and makes everything easier to read. The RGB LED’s [Joakim] used are also a bit different from the norm. Rather than the WS2812 Neopixel, [Joakim] used LPD8806 LED strips. On the controller side [Joakim] may have gone a bit overboard in his choice of an Arduino Yun, but he does put the ATmega328 and Embedded Linux machine to good use.

The real magic happens at boot. [Daniel's] name lights up in red, with various letters going green as each step completes. A green ‘D’ indicates an IP address was obtained from the router’s DHCP server. ‘N’ switches to green when four NTP servers have been contacted, and the Linux processor is reasonably sure it has the correct time. The last letter to change will be the ‘E’, which reports ambient light.

[Joakim] added a web interface to trigger his new features, such as a rainbow color palette, or the ability to show minutes by changing the color of the letters K,L,O,K. The final result is a slick package, which definitely brings a 2009 era design up to 2014 standards!

WARNING: Please check whether you can legally use RF transmitters and receivers at your location before attempting this project (or buying the components). This project is aimed at those who are looking to automate their home.

Carrying on from my previous "433MHz transmitter and receiver" tutorials (1,2 & 3): I have thrown away the need to process the signal with a computer. This means that we can now get the Arduino to record the signal from an RF remote (in close proximity), and play it back in no time at all.

The Arduino will forget the signal when powered down or when the board is reset. The Arduino does not have an extensive memory - there is a limit to how many signals can be stored on the board at any one time. Some people have opted to create a "code" in their projects to help maximise the number of signals stored on the board. In the name of simplicity, I will not encode the signal like I did in my previous tutorials.

I will get the Arduino to record the signal and play it back - with the help of a button. The button will help manage the overall process, and control the flow of code.

Apart from uploading the sketch to the Arduino, this project will not require the use of a computer. Nor will it need a sound card, or any special libraries. Here are the parts required:

 

Parts Required:

• Arduino UNO or compatible board
• Breadboard
• Button
• Red and Green LED
• 330 ohm resistor(s)
• Wires
• RF Module (433 Mhz) - Transmitter and Receiver pair or the 315 Mhz version
• Mercator Ceiling Fan/Light with Remote

Fritzing Sketch

 

 
 

Arduino Sketch

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127

/*    433 MHz RF REMOTE REPLAY sketch       Written by ScottC 24 Jul 2014      Arduino IDE version 1.0.5      Website: http://arduinobasics.blogspot.com      Receiver: XY-MK-5V      Transmitter: FS1000A/XY-FST      Description: Use Arduino to receive and transmit RF Remote signal            ------------------------------------------------------------- */    #define rfReceivePin A0     //RF Receiver data pin = Analog pin 0  #define rfTransmitPin 4  //RF Transmitter pin = digital pin 4  #define button 6           //The button attached to digital pin 6  #define ledPin 13        //Onboard LED = digital pin 13    const int dataSize = 500; //Arduino memory is limited (max=1700)  byte storedData[dataSize]; //Create an array to store the data  const unsigned int threshold = 100; //signal threshold value  int maxSignalLength = 255; //Set the maximum length of the signal  int dataCounter = 0; //Variable to measure the length of the signal  int buttonState = 1; //Variable to control the flow of code using button presses  int buttonVal = 0; //Variable to hold the state of the button  int timeDelay = 105; //Used to slow down the signal transmission (can be from 75 - 135)  void setup(){    Serial.begin(9600); //Initialise Serial communication - only required if you plan to print to the Serial monitor    pinMode(rfTransmitPin, OUTPUT);    pinMode(ledPin, OUTPUT);    pinMode(button, INPUT);  }    void loop(){    buttonVal = digitalRead(button);       if(buttonState>0 && buttonVal==HIGH){      //Serial.println("Listening for Signal");      initVariables();      listenForSignal();    }        buttonVal = digitalRead(button);        if(buttonState<1 && buttonVal==HIGH){      //Serial.println("Send Signal");      sendSignal();    }        delay(20);  }      /* ------------------------------------------------------------------------------      Initialise the array used to store the signal      ------------------------------------------------------------------------------*/  void initVariables(){    for(int i=0; i<dataSize; i++){      storedData[i]=0;    }    buttonState=0;  }      /* ------------------------------------------------------------------------------      Listen for the signal from the RF remote. Blink the RED LED at the beginning to help visualise the process      And also turn RED LED on when receiving the RF signal      ------------------------------------------------------------------------------ */  void listenForSignal(){    digitalWrite(ledPin, HIGH);    delay(1000);    digitalWrite(ledPin,LOW);    while(analogRead(rfReceivePin)<threshold){      //Wait here until an RF signal is received    }    digitalWrite(ledPin, HIGH);        //Read and store the rest of the signal into the storedData array    for(int i=0; i<dataSize; i=i+2){             //Identify the length of the HIGH signal---------------HIGH       dataCounter=0; //reset the counter       while(analogRead(rfReceivePin)>threshold && dataCounter<maxSignalLength){         dataCounter++;       }         storedData[i]=dataCounter;    //Store the length of the HIGH signal                   //Identify the length of the LOW signal---------------LOW       dataCounter=0;//reset the counter       while(analogRead(rfReceivePin)<threshold && dataCounter<maxSignalLength){         dataCounter++;       }       storedData[i+1]=dataCounter;  //Store the length of the LOW signal    }          storedData[0]++;  //Account for the first AnalogRead>threshold = lost while listening for signal      digitalWrite(ledPin, LOW);  }      /*------------------------------------------------------------------------------     Send the stored signal to the FAN/LIGHT's RF receiver. A time delay is required to synchronise     the digitalWrite timeframe with the 433MHz signal requirements. This has not been tested with different     frequencies.     ------------------------------------------------------------------------------ */  void sendSignal(){    digitalWrite(ledPin, HIGH);    for(int i=0; i<dataSize; i=i+2){        //Send HIGH signal        digitalWrite(rfTransmitPin, HIGH);        delayMicroseconds(storedData[i]*timeDelay);        //Send LOW signal        digitalWrite(rfTransmitPin, LOW);        delayMicroseconds(storedData[i+1]*timeDelay);    }    digitalWrite(ledPin, LOW);    delay(1000);            /*-----View Signal in Serial Monitor    for(int i=0; i<dataSize; i=i+2){        Serial.println("HIGH,LOW");        Serial.print(storedData[i]);        Serial.print(",");        Serial.println(storedData[i+1]);    }    ---------------------------------- */  }

 

Now let's see this project in action !

Have a look at the video below to see the Arduino turning a light and fan on/off shortly after receiving the RF signal from the RF remote. The video will also show you how to put this whole project together - step by step.

The Video

 

However, if you do not have a google profile...
Feel free to share this page with your friends in any way you see fit.

Intel may reign supreme in the desktop and laptop space, but ARM is eating its lunch almost everywhere else. That's not something the chipmaker can ignore, which is why it's having another crack at the hobby / developer market with Sharks Cove. The board, designed with Microsoft, has the stated aim of helping developers build apps and drivers for Windows and Android devices that use Intel chips. Since it's also available for everyone else to buy, it could also be quietly positioned as a more powerful alternative to boards like Arduino and Raspberry Pi. Unfortunately, as with the NUC, there's a catch: the board will retail for $300.

Filed under: Desktops, Microsoft, Intel

Comments

Via: Ars Technica, Gizmodo

Source: MSDN, Mouser, SharksCove

For the last couple of days I’ve been working on designing and building a PWM controller capable of handling moderately large currents at modest voltages (5A @ 9V). I don’t need high PWM frequency (4kHz should be plenty), but some of the loads I’m thinking of are rather nonlinear (very little current at low voltages, large but constant current at higher voltages).

I decided to try using an ATtiny chip as the PWM controller, because they are very cheap and can be programmed from the Arduino IDE (using an Arduino board as the ISP programmer).  I first prototyped the design using a Arduino ProMini (so I could add debugging statements and not have to worry about the 1kByte flash limitation of the ATtiny13A).  Once that was working, I rewrote the code for the ATtiny, doing some hand optimization to reduce the code size. I got it down to 880 bytes, but I can see why C is more popular than C++ for the really tiny processors—the C++ and Arduino overhead accounts for about 150 of the 1k bytes of flash!  I could make my code much smaller if I made it more special purpose and did everything in C rather than C++, but once it fit in the 1024 bytes, I stopped worrying about the size.

PWM controller using ATtiny 13A

The design I came up with uses a low-dropout regulator to provide 5V for the ATtiny13A. A potentiometer provides analog input and a nFET provides a low-resistance switch for the output. I used the AOI518, because I have some on hand, but they are reaching the “end of life” so some other nFET may need to be used in a future design (perhaps one of the others in the series, such as the AOI516 which has a slightly lower on-resistance but a slightly higher gate capacitance).

The capacitors C1 and C2 are to keep the switching of the large load from propagating spikes into power supply.  The 470µF capacitor with a 5A current spike should limit the voltage slew to 10.6V/ms—with a 4.7kHz current square wave, this would be about a 1.1V triangle wave.  A polymer electrolytic is used (despite the price) to keep the effective series resistance small.  The one I’m using has an ESR of 9mΩ (@100kHz) and a ripple current up to 6.1A.  The leakage current could be as high as 1.5mA though.  C1 is a small ceramic capacitor to remove higher-frequency noise.  The big Schottky diode on the input is just to provide protection against accidentally hooking the circuit up backwards. I should probably add a 60¢ resettable fuse as well, to keep the current from getting excessive if there is a short.

When there is no load, the maximum current draw is 1.9mA for the pullup resistor R2, 0.9mA for the pot, 4–6mA for the ATtiny13A, and up to 1.5mA for C2, for a total of 8.3–10.3mA.  With a typically 80% efficient 9v switching power supply, this is a waste of about 100mW, or about 0.9kWh/year.

The pullup resistor R2 is not strictly necessary, but was added to keep the PWM pulses clean, turning all the way off even when the load had only tiny current draw—otherwise I could not get very low duty-cycle pulses to work well—the nFET acted as if it were a 1.3nF capacitor and kept a low voltage even when the nFET was off.  With the 4.7kΩ pullup, the voltage goes up appropriately, with a time constant of about 6µs.

So far, I’ve not tried the circuit with a large load—just with a small load that takes 13mA.  With that tiny a load, I don’t see any ripple in the power supply from the PWM.  With a 210mA load, the ripple on the power supply is noticeable: on top of the 20mV of ripple at about 20MHz with no load, I see 30mV of ripple synchronized with the switching of the PWM, when switching 210mA with a duty cycle of 1/2.  Without the 470µF polymer capacitor, the synchronized ripple is more like 200mV, indicating that the capacitor is indeed smoothing out the ripple.

The 30mV swing on 210mA implies that I should see about a 710mV swing if switching 5A.   That shouldn’t cause a problem in my design, but I do need to allow a little more voltage so that the swing isn’t a problem.  I could also use a bigger capacitor, but the polymer electrolytics are a bit expensive, and the regular wet electrolytics can’t handle a big ripple current—one with the same 6A ripple current rating would be 20 times the volume and 3 times the price of the polymer capacitor.

The high-frequency noise is almost certainly coming from the ATtiny, as it is synchronized with the PWM signal. The 5V power supply at the ATtiny is showing a 40mV ripple, which is large considering that there is a bypass capacitor on the Vdd pin.  There is a lot of inductance from the wiring on the board though, which could be increasing the propagation of the high-frequency noise.

For the last couple of days I’ve been working on designing and building a PWM controller capable of handling moderately large currents at modest voltages (5A @ 9V). I don’t need high PWM frequency (4kHz should be plenty), but some of the loads I’m thinking of are rather nonlinear (very little current at low voltages, large but constant current at higher voltages).

I decided to try using an ATtiny chip as the PWM controller, because they are very cheap and can be programmed from the Arduino IDE (using an Arduino board as the ISP programmer).  I first prototyped the design using a Arduino ProMini (so I could add debugging statements and not have to worry about the 1kByte flash limitation of the ATtiny13A).  Once that was working, I rewrote the code for the ATtiny, doing some hand optimization to reduce the code size. I got it down to 880 bytes, but I can see why C is more popular than C++ for the really tiny processors—the C++ and Arduino overhead accounts for about 150 of the 1k bytes of flash!  I could make my code much smaller if I made it more special purpose and did everything in C rather than C++, but once it fit in the 1024 bytes, I stopped worrying about the size.

PWM controller using ATtiny 13A

The design I came up with uses a low-dropout regulator to provide 5V for the ATtiny13A. A potentiometer provides analog input and a nFET provides a low-resistance switch for the output. I used the AOI518, because I have some on hand, but they are reaching the “end of life” so some other nFET may need to be used in a future design (perhaps one of the others in the series, such as the AOI516 which has a slightly lower on-resistance but a slightly higher gate capacitance).

The capacitors C1 and C2 are to keep the switching of the large load from propagating spikes into power supply.  The 470µF capacitor with a 5A current spike should limit the voltage slew to 10.6V/ms—with a 4.7kHz current square wave, this would be about a 1.1V triangle wave.  A polymer electrolytic is used (despite the price) to keep the effective series resistance small.  The one I’m using has an ESR of 9mΩ (@100kHz) and a ripple current up to 6.1A.  The leakage current could be as high as 1.5mA though.  C1 is a small ceramic capacitor to remove higher-frequency noise.  The big Schottky diode on the input is just to provide protection against accidentally hooking the circuit up backwards. I should probably add a 60¢ resettable fuse as well, to keep the current from getting excessive if there is a short.

When there is no load, the maximum current draw is 1.9mA for the pullup resistor R2, 0.9mA for the pot, 4–6mA for the ATtiny13A, and up to 1.5mA for C2, for a total of 8.3–10.3mA.  With a typically 80% efficient 9v switching power supply, this is a waste of about 100mW, or about 0.9kWh/year.

The pullup resistor R2 is not strictly necessary, but was added to keep the PWM pulses clean, turning all the way off even when the load had only tiny current draw—otherwise I could not get very low duty-cycle pulses to work well—the nFET acted as if it were a 1.3nF capacitor and kept a low voltage even when the nFET was off.  With the 4.7kΩ pullup, the voltage goes up appropriately, with a time constant of about 6µs.

So far, I’ve not tried the circuit with a large load—just with a small load that takes 13mA.  With that tiny a load, I don’t see any ripple in the power supply from the PWM.  With a 210mA load, the ripple on the power supply is noticeable: on top of the 20mV of ripple at about 20MHz with no load, I see 30mV of ripple synchronized with the switching of the PWM, when switching 210mA with a duty cycle of 1/2.  Without the 470µF polymer capacitor, the synchronized ripple is more like 200mV, indicating that the capacitor is indeed smoothing out the ripple.

The 30mV swing on 210mA implies that I should see about a 710mV swing if switching 5A.   That shouldn’t cause a problem in my design, but I do need to allow a little more voltage so that the swing isn’t a problem.  I could also use a bigger capacitor, but the polymer electrolytics are a bit expensive, and the regular wet electrolytics can’t handle a big ripple current—one with the same 6A ripple current rating would be 20 times the volume and 3 times the price of the polymer capacitor.

The high-frequency noise is almost certainly coming from the ATtiny, as it is synchronized with the PWM signal. The 5V power supply at the ATtiny is showing a 40mV ripple, which is large considering that there is a bypass capacitor on the Vdd pin.  There is a lot of inductance from the wiring on the board though, which could be increasing the propagation of the high-frequency noise.