Salut,

Revin, dupa aproape 1 an jumate de la ultimul meu articol pe tehnorama, cu proiectul meu de dizertatie.

Dupa ce mi-am ales tema lucrarii (Proiectarea si realizarea unui sistem de conducere a unui robot mobil printr-un labirint), am hotarat impreuna cu coordonatorul lucrarii sa nu mai fac alt robot, cu toate ca acum este foarte simplu cand ai totul la dispozitie pe www.robofun.ro, si sa-l folosesc tot pe ROBOTL (http://www.tehnorama.ro/robotl) care a mai imbatranit cu 1 an jumate.

L-am scos din cutie, l-am sters de praf si m-am apucat sa-i fac unele modificari. Bineinteles ca pentru o rezolutie mai buna la citirea traseului am achizitionat 6 senzori de reflectanta (de linie) si i-am inlocuit pe cei 3 de acelasi tip pe care-i avea ROBOTL.

Din punct de vedere hardware nu au mai fost alte schimbari, exceptand faptul ca am eliminat consumatorii “de efect” (leduri, circuit buzzer) pentru o durata de utilizare mai mare a bateriilor. De asemenea, este important sa subliniez faptul ca am renuntat la bateria de 9V cu care alimentam Arduino pentru ca se consuma exagerat de repede. Am decis sa folosesc 6 baterii de 1,5V pentru o sarcina electrica mai mare. Astfel, MazeBot este cu “un etaj mai sus” decat ROBOTL pentru ca am fost nevoit sa fac spatiu (folosind distantiere) pentru suportul cu cele 6 baterii de 1,5 V. Restul componentelor hardware ale robotului MazeBot le puteti gasi in articolul anterior mentionat, destinat lui ROBOTL.

Partea software se bazeaza pe regula mainii stangi pe perete si un algoritm de optimizare.

In prima etapa, robotul parcurge labirintul conform regulii mana stanga pe perete ce presupune 4 conditii:

1. Daca robotul poate vira stanga , atunci sa vireze stanga.

2. Altfel, daca robotul poate inainta, atunci sa inainteze.

3. Atlfel, daca robotul poate vira dreapta, atunci sa vireze dreapta.

4. Daca robotul este la capat “mort” atunci sa intoarca.

La fiecare decizie, in memoria microcontrollerului se va inregistra o litera corespunzatoare : L, R, S, B (back), D (done) .

In cea de-a doua etapa se parcurge labirintul pe calea optima conform algoritmului de optimizare. Optimizarea inseamna inlocuirea in memoria microcontrollerului a grupurilor formate din 3 litere care contin la mijloc litera B(back) pentru ca asta inseamna ca robotul a facut o intoarcere si a luat-o pe o cale gresita. De exemplu, grupul de litere LBL se va inlocui cu litera S s.a.m.d.

Pentru cei interesati, puteti afla mai multe de aici :

http://www.pololu.com/file/0J195/line-maze-algorithm.pdf http://www.patrickmccabemakes.com/PatrickMccabeMakes/Mazev3.html

Iata rezultatul :

Va multumesc pentru timpul acordat!
Pentru informatii si ajutor in cadrul proiectelor voastre nu ezitati sa ma contactati.
Lucian  (Contact: tarida.lucian@yahoo.com)

proiecte, tutoriale Nici un comentariu

Salutare!

Ei bine m-am potolit cu CNC-ul in apartament (adica asta ), in principal din cauza prafului si a zgomotului infernal, dar si pentru ca tot netul vuia despre asa numitele 3D printers … impropriu spus imprimantele 3D.

In primul rand ce este o imprimanta 3D?

Este o masina de depus material plastic, constituita din 3 axe, sa le spunem X,Y,Z si un mecanism de extrudare pentru filament de plastic numit generic extrudor.
Functioneaza prin topirea materialului plastic si depunerea sa in straturi suprapuse pentru a creea un corp tridimensional.

Acest tip de masinarie exista de ani buni dar preturile sunt imense pentru cele industriale. Prin 2004 insa a aparut proiectul RepRap initiat de prof. Adrian Bowyer de la universitatea din Bath, UK. Proiectul a fost lansat pentru a se creea un 3D printer ieftin, ce isi poate creea propiile componente, in fine cel mai bine vedeti descrierea aici

Proiectul a fost un success si au fost fost creeate mai multe modele de imprimante open source ce au fost si sunt in cotinuare imbunatatite.

Probabil cel mai cunoscut model este Prusa Mendel si cu acesta am decis sa incerc si eu.

Cu ajutorul unui membru letsmakerobots.com din USA care detinea deja o astfel de imprimanta, am putut pune mana pe un set de piese printate pentru structura, un set de LM8UU (rulmenti lineari), setul de piese pritate necesare pentru extrudor si asa numitul hotend pentru aproximativ 200 USD.

Cu electronica am scapat usor, avaind deja driverele si motoarele de la CNC a trebuit doar sa fac o placa cu un ATMega644 pentru a putea rula firmware-ul

In continuare am dat iama prin Hornbach dupa tije filetate de 8 mm, suruburi si piulite.
Barele drepte de 8 mm au fost cel mai greu de gasit, la noi se aduc de la 10 mm in sus, norocul a fost ca aveam cateva bucati de prin imprimante vechi. Diametrele nu au fost perfect egale dar au mers.

Ce a iesit in final arata cam asa:

Iar din spate cu electronica homemade:

Si primul cub reusit:

Evident cu o astfel de jucarie constructia in sine este doar primul pas, urmatorul fiind gasirea setarilor perfecte pentru printuri de calitate.
Mie mi-a luat cam o luna de setat, resetat pana sa reusesc sa scot piese utilizabile cum ar fi cele de mai jos:

Fiind prima imprimanta, Prusa mea a suferit de mai multe probleme inca de la inceput, de exemplu placa pe care se depune am facut-o la repeazala, din niste bucati de parchet laminat ramas prin camara. Desi la inceput a fost OK dupa trecerea iernii a inceput sa lucreze, odata cu inclazirea si s-a lasat. Daca suprafata de depunere nu este perfect plata, in unele locuri plasticul va prinde in altele nu, si se pierde o gramada de timp si plastic.

In cele din urma am decis ca este timpul sa fac alta imprimanta si am ales sa fac un Hugo. Acest design este complet diferit de cel al Prusa si ocupa mai putin spatiu pentru aceeasi suprafata.

Astfel s-a nascut BumbleBee.

Toate piesele de plastic de pe BB au fost printate pe Prusa. Odata ce am terminat de printat piesele, am canibalizat Prusa pentru rulmentii lineari si barele de otel, RIP Prusa.

De data asta am renuntat la a folosi driverele vechi si am luat drivere Pololu bazate pe A4988, mult mai mici in dimensiuni decat ale mele. Driverele sunt montate pe o placa Gen7 pe care am modificat-o pentru a inlocui conectorii cu terminale pe surub.

Mecanic BB e mai stabila decat Prusa si am obtinut printuri mult mai bune calitativ cu ea.

Roti dintate:

Si senile:

Si tancul final:

Software-ul si firmare-ul folosit pentru a controla imprimanta este cel dezvoltat de Repetier pe github aici.

Cu siguranta am uitat cate ceva posturi mai complete gasiti mai jos:

http://letsmakerobots.com/node/29707

http://letsmakerobots.com/node/32879

Si tancul aici:

http://letsmakerobots.com/node/35363

Cam atat

Sarbatori fericite !!

general, proiecte 11 comentarii

Primit pe mail de la Gabi (thx, man ) :

Mi-ati dat tema de casa si dupa cum ma stiu , nu pot avea liniste pana cand nu termin treaba ,prin urmare, deci !
Incarcator auto chinezesc  Xcell pentru Motorola 12-24 V input 5V /500ma output
La input de 7,00 V , in sarcina pe Raspberry , scoate cam 3.9-4,3 V out, stabil , boot decurge ok, server mode cu apache, mysql + script bash de automatizare clima servere. ( fara USB  stick si retea atasate , din lipsa de timp si spatiu)
La input de 6.9 deja nu mai este stabil,se rebooteaza dupa 3 secunde ,si nu este bine
La 7.00 cu stick usb atasat , led-ul de power fluctueaza ca intensitate dar Raspberry ramane stabil ( fara R/W pe stick -lipsa keyboard la indemana in momentul testului).
Consumul raspberry a ajuns la un record de 1,4 W  ceea ce este bine.
Concluzia  : un incarcator de telefon de 16 RON face treaba mai buna decat un stabilizator LM7805 , pragul la care ramane functional este de 7.00V , asta inseamna ca pe robotica din baterii , daca apare un spike de la un motor si bateria cade sub 7.00V Raspberry rebooteaza.
Prin editarea fisierului de clock de la 700 mai jos , este posibil sa functioneze la tensiuni mai joase dar trebuie testat.
Foto trebuiesc prelucrate si vor fi atasate ulterior , aveti acordul meu pentru publicare pe site-ul dvs impreuna cu cele scrise aici.

general Nici un comentariu

Cu multe multumiri d-lui Gheorghe Gainaru, autorul materialului de mai jos, pentru efortul depus si bunavointa de a da rezultatele mai departe.

Click aici pentru a descarca tutorialul in format PDF.

Viorel

general Nici un comentariu

Centrul de Creatie Tehnica pentru Tineret (inventeaza.ro) in colaborare cu Electrical Engineering STudents` European assoCiation Bucuresti (eeStec) organizeaza luni, 29 octombrie 2012 evenimentul de lansare a proiectului “Fotbal Robotic”, care se va derula incepand cu ora 15:00, in Sala Senatului, corp Rectorat, din cadrul Universitatii Politehnice Bucuresti, Splaiul Independentei, nr. 313, sector 6.

Durata evenimentului este de aproximativ 60 de minute, iar acesta va fi structurat in doua sectiuni distincte. In deschiderea evenimentului vor vorbi: Ionut Cotoi, Presedinte al Asociatiei Centrul de Creatie Tehnica pentru Tineret, Radu Manea, Senior Manager al progamului SSM din cadrul Luxoft Romania, un reprezentant din partea Universitatii Politehnice Bucuresti si Rares Curatu, Vice-Presedinte Resurse Umane in cadrul eeStec LC Bucuresti.

Cea de-a doua parte va consta intr-o demonstratie de fotbal robotic, utilizand intregul sistem de joc (roboti, teren, camera video, software comanda wifi).

Robotii urmeaza a fi programati de catre studentii participanti in cadrul celor patru, respectiv patru sedinte de coaching oferite gratuit in cadrul proiectului in perioada 5 – 29 noiembrie 2012.

Organizarea primului campionat de fotbal robotic pentru clasa Mirosot, desfasurat dupa regulamentul Federatiei Internationale de Fotbal Robotic (FIRA) reprezinta un concept educational inedit, adresat studentilor din cadrul universitatilor cu profil tehnic pasionati de electronica, programare si inteligenta artificiala. Acestia se pot inscrie completand formularul online de pe www.fotbalrobotic.ro pana pe data de 2 noiembrie 2012.

Sponsor: Luxoft Romania

Partener academic: Universitatea Politehnica din Bucuresti

Parteneri: Robofun.ro, Gemma Total Advertising, Webefektiv

Parteneri media: Radio Guerrilla, RegieLive, Sapte Seri, PC World, Resboiu, Newsman, Hipo.ro, VideoLink si Hipnotizat de Muzica.

general Nici un comentariu

general Nici un comentariu

Primul campionat de Fotbal Robotic din Romania

general Nici un comentariu

Observand cu mare bucurie ca a ajuns si in romania placa de dezvoltare BeagleBone, am crezut de cuviinta sa  postez realizarile si modificarile mele vis-avis de aceasta placa, sperand sa le fie de ajutor multor incepatori in programare utilizand aceasta placa.

Pentru inceput, dupa ce am achizitionat o astfel de placa, am intrat cu mare interes in lumea extrem de incalcita a celor de la TI vis -avis de AM335X StarterWare, deoarece mie mi-au placut din tot deauna executabilele standalone.

Am achizitionat in acelasi timp Beaglebone, BeagleboneLCD3 cape, Beaglebone Expansion board, BeagleBone Battery cape, PandaBoardES, PandaBoardES LCD/Capacitive touchscreen.

Toate acestea pentru un proiect destul de indraznet, un hexapod ce voi incerca sa il fac sa stie cat mai multe( sa fie la fel de dinamic ca SDK-ul ), dar ca incepator in ARM-uri am inceput cu BeagleBone avand la indemana StarterWare, un inceput perfect pentru un incepator, urmand ca, cu timpul, dezvoltarii AI-ului sa il portez pe un dual core ( PandaBoard).

In fine….

Ca incepator mi sa parut in neregula cand am vazut ca fisierele unui singur driver este imprastiat in 2 pana la 6 foldere si chiar mai multe.

Astfel am inceput sa le asez, drivere la drivere API-uri la API-uri drivere de sistem la drivere de sistem si asa mai departe, dar tot o data si sa impartasesc cu restul programatorilor acest SDK.

Pe langa aceasta “munca de chinez batran” am crezut de cuviinta sa aduc unele modificari referitoare la utilizarea API-urilor si a driverelor.

Consemnez pe de acum ca descrierile eventualelor updateuri vor fi descrise prin modificarea actualului text, si nu prin deschiderea altui thread.

Code Composer Studio avand o forma mult redusa a structurii ‘FILE’ am ajuns la concluzia ca nu poate fi folosita la apelarea functiilor de print, fprint etc, astfel am creeat structuri ce tin toate setarile unui API/driver necesare functionarii corecte fara a ne mai interesa mai departe de setari, ma interesat sa creez un SDK complet dinamic, ce poate fi reconfigurat fara a fi necesara recompilarea programului ci doar schimbarea unor setari din structuri si repornirea driverului respectiv( bine, in aceasta versiune nu este capabil de a reseta module, poate doar sa initializeze module, deci mai am de lucru).

Ca exemplu as putea da:

Pentru a seta o unitate uart trebuie scris urmatorul cod:

 new_uart* DebugCom;/*Variabila globala, sau locala, acesta este un poiter global sau local*/

 DebugCom = new_(new_uart);/*Aloca memoria pentru structura de setari*/
 DebugCom->UartNr = 0;/*numarul modulului uart 0..5*/
 DebugCom->BaudRate = 115200;
 DebugCom->rxFifoTrigLevel = 1;
 DebugCom->txFifoTrigLevel = 1;
 DebugCom->RxBuffSize = 256;
 DebugCom->TxBuffSize = 256;
 UARTOpen(DebugCom, 1);

astfel pointerul “DebugCom” va indica adresa structurii de setari a lui uart0.

Pentru a scrie si citi caractere de la si la unitatea seriala 0 puteti folosi urmatoarele secvente ce se pot gasi si in StarterWare:

UARTPuts(DebugCom, “Hello World!!.\n\r” , -1);

char RxBuff[100];

UARTGets(DebugCom, RxBuff , -1);

Toate functiile din “uartStdio_api.h” sunt adaptate pentru a functiona pe baza acelui pointer.

In acelasi mod sunt concepute toate API-urile din acest SDK, astfel dand voie programatorului sa lucreze complet ierarhic.

Pe langa aceste modificari am mai adaugat:

1. o functie pentru initializarea celor mai importante module din controller.
2. un driver si API LCD pentru BeagleboneLCD3 cape(320×240 16bit).
3. un driver si API pentru touchscreen rezistiv.
4. un driver si API LCD pentru BeagleboneExpansion board (800×480 24bit).
5. un driver si API pentru touchscreen capacitiv cu atingere pana la 5 puncte.
6. un driver si API pentru PMIC sectiunea de control al backlight-ului displayului de la BeagleboneLCD3 cape.
7. un driver si API pentru MMCSD.
8. un driver si API pentru I2C.
9. un driver si API pentru GPIO.
10. un driver si API pentru timerele 2-7.
11. o librarie pentru grafica.
12. un driver pentru EDMA.
13. un API pentru a citi si scrie memorii EEProm de pe busul I2C, inclusiv cea on board.
14. o librarie pentru a creea un numar infinit de timere software de precizie.
15. am implementat libraria de caractere din StarterWare putand avea acces la toate tipurile de caractere de la 12 la 48.

Cele de mai sus sunt “furate” mai mult sau mai putin din StarterWare dar cu multe modificari.

Libraria de grafica are incluse urmatoarele functii:

1. void screen_init(tDisplay* pDisplay);
2. unsigned int  screen_put_pixel(tDisplay *pDisplay, int x, int y, unsigned int Color);
3. unsigned int screen_get_pixel(tDisplay *pDisplay, int x, int y, unsigned int *Color);
4. void screen_clear_color(tDisplay *pDisplay, unsigned int Color);
5. void screen_clear(tDisplay *pDisplay);
6. void screen_set(tDisplay *pDisplay);
7. void screen_backlight_on(tDisplay *pDisplay);
8. void screen_backlight_off(tDisplay *pDisplay);
9. void screen_backlight_level(tDisplay *pDisplay, unsigned int BackLightLevel);
10. void screen_draw_rectangle(tContext *pContext, int x1, int y1, int x2, int y2, unsigned char fill, unsigned int color);
11. void screen_draw_circle(tContext *pContext, int x, int y, int radius, unsigned char fill, unsigned int color);
12. void screen_draw_line(tContext *pContext, int X1, int Y1, int X2, int Y2, unsigned char width, unsigned int color);
13. void screen_draw_horizontal_line(tContext *pContext, int X1, int X2, int Y, unsigned char width, unsigned int color);
14. void screen_draw_vertical_line(tContext *pContext, int Y1, int Y2, int X, unsigned char width, unsigned int color);
15. void screen_draw_elipse(tContext *pContext, int xc,int yc,int rx,int ry, unsigned char Fill, unsigned int Color);
16. int GrStringWidthGet(tContext *pContext, char *pcString, int lLength);
17. void GrStringDraw(tContext *pContext, char *pcString, int lLength, int lX, int lY, unsigned int bOpaque);
18. void GrStringTableSet(void *pvTable);
19. unsigned int GrStringLanguageSet(unsigned short usLangID);
20. unsigned int GrStringGet(int iIndex, char *pcData, unsigned int ulSize);

Functia “screen_backlight_level” poate fi utilizata numai in cazul folosirii BeagleBoneLCD3 cape deoarece foloseste PMIC pentru backlight.

In link-urile de mai jos puteti gasi codul sursa al unui proiect ce utilizeaza acest SDK explicand cum functioneaza, dar si o imagine ce o puteti redenumi “app” si rula de pe cardul SD.

Imagine.

Codul sursa.

Proiectul este configurat pentru a executa urmatoarele actiuni:

1. Initializeaza uart 0, pentru a trimite mesaje in consola.
2. Initializeaza I2C 0 pentru a comunica cu PMIC si cu memoria EEProm onboard.
3. Initializeaza BeagleboneLCD3 cape display.
4. Seteaza backlightul din PMIC la 80%.
5. Initializeaza secventa de calibrare a touchscreenului in doua puncte.
6. Initializeaza un timer software, ce va fi utilizat la contorizarea FPS-urilor si la jocurile de lumini.
7. Initializeaza cei patru pini pe care sunt legate cele paru leduri on board, ca iesiti.
8. Creaza un buffer de 1MB pentru a testa banda de transfer intre controller si DDR.
9. Afiseaza textul “Salutare” cu dimensiunea Cm48.

Dupa care intra in bucla de “Idle”, unde executa urmatoarele actiuni la infinit:

1. Citeste touchscreenul si afiseaza punctul unde este apasat.
2. Creaza un mic joc de lumini cu ajutorul ledurilor on board.
3. Afiseaza in consola numarul de stergeri cu “memset” al bufferului de 1MB pentru a afisa banda de transfer intre controller si DDR.

Tot codul pentru aceste actiuni este:

/*

 * main.c

 */

#define USR_LED_PORT 1
#define USR_LED_0    21
#define USR_LED_1    22
#define USR_LED_2    23
#define USR_LED_3    24

#define E2PROM_ONBOARD_ADDR 0x50

/* Set the screen type */
#define _S035Q01_
//#define _AT070TN92_

/* Set the type of touch screen */
//#define _CapacitiveTouch_
#define _ResistiveTouch_

//#define _TouchDebug_

#define TestRamBandwidthWithMemset
//#define TestRamBandwidthWithForLoop
//#define TestRamBandwidthWithMemsetScreen
//#define TestRamBandwidthWithForLoopScreen
//#define TestSeralEEprom    250
//#define TestMmcSd
//#define TestAudioCodec // This api is not complete, do not define

#include
#include 

#include "main.h"
#include "sys/core_init.h"
#include "sys/sys_timer.h"
//#include "sys/sys_color.h"
#include "api/uartStdio_api.h"
#include "api/twi_api.h"
#include "api/mmcsd_api.h"
#include "api/pmic_api.h"
#include "api/twi_eep_api.h"
#include "api/gfx_api.h"
#include "api/codec_api.h"
#include "api/touch_screen_internal_api.h"
#include "api/touch_screen_ft5x06_api.h"

/* Global pointers of structures */
timer(Timer1);
struct Gpio_Struct *LedUsr0;
struct Gpio_Struct *LedUsr1;
struct Gpio_Struct *LedUsr2;
struct Gpio_Struct *LedUsr3;
new_uart* DebugCom;
new_twi* TWI0;
new_screen* Screen1;
new_screen_context* ScreenContext1;

#ifdef TestAudioCodec
new_mcasp* AudioCodec;
#endif
#ifdef _S035Q01_
new_touchscreen* TouchScreen;
#endif
#ifdef _AT070TN92_
new_ft5x06_touchscreen* TouchScreen;
#endif

void main(void) {

 core_init();
 //sys_color_init();
 /* Set up the UART peripheral for Standard Input/Output operation.*/
 DebugCom = new_(new_uart);
 DebugCom->UartNr = 0;
 DebugCom->BaudRate = 115200;
 DebugCom->rxFifoTrigLevel = 1;
 DebugCom->txFifoTrigLevel = 1;
 DebugCom->RxBuffSize = 256;
 DebugCom->TxBuffSize = 256;
 UARTOpen(DebugCom, 1);
 UARTPuts(DebugCom, "Uart init and config as DebugCom Uart0.\n\r" , -1);
/********************************************************************/
 /* Set up the Twi0 to communicate with PMIC and the Onboard serial EEprom memory */
 TWI0 = new_(new_twi);
 TWI0->BaudRate = 100000;
 TWI0->TwiNr = 0;
 TWI0->Priority = 0;
 TWI0->RxBuffSize = 256;
 TWI0->TxBuffSize = 258;
 twi_open(TWI0);
 UARTPuts(DebugCom, "TWI set up successful at TWI0.\n\r" , -1);
/********************************************************************/
 /* Set up the LCD Screen.*/
#ifdef _AT070TN92_
 Screen1 = new_(new_screen);
 Screen1->LcdType = AT070TN92;
 Screen1->BackLightPort = 1;
 Screen1->BackLightPin = 18;
 screen_init(Screen1);
 UARTPuts(DebugCom, "Screen set up successful.\n\r" , -1);
#endif
#ifdef _S035Q01_
 Screen1 = new_(new_screen);
 Screen1->LcdType = S035Q01;
 Screen1->BackLightLevel = 80;
 Screen1->PmicTwiModuleStruct = TWI0;
 screen_init(Screen1);
 UARTPuts(DebugCom, "Screen set up successful.\n\r" , -1);
#endif
/********************************************************************/
#if defined(_S035Q01_) || defined(_AT070TN92_)
 /* Create screen context */
 ScreenContext1 = new_(new_screen_context);
 /* Set screen context */
 context(ScreenContext1, Screen1, 0xFFFFFF, 0x000000, g_sFontCm48);
#endif
 /********************************************************************/
#ifdef _AT070TN92_
 screen_backlight_on(Screen1);
#endif
#ifdef _S035Q01_
 /* Enable screen backlight.*/
 UARTPuts(DebugCom, "Screen Backlight enabled.\n\r" , -1);
 screen_backlight_level(Screen1, ScreenContext1->pDisplay->BackLightLevel);
 UARTPuts(DebugCom, "Screen Backlight set up to 80%.\n\r" , -1);
#endif
/********************************************************************/
 /* The touch screen is necessary to initialize after Screen init because the
 touch screen use the screen size */
#if defined(_ResistiveTouch_) && (defined(_S035Q01_))
 /* Set up the Touch Screen.*/
 TouchScreen = new_(new_touchscreen);
 TouchScreen->screen_max_x = Screen1->Width;
 TouchScreen->screen_max_y = Screen1->Height;
 InitTouchScreen(TouchScreen);
 UARTPuts(DebugCom, "Touch Screen set up successful.\n\r" , -1);
 UARTPuts(DebugCom, "Init touch screen calibration in two points.\n\r" , -1);
 TouchCalibrate(TouchScreen, Screen1);
 UARTPuts(DebugCom, "Touch screen calibration successful.\n\r" , -1);
 int TouchX, TouchY = 0;
#endif
/********************************************************************/
#if defined(_CapacitiveTouch_) && defined(_AT070TN92_)
 TouchScreen = new_(new_ft5x06_touchscreen);
 TouchScreen->twi_nr = 1;
 TouchScreen->screen_max_x = Screen1->Width;
 TouchScreen->screen_max_y = Screen1->Height;
 ft5x06_init(TouchScreen);
 UARTPuts(DebugCom, "Touch Screen set up successful.\n\r" , -1);
#endif
/********************************************************************/
#ifdef TestMmcSd
 UARTPuts(DebugCom, "MMCSD module set up.\n\r" , -1);
 MMCSD_HardwareInit();
 if(MMCSD_CardInit() == 1)
 {
 UARTPuts(DebugCom, "Card detected and initialized\n\r" , -1);
 char SdMmcBuff[512];
 MMCSDReadCmdSend(&ctrlInfo, SdMmcBuff, 0 , 1);
 UARTPuts(DebugCom, (char*)SdMmcBuff, 512);
 }
 else UARTPuts(DebugCom, "Card not detected\n\r" , -1);
#endif
/********************************************************************/
#ifdef TestSeralEEprom
 /*Test to read first 256 bytes from onboard eeprom chip.*/
 unsigned char TwiBuff[TestSeralEEprom + 2];
 E2promRead(TWI0, E2PROM_ONBOARD_ADDR, 0, TwiBuff, TestSeralEEprom);
 UARTPuts(DebugCom, (char*)TwiBuff, TestSeralEEprom);
#endif

 /* Initialize a software timer for tick on every 250ms*/
 timer_interval(&Timer1, 250);

#if (defined(TestRamBandwidthWithMemset) || defined(TestRamBandwidthWithForLoop)) || ((defined(_S035Q01_) || defined(_AT070TN92_)) && (defined(TestRamBandwidthWithMemsetScreen) || defined(TestRamBandwidthWithForLoopScreen)))
 int Fps = 0;
#endif
 unsigned char USR_LED_STATE = 0;
 LedUsr0 = gpio_assign(USR_LED_PORT, USR_LED_0, GPIO_DIR_OUTPUT);
 LedUsr1 = gpio_assign(USR_LED_PORT, USR_LED_1, GPIO_DIR_OUTPUT);
 LedUsr2 = gpio_assign(USR_LED_PORT, USR_LED_2, GPIO_DIR_OUTPUT);
 LedUsr3 = gpio_assign(USR_LED_PORT, USR_LED_3, GPIO_DIR_OUTPUT);
 /* Black entire screen */
#if defined(_S035Q01_) || defined(_AT070TN92_)
 screen_clear(Screen1);
#endif
 /* White entire screen */
 //screen_set(Screen1);
 /* Audio codec not completed */
#ifdef TestAudioCodec
 AudioCodec = new_(new_mcasp);
 mcasp_init(AudioCodec);
#endif
#if defined(TestRamBandwidthWithMemset) || defined(TestRamBandwidthWithForLoop)
 volatile unsigned char* RamBandwidtchBuffTest = memalign(32, 1024*1024);
#endif
#if defined(_S035Q01_) || defined(_AT070TN92_)
 GrStringDraw(ScreenContext1, "Salutare", -1, 10, 10, 0);
#endif
 while(1){
#if defined(_CapacitiveTouch_) && (defined(_S035Q01_) || defined(_AT070TN92_))
 if(ft5x06_data_ready(TouchScreen))
 {
 ft5x06_read_data(TouchScreen);
 if(TouchScreen->TouchResponse->touch_point &&
 (TouchScreen->TouchResponse->touch_event1 ||
 TouchScreen->TouchResponse->touch_event2 ||
 TouchScreen->TouchResponse->touch_event3 ||
 TouchScreen->TouchResponse->touch_event4 ||
 TouchScreen->TouchResponse->touch_event5))
 {
#ifdef _TouchDebug_
 UARTPuts(DebugCom, "Touch=", -1);
 UARTPutNum(DebugCom, TouchScreen->TouchResponse->touch_point);
 UARTPuts(DebugCom, ",X1=", -1);
 UARTPutNum(DebugCom, TouchScreen->TouchResponse->x1);
 UARTPuts(DebugCom, ",Y1=", -1);
 UARTPutNum(DebugCom, TouchScreen->TouchResponse->y1);
 UARTPuts(DebugCom, ",X2=", -1);
 UARTPutNum(DebugCom, TouchScreen->TouchResponse->x2);
 UARTPuts(DebugCom, ",Y2=", -1);
 UARTPutNum(DebugCom, TouchScreen->TouchResponse->y2);
 UARTPuts(DebugCom, ",X3=", -1);
 UARTPutNum(DebugCom, TouchScreen->TouchResponse->x3);
 UARTPuts(DebugCom, ",Y3=", -1);
 UARTPutNum(DebugCom, TouchScreen->TouchResponse->y3);
 UARTPuts(DebugCom, ",X4=", -1);
 UARTPutNum(DebugCom, TouchScreen->TouchResponse->x4);
 UARTPuts(DebugCom, ",Y4=", -1);
 UARTPutNum(DebugCom, TouchScreen->TouchResponse->y4);
 UARTPuts(DebugCom, ",X5=", -1);
 UARTPutNum(DebugCom, TouchScreen->TouchResponse->x5);
 UARTPuts(DebugCom, ",Y5=", -1);
 UARTPutNum(DebugCom, TouchScreen->TouchResponse->y5);
 UARTPuts(DebugCom, "\n\r", -1);
#endif

 switch(TouchScreen->TouchResponse->touch_point)
 {
 case 5:
 screen_draw_circle(ScreenContext1, TouchScreen->TouchResponse->x5, TouchScreen->TouchResponse->y5, 20, 1, 0xFFFFFF);
 screen_put_pixel(Screen1, TouchScreen->TouchResponse->x5, TouchScreen->TouchResponse->y5, 0xFFFFFF);
 case 4:
 screen_draw_circle(ScreenContext1, TouchScreen->TouchResponse->x4, TouchScreen->TouchResponse->y4, 20, 1, 0xFFFFFF);
 screen_put_pixel(Screen1, TouchScreen->TouchResponse->x4, TouchScreen->TouchResponse->y4, 0xFFFFFF);
 case 3:
 screen_draw_circle(ScreenContext1, TouchScreen->TouchResponse->x3, TouchScreen->TouchResponse->y3, 20, 1, 0xFFFFFF);
 screen_put_pixel(Screen1, TouchScreen->TouchResponse->x3, TouchScreen->TouchResponse->y3, 0xFFFFFF);
 case 2:
 screen_draw_circle(ScreenContext1, TouchScreen->TouchResponse->x2, TouchScreen->TouchResponse->y2, 20, 1, 0xFFFFFF);
 screen_put_pixel(Screen1, TouchScreen->TouchResponse->x2, TouchScreen->TouchResponse->y2, 0xFFFFFF);
 case 1:
 screen_draw_circle(ScreenContext1, TouchScreen->TouchResponse->x1, TouchScreen->TouchResponse->y1, 20, 1, 0xFFFFFF);
 screen_put_pixel(Screen1, TouchScreen->TouchResponse->x1, TouchScreen->TouchResponse->y1, 0xFFFFFF);

 }
 }

 }
#endif
#if defined(_ResistiveTouch_) && (defined(_S035Q01_) || defined(_AT070TN92_))
 if(TouchDetect())
 {
 if(TouchCoOrdGet(TouchScreen, &TouchX, &TouchY))
 {
 screen_put_pixel(Screen1, TouchX, TouchY, 0xFFFFFF);
#ifdef _TouchDebug_
 UARTPuts(DebugCom, "Screen touch detected at: X = ", -1);
 UARTPutNum(DebugCom, TouchX);
 UARTPuts(DebugCom, ", Y = ", -1);
 UARTPutNum(DebugCom, TouchY);
 UARTPuts(DebugCom, "\n\r", -1);
#endif
 }
 }
 //UARTGets(DebugCom, UartBuff, -1);
 //UARTPuts(DebugCom, "\n\r", -1);
 //UARTPuts(DebugCom, UartBuff, -1);
 //UARTPuts(DebugCom, "\n\r", -1);
#endif
 /* Verify if is 250ms tick */
 if(timer_tick(&Timer1))
 {
 if(USR_LED_STATE == 0)
 {
 gpio_out(LedUsr0, 1);
 gpio_out(LedUsr3, 0);
 }
 else if(USR_LED_STATE == 1)
 {
 gpio_out(LedUsr0, 0);
 gpio_out(LedUsr1, 1);
 }
 else if(USR_LED_STATE == 2)
 {
 gpio_out(LedUsr1, 0);
 gpio_out(LedUsr2, 1);
 }
 else if(USR_LED_STATE == 3)
 {
 gpio_out(LedUsr2, 0);
 gpio_out(LedUsr3, 1);
 }
 USR_LED_STATE = (USR_LED_STATE + 1) & 0x03;
#if ((defined(TestRamBandwidthWithMemsetScreen) || defined(TestRamBandwidthWithForLoopScreen)) && (defined(_S035Q01_) || defined(_AT070TN92_)))  || defined(TestRamBandwidthWithMemset) || defined(TestRamBandwidthWithForLoop)
 /* On every 4 ticks of 250ms(1 Second) display the number of screen clears(FPS) */
 if(USR_LED_STATE == 0)
 {
 UARTPuts(DebugCom, "Screen fill capability =", -1);
 UARTPutNum(DebugCom, Fps);
 UARTPuts(DebugCom, "Fps = ", -1);
#if (defined(TestRamBandwidthWithMemsetScreen) || defined(TestRamBandwidthWithForLoopScreen)) && (defined(_S035Q01_) || defined(_AT070TN92_))
 UARTPutNum(DebugCom, Fps * Screen1->Height * Screen1->Width * sizeof(Screen1->DisplayData[0]));
#endif
#if defined(TestRamBandwidthWithMemset) || defined(TestRamBandwidthWithForLoop)
 UARTPutNum(DebugCom, Fps * 1024 * 1024);
#endif
 UARTPuts(DebugCom, "Bytes/s\n\r", -1);
 Fps = 0;
 }
#endif
 }
#if (defined(TestRamBandwidthWithMemsetScreen) || defined(TestRamBandwidthWithForLoopScreen)) && (defined(_S035Q01_) || defined(_AT070TN92_))
#if defined(TestRamBandwidthWithMemsetScreen) && (defined(_S035Q01_) || defined(_AT070TN92_))
 screen_clear(Screen1);
#endif
#if defined(TestRamBandwidthWithForLoopScreen) && (defined(_S035Q01_) || defined(_AT070TN92_))
 screen_clear_color(Screen1, ClrRed);
#endif
 Fps++;
#endif
#if defined(TestRamBandwidthWithMemset)
 if(RamBandwidtchBuffTest) memset((void*)RamBandwidtchBuffTest, 0x00, (1024*1024));
 Fps++;
#endif
#if defined(TestRamBandwidthWithForLoop)
 unsigned int FillTestRamBuff = 0;
 if(RamBandwidtchBuffTest)
 {
 for(; FillTestRamBuff < (1024 * 1024); FillTestRamBuff++)
 {
 RamBandwidtchBuffTest[FillTestRamBuff] = 0;
 }
 }
 Fps++;
#endif

#ifdef TestAudioCodec
 mcasp_idle(AudioCodec);
#endif
 }
}

/***************************** End Of File ***********************************/

Pentru cei ce dispun de BeagleBone Expansion board si un display 800×480 si Touchscreen capacitiv se pot bucura de toata puterea acestora comentand definitiile:

#define _S035Q01_

#define _ResistiveTouch_

si scotand de sub comentariu definitiile:

#define _AT070TN92_

#define _CapacitiveTouch_

Pentru cei ce detin BeagleBone expansion board cu un display 800×480 cu touchscreen rezistiv vor trebui sa comenteze urmatoarea definitie:

#define _S035Q01_

Si sa scoata de sub comentariu definitia:

#define _AT070TN92_

Pentru cei ce nu detin nici una din placile BeagleboneLCD3 cape sau BeagleBone ExpansionBoard cu LCD 800×480 vor trebui sa comenteze urmatoarele definitii:

#define _S035Q01_

#define _ResistiveTouch_

Pentru a utiliza modulul MMCSD este necesara scoaterea de sub comentariu a urmatoarei definitii:

#define TestMmcSd

Pentru a testa (a citi 250 bytes de la EEPromul onboard si al afiza in terminal) este necesara scoaterea de sub comentariu a urmatoarei definitii:

#define TestSeralEEprom    250/* 250 = numarul de bytes ce for fi transferati din memorie catre terminal. */

Dar nu poate depasi “TWI0->RxBuffSize” care este egal cu 256.

Mai multe teste de banda intre controller si DDRam pot fi facute definind doar cate una din urmatoarele definitii:

#define TestRamBandwidthWithMemset

#define TestRamBandwidthWithForLoop

#define TestRamBandwidthWithMemsetScreen

#define TestRamBandwidthWithForLoopScreen

Toate setarile de mai sus sunt raportate la SDK V1.0.

Nu am rezolvat inca cu initializarea cacheului, astfel rata de transfer intre controller si memoria DDR2 este de maxim 60MB/s, deoarece instructiunile nu sunt rulate din cache ci din memoria DDR.

In privinta aceasta am pus intrebarea pe forumul TI sperand ca cineva stie cum se rezolva aceasta problema, si in proiectul de fata este apelata functia “CacheEnable(CACHE_ALL)” dar fara nici un efect.

Precizez ca acest SDK la ora actuala are integrate cam toate driverele si API-urile necesare construirii “creierului” oricarui robot, exceptie facand captura de imagini.

Pe viitor doresc:

1. Sa portez libraria de Fat16/32 din SDK-ul pentru AVR32 AP7000.
2. Sa incerc implementarea driverului de accelerare 2D/3D.
3. Sa portez toate modulele facute din SDK-ul pentru ATxmega(ListBox, CheckBox, ScroolBar, Bytton etc).
4. Sa fac drivere pentru principalii senzor(Giroscop, Accelerare, Compass etc).

V1.1

In aceasta versiune am adaugat foarte multe librarii drivere si functii, toate driverele librariile si apiurile sunt gasite dupa cum urmeaza:

API:

1. Graphic Api.
2. GPIO Api.
3. MMCSD Api.
4. PMIC Api.
5. RTC Api.
6. Capacitive touch screen Api.
7. Resistive touch screen Api.
8. TWI Api.
9. Uart Api.
10. USB api.
11. USB Mass storage Host.
12. USB Mouse host.

Devices:

1. 24c Driver.
2. ADXL345 Driver.

Librarii:

1. Fat 16/32 File system (multi file).
2. Graphic Library.
3. USB Lib.
4. Utility.

Descriere librarii:

1. Fat 16/32 (multi file):

Aceasta librarie initial a fost creata pentru ATxmega si portata pe AVR32 AP7000 si acum pe AM335x.

Aceasta librarie poate fi portata de pe AM335x pe orice controller de 8, 16 sau 32 biti fara modificari.

Cu ajutorul acestei librarii pot fi deschise mai multe discuri in acelasi timp dar si mai multe fisiere de pe discurii in acelasi timp.

De precizat ca in stagiul actual este doar read only, mai am de lucrat pentru ai face si partea de write.

2. Graphic library:

Aceasta este o categorie ce este compusa din mai multe librarii:

• BMP decoder.
• PNG decoder.
• JPG decoder.
• Mpeg video decoder.
• Resurse (fonturi).
• 3D graphic lib (incompleta).
• Button.
• Check box.
• Touch screen keyboard.
• List box.
• Picture box(contine si vertical scroll si horizontal scroll).
• Progress bar.
• Scroll bar(Horizontal si Vertical).
• Text box(contine si vertical scroll si horizontal scroll).
• Utility.

3. Usb lib.

4. Utility.

System:

1. Cache.
2. Core init.
3. ADC pin mux.
4. LCD Pin mux.
5. MII Pin mux.
6. MMCSD Pin mux.
7. SPI Pin mux.
8. TWI Pin mux.
9. Uart Pin mux.
10. Sys color.
11. Sys timers.
12. Sys delay.
13. Watchdog.

O mare realizare in aceasta versiune SDK este ca utilizeaza cache-ul, ceea ce rezulta prin a largi banda de transfer de date intre microcontroller si DDRam la aproximativ 600MB/s, dar pentru lucrul cu blocuri mici de date de exemplu de maxim 32KB viteza de transfer este egala cu viteza procesorului deoarece se lucreaza cu cacheul level 1 care functioneaza la viteza procesorului, pentru blocuri de pana la 256KB latimea de banta poate fi de 1/2 din viteza procesorului deoarece cacheurile level 2 lucreaza la 1/2 din viteza procesorului, totusi trebuie sa tinem cont si de organizarea cacheurilor.

De exemplu cacheurile L1 Date si Instructiuni la AM335x sunt organizare pe 8 Bytes rezultand o latime de banda de maximum Fcore*8 Bytes, Cacheul unificat L2 este organizat pe 4 Bytes iar latima lui de banda este de maximum (Fcore/2) * 4.

Cu ajutorul linkurilor de mai jos puteti descarca Codul sursa, aplicatia binara si fisierul . out.

Codul sursa este reprezentat printr-o aplicatie ce utilizeaza cateva apiuri si librarii din aceste SDK dupa cum urmeaza:

• Initializeaza modulele de baza ale controllerului(initializeazaq MMU, Cache, Branch Prediction, L3L4, Master IRQ, AINTC, Software Timers, GPIO Port 0,1,2 si 3).
• Initializeaza culorile de system ce sunt utilizate pentru skin.
• Initializeaza Uart0 pentru debug.
• Initializeaza RTC.
• Initializeaza USB host Mass storage.
• Initializeaza TWI 0, 1 si 2.
• Initializeaza layerul principal de 480×800 pixeli al LCD-ului(acesta este layerul principal, bufferul de randare al displayului).
• Initializeaza layerul secundar de 1300×760 pixeli al LCD-ului(acest layer este mai mare ca dimensiune decat displayul, astfel in partea dreapta se afla un scroll bar cu care se poate da scroll al acestui layer pe verticala peste layerul principal).
• Deschide backlightul pentru display.
• Initializeaza Touchscreenul capacitiv.
• Creaza 3 timere software: unul de 1000ms unul de 20ms si unul de 40ms(1000ms in principal pentru leduri, 20ms pentru pentru scanarea touchscreenului, 40ms pentru scanarea accelerometrului de pe placa de extensie(in cazul in care se foloseste)).
• Seteaza cei patru pini pe care sunt plasate cele 4 leduri on board.
• Initializeaza senzorul de accelerare ADXL345.
• Scrie pe layerul principal textul “Salu\r\ntare”(acest text este scris doar din motive de test al layerului principal, acesta nu va putea fi vazut decat daca se plaseaza un breackpoint imediat dupa functia de scrie acest text, la suprapunerea layerului secundar acest text va fi automat sters).
• Creaza un buton pe layerul secundar, ce va fi folosit la setarea RTC.
• Creaza un progress bar pe layerul secundar, de proba.
• Creaza un check box pe layerul secundar, cand este cheched va rula filmul in primul picture box, cand va fi uncheched playerului i se va da comanda stop.
• Creaza o tastatura virtuala pe layerul principal, de proba.
• Creaza un List box pe layerul secundar, de proba, si il umple cu cateva itemuri.
• Creaza un text box pe layerul secundar, de proba.
• Creaza un scroll bar in dreapta pe layerul principal pentru a da scroll layerului secundar peste cel principal.
• Creaza un picture box pe layerul secundar unde poate fi afizat filmul decodat cu libraria mpeg1/2.
• Creaza un scroll bar pe layerul secundar pentru a indica stadiul in care se afla filmul rulat in primul picture box, si pentru ca prin atingerea lui a indica playerului de unde sa continue sa ruleze filmul.
• Creaza un buton pe layerul secundar pentru a forta playerul sa dea play la urmatorul fisier video de pe disk.
• Creaza un picture box pe layerul secundar unde in timp ce filmul rulat pe primul picture box nu ruleaza pe al doilea picture box se roteste in 3D un cub.
• Creaza un scroll bar pe layerul secundar pentru a regla variabila depth in cazul in care este activata functia de desenare al unui cub 3D in picturebox.
• Creaze un checkbox pe layerul secundar pentru a activa sau dezactiva raportarea catre terminal al datelor de accelerare al ADXL345.

De precizat ca libraria de decodare a fisierelor MPEg1 si MPEG2 ruleaza corect numai fisiere convertite de VLC, deoarece si VLC foloseste aceeasi librarie de codare/decodare, iar aceasta librarie nu suporta toate formatele MPEG1/2.

Controllerul poate decoda fisiere cu rezolutia de 320×240 fara blocari la frecventa de 500Mhz cu cat este setat de gatre GEL si bootloader.

Pentru a rula fisiere cu rezolutie mai mare este necesara setarea frecventei la cel putin 720Mhz.

De precizat si ca aceasta versiune SDK foloseste doar acceleratorul NEON, dar libraria de decodare MPEG nu este in totalitate optimizata pentru a functiona cu acest accelerator, si nu foloseste acceleratorul 2D/3D integrat.

Pentru a rula fisiere MPEG1/2 este necesar sa folositi un Hard disk USB sau un memory stick iar pe acestea sa fie plasate fisiere cu extensia .mpg si convertite de catre VLC, nu sunt acceptate adaptoare card readere sau huburi usb.

Datorita configuratiei placii de extensie a placii beaglebone inca nu pot termina sectiunea audio, deci filmele vor fi mute .

Daca activati RTC este posibil ca dupa un anumit numar de intreruperi a RTC-ului controllerul sa raporteze o exceptie, am ajuns la concluzia ca aceasta exceptie este generata de un conflict intre citirea registrilor RTC si updatarea registrilor de catre RTC, aceasta exceptie va trebui sa o rezolv cumva mai devreme sau mai tarziu.

Pentru a vedea numarul de FPS-uri al filmului rulat scoateti de sub comentariu “#define UseRtc” astfel in terminal vi se va raporta numarul de FPS-uri.

Pentru a rula executabilele aveti nevoie de o placa beaglebone, o placa beaglebone expansion, si un display cu touchscreen capacitiv.

Personal am luat displayul cu touchscreen capacitiv de la placa de extensie a pandaboard, cu precizarea ca pentru a conecta touchscreenul de la acest display trebuie intoarsa banda de pe conectorul de la controllerul de la display, la pandaboard pinii sunt numerotati 1..5 iar la beaglebone sunt numerotati 5..1, conectorul de pe controllerul de touchscreen suportand conectarea benzii in ambele sensuri(direct cat si invers).

Va continua……..

proiecte Nici un comentariu

Buna Ziua

Robotul a fost conceput pentru un concurs nationl de practica initial era numa radio comandat  dar ulterior am decis sa fac un pas mare inainte si am facut un mic programel in arduino

Nu este cel mai bun program sau cel mai perfectionat pentru ca eu am experienta O in domeniul acesta, si ca sa nu vorbim si de bugetul relativ redus si timpul (aproximativ o luna)

Si acum gata cu cuvintele in vant sa trecem direct la el

Cateva informatii tehnice.

- Are 2 moduri de functionare

-Automat(arduino)

-Radiocomanda

-Este construit in jurul platformei de dezvoltare arduino

-Ca parte mecanica contine

-1 servomotor standard de 11kg/cm

-4 servomotoare standard de 7kg/cm

-1 servomotor nano de 2,5kg/cm (pentru griper)

Sasiul este confectionat din Acrilic(plexiglas)

Este proiectat in corel draw si ulterior taiat cu laserul. UN VIDEOCLP cu ROBOTELUL IN ACTIUNE…………..

Voi reveni cu mai multe amanunte despre  acest proiect, dar daca aveti intrebari sau  comentari le astept cu drag

mentionez ca sunt un novice in post’uri

Arduino & Mac OSX, general, proiecte 2 comentarii

Există scule bune și scule proaste. Tot ce pare a fi “între” cade, de fapt, într-una dintre aceste două categorii.

Acum aproape un an căutam în disperare o stație de lipit “decentă”, pentru micile mele proiecte electronice. Începusem un proiect destul de ambițios, pe care l-am continuat în decursul timpului cu un progres de melc, dar pe care nu l-am abandonat niciodată. Ideea a fost să avansez la un prototip pentru monitorizarea multiplelor plante care îmi împodobesc casa și să în integrez cu o aplicație prin care să pot avea acces, mobil, de oriunde, la datele în timp real.

Am redescoperit, cu acea ocazie, mitocănia ofertei din domeniu de pe piața autohtonă. Majoritatea uneltelor fie sunt mizerabile, fie se găsesc doar cu comandă specială, iar atunci trebuie să plătești cam de două ori prețul lor de pe piața vest-europeană. Măgăria distribuitorilor din România m-a decepționat (am încercat cam zece): fie mi se prezentau diverse variante (care mai de care mai proaste), fie mi se argumenta sec că nu există cerere, fie alte baliverne de gen. Unii nici nu s-au sinchisit să-mi trimită o ofertă (“big mistake”), nume cu pretenții în distribuția acestor produse. În realitate, e vorba de aceeași indiferență, disperare și lăcomie care, din păcate, caracterizează o mare parte a celor de aici, mai mult interesați de “tunuri” decât de o relație civilizată cu clientul. Am pus cruce căutărilor în momentul în care am primit o ofertă pentru un Weller WHS 40D pe care am comparat-o cu prețul din Germania și am constatat că îl depășea de aproximativ 1.8 ori. Argumentul au fost taxele vamale (???!!!) = tupeul șmecherului care vrea cu dinadinsul să te considere fraier. Până la urmă, nu știu cine este fraierul și nici nu-mi mai pasă:  mi-am comandat acel WHS 40D, adus ulterior de o cunoștință care venea din Germania.

În urmă cu două săptămâni, am decis că e momentul să fac un upgrade și să trec la ceva cu adevărat serios. Și, fiind la rândul meu în țara Land-urilor, mi-am comandat, tot de pe amazon.de, acest Weller WD 1000 M care a ajuns într-o zi la adresa hotelului în care am stat, fără taxe de transport și cu un discount consistent, astfel că, facturat, a fost în final undeva pe la 485 euro. Dacă aveți chef, comparați cu ofertele de aici și o să aveți un șoc (dacă veți primi vreo ofertă). Ceea ce confirmă statutul de “piață mizerabilă” cu care ne-am cam obișnuit prea ușor (din păcate). Apropos, WHS-ul 40D cred că îl voi păstra (încă nu m-am hotărât). Deși mai slab (40 W față de 55 W) și mai amatoricesc, depășește oricum calitativ orice stație asemănătoare de pe aici.

Nu sunt adeptul pocnitorilor și nici al filosofiei “merge, tată, și așa”. De fapt, “merge” împiedicat și peticit. Iar, în anumite situații, nu “merge” absolut deloc. Simți imediat diferența de calitate în momentul în care începi să lucrezi: de la finisajul lucrărilor și până la ergonomia în utilizare – aceste unelte au fost gândite să ofere performanțe, nu să te chinui cu ele. Acest articol va prezenta multe imagini și câteva comentarii. Nu voi intra în multe detalii deocamdată, vreau să-l pun la lucru și o să revin cu ceva completări. Scopul acestor rânduri este să prezinte succint “scula” și să vă determine să vă gândiți de mai multe ori atunci când veți cântări opțiunile, chiar pentru proiecte gen hobby.

Da, e “Made in Germany”, nu “in China” și asta se simte la primul contact: cutia (ambalajul) e imensă (de fapt am lăsat-o la hotel fiindcă nu avea rost să o iau cu mine), cu un sistem extrem de inteligent de ancorare și protecție a obiectelor livrate:

1. Stația WD 1M (în imagine)
2. Suportul WMRT cu senzor magnetic (imaginea de mai jos)
3. “Creionul” de lipit WMRP cu cablu și mufă
4. Vârful termic RT3 (atinge 400^oC în 4 secunde !!!)
5. Burete de bronz/ alamă (ce-o fi)
6. CD cu manual, soft și drivere pentru control prin PC (suportă doar vindoze).
7. Un cablu USB mini->tip B sexy, genul extensibil, pentru interconectare
8. Mufă jack 90^o pentru cupla de împământare
9. Manuale (multe), certificat garanție, factură etc.; apropos, manualele sunt traduse în toate limbile din CE (plus rusă), nordice (cele din afara CE), dar nu și Bulgară și Română. Și considerând slovena o variantă slavă foarte apropiată de sârbă și croată, o socoteală simplă aduce numărul țărilor suportate la nivel paneuropean cu excepția Albaniei, Bulgariei și României. Felicitări ! Dar nu mă miră, având în vedere atitudinea celor de aici.

Construcția este ireproșabilă și întregul ansamblu dă senzația de soliditate. Stația centrală de transformare și control WD 1M cântărește 4,4 Kg, iar tot “pachetul” ajunge undeva pe la 7,5 Kg. Întâmplător știu că aceste cifre sunt foarte exacte deoarece a trebuit să-mi cântăresc bagajul pentru a nu avea suprize la aeroport.

Carcasa vernil este din plastic (ceva gen policarbonat), extrem de dură și de solidă la atingere. Jumătatea inferioară și posterioară – din metal (se observă radiatorul), iar jumătatea inferioară și anterioară, din plastic.

Voi reveni cu detalii în utilizare într-un review ulterior.

O zi bună.

Review-uri, general 5 comentarii

arduino assembler atingere atmega168 atmega328 bootloader brick buton buzzer CNC debug DHCP DNS Ethernet fire gsm/gprs http infrarosu Internet joystick lcd led lumina microcontroller microfon post potentiometru R-Dev-Ino releu rgb roboduino robot robot majordom senzor senzor PIR serial server servo shield space sunet telecomanda IR temperatura umiditate weather clock