Jump to content
43oh

Tribes

Members
  • Content Count

    42
  • Joined

  • Last visited

Reputation Activity

  1. Like
    Tribes got a reaction from bluehash in Sensorless BLDC motor control   
    I have been super busy the last couple of weeks, so I didn't really get to do much.
    So far I have completly soldered one board and wrote a simple program to test the MOSFETs and drivers.
    And they work! Flashing the MCU as well!
    But I suspect the bootstrap capacitors may be to small, but we'll see, and changing them is not that difficult.
     
    Tomorrow I can hopefully test the comparator stuff and then start some real development.
     
    And some pictures:



  2. Like
    Tribes got a reaction from bluehash in Sensorless BLDC motor control   
    My boards from elecrow arrived yesterday! Not sure though if I have the time to solder them up this weekend :/
  3. Like
    Tribes got a reaction from bluehash in Sensorless BLDC motor control   
    Boards are on their way from elecrow, but I guess they won't be here for another week. I already got all the components from mouser (interestingly cheaper than buying them in Germany) so when the boards arrive I should be good to go.
     
    atm, I got a 800Kv 9.5A@11.1V and a 750Kv 18A@14.8V (both max. amp) motor. Oh, and both are hobby motors.
    But I'm still looking for a nice low Kv, low power(current) motor, and probably a sensored one.


  4. Like
    Tribes got a reaction from GeekDoc in Simple ADC LED control program MSP430G2553   
    If you really want PWM on P1.0 I would rather generate the signal using interrupts generated by TimerA than a loop with delays. This is a much more elegant solution and allows you to use the low power modes of the MSP430. I am pretty sure you can find examples for software PWM on the forum
  5. Like
    Tribes got a reaction from bluehash in Sensorless BLDC motor control   
    I finally ordered the PCBs at elecrow. Made some small changes like changing the packages of the diodes and I added some text(and a 43oh.com logo).
  6. Like
    Tribes reacted to roadrunner84 in State Machine Tutorial   
    A little on pointers, just for the fun of it.
     
    Pointer may seem complex and intimidating at first, but if you keep a little track of the type of something, it's quite understandable.
     
    C knows basically only one type: a scalar. This means that anything can be represented as a number. A string is a series of numbers representing letters, a boolean is a number (0 or 1), an integer is a number, a loating point is a set of numbers representing a fractional value and a pointer is a number of the address of something else in memory.
    These numbers are very powerful and very versatile, this is why you need to take care that you know what a certain number means.
    int x = 0; // x is an alias to a number; the number 0 int* p = 0; // p is a pointer to a number; the memory address 0 char s[] = "0"; // s is a pointer to a series of characters; the first character is the digit 0 char s2[] = "\0"; // s2 is a pointer to a series of characters; the first character is the NUL character There are two special symbols associated with the use of pointers, the * (asterisk) and the & (ampersand). The confusing thing is that their meaning differs in the context.
    int x; int* p = &x; // int* is the type of p, this is "pointer to integer" *p = 5; // *p means "use the value that p is pointing to". Since p is pointing to an integer, x in this case, x will become 5 p = 5; // WRONG: set p to point to memory address 5 p = &x; // &x means "use the address of x"; p will become the address of x; p points to x int a[4]; // a is an array, this is equal to "a points to the start of a consecutive series of 4 unnamed integers" p = a; // since both p is a pointer to int and a is a pointer to int, we can let p become a or "let the pointer p become the same address as the pointer a" int b[4]; // b is also a pointer to a series of 4 integers b = a; // WRONG: both b and a are pointers, so C won't complain, but you just lost a pointer to the series of 4 integers that b used to point to; this is called memory leak int d[8]; p = a; a = d; d = p; // since we used p as a temporary for a, we can use this to exchange the pointer values of a and d. // note that since a pointed to a series of 4 and d pointed to a series of 8, that now the opposite is the case, I'm not sure how your compiler will behave: int e[2]; void foo(void) { int b[4]; int* p; p = e; e = b; b = p; // normally the array b will be disposed of at function end, but will the compiler drop 4 integers or 2 integers? // best practice is to never assign to the array, but only to pointers } void bar(void) { int b[4]; int* p; int* q; p = e; q = b; // now use p and q where you wanted to use b and e. } As you can see, an array is secretly a pointer to a series of values, this means that we can use array indexing and * (pointer dereferencing) in mixed order:
    int a[4]; int* p = a; p[2] = 5; // a[2] will become 5 *a + 3 = 2; // a[3] will become 2 Things become really interesting when using arrays of pointers
    int a=1; int b=2; int c=3; int* q = &c; // q points to the address of c int* p[3] = {&a, &b, q}; // p is an array of pointers to integers, so p points to a series of pointers to integers int** r = p; // r is a pointer to a pointer to integers, so *r is a series of pointers to integers *(*p + 1) = 5; // equal to *(p[1]) or even equal to p[1][0], all which are equal to b, since p[1] is a pointer to b q = &a; // this only affects q, since p copied the address held by q, so p[2] still is equal to c p[2]=4; // c becomes 4 *q = 0; // a becomes 0 q[0] = 3; // a becomes 3 Things get a little confusing when we're talking about pointers to functions, this is because pointer dereference and address referencing is optional for functions.
    void foo(void) { // do something } foo(); // the compiler will save the current instruction pointer and load the address of foo in the instruction pointer // then when foo is done, it will load the saved instruction pointer back to the instruction pointer, so execution continues just after the call to foo void (* bar)(void); // this is a variable called bar, it is a pointer to a function that looks like void name(void) bar = &foo; // bar is now pointing to the function foo bar = foo; // C accepts omitting the & when talking function pointers, try to avoid this form if you're new to pointers (*bar)(); // do a call to the function that bar points to; call foo bar(); // C accepts omitting the * when talking function pointers, here again. So this also calls foo bar = foo(); // WRONG: try to assign the return value of foo (void) to bar typedef int number; // this is a type definition; the type number is now equal to the type int typedef void(*voidfunc)(void); // this is a type definition; voidfunc is now equal to void(*name)(void) voidfunc baz; // baz is a variable, it is a pointer to a function that looks like void name(void) constant pointers and pointers to constants
    Take notice that pointers don't need to point to the same value throughout the program, unlike variables (and just like variable values).
    C has the keyword const to denote that a value may never change. In the case of the MSP430 this is also used to place a value in flash instead of ram (since you promised not to change it anyway, in AVR you must use the PROGMEM attribute to force a value to flash).
    int x; // x holds a variable value; const int y=5; // y hold a constant value 5, so y will never ever change const int z; // WRONG: since z will never change, you must assign it a value at declaration const int* p = &y; // p points to the constant integer y int const* q = &y; // q points to the constant integer y int * const r = &x; // r is a constant pointer to the integer x, so r will never change, but it's dereferenced value (the value of *r or x) may change int * const s = &y; // WRONG: since y is a const int, s must be a pointer to constant integer, but it is a constant pointer to integer const int * const t = &y; // t is a constant pointer to a constant integer; neither t nor *t (y) may change value As you can see, the const keyword may come before or after the type int. But when placing the const keyword after the * it is a property of the pointer, not a property of the type int.
     
    buffer overflow
    Whenever you're working with arrays and/or pointers, take much care to not cross the boundaries of the actually allocated memory
    int a[4]; // a is 4 integers long: a[0], a[1], a[2] and a[3]. int* p = a; // p points to a[0] p[1] = 5; // p[1] is a[1] and becomes 5 p[4] = 4; // WRONG: p[4] is a[4] which is the memory location after a[3], but we've never allocated this memory. You might be overwriting something else! void fillbuffer(int* buffer, int length, int value) // fill a buffer named buffer of length length with value value { for(int iter = 0; iter <= length; iter++) // WRONG: iter should be less, not less or equal to length { *buffer = value; // write value to the element buffer is pointing to buffer++; // increment the address in buffer by 1 element } } const int len = 5; int b[len]; // b is now 5 integers large p =b; // p now points to b[0] fillbuffer(p, len, 0); // write the value 0 to all elements of p //WARNING: are you sure that your function is doing what it should do? void fillbuffer2(int* buffer, int max_elem, int value) // fill a buffer named buffer of length max_elem - 1 with value value { for(int iter = 0; iter <= max_elem; iter++) // WARNING: will the user pass the right value to max_elem? { *buffer = value; // write value to the element buffer is pointing to buffer++; // increment the address in buffer by 1 element } } const int len2 = 5; int b2[len2]; // b2 is now 5 integers large p2 =b2; // p2 now points to b[0] fillbuffer2(p2, len2 - 1, 0); // write the value 0 to all elements of p2 //WARNING: these "off by 1" situations happen a lot! always be sure you're doing it right I hope this sheds some light on the behaviour of pointers. It is a lot, and you need to be really sure to always use the right symbol at the right time. This is what makes C an unsafe language and what causes 90% of all security leaks in software. Languages like C# and Java try to fix this by monitoring memory overflows or restrict pointery stuff, in which they succeed for less than 100%. Javascript et al. do not support fixed-length arrays or pointers, which causes the language itself to be safe, but not all implementations are.
  7. Like
    Tribes reacted to roadrunner84 in Problem with bit wise operation   
    Time for a little tutorial in binary!
     
    There are three primitive binary operations:
    invert (negate/not): take one input and give back the opposite (a 0 becomes a 1, a 1 becomes a 0) and: take two inputs and give back a 1 if both inputs are 1 as well (give back 0 if any or all inputs are not 1) or: take two inputs and give back a 1 if any or all inputs are 1 (give back 0 only if no inputs are 1) Visually it looks like this, here A and B are inputs and U is the output
    NOT AND OR A | U A B | U A B | U --+-- ----+-- ----+-- 0 | 1 0 0 | 0 0 0 | 0 1 | 0 0 1 | 0 0 1 | 1 1 0 | 0 1 0 | 1 1 1 | 1 1 1 | 1 In the language C, the bitwise notations for these three operations are ~ (tilde, not), & (ampersand, and), | (pipe, or)
     
    So changing a value in bit X to it's inverted value is written as
    X = ~X;
     
    Now, C does not have a bit variable type, (almost) only integer number variables. So a little about bitwise operations on numbers. For the sake of simplicity I use 4-bit numbers, in reality most variables are either 8-bit or 16-bit (or 32/64-bit on PCs).
    Say I have a variable X and I want to set the least significant bit (the bit most to the right when written), how do I do that? I do an OR operation with the value which holds one 1, which is is the least significant bit position, this value is 1
    X = X | 1;
    X: 0 1 0 0 1: 0 0 0 1 ------- OR 0 1 0 1 Observe that a bit in the result is one if any or all bits directly above it are 1 as well.
    X: 0 1 0 1 1: 0 0 0 1 ------- OR 0 1 0 1 Note that the value of this bit in the variable is not important for the result; the least significant bit is always 1 in the result, because one of the inputs was always 1.
     
    Now if we want to clear that bit? We do an AND with the inverse of 1. Say what? Let's draw it
    1: 0 0 0 1 ------- NOT ~1: 1 1 1 0 X: 0 1 0 1 ~1: 1 1 1 0 ------- AND 0 1 0 0 So by ANDing with the inverse of the desired clear bit, you can actually set it to 0. In C we'll write
    X = X & ~1;
     
    Note that in both these cases ONLY the least significant bit changes, any bits that may be set or cleared in other bit positions are unaffected. This is why you want to use the OR and AND operations, not simple assignments.
    In C there are shorthands for operations on something itself:
    X = X & ~1; equals X &= ~1;
    X = X | 1; equals X |= 1;
     
    So if I write P1OUT |= BIT0; I will only be affecting the bits that are set in BIT0, which is only the least siginificant bit. BIT1 only has the second least siginificant bit set, BIT2 the third least siginificant bit, etcetera.
     
    Advanced bit subjects
    If you want to alter multiple bits, you can first OR them together:
    BIT0: 0 0 0 0 0 0 0 1 BIT2: 0 0 0 0 0 1 0 0 ---------------- OR 0 0 0 0 0 1 0 1 BIT0 | BIT2 Then you can use this to set or clear both bits simultaneously:
    X = X | BIT0;
    X = X | BIT2;
    becomes
    X = X | BIT0 | BIT2;
    in short
    X |= BIT0 | BIT2;
     
    Now if you want to clear both bits in X, you need to use the negated values
    X = X & ~BIT0;
    X = X & ~BIT2;
    becomes
    X = X & ~BIT0 & ~BIT2;
    becomes
    X &= ~BIT0 & ~BIT2;
    visually
    BIT0: 0 0 0 0 0 0 0 1 ---------------- NOT ~BIT0: 1 1 1 1 1 1 1 0 BIT2: 0 0 0 0 0 1 0 0 ---------------- NOT ~BIT2: 1 1 1 1 1 0 1 1 ~BIT0: 1 1 1 1 1 1 1 0 ~BIT2: 1 1 1 1 1 0 1 1 --------------- AND 1 1 1 1 1 0 1 0 ~BIT0 & ~BIT2 X: 0 1 0 1 0 1 0 0 1 1 1 1 1 0 1 0 ---------------- AND 0 1 0 1 0 0 0 0 Note that any bit that used to be 0 stays 0 and any 1 stays 1, except for the bits that are 0 in ~BIT0 & ~BIT2
     
    We could get the value 1111 1010 in another way as well: take the inverse of 0000 0101. As you know by now, 0000 0101 is attained by ORing BIT0 and BIT2
    BIT0: 0 0 0 0 0 0 0 1 BIT2: 0 0 0 0 0 1 0 0 ---------------- OR 0 0 0 0 0 1 0 1 BIT0 | BIT2 0 0 0 0 0 1 0 1 BIT0 | BIT2 --------------- NOT 1 1 1 1 1 0 1 0 ~(BIT0 | BIT2) X: 0 1 0 1 0 1 0 0 1 1 1 1 1 0 1 0 ---------------- AND 0 1 0 1 0 0 0 0 Observe that the result of ~(BIT0 | BIT2) is identical to ~BIT0 & ~BIT2. This property is called Demorgan's law:
    By inverting both inputs and the output of an AND operation, I get an OR operation. By inverting both inputs and the output of an OR operation, I get an AND operation. Since ~BIT0 inverted is ~~BIT0, which is equal to BIT0, this property holds. So I take NOT NOT BIT0 (ie: BIT0) and NOT NOT BIT2 (ie: BIT2) and replace the AND operation with an OR operation. Then I NOT the result once more and get the same result.
     
    So
    X = X & ~BIT0 & ~BIT2;
    becomes
    X &= ~BIT0 & ~BIT2;
    which is equal to
    X &= ~(~~BIT0 | ~~BIT2);
    is equal to
    X &= ~(BIT0 | BIT2);
     
    As a last reminder: BIT0, BIT1, etc. are part of the MSP430 library (msp430.h), not part of the C language itself. So you cannot use these definitions in a PC application unless you create them first.
     
    Exclusive or and asymmetric bitwise operations
    Apart from the three basic operation there is one other operation that might be useful on occasion; the exclusive or. Exclusive or (or XOR in short) is written as ^ (circumflex, xor) and gives back 1 if exactly one input is 1 (give back 0 if no or both inputs are 1)
    XOR A B | U ----+-- 0 0 | 0 0 1 | 1 1 0 | 1 1 1 | 0 XOR can be used to toggle bits. If I have a variable X and want to toggle the least siginificant bit, I XOR X with 1.
    X = X ^ 1;
    or
    X ^= 1;
    X: 0 1 0 1 0 1 0 1 1: 0 0 0 0 0 0 0 1 ---------------- XOR 0 1 0 1 0 1 0 0 X: 0 1 0 1 0 1 0 0 1: 0 0 0 0 0 0 0 1 ---------------- XOR 0 1 0 1 0 1 0 1 As you can see, it works both ways. Be careful when using XOR, as you explicitly have no control over the resulting value; you only make sure it has changed, so keep track of the value it may have had before.
     
    To make our list of operators complete, let's sum up all 16 possible output combinations and see when they're useful and when not.
    NUL AND AND ~ A ~ AND B XOR OR ~( OR ) ~( XOR ) ~B OR ~ ~A ~ OR ~( AND ) ONE A B | U A B | U A B | U A B | U A B | U A B | U A B | U A B | U A B | U A B | U A B | U A B | U A B | U A B | U A B | U A B | U ----+-- ----+-- ----+-- ----+-- ----+-- ----+-- ----+-- ----+-- ----+-- ----+-- ----+-- ----+-- ----+-- ----+-- ----+-- ----+-- 0 0 | 0  0 0 | 0  0 0 | 0  0 0 | 0  0 0 | 0  0 0 | 0  0 0 | 0  0 0 | 0  0 0 | 1  0 0 | 1  0 0 | 1  0 0 | 1  0 0 | 1  0 0 | 1  0 0 | 1  0 0 | 1 0 1 | 0  0 1 | 0  0 1 | 0  0 1 | 0  0 1 | 1  0 1 | 1  0 1 | 1  0 1 | 1  0 1 | 0  0 1 | 0  0 1 | 0  0 1 | 0  0 1 | 1  0 1 | 1  0 1 | 1  0 1 | 1 1 0 | 0  1 0 | 0  1 0 | 1  1 0 | 1  1 0 | 0  1 0 | 0  1 0 | 1  1 0 | 1  1 0 | 0  1 0 | 0  1 0 | 1  1 0 | 1  1 0 | 0  1 0 | 0  1 0 | 1  1 0 | 1 1 1 | 0  1 1 | 1  1 1 | 0  1 1 | 1  1 1 | 0  1 1 | 1  1 1 | 0  1 1 | 1  1 1 | 0  1 1 | 1  1 1 | 0  1 1 | 1  1 1 | 0  1 1 | 1  1 1 | 0  1 1 | 1 As you may see, some operations aren't useful, like the NUL and ONE operator, just use hard values in these cases. The A, B, ~A and ~B operator ignore one parameter, so leave the ignored parameter out.
    Then we find the three btiwise operators AND, OR and XOR and their twins ~( AND), ~( OR ) and ~( XOR ). When I write ~( AND ), read it like X = ~(A & B );
    There are four operators left, which I named ~ AND, ~ OR, AND ~ and OR ~. These operators take one of their two parameters inverted, they are asymmetrical; you cannot flip the two parameters and get the same result. As an example the ~ AND operator is written like X = ~A & B;
  8. Like
    Tribes got a reaction from OhmMegaman in Sensorless BLDC motor control   
    Hi there,
     
    my current project is to build a controller for a sensorless BLDC motor using a MSP430G2553. I want to realize trapezoidal control with Back-EMF/zero-crossing detection. I plan to detect zero-crossing with the Comparator(CA2/3/4 vs. CA1) and generate PWM using Timer1. Timer0 will be used for things like 30
    BLMC_.zip




  9. Like
    Tribes reacted to Lgbeno in Sensorless BLDC motor control   
    Btw, I have quite a few of my bldc boosters sitting around, I could send you one to jump start your code dev, send me a pm if you want one.
  10. Like
    Tribes reacted to hvontres in Sensorless BLDC motor control   
  11. Like
    Tribes reacted to Lgbeno in Sensorless BLDC motor control   
    Sorry, bumped the send button. What I was trying to say was that with the single pin pwm input for the gate drivers, this tells me that they are complementary drivers, ie when the pin is high, high side get is on, when low, low side get is on. This is an issue for bldc because there are 6 different pwm states where you may be driving phase a high side and phase b low side, all other fets need to be off in this state. I don't think that is possible with these gate drivers.
     
    You need to get drivers that have seprate inputs for high side and low side drive, or use 6 single channel drivers. Finding a cost effective gate drive is a difficult thing, especially for these huge 6mohm fets!
  12. Like
    Tribes reacted to Lgbeno in Sensorless BLDC motor control   
    Cool project, I did something very similar as well!
     
    https://github.com/lgbeno/BLDC-Booster
     
    There is software on there too that you are free to reference. It works with some exceptions. The method that I used for commutation is bemf integration similar to the ti instaspin approach. The issues that I had was that for very fast motors(>500Kv), I wasn't sampling the ADC fast enough to get the commutation timing right but for slow motors, it works great.
     
    A few words of wisdom since I worked on this project for quite some time. I would recommend using the 28pin Tssop or qfn32 versions of g2553. Reason being is that it has 3 pins attached to ta1.1 which you can use for the high side pwm signals and 3 pins attached to ta1.2 to be used for low side pwm signals. This does 3 things, frees up timer 0 for something else, allows you to do dead time insertion (if your gate drivers don't already) and just makes your code easier too!
     
    The other thing is that you will see your pwm super imposed on your bemf which will likely cause false trips of the comparator. To solve this, there's a low pass filter but that also introduces a dc offset that throws off your zero cross point.
     
    Long story short, I came up with a different network that filters and then ac couples the bemf to the comparator. I was seeing pretty good results with that approach. Then I had to return my borrowed scope and have not been able to work on it. Good news is I'm getting a brand new Rigol DS2072 for keeps on Thursday.
     
    Anyway I guess that is my project life story, hope it helps. Tomorrow ill try to dig up schematics with those improvements (not in github yet).
     
    Btw the schematics are very inspired by the microkoptor.de schematics, mine are as well... I wonder how they got away with the pwm glitches in their software. Obviously theirs works quite well.
  13. Like
    Tribes got a reaction from rohit in Sensorless BLDC motor control   
    Hi there,
     
    my current project is to build a controller for a sensorless BLDC motor using a MSP430G2553. I want to realize trapezoidal control with Back-EMF/zero-crossing detection. I plan to detect zero-crossing with the Comparator(CA2/3/4 vs. CA1) and generate PWM using Timer1. Timer0 will be used for things like 30
    BLMC_.zip




  14. Like
    Tribes reacted to username in Sensorless BLDC motor control   
    Ya bum, you beat me to it! Very cool idea, what amp current are you hoping for? I assume this is for a quad copter ESC project?
    Lookin forward to seeing more and best of luck!
  15. Like
    Tribes got a reaction from username in Sensorless BLDC motor control   
    Hi there,
     
    my current project is to build a controller for a sensorless BLDC motor using a MSP430G2553. I want to realize trapezoidal control with Back-EMF/zero-crossing detection. I plan to detect zero-crossing with the Comparator(CA2/3/4 vs. CA1) and generate PWM using Timer1. Timer0 will be used for things like 30
    BLMC_.zip




  16. Like
    Tribes reacted to RobG in Community BoosterPacks for Maker Faire Display   
    Make sure you save some space in your suitcase for my display board
     
    Still need to secure all the boards and run power to six of them.
     

  17. Like
    Tribes reacted to GeekDoc in International Workers Day   
    I don't know how much better conditions I can hope for... I just landed a good-paying job with promotion potential, doing what I love (programming), and working from home.  Not sure when I start yet, but I think this'll be the best gig I've ever had!
  18. Like
    Tribes reacted to bluehash in The Booster BoosterPack - LiPo Battery Pack + USB Charger   
    43oh Store  Link
    43oh Doc/Wiki Link
     
    This is a LiPo BoosterPack I have been working during my downtime . I named it Booster since it is a power pack  ;-) This should be perfect for  wireless projects or for those times you need to be away from a PC.
     
    First, features:
    * USB connector for charging
    * Sits over the MSP430 Launchpad and below the Stellaris/C2000 Launchpad with pass-through(excluding inner row for C2000/Stellaris) for all pins including power. 
    * Switch to turn power on/off when in battery mode. When shutdown via a switch, power consumption by the LDO is 0.1uA typical.
    * Charges LiPo battery to 4.2V. Support for one cell.
    * Onboard LDO Microchip MCP1252. Provides 3.3V, 120mA output. 
    * Lipo charger is based around Microchip MCP73831
    * Charge status LED
    * Spans the length of the Launchpad to accommodate different LiPo battery sizes.
     
    The battery needs to be charged through the Booster's USB connector, as there is no way I can pass 5v from the Launchpad to the Booster board. The battery does charge when the usb connector is plugged in. I tested it using the OLED board when connected to the USB port. Also, stacking headers are used for stacking boosterpacks.
     
    I'm having trouble with the charge status LED. It still remains on when the battery reaches 4.2v... still some debugging to do. I have 8 PCBs which I can give away at cost in a GB. If anyone is interested , let me know. I have a few extra batteries too.
     
    Battery vendors:
    Any 3.7v LiPo should work.
    Syma S107 3.7V, 240mA

    43oh_BP_Booster.pdf
  19. Like
    Tribes reacted to Fred in LaunchPad Proto Plate- from Ponoko   
    Well it took me a while and a bit of experimenting, but here's the final result in clear and black acrylic. I shuffled the Launchpad logo around so it wouldn't be covered by the corner pieces and added the 43oh.com logo by @@JWoodrell. The quality on the raster engraving is a little inconsistent on the narrower 43oh.com logo but it's the best I can manage at the moment on my cheap laser. Photographing the black one was tricky as it's very glossy. It was like photographing a mirror.
     
     
     
    The corner pieces glue on very nicely with superglue so I think it'll be easiest if people stick the corners on themselves. That gives the option of using for the Stellaris (or the Fraunchpad will fit but there's no guide engraved for this). I've not got a C2000 so don't know if that will fit. It also means you can go left or right handed without blocking the USB port.
     

    I'll send them off to @@bluehash on Monday. If anyone in Europe want's one then shout and I can mail it directly from the UK.
     
  20. Like
    Tribes reacted to JWoodrell in Well that was a challenge, SNES USB 2.0   
    This is my recent project, ready for board fab.
    It is a MSP430G2553 running the bbUSB stack, and talking to the controller circuitry like my other 1.2 boards.  but this one runs the USB into a 2 port hub chip, and the other port is connected to a micro-SD card so ittl show up as a memory card when you plug the controller in to the PC. there are 4 RGB leds showing out the top of the controller as a battery level bar chart, or whatever I want to use them for.  It has a 1000maH lithium battery in it, with a charge manager chip. as well as the RX/TX Lines to wire in a HC05 into the USCI_B port.  I put a buck/boost regulator in it so it can maintain its voltage off the battery as it drains, the battery charge IC automatically goes to sleep when VBUS is lower than the battery voltage, and since I'm running the + side of the battery through a shottky, it will be when running from battery, but not when plugged into USB, so it will charge the battery on its own when plugged in
     
    overall I am proud of myself, this is easily the most complicated project I've done so far, but I can definitely say I enjoy doing hardware more than software...  hehe
     
    I am surprised that all the traces could be connected, I kinda ran outta room.   the overall board is 35mm x 25mm, 2 sided


     
    the only thing I couldn't implement was a push button to wake up the controller from sleep, but I can wake up periodically and poll a controller button. I just ran out of board space, 6mm of button takes up a huge footprint here.
     
    the charlie-plexed RGB led's were the toughest to fit and route.
     
    Its sad when your hobby starts to feel more like work, but this took a lot of my time the last few days.
     
    here was the original plan on the system I wanted.  I still have the optional reciever board to build, but its gonna be dead simple.

    it looked so simple then, all nice and neat
  21. Like
    Tribes reacted to Philipp in How many 'lego-natives' on this forum?   
    Hey,
    I have an idea for an booster which can connect to two lego motors and two or maybe more lego sensors. Details on this are still in the very early design stage.
    I'm not talking about the newer lego Mindstorms NXT motors with integrated encoders and i2c, i'm talking about the 'old' stuff from the first lego mindstorms or lego train generation:

     
     
    Before beginning to work on this I just want to ask you guys, if you or your kids still do have some of this older Lego Technics stuff and if you're somehow interested in making these lovely motors work with Stellaris and msp430 launchpads.
    Possible applications are basically endless, everyone who had the joy to play with Lego Technic some time ago knows what i'm talking about.
     
    So, what do you think? ;-)
  22. Like
    Tribes reacted to oPossum in 6 channel logic analyzer   
    The LogicBoost is a 6 channel 16 MHz 256 ksample logic anlyzer booster for the MSP430 launchpad. It works with 3 to 5 volt logic levels.

    Many common communication protocols can be observed, such as:
    - Async serial ("UART", "RS-232")
    - SPI
    - IIC
    - Dallas/Maxim one wire
    - Low speed USB (1.5 Mbps)
    - DHT11/22 sensors
    - Consumer infrared and IRDA
    It is also useful for PWM and other applications.
     
    SPI RAM chips are used for the acquisition buffer. This greatly simplifies the design relative to using parallel SRAM chips. The SPI RAM have and internal address counter that eliminates the need for an external address bus and counter. The MSP430 sets up an address and write mode, and then data is clocked into the RAM on every SPI clock.
     

     
    The PCB is 50 x 50 mm for low cost and uses thru-hole components so anyone can build it. An optional FTDI board can be used for faster host communication.

     
    It can be stacked with the Launchpad Mini - also 50 x 50 mm. An FTDI board is required for host communication and power in this configuration.


  23. Like
    Tribes reacted to oPossum in Memory Footprint With a Thermometer Example on Energia   
    It only takes 5 words to make an LED blink on MSP430
     

    ; Blink LED on P1.1 - This will work on most MSP430 .def main main: .word 0x4392, 0x0022, 0xE392, 0x0021, 0x3FFF
  24. Like
    Tribes reacted to larsie in LCD and Touch booster pack   
    I thought I
  25. Like
    Tribes reacted to CorB in LCD and Touch booster pack   
    Hi,
     
    After getting in contact with Larsie I managed to buy one of these modules. I went for the non-touch version since it has a space to mount an MSP chip on a DIP socket, bind that to an Anaren AIR module and you have a neat small package. Better than my current setup where I am using a 16x2 LCD to display the info that goes around in my wireless test-system.
     
    The board arrived swift - not so odd as Norway isnt that far away from the Netherlands - and I got it up and running rather fast. It was easy to use the LCD and the Anaren AIR module together, no needs to configure anything special. Rewriting the old LCD-code to the new SPI-driven setup was easy. Larsie also helped me out connecting the backlight.
     
    Here's how the module looks after installing and creating some code to see the output of the wireless nodes. I even managed to get a graph of one of the nodes that displays the change of its readout. And yep ... no buttons installed yet.

     
    One thing however isnt optimal yet, when the LCD is positioned normally (so you can read it easy) the Anaren AIR module is positioned sideways and the antenna isnt oriented optimally. Next step I am currently working on is using a rotated font and the first steps into that seem to be going in the right direction.
     

     
    Its a nice small display that can be helpfull during development allowing you to have both text and graphics (albeit limited !) on a screen. I am happy Larsie made this and that I am able to use this.
     
    cheers
    Cor
×
×
  • Create New...