AVR - Miértek hogyanok - Hobbielektronika.hu - online elektronikai magazin és fórum

(#)	kapu48 válasza killbill hozzászólására (»)	Nov 4, 2014		/

1000 Bocs!

Nálam az optimize(-O1) kiszedte a: x = ((x >> 4) & 0x0f) | ((x << 4) & 0xf0);
Sort belőle!

Ezt Ki érti???

A hozzászólás módosítva: Nov 4, 2014

(#)	jimmi12 válasza TavIR-AVR hozzászólására (»)	Nov 4, 2014		/

Helo,

Köszönöm a választ, mindazonáltal, mivel a hardver már megvan nem szeretném feladni a dolgot.
Amit szeretnék elérni az a következő, van négy bemenet és négy kimenet, ezeket szeretném vezérelni ill. lekérdezni soros port-on keresztül és mindezt attiny2313-al. A net-en sok hasonló programot találtam, de egyik sem akar működni. Az Arduino-t egyenlőre félretettem, letöltöttem egy CodeVisionAVR programot és van egy stk500 klónóm is hozzá. Tegnap találtam egy programot ami nagyon hasonló, azonban ha megpróbálom lefordítani több hibát is kapok. Az első az #include "avr/io.h", ha ezt átírom #include "io.h"-ra akkor már csak 3 hiba marad. Kettő a soros kommunikációval kapcsolataos, viszont a harmadik az 'int main()' függvénnyel. A hiba: the 'main' function must return 'void' type. Ezzel sajnos nemtudok mit ketdeni...

avr-io_UART.c

(#)	killbill válasza jimmi12 hozzászólására (»)	Nov 4, 2014		/

int main() helyett irjal void main()-t. Es ha van return utasitas a main fuggvenyben, akkor annak nem lehet erteke, azaz return; kell legyen.

A hozzászólás módosítva: Nov 4, 2014

(#)	jimmi12 válasza killbill hozzászólására (»)	Nov 4, 2014		/

Szia killbill,

Köszi a tippet ez úgytűnik bevált, már csak két hibám van:
- a eredeti program AT90S2313-ra íródott én viszont tiny2313-at használok, az első hiba, void UART_Init(uint32_t Baud) declaration syntax error, néztem az adatlapot és ami feltűnő, hogy a tiny-ben USART van, nem UART.
Erre van valami ötleted, hogy hogyan lehet korrigálni?

(#)	killbill válasza jimmi12 hozzászólására (»)	Nov 4, 2014		/

Hat, oszinten szolva en egyik tipust sem ismerem (pontosabban, valamikor 10..15 eve foglalkoztam AT90S2313-mal). A declaration syntax error programozasi dolog, nem sok koze magahoz a chip-hez. Talan hianyzik a

#include <stdint.h>

a programod legelejerol, nem tudom.
Az adatlap alapjan a UART es USART kozott a ket chip-ben eleg sok kulonbseg van. El kell olvasni, meg kell erteni. Aztan meg kell erteni az eredeti programot es atirni az ATTiny-re.

A hozzászólás módosítva: Nov 4, 2014

(#)	kapu48 válasza jimmi12 hozzászólására (»)	Nov 4, 2014		/

És helyesen: #include <avr/io.h>

(#)	Droot válasza killbill hozzászólására (»)	Nov 4, 2014		/

Nem voltak... Köszi!
Mostmár jobb a helyzet.
A gond annyi, hogy csak a Chip1-en látom kiírva és mintha ismételné, tehár kiírom hogy "Paratartalom:" és ennyit látok: "Alom: rt", olyan mintha azt hinné hogy csak a chip 1 működik. Illetve a betűk közötti távolság majdnem 1 betűnyi. (Nem ekkora volt rendes bekötés mellett.)

lcd.h

/*
* Copyright: Fabian Maximilian Thiele mailto:me@apetech.de
* Author: Fabian Maximilian Thiele
* Remarks: this Copyright must be included
* known Problems: none
* Version: 1.1
* Description: Graphic Library for KS0108- (and compatible) based LCDs
*
*/
#include <inttypes.h>
#include <avr/pgmspace.h>
#ifndef KS0108_H
#define KS0108_H
// Ports
#define LCD_CMD_PORT PORTC // Command Output Register
#define LCD_CMD_DIR DDRC // Data Direction Register for Command Port
#define LCD_CS_PORT PORTB
#define LCD_CS_DIR DDRB
#define LCD_DATA_IN PINA // Data Input Register
#define LCD_DATA_OUT PORTA // Data Output Register
#define LCD_DATA_DIR DDRA // Data Direction Register for Data Port
// Command Port Bits
#define D_I 5 // D/I Bit Number
#define R_W 6 // R/W Bit Number
#define EN 7 // EN Bit Number
#define CSEL1 0 // CS1 Bit Number
#define CSEL2 1 // CS2 Bit Number
// Chips
#define CHIP1 0x00
#define CHIP2 0x01
// Commands
#define LCD_ON 0xFC
#define LCD_OFF 0x7C
#define LCD_SET_ADD 0x02
#define LCD_SET_PAGE 0x1D
#define LCD_DISP_START 0x03
// Colors
#define BLACK 0xFF
#define WHITE 0x00
// Font Indices
#define FONT_LENGTH 0
#define FONT_FIXED_WIDTH 2
#define FONT_HEIGHT 3
#define FONT_FIRST_CHAR 4
#define FONT_CHAR_COUNT 5
#define FONT_WIDTH_TABLE 6
// Uncomment for slow drawing
// #define DEBUG
typedef struct {
uint8_t x;
uint8_t y;
uint8_t page;
} lcdCoord;
typedef uint8_t (*ks0108FontCallback)(const uint8_t*);
//
// Function Prototypes
//
uint8_t Reverse( uint8_t x );
// Graphic Functions
void ks0108DrawLine(uint8_t x1, uint8_t y1, uint8_t x2, uint8_t y2, uint8_t color);
void ks0108DrawRect(uint8_t x, uint8_t y, uint8_t width, uint8_t height, uint8_t color);
void ks0108DrawRoundRect(uint8_t x, uint8_t y, uint8_t width, uint8_t height, uint8_t radius, uint8_t color);
void ks0108FillRect(uint8_t x, uint8_t y, uint8_t width, uint8_t height, uint8_t color);
void ks0108InvertRect(uint8_t x, uint8_t y, uint8_t width, uint8_t height);
void ks0108SetInverted(uint8_t invert);
void ks0108SetDot(uint8_t x, uint8_t y, uint8_t color);
#define ks0108DrawVertLine(x, y, length, color) {ks0108FillRect(x, y, 0, length, color);}
#define ks0108DrawHoriLine(x, y, length, color) {ks0108FillRect(x, y, length, 0, color);}
#define ks0108DrawCircle(xCenter, yCenter, radius, color) {ks0108DrawRoundRect(xCenter-radius, yCenter-radius, 2*radius, 2*radius, radius, color);}
#define ks0108ClearScreen() {ks0108FillRect(0, 0, 127, 63, WHITE);}
// Font Functions
uint8_t ks0108ReadFontData(const uint8_t* ptr); //Standard Read Callback
void ks0108SelectFont(const char* font, ks0108FontCallback callback, uint8_t color);
int ks0108PutChar(char c);
void ks0108Puts(char* str);
void ks0108Puts_P(PGM_P str);
uint8_t ks0108CharWidth(char c);
uint16_t ks0108StringWidth(char* str);
uint16_t ks0108StringWidth_P(PGM_P str);
// Control Functions
void ks0108GotoXY(uint8_t x, uint8_t y);
void ks0108Init(uint8_t invert);
inline uint8_t ks0108ReadData(void);
void ks0108WriteCommand(uint8_t cmd, uint8_t chip);
void ks0108WriteData(uint8_t data);
#endif

lcd.c

#include <inttypes.h>
#include <avr/io.h>
#include <avr/pgmspace.h>
#include "ks0108.h"
lcdCoord ks0108Coord;
uint8_t ks0108Inverted=0;
ks0108FontCallback ks0108FontRead;
uint8_t ks0108FontColor;
const uint8_t* ks0108Font;
uint8_t Reverse( uint8_t x )
{
x = ((x >> 1) & 0x55) | ((x << 1) & 0xaa);
x = ((x >> 2) & 0x33) | ((x << 2) & 0xcc);
x = ((x >> 4) & 0x0f) | ((x << 4) & 0xf0);
return x;
}
uint8_t ks0108ReadFontData(const uint8_t* ptr) {
return pgm_read_byte(ptr);
}
void ks0108SelectFont(const char* font, ks0108FontCallback callback, uint8_t color) {
ks0108Font = font;
ks0108FontRead = callback;
ks0108FontColor = color;
}
int ks0108PutChar(char c) {
uint8_t width = 0;
uint8_t height = ks0108FontRead(ks0108Font+FONT_HEIGHT);
uint8_t bytes = (height+7)/8;
uint8_t firstChar = ks0108FontRead(ks0108Font+FONT_FIRST_CHAR);
uint8_t charCount = ks0108FontRead(ks0108Font+FONT_CHAR_COUNT);
uint16_t index = 0;
uint8_t x = ks0108Coord.x, y = ks0108Coord.y;
if(c < firstChar || c >= (firstChar+charCount)) {
return 1;
}
c-= firstChar;
// read width data, to get the index
for(uint8_t i=0; i<c; i++) {
index += ks0108FontRead(ks0108Font+FONT_WIDTH_TABLE+i);
}
index = index*bytes+charCount+FONT_WIDTH_TABLE;
width = ks0108FontRead(ks0108Font+FONT_WIDTH_TABLE+c);
// last but not least, draw the character
for(uint8_t i=0; i<bytes; i++) {
uint8_t page = i*width;
for(uint8_t j=0; j<width; j++) {
uint8_t data = ks0108FontRead(ks0108Font+index+page+j);
if(height < (i+1)*8) {
data >>= (i+1)*8-height;
}
if(ks0108FontColor == BLACK) {
ks0108WriteData(data);
} else {
ks0108WriteData(~data);
}
}
// 1px gap between chars
if(ks0108FontColor == BLACK) {
ks0108WriteData(0x00);
} else {
ks0108WriteData(0xFF);
}
ks0108GotoXY(x, ks0108Coord.y+8);
}
ks0108GotoXY(x+width+1, y);
return 0;
}
void ks0108Puts(char* str) {
int x = ks0108Coord.x;
while(*str != 0) {
if(*str == '\n') {
ks0108GotoXY(x, ks0108Coord.y+ks0108FontRead(ks0108Font+FONT_HEIGHT));
} else {
ks0108PutChar(*str);
}
str++;
}
}
uint8_t ks0108CharWidth(char c) {
uint8_t width = 0;
uint8_t firstChar = ks0108FontRead(ks0108Font+FONT_FIRST_CHAR);
uint8_t charCount = ks0108FontRead(ks0108Font+FONT_CHAR_COUNT);
// read width data
if(c >= firstChar && c < (firstChar+charCount)) {
c -= firstChar;
width = ks0108FontRead(ks0108Font+FONT_WIDTH_TABLE+c)+1;
}
return width;
}
uint16_t ks0108StringWidth(char* str) {
uint16_t width = 0;
while(*str != 0) {
width += ks0108CharWidth(*str++);
}
return width;
}
void ks0108GotoXY(uint8_t x, uint8_t y) {
uint8_t chip = CHIP1, cmd;
if(x > 127) x = 0; // ensure that coordinates are legal
if(y > 63) y = 0;
ks0108Coord.x = x; // save new coordinates
ks0108Coord.y = y;
ks0108Coord.page = y/8;
if(x >= 64) { // select the right chip
x -= 64;
chip = CHIP2;
}
cmd = LCD_SET_ADD | x;
ks0108WriteCommand(cmd, chip); // set x address on active chip
cmd = LCD_SET_PAGE | ks0108Coord.page; // set y address on both chips
ks0108WriteCommand(cmd, CHIP1);
ks0108WriteCommand(cmd, CHIP2);
}
void ks0108Init(uint8_t invert) {
ks0108Coord.x = 0;
ks0108Coord.y = 0;
ks0108Coord.page = 0;
ks0108Inverted = invert;
LCD_CMD_DIR = 0xFF; // command port is output
LCD_CS_DIR = (1<<CSEL1) | (1<<CSEL2);
ks0108WriteCommand(LCD_ON, CHIP1); // power on
ks0108WriteCommand(LCD_ON, CHIP2);
ks0108WriteCommand(LCD_DISP_START, CHIP1); // display start line = 0
ks0108WriteCommand(LCD_DISP_START, CHIP2);
ks0108ClearScreen(); // display clear
ks0108GotoXY(0,0);
}
inline void ks0108Enable(void) {
LCD_CMD_PORT |= 0x01 << EN; // EN high level width: min. 450ns
asm volatile("nop\n\t"
"nop\n\t"
"nop\n\t"
::);
LCD_CMD_PORT &= ~(0x01 << EN);
for(volatile uint8_t i=0; i<8; i++); // a little delay loop (faster than reading the busy flag)
}
void ks0108FillRect(uint8_t x, uint8_t y, uint8_t width, uint8_t height, uint8_t color) {
uint8_t mask, pageOffset, h, i, data;
height++;
pageOffset = y%8;
y -= pageOffset;
mask = 0xFF;
if(height < 8-pageOffset) {
mask >>= (8-height);
h = height;
} else {
h = 8-pageOffset;
}
mask <<= pageOffset;
ks0108GotoXY(x, y);
for(i=0; i<=width; i++) {
data = ks0108ReadData();
if(color == BLACK) {
data |= mask;
} else {
data &= ~mask;
}
ks0108WriteData(data);
}
while(h+8 <= height) {
h += 8;
y += 8;
ks0108GotoXY(x, y);
for(i=0; i<=width; i++) {
ks0108WriteData(color);
}
}
if(h < height) {
mask = ~(0xFF << (height-h));
ks0108GotoXY(x, y+8);
for(i=0; i<=width; i++) {
data = ks0108ReadData();
if(color == BLACK) {
data |= mask;
} else {
data &= ~mask;
}
ks0108WriteData(data);
}
}
}
uint8_t ks0108DoReadData(uint8_t first) {
uint8_t data;
volatile uint8_t i;
LCD_DATA_OUT = 0x00;
LCD_DATA_DIR = 0x00; // data port is input
if(ks0108Coord.x < 64) {
LCD_CS_PORT &= ~(0x01 << CSEL2); // deselect chip 2
LCD_CS_PORT |= 0x01 << CSEL1; // select chip 1
} else if(ks0108Coord.x >= 64) {
LCD_CS_PORT &= ~(0x01 << CSEL1); // deselect chip 1
LCD_CS_PORT |= 0x01 << CSEL2; // select chip 2
}
if(ks0108Coord.x == 64 && first) { // chip2 X-address = 0
ks0108WriteCommand(LCD_SET_ADD, CHIP2); // wuff wuff
}
LCD_CMD_PORT |= 0x01 << D_I; // D/I = 1
LCD_CMD_PORT |= 0x01 << R_W; // R/W = 1
LCD_CMD_PORT |= 0x01 << EN; // EN high level width: min. 450ns
asm volatile("nop\n\t"
"nop\n\t"
"nop\n\t"
::);
data = Reverse(LCD_DATA_IN); // read Data
LCD_CMD_PORT &= ~(0x01 << EN);
for(i=0; i<8; i++); // a little delay loop (faster than reading the busy flag)
LCD_DATA_DIR = 0xFF;
ks0108GotoXY(ks0108Coord.x, ks0108Coord.y);
if(ks0108Inverted)
data = ~data;
return data;
}
inline uint8_t ks0108ReadData(void) {
ks0108DoReadData(1); // dummy read
return ks0108DoReadData(0); // "real" read
}
void ks0108WriteCommand(uint8_t cmd, uint8_t chip) {
if(chip == CHIP1) {
LCD_CS_PORT &= ~(0x01 << CSEL2); // deselect chip 2
LCD_CS_PORT |= 0x01 << CSEL1; // select chip 1
} else if(chip == CHIP2) {
LCD_CS_PORT &= ~(0x01 << CSEL1); // deselect chip 1
LCD_CS_PORT |= 0x01 << CSEL2; // select chip 2
}
LCD_CMD_PORT &= ~(0x01 << D_I); // D/I = 0
LCD_CMD_PORT &= ~(0x01 << R_W); // R/W = 0
LCD_DATA_DIR = 0xFF; // data port is output
LCD_DATA_OUT = Reverse(cmd); // write command
ks0108Enable(); // enable
LCD_DATA_OUT = 0x00;
}
void ks0108WriteData(uint8_t data) {
uint8_t displayData, yOffset, cmdPort;
if(ks0108Coord.x >= 128)
return;
if(ks0108Coord.x < 64) {
LCD_CS_PORT &= ~(0x01 << CSEL2); // deselect chip 2
LCD_CS_PORT |= 0x01 << CSEL1; // select chip 1
} else if(ks0108Coord.x >= 64) {
LCD_CS_PORT &= ~(0x01 << CSEL1); // deselect chip 1
LCD_CS_PORT |= 0x01 << CSEL2; // select chip 2
}
if(ks0108Coord.x == 64) // chip2 X-address = 0
ks0108WriteCommand(LCD_SET_ADD, CHIP2);
LCD_CMD_PORT |= 0x01 << D_I; // D/I = 1
LCD_CMD_PORT &= ~(0x01 << R_W); // R/W = 0
LCD_DATA_DIR = 0xFF; // data port is output
yOffset = ks0108Coord.y%8;
if(yOffset != 0) {
// first page
cmdPort = LCD_CMD_PORT; // save command port
displayData = ks0108ReadData();
LCD_CMD_PORT = cmdPort; // restore command port
LCD_DATA_DIR = 0xFF; // data port is output
displayData |= data << yOffset;
if(ks0108Inverted)
displayData = ~displayData;
LCD_DATA_OUT = Reverse(displayData); // write data
ks0108Enable(); // enable
// second page
ks0108GotoXY(ks0108Coord.x, ks0108Coord.y+8);
displayData = ks0108ReadData();
LCD_CMD_PORT = cmdPort; // restore command port
LCD_DATA_DIR = 0xFF; // data port is output
displayData |= data >> (8-yOffset);
if(ks0108Inverted)
displayData = ~displayData;
LCD_DATA_OUT = Reverse(displayData); // write data
ks0108Enable(); // enable
ks0108GotoXY(ks0108Coord.x+1, ks0108Coord.y-8);
} else {
if(ks0108Inverted)
data = ~data;
LCD_DATA_OUT = Reverse(data); // write data
ks0108Enable(); // enable
ks0108Coord.x++;
}
LCD_DATA_OUT = 0x00;
}

(#)	rolandgw válasza jimmi12 hozzászólására (»)	Nov 4, 2014		/

Különbözik a két avr uart regiszter használata,elnevezése.Először is az AT-nál baud-ra UBRR regiszter van, a tiny-nél UBRRL (ez felel meg cím szerint az AT regiszternek)és UBRRH,valamint a control,status regiszterek is más néven futnak,de átírható,ha végignézed.

A hozzászólás módosítva: Nov 4, 2014

(#)	HA1DUQ hozzászólása	Nov 5, 2014		/

Sziasztok!

Vettem ezt a programozót

mi kell hozzá, hol találok egy kapcsolást rajzot amire fel tudom a atmel chippeket rakni és beprogramozni.
esetleg ez tud vissza felé is, ki tudom olvasni a chip programját

Kezdésnek mit ajánlanátok

(#)	Sick-Bastard hozzászólása	Nov 5, 2014		/

Üdv!

Elhoztam vidékre az AVR és ENC28J60-as tesztpanelem, de itt valahogy nem akar működni.
Először a tápegységre gyanakodtam, de ott úgy néz ki minden rendben van. Megvan a 12V 340mA terhelés mellett (izzóval teszteltem). A 3,3V-ot a LM1084 adja a fali 12Vos tápról. Igaz csak 3V-ot ad le.

Az AVR-nek saját kristálya van ami 16MHz-es, a div8 aktív. A VCC és GND lábainál közvetlen van egy 47µF tantál kondi.

Amit nem értek:
Ha nem kötöm be az ENC-t a panelbe akkor az AVR elindul. Alap esetben 2Mhz-en kezd, majd az első sor kóddal 16Mhz-re állítom (kikapcsolom a div8-at).
Ha bekötöm az ENC-t akkor nem hogy nem indul el a program, de a 2Mhz helyett is csak 1,7Mhz-et kapok, ami ráadásul nem stabil. 1,73-1,78 között ingadozik.

Otthon ugyanezt a táp felállást használtam.
Ami eltérés van:
- Nem kötöttem be a saját gyártású USBasp programozót. (innen semmi sem kap USBről áramot)
- Nem kötöttem be az USB-RS232 átalakítót. (csak az átalakító kap USBről áramot)

Mitől lehet az AVR órajele instabil?

(#)	Sick-Bastard válasza Sick-Bastard hozzászólására (»)	Nov 5, 2014		/

Tárgytalan... Mégis a táplálással van a baj. Elemről megy.

(#)	TavIR-AVR válasza HA1DUQ hozzászólására (»)	Nov 5, 2014		/

Kezdésnek? Dobd ki.
A fórumban is sokszor le lett írva: AVRASP egy nagy kalap kaki (árával arányosan használható).

Amivel _esetleg_ kezelhető: AVRDuDe keretrendszer, illetve amit a gyártója adott hozzá/leírásában szerepel.

(#)	TavIR-AVR válasza jimmi12 hozzászólására (»)	Nov 5, 2014		/

Tipp: Fordítsd le a 90S2313-ra, és a kapott HEX-t égesd be a T2313 chipbe.
Csereszabatosak

(#)	zsolt58 hozzászólása	Nov 6, 2014		/

Hello
Valaki segitene mert az AVR-okba meg egy kicsit kezdö vagyok!
Na az lenne a kérdésem, hogy ebben a cikkben azt irja, hogy kell a propeller kijelzö program de Jaedong azt irta, hogy az nélkül is meg lehet irni ezt a programot!
Na majd csak eljutok a kérdésig!
C-be vagy c++-ba kell programozni vele vagy másik nyelvbe?
És, hogy nekem LPT porton kellene valahogy Programoznom! evvel kapcsolatban is gondba vagyok!
És még,hogy valaki tudna-e evvel a programozásal kapcsolatos videot? vagy Luxus lenne nekem ha vallaki megirna nekem jo lenne!

A hozzászólás módosítva: Nov 6, 2014

(#)	TavIR-AVR válasza zsolt58 hozzászólására (»)	Nov 6, 2014		/

A jópofin kívül:
- tulajdonképpen mi a kérdésed?
- mit is szeretnél megtudni?

Szóval egy jópofi-magyar nyelvről egy műszaki-magyar nyelvre fordítást, ha lehetne....

(#)	zsolt58 hozzászólása	Nov 6, 2014		/

Idézet:
„C-be vagy c++-ba kell programozni vele vagy másik nyelvbe?
És, hogy nekem LPT porton kellene valahogy Programoznom! evvel kapcsolatban is gondba vagyok!
És még,hogy valaki tudna-e evvel a programozásal kapcsolatos videot? vagy Luxus lenne nekem ha vallaki megirna nekem jo lenne!”

Ez a kérdés!
De ez hozá tartozik!

Idézet:
„ebben a cikkben azt irja, hogy kell a propeller kijelzö program de Jaedong azt irta, hogy az nélkül is meg lehet irni ezt a programot!”

(#)	TavIR-AVR válasza zsolt58 hozzászólására (»)	Nov 6, 2014		/

Ok, én vagyok a helikopter. Nem értem....

A linkelt program C nyelven van.
"És, hogy nekem LPT porton kellene valahogy Programoznom! evvel kapcsolatban is gondba vagyok! "
Igen informatív a kérdés....

"És még,hogy valaki tudna-e evvel a programozásal kapcsolatos videot? vagy Luxus lenne nekem ha vallaki megirna nekem jo lenne!”"
Ebben hol a kérdés/kérdőjel?

(#)	zsolt58 válasza TavIR-AVR hozzászólására (»)	Nov 6, 2014		/

Akkor ujbol fogalmazok!
LPT porton kellene programozni azt a programot ami a cikkben van és a propeller kijelző program nélkül!
Remélem érthetö voltam!

(#)	Alpha6230 válasza zsolt58 hozzászólására (»)		Nov 6, 2014		/

Nem.
A mondataid felkiáltójellel végződnek, mely felkiáltást vagy parancsoló mondatot jelent. Tehát kérdésed nincs...
Az lpt port jelentése Linear Print Terminal. A linkelt tartalom kicsit kevés, hogy pontosan tudjuk mi nem világos számodra. Szerintem ez még nem a neked való projekt. Kezd egy sima nyomógombal és egy led-el, ha azt már tudod villogtatni egy általad választott avr-el, akkor fuss neki mégegyszer.

(#)	killbill válasza Alpha6230 hozzászólására (»)	Nov 6, 2014		/

Idézet:
„Az lpt port jelentése Linear Print Terminal.”

Szerintem a Line PrinTer roviditese. Sornyomtato, magyarul. Legalabbis 30 eve meg ezt jelentette.

(#)	Massawa hozzászólása	Nov 7, 2014		/

Egy kérdés.
6 nyomogombot kezelek egy IRQ rutinban. Ezek közül 1 gombnak egy bonyolultabb funkciot tervezek ( illetve megcsináltam, de nem müködik megbizhatoan). Szoval ennek a gombnak ( nevezzük F - nek). 2 funkcioja van. Az egyik - azonnali - feladat, hogy leállitja a futo programot ( motorokat). A másik funkcioja meg az lenne, hogy 3 üzemmod között váltson, nos ez utobbi egy kicsit bizonytalan, néha vált néha nem.
Ezért gondoltam, hogy az üzemmodváltást fel kéne javitani pl. ugy, hogy akkor váltana csak, ha az F gomb legalább 3 másodpercig nyomva van.
Nos ezt kéne kezelni.
Két ötletem van, az egyik hogy elinditok egy timert, s ha 3 sec alatt állandoan az F van beolvasva, akkor vált, vagy ugy, hogy elinditok egy számlálot, ami mondjuk 50-röl leszámolna és ha 50x egymás után az IRQ az F-t olvasná be, akkor történne az üzemmodváltás. Ha közben nem az F lenne beolvasva, akkor visszaállna a számlálo 50-re és várná ujra az F gombot.
Mi lenne egyszerübb, könnyebben kivitelezhetö?

A hozzászólás módosítva: Nov 7, 2014

(#)	zsolt58 válasza killbill hozzászólására (»)	Nov 7, 2014		/

Idézet:
„Szerintem a Line PrinTer roviditese. Sornyomtato, magyarul. Legalabbis 30 eve meg ezt jelentette.”

Igen én nyomtato portra gondoltam!
Akkor a kérdés:
Hogy lehet LPT porton programozni azt a programot ami a cikkben van és a propeller kijelző program nélkül?
És, hogy tudna-e valaki ajánlani egy videot vagy segitene megirni a programot?

A hozzászólás módosítva: Nov 7, 2014

(#)	killbill válasza zsolt58 hozzászólására (»)	Nov 7, 2014		/

Halvany fogalmam sincs rola, hogy hogyan lehet programozni. En csak arra reagaltam, hogy az LPT rovidites mit takar.

(#)	kapu48 válasza zsolt58 hozzászólására (»)	Nov 7, 2014		/

Programozás
Google: AVR+STK200
Bővebben: Link

Ezek közül valamelyiket megépíted.
ATMEL Studioval lefordítod a programodat, ez már tudtommal nem kezeli az STK200-ast.

Ezért a kapott *.hex állományt feltölteni pl.: régebbi Bascom IDE-vel tudod.

(#)	benjami válasza Massawa hozzászólására (»)	Nov 7, 2014		/

Egy gomb lenyomva tartásának idejét, csak akkor fogod megtudni, ha már felengedted. Ezért a gomb felengedését kell figyelni (ehhez el kell tárolnod a gomb előző állapotát is). Célszerű ezt timer interruptban megtenni. Mondjuk ha másodpercenként 30-szor olvasod be a gombokat, akkor azt kell számolni, hogy 90 beolvasásig le volt-e nyomva. Ehhez kell egy számláló amit mindig megnövelsz eggyel ha az F gombod le van nyomva (a túlcsordulását nem szabad megengedni). Ha a felengedéskor nagyobb ez a számláló mint 90 (3 másodperc), akkor hosszan nyomtad, ha nem akkor röviden. A felengedéskor ne felejtsd el a számlálót is lenullázni.

(#)	Massawa válasza benjami hozzászólására (»)	Nov 7, 2014		/

Kösz, de ez nem fog menni, mert a meglevö IRQ rutin csak azzal foglalkozik, hogy ciklusonként megmondja melyik gomb van megnyomva a 6 közül. Szoval ez a kiindulási alap. Ez a rutin már teljesen be van dolgozva a program minden részébe és minden müködik.
Ezen nem szeretnék változtatni.
Azaz az emlitett F gomb is müködik és minden üzemmodban van egy alapfunkcioja. Ezt meg szeretném tartani, már honapok ota irom a progit. Az egyik üzemmodban az alapfunkcio mellett elvben üzemmodot is váltania kellene, de nyilvánvaloan hogy itt konfliktusba kerül önmagával, mert elvégzi elsödleges feladatát és közben "maga alá vált", hiszen üzemmodot is vált. Ezt szeretném valahogy megoldani, hogy a másodlagos feladat ne keveredjen a fö feladattal. Ezért gondoltam, hogy az üzemmodváltásra csak akkor kerülne sor, ha a gomb hosszabb ideig van lenyomva. Azt sajnos ki kell zárnom, hogy közben felengedem. Esetleg még az jöhetne számitásba, hogy az emlegetett 3 sec alatt 2x kellene ugyanazt az F gombot lenyomni. Ez nem okozna konfliktust a fö feladatokban, mégis elkülönitené az üzemmodváltást. ( a progi ASM-ben van).

(#)	wbt válasza Massawa hozzászólására (»)	Nov 7, 2014		/

Szia!
Szerintem nem kell megvárni a gomb elengedését, ha az INT rutinban a számláló eléri a 90-et, bebillent egy "hosszannyomtak" bitet, ezt a főprogram figyeli és elmegy, ahova kell.

(#)	Massawa válasza wbt hozzászólására (»)	Nov 7, 2014		/

Én is valami ilyesmire gondolok, az INT/IRQ rutin kimenete a gomb értéke (1-6). Ha ide beraknák egy számlálot, ami minden ciklusban , ha nem változik a gomb (F=6) értéke 1-l növekedne, különben nullázodna - akkor a számlálo értéke + gomb értéke egyöntetüen adhatná az üzemmodválto parancsot. Na még alszok rá egyet s aztán nekifogok megirni a rutint.

(#)	Massawa válasza Massawa hozzászólására (»)	Nov 7, 2014		/

Most nézem ( már el is felejtettem) hogy az IRQ rutinban van egy prellmentesités is, ami a gombok prelljét szüri ( hasonlo elven, azaz egymásután 5x kell beolvasnia ugyanazt a gombot mielött továbbadja.). Ha ide beirnék egy másikat - csakis egy gombra hangolva és az 5 helyet mondjuk 50-t kéne számolnia, akkor lehet, hogy használhato is lenne.

(#)	benjami válasza Massawa hozzászólására (»)	Nov 7, 2014		/

Megjegyzem: ha timer megszakításban kérdezed le a gombokat 20-30 lekérdezés/másodperc sebességgel, nem kell foglalkoznod a prellmentesítéssel.
wbt: igazad van, ha a számláló eléri a 90-et az tényleg elég, nem kell megvárni azt hogy utána még fél óráig nyomjuk a gombot.

A hozzászólás módosítva: Nov 7, 2014