Are you the publisher? Claim or contact us about this channel


Embed this content in your HTML

Search

Report adult content:

click to rate:

Account: (login)

More Channels


Channel Catalog


Channel Description:

All Content in element14 Community
    0 0

    Hi,

    I purchased one year of updates via the app in CS some months ago but my "Subscription Status" has not updated.

    Invoice number INV00001262. Can someone sort this out for me please?

    Thanks


    0 0
  • 11/22/17--22:41: Article 9

  • 0 0

     

     

    This is a simple test of the Beaglebone Blue Robotics Controller with a Pan/Tilt Camera Mount. The micro servos that came with the Pan/Tilt are not that great for precision control but will suffice for the purpose of this test. These servos will likely be replaced with higher grade servos at a later time.

     

    I would also like to mention, the BB Blue is being powered by a 12V 2.5A Power Supply. The BB Blue is meant to be powered by a Li-Ion Battery. The battery should arrive in a few days.

     

    Pan. Check.

    Tilt. Check.

     

    No Stormtroopers were injured in this test.

     

    Thanks for viewing this post.

     

    Cheers,

     

    Trent


    0 0

    Cool LED displays. I don't have a lot of time at the moment, but wanted to do something [I did vote for it, after all] so I've

    thrown together this - a simple bit of experimenting with an Arduino.

     

    Rather than just light an LED, I thought I'd make it a little bit of a challenge and see if I could light a series string

    of seven LEDs. The red LEDs I'm using have a forward voltage of around 2V, so that means I need something like 13V or 14V

    to get them illuminated. I could have just used a bench supply to provide the LED voltage but that's not much fun and

    wouldn't have made a very interesting blog so I'm going to generate the voltage from the Arduino's 5V with a very simple

    and crude boost converter.

     

    Here it is working (warning: world's worst video)

     

     

    and here it is drawn as a circuit diagram

     

     

    you can see how I just lashed the components together, without a breadbord or pcb, in this next photograph

     

     

    How does it work? The MOSFET is switched by the Arduino. Let's consider a time where the output has been low for a while

    and is just about to switch high - the gate voltage (relative to the source) is very low and the MOSFET is off. When the

    Arduino pin goes high, the gate rises to something close to 5V and the MOSFET turns on. That happens fairly quickly. When

    the MOSFET is on it behaves much as a small value resistor would (in this case, a few ohms), so at that point we have 5V

    across the coil. The current through the coil can't change instantaneously, instead it starts to ramp up with the rate of

    change dependent on the inductance - I chose the 10mH value so that it would ramp to about 20mA in a few tens of

    microseconds, a time period which we could control quite accurately with the processor on the board. If you look at the

    waveforms below, you can see the ramp up of the current [yellow trace is the output pin, blue trace is the coil current].

     

     

    As it ramps, energy is being stored in the form of a magnetic field around the coil. After 60uS, the Arduino turns off

    the MOSFET, and then the interesting bit happens; the magnetic field storing the energy can't remain there indefinitely,

    so the coil needs to be rid of it. If it needs to, and in this case it does, it will do that by increasing the voltage at

    the MOSFET end so as to maintain the current that was flowing at the time the switch turned off [as the energy stored is

    used up, the current will fall until we are back to zero again]. Initially, the coil can charge the intrinsic capacitance

    at the drain of the MOSFET and the capacitance of the LEDs, but those capacitances aren't all that large and it will

    quickly attain a voltage where the LEDs turn on and then most of the energy will go to running the LEDs for a short

    period. Repeating the process gives the illusion that the LEDs are on continuously. The next set of waveforms show the

    voltage at the coil/MOSFET/LED node and the current that flows through the LEDs. As the current declines, the voltage

    falls because the forward voltage of the LEDs depends on the current. When the energy stored by the coil is almost used

    up, it no longer runs the LEDs but instead what's left of the energy moves back and forth from the coil to the

    capacitance at that node [which of course includes the capacitance of the scope probe tip]. The ringing looks a bit

    alarming but there's little energy there and it's not doing any real harm.

     

     

    Sorry the current waveforms are a bit of a mess. The probe is a bit noisy and isn't that good with small currents.

     

    A couple of points if you want to replicate this. Firstly, check the waveform timing produced by the Arduino before connecting the

    circuit - there's no protection if the timing is wrong. Secondly, if the LED string is disconnected for any reason, the voltage

    will increase until the current does flow, even if that means the coil has to avalanch the MOSFET to do it - so make sure

    the LEDs are the right way round and connect properly - if you're a bit nervous, a 24V zener across the LED string would

    provide an alternative path in the event of a fault.

     

    Finally, here's the sketch I used.

     

    int outPin = 9;   // output pin to use 
    // the setup routine runs once when you press reset:
    void setup() {  // set output pin:  pinMode(outPin, OUTPUT);
    }
    // the loop routine runs over and over again forever:
    void loop() {
    word onPeriod = 0;  // LED on  for(onPeriod=0;onPeriod<5000;onPeriod++) {    // repeat for about half a second    noInterrupts();    digitalWrite(outPin, HIGH);   // pin is high    delayMicroseconds(60);        // ...for 60 microseconds    digitalWrite(outPin, LOW);    // then low    interrupts();    delayMicroseconds(60);        // ...for 60 microseconds    }  // LED off  delay(500);   // off for half a second
    }

     

    If you want to try fading the LEDs, keep the high time constant and lengthen the low time.


    0 0

    Introduction

    Sometimes it is great to be able to see if things are hot or cold with a thermometer or other device. Multiply it by 64 and it is possible to get a graphical image of hot spots or detect humans for instance.

    A thermopile array can be used to measure temperature from a distance and a special part from Panasonic called Grid-EYE happens to have 64 of them : )

    Since the Sense HAT has 64 LEDs, I wanted to try them together : )

    sense-hat-lit-rainbow.jpg

     

    This is what is implemented:

    system-overview-r2.png

     

    For more experiments with the Grid-EYE and a review, see here: Panasonic Grid-EYE RoadTest - Review

     

    What can you do with it?

    The Grid-EYE is designed for detecting humans or objects that come into its field of view. It could be used for automatically turning on the heating when a human is detected, or automatically opening doors for instance. It differs greatly from the usual passive infrared (PIR) sensors used in alarm systems; they require movement whereas thermopile sensors will continuously detect objects while they remain in the field of view. By processing the images over time it is possible to see which direction humans or objects are moving. This could be useful for more intelligent automated doors or barriers, or for innovative electronic advertising that is triggered by human presence and actions.

     

    In the brief time that I explored, it was possible to see people from a distance of five metres, and a 10 ohm resistor connected to an AA battery from about an inch away. By experimenting with the software it is possible to choose the spectrum of color that is desired for the particular temperature range of interest.

    grid-eye-sense-hat-animation.gif

     

    Grid-EYE usefulness for people detection (occupancy sensor) was explored in the Grid-EYE Review blog post.

     

    Build Steps

    The project is straightforward and simple, so in the interests of efficiency this report won’t have a lot of text!

    To build this project, a Pi 3 and a Sense HAT is needed, and the Grid-Eye evaluation kit. I already had the Pi 3 and Sense HAT (and the associated memory card and power supply) as part of the Pi 3 IBM IoT Learner KitPi 3 IBM IoT Learner Kitreviewed here. The Grid-EYE evaluation board is available separately. The one I had (model AMG8832) is not available any more but there is a better performance AMG8834 Grid-EYE Evaluation ModuleAMG8834 Grid-EYE Evaluation Module that can detect humans up to 7 metres away.

     

    The evaluation board contains the Grid-EYE, a pre-programmed microcontroller and Bluetooth Smart capability. Basically nothing needs to be done with the eval board except plug it into a power supply! The supply can be a 5V mobile phone charger or a PC USB port. The photo here shows the Grid-EYE evaluation board. It is about the footprint of a playing card. The Grid-EYE module itself is very small, about 12mm on its longest dimension.

    grideye-annotated.jpg

     

    Since the Pi 3 also has Bluetooth Smart capability, the Grid-EYE board connects to the Pi using this. This is great because it means that the imaging can be performed remotely.

    The Pi 3 is responsible for translating the 8x8 array of values into colours and sending them to the Sense HAT’s display. The Pi 3 also runs a little web server so any web browser (e.g. PC or mobile phone) can be used to connect to the Pi and view the images live.

    Check out the short video (1.5 mins) for some example capture.

     

     

    Here are the instructions to build it. First, as root user (or prepend sudo to these commands):

     

    apt-get install libbluetooth-dev
    update-nodejs-and-nodered

     

    Then, as normal user (e.g. pi or your username):

     

    git clone https://github.com/shabaz123/grid-eye
    cd grid-eye
    npm install noble
    npm install sense-hat-led
    npm install rotate-matrix
    npm install ioctl
    npm install socket.io
    npm install imagejs

     

    Change the index.js file at grid-eye/node_modules/sense-hat-led using the index.js_mine file (which has been through the babel transpiler) using this command:

     

     

    cp index.js_mine node_modules/sense-hat-led/index.js

     

     

    The grid-eye/index.js file will need a modification, search for the line with the text progpath and set it to point to the grid-eye folder. The slash at the end is important. For example for me it says:

     

    var progpath='/home/shabaz/grid-eye/';

     

    That’s it! To run it, as root user (or prepend with sudo) type:

     

    node index.js

     

    Use a browser to navigate to http://xx.xx.xx.xx:8081/index.html

    The code works but is just prototype quality and there is lots of room for improvement. It seems to work reasonably well but would benefit from some configuration options (things like temperature range are hard-coded).


    0 0

    A note at the beginning: in the scoring above I'm using 5 as "meets what I expect from such a tool / product", and better scores are only when it exceeds expectations. So a 30 means "this is what as good as expected", below that means its lacking and more than that indicates its better.

    Intro

    This is not really a traditional road test. This is because I do already own a PicKit3 for several years, albeit a DIY one. So it does not really make sense to write a test about it - I'm already familiar with it. Instead I proposed to look at the differences between the two, to find out why you might (or should?) buy a PK3 instead of building your own.

    So this road test will be in a somewhat unusual format. First I will explain why and how I build my own PicKit3, so you know what I was starting with. Then we will get a look at the real PicKit3 I got from Microchip (many thanks to them, and to Farnell, for sponsoring this road test!). The last part will then show how both differ.

    Building a DIY PicKit3

    The reason I did build my own PicKit instead of buying one was mostly a reason of price. While these tools are not very expensive, when you add shipping they get quite pricey in comparison. And when I started into working with Microchips PIC series, I did not have that much money available for my hobby.

    I actually started with a DIY PicKit2, not with the PK3. It is much simpler, and there are quite a lot of tutorials and blog posts available of how to do this. For initial programming you could use a simple parallel-port programmer (back then PCs still had these...). So I ended up with this:

    {gallery} DIY PicKit2

    Inside of the DIY PicKit2

    Enclosure for the DIY PicKit2

    DIY PicKit2 PCB

    DIY PicKit2 PCB backside

    Back then the idea was to use the PicKit2 to then build an ICD2, which was its faster and more versatile bigger brother (and there are also tons of instructions how to build one). But with the introduction of MPLAB X support for the newer PICs from Microchip (e.g. the Pic32 line) was never added to the PK2 and the ICD2. So the goal shifted to the PicKit3.

    Fortunately Microchip was so kind to still publish the schematics for it in the user guide. so I went ahead with building one. See my blog post about the DIY PicKit3 for the changes I made, for schematics and anything you need to know should you want to go the same route. The result looks quite similar to the PK2, since I also used a Sparkfun box:

     

    {gallery} DIY PicKit3

    DIY PicKit3 Enclosure

    Inside of the DIY PicKit3

    DIY PicKit3 - PCB top side

    DIY PicKit3 PCB bottom side

    Yes, it looks quite messy since I just used a protoboard. But at least it inspired someone else for come up with a proper PCB.

    What you get for buying a PK3

    First, you get a nice package. Second thing you notice is how small it actually is:

     

    {gallery} Microchip PicKit3

    PicKit3 packaging

    PicKit3 size comparison

    PK3 poster

    (especially when compared to my DIY versions).

    The added poster with all the required information of how to connect and use the PK3 was a nice surprise. I really like it, unfortunately I don't have a place where to put it near my bench. Suggestion to Microchip: add a sticker on the PK3 showing the pin names (just as I did on my DIY PK3) - this something you always need to know.

    The red USB cable also has a nice touch, it fits the company color scheme quite well.

    Comparison

    Since I wanted to have a deeper look, we need also to look at whats inside. So its time for a teardown. Fortunately the two plastic halves of the enclosure come apart without using too much force, so I had a look at the PCB:

    {gallery} PicKit3 PCB

    PCB top side

    PCB bottom side

    The PCB itself seems to be a four layer one, and most of the components go only to the top side. The quality of soldering was very good. There is some flux residue on the USB connector, so it seems it was soldered manually at the sides (so its sits stronger on the PCB and doesn't come lose).

    There are quite some number of test points, so should it fails you actually should have a chance to find out whats wrong (using the schematic). But I guess thats not their purpose, they are most likely to do after-production testing.

    When compared with my DIY version, the original PicKit3 is build with less ICs and more discrete parts. This is because it does quite some functionality with transistors (especially around voltage switching) which I replaced with ICs because thats what I had available. This also allows for a denser PCB. All in all I like the build quality. Also the layout looks neat and tidy, thats what you expect from a big company.

    From the schematic I know that the PicKit3 comes with some protection on the input and output ports, so it should withstand some mishandling such as mixed-up wiring (thats actually something my DIY version skipped - I had no SMD PTC available at that time). I know that the PK3 has some bad reputation for being unreliable, but from my experiences I cannot confirm this. And I think the original version should be even more robust than mine.

    Another difference is that, on my DIY version, I skipped the flash memory chip for the on-the-go functional, since I had no use for it. But I can see its value when you need to program in a place where you cannot bring your computer with you, or when you need to program multiple devices with the same code.

    The biggest difference, construction-wise, is the choice of the programming connector. As you can see from the images above, the PicKit3 comes with a female header directly at the front. This means for programming you need a male header on you board. If you want to use a 90° header, it needs to be right at one of the sides of the board, otherwise you can only use straight headers. And then the PK3 needs to stand upright on your board, which I think is not really optimal (and can stress your board and the connector). In addition, I don't like to add male headers on a PCB since there is always the chance that some contacts get shorted by accident (Vcc and GND are next to each other on the connector). From a development tool I expect that it is safe against such mishandling (the PK3 has PTCs in all lines, so its protected against over-current), but normally on a PCB you don't add something like that.

    {gallery} Connecting the PicKit3 to a breadboard

    Pic12F1822 sample circuit on a breadboard

    PicKit3 with straight pin headers

    PicKit3 with 90° headers

    using a short cable with two male headers

    None of these is optimal, so in the end I just build a short cable with two male headers which you can use. For my DIY variant I directly used a male connector, so I don't need an adapter. Additional note here: normally pin 1 is on the left side of a connector, for the PicKit3 its on the right side. Watch out for this.

    So much for the differences. Testing the real PicKit3 was unremarkable - it does just what it should, without any fuss. And just doing its job is what you expect from a debugging tool - it should just work. Its not the fastest, but for small and medium-sized PICs its surely fast enough. In that regards there was no difference to my DIY one, except that the real thing uses much less bench space.

    Conclusion

    So, is it worth to build your own PicKit3? I don't think so anymore. Probably it was not even worth it back then when I built mine - but I had nearly all parts available (and a PicKit2 to program it initially) so it seemed like a good idea. But now the availability of the PK3 is good enough (and shipping to Germany is not so expensive anymore) that its just easier to buy one. When you limit yourself to older PIC chips (which means you miss out on all the new and nice functionality of the newer ones) it still might be OK to build your own PicKit2, as its of simpler construction. This can save you some bucks, but limits you to the older MPLab (the MPLabX will not work with the PK2).

    But when you think about doing more work with PICs, or want to use the new functionality, just get a PK3 directly from Microchips. Its small, looks nice, and does its job. And building a small adapter cable so you can use it easily on a breadboard is not such a big deal. I for myself might start saving some money to get an ICD4...


    0 0

    I bought boards from a cheap Chinese cb manufacture- jlcpcb, I will show some pictures about my boards.

    The edges of the board are evenly milled to a smooth state. Not scribing.

    jlcpcb

     

    The boards themselves turned out quite good. I like it.The mask is smooth, shiny, glossy.

    jlcpcb

     

    Matching the mask with the paddles is close to perfect. The gap to the eye is not visible, under the magnifying glass you can see a small offset.

     

    The silkscreen is good, but it can be better. The drawing on small (very small) details floats a little and is interrupted on thin lines. Thin lines stick together or break.

    jlcpcb

    jlcpcb

    The minimum readable text has a height of about 0.8 ... 1mm - the number that left the manufacturer.

    The combination of silkscreen printing is not ideal, but very good. The silkscreen itself keeps well, does not peel off, does not shovel. Acetone is not washed off and in general I could not find any solvent in my life that would take it.

    The diameter of the holes is clearly maintained. For me it was important, because I designed holes such that the PLS pins in them would come in with a little effort and they would be held in place by frictional force during the installation. Slightly thicker tinning or mismatch of holes and pins will have to be hammered. A little more - they will fall out. Immediately everything is perfect, exactly as planned. And I did not pick a diameter for this manufacturer. By the way, in Resonite, for example, tinning is thicker and the pins have to be inserted with considerable effort.

    In a word, the quality is that I want. The price is really amazing. Everybody can check it.  https://www.jlcpcb.com/

     


    0 0

    IoT on Wheels OBD-II Device from Samsung

     

    Samsung has released the Samsung Connect Auto – a quick and easy IoT upgrade device for your vehicle

     

    ConnectedCar_Main_2.jpg

    Image Source Samsung

     

    The Samsung Connect Auto is a smart OBD-II Socket interface device.

     

    Pretty much every car built since 1996 has been fitted with an OBD-II port, which allows access to the vehicle's On-board Diagnostics system (OBD). We will go into the OBD in further detail below.

     

    OBD_connector_shape.svg.png

    Image Source Wikipedia

     

     

    This device is powered by the OBD-II Port (Pin 16 is 12/24v and Pin 4 is Chassis Ground). It provides a 4G LTE Hotspot for up to 10 devices in the vehicle.

    This does mean that this product is sold via cellular network providers such as AT&T in the USA so it use the Samsung Connect Auto, you would need an accompanying cellular data package.

     

    Samsung-Connect-Auto-05.png

     

    As an always-on WI-FI, 4G LTE is very handy, even if it is just to keep the kids entertained during long journeys. This is a fully connected internet device that is plugged directly into your car's CAN bus network. It has the option to do so much more than just leech power.

     

    The Connect Auto comes with an Android app that gathers and interprets the data from the car's CAN bus network. The first and most obvious use of this is to check error codes given by the vehicle, which Samsung calls the “Virtual Mechanic” feature.

    This can be very useful for avoiding large service bills and knowing about the health of your car. 

     

     

    Each of the EOBD fault codes consists of five characters: a letter, followed by four numbers. The letter refers to the system being interrogated e.g. Pxxxx would refer to the powertrain system. The next character would be a 0 if complied to the EOBD standard. So it should look like P0xxx.

     

    The next character would refer to the sub system:

     

    • P00xx – Fuel and air metering and auxiliary emission controls.
    • P01xx – Fuel and air metering.
    • P02xx – Fuel and air metering (injector circuit).
    • P03xx – Ignition system or misfire.
    • P04xx – Auxiliary emissions controls.
    • P05xx – Vehicle speed controls and idle control system.
    • P06xx – Computer output circuit.
    • P07xx – Transmission.
    • P08xx – Transmission.

     

    The following two characters would refer to the individual fault within each subsystem.


    Samsung-Connect-Auto-04 (1).pngSamsung-Connect-Auto-02.png

     

    Bluetooth OBD-II port scanners have been on the market for a few years now, and checking error codes is usually where the functionality ends, but the Auto Connect does this and more… much, much, more.

     

    The next trick in this little box is security. The app allows you to get notifications if:

    • Your vehicle exists a definable geo-fence,
    • Moved unexpectedly without your phone being present
    • If someone unplugs the OBD-II device.

     

    Another core security feature, mirrored by Samsung’s other mobile devices, is the “Find my Vehicle” feature that allows you to pinpoint your vehicle's last known GPS coordinates on a map.

     

    I feel this feature will be used less when a car has been stolen and more when you cannot remember where you parked your car after a particularly rough trip to Ikea. 

     

    Fuel Economy and driver style are the next values to be crunched over in the Samsung cloud servers. They track metrics and events such as:

    • Hard acceleration events
    • Hard breaking events
    • Hard Cornering events
    • Time spend Over 100Km/h

     

    These recorded events plus fuel consumption all add up to your Driver Score. The better the score, the more efficient and safer you are as a driver.

    The app gives you this feedback to help you improve your fuel efficiency, get more miles out of your tyres and brake pads.

     

    As someone with a heavy foot I would probably not like what the app has to say about my driving style.

     

    Samsung hopes to make connections with insurance companies and make this device a “black box” for driving, reporting good and bad behaviour to your insurance company so they can teak your insurance fees.

     

    The last trick in this under dash box of wonders is its ability to track:

    • Journey Details
    • Hours driving
    • Fuel Costs

     

    These could, presumably, be output to help claiming mileage back on business trips or tracking other drivers of your car.

     

    This device is a polished end IoT on Wheels product with built in connection to the CAN bus network of sensors feeding to Samsung’s Cloud platform, which then displays this data concisely in an app with Google maps integration and a sleek intuitive user interface.

     

    The theme of IoT on Wheels Design Challenge is to improve our vehicles with IoT connectivity, whether it be our cars, bikes, motorcycles, scooters or skateboards.

     

    They get us to work, school, or offer a speedy way to visit a friend or just have some fun. But even though we love our WHEELS, they could be safer, smarter, or more efficient. That’s the goal of the element14 ‘IoT on Wheels’ Design Challenge with STMicroelectronics.

     

    Integrate the low-cost  NUCLEO-L476RG Development Board from STMicroelectronics into your project for the chance to win a prize package worth up to $1800.

     

    The IoT on Wheels Design Challenge will choose 10 sponsored challengers to receive a Challenger Kit for FREE, but anyone can join the Challenge as a non-sponsored Challenger.
    Here's how:
    Simply get the low-cost NUCLEO-L476RG and integrate it into your project, as well as post 10 blogs about your design journey in the IoT on Wheels space (tagging your blogs 'IoT on Wheels').

     

    The deadline for project submissions is 13th November.

     

    To be eligible to win some fantastic prizes, including a Segway MiniPRO – a hands-free two-wheel electric scooter – you must blog at least 10 times on the Community detailing your project build.

     

    All Challengers must build their projects in accordance with the Challenge's terms and conditions. All projects must include theNUCLEO-L476RG.


    0 0

     

    Original Post Updated Info

    Many engineers I know all want to fabricate PCBs for the custom, prototype, or one of a kind projects, but they often can not afford to have them printed at the volume many board houses require.

     

    What are some cheap PCB printing services out there?

     

    Personally, I am looking for board houses that will print 1 - 10 boards for less than 2 dollars a piece. Component placement services a plus!

     

     

    Any help would be appreciated.

     

    Cabe

    Since this conversation has been around since 2010, we've decided to freshen it a bit with updated information below.

     

    A comprehensive guide to Getting Started Designing Your First PCB

     

    PCB Terminology you may need to (want to) know can be found in the PCB Glossary

     

    Here are some PCB Manufacturers recommended by element14.com.


    0 0
  • 11/23/17--01:34: Windows 10
  • Hi,

     

    Does gnu-mcu-eclipse-openocd-0.10.0 work under Windows 10!