Moro. Tuli tarve mittalaitteille pikku sumoreen ja noissa digitönäreissä kun ei oikeen riitä pituus edes tähän pieneen jyrsimeen.
aloin miettiä muuta vaihtoehtoa en tiedä onnistuuko mutta koitetaan ainakin.
eli ostin ebaysta ison tulostimen encoderinauhaa 15€ 1.5metriä ja encoderin 8€. ei ole hinnan kiroissa.
tämä nauha on 600dpi koneesta eli pääsee 4 satkun resoluutioon 1200dpi: täkin on tarjolla.
mutta mulle riittää toikin nyt tässä vaiheessa.mittasauvan tein alu-u profiilista johon nauhan asetin kahden muovisoiron avulla.
encoderiin liimasin muovipalan liukupalaksi ja kulmalista pitää sitä urassa.encoderia lukee avr xmega128 jossa on tulot kolmelle encoderille.
kokeilut vasta yhdellä.encoderin luku toimii ja tulostuskin, mutta vielä en keksinyt miten skaalaan tuon rekisterin arvon millimetreiksi.
tuo kerroin kun ei ole tasaluku. pari kuvaa ja video toiminnasta . saa nähdä pääseekö maaliin tässäkään projektissa ;)
Hieno homma.
Onko kyseessä tämän tapainen "magnetic tape":
http://www.machine-dro.co.uk/index.php?target=categories&category_id=59
Vai optinen nauha?
Mistä ostit ja mikä oli hintaluokka? Luvataanko tolle jotain speksiäkin?
Pekka
Lainaus käyttäjältä: jussi - 15.05.11 - klo:20:57[...] encoderia lukee avr xmega128 jossa on tulot kolmelle encoderille.
kokeilut vasta yhdellä.encoderin luku toimii ja tulostuskin, mutta vielä en keksinyt miten skaalaan tuon rekisterin arvon millimetreiksi.
tuo kerroin kun ei ole tasaluku. [...]
Asema-anturin mittaustiedon muunto on helppoa kuin heinänteko. Ainakin melkein. Tällaista voisi soveltaa:
1. Asematieto ylläpidetään kiinteän pilkun muuttujassa jonka kokonais- ja murto-osien tarkkuus vastaa haluttua arvoaluetta ja resoluutiota. Esimerkin vuoksi oletetaan, että tarkkuudeksi riittää S15.16, eli etumerkillinen 15-bittinen kokonaisosa ja 16-bittinen murto-osa. Jos 1 kokonaisosan bitti on millin niin liikeala on 15 metriä ja rapiat +/- suunnissa, ja tarkkuus on 1/65536 milliä eli harrastelukäyttöön ehkä just riittävä :)
Muuttuja on siis C-kielen long integer-tyyppiä ja ylemmässä 16 bitin sanassa on kokonaisosa ja alemmassa murto-osa.
2. Jokainen enkooderin inkrementti lisätään / vähennetään asematietoon aina liikesuunnan mukaan. Enkooderin pulssia vastaava lukema saadaan laskemalla seuraavasti. Oletetaan että x = enkooderin yhden inkrementin liikematka. Tällöin ohjelmallinen inkrementti on HEX( x * 65536). Jos vaikka x = 0,025 mm/pulssi, niin inkrementti on HEX( 0,025 * 65536) = 0x666.
3. Asematieto muunnetaan desimaaliseksi melkein suoraviivaisesti seuraavin askelin:
3.1 Kokonaisosa menee helposti ajonaikaisen vakiokirjaston itoa-funktiolla (löytyy ainakin esim WinAVRstä ja pitäisi löytyä kaikista C-kirjastoista). Tällä saadaan kokonaisosaa vastaava merkkijono jonka voi suoraan heittää merkkinäytölle. BCD-luvuksi muuntoon löytynee vastaavat avut.
3.2 Murto-osa on pikkasen työläämpi, mutta onnistuu näin pseudokoodattuna:
byte base = 0x0a // muunnoksen kantaluku. Tässä 10 eli A. Mikä vaan muukin kantaluku toimii.
unsigned long temp;
byte nextBCD;
char nextdigit;
temp = low word(asematieto); // asematiedon murto-osa 32-bittiseen etumerkittömään muuttujaan temp
if (temp < 0) { // tsekataan että on positiivinen ja käännetään tarvittaessa (otetaan 2-komplementti)
temp = temp xor 0xffff;
temp = temp +1;
}
while (temp >0) { // kierretään tässä silmukassa kunne murto-osa on kokonan käsitelty
temp = temp * base; // temp-muuttujan yläsanan alemmassa tavussa on nyt seuraava murto-osan numero
nextBCD = temp >> 16; // nextBCD-muuttujaan viedään temp:in toka tavu ylhäältä lukien. Tämä on seuraava murto-osan
// desimaalinumero
nextdigit = itoa(nextBCD); // muunnetaan saatu luku merkiksi jos halutaan lisätä se merkkijonoon tms.
temp = temp and 0xffff; // putsataan saatu numero pois tempin yläosasta ja jatketaan alaosan kanssa
}Yhdistämällä kokonais- ja murto-osat sopivasti saadaan siis asema esitettyä desimaalisena halutulla tavalla.
LainaaVai optinen nauha?
kyllä siis optinen nauha kyseessä ja nauha oli tosiaan ebayssa noin 15€ 1.5metriä ja sensori noin 8€ mitään datalehdyköitä en noista varsinaisesti löytänyt netistä toi 600dpi nauha on 150lpi ja sillä pääsee tosiaan tuohon 4satasen tarkkuuteen mikäli nyt oikein olen ymmärtäny.
LainaaAsema-anturin mittaustiedon muunto on helppoa kuin heinänteko
Varmaan joo jos osais tehdä heinääkin 8)
Kiitos esimerkistä .
Ihan se ei mulle vielä auennu mutta pitää pureskella sitä rauhassa.
Lainaus käyttäjältä: jussi - 16.05.11 - klo:16:40[...]
Kiitos esimerkistä .
Ihan se ei mulle vielä auennu mutta pitää pureskella sitä rauhassa.
No joo toi oli äkkiä kiireessä kyhätty esitys. Kyllä voin avata sitä lisääkin, kysy vaan mikä kohta ei auennut.
Täältä tulee kysymyksiä :-[
Mikä on kiinteänpilkun muuttuja?
Miten saan luettua tuon long int muuttujan ylä ja alasanan ?
sellaisen asian huomasin,että kun asematietomuuttuja päivittyy tuolta laskurin rekisteristä jos sen määrittää int. laskurin tullessa nollaan se kääntyy negatiiviseksi.
mutta jos määritys on long int se jatkaa nollan jälkeen 65536:desta alaspäin eikä muutu negatiiviseksi.ei ymmärrä.
tuolla tulostan sen negatiiviseksi
if (TIMER_value < 0)
{
lcd_putc(0x2d);
TIMER_value = ~TIMER_value;
TIMER_value+=1;
}
tässä noin aluksi :)
Taitaapa olla siten että kakkosen komplementista on kysymys eli binääriluvun esitysmuodosta. Heksana nolla on 0x0000 ja kun tuosta vähentää ykkösen on lopputulos 0xFFFF eli sanan kaikki bitit ovat pystyssä. C-kielessä int on koneen sanan pituinen jos toteutus noudattaa standardia. int-tyypissä ensimmäinen bitti tulkitaan etumerkiksi, unsigned int -tyypissä taas ensimmäinenkin bitti kuuluu numeroroon mukaan. long int on pidempi eli tässä tapauksessa varmaankin ainakin 32 bittiä joten siinä esitysmuodossa etumerkkibitti on kauampana vasemmalla ja kun se sattuu tässä tapauksessa olemaan nolla niin muistipaikkojen sisältö tulkitaan eritavalla. Joka tapauksessa muistissa esitysmuoto on varmaan kunnossa, mutta sovellus käsittelee lukuja 'väärin'.
yläsanan ja alasanan saa vaikka seuraavasti, olkoot x muuttuja josta pitää sanat erottaa:
alasana = x && 0x0000FFFF; // and-bittioperaatiolla nollataan ylimmät 8 bittiä
alasana = x >> 8; // siirretään bittejä oikealle 8 pykälää, vasempaan reunaan tulee nollia
Niin ja tuossa huomioi sitten oikeasti sanan pituus (8 vai 16 bittiä), esimerkki kahdeksalla bitillä.
Jos ei auennut niin kysy, kerrotaan lisää. Tällä palstalla on useita c-kielen taitajia.
Lainaus käyttäjältä: jussi - 17.05.11 - klo:16:43
Täältä tulee kysymyksiä :-[
Mikä on kiinteänpilkun muuttuja?
Muuttujia on kolmenlaisia. Kokonaislukumuuttujat kuten char, int, long jotka ovat niitä leipämuuttujia.
Numeerisessa laskennassa joudutaan kuitenkin käsittelemään muuttujia joiden arvoalueet ovat hyvin laajat sekä suuriin että pieniin arvoihin päin (siis lähelle nollaa). Jotta voitaisi samalla muuttujatyypillä käsitellä sekä hyvin isoja että hyvin pieniä lukuja, on keksittävä jotain parempaa kuin kokonaisluvut. Tämä parempi keksintö on kahtalainen: kiinteän pilkun luvut ja liukuluvut (floating point). Liukuluku esitetään muodossa etumerkki/eksponentti/mantissa missä eksponentille ja mantissalle on varattu bittejä vähän prosessorin kapasiteetista ja nimenomaisesta liukulukutyypistä riippuen. AVR-prosessorit tukevat 32-bittisiä likulukutyyppejä (float). Kts lisää täältä: http://fi.wikipedia.org/wiki/Liukuluku (http://fi.wikipedia.org/wiki/Liukuluku)
Kiinteän pilkun esityksessä sekä luvun kokonais- että murto-osat esitetään "kokonaislukuna" joille kummallekin on varattu tarkoituksenmukainen määrä bittejä, esim etumerkki+15b kokonaisosa+16b murto-osa. Tämä oli se esitys jota aiemmin ehdotin, mutta mikä tahansa muukin jako tulee kyseeseen sen mukaan mikä on tarkoituksenmukaista.
Yleensä kiinteän pilkun aritmetiikka on nopeampaa, ja käytännössä näin on aina "tehottomammilla" prosessoreilla kuten nämä AVR:t. Sitten kun puhutaan 3 gigan neliydinpenasta jossa on integroitu aritmetiikkaprosessori niin asialla ei ole juurikaan väliä ja liukuluvut ovat yleensä suoraviivaisin vaihtoehto. Suomenkielinen wikipedia ei tunnu tästä tietävän, mutta englanniksi löytyy tällainen: http://en.wikipedia.org/wiki/Fixed_point_number (http://en.wikipedia.org/wiki/Fixed_point_number)
AVR-gcc ja erityisesti AVR-libc tuntevat suoraan siis float-muuttujatyypin mutta eivät mitään kiinteän pilkun tyyppiä. Sen takia kaikki operaatiot on koodattava itse tai haettava netistä joku sopiva kirjastopaketti.
Lainaa
Miten saan luettua tuon long int muuttujan ylä ja alasanan ?
long pitkamuuttuja;
int ylamuuttuja;
word alamuuttuja;
alamuuttuja = pitkamuuttuja // C-kääntäjä tekee automaattisen tyyppimuunnoksen ja heittää mäkeen longin yläosan.
alamuuttuja = pitkamuuttuja & 0xffff; // asianmukaisempi keino jossa ei jätetä mitään sattuman varaan
ylamuuttuja = pitkamuuttuja >> 16; // oikealle shiftaus ( >> ) 16 kertaa siirtää longin 16 ylintä bittiä int-muuttujaan
Lainaa
sellaisen asian huomasin,että kun asematietomuuttuja päivittyy tuolta laskurin rekisteristä jos sen määrittää int. laskurin tullessa nollaan se kääntyy negatiiviseksi.
mutta jos määritys on long int se jatkaa nollan jälkeen 655536:desta alaspäin eikä muutu negatiiviseksi.ei ymmärrä.
Long-tyypin arvoalue on 65-tuhatkertainen 16-bittiseen laskuriin nähden, joten sen etumerkki ei lainkaan seuraa int-pituisen muuttujan etumerkkiä tuossa sijoituslauseessa. Eli 2-komplementtiesityksessä 16-bittisen muuttujan ylin bitti määrää etumerkin (1 = negatiivinen). Long-tyypiossä tämän yläpuolelle jää sijoituksessa edelleen 16 kpl 0-bittejä joten long ei tällä tavalla muutu negatiiviseksi. Jos haluat tuon sijoituksen tehdä, niin joudut sijoittamaan ylimpiin 16 bittiin etumerkkiä vastaavan bitin. Esim tähän tyyliin:
long pitkaluku;
int lyhytluku;
pitkaluku = lyhytluku; // tämä ei vielä riitä, vaan:
if (lyhytluku < 0) { // jos lyhyt integer on negatiivinen, eli ylin bitti on 1, niin kopioidaan se pitkan ylaosaan
pitkaluku = pitkaluku ^ 0xffff0000;
}
Tuo xmegan laskuri on int "tyyppinen" joten C-ohjelmassa se pitää määritellä int:iksi, muuten käy juuri kuten sinulle kävi. Nyt vaan on niin, että int-tyypin arvoalue +/- 32 tuhatta ja rapiat ei alkuunkaan riitä, juuri tuon numeerisen laskennan vaatimuksista johtuen, mihin edellä viittasin. Tästä syystä joudut todennäköisesti kehittämään systeemin jolla lasket nuo pulssit ohjelmallisesti. Joko suoraan keskeytysohjelmalla yksitellen tai mikäli pulsseja tulee niin nopeasti ettei ehdi, niin sitten käyttämällä tuota prosessorin hardware-laskuria ja sen ylivuotokeskeytysta jolla tunnistat laskurin ympäripyörähtämisen. Todellinen asema tallennetaan silloin ohjelmallisesti niin, että alempi sana on hardware-laskurissa ja ylempi sana ohjelmassa. Ylempää sanaa kasvatetaan / vähennetään sitten aina hardware-laskurin yli/alivuodosta. Desimaalinen näytettävä asema lasketaan ja muunnetaan sitten noista muuttujista kuten edellä on esitetty.
Lainaa
tuolla tulostan sen negatiiviseksi
if (TIMER_value < 0)
{
lcd_putc(0x2d);
TIMER_value = ~TIMER_value;
TIMER_value+=1;
}
tässä noin aluksi :)
Taitaisi toimia myös
TIMER_value = -TIMER_value;
LainaaTaitaisi toimia myös
TIMER_value = -TIMER_value;
jep niinpä näyttää toimivan :)
Mietinkin tuota keskeytystä jo aiemmin ,mutta mulle jäi sellanen käsitys että kun qdec on otettu käyttöön niin keskeytyksen saa vain index pulssilla.
eli tuo timer/counter owerflow on siis mahdollinen vaikka on qdec kaytössä
Lainaus käyttäjältä: jussi - 17.05.11 - klo:22:55
Mietinkin tuota keskeytystä jo aiemmin ,mutta mulle jäi sellanen käsitys että kun qdec on otettu käyttöön niin keskeytyksen saa vain index pulssilla.
eli tuo timer/counter owerflow on siis mahdollinen vaikka on qdec kaytössä
Mä olen viime ajat Atmelin piireistä pelannut enempi noiden 32-bittisten UC3 sarjalaisten kanssa enkä nyt ihan ulkoa muista miten noi xmegan QDEC-eventit ja niihin yhdistetyt laskurit käyttäytyi. Tuosta viivaimesta ei tietty mitään indeksipulssia saa joten indeksillä resetti jää pois, eikä sitä mihinkään tarvitakaan. Kvadratuuridekooderille piti muistaakseni kertoa montako reunaa kierroksella anturi antaa ja se on nyt hankaluus lineaarienkooderin tapauksessa. Määrän voi tietty asettaa laskurin max. arvoon ja jos konfaa indeksin pois käytöstä niin kaipa tuon pitäisi toimia. Tarttisi kokeilla, miten laskuri antaa yli/alivuotokeskeytyksiä tai eventtejä tuossa tapauksessa, mutta mulla on nyt viritetty toisenlaiset piirikannat kehityspenkkiin niin en pääse samantien kokeilmaan.
Varmaan tuota joutuu vähän protoilemaan, mutta uskon kyllä että sen saa jollain konstilla toimimaan.
Vielä tähän aiheeseen: yksi suosittu kiinteän pilkun open source-kirjasto löytyy täältä: http://code.google.com/p/libfixmath/downloads/detail?name=libfixmath_r37.zip (http://code.google.com/p/libfixmath/downloads/detail?name=libfixmath_r37.zip). Minusta se ei enää vaadi 64-bittisten perusmuuttujien tukea ainakaan kaikille operaatioille eli on käyttökelpoinen AVR:nkin kanssa (joskaan en ole itse juuri tuota kokeillut).
Kirjasto toteuttaa mm. koneenohjauksessa ja erilaisissa säätäjissä tuiki tarpeelliset saturoituvat operaatiot. Tämä tarkoittaa, että arvoalueiden ylityksissä kirjasto käyttäytyy sivistyneesti ja muuttujat jäävät makaamaan ns. "tappiin" pyörähtelemättä ympäri tms hölmöä.
Kun käytät Atmelin prosessoria niin kiinnostava voisi olla myös UC32-perheen Software Frameworkiin kuuluva DSPLib-toteutus. Se ei suoraan ole ajokelpoinen xmegassa mutta jos sen sorsat löytyisi jostain niin siellä on kaikki yleisimmät digitaalisen signaalinkäsittelyn operaatiot - perusaritmetiikka, trigonometriset funktiot sekä ainakin Fourier-muunnos, lineaarinen konvoluutio, FIR ja IIR-suotimet ja muutakin. Noita viilaamalla voisi saada käyttökelpoista myös xmegalle.
Nonniin ;D ihmeiden aika ei ole ohi.sain sen näyttämään millejä kymppejä ja satkut pyöristetty lähimpään vitoseen tai nollaan. Nopealla mittauksellä näyttäis vieläpä oikeelta. toivotaan että on myös kun saa tarkemmin mitattua.
Nyt vaan hommaamaan 4rivinen3.3v näyttö ja pari encoder sensoria lisää.
Kiitokset Taurulle ja Kremmenille oikeeseen suuntaan potkimisesta :)
Ja tosiaan kyllähän tuo ylivuotokeskeytys toimii ihn normaalisti. tosin tähän sitä en nyt tarvinnut.
http://www.youtube.com/watch?v=kLuiPiJ1di0 (http://www.youtube.com/watch?v=kLuiPiJ1di0)
Lainaus käyttäjältä: jussi - 30.05.11 - klo:23:14
Nonniin ;D ihmeiden aika ei ole ohi.sain sen näyttämään millejä kymppejä ja satkut pyöristetty lähimpään vitoseen tai nollaan. Nopealla mittauksellä näyttäis vieläpä oikeelta. toivotaan että on myös kun saa tarkemmin mitattua.
Nyt vaan hommaamaan 4rivinen3.3v näyttö ja pari encoder sensoria lisää.
Kiitokset Taurulle ja Kremmenille oikeeseen suuntaan potkimisesta :)
Ja tosiaan kyllähän tuo ylivuotokeskeytys toimii ihn normaalisti. tosin tähän sitä en nyt tarvinnut.
http://www.youtube.com/watch?v=kLuiPiJ1di0 (http://www.youtube.com/watch?v=kLuiPiJ1di0)
Okei, yläpeukkua! Kyllähän tuossa kaikki onnistumisen eväät olikin, mutta hienoa silti että pelittää. Käytitkö valmiita kirjastoja laskentaan, vai väänsitkö itse? Ihan mielenkiinnosta olisi hupaisaa tutustua tuohon koodiin, jollei se ole niin luottamuksellista ettei voi laittaa näkyviin.
No hyvä että minun esimerkki ei ajanut sinua harhapoluille kun kiireessä kirjoitatussa koodissa meni sekaisin looginen AND ja bitti AND -operaattorit.
Lopputuloksena taisi olla todella halpa ja toimiva mittalaite. Lieneekö 2400dpi enkoodereita saatavilla? Jos tuommoista joskus sorviin tai jyrsimeen suunnittelisi laittaa niin 5 satkua ei riitä (paitsi väljään koneeseen).
LainaaIhan mielenkiinnosta olisi hupaisaa tutustua tuohon koodiin
Hupaisaa se varmaan onkin :D . Joo ei tuossa mitään salaisuutta tai mullistavaa ole. Jos on niin on tullut vahingossa.
laitan tänne näkyville kun vielä testaan tuon Z akselin ,että toimii. Tuossahan on kovin vähän mun itse tekemää koodia mä kasaan vaan niinkun lego palikoita
pätkä sieltä ja toinen täältä.Mutta tulihan sitä taas jotain uutta opittua.
LainaaJos tuommoista joskus sorviin tai jyrsimeen suunnittelisi laittaa niin 5 satkua ei riitä
Eihän toi tietenkään kaupallisille pärjää, mutta hinta/laatusuhde on ihan hyvä. 3 akselin näyttö 5 satkun tarkkuudella noin 100€
hakkaa se noi sumoren mittarinkulat ainakin ;D ja laitoin tilaukseen 1200dpi kamat niillä saa sitten jo sen 2 satkun tarkkuuden.
Tässä olis nyt ihmeteltäväksi jos jotain kiinnostaa.
/* This file has been prepared for Doxygen automatic documentation generation. */
/*! \file *********************************************************************
*
* \brief The XMEGA Quadrature Decoder example source code.
*
* This file contains example code that demonstrate the quadrature
* decoder. It shows how to set up the event system and the Timer/Counter
* to decode the angle of rotation from a quadrature encoder.
*
* \par Application note:
* AVR1600: Using the XMEGA Quadrature Decoder
*****************************************************************************/
#include <stdio.h>
#include <util/delay.h>
#include "avr_compiler.h"
#include "qdec_driver.h"
#include "lcd.h"
bool dir = 0;
int TIMER_valuex = 0;
int TIMER_valuey = 0;
int TIMER_valuez = 0;
uint16_t lineCount = 0 ;
uint8_t DIR;
/*
* Hardware setup:X
* - PC0 - QDPH0
* - PC1 - QDPH90
* - PC2 - QDINDX
* Hardware setup:Y
* - PD0 - QDPH0
* - PD1 - QDPH90
* - PD2 - QDINDX
* Hardware setup:Z
* - PE0 - QDPH0
* - PE1 - QDPH90
* - PE2 - QDINDX
*
* Peripherals used:
* - PORTD[2:0] signal input.
* - Event channel 0: quadrature signal.
* - Event channel 1: index signal.
* - TCC0: Quadrature counter.
*/
int main( void )
{
/* Setup PORTD with pin 0 as input for QDPH0, dont invert IO pins.
*
* Setup event channel 0, pin 0 on PORTD as input, don't enable index.
* if index used then state 00 is set as the index reset state.
*
* Setup TCC0 with Event channel 0 and lineCount.
*/
QDEC_Total_Setup(&PORTC, /*PORT_t * qPort*/ // Qdec laskureiden XYZ asetukset
0, /*uint8_t qPin*/
false, /*bool invIO*/
0, /*uint8_t qEvMux*/
EVSYS_CHMUX_PORTC_PIN0_gc, /*EVSYS_CHMUX_t qPinInput*/
false, /*bool useIndex*/
EVSYS_QDIRM_00_gc, /*EVSYS_QDIRM_t qIndexState*/
&TCC0, /*TC0_t * qTimer*/
TC_EVSEL_CH0_gc, /*TC_EVSEL_t qEventChannel*/
lineCount); /*uint8_t lineCount*/
QDEC_Total_Setup(&PORTD, /*PORT_t * qPort*/
0, /*uint8_t qPin*/
false, /*bool invIO*/
2, /*uint8_t qEvMux*/
EVSYS_CHMUX_PORTD_PIN0_gc, /*EVSYS_CHMUX_t qPinInput*/
false, /*bool useIndex*/
EVSYS_QDIRM_00_gc, /*EVSYS_QDIRM_t qIndexState*/
&TCD0, /*TC0_t * qTimer*/
TC_EVSEL_CH2_gc, /*TC_EVSEL_t qEventChannel*/
lineCount); /*uint8_t lineCount*/
QDEC_Total_Setup(&PORTE, /*PORT_t * qPort*/
0, /*uint8_t qPin*/
false, /*bool invIO*/
4, /*uint8_t qEvMux*/
EVSYS_CHMUX_PORTE_PIN0_gc, /*EVSYS_CHMUX_t qPinInput*/
false, /*bool useIndex*/
EVSYS_QDIRM_00_gc, /*EVSYS_QDIRM_t qIndexState*/
&TCE0, /*TC0_t * qTimer*/
TC_EVSEL_CH4_gc, /*TC_EVSEL_t qEventChannel*/
lineCount); /*uint8_t lineCount*/
long int murtox = 0;
unsigned int murto2x = 0;
long int long_T_valuex = 0;
int high_valuex = 0;
unsigned int low_valuex = 0;
long int murtoy = 0;
unsigned int murto2y = 0;
long int long_T_valuey = 0;
int high_valuey = 0;
unsigned int low_valuey = 0;
long int murtoz = 0;
unsigned int murto2z = 0;
long int long_T_valuez = 0;
int high_valuez = 0;
unsigned int low_valuez = 0;
lcd_init(LCD_DISP_ON);
lcd_clrscr();
while (1) {
TIMER_valuex=TCC0_CNT; //laskurimuuttujien päivitykset
TIMER_valuey=TCD0_CNT;
TIMER_valuez=TCE0_CNT;
//********************************************************************************************//
long_T_valuex = TIMER_valuex;
long_T_valuex = long_T_valuex * 2774; // kerroin 2774
lcd_gotoxy(3,0);
if (TIMER_valuex < 0)
{
lcd_putc('-');
long_T_valuex = -long_T_valuex;
}
else
lcd_putc('+');
low_valuex = long_T_valuex & 0xffff;
high_valuex = long_T_valuex >> 16; // oikealle shiftaus
murtox = low_valuex;
murtox = murtox*100;
murto2x = murtox >>16;
//********************************************************************************************//
long_T_valuey = TIMER_valuey;
long_T_valuey = long_T_valuey * 2774; // kerroin 2774
lcd_gotoxy(3,1);
if (TIMER_valuey < 0)
{
lcd_putc('-');
long_T_valuey = -long_T_valuey;
}
else
lcd_putc('+');
low_valuey = long_T_valuey & 0xffff;
high_valuey = long_T_valuey >> 16; // oikealle shiftaus
murtoy = low_valuey;
murtoy = murtoy*100;
murto2y = murtoy >>16;
//********************************************************************************************//
long_T_valuez = TIMER_valuez;
long_T_valuez = long_T_valuez * 2774; // kerroin 2774
lcd_gotoxy(3,2);
if (TIMER_valuez < 0)
{
lcd_putc('-');
long_T_valuez = -long_T_valuez;
}
else
lcd_putc('+');
low_valuez = long_T_valuez & 0xffff;
high_valuez = long_T_valuez >> 16; // oikealle shiftaus
murtoz = low_valuez;
murtoz = murtoz*100;
murto2z = murtoz >>16;
//********************************************************************************************//
lcd_gotoxy(0,0);
lcd_puts_P("X");
lcd_gotoxy(4,0);
PutNumber(high_valuex); //kokonaisluvun tulostus
lcd_putc(0x2e);
lcd_gotoxy(8,0);
PutNumber2(murto2x); //murto-osan tulostus
//********************************************************************************************//
lcd_gotoxy(0,1);
lcd_puts_P("Y");
lcd_gotoxy(4,1);
PutNumber(high_valuey); //kokonaisluvun tulostus
lcd_putc(0x2e);
lcd_gotoxy(8,1);
PutNumber2(murto2y); //murto-osan tulostus
//********************************************************************************************//
lcd_gotoxy(0,2);
lcd_puts_P("Z");
lcd_gotoxy(4,2);
PutNumber(high_valuez); //kokonaisluvun tulostus
lcd_putc(0x2e);
lcd_gotoxy(8,2);
PutNumber2(murto2z); //murto-osan tulostus
//********************************************************************************************//
_delay_ms(10);
lcd_clrscr();
DIR=QDEC_Get_Direction(&TCC0); //laskurin suunta C0 X
switch(DIR)
{
case 1:
lcd_gotoxy(14,0);
lcd_puts_P("->");
break;
case 0:
lcd_gotoxy(12,0);
lcd_puts_P("<- ");
break;
}
DIR=QDEC_Get_Direction(&TCD0); //laskurin suunta D0 Y
switch(DIR)
{
case 1:
lcd_gotoxy(14,1);
lcd_puts_P("->");
break;
case 0:
lcd_gotoxy(12,1);
lcd_puts_P("<- ");
break;
}
DIR=QDEC_Get_Direction(&TCE0); //laskurin suunta E0 Z
switch(DIR)
{
case 1:
lcd_gotoxy(14,2);
lcd_puts_P("->");
break;
case 0:
lcd_gotoxy(12,2);
lcd_puts_P("<- ");
break;
}
}
}
Vähän edistystä tähänkin rojektiin. Nyt näyttö pelaa ja näyttää kaikki 3 akselia
osat on kaikki. pitää vaan viimeistellä ja tiivistellä jotenkin nuo mittasauvat
Taitaa tämäkin valmistua. ensimmäinen encoderi kiinni koneessa. ja näyttää vieläpä oikein. :) Vielä vois koittaa tuota glcd:n kirjastoa tutkia jos sais tehtyä isommat fontit.
Jyrsin käytössä noi digitaalit on kyllä mahtavat. Nyt kun täälläkin on ollut puhetta noista sorvin digeistä ajattelin tehdä tuohon pikkusorviinkin nuo digit.
noissa "oikessa" kun on noita muistpaikkoja. onko niille mitään käyttöä jos ei ole pikavaihtoteriä??. ajattelin ,että pärjäis R/D vaihto ja mitatun lukeman syöttö 4x3 näppäinmatriisilla. ja tietysti nollausnapit
ni millaista tuo teippi on?
harkitsitko tämän toteutusta arduinolla ?
Kerran kävi mielessä etsata noita digitaalitönäreissä olevaa liuskaa (teipin alla piilossa), saisi sen pituisia kuin haluaisi. Rakenteeltaanhan se liuska on melko yksinkertainen. Ajattelin jollain pikku moottorilla enkooderin ohjaamana pyörittää nauhaa ja stanssata maskia... Jos ymmärsin tuon digitaalitönärin toiminnan oikein niin siinä mitataan kapasitiivisesti tiheämmällä kammalla tuota liuskaa ja saadaan ilmeisesti siniaaltoprofiililla lukemat näistä mittapään antureista, pienet poikkeamat suodattuu kun näistä aina yksi on kapasitiivisempi kuin muut ja lukemat keskiarvoistetaan. Tuossa saattaisi toimia jokin muukin rakenne kuin etsattu liuska, esim 1mm korkeita ja sopivan levyisiä paloja jos liimasi, vaihtelis materiaalia aina palikoitten välissä (alumiini/kupari ja muovi/lasikuitu) Joo, mulla on liikaa aikaa...
(http://i.imgur.com/tiRLL.jpg)
miksi suotta kapasitiivisesti mittaamaan?
tulostaa suoraan tarkalla tulostimella vaikka kalvolle tai muulle kestävälle matskulle tämmönen, laittaa 2 optista lukupäätä niin saadaan 4 bittiä mittadataa jota voi vertailla 2bit/2bit.
perus laserit tulostaa vähintään 600x600dpi (600 pistettä tuumalla) joten jos lukupää vain pystyy lukemaan vaikka yhtä pistettä niin mittatarkkuuden saa tulostamalla 0.001 tuumaa?
kunhan näin lauantai tärinöissä funtsailen ;D
a12
Tuo 600dpi encoderinauha on niin halpaa ettei paljon kannata ite tulostella. Noilla pääsee tosiaan "vaan" 4 satkun tarkkuuteen.
Digitönärin stripin syövyttäminen oli mullakin mielessä. en vaan keksinyt miten sen jaon mittais luotettavasti.Luultavasti se on joku piirilevyn suunitteluohjeman vakio mitta.
ja noista tönäreistä saa sarjadatan ulos.
Xmegaa käytän noihin, koska niissä on rautatasolla hoidettu tuo encoderin luku. Saattaa löytyä jo arduinoistakin tuota xmegaa
No niin pitihän sitä sitten alkaa jalostamaan :)
kuvan mukainen lukija ja 80 cm encoder nauha. Nyt on sitten satkun tarkkuus. Ja periaatteessa mittaan 999.99 asti mahdollinen, kun laittaa tuota nauhaa lisää toisen perään. sen jälkeen laskuri pyörähtää ympäri.Nyt vaan pitää alkaa kokeileen sarjadataa tuosta ottaan ulos xmegalle ja tulostaa isompaan näyttöön.
Eikä kestä leikkuunestettä.... ::)
No eihän sitä noin ole tarkoituskaan asentaa koteloinnistahan se kii on. sen voi vaikka valaa epoksiin kun noita nappeja ja näyttöä ei tarvi käyttää. ne voi vaikka irrottaa tuosta.
Muok. Tuo encoderinauha on lasikuitua ja kuparia ja lakka päällä ja voi senkin suojata niinkun tavallisen digitönärin.
Keskuudessamme taitaa olla valtaosa ihmisiä, joiden taidoilla ei synny tuollaisia diginäyttöjä joita "jussikin"tuossa esittelee. Itse on osaa mitään mutta haluaisin silti hyötyä tuollaisesta mahdollisuudesta että taitajat suuntaisivat potentiaalinsa hetkeksi tuollaisen "tee se itse" diginäyttölaitteen kehittämiseen. Olen katsellut käytettyjä laitteita mutta vähissä on ja ikivanhoista ei rohkene maksaa puolta uusien hinnoista. Kun uudetkin maksaa kiinanmalleinakin itse ulkomailta tilattuna aika paljon, niin heräsi ajatus kokeilla yhteisömme terävän pään voimavarojen yhdistämistä kehittääkseen halvan ja kuitenkin toimivan diginäytön. Toisessa jyrsinkoneessani (bridgeport) on näytöt kahdelle akselille mutta yleisjyrsinkone ja moposorvi huutavat näyttöjä. Olen jo tuhlannut varallisuutta kohtuuttomasti työkalujen ostoon. Ilman niitäkään ei lastua synny. En varsinaisesti ole köyhä mutta tulorajoitteinen eläkeläinen kuitenkin, joten tuollainen halpaversio kiinnostaisi.
Hommasitko jostain tuota irtoliuskaa? Tuo lukupää menee melko pieneen tilaan, siitä voi surutta poistaa näytön, nappulat ja patterin, syöttö sitten näytöstä. Jyrsii pienen alumiini latan ja epoksoi sinne, anturankin voinee päällystää ohuen ohuella hartsikeroksella.
LainaaTuo lukupää menee melko pieneen tilaan, siitä voi surutta poistaa näytön, nappulat ja patterin, syöttö sitten näytöstä. Jyrsii pienen alumiini latan ja epoksoi sinne, anturankin voinee päällystää ohuen ohuella hartsikeroksella
Lainasin tuon kun se on lähes ajatusten lukua :) noin sen juuri toteutan.
http://www.machine-dro.co.uk/ (http://www.machine-dro.co.uk/) Tuossa linkki mistä saa liuskaa ja lukupäätä. Eikä hinta huimaa 27€ rahteineen.Taaskaan ei voi kun ihmetellä kotimaista hinnoittelua. Tämä tuli lontoon pohjoispuolelta tampereelle noin 3€ postikuluilla. Verrokkina juuri laitoin pienemmän ja kevyemmän paketin helsinkiin itellalla 7.20€ Pakollinen avautuminen aiheesta.;D
Tuostä näytöstä tuli mieleeni,että varmaan helpoin tapa saada isompaa numeroa olisi laittaa 7 sekmentti näyttöjä.
Ei vaan viittis alkaa askarteleen.Eli tietääkö kukaan onko olemassa noita 7 sekmenttinäyttöjä missä olis ajuripiirit integroitu. pikainen googletus ei vielä tuottanut tulosta.
Mä tein parisen vuotta sitten piruuttani piirilevyjen valotuskoneen ajastimen Mega88:lla. Siihen tuli 4 melko isoa 7-segmenttinäyttöä ja niille skannaava driveri. Se olisi varmaan triviaali toteuttaa tuohon DRO-näytöksi kun kaikki lisäkomponentit saisi mahtumaan samalle kortille mihin nuo segmenttinäytöt asennetaan. Jos kiinnostaa niin piirikaavio liitteenä, siitä saa toimivaksi testatun toteutuksen. Jos digittejä tulee kovasti niin digittiajureina voi käyttää 8-bittisiä ULN:ia ja nidenkin ohjauksen voi tehdä sarjarekisterillä; ehkä säästyy I/O:ta, tai sitten ei...
P.S. Toisaalta tuosta olisi tosi helppo muokata ihan oma SPI, IIC tai TWI-liitettävä näyttömoduuli pienellä muokkauksella. Sille vielä ajurikirjasto niin elämä olisi helppoa :). Tuo breakout-boardi tuli jo melkein ratkaistua - pitäisköhän kiinnostua tästä seuraavaksi ::)
onnituisiko tuo luku arduinolla ja sitten näytöksi joko 4x20 rivinen lcd näyttö tahi tommonen 7segmenttinäyttö paketti
http://www.dealextreme.com/p/8x-digital-tube-8x-key-8x-double-color-led-module-81873
Kannattaa varmaan tehdä samalle levylle, kunkerran joutuu jokatapauksessa laittaan nuo siirtorekisterit ja driver piirin. Ajattelin lähinnä jos löytyis joku valmis tyyliin 44780 ohjain paketti mihin olis kirjastoja jo valmiina. Vähän jo kallistuin tuon aiemmin käyttämäni 128x64 glcd:n käyttöön koittais vaan muokata siihen isommat fontit. Toisaalta noi reilumman kokoiset näytöt olis parempia.
Kremmen onko tuosta mega88 loppunut i/o:t kesken vai onko tuon näppäinmatriisin ja ULN yhteiset pinnit jostain muusta syystä.
Olihan siinä I/O:kin kortilla, mutta jos katsot tarkkaan niin huomaat, että tuossa on 4 digittiä ja näppiksessä 4 riviä. Eli hoidin näytön ja näppiksen skannauksen yksillä ja samoilla signaaleilla. Näppiksen rivitieto on synkattu näytön skannaukseen ja inputeiksi otetaan saraketieto painetuista näppäimistä.
Voiskos tuon näippäimistön skannauksen koodin saada ihmeteltäväksi sitäkin tässä tarvitaan ainakin sorvia ajatellen.Tuon jyrsimen kanssa en ole keksiny käyttöö.
Toki, täytyy kaivaa se esiin; kyllä se täältä jostain löytyy. Vaikeahan se ei millään muotoa ole.
Hetken kesti mutta löytyihän se viimein.
Liitteenä koko roska, ei siinä timerissa olekaan kuin yksi pieni tiedosto.
Tuo on aikanaan melko ripeästi koodattu, joten I/O-portit ainakin on näköjään ihan rautanimillä, mutta eihän se varmaan sinua haittaa kun XMegassa on melkein samat portit.
Muutin päätteen .txt , laita takaisin .c jos meinaat kokeilla kääntämistä.
Lainaus käyttäjältä: pomit - 09.04.12 - klo:22:11
onnituisiko tuo luku arduinolla ja sitten näytöksi joko 4x20 rivinen lcd näyttö tahi tommonen 7segmenttinäyttö paketti
http://www.dealextreme.com/p/8x-digital-tube-8x-key-8x-double-color-led-module-81873
Eipä sitä voi estää onnistumasta, jos sen noin haluaisi tehdä.
Itse olen kyllä kiertänyt Dealextremen kapineet kaukaa. Ehkä ei pitäisi yleistää, ja voihan tuollainen melko puhtaasti digitaalinen vehje toimia hyvinkin, mutta. Ainakaan en suostu itse koskemaan tikullakaan mihinkään mikä tulee Dealextremeltä ja liippaa millään tavalla verkkojännitteitä tai sisältää elektrolyyttikonkkia missään kriittisessä paikassa. On jo monen kertaan nähty että Extremen tavara on pahinta mahdollista kiinankuraa jonka pääasiallinen ja ainoa etu on halpa hinta. Sillä halvalla hinnalla vaan on hintansa...
Sanottakoon nyt kuitenkin, ettei juuri tuo ehdottamasi näyttö vaikuta päällisin puolin mitenkään erityisen epäilyttävältä. Ja ainakaan tuohon hintaan sitä ei ole mahdollista Euroopan mantereella tuottaa enää tällä vuosituhannella :'(
Jos neljä numeroa riittää (epäilen) niin tuolla on valmiita palikoita. Näille tulee kyllä jo hintaa jos laittaa useamman ja vielä pitäisi olla pääprossu millä näitä ajaa.
http://www.sparkfun.com/products/9767 (http://www.sparkfun.com/products/9767)
Lienee helpompaa ja halvempaa tehdä kuten Kremmen ehdotti aivan alusta, pelkät segmentit ei tuolla paljoa maksa http://www.sparkfun.com/products/10931 (http://www.sparkfun.com/products/10931)
Minun ajatus oli täsmälleen sama kuin tuo Sparkfunin kapine. Ei sinänsä yllättävää, eihän tuossa konseptina mitään mullistavaa ole. Hardware-toteutus on triviaali ja varmaan vähemmälläkin raudalla pärjää kuin siinä minun timer-toteutuksessa, jossa ei ollut mitenkään minimoitu komponenttimääriä.
Mutta siis yhdellä prosessorilla saa niin monta digittiä kuin haluaa.
nojoo tulee itsekin tilattua muualta, sattui ensimmäisen eteen tuo dx vempain.
ebaystä tilaan lähinnä suoraan vaikka samaa kiinan kamaa ne on sielläkin :)
toimituskin on nopeampaa.
Lainaus käyttäjältä: Kremmen - 09.04.12 - klo:23:37
Eipä sitä voi estää onnistumasta, jos sen noin haluaisi tehdä.
Itse olen kyllä kiertänyt Dealextremen kapineet kaukaa. Ehkä ei pitäisi yleistää, ja voihan tuollainen melko puhtaasti digitaalinen vehje toimia hyvinkin, mutta. Ainakaan en suostu itse koskemaan tikullakaan mihinkään mikä tulee Dealextremeltä ja liippaa millään tavalla verkkojännitteitä tai sisältää elektrolyyttikonkkia missään kriittisessä paikassa. On jo monen kertaan nähty että Extremen tavara on pahinta mahdollista kiinankuraa jonka pääasiallinen ja ainoa etu on halpa hinta. Sillä halvalla hinnalla vaan on hintansa...
Sanottakoon nyt kuitenkin, ettei juuri tuo ehdottamasi näyttö vaikuta päällisin puolin mitenkään erityisen epäilyttävältä. Ja ainakaan tuohon hintaan sitä ei ole mahdollista Euroopan mantereella tuottaa enää tällä vuosituhannella :'(
Sen takia vastailin noinkin jyrkästi kun ihan taannoin oli toisaalla ruodintaa jostain Dealextremen verkkokäyttöisistä ledivaloista jotka oli päivänselviä murhakytkentöjä. Siellä jäi verkkojännitteiset piuhat käteen kun kerran taivutti, mistään ryömintäväleistä tai eristyslujuuksista ei ollut myöskään kannettu minkään valtakunnan huolta. Että ainoa joka nuo voisi hyväksyä on Sähköteurastuslaitos.
menee vähän offtopic,mutta olen välttänyt kaikkea verkkovirtalaitteita tuolta kiinan maalta.
palatakseni siihen arduinoon ni pongasin tämmösen
http://tronixstuff.wordpress.com/2012/04/09/arduino-and-tm1640-led-display-modules/
saisi vähän tarkkuutta :) mutta jos tuosta saisi pilkottua samaan näyttöön kaikki lukemat ?
Nyt alkaa digitaalit riittämään... ehkä liikaakin! Ei paha hinta tuolla jos katsoin oikein. Laittasin kyllä 3 tommosta ja rautasahalla poikki ylimäärät ;)
tämä voisi olla parempi jos saa ajettua yhdeltä arduinolta..
http://tronixstuff.wordpress.com/2012/03/11/arduino-and-tm1638-led-display-modules/
Joku tämmönen olisi sopiva, tuolta tuota ei vaan taida saada... http://robotics.org.za/index.php?route=product/product&product_id=224 (http://robotics.org.za/index.php?route=product/product&product_id=224)
Helpommalla taitaa päästä jos tämän joku tekisi kokonaan alusta, eli SPI väyläinen näyttö ja siihen ohjainprossu, näitä voisi sitten ketjutella tarpeen mukaan, sorvi/jyrsin jne...
Kyllä minä tuollaisen teen kun vaan speksit sovitaan :)
Mielellään näyttö saisi olla omalla ledi ajurilla (ei prossulla, näiden ohjelmoinnissa kun voi olla liikaa tuuskaamista asiaan vihkiintymättömille) http://datasheets.maxim-ic.com/en/ds/MAX7219-MAX7221.pdf (http://datasheets.maxim-ic.com/en/ds/MAX7219-MAX7221.pdf), mielellään desimaalipilkun ajo myöskin haluttuun paikkaan olis plussaa.
Tuo maximin piiri taitaa vaatia hieman ylimääräisiä komponentteja, ehkäpä näitä olisi joitain parempiakin.
Tuossa on mielenkiintosesti tuo ketjutus tehty, eli voisi olla hyvä jos liittimet osoittais ylös ja alas ja sitten näitä vain napsuttelis kasaan. http://www.sparkfun.com/products/10103 (http://www.sparkfun.com/products/10103) tuossa nuo liittimet on siis sivuilla.
Tuodaanpas vielä yksi ajatus voisko näitä näyttöjä ketjuttaa niin,että kaikille esim. kolmelle näytölle olis samat pinnit muuten,mutta enable pinnillä vuoroteltais mikä näyttö näyttais vuorollaan
http://www.ebay.com/itm/8-1-0801-Character-LCD-Module-Display-Screen-LCM-/200659768960?pt=LH_DefaultDomain_0&hash=item2eb8411680 (http://www.ebay.com/itm/8-1-0801-Character-LCD-Module-Display-Screen-LCM-/200659768960?pt=LH_DefaultDomain_0&hash=item2eb8411680)
Voihan noitakin ketjutellakytkeä rinnan, tuppaavat vain olemaan pienehköjä, mutta se on sitten makuasia.
Itellä olis mielessä seitesegmentit erillisajureilla ja samantapainen pieni lattana prossulevy. Näihinhän saisi sitten reikien keskitykset sun muut hilavitkutinajotkin tehtyä, valitsee vain tuon prossun semmoseksi että IO:t riittää nappuloille ja inputeille. Vähän kuin mekanosarjat, jos ei tarvi niin jättää pois levysiä. Inputitkin vois olla omalla levyllä silloin.
siinä tm1638 piirillä olevassa olisi ollut napit valmiina...
näyttää epeistä löytyvän noita 16x2 lcd shieldejä vaikka kuinka muttei isompia, siis valmiina.
mutta tämmönen, http://www.ebay.com/itm/TFT-3-2-320-240-With-Touch-Shield-Arduino-Compatible-/270655252530?pt=LH_DefaultDomain_0&hash=item3f044f6832
menee jo kyllä vähän hifistelyksi paskasilla nakeilla :D
tai ilman koskettelua
http://www.ebay.com/itm/Serial-Parallel-128x64-Dots-Graphic-LCD-Display-for-Arduino-AVR-PIC-White-Blue-/370600970849?pt=LH_DefaultDomain_0&hash=item56498a0a61
Jos oikein isoa näyttöä tarvii niin pitäs tehä USB väylään tuo tönärinluku ja puuceelle näyttöohjelma... ;D, toisaalta noita SVGA ajureitakin löytyy jo prossun ohjaamana niin ei tarvisi kuin monitorin
Tuota 128x64 näyttöä käytin aiemmassa DRO:ssa ne halpoja ja helppoja käyttää vakiokirjastoilla, mutta merkin korkeus on vain noin 3 milliä. jos muokkais sitä kirjastoa niin siltikin 3 akselin näyttöön olis varmaan noin 8 mm merkin korkeus maksimi. kyllä tollakin pärjää mutta vähän kaipais isompaa.
Tuossa linkkaamassani näytössä olis 12mm korkeat merkit. mikä ei suuri ole lyllä sekään. minkähän kokoisia noi "oikeet" DRO näytöt on?
Laitoin omaan koneeseen halvat iGaging DRO:t.
https://picasaweb.google.com/114867436470447580998/SumoreSP2217III# (https://picasaweb.google.com/114867436470447580998/SumoreSP2217III#)
Mielessä kävi tehdä punaisista 7-segmentti näytöistä parempi näyttö. Noissahan on suunnilleen vakio signaali kaapelissa. Vaikka liitin on mini-usb niin signaali on ihan muuta.
Täältä löytyy hyvää tietoa:
http://www.shumatech.com/support/chinese_scales.htm (http://www.shumatech.com/support/chinese_scales.htm)
Pitää katsoa CNC modauksen valmistuttua että jätänkö DRO:t paikalleen vai myynkö pois.
Mutta säikeeseen liittyen noista iGaging DRO:sta on halpa käyttää lukijaa ja kiskoa ja jos haluaa DIY osuutta mukaan niin tekee hienomman ja isomman näytön.
kyllä ne isompia pitäisi olla kuin 3mm ???
se pc softakaan ei hullumpi idea olisi kun se jo on tuolla pajassa, pitäisi vaan saada softa linuxille ja mielellään halvalla se kytkentä.
ehkä ne halvat digitönärit riittää toistaiseksi pikakiinnitteisenä tuossa omassa sorvi/jyrsin yhdistelmässä..
edit: näyttää noita löytyvän valmiina kun vaan googlailee "arduino chinese digital caliper"
valmis paketti :)
http://www.instructables.com/id/Reading-Digital-Callipers-with-an-Arduino-USB/?ALLSTEPS
edit2: jatketaan tätä hurjastelua jopa iphonesta saa lukijan noilla kiinan tönäreillä
http://www.msh-tools.com/DRO/micro.html
Lainaus käyttäjältä: pomit - 11.04.12 - klo:12:38
siinä tm1638 piirillä olevassa olisi ollut napit valmiina...
näyttää epeistä löytyvän noita 16x2 lcd shieldejä vaikka kuinka muttei isompia, siis valmiina.
mutta tämmönen, http://www.ebay.com/itm/TFT-3-2-320-240-With-Touch-Shield-Arduino-Compatible-/270655252530?pt=LH_DefaultDomain_0&hash=item3f044f6832
menee jo kyllä vähän hifistelyksi paskasilla nakeilla :D
tai ilman koskettelua
http://www.ebay.com/itm/Serial-Parallel-128x64-Dots-Graphic-LCD-Display-for-Arduino-AVR-PIC-White-Blue-/370600970849?pt=LH_DefaultDomain_0&hash=item56498a0a61
Täällähän on lähtenyt keskustelu rivakasti käyntiin :)
Hommasin joku aika siten parikin tuon kaltaista kosketusnäyttöpaneelia, sillä erolla että näissä minun moduleissa on vielä i2c-linjan päässä flash-muistipiiri ja SD-kortinlukija. Noista rakentelee jo yhtä ja toista, joskin mikäli kaikki ominaisuudet haluaa tehokäyttöön niin joku Mega328 alkaa jäämään kevyeksi. Mutta onhan 8-bittisessä Mega-sarjassa vielä selvästi tilavampia piirejä, vaikka joku 256:nen jossa on jo muistia kivasti ja I/O-takin niin että ei lopu heti kesken. Hinnat ei päätä huimaa silleen että niillä nyt olisi oleellista vaikutusta.
Itseä kiinnostaisi määritellä pienimuotoinen systeemi jossa olisi mittausyksiköitä jotka ottavat tietoa sisään jollain tavalla, ja muokkaavat niistä yhdenmukaistettuja sanomia input-väylään. Jossain tämän väylän varrella majailee master-laite joka työstää mittausdatan ja formatoi siitä tavalla ja toisella näytettävää / toimeenpantavaa dataa. Tuo työstetty data sitten tuupataan output-väylään jonka varrella ovat näyttö / toimiyksiköt.
Käytännössä input- ja output-väylät voivat olla yksi ja sama niin, että jokin väylään liittyvä laite on master joka toimii kapellimestarina ja muut tekevät työtä käskettyä. Minimitoteutus voisi olla kahden yksikön systeemi jossa masteriin on integroitu näyttö, ja mittausyksikkö on orja. Tämmöinen systeemi natsaisi paitsi nyt keskusteltuihin DRO- ja kierrosluvun mittaussovelluksiin, niin myös siihen minun joku aika sitten ruotimaani omaan kuormamittaritarpeeseen. Ja siis yksittäiset laitteet tässä sovelluksessa ei tarvii olla kummoisia, että hintaa ei tämmöiselle välttämättä kauheasti kerry. (Säästämisen vuoksihan autoissakin on siirrytty väyläpohjaisiin toimilaitteisiin kun ne tulee halvemmiksi).
Tähän minisystemiin voisi aika suoraviivaisesti määritellä uusia hardware-yksiköitä aina tarpeen mukaan. Mitä taas ohjelmistoon tulee, niin minä voin kyllä kirjoittaakaikkien yksikkötyyppien perustoteutukset niin, että tiedon siirto väylässä ja kaikki siihen liityvät kuviot tulee systeemissä valmiina eikä niihin tarvitse puuttua. Yleisimmät mittaustyypit kuten aika, taajuus, jännite jne jne hoidetaan kirjastoilla jotka tarvitsee vain alustaa ja käyttää. Samoin väyläsanomien formatointi ja liikenteen ohjaus on syytä hoitaa kirjastoilla jotka vain otetaan mukaan sovelluksen. Mikäli väyläksi valittaisi i2c joka on oma suosikkini, niin sanomien rakenteelle ja liikennöivien asemien määrälle on hyvin vähän rajoituksia. Lisäksi AVR-prosessorit tukevat tuota liikennöintiä varsin mukavasti. Kun Atmelin työkalut on vielä ilmaisia niin tähän systeemiin pystyy kehittämään varsin juoheasti toimivan frameworkin kun vähän näkee vaivaa (ja sehän se on harrastusten suola).
Voin vaikka iltasella piirtää pientä kuvanpätkää tästä ajatuksesta niin se ehkä aukeaa paremmin.
Minä rakentelin halpojen digitönereiden ympärille pari vuotta sitten YADRO DRO-systeemin (http://www.yadro.de/). Nimi on osuvasti Yet Another DRO.Toiminut erinomaisesti, näyttö on varmasti riittävän kokoinen (n 50mm korkeat numerot) ja tarvittaessa tehtävissä omia uusia toimintoja. Nyt löytyy keskitykset, pultinreiät ympyrän kaarelle yms.
Tuosta voi ottaa vinkkiä ja tehdä vielä paremman toteutuksen.
Anteeksi kun innostin yhteisömme luovaa heikkovirtaosaajaporukkaa tuohon DRO-hullutukseen, köyhyyttäni. Tuo taurun idea, on siinäkin järkeä mutta kauhistuttaa kustannukset ja investoinnit ylimääräiseen läppäriin. Rouva ei anna omaansa ja omaa pöytäkonetta ei jaksa raahata verstaaseen. Kyllä ihan itsellinen halpakin laite viehättäisi.
TH
Tossa on aika mielenkiintoinen kokeilu...jalostamalla ehkä tarkaksikin ??
http://www.lindsayengraving.com/other_interests/dro.html
Henk. koht. En välitä PC:n kanssa kikkailla näissä.Minusta nämä kontrollerit on sitä varten.
PC on ylimääräinen härpätin, mutta tässä tapauksessa minun kannalta helpoin vaihtoehto. Myös edullinen koska tähän riittää mikä tahansa vanha kone mihin asentuu MS-DOS tai joku sen klooni.
tosta ajattelin itse lähteä liikkeelle...
http://www.poscope.com/pokeys56e
Tietsika on halpa nykyään:http://www.raspberrypi.org/ (http://www.raspberrypi.org/)
No eipä ollut kallis. Eipä silti Giganttikaan noita tuolla hinnalla luovuta. Toisaalta kauhistuttaa laittaa niinkin jaloa laitetta kuin tietokone/läppäri tekeen jotakin noin yksinkertaista hommaa. No, kyllä minäkin annan nyt tosi yksinkertaista purtavaa läppärille. Jos en vetoaisi köyhyyteeni enkä tulorajoitteisuuteeni, niin kyllä nuukuus on yksi hyvistä ominaisuuksistani. En minä siistä kärsi mutta vaimo kyllä joskus ehkä häpeää, ison talon tytär.
TH
eipä noi käytetyt cruzillakaan paljoo maksa...
http://www.cruzbroker.fi/k%C3%A4ytetty_windows_xp_p%C3%B6yt%C3%A4kone_pr_55040005.html
Vanhat PC:t ei tosiaan paljoa maksa ja verrattuna mikrokontrollereihin, niin onhan jopa kivikautisessa Penassakin ihan eri tavalla vääntöä kuin jossain 8-bittisessä pikkukivessä. Toisaalta PC:t on isoja möhkäleitä ja määrätyssä mielessä hirveän rajoittuneita. Kovin montaa PC:n rohjoa tuskin kukaan viitsii teipata koneen kylkeen hoitamaan kukin yhtä asiaa. Sitten maailmalta saa mitä ihmeellisimpiä ja hienompia rakennuspalikoita eri tarkoituksiin; niitähän on tähänkin keskusteluun jo linkattu kopallinen. Noista saa varmasti väsättyä yhtä ja toista, eikä ne varmasti ole huono ratkaisu kun vaan sopivan löytää.
Kuitenkin minulla on tästä omat ajatukseni ja ne tulee tässä. Jokin aika sitten kirjoittelin omiiin projektitarpeisiin tulevasta kuormitusmittarista jonka siis meinaan tehdä ainakin itselleni ja joka on kaikkien halukkaiden vapaasti käytettävissä. Osin tämänkin keskustelun pohjalta kehitin ajatusta pikkuisen eteenpäin ja lopputulos olisi kuvan kaltainen. Ei kannata pyörtyä, tuohon on kuvattu kaikki erilliset elementit mitä toteutuksessa voi olla; minimi kuitenkin on 1 palikka. Mutta jos avaan vähän tuota konseptia niin kuva varmaan hahmottuu.
(http://i4.aijaa.com/b/00995/9983797.jpg) (http://aijaa.com/009959983797)
Perusidea on siis kytkeä signaalien tms mittausyksikkö / yksiköitä ja datan näyttöyksikkö / yksiköitä toisiinsa yksinkertaisen 2-johtimisen Inter-IC -väylän eli I2C:n avulla. Tuon väylän on aikanaan speksannut Philips, nyk. NXP mikropiirien väliseen sarjamuotoiseen tiedonsiirtoon. I2C on täysin passiivinen väylä, sen ainoat komponentit ovat data-ja kellolinja sekä niiden ylösvetovastukset jossain väylän varrella. Tämä standardi on hyvin tunnettu ja laajasti tuettu, sille on olemassa massiivinen määrä dokumentaatiota ja väylää tukevia komponentteja. Eli siinä suhteessa aika varma valinta. Konseptikuvassa on näytetty myös mahdollinen joskaan ei missään nimessä pakollinen väylän jatkaminen erityisten väylävahvistimien avulla. Tällä on mahdollista kytkeä mukaan kaukana sijaitsevia yksiköitä, vähintään satojen metrien päässä, niin haluttaessa.
Jokainen väylään liittyvä yksikkö toteutetaan määrätyn peruskuvion mukaan:
- Vakiona yksikössä on I2C-väyläliityntäelektroniikka joka yksinkertaisimmillaan ei ole mitään - lähes kaikissa kaupasta saatavissa mikrokontrollereissa kun on I2C-liityntämahdollisuus suoraan.
- Ohjelmallisten toteutusten yhdenmukaistamiseksi ja ympäristön vakioimiseksi käytetään pientä reaaliaikakäyttistä. Varmin veto on FreeRTOS joka lienee maailman yleisin sulautettujen järjestelmien open source-käyttöjärjestelmä ja on portattu kymmenille eri prosessoreille ja kontrollereille.
- Kytkennät reaalimaailman ja sovelluksen välillä tehdään laiteajureilla jotka ovat FreeRTOS-käyttiksen taskeja. Nämä vakioidaan mahdollisimman pitkälle ainakin niin, että I2C-väylän toiminnasta ei tarvitse sovellustasolla juuri kiinnostua. Samoin valtaosa mittaus-, signaalinkäsittely- ja näyttölaiteprosessoinnista hoidetaan vakiokirjastojen ja ajuritaskien avulla.
- I2C on luonteeltaan master/slave-väylä jossa vähintään yksi väylämaster komentaa kytkettyjä orja-asemia. On periaatteesa samantekevää mikä väylämasterin rooli muuten on, se voi olla mittausasema, näyttöasema tai jos sovellukseen sisältyy erillinen signaalinkäsittely-yksikkö niin sitten luontevimmin ehkä se. Korostin tuossa kuvassa sen keltaisella pohjalla tämän merkiksi. I2C-standardi sinänsä sallii useita väylämastereita mikä avaa ihan mielenkiintoisia mahdollisuuksia kyhätä useita, yhteisiä resursseja hyödyntäviä sovelluksia samaan väylään.
Tuommoinen perusrakenne tarjoaa sovellukselle aika pitkälle vakioidun ympäristön. Kuten kuvasta näkyy niin jokaisella yksiköllä pyörii oma sovelluksensa joka on vapaasti koodattavissa yhdeksi tai useaksi käyttöjärjestelmän taskiksi. Jokaiselle sovellukselle on syytä toteuttaa muutamat hallinnointitoiminnot, kuten esimerkiksi mahdollisuus masterilta käsin selvittää yksikön toiminta jonkin sovittavan luokituksen mukaan. Kun tähän yhdistetään masterin sovellusrunkoon I2C-väylän automaattinen konfiguraatio (eli määrätyissä tilanteissa master selvittää automaattisesti väylään liitetyt laitteet ja mitä ne tuottavat/kuluttavat) niin saadaan aikaan itsekonfiguroituva systeemi.
Omasta kokemuksesta voin väittää että rakenne kannattaa toteuttaa tällä tavalla. Ne jotka haluavat itse koodata omat sovelluksensa pääsevät vauhtiin ihan eri tavalla kuin aloittamalla tyhjältä ruutupaperilta. Samoin kaikki edistysaskeleet mitä joku on keksinyt ovat kohtuullisen määrämuotoisessa ympäristössä levitettävissä aivan eri tavalla.
Tuossa konseptikuvasa ei nyt ollut sellaisa yksiköitä jotka ohjaisivat jotain toimilaitteita, mutta sillehän ei ole mitään estettä. On maailman yksinkertaisin asia toteuttaa joku relelähtöyksikkö tai moottorinohjausyksikkö tms noin konseptitasolla. Tuohon kun vielä kehittää USB- tai Ethernet-liitäntäyksikön niin PC:llä pääsee kiinni väylään ja voi tehdä mitä huvittaa. Tai laittaa 2,4 GHz WLAN-modulin ja kameran kiinni väylään niin voi kauko-ohjata työstintä yläkerran sohvalta käsin. Tai jotain, taivashan tässä on rajana, tai mielikuvitus.
Mutta siis tyvestä puuhun noustaan. Ihan yhdestä tai kahdesta simppelistä yksiköstä voi hyvin aloittaa ilman noita vaikeampia juttuja joita voi toteutella sitten jos/kun ne on ajankohtaisia. Jos vaikka tekisi kierrosluku- ja DRO-näytöt tälleen. Ja minä aion nyt joka tapauksessa tehdä omat kuormamittarini tällä arkkitehtuurilla.
Kommentit ja ehdotukset on tervetulleita kuten aina.
P.S. niin ja se jäi vielä mainitsematta, että sokerina pohjalla maailmastahan löytyy vaikka mitä valmiiksi I2C-väylään kytkettyjä toimintoja. Sehän on alunperin tarkoitettu piirien kytkemiseksi suoraan. Joten siis yksinkertaisin "tyhmä" yksikkö voi olla pelkkä A/D-muunnin tms ja silti se toimii juuri kuten kaikki muutkin ainakin väylätasolla.
Mainitsin edellisessä viestissäni FreeRTOS-käyttöjärjestelmän. Foorumin koodinikkareille vinkiksi niin siihen maksaa kyllä vaivan tutustua. Kenelle sulautetut reaaliaikakäyttöjärjestelmät eivät ole entuudesta tuttuja, niin FreeRTOS tarjoaa oivan kohteen, se kun on ilmainen ja hyvin dokumentoitu.
Löytyy siis tuolta: http://www.freertos.org/ (http://www.freertos.org/)
Yleisin vastaväite käyttikselle mikrokontrollerissa on, että sinne ei mahdu ja se ei jaksa pyörittää eikä sitä muutenkaan mihinkään tarvita. Kumpikaan ensimmäisistä ei kuitenkaan oikeasti pidä paikkaansa kuin ehkä äärimmäisissä minitapauksissa. Ne piirit joista täälläkin on keskusteltu jaksavat hyvin ajaa isompaa kokonaisuutta kuin äkkinäinen jaksaa koodata. Tarvitseminen taas on vähän sama kuin että ei autoa mihinkään tarvita kun jalankin pääsee. Joskus jalankulku voi olla ihan riittävä, mutta usein tarpeettoman hankalaa jos matka on pitkä.
Itse olen FreeRTOS:ia käyttänyt Mega32, 88, 168, 328, Xmega128A, AT32UC3A ja AT32UC3C -sarjan kontrollerien kanssa ja hyvin on pelannut. Se varmasti toisi tähänkin projektiin mukavasti rotia ja yhdenmukaisuutta oikein sovellettuna.
Lainaus käyttäjältä: pave - 11.04.12 - klo:20:31
Tietsika on halpa nykyään:http://www.raspberrypi.org/ (http://www.raspberrypi.org/)
Pitipä oikein laittaa yksi kappale B-versiota tilaukseen. Olisihan se komeaa jos LinuxCNC:n saisi pyörimään tuollaisella :).
Se ei vissiin onnistu kun se tarvii jonku real time kernelin, jos nyt olen oikein ymmärtänyt. Voin kyllä olla väärässäkin. :(
Joo tarvii kyllä, eli mukaan pitää saada RTAI-reaaliaikakernel. Vähintään tuosta tulee keskihaastava porttaussavotta ja nähtäväksi jää, miten koneliitynnän saa aikaan kun ei ole LPT-porttia eikä PCI-liittimiä johon saisi Mesan kortin tms. Eli voipi olla pitkä tie eikä se nyt tässä ollut pääasiallinen syy miksi tuon hommasin. Siitä voisi kuitenkin saada hyvän laskentayksikön erilaisiin hajautettuihin sovelluksiin ja se oli minulla ensimmäisenä mielessä. En äkkiseltään löytänyt Raspberryn sivuilta tarkkoja speksejä, mutta jos prosessori on ARM11 niin sillä tekee yhtä ja toista. Tuo keskusyksikköhän jaksaa esim videosignaalin käsittelyä oikein hyvin, joten kyllä sillä hoituu aika vaikea DSP:kin yhtä hyvin. Jos kortilla olevasta I/O:sta saisi kyhättyä I2C-rajapinnan niin siitä tulisi erinomainen signaalinkäsittelyalusta vaikka tässä säikeessä esittämääni mittausväyläsysteemiin. Sehän ei maksa juuri enempää kuin normi Arduino.
Nyt mä tarjoan kyllä itelleni olusen :P. Taas pientä edistystä lukemat näytöllä. jotain pientä matematiikassa näytölle tulostuksessa on , kun 327.68mm jälkeen pyörähtää ympäri. johdot on pakko tehdä häiriösuojatuista ja1.5->3.3v level translate myös parantaa. joutuu samplaan aika tavalla että pysyy lukema vakaana. Tästä on hyvä taas jatkaa.
Lainaus käyttäjältä: Kremmen - 13.04.12 - klo:22:23
Joo tarvii kyllä, eli mukaan pitää saada RTAI-reaaliaikakernel. Vähintään tuosta tulee keskihaastava porttaussavotta ja nähtäväksi jää, miten koneliitynnän saa aikaan kun ei ole LPT-porttia eikä PCI-liittimiä johon saisi Mesan kortin tms. Eli voipi olla pitkä tie eikä se nyt tässä ollut pääasiallinen syy miksi tuon hommasin. Siitä voisi kuitenkin saada hyvän laskentayksikön erilaisiin hajautettuihin sovelluksiin ja se oli minulla ensimmäisenä mielessä. En äkkiseltään löytänyt Raspberryn sivuilta tarkkoja speksejä, mutta jos prosessori on ARM11 niin sillä tekee yhtä ja toista. Tuo keskusyksikköhän jaksaa esim videosignaalin käsittelyä oikein hyvin, joten kyllä sillä hoituu aika vaikea DSP:kin yhtä hyvin. Jos kortilla olevasta I/O:sta saisi kyhättyä I2C-rajapinnan niin siitä tulisi erinomainen signaalinkäsittelyalusta vaikka tässä säikeessä esittämääni mittausväyläsysteemiin. Sehän ei maksa juuri enempää kuin normi Arduino.
Per.. Näitä sun juttuja kun lukee tekee mieli opettelemaan lisää. Vanhalta vaan loppuu aika kesken (ja muisti) :D
Lainaus käyttäjältä: jussi - 13.04.12 - klo:22:44
Nyt mä tarjoan kyllä itelleni olusen :P. Taas pientä edistystä lukemat näytöllä. jotain pientä matematiikassa näytölle tulostuksessa on , kun 327.68mm jälkeen pyörähtää ympäri. johdot on pakko tehdä häiriösuojatuista ja1.5->3.3v level translate myös parantaa. joutuu samplaan aika tavalla että pysyy lukema vakaana. Tästä on hyvä taas jatkaa.
Varma vinkki: sulla on jossain kohtaa koodia tuo lukema integer-tyyppisessä muutujassa jonka arvoalue on... tadaa... -32768 ... +32767. Kun liike vaan jatkuu yhteen suuntaan niin arvoalue ei riitä vaan muuttujan sisältö tulkitaan yhtäkkiä negatiiviseksi. Siispä etsimään ja kun löytyy niin muuta long integer-tyyppiseksi. Alkaa se arvoalue riittämään.
Ja taas tähän aiheeseen liittyvänä Trivial Pursuit-tyyppisenä anekdoottina allekirjoittanut lähetettiin 80-luvulla Viira Oy:lle palokuntahommiin. Silloisen työnantajan toteuttamalla paperikoneen viiran venytyspenkin säätösysteemeillä oli ikävä taipumus vetää poikki uusia, aivan käsittämättömän kalliita Valmetin kaksoisviirakoneeseen tulevia fosforipronssiviiroja. Siellä poikia vähän harmitti kun oli ensin kuukausi kudottu yhtä viiraa ja sitten se katkesi yhdessä hujauksessa. No siinä oli juuri tuo sama juttu. Viira meni poikki aina kun vetomitta ylitti maagisen 32,767 metriä ja kone riuhtaisi kuvitellen olevansa puolessa matkassa. Arvatkaapa onko tuo kakkosen potenssi syöpynyt mieleen ;D
Jos luvun arvoalue on aina positiivinen niin luvun voi esitellä unsigned tyyppisenä silloin tulee käyttöön koko muuttuja positiivisena.
Tuolle Rasperrylle ollaan kääntämässä tätä Amigan "vanhaa" käyttistä jota on tehty nyt kohta toistakymmentä vuotta opensourcena eli projekti nimeltään Aros, pyörii jo normi x86 pohjasilla ja jollain tapaa myös muillakin prossuilla. Käyttis on todella pieni ja kevyt mutta ei reaaliaikainen, olisi vinhaa koittaa kääntää LinuxCNC sille ja kattoa miten se Aroksen alla pyörii.
Lainaus käyttäjältä: jyrki.j.koivisto - 14.04.12 - klo:09:44
Jos luvun arvoalue on aina positiivinen niin luvun voi esitellä unsigned tyyppisenä silloin tulee käyttöön koko muuttuja positiivisena.
Totta, mutta jos tuossa DRO:ssa on lukeman nollausmahdollisuus niin silloin täytyy kyetä esittämääm myös negatiivisia lukemia. Liikehän voi jatkua nollauskohdasta kumpaan suuntaan tahansa.
Vaikka näin ei olisikaan niin etumerkitön integer venyy tässä tapauksessa 655 milliin mikä ei sekään vielä riitä jos mittasauvalla on pituutta vaikka metri. Pysyn siis aiemmassa suosituksessa :) (siksikin, että kyseessä on mitä ilmeisimmin bugi, joka pitää joka tapauksessa fiksata ajatuksen kanssa pois.)
Lainaa
Tuolle Rasperrylle ollaan kääntämässä tätä Amigan "vanhaa" käyttistä jota on tehty nyt kohta toistakymmentä vuotta opensourcena eli projekti nimeltään Aros, pyörii jo normi x86 pohjasilla ja jollain tapaa myös muillakin prossuilla. Käyttis on todella pieni ja kevyt mutta ei reaaliaikainen, olisi vinhaa koittaa kääntää LinuxCNC sille ja kattoa miten se Aroksen alla pyörii.
Reaaliaikaisuuden määrehän on lähinnä se, että käyttiksen vaste ulkomaailman tapahtumiin on deterministinen. Käytännössä tarkoittaa lähinnä hallittua keskeytysten latenssia ja keskeytysten suunnitelmallista kytkentää käyttöjärjestelmän skeduleriin ja taskien ajotilan käsittelyyn. Skedulerin pitää lisäksi vielä toimia myös siten deterministisesti, että korkeimman prioriteetin ajovalmis taski saa aina taatusti ajovuoron. Ei-reaaliaikakäyttiksillähän on taipumusta unohtua touhuamaan milloin mitäkin pitkiksi ajoiksi, vaikkapa työstämään jotain levy-I/O:ta sadoiksi millisekunneiksi huolimatta siitä, että servo on työntämässä piuhat punoittaen kelkkaa päin päätyä :)
Amiga jäi minulle aikanaan tuntemattomaksi, en ole sen kanssa koskaan leikkinyt. Siispä Aroksen joutuu selvittämään joku toinen. Itseä sen sijaan polttelisi portata FreeRTOS Raspberrylle. Jaa mutta siinähän on kivenä ARM11, ja FreeRTOS on portattu ainakin ARM7:lle ja 9:lle. Ehkä niistä saisi valmista mallia tai odottaa vähän niin joku innokas tekee porttauksen. FreeRTOS on toki erilainen kuin RTAI mutta molemmissa on perustasolla samat keskeytystenhallinta, signalointi ja taskien välinen kommunikointi. Varmaan koodia puukottamalla saisi toimimaan kohtuu hyvinkin. Olishan se kova juttu ajaa LinuxCNC:tä ilman PC:tä lähimaillakaan. Hmm...
Niin se vaan on prkl , >:( ,että peruskoulun matikka ei tähän nyt riitä. printf funktiolla tuo toimii ja tulostuu oikein vaikka 10 metriin asti.
Turhan raskas tapa vaan tähän ehkä. Kun pitää lukea 3 akselia yhtäaikaa. Tuo aiemmin käyttämäni tapa ei tässä toiminut eikä 10 muutakaan :(.
Kyllä se toimimaan saadaan ilman printf-funktiotakin, joka onkin raskas kuin synti.
Laitapa se (toimimaton) koodi näkysälle niin fiksataan se.
Perhana kun en tallentanut niitä mitkä kaikkein lähimmäksi toimi. nyt oon jo niin sekaisin noista ,etten pirullakaan muista miten sain toimimaan sen,tuohon 327 mm asti ja desimaalit. laitan nyt tuon viimeisimmän. Mä en ymmärrä miksi tuo kokonaisluku on tuossa alasanassa ja yläsana tyhjää täynnä ja desimaalit kadonnut johonkin. koodin lopussa on lcd tulostus funktiot millä olen tuossa aiemmassa tulostanut .Valtaosa koodista on taas netistä keräiltyä muuteltua sopivaksi. oma epäilykseni on ,että verrattuna tuohon aiempaan paikkatieto oli int16->int32 tässä se on valmiiksi int32 ja siitä muunnetaan int64 että näkyy myös negatiiviset luvut. Nyt kun sitä lähdetään muuttamaan kahdeksi int16 luvuksi tapahtuu jotain mitä en ymmärrä.
No, katsotaan eiköhän se selviä. En lupaa tänään enkä huomenna mitään lopullista viisautta kun Tukholman lento lähtee huomenna klo 6:50 (...kele) ja tulen takaisin vasta myöhään, pitää siis mennä ajoissa höyhensaarille. Mutta pakko tuon on lähipäivinä ratketa.
P.S. niin ja sullahan oli XMega prosessorina eikös niin? Siltä ainakin näyttää noiden alustusjuttujen perusteella.
No yksi aivan triviaali bugi löytyi helposti. Tämä nyt ainakin menee pieleen, mutta meneekö muuta niin en sitä vielä tarkemmin tutkinut. Tuo datan vastaanotto mittasauvalta saattaa myös olla... hmm... vähän hauras... No mutta asiaan.
Nämä kaksi ei toimi kuten oletat:
int GetHighWord(int intValue)
{
return (intValue & (0xFFFF << 16));
}
ja
int GetLowWord(int intValue)
{
return (intValue & 0x0000FFFF);
}
Oikea esittely jolla nämä toimii suoraan olisi:
int16_t GetHighWord(int32_t intValue)
{
return (intValue & (0xFFFF << 16));
}
ja
uint16_t GetLowWord(uint32_t intValue)
{
return (intValue & 0x0000FFFF);
}
Eli ei tarvitse muuttaa kuin tyyppien esittely. Kun olet mennyt käyttämään funktion argumentissa int-tyyppiä eli 16-bittistä muuttujaa niin kääntäjä suorittaa automaattisen tyyppimuunnoksen kutsussa käytetystä muuttujatyypistä (siis long integeristä) esittelyn mukaiseksi integer-tyypiksi. Tällöin ylimmät 16 bittiä lentävät bittiavaruuteen eivätkä koskaan edes saavu sisälle funktioon. Ihan tuo voi riittää siihen että alkaa toimimaan. Jollei, niin on meillä vielä paikkoja joita käydä läpi.
Joo xmega on käytössä ja kokeilin noita tyyppejä myös noin muttei toiminut. siinä kohtaa saattoi olla jotain muuta sitten lisäksi.
kääntäjä antaa muuten varoituksen ledt shiftingistä tuossa Gethighwordissa
Okei mutta niin ne pitää kyllä olla. Tuossa int-muodossa se ei voi toimia. Tosin harvoinkos sitä löytyy useita bugeja samasta koodista. Katsellaan lisää.
Muok: Melkein veikkaan että nuo näytön formatointirutiinit ei toimi tuolla tavalla. Koetan niitä vielä vähän tsekkailla.
Muok2: Itse asiassa GetHighWord pitää tehdä tämä:
return intValue >> 16;
Olisko sinulla linkki tuohon lcd-kirjastoion tai sen lähdekoodi, kun niitä on niin paljon, ettei voi tietää mikä lcd.h olisi se käyttämäsi. Ja lcd.c myös kiitos.
Nyt on pakko nostaa kädet pystyyn :( ei vaan onnistu . Piti oikein kokeilla edellistä projektia tallä lcdllä ja koodilla .se toimii tämä ei.
Tuossa edellisessäkin koodissa saattaa olla jotain väärin ja ylimääräistä jonka fiksu kääntäjä heittää kuikkaan. je se toimii vahingossa. ilman että ymmärrän mitä siinä tapahtuu. kuollaksenikaan en muista miten tuohon päädyin.
Toimiihan toi nyt ainakin sillä sprintf funktiolla jos muu ei auta xmega sitä tuntuis jotenkin pyörittävän
Laitoin lcd.c ja lcd.h tähän samaan tiedostoon.
Pitääpä koittaa vääntää iteki joku tommonen, ei vain ole Atmelin ohjelmointi systeemeitä kuin Amigassa (jota en ole buutannu käyntiin vuosiin) joten koitan Microchipin prossuilla kunhan ehin.
Tuosta jussin koodista löytyi pari aika helppoa lisäbugia. Nyt muunnos toimii teknisesti oikein, mutta voisin tehdä malliksi esimerkin kuinka itse toteuttaisin tuon laskennan. Se kun on varsin yleinen probleema jota joutuu ratkomaan tosituvasti ja sen voi minusta tehdä yksinkertaisemmin, yleispätevästi ja jopa ymmärrettävämminkin. Perästä kuuluu.
Hyvä homma. olin jo lähes valmis pilkkoon ton stripin kirveellä sentin paloiks. :) Olen koittanut laittaa talteen aina kun on löytynyt joku hyvä ja toimiva funktio. ikäänkuin oma kirjasto mistä voi liittää niinkuin legopalikoita.
Kremmeni viittasi kaiketi tuohon 10 luku järjestelmään muuttamiseen, sen voi tehdä paljonkin helpommin ja ilman jakolaskuja (jako ja kertolaskut on aina olleet ne hitaimmat käskyt suorittaa) Tuossa on itoa funktion sorsa http://www.raspberryginger.com/jbailey/minix/html/itoa_8c-source.html (http://www.raspberryginger.com/jbailey/minix/html/itoa_8c-source.html) tehtynä kuitenkin jakolaskulla.
Ascii hexaksi muunnos on vielä simppelimpi. Käyppäs vilkasees ASCII-taulukkoa niin idea on selviää. 2 kerto ja jakolaskut voi tehdä shiftaamalla bittejä ja se on vanha optimointi kikka jne.
Tässä laskentaesimerkki toteutettuna kiinteän pilkun esitystavalla, jota suosittelen käytettäväksi tällaisissa sovelluksissa.
Irroitin tästä koodista kaikki hämäävät käytännön jutut ja jätin vain laskentaosuuden ja näytön formatoinnin jäljelle.
Koodi on ajettu emulaattorissa ja toimii.
Tarvittavaan fixmath-kirjastoon löytyy linkki kommenteista, mutta voi sen laittaa tähänkin: http://code.google.com/p/libfixmath/downloads/detail?name=libfixmath_r64.zip&can=2&q= (http://code.google.com/p/libfixmath/downloads/detail?name=libfixmath_r64.zip&can=2&q=)
Tuolta siis tarvitaan fix16.h, fix16.c ja int64.h -tiedostot.
Jos koodi ei hahmotu niin kysykää vapaasti.
En sitten malttanut olla vielä etsimättä ratkaisua ,mikä sitten löytyi arduino foorumilta. siellä oli näytillä funktio mikä arduinossa tekee tuon homman.
Muokkasin siitä tähän sopivan ja nyt se toimii. Ero koodin koossa on 6190 bytes ->sprintf versio 6920bytes.
Pakko on kyllä kokeilla tuota Kremmenin esimerkkiäkin jos vaikka oppis samalla jotain.
Niin tässä olisi se etu, että on käytetty ensinnäkin vakiokirjastoa joka on testattu ja debugattu miljoonaan kertaan käyttäjäkunnan erilaisissa sovelluksissa. Toinen etu on, että numeerisen tiedon käsittely tapahtuu menetelmänmukaisesti, eli on olemassa standardi (siis tämä S15.16 kiinteän pilkun lukutyyppi) jota on helppo soveltaa eri tilanteissa, ja jonka toimivuuden ennakointi on varmalla pohjalla. Voit esim etukäteen tietää, tuleeko lukujen arvoalueet riittämään sovelluksen tarpeisiin jne.
Muok: Binäärin koko kun optimoitiin koon suhteen (-Os) oli 6074 tavua ja kun optimoitiin tappiin, eli suoritusajan maksimioptimointi (-O3) 7410 tavua.
Mielenkiintoista on ehkä havaita (kts oheinen linkkerikartta) että koodisegmentissä (.text osio tuossa kartassa) varsinaisen ohjelman koodi, eli segmentti DIY_DRO.o ulotuu vain välille 0x23a - 0x42c eli siinä on vain 498 tavua varsinaista sovellusta. Kaikki muu on kirjastoa joka ei toistu kun ohjelma kasvaa. Tässä muuten on linkattuna mukaan lcd-näytön koodi, joten koon puolesta tämä lienee melkein vertailukelpoinen muihin ratkaisuihin. Mittadatan sisäänluku tästä lähinnä puuttuu.
Piruuttani profiloin tuota esimerkkiä vielä lyhyesti ja pääohjelman suoritus alusta loppuun (siis siinähän ei ole mitään iteraatioita) tuolla esimerkkidatalla kestää 9891 kellojaksoa eli 32 MHz kellolla 309,09 us. Yksi kiinteän pilkun kertolasku kestää 2087 kelloa eli 65,22 us. Maksimioptimointi ei nopeuta näitä kuin mitättömät 5 kellojaksoa joten sen puolesta ei ole väliä mitä optimointia käyttää.
Maxim toimitti 3 kappaletta näyttö ajureita ja laitoin Elfalle tilauksen 6 kappaleesta neljän numeron segmenttinäyttöjä, ajattelin näistä alkaa väsäämään, jos taaskaan into riittää... ;D Oishan tuo mukava jos ei tarvisi kokoajan tönärillä olla mittaamassa, vaikkei nuo omat jyrsinnät niin millinpäälle olekkaan.
http://www.youtube.com/watch?v=qaXvLtR1FjE&feature=youtu.be (http://www.youtube.com/watch?v=qaXvLtR1FjE&feature=youtu.be)
Pientä päivitystä rojektiin. Päädyin 3.2" tft näyttöön kosketuspaneelilla.tuosta nyt voi olla montaa mieltä soveltuvuudesta tähän käyttöön,mutta kustannustehokas ratkaisu se on.Eikä tarvi erillisiä nappeja ja voi näyttää montaa eri asiaa eri sivuilla. Mulla ei ainakaan pikkusorvissa niin likaisia hommia tehdä ettei vois sormeilla näyttöä. vielä olisi ratkaistava näytön kalibroinnnin talletus eepromiin.ei ainakaan vielä löytyny sopivaa esimerkkiä. ja sitten tuo i2c väylä. se tähän nyt tulee vaikka alkuun pidin sitä liian vaikeana. tuosta 44pinnisestä xmegasta loppuu pinnit sen vuoksi se on nyt tehtävä noin .Ja tuleepahan tutustuttua tuohon i2c :henkin. toinen vaihtoehto olisi xmega128a1 100 pinniä. on vaan paljon vaikeempi ite juotella kiinni.sen vuoksi pitädyn tuossa xmega32a4:ssa. samalla pääsee eroon noista 1.5v data ja kello linjoista mitkä tuolta lukijalta tulee. täytyy sinne vaan tehdä pieni printti mihin tulee mega 328.Täytyy välillä tässä miettiä tuon lukijan/kooderistripin mekaanista rakennetta.
Hyvän näköinen tuli ! Tuossahan parasta on tuo muokkatavuus. Ja tuohon helppo lisätä muitakin ominaisuuksia.
Koulussa aikoinaan oli jyrsimen dro:ssa reikä piirin poraukseen laskuri. Sellaiset varmaan helppo lisäillä tähänkin.
Siinähän ilmoitettiin reikä piirin x y nolla, reikä reikä jako, kulma ja reikien lukumäärä. Muistaakseni.. Sitten näyttö näytti yksitelen jokaisen reiän paikan. Kuittaus ja siirto seuraavaan reikään.. Erittäin pätevä manukoneessa.
Toinen hyvä ominaisuus oli että dro:ssa oli useampi muisti paikka nolille. Eli eri nolla pisteita pystyi ottamaan ylös vaihtamaan näyttöä ja ottamaan taas eri nollat. Ja tarvittaessa palaamaan edellisiin mittoihin.
Ja niin tikku roikkumaan näytön viereen niin ei tarvi likaisilla sormilla näyttöä tökkiä.. ;)
Taas vähän edistystä. Kosketuspaneelin kalibrointi tallentuu eepromiin.Ja tuon reikäpiirin laskurin sain tehtyä.puutteet matemaattisissa kyvyissä aiheuttaa harmaita hiuksia ,mutta haluttu lopputulos siitä taas ihme kyllä tuli.Nuo lukualueiden koot ja muunnokset ja yhdistelyt ,kun niitä ei oikeen hahmota mitä missäkin kohtaa tapahtuu ,niin vaarana on sitten ylivuodot ja ihmeelliset bugit mitä on hankala ettiä. Syöttötiedoiksi valitsin ensimmäisen reiän kulma.Reikien lukumäärä. Ja kehän radius. yksitellen valitaan ja sitten siirrytään kohdeasemaan. Yhden pwm lähdönkin tuohon lisäsin. sitä voi periaatteessa käyttää mihin vaan.Nyt se hoitaa taustavaloa.Käyttöliittymää voi tosiaan muokata jyrsimelle ja sorville sopivaksi esim Z-akselin lukeman voi vaihtaa vaikka sorvin karan kierroslukumittariksi.Seuraavaksi sitten I2c väylän kimppuun josko sekin siitä aukeaisi.Matikkaa on tullu opiskeltua jo varmaan enemmän kun koulussa koskaan Trigonometria ei tainnu kuulua peruskoulun valikoimaan tai sit oli silloin muuta takemistä :)
http://youtu.be/CGz_ozdwwjk (http://youtu.be/CGz_ozdwwjk)
Ompa HIENO :)
Sorvi käyttöä ajatellen eikös z- akselia käytetä sorvin pituusliikkeen mittana ja x- akselia halkaisialle, eli y- olisi vapaa kierrosluvulle.
Toinen mikä tuli mieleen sorvi käytössä x- liikkeen lukema pitäis kaksinkertaistua todelliseen liikkeeseen nähden niin näyttö näyttäisi suoraan kappaleen halkaisiaa. Toisin sanoen kun terä liikkuu 1mm. halkaisia muuttuu 2mm.