www.elektronik.si

[fx]

Pišem program, ki bi krmilil robota, za OS sem uporabil Linux, programski jezik C++ in sem naletel na težavo, program mi noče pošiljati podatkov na serijski port, program sem uporabil iz revije Monitor/julij-avgust 2004 Programer >> Programsko pošiljanje sporočil SMS str. 132-135.


Tukaj je koda :

/*** Datoteka: sms.c ***/
/*** Poslje SMS sporocilo na GSM modem Siemens TC35 ***/
/*** Sporocilo prebere iz datoteke sms_dat ***/

#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <termios.h>
#include <string.h>
#include <sys/times.h>
#include <errno.h>
#include <iostream>

#define MODEM_PORT "/dev/ttyS0" // Serijski port COM 1
#define BSIZE 100 // Velikost ukaza AT
#define SMSSIZE 160 // Velikost sporocila SMS
#define BAUDRATE B2400 // Hitrost prenosa

// Modemski AT ukazi
#define ECHO_OFF "ATE0"
#define NO_PDU "AT+CMGF=1"
// Telefonska stevilka na katero posiljamo SMS
#define SEND_SMS "AT+CMGS=\"+386xyzabcde\""

// Lokacija SMS datoteke sms_dat
#define SMSFILE "/windows/D/Linux/sms_test"

#define TRUE 1
#define FALSE 0

/*******************/
/*** Funkcije ***/
/******************/

// Odpre datoteko
FILE* open_file(const char *path, const char *mode)
{
FILE* fd = fopen(path, mode);
if (fd == NULL)
printf("Odpiranje porta %d %s\n", errno, strerror(errno));
return (fd);
}

// Vpisi podatke na serijski port
void write_modem(char *psz_buf, int fds)
{
// Poslani niz koncujemo z znakom \n (0x0d)
// za novo vrstico ter \r (0x0a) za zacetek vrstice
psz_buf[strlen(psz_buf)] = 0x0d;
psz_buf[strlen(psz_buf)+1] = 0x0a;

if (write(fds, psz_buf, strlen(psz_buf)) < 0)
fprintf(stderr, " Error writing... \n");
}

// Bere podatke s serijskega porta
void read_modem(int fds)
{
char sz_inbuf[BSIZE]; // Izhodni ukaz
memset(sz_inbuf, 0, BSIZE);

//usleep(500000); // Pocakaj trenutek
if (read(fds, sz_inbuf, sizeof(sz_inbuf)) < 0)
fprintf(stderr, "Napaka pri citanju... \n");
printf ("Sprejeti niz je:%s \n", sz_inbuf);
}

// Poslje ukaz AT
void send_AT_recv(char *psz_buf, int fds)
{
printf ("Posiljam ukaz < %s >. \n", psz_buf);
write_modem(psz_buf, fds);
read_modem(fds);
memset (psz_buf, 0, BSIZE);
}

/*********************/
/*** Konec funkcij ***/
/*********************/


/**********************/
/*** Glavni program ***/
/**********************/
int main()
{
int fd; // datotecni deskriptor za serijski port
int n_file_full = FALSE;
int nch = 0, ch = 0;

FILE *fds;
struct termios my_termios;
char sz_at_com[BSIZE]; // ukaz AT
char sz_sms[SMSSIZE]; // SMS

// Odpiranje serijskega porta
if ((fd = open(MODEM_PORT, O_RDWR | O_NOCTTY)))
printf("Odpiranje porta: %d %s\n", errno, strerror(errno));

// Odpiranje SMS datoteke
fds = open_file(SMSFILE, "r");

//*** Konfiguriranje modema ***

// Prebere obstojece parametre porta
tcgetattr(fd, &my_termios);

// Nastavi: baudno hitost, strojno krmiljenje, stevilo podatkovnih bitov
// Ignorira modemske statusne linije ter aktivira sprejemnik.
my_termios.c_cflag = BAUDRATE | CRTSCTS | CS8 | CLOCAL | CREAD;

// Izklopi odmev
my_termios.c_lflag &= ~ECHO;

// Ignorira paritetne napake in napake na okvirjih
my_termios.c_iflag = IGNPAR;

// Direktno posiljanje brez procesiranja (raw output)
my_termios.c_oflag = 0;

tcflush(fd, TCIFLUSH);
// Nastavi parametre porta
tcsetattr(fd, TCSAFLUSH, &my_termios);

// *** Konec konfiguracije modema ***


// Poslji SMS ko je datoteka SMSFILE polna
while (TRUE) {

if (n_file_full) {
fds = open_file(SMSFILE, "r");
n_file_full = FALSE;
}

// Prestej znake
while ((ch = getc(fds)) != EOF) nch++;

// Poslji SMS ce datoteka ni prazna
if (nch > TRUE) {

n_file_full = TRUE;

// Preberi vsebino datoteke od zacetka
memset (sz_sms, 0, 160);
fseek(fds, 0, SEEK_SET);
fread (sz_sms, 1, 160, fds);

// Ponastavi vrednosti
nch = ch = 0;

printf ("SMS vsebina: %s \n", sz_sms);

// Izbrisi datoteko s ponovnim odpiranje
fds = open_file(SMSFILE, "w");
fclose (fds);

// Poslji ATE0 - ugasni odmev (echo off)
sprintf (sz_at_com, ECHO_OFF);
send_AT_recv(sz_at_com, fd);

// Nastavi tekstovni nacin posiljanja
sprintf (sz_at_com, NO_PDU);
send_AT_recv(sz_at_com, fd);

// Poslji sporocilo SMS
sprintf (sz_at_com, SEND_SMS);
send_AT_recv(sz_at_com, fd);

// Dejansko posiljanje sporocila SMS
sprintf(sz_at_com, "%s %c ", sz_sms, 26);
send_AT_recv(sz_at_com, fd);
}
}
close (fd);

} // END

Ta progam mi noce poslati nic na serijski port, ce pa uporabim minicom (podobna zadeva kot HT v win) pa mi minicom posilja podatke na serijski port in tudi C ga sprejeme in izpise na LCD zaslon - tako da z kablom ni nič narobe. Torej ostane samo problem v programu, če bo kdo mi pomagal, sem za prenos podatkov uporabil 2400 8N1.

lp

"UNIX & C++ "

[frenki]

Namesto na port piši v neko datoteko in poglej, kaj dobiš noter.

Lp, Frenki

[fx]

Torej naj program okrog prensem ?

lp

"UNIX & C++"

[strobos]

Ja, ker je isto če pišeš na com ali pa v datoteko.

lp

[Umnik]

Ni mi jasno kaj bi ti okrog pr(e)našal ampak vseeno:
Frenki ti je predlagal, da namesto da pošiljaš podatke na serijski port pošlji te podatke v neko datoteko in pogladaš kaj ti program pravzaprav pošilja v mikrokontroler. Logično.
Kolikor sem na hitro pogledal program, ta "verjetno" pošilja tudi AT ukaze za inicializacijo modema na telefonu. C jih verjetno ne potrebuje, ne?
se pravi, da lahko vse kar se tiče pošiljanja AT ukazov odstraniš.
Sem pa pogledal samo "na hitro", tako da težko kaj pametnega predlagam...

Poglej si raje Code Project, tam boš 100% našel programsko kodo za pogovarjanje s serijskim portom.

[fx]

Umnik a si ti kaj podobnega že naredil ali pa kdo drug ?

lp

"UNIX & C++"

[strobos]

Pozdrav,

jaz sem že delal in uporabljal ampak te verjetno nebo zanimalo, ker je narejeno v visual basicu.

Lp

[fx]

To pa je res, sem pa jaz tudi delo z VB?

Kaj pa to :

/*
* include/linux/serial.h
*
* Copyright © 1992 by Theodore Ts'o.
*
* Redistribution of this file is permitted under the terms of the GNU
* Public License (GPL)
*/

#ifndef _LINUX_SERIAL_H
#define _LINUX_SERIAL_H

#ifdef __KERNEL__
#include <asm/page.h>

/*
* Counters of the input lines (CTS, DSR, RI, CD) interrupts
*/

struct async_icount {
__u32 cts, dsr, rng, dcd, tx, rx;
__u32 frame, parity, overrun, brk;
__u32 buf_overrun;
};

/*
* The size of the serial xmit buffer is 1 page, or 4096 bytes
*/
#define SERIAL_XMIT_SIZE PAGE_SIZE

#endif

struct serial_struct {
int type;
int line;
unsigned int port;
int irq;
int flags;
int xmit_fifo_size;
int custom_divisor;
int baud_base;
unsigned short close_delay;
char io_type;
char reserved_char[1];
int hub6;
unsigned short closing_wait; /* time to wait before closing */
unsigned short closing_wait2; /* no longer used... */
unsigned char *iomem_base;
unsigned short iomem_reg_shift;
unsigned int port_high;
unsigned long iomap_base; /* cookie passed into ioremap */
int reserved[1];
};

/*
* For the close wait times, 0 means wait forever for serial port to
* flush its output. 65535 means don't wait at all.
*/
#define ASYNC_CLOSING_WAIT_INF 0
#define ASYNC_CLOSING_WAIT_NONE 65535

/*
* These are the supported serial types.
*/
#define PORT_UNKNOWN 0
#define PORT_8250 1
#define PORT_16450 2
#define PORT_16550 3
#define PORT_16550A 4
#define PORT_CIRRUS 5 /* usurped by cyclades.c */
#define PORT_16650 6
#define PORT_16650V2 7
#define PORT_16750 8
#define PORT_STARTECH 9 /* usurped by cyclades.c */
#define PORT_16C950 10 /* Oxford Semiconductor */
#define PORT_16654 11
#define PORT_16850 12
#define PORT_RSA 13 /* RSA-DV II/S card */
#define PORT_MAX 13

#define SERIAL_IO_PORT 0
#define SERIAL_IO_HUB6 1
#define SERIAL_IO_MEM 2

struct serial_uart_config {
char *name;
int dfl_xmit_fifo_size;
int flags;
};

#define UART_CLEAR_FIFO 0x01
#define UART_USE_FIFO 0x02
#define UART_STARTECH 0x04
#define UART_NATSEMI 0x08

/*
* Definitions for async_struct (and serial_struct) flags field
*/
#define ASYNC_HUP_NOTIFY 0x0001 /* Notify getty on hangups and closes
on the callout port */
#define ASYNC_FOURPORT 0x0002 /* Set OU1, OUT2 per AST Fourport settings */
#define ASYNC_SAK 0x0004 /* Secure Attention Key (Orange book) */
#define ASYNC_SPLIT_TERMIOS 0x0008 /* Separate termios for dialin/callout */

#define ASYNC_SPD_MASK 0x1030
#define ASYNC_SPD_HI 0x0010 /* Use 56000 instead of 38400 bps */

#define ASYNC_SPD_VHI 0x0020 /* Use 115200 instead of 38400 bps */
#define ASYNC_SPD_CUST 0x0030 /* Use user-specified divisor */

#define ASYNC_SKIP_TEST 0x0040 /* Skip UART test during autoconfiguration */
#define ASYNC_AUTO_IRQ 0x0080 /* Do automatic IRQ during autoconfiguration */
#define ASYNC_SESSION_LOCKOUT 0x0100 /* Lock out cua opens based on session */
#define ASYNC_PGRP_LOCKOUT 0x0200 /* Lock out cua opens based on pgrp */
#define ASYNC_CALLOUT_NOHUP 0x0400 /* Don't do hangups for cua device */

#define ASYNC_HARDPPS_CD 0x0800 /* Call hardpps when CD goes high */

#define ASYNC_SPD_SHI 0x1000 /* Use 230400 instead of 38400 bps */
#define ASYNC_SPD_WARP 0x1010 /* Use 460800 instead of 38400 bps */

#define ASYNC_LOW_LATENCY 0x2000 /* Request low latency behaviour */

#define ASYNC_BUGGY_UART 0x4000 /* This is a buggy UART, skip some safety
* checks. Note: can be dangerous! */

#define ASYNC_AUTOPROBE 0x8000 /* Port was autoprobed by PCI or PNP code */

#define ASYNC_FLAGS 0x7FFF /* Possible legal async flags */
#define ASYNC_USR_MASK 0x3430 /* Legal flags that non-privileged
* users can set or reset */

/* Internal flags used only by kernel/chr_drv/serial.c */
#define ASYNC_INITIALIZED 0x80000000 /* Serial port was initialized */
#define ASYNC_CALLOUT_ACTIVE 0x40000000 /* Call out device is active */
#define ASYNC_NORMAL_ACTIVE 0x20000000 /* Normal device is active */
#define ASYNC_BOOT_AUTOCONF 0x10000000 /* Autoconfigure port on bootup */
#define ASYNC_CLOSING 0x08000000 /* Serial port is closing */
#define ASYNC_CTS_FLOW 0x04000000 /* Do CTS flow control */
#define ASYNC_CHECK_CD 0x02000000 /* i.e., CLOCAL */
#define ASYNC_SHARE_IRQ 0x01000000 /* for multifunction cards
--- no longer used */
#define ASYNC_CONS_FLOW 0x00800000 /* flow control for console */

#define ASYNC_BOOT_ONLYMCA 0x00400000 /* Probe only if MCA bus */
#define ASYNC_INTERNAL_FLAGS 0xFFC00000 /* Internal flags */

/*
* Multiport serial configuration structure --- external structure
*/
struct serial_multiport_struct {
int irq;
int port1;
unsigned char mask1, match1;
int port2;
unsigned char mask2, match2;
int port3;
unsigned char mask3, match3;
int port4;
unsigned char mask4, match4;
int port_monitor;
int reserved[32];
};

/*
* Serial input interrupt line counters -- external structure
* Four lines can interrupt: CTS, DSR, RI, DCD
*/
struct serial_icounter_struct {
int cts, dsr, rng, dcd;
int rx, tx;
int frame, overrun, parity, brk;
int buf_overrun;
int reserved[9];
};


#ifdef __KERNEL__
/* Export to allow PCMCIA to use this - Dave Hinds */
extern int register_serial(struct serial_struct *req);
extern void unregister_serial(int line);

/* Allow architectures to override entries in serial8250_ports[] at run time: */
struct uart_port; /* forward declaration */
extern int early_serial_setup(struct uart_port *port);

#endif /* __KERNEL__ */
#endif /* _LINUX_SERIAL_H */

Kaj ta koda naredi, koliko sem na hitro pogledal naj bi pošiljal podatke na serijski port - če se motim me popravite.

lp

"UNIX & C++"